diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 4256387e1209..8d89ec6d6043 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -2,3 +2,11 @@
 97c5ee99bc98dc475512e549b252b23a6e7e0997
 # Use builtin generics and PEP 604 for type annotations wherever possible (#13427)
 23ee1e7aff357e656e3102435ad0fe3b5074571e
+# Use variable annotations (#10723)
+f98f78216ba9d6ab68c8e69c19e9f3c7926c5efe
+# run pyupgrade (#12711)
+fc335cb16315964b923eb1927e3aad1516891c28
+# update black to 23.3.0 (#15059)
+4276308be01ea498d946a79554b4a10b1cf13ccb
+# Update black to 24.1.1 (#16847)
+8107e53158d83d30bb04d290ac10d8d3ccd344f8
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index 64a2e6494c1b..a88773308d5e 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"
diff --git a/.github/ISSUE_TEMPLATE/feature.md b/.github/ISSUE_TEMPLATE/feature.md
index 135bc2bd3b94..984e552e51b1 100644
--- a/.github/ISSUE_TEMPLATE/feature.md
+++ b/.github/ISSUE_TEMPLATE/feature.md
@@ -6,8 +6,8 @@ labels: "feature"
 
 **Feature**
 
-(A clear and concise description of your feature proposal.)
+<!-- Enter a clear and concise description of your feature proposal here. -->
 
 **Pitch**
 
-(Please explain why this feature should be implemented and how it would be used. Add examples, if applicable.)
+<!-- Please explain why this feature should be implemented and how it would be used. Add examples, if applicable. -->
diff --git a/.github/workflows/build_wheels.yml b/.github/workflows/build_wheels.yml
index da140375d603..dae4937d5081 100644
--- a/.github/workflows/build_wheels.yml
+++ b/.github/workflows/build_wheels.yml
@@ -5,15 +5,20 @@ on:
     branches: [main, master, 'release*']
     tags: ['*']
 
+permissions:
+  contents: read
+
 jobs:
   build-wheels:
     if: github.repository == 'python/mypy'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v5
         with:
-          python-version: '3.7'
+          python-version: '3.11'
       - name: Trigger script
         env:
           WHEELS_PUSH_TOKEN: ${{ secrets.WHEELS_PUSH_TOKEN }}
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 8851f7fbb0f3..3f945b84b7f0 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -8,25 +8,40 @@ on:
   pull_request:
     paths:
     - 'docs/**'
+    # We now have a docs check that fails if any error codes don't have documentation,
+    # so it's important to do the docs build on all PRs touching mypy/errorcodes.py
+    # in case somebody's adding a new error code without any docs
+    - 'mypy/errorcodes.py'
     - 'mypyc/doc/**'
     - '**/*.rst'
     - '**/*.md'
     - CREDITS
     - LICENSE
 
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
 jobs:
   docs:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     env:
       TOXENV: docs
       TOX_SKIP_MISSING_INTERPRETERS: False
+      VERIFY_MYPY_ERROR_CODES: 1
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v5
         with:
-          python-version: '3.7'
+          python-version: '3.12'
       - name: Install tox
-        run: pip install --upgrade 'setuptools!=50' tox==4.4.4
+        run: pip install tox==4.21.2
       - name: Setup tox environment
         run: tox run -e ${{ env.TOXENV }} --notest
       - name: Test
diff --git a/.github/workflows/mypy_primer.yml b/.github/workflows/mypy_primer.yml
index e7e4af1f07b7..ee868484751e 100644
--- a/.github/workflows/mypy_primer.yml
+++ b/.github/workflows/mypy_primer.yml
@@ -15,6 +15,9 @@ on:
     - 'mypy/test/**'
     - 'test-data/**'
 
+permissions:
+  contents: read
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
@@ -23,20 +26,20 @@ jobs:
   mypy_primer:
     name: Run mypy_primer
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
     strategy:
       matrix:
         shard-index: [0, 1, 2, 3, 4]
       fail-fast: false
+    timeout-minutes: 60
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           path: mypy_to_test
           fetch-depth: 0
-      - uses: actions/setup-python@v4
+          persist-credentials: false
+      - uses: actions/setup-python@v5
         with:
-          python-version: "3.10"
+          python-version: "3.13"
       - name: Install dependencies
         run: |
           python -m pip install -U pip
@@ -66,18 +69,33 @@ jobs:
             --output concise \
             | tee diff_${{ matrix.shard-index }}.txt
           ) || [ $? -eq 1 ]
-      - name: Upload mypy_primer diff
-        uses: actions/upload-artifact@v3
-        with:
-          name: mypy_primer_diffs
-          path: diff_${{ matrix.shard-index }}.txt
-      - if: ${{ matrix.shard-index }} == 0
+      - if: ${{ matrix.shard-index == 0 }}
         name: Save PR number
         run: |
           echo ${{ github.event.pull_request.number }} | tee pr_number.txt
-      - if: ${{ matrix.shard-index }} == 0
-        name: Upload PR number
-        uses: actions/upload-artifact@v3
+      - name: Upload mypy_primer diff + PR number
+        uses: actions/upload-artifact@v4
+        if: ${{ matrix.shard-index == 0 }}
+        with:
+          name: mypy_primer_diffs-${{ matrix.shard-index }}
+          path: |
+            diff_${{ matrix.shard-index }}.txt
+            pr_number.txt
+      - name: Upload mypy_primer diff
+        uses: actions/upload-artifact@v4
+        if: ${{ matrix.shard-index != 0 }}
+        with:
+          name: mypy_primer_diffs-${{ matrix.shard-index }}
+          path: diff_${{ matrix.shard-index }}.txt
+
+  join_artifacts:
+    name: Join artifacts
+    runs-on: ubuntu-latest
+    needs: [mypy_primer]
+    steps:
+      - name: Merge artifacts
+        uses: actions/upload-artifact/merge@v4
         with:
           name: mypy_primer_diffs
-          path: pr_number.txt
+          pattern: mypy_primer_diffs-*
+          delete-merged: true
diff --git a/.github/workflows/mypy_primer_comment.yml b/.github/workflows/mypy_primer_comment.yml
index 6e3bb590364f..21f1222a5b89 100644
--- a/.github/workflows/mypy_primer_comment.yml
+++ b/.github/workflows/mypy_primer_comment.yml
@@ -1,24 +1,25 @@
 name: Comment with mypy_primer diff
 
-on:
+on:  # zizmor: ignore[dangerous-triggers]
   workflow_run:
     workflows:
       - Run mypy_primer
     types:
       - completed
 
-permissions:
-  contents: read
-  pull-requests: write
+permissions: {}
 
 jobs:
   comment:
     name: Comment PR from mypy_primer
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
     if: ${{ github.event.workflow_run.conclusion == 'success' }}
     steps:
       - name: Download diffs
-        uses: actions/github-script@v6
+        uses: actions/github-script@v7
         with:
           script: |
             const fs = require('fs');
@@ -44,11 +45,11 @@ jobs:
 
       - name: Post comment
         id: post-comment
-        uses: actions/github-script@v6
+        uses: actions/github-script@v7
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
-            const MAX_CHARACTERS = 30000
+            const MAX_CHARACTERS = 50000
             const MAX_CHARACTERS_PER_PROJECT = MAX_CHARACTERS / 3
 
             const fs = require('fs')
diff --git a/.github/workflows/sync_typeshed.yml b/.github/workflows/sync_typeshed.yml
index 1db2e846f099..2d5361a5919c 100644
--- a/.github/workflows/sync_typeshed.yml
+++ b/.github/workflows/sync_typeshed.yml
@@ -5,22 +5,25 @@ on:
   schedule:
     - cron: "0 0 1,15 * *"
 
-permissions:
-  contents: write
-  pull-requests: write
+permissions: {}
 
 jobs:
   sync_typeshed:
     name: Sync typeshed
     if: github.repository == 'python/mypy'
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          persist-credentials: true  # needed to `git push` the PR branch
         # TODO: use whatever solution ends up working for
         # https://github.com/python/typeshed/issues/8434
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: "3.10"
       - name: git config
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 81587f3ca747..c42550431bb1 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -15,6 +15,9 @@ on:
     - CREDITS
     - LICENSE
 
+permissions:
+  contents: read
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
@@ -26,87 +29,90 @@ 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
-          python: '3.8'
-          arch: x64
-          os: ubuntu-latest
-          toxenv: py
-          tox_extra_args: "-n 2"
-        - name: Test suite with py39-ubuntu
+        # Make sure to run mypyc compiled unit tests for both
+        # the oldest and newest supported Python versions
+        - name: Test suite with py39-ubuntu, mypyc-compiled
           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'
-          arch: x64
-          os: ubuntu-latest
-          toxenv: py
-          tox_extra_args: "-n 2"
-          test_mypyc: true
-        - name: Test suite with py310-ubuntu, mypyc-compiled
-          python: '3.10'
-          arch: x64
-          os: ubuntu-latest
+          os: ubuntu-24.04-arm
           toxenv: py
-          tox_extra_args: "-n 2"
+          tox_extra_args: "-n 4"
           test_mypyc: true
+        - name: Test suite with py39-windows-64
+          python: '3.9'
+          os: windows-latest
+          toxenv: py39
+          tox_extra_args: "-n 4"
         - name: Test suite with py310-ubuntu
           python: '3.10'
-          arch: x64
-          os: ubuntu-latest
+          os: ubuntu-24.04-arm
           toxenv: py
-          tox_extra_args: "-n 2"
+          tox_extra_args: "-n 4"
         - name: Test suite with py311-ubuntu, mypyc-compiled
           python: '3.11'
-          arch: x64
-          os: ubuntu-latest
+          os: ubuntu-24.04-arm
           toxenv: py
-          tox_extra_args: "-n 2"
+          tox_extra_args: "-n 4"
           test_mypyc: true
-        - name: mypyc runtime tests with py37-macos
-          python: '3.7'
-          arch: x64
-          os: macos-latest
+        - name: Test suite with py312-ubuntu, mypyc-compiled
+          python: '3.12'
+          os: ubuntu-24.04-arm
           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'
-          arch: x64
-          os: ubuntu-latest
+          tox_extra_args: "-n 4"
+          test_mypyc: true
+        - name: Test suite with py313-ubuntu, mypyc-compiled
+          python: '3.13'
+          os: ubuntu-24.04-arm
           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'
-          arch: x64
+          tox_extra_args: "-n 4"
+          test_mypyc: true
+
+        # - name: Test suite with py314-dev-ubuntu
+        #   python: '3.14-dev'
+        #   os: ubuntu-24.04-arm
+        #   toxenv: py
+        #   tox_extra_args: "-n 4"
+        #   allow_failure: true
+        #   test_mypyc: true
+
+        - name: mypyc runtime tests with py39-macos
+          python: '3.9.21'
+          # TODO: macos-13 is the last one to support Python 3.9, change it to macos-latest when updating the Python version
+          os: macos-13
+          toxenv: py
+          tox_extra_args: "-n 3 mypyc/test/test_run.py mypyc/test/test_external.py"
+        # This is broken. See
+        # - https://github.com/python/mypy/issues/17819
+        # - https://github.com/python/mypy/pull/17822
+        # - name: mypyc runtime tests with py38-debug-build-ubuntu
+        #   python: '3.9.21'
+        #   os: ubuntu-latest
+        #   toxenv: py
+        #   tox_extra_args: "-n 4 mypyc/test/test_run.py mypyc/test/test_external.py"
+        #   debug_build: true
+
+        - name: Type check our own code (py39-ubuntu)
+          python: '3.9'
           os: ubuntu-latest
           toxenv: type
-        - name: Type check our own code (py37-windows-64)
-          python: '3.7'
-          arch: x64
+        - name: Type check our own code (py39-windows-64)
+          python: '3.9'
           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
-        - name: Formatting with Black + isort and code style with flake8
+        - name: Formatting and code style with Black + ruff
           python: '3.10'
-          arch: x64
           os: ubuntu-latest
           toxenv: lint
 
     name: ${{ matrix.name }}
+    timeout-minutes: 60
     env:
       TOX_SKIP_MISSING_INTERPRETERS: False
-      # Rich (pip)
-      FORCE_COLOR: 1
+      # Rich (pip) -- Disable color for windows + pytest
+      FORCE_COLOR: ${{ !(startsWith(matrix.os, 'windows-') && startsWith(matrix.toxenv, 'py')) && 1 || 0 }}
       # Tox
       PY_COLORS: 1
       # Mypy (see https://github.com/python/mypy/issues/7771)
@@ -115,12 +121,12 @@ jobs:
       MYPY_FORCE_TERMINAL_WIDTH: 200
       # Pytest
       PYTEST_ADDOPTS: --color=yes
+
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
+    - uses: actions/checkout@v4
       with:
-        python-version: ${{ matrix.python }}
-        architecture: ${{ matrix.arch }}
+        persist-credentials: false
+
     - name: Debug build
       if: ${{ matrix.debug_build }}
       run: |
@@ -128,40 +134,62 @@ jobs:
         PYTHONDIR=~/python-debug/python-$PYTHONVERSION
         VENV=$PYTHONDIR/env
         ./misc/build-debug-python.sh $PYTHONVERSION $PYTHONDIR $VENV
+        # TODO: does this do anything? env vars aren't passed to the next step right
         source $VENV/bin/activate
+    - name: Latest dev build
+      if: ${{ endsWith(matrix.python, '-dev') }}
+      run: |
+          git clone --depth 1 https://github.com/python/cpython.git /tmp/cpython --branch $( echo ${{ matrix.python }} | sed 's/-dev//' )
+          cd /tmp/cpython
+          echo git rev-parse HEAD; git rev-parse HEAD
+          git show --no-patch
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            build-essential gdb lcov libbz2-dev libffi-dev libgdbm-dev liblzma-dev libncurses5-dev \
+            libreadline6-dev libsqlite3-dev libssl-dev lzma lzma-dev tk-dev uuid-dev zlib1g-dev
+          ./configure --prefix=/opt/pythondev
+          make -j$(nproc)
+          sudo make install
+          sudo ln -s /opt/pythondev/bin/python3 /opt/pythondev/bin/python
+          sudo ln -s /opt/pythondev/bin/pip3 /opt/pythondev/bin/pip
+          echo "/opt/pythondev/bin" >> $GITHUB_PATH
+    - uses: actions/setup-python@v5
+      if: ${{ !(matrix.debug_build || endsWith(matrix.python, '-dev')) }}
+      with:
+        python-version: ${{ matrix.python }}
+
     - name: Install tox
-      run: pip install --upgrade 'setuptools!=50' tox==4.4.4
+      run: |
+        echo PATH; echo $PATH
+        echo which python; which python
+        echo which pip; which pip
+        echo python version; python -c 'import sys; print(sys.version)'
+        echo debug build; python -c 'import sysconfig; print(bool(sysconfig.get_config_var("Py_DEBUG")))'
+        echo os.cpu_count; python -c 'import os; print(os.cpu_count())'
+        echo os.sched_getaffinity; python -c 'import os; print(len(getattr(os, "sched_getaffinity", lambda *args: [])(0)))'
+        pip install setuptools==75.1.0 tox==4.21.2
+
     - name: Compiled with mypyc
       if: ${{ matrix.test_mypyc }}
       run: |
         pip install -r test-requirements.txt
         CC=clang MYPYC_OPT_LEVEL=0 MYPY_USE_MYPYC=1 pip install -e .
+
     - name: Setup tox environment
-      run: tox run -e ${{ matrix.toxenv }} --notest
+      run: |
+        tox run -e ${{ matrix.toxenv }} --notest
     - name: Test
       run: tox run -e ${{ matrix.toxenv }} --skip-pkg-install -- ${{ matrix.tox_extra_args }}
+      continue-on-error: ${{ matrix.allow_failure == 'true' }}
 
-  python-nightly:
-    runs-on: ubuntu-latest
-    name: Test suite with Python nightly
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.12-dev'
-      - name: Install tox
-        run: pip install --upgrade 'setuptools!=50' tox==4.4.4
-      - name: Setup tox environment
-        run: tox run -e py --notest
-      - name: Test
-        run: tox run -e py --skip-pkg-install -- "-n 2"
-        continue-on-error: true
-      - name: Mark as a success
-        run: exit 0
+    - name: Mark as success (check failures manually)
+      if: ${{ matrix.allow_failure == 'true' }}
+      run: exit 0
 
   python_32bits:
     runs-on: ubuntu-latest
     name: Test mypyc suite with 32-bit Python
+    timeout-minutes: 60
     env:
       TOX_SKIP_MISSING_INTERPRETERS: False
       # Rich (pip)
@@ -177,7 +205,9 @@ jobs:
       CXX: i686-linux-gnu-g++
       CC: i686-linux-gnu-gcc
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: Install 32-bit build dependencies
         run: |
           sudo dpkg --add-architecture i386 && \
@@ -200,8 +230,8 @@ jobs:
           default: 3.11.1
           command: python -c "import platform; print(f'{platform.architecture()=} {platform.machine()=}');"
       - name: Install tox
-        run: pip install --upgrade 'setuptools!=50' tox==4.4.4
+        run: pip install setuptools==75.1.0 tox==4.21.2
       - name: Setup tox environment
         run: tox run -e py --notest
       - name: Test
-        run: tox run -e py --skip-pkg-install -- -n 2 mypyc/test/
+        run: tox run -e py --skip-pkg-install -- -n 4 mypyc/test/
diff --git a/.github/workflows/test_stubgenc.yml b/.github/workflows/test_stubgenc.yml
index db9bf413faa3..4676acf8695b 100644
--- a/.github/workflows/test_stubgenc.yml
+++ b/.github/workflows/test_stubgenc.yml
@@ -1,4 +1,4 @@
-name: Test stubgenc on pybind11-mypy-demo
+name: Test stubgenc on pybind11_fixtures
 
 on:
   workflow_dispatch:
@@ -10,21 +10,32 @@ on:
     - 'misc/test-stubgenc.sh'
     - 'mypy/stubgenc.py'
     - 'mypy/stubdoc.py'
+    - 'mypy/stubutil.py'
     - 'test-data/stubgen/**'
 
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
 jobs:
   stubgenc:
     # Check stub file generation for a small pybind11 project
     # (full text match is required to pass)
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     steps:
 
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
 
-    - name: Setup 🐍 3.8
-      uses: actions/setup-python@v4
+    - name: Setup 🐍 3.9
+      uses: actions/setup-python@v5
       with:
-        python-version: 3.8
+        python-version: 3.9
 
     - name: Test stubgenc
       run: misc/test-stubgenc.sh
diff --git a/.gitignore b/.gitignore
index c6761f0ed736..9c325f3e29f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,7 @@ venv/
 test-data/packages/.pip_lock
 dmypy.json
 .dmypy.json
+/.mypyc_test_output
 
 # Packages
 *.egg
@@ -57,6 +58,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 92d827fba006..3b323f03b99c 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,26 +1,64 @@
-exclude: '^(mypyc/external/)|(mypy/typeshed/)'  # Exclude all vendored code from lints
+exclude: '^(mypyc/external/)|(mypy/typeshed/)|misc/typeshed_patches'  # Exclude all vendored code from lints
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0  # must match test-requirements.txt
+    rev: v5.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
-  - repo: https://github.com/psf/black
-    rev: 23.3.0  # must match test-requirements.txt
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 25.1.0
     hooks:
       - id: black
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0  # must match test-requirements.txt
+        exclude: '^(test-data/)'
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.4
     hooks:
-      - id: isort
-  - repo: https://github.com/pycqa/flake8
-    rev: 6.0.0  # must match test-requirements.txt
+      - id: ruff
+        args: [--exit-non-zero-on-fix]
+  - repo: https://github.com/python-jsonschema/check-jsonschema
+    rev: 0.32.1
     hooks:
-      - id: flake8
+      - id: check-github-workflows
+      - id: check-github-actions
+      - id: check-readthedocs
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.4.1
+    hooks:
+      - id: codespell
+        args:
+          - --ignore-words-list=HAX,ccompiler,ot,statics,whet,zar
+        exclude: ^(mypy/test/|mypy/typeshed/|mypyc/test-data/|test-data/).+$
+  - repo: https://github.com/rhysd/actionlint
+    rev: v1.7.7
+    hooks:
+      - id: actionlint
+        args: [
+          -ignore=property "debug_build" is not defined,
+          -ignore=property "allow_failure" is not defined,
+          -ignore=SC2(046|086),
+        ]
         additional_dependencies:
-          - flake8-bugbear==23.3.23  # must match test-requirements.txt
-          - flake8-noqa==1.3.1       # must match test-requirements.txt
+          # actionlint has a shellcheck integration which extracts shell scripts in `run:` steps from GitHub Actions
+          # and checks these with shellcheck. This is arguably its most useful feature,
+          # but the integration only works if shellcheck is installed
+          - "github.com/wasilibs/go-shellcheck/cmd/shellcheck@v0.10.0"
+  - repo: https://github.com/woodruffw/zizmor-pre-commit
+    rev: v1.5.2
+    hooks:
+      - id: zizmor
+  - repo: local
+    hooks:
+      - id: bad-pr-link
+        name: Bad PR link
+        description: Detect PR links text that don't match their URL
+        language: pygrep
+        entry: '\[(\d+)\]\(https://github.com/python/mypy/pull/(?!\1/?\))\d+/?\)'
+        files: CHANGELOG.md
+  # Should be the last one:
+  - repo: meta
+    hooks:
+      - id: check-hooks-apply
+      - id: check-useless-excludes
 
 ci:
-  # We run flake8 as part of our GitHub Actions suite in CI
-  skip: [flake8]
+  autoupdate_schedule: quarterly
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 000000000000..8ec33ee641ed
--- /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/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 000000000000..01d58ce6a1b3
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,3422 @@
+# Mypy Release Notes
+
+## Next Release
+
+## Mypy 1.16
+
+We’ve just uploaded mypy 1.16 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).
+Mypy is a static type checker for Python. This release includes new features and bug fixes.
+You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Different Property Getter and Setter Types
+
+Mypy now supports using different types for a property getter and setter:
+
+```python
+class A:
+    _value: int
+
+    @property
+    def foo(self) -> int:
+        return self._value
+
+    @foo.setter
+    def foo(self, x: str | int) -> None:
+        try:
+            self._value = int(x)
+        except ValueError:
+            raise Exception(f"'{x}' is not a valid value for 'foo'")
+```
+This was contributed by Ivan Levkivskyi (PR [18510](https://github.com/python/mypy/pull/18510)).
+
+### Flexible Variable Redefinitions (Experimental)
+
+Mypy now allows unannotated variables to be freely redefined with
+different types when using the experimental `--allow-redefinition-new`
+flag. You will also need to enable `--local-partial-types`. Mypy will
+now infer a union type when different types are assigned to a
+variable:
+
+```py
+# mypy: allow-redefinition-new, local-partial-types
+
+def f(n: int, b: bool) -> int | str:
+    if b:
+        x = n
+    else:
+        x = str(n)
+    # Type of 'x' is int | str here.
+    return x
+```
+
+Without the new flag, mypy only supports inferring optional types (`X
+| None`) from multiple assignments, but now mypy can infer arbitrary
+union types.
+
+An unannotated variable can now also have different types in different
+code locations:
+
+```py
+# mypy: allow-redefinition-new, local-partial-types
+...
+
+if cond():
+    for x in range(n):
+        # Type of 'x' is 'int' here
+        ...
+else:
+    for x in ['a', 'b']:
+        # Type of 'x' is 'str' here
+        ...
+```
+
+We are planning to turn this flag on by default in mypy 2.0, along
+with `--local-partial-types`. The feature is still experimental and
+has known issues, and the semantics may still change in the
+future. You may need to update or add type annotations when switching
+to the new behavior, but if you encounter anything unexpected, please
+create a GitHub issue.
+
+This was contributed by Jukka Lehtosalo
+(PR [18727](https://github.com/python/mypy/pull/18727), PR [19153](https://github.com/python/mypy/pull/19153)).
+
+### Stricter Type Checking with Imprecise Types
+
+Mypy can now detect additional errors in code that uses `Any` types or has missing function annotations.
+
+When calling `dict.get(x, None)` on an object of type `dict[str, Any]`, this
+now results in an optional type (in the past it was `Any`):
+
+```python
+def f(d: dict[str, Any]) -> int:
+    # Error: Return value has type "Any | None" but expected "int"
+    return d.get("x", None)
+```
+
+Type narrowing using assignments can result in more precise types in
+the presence of `Any` types:
+
+```python
+def foo(): ...
+
+def bar(n: int) -> None:
+    x = foo()
+    # Type of 'x' is 'Any' here
+    if n > 5:
+        x = str(n)
+        # Type of 'x' is 'str' here
+```
+
+When using `--check-untyped-defs`, unannotated overrides are now
+checked more strictly against superclass definitions.
+
+Related PRs:
+
+ * Use union types instead of join in binder (Ivan Levkivskyi, PR [18538](https://github.com/python/mypy/pull/18538))
+ * Check superclass compatibility of untyped methods if `--check-untyped-defs` is set (Stanislav Terliakov, PR [18970](https://github.com/python/mypy/pull/18970))
+
+### Improvements to Attribute Resolution
+
+This release includes several fixes to inconsistent resolution of attribute, method and descriptor types.
+
+ * Consolidate descriptor handling (Ivan Levkivskyi, PR [18831](https://github.com/python/mypy/pull/18831))
+ * Make multiple inheritance checking use common semantics (Ivan Levkivskyi, PR [18876](https://github.com/python/mypy/pull/18876))
+ * Make method override checking use common semantics  (Ivan Levkivskyi, PR [18870](https://github.com/python/mypy/pull/18870))
+ * Fix descriptor overload selection (Ivan Levkivskyi, PR [18868](https://github.com/python/mypy/pull/18868))
+ * Handle union types when binding `self` (Ivan Levkivskyi, PR [18867](https://github.com/python/mypy/pull/18867))
+ * Make variable override checking use common semantics (Ivan Levkivskyi, PR [18847](https://github.com/python/mypy/pull/18847))
+ * Make descriptor handling behave consistently (Ivan Levkivskyi, PR [18831](https://github.com/python/mypy/pull/18831))
+
+### Make Implementation for Abstract Overloads Optional
+
+The implementation can now be omitted for abstract overloaded methods,
+even outside stubs:
+
+```py
+from abc import abstractmethod
+from typing import overload
+
+class C:
+    @abstractmethod
+    @overload
+    def foo(self, x: int) -> int: ...
+
+    @abstractmethod
+    @overload
+    def foo(self, x: str) -> str: ...
+
+    # No implementation required for "foo"
+```
+
+This was contributed by Ivan Levkivskyi (PR [18882](https://github.com/python/mypy/pull/18882)).
+
+### Option to Exclude Everything in .gitignore
+
+You can now use `--exclude-gitignore` to exclude everything in a
+`.gitignore` file from the mypy build. This behaves similar to
+excluding the paths using `--exclude`. We might enable this by default
+in a future mypy release.
+
+This was contributed by Ivan Levkivskyi (PR [18696](https://github.com/python/mypy/pull/18696)).
+
+### Selectively Disable Deprecated Warnings
+
+It's now possible to selectively disable warnings generated from
+[`warnings.deprecated`](https://docs.python.org/3/library/warnings.html#warnings.deprecated)
+using the [`--deprecated-calls-exclude`](https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-deprecated-calls-exclude)
+option:
+
+```python
+# mypy --enable-error-code deprecated
+#      --deprecated-calls-exclude=foo.A
+import foo
+
+foo.A().func()  # OK, the deprecated warning is ignored
+```
+
+```python
+# file foo.py
+
+from typing_extensions import deprecated
+
+class A:
+    @deprecated("Use A.func2 instead")
+    def func(self): pass
+
+    ...
+```
+
+Contributed by Marc Mueller (PR [18641](https://github.com/python/mypy/pull/18641))
+
+### Annotating Native/Non-Native Classes in Mypyc
+
+You can now declare a class as a non-native class when compiling with
+mypyc. Unlike native classes, which are extension classes and have an
+immutable structure, non-native classes are normal Python classes at
+runtime and are fully dynamic.  Example:
+
+```python
+from mypy_extensions import mypyc_attr
+
+@mypyc_attr(native_class=False)
+class NonNativeClass:
+    ...
+
+o = NonNativeClass()
+
+# Ok, even if attribute "foo" not declared in class body
+setattr(o, "foo", 1)
+```
+
+Classes are native by default in compiled modules, but classes that
+use certain features (such as most metaclasses) are implicitly
+non-native.
+
+You can also explicitly declare a class as native. In this case mypyc
+will generate an error if it can't compile the class as a native
+class, instead of falling back to a non-native class:
+
+```python
+from mypy_extensions import mypyc_attr
+from foo import MyMeta
+
+# Error: Unsupported metaclass for a native class
+@mypyc_attr(native_class=True)
+class C(metaclass=MyMeta):
+    ...
+```
+
+Since native classes are significantly more efficient that non-native
+classes, you may want to ensure that certain classes always compiled
+as native classes.
+
+This feature was contributed by Valentin Stanciu (PR [18802](https://github.com/python/mypy/pull/18802)).
+
+### Mypyc Fixes and Improvements
+
+ * Improve documentation of native and non-native classes (Jukka Lehtosalo, PR [19154](https://github.com/python/mypy/pull/19154))
+ * Fix compilation when using Python 3.13 debug build (Valentin Stanciu, PR [19045](https://github.com/python/mypy/pull/19045))
+ * Show the reason why a class can't be a native class (Valentin Stanciu, PR [19016](https://github.com/python/mypy/pull/19016))
+ * Support await/yield while temporary values are live (Michael J. Sullivan, PR [16305](https://github.com/python/mypy/pull/16305))
+ * Fix spilling values with overlapping error values (Jukka Lehtosalo, PR [18961](https://github.com/python/mypy/pull/18961))
+ * Fix reference count of spilled register in async def (Jukka Lehtosalo, PR [18957](https://github.com/python/mypy/pull/18957))
+ * Add basic optimization for `sorted` (Marc Mueller, PR [18902](https://github.com/python/mypy/pull/18902))
+ * Fix access of class object in a type annotation (Advait Dixit, PR [18874](https://github.com/python/mypy/pull/18874))
+ * Optimize `list.__imul__` and `tuple.__mul__ `(Marc Mueller, PR [18887](https://github.com/python/mypy/pull/18887))
+ * Optimize `list.__add__`, `list.__iadd__` and `tuple.__add__` (Marc Mueller, PR [18845](https://github.com/python/mypy/pull/18845))
+ * Add and implement primitive `list.copy()` (exertustfm, PR [18771](https://github.com/python/mypy/pull/18771))
+ * Optimize `builtins.repr` (Marc Mueller, PR [18844](https://github.com/python/mypy/pull/18844))
+ * Support iterating over keys/values/items of dict-bound TypeVar and ParamSpec.kwargs (Stanislav Terliakov, PR [18789](https://github.com/python/mypy/pull/18789))
+ * Add efficient primitives for `str.strip()` etc. (Advait Dixit, PR [18742](https://github.com/python/mypy/pull/18742))
+ * Document that `strip()` etc. are optimized (Jukka Lehtosalo, PR [18793](https://github.com/python/mypy/pull/18793))
+ * Fix mypyc crash with enum type aliases (Valentin Stanciu, PR [18725](https://github.com/python/mypy/pull/18725))
+ * Optimize `str.find` and `str.rfind` (Marc Mueller, PR [18709](https://github.com/python/mypy/pull/18709))
+ * Optimize `str.__contains__` (Marc Mueller, PR [18705](https://github.com/python/mypy/pull/18705))
+ * Fix order of steal/unborrow in tuple unpacking (Ivan Levkivskyi, PR [18732](https://github.com/python/mypy/pull/18732))
+ * Optimize `str.partition` and `str.rpartition` (Marc Mueller, PR [18702](https://github.com/python/mypy/pull/18702))
+ * Optimize `str.startswith` and `str.endswith` with tuple argument (Marc Mueller, PR [18678](https://github.com/python/mypy/pull/18678))
+ * Improve `str.startswith` and `str.endswith` with tuple argument (Marc Mueller, PR [18703](https://github.com/python/mypy/pull/18703))
+ * `pythoncapi_compat`: don't define Py_NULL if it is already defined (Michael R. Crusoe, PR [18699](https://github.com/python/mypy/pull/18699))
+ * Optimize `str.splitlines` (Marc Mueller, PR [18677](https://github.com/python/mypy/pull/18677))
+ * Mark `dict.setdefault` as optimized (Marc Mueller, PR [18685](https://github.com/python/mypy/pull/18685))
+ * Support `__del__` methods (Advait Dixit, PR [18519](https://github.com/python/mypy/pull/18519))
+ * Optimize `str.rsplit` (Marc Mueller, PR [18673](https://github.com/python/mypy/pull/18673))
+ * Optimize `str.removeprefix` and `str.removesuffix` (Marc Mueller, PR [18672](https://github.com/python/mypy/pull/18672))
+ * Recognize literal types in `__match_args__` (Stanislav Terliakov, PR [18636](https://github.com/python/mypy/pull/18636))
+ * Fix non extension classes with attribute annotations using forward references (Valentin Stanciu, PR [18577](https://github.com/python/mypy/pull/18577))
+ * Use lower-case generic types such as `list[t]` in documentation (Jukka Lehtosalo, PR [18576](https://github.com/python/mypy/pull/18576))
+ * Improve support for `frozenset` (Marc Mueller, PR [18571](https://github.com/python/mypy/pull/18571))
+ * Fix wheel build for cp313-win (Marc Mueller, PR [18560](https://github.com/python/mypy/pull/18560))
+ * Reduce impact of immortality (introduced in Python 3.12) on reference counting performance (Jukka Lehtosalo, PR [18459](https://github.com/python/mypy/pull/18459))
+ * Update math error messages for 3.14 (Marc Mueller, PR [18534](https://github.com/python/mypy/pull/18534))
+ * Update math error messages for 3.14 (2) (Marc Mueller, PR [18949](https://github.com/python/mypy/pull/18949))
+ * Replace deprecated `_PyLong_new` with `PyLongWriter` API (Marc Mueller, PR [18532](https://github.com/python/mypy/pull/18532))
+
+### Fixes to Crashes
+
+ * Traverse module ancestors when traversing reachable graph nodes during dmypy update (Stanislav Terliakov, PR [18906](https://github.com/python/mypy/pull/18906))
+ * Fix crash on multiple unpacks in a bare type application (Stanislav Terliakov, PR [18857](https://github.com/python/mypy/pull/18857))
+ * Prevent crash when enum/TypedDict call is stored as a class attribute (Stanislav Terliakov, PR [18861](https://github.com/python/mypy/pull/18861))
+ * Fix crash on multiple unpacks in a bare type application (Stanislav Terliakov, PR [18857](https://github.com/python/mypy/pull/18857))
+ * Fix crash on type inference against non-normal callables (Ivan Levkivskyi, PR [18858](https://github.com/python/mypy/pull/18858))
+ * Fix crash on decorated getter in settable property (Ivan Levkivskyi, PR [18787](https://github.com/python/mypy/pull/18787))
+ * Fix crash on callable with `*args` and suffix against Any (Ivan Levkivskyi, PR [18781](https://github.com/python/mypy/pull/18781))
+ * Fix crash on deferred supertype and setter override (Ivan Levkivskyi, PR [18649](https://github.com/python/mypy/pull/18649))
+ * Fix crashes on incorrectly detected recursive aliases (Ivan Levkivskyi, PR [18625](https://github.com/python/mypy/pull/18625))
+ * Report that `NamedTuple` and `dataclass` are incompatile instead of crashing (Christoph Tyralla, PR [18633](https://github.com/python/mypy/pull/18633))
+ * Fix mypy daemon crash (Valentin Stanciu, PR [19087](https://github.com/python/mypy/pull/19087))
+
+### Performance Improvements
+
+These are specific to mypy. Mypyc-related performance improvements are discussed elsewhere.
+
+ * Speed up binding `self` in trivial cases (Ivan Levkivskyi, PR [19024](https://github.com/python/mypy/pull/19024))
+ * Small constraint solver optimization (Aaron Gokaslan, PR [18688](https://github.com/python/mypy/pull/18688))
+
+### Documentation Updates
+
+ * Improve documentation of `--strict` (lenayoung8, PR [18903](https://github.com/python/mypy/pull/18903))
+ * Remove a note about `from __future__ import annotations` (Ageev Maxim, PR [18915](https://github.com/python/mypy/pull/18915))
+ * Improve documentation on type narrowing (Tim Hoffmann, PR [18767](https://github.com/python/mypy/pull/18767))
+ * Fix metaclass usage example (Georg, PR [18686](https://github.com/python/mypy/pull/18686))
+ * Update documentation on `extra_checks` flag (Ivan Levkivskyi, PR [18537](https://github.com/python/mypy/pull/18537))
+
+### Stubgen Improvements
+
+ * Fix `TypeAlias` handling (Alexey Makridenko, PR [18960](https://github.com/python/mypy/pull/18960))
+ * Handle `arg=None` in C extension modules (Anthony Sottile, PR [18768](https://github.com/python/mypy/pull/18768))
+ * Fix valid type detection to allow pipe unions (Chad Dombrova, PR [18726](https://github.com/python/mypy/pull/18726))
+ * Include simple decorators in stub files (Marc Mueller, PR [18489](https://github.com/python/mypy/pull/18489))
+ * Support positional and keyword-only arguments in stubdoc (Paul Ganssle, PR [18762](https://github.com/python/mypy/pull/18762))
+ * Fall back to `Incomplete` if we are unable to determine the module name (Stanislav Terliakov, PR [19084](https://github.com/python/mypy/pull/19084))
+
+### Stubtest Improvements
+
+ * Make stubtest ignore `__slotnames__` (Nick Pope, PR [19077](https://github.com/python/mypy/pull/19077))
+ * Fix stubtest tests on 3.14 (Jelle Zijlstra, PR [19074](https://github.com/python/mypy/pull/19074))
+ * Support for `strict_bytes` in stubtest (Joren Hammudoglu, PR [19002](https://github.com/python/mypy/pull/19002))
+ * Understand override (Shantanu, PR [18815](https://github.com/python/mypy/pull/18815))
+ * Better checking of runtime arguments with dunder names (Shantanu, PR [18756](https://github.com/python/mypy/pull/18756))
+ * Ignore setattr and delattr inherited from object (Stephen Morton, PR [18325](https://github.com/python/mypy/pull/18325))
+
+### Miscellaneous Fixes and Improvements
+
+ * Add `--strict-bytes` to `--strict` (wyattscarpenter, PR [19049](https://github.com/python/mypy/pull/19049))
+ * Admit that Final variables are never redefined (Stanislav Terliakov, PR [19083](https://github.com/python/mypy/pull/19083))
+ * Add special support for `@django.cached_property` needed in `django-stubs` (sobolevn, PR [18959](https://github.com/python/mypy/pull/18959))
+ * Do not narrow types to `Never` with binder (Ivan Levkivskyi, PR [18972](https://github.com/python/mypy/pull/18972))
+ * Local forward references should precede global forward references (Ivan Levkivskyi, PR [19000](https://github.com/python/mypy/pull/19000))
+ * Do not cache module lookup results in incremental mode that may become invalid (Stanislav Terliakov, PR [19044](https://github.com/python/mypy/pull/19044))
+ * Only consider meta variables in ambiguous "any of" constraints (Stanislav Terliakov, PR [18986](https://github.com/python/mypy/pull/18986))
+ * Allow accessing `__init__` on final classes and when `__init__` is final (Stanislav Terliakov, PR [19035](https://github.com/python/mypy/pull/19035))
+ * Treat varargs as positional-only (A5rocks, PR [19022](https://github.com/python/mypy/pull/19022))
+ * Enable colored output for argparse help in Python 3.14 (Marc Mueller, PR [19021](https://github.com/python/mypy/pull/19021))
+ * Fix argparse for Python 3.14 (Marc Mueller, PR [19020](https://github.com/python/mypy/pull/19020))
+ * `dmypy suggest` can now suggest through contextmanager-based decorators (Anthony Sottile, PR [18948](https://github.com/python/mypy/pull/18948))
+ * Fix `__r<magic_methods>__` being used under the same `__<magic_method>__` hook (Arnav Jain, PR [18995](https://github.com/python/mypy/pull/18995))
+ * Prioritize `.pyi` from `-stubs` packages over bundled `.pyi` (Joren Hammudoglu, PR [19001](https://github.com/python/mypy/pull/19001))
+ * Fix missing subtype check case for `type[T]` (Stanislav Terliakov, PR [18975](https://github.com/python/mypy/pull/18975))
+ * Fixes to the detection of redundant casts (Anthony Sottile, PR [18588](https://github.com/python/mypy/pull/18588))
+ * Make some parse errors non-blocking (Shantanu, PR [18941](https://github.com/python/mypy/pull/18941))
+ * Fix PEP 695 type alias with a mix of type arguments (PEP 696) (Marc Mueller, PR [18919](https://github.com/python/mypy/pull/18919))
+ * Allow deeper recursion in mypy daemon, better error reporting (Carter Dodd, PR [17707](https://github.com/python/mypy/pull/17707))
+ * Fix swapped errors for frozen/non-frozen dataclass inheritance (Nazrawi Demeke, PR [18918](https://github.com/python/mypy/pull/18918))
+ * Fix incremental issue with namespace packages (Shantanu, PR [18907](https://github.com/python/mypy/pull/18907))
+ * Exclude irrelevant members when narrowing union overlapping with enum (Stanislav Terliakov, PR [18897](https://github.com/python/mypy/pull/18897))
+ * Flatten union before contracting literals when checking subtyping (Stanislav Terliakov, PR [18898](https://github.com/python/mypy/pull/18898))
+ * Do not add `kw_only` dataclass fields to `__match_args__` (sobolevn, PR [18892](https://github.com/python/mypy/pull/18892))
+ * Fix error message when returning long tuple with type mismatch (Thomas Mattone, PR [18881](https://github.com/python/mypy/pull/18881))
+ * Treat `TypedDict` (old-style) aliases as regular `TypedDict`s (Stanislav Terliakov, PR [18852](https://github.com/python/mypy/pull/18852))
+ * Warn about unused `type: ignore` comments when error code is disabled (Brian Schubert, PR [18849](https://github.com/python/mypy/pull/18849))
+ * Reject duplicate `ParamSpec.{args,kwargs}` at call site (Stanislav Terliakov, PR [18854](https://github.com/python/mypy/pull/18854))
+ * Make detection of enum members more consistent (sobolevn, PR [18675](https://github.com/python/mypy/pull/18675))
+ * Admit that `**kwargs` mapping subtypes may have no direct type parameters (Stanislav Terliakov, PR [18850](https://github.com/python/mypy/pull/18850))
+ * Don't suggest `types-setuptools` for `pkg_resources` (Shantanu, PR [18840](https://github.com/python/mypy/pull/18840))
+ * Suggest `scipy-stubs` for `scipy` as non-typeshed stub package (Joren Hammudoglu, PR [18832](https://github.com/python/mypy/pull/18832))
+ * Narrow tagged unions in match statements (Gene Parmesan Thomas, PR [18791](https://github.com/python/mypy/pull/18791))
+ * Consistently store settable property type (Ivan Levkivskyi, PR [18774](https://github.com/python/mypy/pull/18774))
+ * Do not blindly undefer on leaving function (Ivan Levkivskyi, PR [18674](https://github.com/python/mypy/pull/18674))
+ * Process superclass methods before subclass methods in semanal (Ivan Levkivskyi, PR [18723](https://github.com/python/mypy/pull/18723))
+ * Only defer top-level functions (Ivan Levkivskyi, PR [18718](https://github.com/python/mypy/pull/18718))
+ * Add one more type-checking pass (Ivan Levkivskyi, PR [18717](https://github.com/python/mypy/pull/18717))
+ * Properly account for `member` and `nonmember` in enums (sobolevn, PR [18559](https://github.com/python/mypy/pull/18559))
+ * Fix instance vs tuple subtyping edge case (Ivan Levkivskyi, PR [18664](https://github.com/python/mypy/pull/18664))
+ * Improve handling of Any/object in variadic generics (Ivan Levkivskyi, PR [18643](https://github.com/python/mypy/pull/18643))
+ * Fix handling of named tuples in class match pattern (Ivan Levkivskyi, PR [18663](https://github.com/python/mypy/pull/18663))
+ * Fix regression for user config files (Shantanu, PR [18656](https://github.com/python/mypy/pull/18656))
+ * Fix dmypy socket issue on GNU/Hurd (Mattias Ellert, PR [18630](https://github.com/python/mypy/pull/18630))
+ * Don't assume that for loop body index variable is always set (Jukka Lehtosalo, PR [18631](https://github.com/python/mypy/pull/18631))
+ * Fix overlap check for variadic generics (Ivan Levkivskyi, PR [18638](https://github.com/python/mypy/pull/18638))
+ * Improve support for `functools.partial` of overloaded callable protocol (Shantanu, PR [18639](https://github.com/python/mypy/pull/18639))
+ * Allow lambdas in `except*` clauses (Stanislav Terliakov, PR [18620](https://github.com/python/mypy/pull/18620))
+ * Fix trailing commas in many multiline string options in `pyproject.toml` (sobolevn, PR [18624](https://github.com/python/mypy/pull/18624))
+ * Allow trailing commas for `files` setting in `mypy.ini` and `setup.ini` (sobolevn, PR [18621](https://github.com/python/mypy/pull/18621))
+ * Fix "not callable" issue for `@dataclass(frozen=True)` with `Final` attr (sobolevn, PR [18572](https://github.com/python/mypy/pull/18572))
+ * Add missing TypedDict special case when checking member access (Stanislav Terliakov, PR [18604](https://github.com/python/mypy/pull/18604))
+ * Use lower case `list` and `dict` in invariance notes (Jukka Lehtosalo, PR [18594](https://github.com/python/mypy/pull/18594))
+ * Fix inference when class and instance match protocol (Ivan Levkivskyi, PR [18587](https://github.com/python/mypy/pull/18587))
+ * Remove support for `builtins.Any` (Marc Mueller, PR [18578](https://github.com/python/mypy/pull/18578))
+ * Update the overlapping check for tuples to account for NamedTuples (A5rocks, PR [18564](https://github.com/python/mypy/pull/18564))
+ * Fix `@deprecated` (PEP 702) with normal overloaded methods (Christoph Tyralla, PR [18477](https://github.com/python/mypy/pull/18477))
+ * Start propagating end columns/lines for `type-arg` errors (A5rocks, PR [18533](https://github.com/python/mypy/pull/18533))
+ * Improve handling of `type(x) is Foo` checks (Stanislav Terliakov, PR [18486](https://github.com/python/mypy/pull/18486))
+ * Suggest `typing.Literal` for exit-return error messages (Marc Mueller, PR [18541](https://github.com/python/mypy/pull/18541))
+ * Allow redefinitions in except/else/finally (Stanislav Terliakov, PR [18515](https://github.com/python/mypy/pull/18515))
+ * Disallow setting Python version using inline config (Shantanu, PR [18497](https://github.com/python/mypy/pull/18497))
+ * Improve type inference in tuple multiplication plugin (Shantanu, PR [18521](https://github.com/python/mypy/pull/18521))
+ * Add missing line number to `yield from` with wrong type (Stanislav Terliakov, PR [18518](https://github.com/python/mypy/pull/18518))
+ * Hint at argument names when formatting callables with compatible return types in error messages (Stanislav Terliakov, PR [18495](https://github.com/python/mypy/pull/18495))
+ * Add better naming and improve compatibility for ad hoc intersections of instances (Christoph Tyralla, PR [18506](https://github.com/python/mypy/pull/18506))
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+- A5rocks
+- Aaron Gokaslan
+- Advait Dixit
+- Ageev Maxim
+- Alexey Makridenko
+- Ali Hamdan
+- Anthony Sottile
+- Arnav Jain
+- Brian Schubert
+- bzoracler
+- Carter Dodd
+- Chad Dombrova
+- Christoph Tyralla
+- Dimitri Papadopoulos Orfanos
+- Emma Smith
+- exertustfm
+- Gene Parmesan Thomas
+- Georg
+- Ivan Levkivskyi
+- Jared Hance
+- Jelle Zijlstra
+- Joren Hammudoglu
+- lenayoung8
+- Marc Mueller
+- Mattias Ellert
+- Michael J. Sullivan
+- Michael R. Crusoe
+- Nazrawi Demeke
+- Nick Pope
+- Paul Ganssle
+- Shantanu
+- sobolevn
+- Stanislav Terliakov
+- Stephen Morton
+- Thomas Mattone
+- Tim Hoffmann
+- Tim Ruffing
+- Valentin Stanciu
+- Wesley Collin Wright
+- wyattscarpenter
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+## Mypy 1.15
+
+We’ve just uploaded mypy 1.15 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).
+Mypy is a static type checker for Python. This release includes new features, performance
+improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Performance Improvements
+
+Mypy is up to 40% faster in some use cases. This improvement comes largely from tuning the performance
+of the garbage collector. Additionally, the release includes several micro-optimizations that may
+be impactful for large projects.
+
+Contributed by Jukka Lehtosalo
+- PR [18306](https://github.com/python/mypy/pull/18306)
+- PR [18302](https://github.com/python/mypy/pull/18302)
+- PR [18298](https://github.com/python/mypy/pull/18298)
+- PR [18299](https://github.com/python/mypy/pull/18299)
+
+### Mypyc Accelerated Mypy Wheels for ARM Linux
+
+For best performance, mypy can be compiled to C extension modules using mypyc. This makes
+mypy 3-5x faster than when interpreted with pure Python. We now build and upload mypyc
+accelerated mypy wheels for `manylinux_aarch64` to PyPI, making it easy for Linux users on
+ARM platforms to realise this speedup -- just `pip install` the latest mypy.
+
+Contributed by Christian Bundy and Marc Mueller
+(PR [mypy_mypyc-wheels#76](https://github.com/mypyc/mypy_mypyc-wheels/pull/76),
+PR [mypy_mypyc-wheels#89](https://github.com/mypyc/mypy_mypyc-wheels/pull/89)).
+
+### `--strict-bytes`
+
+By default, mypy treats `bytearray` and `memoryview` values as assignable to the `bytes`
+type, for historical reasons. Use the `--strict-bytes` flag to disable this
+behavior. [PEP 688](https://peps.python.org/pep-0688) specified the removal of this
+special case. The flag will be enabled by default in **mypy 2.0**.
+
+Contributed by Ali Hamdan (PR [18263](https://github.com/python/mypy/pull/18263)) and
+Shantanu Jain (PR [13952](https://github.com/python/mypy/pull/13952)).
+
+### Improvements to Reachability Analysis and Partial Type Handling in Loops
+
+This change results in mypy better modelling control flow within loops and hence detecting
+several previously ignored issues. In some cases, this change may require additional
+explicit variable annotations.
+
+Contributed by Christoph Tyralla (PR [18180](https://github.com/python/mypy/pull/18180),
+PR [18433](https://github.com/python/mypy/pull/18433)).
+
+(Speaking of partial types, remember that we plan to enable `--local-partial-types`
+by default in **mypy 2.0**.)
+
+### Better Discovery of Configuration Files
+
+Mypy will now walk up the filesystem (up until a repository or file system root) to discover
+configuration files. See the
+[mypy configuration file documentation](https://mypy.readthedocs.io/en/stable/config_file.html)
+for more details.
+
+Contributed by Mikhail Shiryaev and Shantanu Jain
+(PR [16965](https://github.com/python/mypy/pull/16965), PR [18482](https://github.com/python/mypy/pull/18482))
+
+### Better Line Numbers for Decorators and Slice Expressions
+
+Mypy now uses more correct line numbers for decorators and slice expressions. In some cases,
+you may have to change the location of a `# type: ignore` comment.
+
+Contributed by Shantanu Jain (PR [18392](https://github.com/python/mypy/pull/18392),
+PR [18397](https://github.com/python/mypy/pull/18397)).
+
+### Drop Support for Python 3.8
+
+Mypy no longer supports running with Python 3.8, which has reached end-of-life.
+When running mypy with Python 3.9+, it is still possible to type check code
+that needs to support Python 3.8 with the `--python-version 3.8` argument.
+Support for this will be dropped in the first half of 2025!
+
+Contributed by Marc Mueller (PR [17492](https://github.com/python/mypy/pull/17492)).
+
+### Mypyc Improvements
+
+ * Fix `__init__` for classes with `@attr.s(slots=True)` (Advait Dixit, PR [18447](https://github.com/python/mypy/pull/18447))
+ * Report error for nested class instead of crashing (Valentin Stanciu, PR [18460](https://github.com/python/mypy/pull/18460))
+ * Fix `InitVar` for dataclasses (Advait Dixit, PR [18319](https://github.com/python/mypy/pull/18319))
+ * Remove unnecessary mypyc files from wheels (Marc Mueller, PR [18416](https://github.com/python/mypy/pull/18416))
+ * Fix issues with relative imports (Advait Dixit, PR [18286](https://github.com/python/mypy/pull/18286))
+ * Add faster primitive for some list get item operations (Jukka Lehtosalo, PR [18136](https://github.com/python/mypy/pull/18136))
+ * Fix iteration over `NamedTuple` objects (Advait Dixit, PR [18254](https://github.com/python/mypy/pull/18254))
+ * Mark mypyc package with `py.typed` (bzoracler, PR [18253](https://github.com/python/mypy/pull/18253))
+ * Fix list index while checking for `Enum` class (Advait Dixit, PR [18426](https://github.com/python/mypy/pull/18426))
+
+### Stubgen Improvements
+
+ * Improve dataclass init signatures (Marc Mueller, PR [18430](https://github.com/python/mypy/pull/18430))
+ * Preserve `dataclass_transform` decorator (Marc Mueller, PR [18418](https://github.com/python/mypy/pull/18418))
+ * Fix `UnpackType` for 3.11+ (Marc Mueller, PR [18421](https://github.com/python/mypy/pull/18421))
+ * Improve `self` annotations (Marc Mueller, PR [18420](https://github.com/python/mypy/pull/18420))
+ * Print `InspectError` traceback in stubgen `walk_packages` when verbose is specified (Gareth, PR [18224](https://github.com/python/mypy/pull/18224))
+
+### Stubtest Improvements
+
+ * Fix crash with numpy array default values (Ali Hamdan, PR [18353](https://github.com/python/mypy/pull/18353))
+ * Distinguish metaclass attributes from class attributes (Stephen Morton, PR [18314](https://github.com/python/mypy/pull/18314))
+
+### Fixes to Crashes
+
+ * Prevent crash with `Unpack` of a fixed tuple in PEP695 type alias (Stanislav Terliakov, PR [18451](https://github.com/python/mypy/pull/18451))
+ * Fix crash with `--cache-fine-grained --cache-dir=/dev/null` (Shantanu, PR [18457](https://github.com/python/mypy/pull/18457))
+ * Prevent crashing when `match` arms use name of existing callable (Stanislav Terliakov, PR [18449](https://github.com/python/mypy/pull/18449))
+ * Gracefully handle encoding errors when writing to stdout (Brian Schubert, PR [18292](https://github.com/python/mypy/pull/18292))
+ * Prevent crash on generic NamedTuple with unresolved typevar bound (Stanislav Terliakov, PR [18585](https://github.com/python/mypy/pull/18585))
+
+### Documentation Updates
+
+ * Add inline tabs to documentation (Marc Mueller, PR [18262](https://github.com/python/mypy/pull/18262))
+ * Document any `TYPE_CHECKING` name works (Shantanu, PR [18443](https://github.com/python/mypy/pull/18443))
+ * Update documentation to not mention 3.8 where possible (sobolevn, PR [18455](https://github.com/python/mypy/pull/18455))
+ * Mention `ignore_errors` in exclude documentation (Shantanu, PR [18412](https://github.com/python/mypy/pull/18412))
+ * Add `Self` misuse to common issues (Shantanu, PR [18261](https://github.com/python/mypy/pull/18261))
+
+### Other Notable Fixes and Improvements
+
+ * Fix literal context for ternary expressions (Ivan Levkivskyi, PR [18545](https://github.com/python/mypy/pull/18545))
+ * Ignore `dataclass.__replace__` LSP violations (Marc Mueller, PR [18464](https://github.com/python/mypy/pull/18464))
+ * Bind `self` to the class being defined when checking multiple inheritance (Stanislav Terliakov, PR [18465](https://github.com/python/mypy/pull/18465))
+ * Fix attribute type resolution with multiple inheritance (Stanislav Terliakov, PR [18415](https://github.com/python/mypy/pull/18415))
+ * Improve security of our GitHub Actions (sobolevn, PR [18413](https://github.com/python/mypy/pull/18413))
+ * Unwrap `type[Union[...]]` when solving type variable constraints (Stanislav Terliakov, PR [18266](https://github.com/python/mypy/pull/18266))
+ * Allow `Any` to match sequence patterns in match/case (Stanislav Terliakov, PR [18448](https://github.com/python/mypy/pull/18448))
+ * Fix parent generics mapping when overriding generic attribute with property (Stanislav Terliakov, PR [18441](https://github.com/python/mypy/pull/18441))
+ * Add dedicated error code for explicit `Any` (Shantanu, PR [18398](https://github.com/python/mypy/pull/18398))
+ * Reject invalid `ParamSpec` locations (Stanislav Terliakov, PR [18278](https://github.com/python/mypy/pull/18278))
+ * Stop suggesting stubs that have been removed from typeshed (Shantanu, PR [18373](https://github.com/python/mypy/pull/18373))
+ * Allow inverting `--local-partial-types` (Shantanu, PR [18377](https://github.com/python/mypy/pull/18377))
+ * Allow to use `Final` and `ClassVar` after Python 3.13 (정승원, PR [18358](https://github.com/python/mypy/pull/18358))
+ * Update suggestions to include latest stubs in typeshed (Shantanu, PR [18366](https://github.com/python/mypy/pull/18366))
+ * Fix `--install-types` masking failure details (wyattscarpenter, PR [17485](https://github.com/python/mypy/pull/17485))
+ * Reject promotions when checking against protocols (Christoph Tyralla, PR [18360](https://github.com/python/mypy/pull/18360))
+ * Don't erase type object arguments in diagnostics (Shantanu, PR [18352](https://github.com/python/mypy/pull/18352))
+ * Clarify status in `dmypy status` output (Kcornw, PR [18331](https://github.com/python/mypy/pull/18331))
+ * Disallow no-argument generic aliases when using PEP 613 explicit aliases (Brian Schubert, PR [18173](https://github.com/python/mypy/pull/18173))
+ * Suppress errors for unreachable branches in conditional expressions (Brian Schubert, PR [18295](https://github.com/python/mypy/pull/18295))
+ * Do not allow `ClassVar` and `Final` in `TypedDict` and `NamedTuple` (sobolevn, PR [18281](https://github.com/python/mypy/pull/18281))
+ * Report error if not enough or too many types provided to `TypeAliasType` (bzoracler, PR [18308](https://github.com/python/mypy/pull/18308))
+ * Use more precise context for `TypedDict` plugin errors (Brian Schubert, PR [18293](https://github.com/python/mypy/pull/18293))
+ * Use more precise context for invalid type argument errors (Brian Schubert, PR [18290](https://github.com/python/mypy/pull/18290))
+ * Do not allow `type[]` to contain `Literal` types (sobolevn, PR [18276](https://github.com/python/mypy/pull/18276))
+ * Allow bytearray/bytes comparisons with `--strict-bytes` (Jukka Lehtosalo, PR [18255](https://github.com/python/mypy/pull/18255))
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+- Advait Dixit
+- Ali Hamdan
+- Brian Schubert
+- bzoracler
+- Cameron Matsui
+- Christoph Tyralla
+- Gareth
+- Ivan Levkivskyi
+- Jukka Lehtosalo
+- Kcornw
+- Marc Mueller
+- Mikhail f. Shiryaev
+- Shantanu
+- sobolevn
+- Stanislav Terliakov
+- Stephen Morton
+- Valentin Stanciu
+- Viktor Szépe
+- wyattscarpenter
+- 정승원
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+## Mypy 1.14
+
+We’ve just uploaded mypy 1.14 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).
+Mypy is a static type checker for Python. This release includes new features and bug fixes.
+You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Change to Enum Membership Semantics
+
+As per the updated [typing specification for enums](https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members),
+enum members must be left unannotated.
+
+```python
+class Pet(Enum):
+    CAT = 1  # Member attribute
+    DOG = 2  # Member attribute
+
+    # New error: Enum members must be left unannotated
+    WOLF: int = 3
+
+    species: str  # Considered a non-member attribute
+```
+
+In particular, the specification change can result in issues in type stubs (`.pyi` files), since
+historically it was common to leave the value absent:
+
+```python
+# In a type stub (.pyi file)
+
+class Pet(Enum):
+    # Change in semantics: previously considered members,
+    # now non-member attributes
+    CAT: int
+    DOG: int
+
+    # Mypy will now issue a warning if it detects this
+    # situation in type stubs:
+    # > Detected enum "Pet" in a type stub with zero
+    # > members. There is a chance this is due to a recent
+    # > change in the semantics of enum membership. If so,
+    # > use `member = value` to mark an enum member,
+    # > instead of `member: type`
+
+class Pet(Enum):
+    # As per the specification, you should now do one of
+    # the following:
+    DOG = 1  # Member attribute with value 1 and known type
+    WOLF = cast(int, ...)  # Member attribute with unknown
+                           # value but known type
+    LION = ...  # Member attribute with unknown value and
+                # # unknown type
+```
+
+Contributed by Terence Honles (PR [17207](https://github.com/python/mypy/pull/17207)) and
+Shantanu Jain (PR [18068](https://github.com/python/mypy/pull/18068)).
+
+### Support for @deprecated Decorator (PEP 702)
+
+Mypy can now issue errors or notes when code imports a deprecated feature
+explicitly with a `from mod import depr` statement, or uses a deprecated feature
+imported otherwise or defined locally. Features are considered deprecated when
+decorated with `warnings.deprecated`, as specified in [PEP 702](https://peps.python.org/pep-0702).
+
+You can enable the error code via `--enable-error-code=deprecated` on the mypy
+command line or `enable_error_code = deprecated` in the mypy config file.
+Use the command line flag `--report-deprecated-as-note` or config file option
+`report_deprecated_as_note=True` to turn all such errors into notes.
+
+Deprecation errors will be enabled by default in a future mypy version.
+
+This feature was contributed by Christoph Tyralla.
+
+List of changes:
+
+ * Add basic support for PEP 702 (`@deprecated`) (Christoph Tyralla, PR [17476](https://github.com/python/mypy/pull/17476))
+ * Support descriptors with `@deprecated` (Christoph Tyralla, PR [18090](https://github.com/python/mypy/pull/18090))
+ * Make "deprecated" note an error, disabled by default (Valentin Stanciu, PR [18192](https://github.com/python/mypy/pull/18192))
+ * Consider all possible type positions with `@deprecated` (Christoph Tyralla, PR [17926](https://github.com/python/mypy/pull/17926))
+ * Improve the handling of explicit type annotations in assignment statements with `@deprecated` (Christoph Tyralla, PR [17899](https://github.com/python/mypy/pull/17899))
+
+### Optionally Analyzing Untyped Modules
+
+Mypy normally doesn't analyze imports from third-party modules (installed using pip, for example)
+if there are no stubs or a py.typed marker file. To force mypy to analyze these imports, you
+can now use the `--follow-untyped-imports` flag or set the `follow_untyped_imports`
+config file option to True. This can be set either in the global section of your mypy config
+file, or individually on a per-module basis.
+
+This feature was contributed by Jannick Kremer.
+
+List of changes:
+
+ * Implement flag to allow type checking of untyped modules (Jannick Kremer, PR [17712](https://github.com/python/mypy/pull/17712))
+ * Warn about `--follow-untyped-imports` (Shantanu, PR [18249](https://github.com/python/mypy/pull/18249))
+
+### Support New Style Type Variable Defaults (PEP 696)
+
+Mypy now supports type variable defaults using the new syntax described in PEP 696, which
+was introduced in Python 3.13. Example:
+
+```python
+@dataclass
+class Box[T = int]:  # Set default for "T"
+    value: T | None = None
+
+reveal_type(Box())                      # type is Box[int], since it's the default
+reveal_type(Box(value="Hello World!"))  # type is Box[str]
+```
+
+This feature was contributed by Marc Mueller (PR [17985](https://github.com/python/mypy/pull/17985)).
+
+### Improved For Loop Index Variable Type Narrowing
+
+Mypy now preserves the literal type of for loop index variables, to support `TypedDict`
+lookups. Example:
+
+```python
+from typing import TypedDict
+
+class X(TypedDict):
+    hourly: int
+    daily: int
+
+def func(x: X) -> int:
+    s = 0
+    for var in ("hourly", "daily"):
+        # "Union[Literal['hourly']?, Literal['daily']?]"
+        reveal_type(var)
+
+        # x[var] no longer triggers a literal-required error
+        s += x[var]
+    return s
+```
+
+This was contributed by Marc Mueller (PR [18014](https://github.com/python/mypy/pull/18014)).
+
+### Mypyc Improvements
+
+ * Document optimized bytes operations and additional str operations (Jukka Lehtosalo, PR [18242](https://github.com/python/mypy/pull/18242))
+ * Add primitives and specialization for `ord()` (Jukka Lehtosalo, PR [18240](https://github.com/python/mypy/pull/18240))
+ * Optimize `str.encode` with specializations for common used encodings (Valentin Stanciu, PR [18232](https://github.com/python/mypy/pull/18232))
+ * Fix fall back to generic operation for staticmethod and classmethod (Advait Dixit, PR [18228](https://github.com/python/mypy/pull/18228))
+ * Support unicode surrogates in string literals (Jukka Lehtosalo, PR [18209](https://github.com/python/mypy/pull/18209))
+ * Fix index variable in for loop with `builtins.enumerate` (Advait Dixit, PR [18202](https://github.com/python/mypy/pull/18202))
+ * Fix check for enum classes (Advait Dixit, PR [18178](https://github.com/python/mypy/pull/18178))
+ * Fix loading type from imported modules (Advait Dixit, PR [18158](https://github.com/python/mypy/pull/18158))
+ * Fix initializers of final attributes in class body (Jared Hance, PR [18031](https://github.com/python/mypy/pull/18031))
+ * Fix name generation for modules with similar full names (aatle, PR [18001](https://github.com/python/mypy/pull/18001))
+ * Fix relative imports in `__init__.py` (Shantanu, PR [17979](https://github.com/python/mypy/pull/17979))
+ * Optimize dunder methods (jairov4, PR [17934](https://github.com/python/mypy/pull/17934))
+ * Replace deprecated `_PyDict_GetItemStringWithError` (Marc Mueller, PR [17930](https://github.com/python/mypy/pull/17930))
+ * Fix wheel build for cp313-win (Marc Mueller, PR [17941](https://github.com/python/mypy/pull/17941))
+ * Use public PyGen_GetCode instead of vendored implementation (Marc Mueller, PR [17931](https://github.com/python/mypy/pull/17931))
+ * Optimize calls to final classes (jairov4, PR [17886](https://github.com/python/mypy/pull/17886))
+ * Support ellipsis (`...`) expressions in class bodies (Newbyte, PR [17923](https://github.com/python/mypy/pull/17923))
+ * Sync `pythoncapi_compat.h` (Marc Mueller, PR [17929](https://github.com/python/mypy/pull/17929))
+ * Add `runtests.py mypyc-fast` for running fast mypyc tests (Jukka Lehtosalo, PR [17906](https://github.com/python/mypy/pull/17906))
+
+### Stubgen Improvements
+
+ * Do not include mypy generated symbols (Ali Hamdan, PR [18137](https://github.com/python/mypy/pull/18137))
+ * Fix `FunctionContext.fullname` for nested classes (Chad Dombrova, PR [17963](https://github.com/python/mypy/pull/17963))
+ * Add flagfile support (Ruslan Sayfutdinov, PR [18061](https://github.com/python/mypy/pull/18061))
+ * Add support for PEP 695 and PEP 696 syntax (Ali Hamdan, PR [18054](https://github.com/python/mypy/pull/18054))
+
+### Stubtest Improvements
+
+ * Allow the use of `--show-traceback` and `--pdb` with stubtest (Stephen Morton, PR [18037](https://github.com/python/mypy/pull/18037))
+ * Verify `__all__` exists in stub (Sebastian Rittau, PR [18005](https://github.com/python/mypy/pull/18005))
+ * Stop telling people to use double underscores (Jelle Zijlstra, PR [17897](https://github.com/python/mypy/pull/17897))
+
+### Documentation Updates
+
+ * Update config file documentation (sobolevn, PR [18103](https://github.com/python/mypy/pull/18103))
+ * Improve contributor documentation for Windows (ag-tafe, PR [18097](https://github.com/python/mypy/pull/18097))
+ * Correct note about `--disallow-any-generics` flag in documentation (Abel Sen, PR [18055](https://github.com/python/mypy/pull/18055))
+ * Further caution against `--follow-imports=skip` (Shantanu, PR [18048](https://github.com/python/mypy/pull/18048))
+ * Fix the edit page button link in documentation (Kanishk Pachauri, PR [17933](https://github.com/python/mypy/pull/17933))
+
+### Other Notables Fixes and Improvements
+
+ * Allow enum members to have type objects as values (Jukka Lehtosalo, PR [19160](https://github.com/python/mypy/pull/19160))
+ * Show `Protocol` `__call__` for arguments with incompatible types (MechanicalConstruct, PR [18214](https://github.com/python/mypy/pull/18214))
+ * Make join and meet symmetric with `strict_optional` (MechanicalConstruct, PR [18227](https://github.com/python/mypy/pull/18227))
+ * Preserve block unreachablility when checking function definitions with constrained TypeVars (Brian Schubert, PR [18217](https://github.com/python/mypy/pull/18217))
+ * Do not include non-init fields in the synthesized `__replace__` method for dataclasses (Victorien, PR [18221](https://github.com/python/mypy/pull/18221))
+ * Disallow `TypeVar` constraints parameterized by type variables (Brian Schubert, PR [18186](https://github.com/python/mypy/pull/18186))
+ * Always complain about invalid varargs and varkwargs (Shantanu, PR [18207](https://github.com/python/mypy/pull/18207))
+ * Set default strict_optional state to True (Shantanu, PR [18198](https://github.com/python/mypy/pull/18198))
+ * Preserve type variable default None in type alias (Sukhorosov Aleksey, PR [18197](https://github.com/python/mypy/pull/18197))
+ * Add checks for invalid usage of continue/break/return in `except*` block (coldwolverine, PR [18132](https://github.com/python/mypy/pull/18132))
+ * Do not consider bare TypeVar not overlapping with None for reachability analysis (Stanislav Terliakov, PR [18138](https://github.com/python/mypy/pull/18138))
+ * Special case `types.DynamicClassAttribute` as property-like (Stephen Morton, PR [18150](https://github.com/python/mypy/pull/18150))
+ * Disallow bare `ParamSpec` in type aliases (Brian Schubert, PR [18174](https://github.com/python/mypy/pull/18174))
+ * Move long_description metadata to pyproject.toml (Marc Mueller, PR [18172](https://github.com/python/mypy/pull/18172))
+ * Support `==`-based narrowing of Optional (Christoph Tyralla, PR [18163](https://github.com/python/mypy/pull/18163))
+ * Allow TypedDict assignment of Required item to NotRequired ReadOnly item (Brian Schubert, PR [18164](https://github.com/python/mypy/pull/18164))
+ * Allow nesting of Annotated with TypedDict special forms inside TypedDicts (Brian Schubert, PR [18165](https://github.com/python/mypy/pull/18165))
+ * Infer generic type arguments for slice expressions (Brian Schubert, PR [18160](https://github.com/python/mypy/pull/18160))
+ * Fix checking of match sequence pattern against bounded type variables (Brian Schubert, PR [18091](https://github.com/python/mypy/pull/18091))
+ * Fix incorrect truthyness for Enum types and literals (David Salvisberg, PR [17337](https://github.com/python/mypy/pull/17337))
+ * Move static project metadata to pyproject.toml (Marc Mueller, PR [18146](https://github.com/python/mypy/pull/18146))
+ * Fallback to stdlib json if integer exceeds 64-bit range (q0w, PR [18148](https://github.com/python/mypy/pull/18148))
+ * Fix 'or' pattern structural matching exhaustiveness (yihong, PR [18119](https://github.com/python/mypy/pull/18119))
+ * Fix type inference of positional parameter in class pattern involving builtin subtype (Brian Schubert, PR [18141](https://github.com/python/mypy/pull/18141))
+ * Fix `[override]` error with no line number when argument node has no line number (Brian Schubert, PR [18122](https://github.com/python/mypy/pull/18122))
+ * Fix some dmypy crashes (Ivan Levkivskyi, PR [18098](https://github.com/python/mypy/pull/18098))
+ * Fix subtyping between instance type and overloaded (Shantanu, PR [18102](https://github.com/python/mypy/pull/18102))
+ * Clean up new_semantic_analyzer config (Shantanu, PR [18071](https://github.com/python/mypy/pull/18071))
+ * Issue warning for enum with no members in stub (Shantanu, PR [18068](https://github.com/python/mypy/pull/18068))
+ * Fix enum attributes are not members (Terence Honles, PR [17207](https://github.com/python/mypy/pull/17207))
+ * Fix crash when checking slice expression with step 0 in tuple index (Brian Schubert, PR [18063](https://github.com/python/mypy/pull/18063))
+ * Allow union-with-callable attributes to be overridden by methods (Brian Schubert, PR [18018](https://github.com/python/mypy/pull/18018))
+ * Emit `[mutable-override]` for covariant override of attribute with method (Brian Schubert, PR [18058](https://github.com/python/mypy/pull/18058))
+ * Support ParamSpec mapping with `functools.partial` (Stanislav Terliakov, PR [17355](https://github.com/python/mypy/pull/17355))
+ * Fix approved stub ignore, remove normpath (Shantanu, PR [18045](https://github.com/python/mypy/pull/18045))
+ * Make `disallow-any-unimported` flag invertible (Séamus Ó Ceanainn, PR [18030](https://github.com/python/mypy/pull/18030))
+ * Filter to possible package paths before trying to resolve a module (falsedrow, PR [18038](https://github.com/python/mypy/pull/18038))
+ * Fix overlap check for ParamSpec types (Jukka Lehtosalo, PR [18040](https://github.com/python/mypy/pull/18040))
+ * Do not prioritize ParamSpec signatures during overload resolution (Stanislav Terliakov, PR [18033](https://github.com/python/mypy/pull/18033))
+ * Fix ternary union for literals (Ivan Levkivskyi, PR [18023](https://github.com/python/mypy/pull/18023))
+ * Fix compatibility checks for conditional function definitions using decorators (Brian Schubert, PR [18020](https://github.com/python/mypy/pull/18020))
+ * TypeGuard should be bool not Any when matching TypeVar (Evgeniy Slobodkin, PR [17145](https://github.com/python/mypy/pull/17145))
+ * Fix convert-cache tool (Shantanu, PR [17974](https://github.com/python/mypy/pull/17974))
+ * Fix generator comprehension with mypyc (Shantanu, PR [17969](https://github.com/python/mypy/pull/17969))
+ * Fix crash issue when using shadowfile with pretty (Max Chang, PR [17894](https://github.com/python/mypy/pull/17894))
+ * Fix multiple nested classes with new generics syntax (Max Chang, PR [17820](https://github.com/python/mypy/pull/17820))
+ * Better error for `mypy -p package` without py.typed (Joe Gordon, PR [17908](https://github.com/python/mypy/pull/17908))
+ * Emit error for `raise NotImplemented` (Brian Schubert, PR [17890](https://github.com/python/mypy/pull/17890))
+ * Add `is_lvalue` attribute to AttributeContext (Brian Schubert, PR [17881](https://github.com/python/mypy/pull/17881))
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+- aatle
+- Abel Sen
+- Advait Dixit
+- ag-tafe
+- Alex Waygood
+- Ali Hamdan
+- Brian Schubert
+- Carlton Gibson
+- Chad Dombrova
+- Chelsea Durazo
+- chiri
+- Christoph Tyralla
+- coldwolverine
+- David Salvisberg
+- Ekin Dursun
+- Evgeniy Slobodkin
+- falsedrow
+- Gaurav Giri
+- Ihor
+- Ivan Levkivskyi
+- jairov4
+- Jannick Kremer
+- Jared Hance
+- Jelle Zijlstra
+- jianghuyiyuan
+- Joe Gordon
+- John Doknjas
+- Jukka Lehtosalo
+- Kanishk Pachauri
+- Marc Mueller
+- Max Chang
+- MechanicalConstruct
+- Newbyte
+- q0w
+- Ruslan Sayfutdinov
+- Sebastian Rittau
+- Shantanu
+- sobolevn
+- Stanislav Terliakov
+- Stephen Morton
+- Sukhorosov Aleksey
+- Séamus Ó Ceanainn
+- Terence Honles
+- Valentin Stanciu
+- vasiliy
+- Victorien
+- yihong
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+
+## Mypy 1.13
+
+We’ve just uploaded mypy 1.13 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)).
+Mypy is a static type checker for Python. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+Note that unlike typical releases, Mypy 1.13 does not have any changes to type checking semantics
+from 1.12.1.
+
+### Improved Performance
+
+Mypy 1.13 contains several performance improvements. Users can expect mypy to be 5-20% faster.
+In environments with long search paths (such as environments using many editable installs), mypy
+can be significantly faster, e.g. 2.2x faster in the use case targeted by these improvements.
+
+Mypy 1.13 allows use of the `orjson` library for handling the cache instead of the stdlib `json`,
+for improved performance. You can ensure the presence of `orjson` using the `faster-cache` extra:
+
+    python3 -m pip install -U mypy[faster-cache]
+
+Mypy may depend on `orjson` by default in the future.
+
+These improvements were contributed by Shantanu.
+
+List of changes:
+* Significantly speed up file handling error paths (Shantanu, PR [17920](https://github.com/python/mypy/pull/17920))
+* Use fast path in modulefinder more often (Shantanu, PR [17950](https://github.com/python/mypy/pull/17950))
+* Let mypyc optimise os.path.join (Shantanu, PR [17949](https://github.com/python/mypy/pull/17949))
+* Make is_sub_path faster (Shantanu, PR [17962](https://github.com/python/mypy/pull/17962))
+* Speed up stubs suggestions (Shantanu, PR [17965](https://github.com/python/mypy/pull/17965))
+* Use sha1 for hashing (Shantanu, PR [17953](https://github.com/python/mypy/pull/17953))
+* Use orjson instead of json, when available (Shantanu, PR [17955](https://github.com/python/mypy/pull/17955))
+* Add faster-cache extra, test in CI (Shantanu, PR [17978](https://github.com/python/mypy/pull/17978))
+
+### Acknowledgements
+Thanks to all mypy contributors who contributed to this release:
+
+- Shantanu Jain
+- Jukka Lehtosalo
+
+## Mypy 1.12
+
+We’ve just uploaded mypy 1.12 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type
+checker for Python. This release includes new features, performance improvements and bug fixes.
+You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Support Python 3.12 Syntax for Generics (PEP 695)
+
+Support for the new type parameter syntax introduced in Python 3.12 is now enabled by default,
+documented, and no longer experimental. It was available through a feature flag in
+mypy 1.11 as an experimental feature.
+
+This example demonstrates the new syntax:
+
+```python
+# Generic function
+def f[T](x: T) -> T: ...
+
+reveal_type(f(1))  # Revealed type is 'int'
+
+# Generic class
+class C[T]:
+    def __init__(self, x: T) -> None:
+       self.x = x
+
+c = C('a')
+reveal_type(c.x)  # Revealed type is 'str'
+
+# Type alias
+type A[T] = C[list[T]]
+```
+
+For more information, refer to the [documentation](https://mypy.readthedocs.io/en/latest/generics.html).
+
+These improvements are included:
+
+ * Document Python 3.12 type parameter syntax (Jukka Lehtosalo, PR [17816](https://github.com/python/mypy/pull/17816))
+ * Further documentation updates (Jukka Lehtosalo, PR [17826](https://github.com/python/mypy/pull/17826))
+ * Allow Self return types with contravariance (Jukka Lehtosalo, PR [17786](https://github.com/python/mypy/pull/17786))
+ * Enable new type parameter syntax by default (Jukka Lehtosalo, PR [17798](https://github.com/python/mypy/pull/17798))
+ * Generate error if new-style type alias used as base class (Jukka Lehtosalo, PR [17789](https://github.com/python/mypy/pull/17789))
+ * Inherit variance if base class has explicit variance (Jukka Lehtosalo, PR [17787](https://github.com/python/mypy/pull/17787))
+ * Fix crash on invalid type var reference (Jukka Lehtosalo, PR [17788](https://github.com/python/mypy/pull/17788))
+ * Fix covariance of frozen dataclasses (Jukka Lehtosalo, PR [17783](https://github.com/python/mypy/pull/17783))
+ * Allow covariance with attribute that has "`_`" name prefix (Jukka Lehtosalo, PR [17782](https://github.com/python/mypy/pull/17782))
+ * Support `Annotated[...]` in new-style type aliases (Jukka Lehtosalo, PR [17777](https://github.com/python/mypy/pull/17777))
+ * Fix nested generic classes (Jukka Lehtosalo, PR [17776](https://github.com/python/mypy/pull/17776))
+ * Add detection and error reporting for the use of incorrect expressions within the scope of a type parameter and a type alias (Kirill Podoprigora, PR [17560](https://github.com/python/mypy/pull/17560))
+
+### Basic Support for Python 3.13
+
+This release adds partial support for Python 3.13 features and compiled binaries for
+Python 3.13. Mypyc now also supports Python 3.13.
+
+In particular, these features are supported:
+ * Various new stdlib features and changes (through typeshed stub improvements)
+ * `typing.ReadOnly` (see below for more)
+ * `typing.TypeIs` (added in mypy 1.10, [PEP 742](https://peps.python.org/pep-0742/))
+ * Type parameter defaults when using the legacy syntax ([PEP 696](https://peps.python.org/pep-0696/))
+
+These features are not supported yet:
+ * `warnings.deprecated` ([PEP 702](https://peps.python.org/pep-0702/))
+ * Type parameter defaults when using Python 3.12 type parameter syntax
+
+### Mypyc Support for Python 3.13
+
+Mypyc now supports Python 3.13. This was contributed by Marc Mueller, with additional
+fixes by Jukka Lehtosalo. Free threaded Python 3.13 builds are not supported yet.
+
+List of changes:
+
+ * Add additional includes for Python 3.13 (Marc Mueller, PR [17506](https://github.com/python/mypy/pull/17506))
+ * Add another include for Python 3.13 (Marc Mueller, PR [17509](https://github.com/python/mypy/pull/17509))
+ * Fix ManagedDict functions for Python 3.13 (Marc Mueller, PR [17507](https://github.com/python/mypy/pull/17507))
+ * Update mypyc test output for Python 3.13 (Marc Mueller, PR [17508](https://github.com/python/mypy/pull/17508))
+ * Fix `PyUnicode` functions for Python 3.13 (Marc Mueller, PR [17504](https://github.com/python/mypy/pull/17504))
+ * Fix `_PyObject_LookupAttrId` for Python 3.13 (Marc Mueller, PR [17505](https://github.com/python/mypy/pull/17505))
+ * Fix `_PyList_Extend` for Python 3.13 (Marc Mueller, PR [17503](https://github.com/python/mypy/pull/17503))
+ * Fix `gen_is_coroutine` for Python 3.13 (Marc Mueller, PR [17501](https://github.com/python/mypy/pull/17501))
+ * Fix `_PyObject_FastCall` for Python 3.13 (Marc Mueller, PR [17502](https://github.com/python/mypy/pull/17502))
+ * Avoid uses of `_PyObject_CallMethodOneArg` on 3.13 (Jukka Lehtosalo, PR [17526](https://github.com/python/mypy/pull/17526))
+ * Don't rely on `_PyType_CalculateMetaclass` on 3.13 (Jukka Lehtosalo, PR [17525](https://github.com/python/mypy/pull/17525))
+ * Don't use `_PyUnicode_FastCopyCharacters` on 3.13 (Jukka Lehtosalo, PR [17524](https://github.com/python/mypy/pull/17524))
+ * Don't use `_PyUnicode_EQ` on 3.13, as it's no longer exported (Jukka Lehtosalo, PR [17523](https://github.com/python/mypy/pull/17523))
+
+### Inferring Unions for Conditional Expressions
+
+Mypy now always tries to infer a union type for a conditional expression if left and right
+operand types are different. This results in more precise inferred types and lets mypy detect
+more issues. Example:
+
+```python
+s = "foo" if cond() else 1
+# Type of "s" is now "str | int" (it used to be "object")
+```
+
+Notably, if one of the operands has type `Any`, the type of a conditional expression is
+now `<type> | Any`. Previously the inferred type was just `Any`. The new type essentially
+indicates that the value can be of type `<type>`, and potentially of some (unknown) type.
+Most operations performed on the result must also be valid for `<type>`.
+Example where this is relevant:
+
+```python
+from typing import Any
+
+def func(a: Any, b: bool) -> None:
+    x = a if b else None
+    # Type of x is "Any | None"
+    print(x.y)  # Error: None has no attribute "y"
+```
+
+This feature was contributed by Ivan Levkivskyi (PR [17427](https://github.com/python/mypy/pull/17427)).
+
+### ReadOnly Support for TypedDict (PEP 705)
+
+You can now use `typing.ReadOnly` to specity TypedDict items as
+read-only ([PEP 705](https://peps.python.org/pep-0705/)):
+
+```python
+from typing import TypedDict
+
+# Or "from typing ..." on Python 3.13
+from typing_extensions import ReadOnly
+
+class TD(TypedDict):
+    a: int
+    b: ReadOnly[int]
+
+d: TD = {"a": 1, "b": 2}
+d["a"] = 3  # OK
+d["b"] = 5  # Error: "b" is ReadOnly
+```
+
+This feature was contributed by Nikita Sobolev (PR [17644](https://github.com/python/mypy/pull/17644)).
+
+### Python 3.8 End of Life Approaching
+
+We are planning to drop support for Python 3.8 in the next mypy feature release or the
+one after that. Python 3.8 reaches end of life in October 2024.
+
+### Planned Changes to Defaults
+
+We are planning to enable `--local-partial-types` by default in mypy 2.0. This will
+often require at least minor code changes. This option is implicitly enabled by mypy
+daemon, so this makes the behavior of daemon and non-daemon modes consistent.
+
+We recommend that mypy users start using local partial types soon (or to explicitly disable
+them) to prepare for the change.
+
+This can also be configured in a mypy configuration file:
+
+```
+local_partial_types = True
+```
+
+For more information, refer to the
+[documentation](https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-local-partial-types).
+
+### Documentation Updates
+
+Mypy documentation now uses modern syntax variants and imports in many examples. Some
+examples no longer work on Python 3.8, which is the earliest Python version that mypy supports.
+
+Notably, `Iterable` and other protocols/ABCs are imported from `collections.abc` instead of
+`typing`:
+```python
+from collections.abc import Iterable, Callable
+```
+
+Examples also avoid the upper-case aliases to built-in types: `list[str]` is used instead
+of `List[str]`. The `X | Y` union type syntax introduced in Python 3.10 is also now prevalent.
+
+List of documentation updates:
+
+ * Document `--output=json` CLI option (Edgar Ramírez Mondragón, PR [17611](https://github.com/python/mypy/pull/17611))
+ * Update various references to deprecated type aliases in docs (Jukka Lehtosalo, PR [17829](https://github.com/python/mypy/pull/17829))
+ * Make "X | Y" union syntax more prominent in documentation (Jukka Lehtosalo, PR [17835](https://github.com/python/mypy/pull/17835))
+ * Discuss upper bounds before self types in documentation (Jukka Lehtosalo, PR [17827](https://github.com/python/mypy/pull/17827))
+ * Make changelog visible in mypy documentation (quinn-sasha, PR [17742](https://github.com/python/mypy/pull/17742))
+ * List all incomplete features in `--enable-incomplete-feature` docs (sobolevn, PR [17633](https://github.com/python/mypy/pull/17633))
+ * Remove the explicit setting of a pygments theme (Pradyun Gedam, PR [17571](https://github.com/python/mypy/pull/17571))
+ * Document ReadOnly with TypedDict (Jukka Lehtosalo, PR [17905](https://github.com/python/mypy/pull/17905))
+ * Document TypeIs (Chelsea Durazo, PR [17821](https://github.com/python/mypy/pull/17821))
+
+### Experimental Inline TypedDict Syntax
+
+Mypy now supports a non-standard, experimental syntax for defining anonymous TypedDicts.
+Example:
+
+```python
+def func(n: str, y: int) -> {"name": str, "year": int}:
+    return {"name": n, "year": y}
+```
+
+The feature is disabled by default. Use `--enable-incomplete-feature=InlineTypedDict` to
+enable it. *We might remove this feature in a future release.*
+
+This feature was contributed by Ivan Levkivskyi (PR [17457](https://github.com/python/mypy/pull/17457)).
+
+### Stubgen Improvements
+
+ * Fix crash on literal class-level keywords (sobolevn, PR [17663](https://github.com/python/mypy/pull/17663))
+ * Stubgen add `--version` (sobolevn, PR [17662](https://github.com/python/mypy/pull/17662))
+ * Fix `stubgen --no-analysis/--parse-only` docs (sobolevn, PR [17632](https://github.com/python/mypy/pull/17632))
+ * Include keyword only args when generating signatures in stubgenc (Eric Mark Martin, PR [17448](https://github.com/python/mypy/pull/17448))
+ * Add support for detecting `Literal` types when extracting types from docstrings (Michael Carlstrom, PR [17441](https://github.com/python/mypy/pull/17441))
+ * Use `Generator` type var defaults (Sebastian Rittau, PR [17670](https://github.com/python/mypy/pull/17670))
+
+### Stubtest Improvements
+ * Add support for `cached_property` (Ali Hamdan, PR [17626](https://github.com/python/mypy/pull/17626))
+ * Add `enable_incomplete_feature` validation to `stubtest` (sobolevn, PR [17635](https://github.com/python/mypy/pull/17635))
+ * Fix error code handling in `stubtest` with `--mypy-config-file` (sobolevn, PR [17629](https://github.com/python/mypy/pull/17629))
+
+### Other Notables Fixes and Improvements
+
+ * Report error if using unsupported type parameter defaults (Jukka Lehtosalo, PR [17876](https://github.com/python/mypy/pull/17876))
+ * Fix re-processing cross-reference in mypy daemon when node kind changes (Ivan Levkivskyi, PR [17883](https://github.com/python/mypy/pull/17883))
+ * Don't use equality to narrow when value is IntEnum/StrEnum (Jukka Lehtosalo, PR [17866](https://github.com/python/mypy/pull/17866))
+ * Don't consider None vs IntEnum comparison ambiguous (Jukka Lehtosalo, PR [17877](https://github.com/python/mypy/pull/17877))
+ * Fix narrowing of IntEnum and StrEnum types (Jukka Lehtosalo, PR [17874](https://github.com/python/mypy/pull/17874))
+ * Filter overload items based on self type during type inference (Jukka Lehtosalo, PR [17873](https://github.com/python/mypy/pull/17873))
+ * Enable negative narrowing of union TypeVar upper bounds (Brian Schubert, PR [17850](https://github.com/python/mypy/pull/17850))
+ * Fix issue with member expression formatting (Brian Schubert, PR [17848](https://github.com/python/mypy/pull/17848))
+ * Avoid type size explosion when expanding types (Jukka Lehtosalo, PR [17842](https://github.com/python/mypy/pull/17842))
+ * Fix negative narrowing of tuples in match statement (Brian Schubert, PR [17817](https://github.com/python/mypy/pull/17817))
+ * Narrow falsey str/bytes/int to literal type (Brian Schubert, PR [17818](https://github.com/python/mypy/pull/17818))
+ * Test against latest Python 3.13, make testing 3.14 easy (Shantanu, PR [17812](https://github.com/python/mypy/pull/17812))
+ * Reject ParamSpec-typed callables calls with insufficient arguments (Stanislav Terliakov, PR [17323](https://github.com/python/mypy/pull/17323))
+ * Fix crash when passing too many type arguments to generic base class accepting single ParamSpec (Brian Schubert, PR [17770](https://github.com/python/mypy/pull/17770))
+ * Fix TypeVar upper bounds sometimes not being displayed in pretty callables (Brian Schubert, PR [17802](https://github.com/python/mypy/pull/17802))
+ * Added error code for overlapping function signatures (Katrina Connors, PR [17597](https://github.com/python/mypy/pull/17597))
+ * Check for `truthy-bool` in `not ...` unary expressions (sobolevn, PR [17773](https://github.com/python/mypy/pull/17773))
+ * Add missing lines-covered and lines-valid attributes (Soubhik Kumar Mitra, PR [17738](https://github.com/python/mypy/pull/17738))
+ * Fix another crash scenario with recursive tuple types (Ivan Levkivskyi, PR [17708](https://github.com/python/mypy/pull/17708))
+ * Resolve TypeVar upper bounds in `functools.partial` (Shantanu, PR [17660](https://github.com/python/mypy/pull/17660))
+ * Always reset binder when checking deferred nodes (Ivan Levkivskyi, PR [17643](https://github.com/python/mypy/pull/17643))
+ * Fix crash on a callable attribute with single unpack (Ivan Levkivskyi, PR [17641](https://github.com/python/mypy/pull/17641))
+ * Fix mismatched signature between checker plugin API and implementation (bzoracler, PR [17343](https://github.com/python/mypy/pull/17343))
+ * Indexing a type also produces a GenericAlias (Shantanu, PR [17546](https://github.com/python/mypy/pull/17546))
+ * Fix crash on self-type in callable protocol (Ivan Levkivskyi, PR [17499](https://github.com/python/mypy/pull/17499))
+ * Fix crash on NamedTuple with method and error in function (Ivan Levkivskyi, PR [17498](https://github.com/python/mypy/pull/17498))
+ * Add `__replace__` for dataclasses in 3.13 (Max Muoto, PR [17469](https://github.com/python/mypy/pull/17469))
+ * Fix help message for `--no-namespace-packages` (Raphael Krupinski, PR [17472](https://github.com/python/mypy/pull/17472))
+ * Fix typechecking for async generators (Danny Yang, PR [17452](https://github.com/python/mypy/pull/17452))
+ * Fix strict optional handling in attrs plugin (Ivan Levkivskyi, PR [17451](https://github.com/python/mypy/pull/17451))
+ * Allow mixing ParamSpec and TypeVarTuple in Generic (Ivan Levkivskyi, PR [17450](https://github.com/python/mypy/pull/17450))
+ * Improvements to `functools.partial` of types (Shantanu, PR [17898](https://github.com/python/mypy/pull/17898))
+ * Make ReadOnly TypedDict items covariant (Jukka Lehtosalo, PR [17904](https://github.com/python/mypy/pull/17904))
+ * Fix union callees with `functools.partial` (Jukka Lehtosalo, PR [17903](https://github.com/python/mypy/pull/17903))
+ * Improve handling of generic functions with `functools.partial` (Ivan Levkivskyi, PR [17925](https://github.com/python/mypy/pull/17925))
+
+### Typeshed Updates
+
+Please see [git log](https://github.com/python/typeshed/commits/main?after=91a58b07cdd807b1d965e04ba85af2adab8bf924+0&branch=main&path=stdlib) for full list of standard library typeshed stub changes.
+
+### Mypy 1.12.1
+ * Fix crash when showing partially analyzed type in error message (Ivan Levkivskyi, PR [17961](https://github.com/python/mypy/pull/17961))
+ * Fix iteration over union (when self type is involved) (Shantanu, PR [17976](https://github.com/python/mypy/pull/17976))
+ * Fix type object with type var default in union context (Jukka Lehtosalo, PR [17991](https://github.com/python/mypy/pull/17991))
+ * Revert change to `os.path` stubs affecting use of `os.PathLike[Any]` (Shantanu, PR [17995](https://github.com/python/mypy/pull/17995))
+
+### Acknowledgements
+Thanks to all mypy contributors who contributed to this release:
+
+- Ali Hamdan
+- Anders Kaseorg
+- Bénédikt Tran
+- Brian Schubert
+- bzoracler
+- Chelsea Durazo
+- Danny Yang
+- Edgar Ramírez Mondragón
+- Eric Mark Martin
+- InSync
+- Ivan Levkivskyi
+- Jordandev678
+- Katrina Connors
+- Kirill Podoprigora
+- Marc Mueller
+- Max Muoto
+- Max Murin
+- Michael Carlstrom
+- Michael I Chen
+- Pradyun Gedam
+- quinn-sasha
+- Raphael Krupinski
+- Sebastian Rittau
+- Shantanu
+- sobolevn
+- Soubhik Kumar Mitra
+- Stanislav Terliakov
+- wyattscarpenter
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+
+## Mypy 1.11
+
+We’ve just uploaded mypy 1.11 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Support Python 3.12 Syntax for Generics (PEP 695)
+
+Mypy now supports the new type parameter syntax introduced in Python 3.12 ([PEP 695](https://peps.python.org/pep-0695/)).
+This feature is still experimental and must be enabled with the `--enable-incomplete-feature=NewGenericSyntax` flag, or with `enable_incomplete_feature = NewGenericSyntax` in the mypy configuration file.
+We plan to enable this by default in the next mypy feature release.
+
+This example demonstrates the new syntax:
+
+```python
+# Generic function
+def f[T](x: T) -> T: ...
+
+reveal_type(f(1))  # Revealed type is 'int'
+
+# Generic class
+class C[T]:
+    def __init__(self, x: T) -> None:
+       self.x = x
+
+c = C('a')
+reveal_type(c.x)  # Revealed type is 'str'
+
+# Type alias
+type A[T] = C[list[T]]
+```
+
+This feature was contributed by Jukka Lehtosalo.
+
+
+### Support for `functools.partial`
+
+Mypy now type checks uses of `functools.partial`. Previously mypy would accept arbitrary arguments.
+
+This example will now produce an error:
+
+```python
+from functools import partial
+
+def f(a: int, b: str) -> None: ...
+
+g = partial(f, 1)
+
+# Argument has incompatible type "int"; expected "str"
+g(11)
+```
+
+This feature was contributed by Shantanu (PR [16939](https://github.com/python/mypy/pull/16939)).
+
+
+### Stricter Checks for Untyped Overrides
+
+Past mypy versions didn't check if untyped methods were compatible with overridden methods. This would result in false negatives. Now mypy performs these checks when using `--check-untyped-defs`.
+
+For example, this now generates an error if using `--check-untyped-defs`:
+
+```python
+class Base:
+    def f(self, x: int = 0) -> None: ...
+
+class Derived(Base):
+    # Signature incompatible with "Base"
+    def f(self): ...
+```
+
+This feature was contributed by Steven Troxler (PR [17276](https://github.com/python/mypy/pull/17276)).
+
+
+### Type Inference Improvements
+
+The new polymorphic inference algorithm introduced in mypy 1.5 is now used in more situations. This improves type inference involving generic higher-order functions, in particular.
+
+This feature was contributed by Ivan Levkivskyi (PR [17348](https://github.com/python/mypy/pull/17348)).
+
+Mypy now uses unions of tuple item types in certain contexts to enable more precise inferred types. Example:
+
+```python
+for x in (1, 'x'):
+    # Previously inferred as 'object'
+    reveal_type(x)  # Revealed type is 'int | str'
+```
+
+This was also contributed by Ivan Levkivskyi (PR [17408](https://github.com/python/mypy/pull/17408)).
+
+
+### Improvements to Detection of Overlapping Overloads
+
+The details of how mypy checks if two `@overload` signatures are unsafely overlapping were overhauled. This both fixes some false positives, and allows mypy to detect additional unsafe signatures.
+
+This feature was contributed by Ivan Levkivskyi (PR [17392](https://github.com/python/mypy/pull/17392)).
+
+
+### Better Support for Type Hints in Expressions
+
+Mypy now allows more expressions that evaluate to valid type annotations in all expression contexts. The inferred types of these expressions are also sometimes more precise. Previously they were often `object`.
+
+This example uses a union type that includes a callable type as an expression, and it no longer generates an error:
+
+```python
+from typing import Callable
+
+print(Callable[[], int] | None)  # No error
+```
+
+This feature was contributed by Jukka Lehtosalo (PR [17404](https://github.com/python/mypy/pull/17404)).
+
+
+### Mypyc Improvements
+
+Mypyc now supports the new syntax for generics introduced in Python 3.12 (see above). Another notable improvement is significantly faster basic operations on `int` values.
+
+ * Support Python 3.12 syntax for generic functions and classes (Jukka Lehtosalo, PR [17357](https://github.com/python/mypy/pull/17357))
+ * Support Python 3.12 type alias syntax (Jukka Lehtosalo, PR [17384](https://github.com/python/mypy/pull/17384))
+ * Fix ParamSpec (Shantanu, PR [17309](https://github.com/python/mypy/pull/17309))
+ * Inline fast paths of integer unboxing operations (Jukka Lehtosalo, PR [17266](https://github.com/python/mypy/pull/17266))
+ * Inline tagged integer arithmetic and bitwise operations (Jukka Lehtosalo, PR [17265](https://github.com/python/mypy/pull/17265))
+ * Allow specifying primitives as pure (Jukka Lehtosalo, PR [17263](https://github.com/python/mypy/pull/17263))
+
+
+### Changes to Stubtest
+ * Ignore `_ios_support` (Alex Waygood, PR [17270](https://github.com/python/mypy/pull/17270))
+ * Improve support for Python 3.13 (Shantanu, PR [17261](https://github.com/python/mypy/pull/17261))
+
+
+### Changes to Stubgen
+ * Gracefully handle invalid `Optional` and recognize aliases to PEP 604 unions (Ali Hamdan, PR [17386](https://github.com/python/mypy/pull/17386))
+ * Fix for Python 3.13 (Jelle Zijlstra, PR [17290](https://github.com/python/mypy/pull/17290))
+ * Preserve enum value initialisers (Shantanu, PR [17125](https://github.com/python/mypy/pull/17125))
+
+
+### Miscellaneous New Features
+ * Add error format support and JSON output option via `--output json` (Tushar Sadhwani, PR [11396](https://github.com/python/mypy/pull/11396))
+ * Support `enum.member` in Python 3.11+ (Nikita Sobolev, PR [17382](https://github.com/python/mypy/pull/17382))
+ * Support `enum.nonmember` in Python 3.11+ (Nikita Sobolev, PR [17376](https://github.com/python/mypy/pull/17376))
+ * Support `namedtuple.__replace__` in Python 3.13 (Shantanu, PR [17259](https://github.com/python/mypy/pull/17259))
+ * Support `rename=True` in collections.namedtuple (Jelle Zijlstra, PR [17247](https://github.com/python/mypy/pull/17247))
+ * Add support for `__spec__` (Shantanu, PR [14739](https://github.com/python/mypy/pull/14739))
+
+
+### Changes to Error Reporting
+ * Mention `--enable-incomplete-feature=NewGenericSyntax` in messages (Shantanu, PR [17462](https://github.com/python/mypy/pull/17462))
+ * Do not report plugin-generated methods with `explicit-override` (sobolevn, PR [17433](https://github.com/python/mypy/pull/17433))
+ * Use and display namespaces for function type variables (Ivan Levkivskyi, PR [17311](https://github.com/python/mypy/pull/17311))
+ * Fix false positive for Final local scope variable in Protocol (GiorgosPapoutsakis, PR [17308](https://github.com/python/mypy/pull/17308))
+ * Use Never in more messages, use ambiguous in join (Shantanu, PR [17304](https://github.com/python/mypy/pull/17304))
+ * Log full path to config file in verbose output (dexterkennedy, PR [17180](https://github.com/python/mypy/pull/17180))
+ * Added `[prop-decorator]` code for unsupported property decorators (#14461) (Christopher Barber, PR [16571](https://github.com/python/mypy/pull/16571))
+ * Suppress second error message with `:=` and `[truthy-bool]` (Nikita Sobolev, PR [15941](https://github.com/python/mypy/pull/15941))
+ * Generate error for assignment of functional Enum to variable of different name (Shantanu, PR [16805](https://github.com/python/mypy/pull/16805))
+ * Fix error reporting on cached run after uninstallation of third party library (Shantanu, PR [17420](https://github.com/python/mypy/pull/17420))
+
+
+### Fixes for Crashes
+ * Fix daemon crash on invalid type in TypedDict (Ivan Levkivskyi, PR [17495](https://github.com/python/mypy/pull/17495))
+ * Fix crash and bugs related to `partial()` (Ivan Levkivskyi, PR [17423](https://github.com/python/mypy/pull/17423))
+ * Fix crash when overriding with unpacked TypedDict (Ivan Levkivskyi, PR [17359](https://github.com/python/mypy/pull/17359))
+ * Fix crash on TypedDict unpacking for ParamSpec (Ivan Levkivskyi, PR [17358](https://github.com/python/mypy/pull/17358))
+ * Fix crash involving recursive union of tuples (Ivan Levkivskyi, PR [17353](https://github.com/python/mypy/pull/17353))
+ * Fix crash on invalid callable property override (Ivan Levkivskyi, PR [17352](https://github.com/python/mypy/pull/17352))
+ * Fix crash on unpacking self in NamedTuple (Ivan Levkivskyi, PR [17351](https://github.com/python/mypy/pull/17351))
+ * Fix crash on recursive alias with an optional type (Ivan Levkivskyi, PR [17350](https://github.com/python/mypy/pull/17350))
+ * Fix crash on type comment inside generic definitions (Bénédikt Tran, PR [16849](https://github.com/python/mypy/pull/16849))
+
+
+### Changes to Documentation
+ * Use inline config in documentation for optional error codes (Shantanu, PR [17374](https://github.com/python/mypy/pull/17374))
+ * Use lower-case generics in documentation (Seo Sanghyeon, PR [17176](https://github.com/python/mypy/pull/17176))
+ * Add documentation for show-error-code-links (GiorgosPapoutsakis, PR [17144](https://github.com/python/mypy/pull/17144))
+ * Update CONTRIBUTING.md to include commands for Windows (GiorgosPapoutsakis, PR [17142](https://github.com/python/mypy/pull/17142))
+
+
+### Other Notable Improvements and Fixes
+ * Fix ParamSpec inference against TypeVarTuple (Ivan Levkivskyi, PR [17431](https://github.com/python/mypy/pull/17431))
+ * Fix explicit type for `partial` (Ivan Levkivskyi, PR [17424](https://github.com/python/mypy/pull/17424))
+ * Always allow lambda calls (Ivan Levkivskyi, PR [17430](https://github.com/python/mypy/pull/17430))
+ * Fix isinstance checks with PEP 604 unions containing None (Shantanu, PR [17415](https://github.com/python/mypy/pull/17415))
+ * Fix self-referential upper bound in new-style type variables (Ivan Levkivskyi, PR [17407](https://github.com/python/mypy/pull/17407))
+ * Consider overlap between instances and callables (Ivan Levkivskyi, PR [17389](https://github.com/python/mypy/pull/17389))
+ * Allow new-style self-types in classmethods (Ivan Levkivskyi, PR [17381](https://github.com/python/mypy/pull/17381))
+ * Fix isinstance with type aliases to PEP 604 unions (Shantanu, PR [17371](https://github.com/python/mypy/pull/17371))
+ * Properly handle unpacks in overlap checks (Ivan Levkivskyi, PR [17356](https://github.com/python/mypy/pull/17356))
+ * Fix type application for classes with generic constructors (Ivan Levkivskyi, PR [17354](https://github.com/python/mypy/pull/17354))
+ * Update `typing_extensions` to >=4.6.0 to fix Python 3.12 error (Ben Brown, PR [17312](https://github.com/python/mypy/pull/17312))
+ * Avoid "does not return" error in lambda (Shantanu, PR [17294](https://github.com/python/mypy/pull/17294))
+ * Fix bug with descriptors in non-strict-optional mode (Max Murin, PR [17293](https://github.com/python/mypy/pull/17293))
+ * Don’t leak unreachability from lambda body to surrounding scope (Anders Kaseorg, PR [17287](https://github.com/python/mypy/pull/17287))
+ * Fix issues with non-ASCII characters on Windows (Alexander Leopold Shon, PR [17275](https://github.com/python/mypy/pull/17275))
+ * Fix for type narrowing of negative integer literals (gilesgc, PR [17256](https://github.com/python/mypy/pull/17256))
+ * Fix confusion between .py and .pyi files in mypy daemon (Valentin Stanciu, PR [17245](https://github.com/python/mypy/pull/17245))
+ * Fix type of `tuple[X, Y]` expression (urnest, PR [17235](https://github.com/python/mypy/pull/17235))
+ * Don't forget that a `TypedDict` was wrapped in `Unpack` after a `name-defined` error occurred (Christoph Tyralla, PR [17226](https://github.com/python/mypy/pull/17226))
+ * Mark annotated argument as having an explicit, not inferred type (bzoracler, PR [17217](https://github.com/python/mypy/pull/17217))
+ * Don't consider Enum private attributes as enum members (Ali Hamdan, PR [17182](https://github.com/python/mypy/pull/17182))
+ * Fix Literal strings containing pipe characters (Jelle Zijlstra, PR [17148](https://github.com/python/mypy/pull/17148))
+
+
+### Typeshed Updates
+
+Please see [git log](https://github.com/python/typeshed/commits/main?after=6dda799d8ad1d89e0f8aad7ac41d2d34bd838ace+0&branch=main&path=stdlib) for full list of standard library typeshed stub changes.
+
+### Mypy 1.11.1
+ * Fix `RawExpressionType.accept` crash with `--cache-fine-grained` (Anders Kaseorg, PR [17588](https://github.com/python/mypy/pull/17588))
+ * Fix PEP 604 isinstance caching (Shantanu, PR [17563](https://github.com/python/mypy/pull/17563))
+ * Fix `typing.TypeAliasType` being undefined on python < 3.12 (Nikita Sobolev, PR [17558](https://github.com/python/mypy/pull/17558))
+ * Fix `types.GenericAlias` lookup crash (Shantanu, PR [17543](https://github.com/python/mypy/pull/17543))
+
+### Mypy 1.11.2
+ * Alternative fix for a union-like literal string (Ivan Levkivskyi, PR [17639](https://github.com/python/mypy/pull/17639))
+ * Unwrap `TypedDict` item types before storing (Ivan Levkivskyi, PR [17640](https://github.com/python/mypy/pull/17640))
+
+### Acknowledgements
+Thanks to all mypy contributors who contributed to this release:
+
+- Alex Waygood
+- Alexander Leopold Shon
+- Ali Hamdan
+- Anders Kaseorg
+- Ben Brown
+- Bénédikt Tran
+- bzoracler
+- Christoph Tyralla
+- Christopher Barber
+- dexterkennedy
+- gilesgc
+- GiorgosPapoutsakis
+- Ivan Levkivskyi
+- Jelle Zijlstra
+- Jukka Lehtosalo
+- Marc Mueller
+- Matthieu Devlin
+- Michael R. Crusoe
+- Nikita Sobolev
+- Seo Sanghyeon
+- Shantanu
+- sobolevn
+- Steven Troxler
+- Tadeu Manoel
+- Tamir Duberstein
+- Tushar Sadhwani
+- urnest
+- Valentin Stanciu
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+
+## Mypy 1.10
+
+We’ve just uploaded mypy 1.10 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Support TypeIs (PEP 742)
+
+Mypy now supports `TypeIs` ([PEP 742](https://peps.python.org/pep-0742/)), which allows
+functions to narrow the type of a value, similar to `isinstance()`. Unlike `TypeGuard`,
+`TypeIs` can narrow in both the `if` and `else` branches of an if statement:
+
+```python
+from typing_extensions import TypeIs
+
+def is_str(s: object) -> TypeIs[str]:
+    return isinstance(s, str)
+
+def f(o: str | int) -> None:
+    if is_str(o):
+        # Type of o is 'str'
+        ...
+    else:
+        # Type of o is 'int'
+        ...
+```
+
+`TypeIs` will be added to the `typing` module in Python 3.13, but it
+can be used on earlier Python versions by importing it from
+`typing_extensions`.
+
+This feature was contributed by Jelle Zijlstra (PR [16898](https://github.com/python/mypy/pull/16898)).
+
+### Support TypeVar Defaults (PEP 696)
+
+[PEP 696](https://peps.python.org/pep-0696/) adds support for type parameter defaults.
+Example:
+
+```python
+from typing import Generic
+from typing_extensions import TypeVar
+
+T = TypeVar("T", default=int)
+
+class C(Generic[T]):
+   ...
+
+x: C = ...
+y: C[str] = ...
+reveal_type(x)  # C[int], because of the default
+reveal_type(y)  # C[str]
+```
+
+TypeVar defaults will be added to the `typing` module in Python 3.13, but they
+can be used with earlier Python releases by importing `TypeVar` from
+`typing_extensions`.
+
+This feature was contributed by Marc Mueller (PR [16878](https://github.com/python/mypy/pull/16878)
+and PR [16925](https://github.com/python/mypy/pull/16925)).
+
+### Support TypeAliasType (PEP 695)
+As part of the initial steps towards implementing [PEP 695](https://peps.python.org/pep-0695/), mypy now supports `TypeAliasType`.
+`TypeAliasType` provides a backport of the new `type` statement in Python 3.12.
+
+```python
+type ListOrSet[T] = list[T] | set[T]
+```
+
+is equivalent to:
+
+```python
+T = TypeVar("T")
+ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,))
+```
+
+Example of use in mypy:
+
+```python
+from typing_extensions import TypeAliasType, TypeVar
+
+NewUnionType = TypeAliasType("NewUnionType", int | str)
+x: NewUnionType = 42
+y: NewUnionType = 'a'
+z: NewUnionType = object()  # error: Incompatible types in assignment (expression has type "object", variable has type "int | str")  [assignment]
+
+T = TypeVar("T")
+ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,))
+a: ListOrSet[int] = [1, 2]
+b: ListOrSet[str] = {'a', 'b'}
+c: ListOrSet[str] = 'test'  # error: Incompatible types in assignment (expression has type "str", variable has type "list[str] | set[str]")  [assignment]
+```
+
+`TypeAliasType` was added to the `typing` module in Python 3.12, but it can be used with earlier Python releases by importing from `typing_extensions`.
+
+This feature was contributed by Ali Hamdan (PR [16926](https://github.com/python/mypy/pull/16926), PR [17038](https://github.com/python/mypy/pull/17038) and PR [17053](https://github.com/python/mypy/pull/17053))
+
+### Detect Additional Unsafe Uses of super()
+
+Mypy will reject unsafe uses of `super()` more consistently, when the target has a
+trivial (empty) body. Example:
+
+```python
+class Proto(Protocol):
+    def method(self) -> int: ...
+
+class Sub(Proto):
+    def method(self) -> int:
+        return super().meth()  # Error (unsafe)
+```
+
+This feature was contributed by Shantanu (PR [16756](https://github.com/python/mypy/pull/16756)).
+
+### Stubgen Improvements
+- Preserve empty tuple annotation (Ali Hamdan, PR [16907](https://github.com/python/mypy/pull/16907))
+- Add support for PEP 570 positional-only parameters (Ali Hamdan, PR [16904](https://github.com/python/mypy/pull/16904))
+- Replace obsolete typing aliases with builtin containers (Ali Hamdan, PR [16780](https://github.com/python/mypy/pull/16780))
+- Fix generated dataclass `__init__` signature (Ali Hamdan, PR [16906](https://github.com/python/mypy/pull/16906))
+
+### Mypyc Improvements
+
+- Provide an easier way to define IR-to-IR transforms (Jukka Lehtosalo, PR [16998](https://github.com/python/mypy/pull/16998))
+- Implement lowering pass and add primitives for int (in)equality (Jukka Lehtosalo, PR [17027](https://github.com/python/mypy/pull/17027))
+- Implement lowering for remaining tagged integer comparisons (Jukka Lehtosalo, PR [17040](https://github.com/python/mypy/pull/17040))
+- Optimize away some bool/bit registers (Jukka Lehtosalo, PR [17022](https://github.com/python/mypy/pull/17022))
+- Remangle redefined names produced by async with (Richard Si, PR [16408](https://github.com/python/mypy/pull/16408))
+- Optimize TYPE_CHECKING to False at Runtime (Srinivas Lade, PR [16263](https://github.com/python/mypy/pull/16263))
+- Fix compilation of unreachable comprehensions (Richard Si, PR [15721](https://github.com/python/mypy/pull/15721))
+- Don't crash on non-inlinable final local reads (Richard Si, PR [15719](https://github.com/python/mypy/pull/15719))
+
+### Documentation Improvements
+- Import `TypedDict` from `typing` instead of `typing_extensions` (Riccardo Di Maio, PR [16958](https://github.com/python/mypy/pull/16958))
+- Add missing `mutable-override` to section title (James Braza, PR [16886](https://github.com/python/mypy/pull/16886))
+
+### Error Reporting Improvements
+
+- Use lower-case generics more consistently in error messages (Jukka Lehtosalo, PR [17035](https://github.com/python/mypy/pull/17035))
+
+### Other Notable Changes and Fixes
+- Fix incorrect inferred type when accessing descriptor on union type (Matthieu Devlin, PR [16604](https://github.com/python/mypy/pull/16604))
+- Fix crash when expanding invalid `Unpack` in a `Callable` alias (Ali Hamdan, PR [17028](https://github.com/python/mypy/pull/17028))
+- Fix false positive when string formatting with string enum (roberfi, PR [16555](https://github.com/python/mypy/pull/16555))
+- Narrow individual items when matching a tuple to a sequence pattern (Loïc Simon, PR [16905](https://github.com/python/mypy/pull/16905))
+- Fix false positive from type variable within TypeGuard or TypeIs (Evgeniy Slobodkin, PR [17071](https://github.com/python/mypy/pull/17071))
+- Improve `yield from` inference for unions of generators (Shantanu, PR [16717](https://github.com/python/mypy/pull/16717))
+- Fix emulating hash method logic in `attrs` classes (Hashem, PR [17016](https://github.com/python/mypy/pull/17016))
+- Add reverted typeshed commit that uses `ParamSpec` for `functools.wraps` (Tamir Duberstein, PR [16942](https://github.com/python/mypy/pull/16942))
+- Fix type narrowing for `types.EllipsisType` (Shantanu, PR [17003](https://github.com/python/mypy/pull/17003))
+- Fix single item enum match type exhaustion (Oskari Lehto, PR [16966](https://github.com/python/mypy/pull/16966))
+- Improve type inference with empty collections (Marc Mueller, PR [16994](https://github.com/python/mypy/pull/16994))
+- Fix override checking for decorated property (Shantanu, PR [16856](https://github.com/python/mypy/pull/16856))
+- Fix narrowing on match with function subject (Edward Paget, PR [16503](https://github.com/python/mypy/pull/16503))
+- Allow `+N` within `Literal[...]` (Spencer Brown, PR [16910](https://github.com/python/mypy/pull/16910))
+- Experimental: Support TypedDict within `type[...]` (Marc Mueller, PR [16963](https://github.com/python/mypy/pull/16963))
+- Experimtental: Fix issue with TypedDict with optional keys in `type[...]` (Marc Mueller, PR [17068](https://github.com/python/mypy/pull/17068))
+
+### Typeshed Updates
+
+Please see [git log](https://github.com/python/typeshed/commits/main?after=6dda799d8ad1d89e0f8aad7ac41d2d34bd838ace+0&branch=main&path=stdlib) for full list of standard library typeshed stub changes.
+
+### Mypy 1.10.1
+
+- Fix error reporting on cached run after uninstallation of third party library (Shantanu, PR [17420](https://github.com/python/mypy/pull/17420))
+
+### Acknowledgements
+Thanks to all mypy contributors who contributed to this release:
+
+- Alex Waygood
+- Ali Hamdan
+- Edward Paget
+- Evgeniy Slobodkin
+- Hashem
+- hesam
+- Hugo van Kemenade
+- Ihor
+- James Braza
+- Jelle Zijlstra
+- jhance
+- Jukka Lehtosalo
+- Loïc Simon
+- Marc Mueller
+- Matthieu Devlin
+- Michael R. Crusoe
+- Nikita Sobolev
+- Oskari Lehto
+- Riccardo Di Maio
+- Richard Si
+- roberfi
+- Roman Solomatin
+- Sam Xifaras
+- Shantanu
+- Spencer Brown
+- Srinivas Lade
+- Tamir Duberstein
+- youkaichao
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+
+## Mypy 1.9
+
+We’ve just uploaded mypy 1.9 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Breaking Changes
+
+Because the version of typeshed we use in mypy 1.9 doesn't support 3.7, neither does mypy 1.9. (Jared Hance, PR [16883](https://github.com/python/mypy/pull/16883))
+
+We are planning to enable
+[local partial types](https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-local-partial-types) (enabled via the
+`--local-partial-types` flag) later this year by default. This change
+was announced years ago, but now it's finally happening. This is a
+major backward-incompatible change, so we'll probably include it as
+part of the upcoming mypy 2.0 release. This makes daemon and
+non-daemon mypy runs have the same behavior by default.
+
+Local partial types can also be enabled in the mypy config file:
+```
+local_partial_types = True
+```
+
+We are looking at providing a tool to make it easier to migrate
+projects to use `--local-partial-types`, but it's not yet clear whether
+this is practical. The migration usually involves adding some
+explicit type annotations to module-level and class-level variables.
+
+### Basic Support for Type Parameter Defaults (PEP 696)
+
+This release contains new experimental support for type parameter
+defaults ([PEP 696](https://peps.python.org/pep-0696)). Please try it
+out! This feature was contributed by Marc Mueller.
+
+Since this feature will be officially introduced in the next Python
+feature release (3.13), you will need to import `TypeVar`, `ParamSpec`
+or `TypeVarTuple` from `typing_extensions` to use defaults for now.
+
+This example adapted from the PEP defines a default for `BotT`:
+```python
+from typing import Generic
+from typing_extensions import TypeVar
+
+class Bot: ...
+
+BotT = TypeVar("BotT", bound=Bot, default=Bot)
+
+class Context(Generic[BotT]):
+    bot: BotT
+
+class MyBot(Bot): ...
+
+# type is Bot (the default)
+reveal_type(Context().bot)
+# type is MyBot
+reveal_type(Context[MyBot]().bot)
+```
+
+### Type-checking Improvements
+ * Fix missing type store for overloads (Marc Mueller, PR [16803](https://github.com/python/mypy/pull/16803))
+ * Fix `'WriteToConn' object has no attribute 'flush'` (Charlie Denton, PR [16801](https://github.com/python/mypy/pull/16801))
+ * Improve TypeAlias error messages (Marc Mueller, PR [16831](https://github.com/python/mypy/pull/16831))
+ * Support narrowing unions that include `type[None]` (Christoph Tyralla, PR [16315](https://github.com/python/mypy/pull/16315))
+ * Support TypedDict functional syntax as class base type (anniel-stripe, PR [16703](https://github.com/python/mypy/pull/16703))
+ * Accept multiline quoted annotations (Shantanu, PR [16765](https://github.com/python/mypy/pull/16765))
+ * Allow unary + in `Literal` (Jelle Zijlstra, PR [16729](https://github.com/python/mypy/pull/16729))
+ * Substitute type variables in return type of static methods (Kouroche Bouchiat, PR [16670](https://github.com/python/mypy/pull/16670))
+ * Consider TypeVarTuple to be invariant (Marc Mueller, PR [16759](https://github.com/python/mypy/pull/16759))
+ * Add `alias` support to `field()` in `attrs` plugin (Nikita Sobolev, PR [16610](https://github.com/python/mypy/pull/16610))
+ * Improve attrs hashability detection (Tin Tvrtković, PR [16556](https://github.com/python/mypy/pull/16556))
+
+### Performance Improvements
+
+ * Speed up finding function type variables (Jukka Lehtosalo, PR [16562](https://github.com/python/mypy/pull/16562))
+
+### Documentation Updates
+
+ * Document supported values for `--enable-incomplete-feature` in "mypy --help" (Froger David, PR [16661](https://github.com/python/mypy/pull/16661))
+ * Update new type system discussion links (thomaswhaley, PR [16841](https://github.com/python/mypy/pull/16841))
+ * Add missing class instantiation to cheat sheet (Aleksi Tarvainen, PR [16817](https://github.com/python/mypy/pull/16817))
+ * Document how evil `--no-strict-optional` is (Shantanu, PR [16731](https://github.com/python/mypy/pull/16731))
+ * Improve mypy daemon documentation note about local partial types (Makonnen Makonnen, PR [16782](https://github.com/python/mypy/pull/16782))
+ * Fix numbering error (Stefanie Molin, PR [16838](https://github.com/python/mypy/pull/16838))
+ * Various documentation improvements (Shantanu, PR [16836](https://github.com/python/mypy/pull/16836))
+
+### Stubtest Improvements
+ * Ignore private function/method parameters when they are missing from the stub (private parameter names start with a single underscore and have a default) (PR [16507](https://github.com/python/mypy/pull/16507))
+ * Ignore a new protocol dunder (Alex Waygood, PR [16895](https://github.com/python/mypy/pull/16895))
+ * Private parameters can be omitted (Sebastian Rittau, PR [16507](https://github.com/python/mypy/pull/16507))
+ * Add support for setting enum members to "..." (Jelle Zijlstra, PR [16807](https://github.com/python/mypy/pull/16807))
+ * Adjust symbol table logic (Shantanu, PR [16823](https://github.com/python/mypy/pull/16823))
+ * Fix posisitional-only handling in overload resolution (Shantanu, PR [16750](https://github.com/python/mypy/pull/16750))
+
+### Stubgen Improvements
+ * Fix crash on star unpack of TypeVarTuple (Ali Hamdan, PR [16869](https://github.com/python/mypy/pull/16869))
+ * Use PEP 604 unions everywhere (Ali Hamdan, PR [16519](https://github.com/python/mypy/pull/16519))
+ * Do not ignore property deleter (Ali Hamdan, PR [16781](https://github.com/python/mypy/pull/16781))
+ * Support type stub generation for `staticmethod` (WeilerMarcel, PR [14934](https://github.com/python/mypy/pull/14934))
+
+### Acknowledgements
+
+​Thanks to all mypy contributors who contributed to this release:
+
+- Aleksi Tarvainen
+- Alex Waygood
+- Ali Hamdan
+- anniel-stripe
+- Charlie Denton
+- Christoph Tyralla
+- Dheeraj
+- Fabian Keller
+- Fabian Lewis
+- Froger David
+- Ihor
+- Jared Hance
+- Jelle Zijlstra
+- Jukka Lehtosalo
+- Kouroche Bouchiat
+- Lukas Geiger
+- Maarten Huijsmans
+- Makonnen Makonnen
+- Marc Mueller
+- Nikita Sobolev
+- Sebastian Rittau
+- Shantanu
+- Stefanie Molin
+- Stephen Morton
+- thomaswhaley
+- Tin Tvrtković
+- WeilerMarcel
+- Wesley Collin Wright
+- zipperer
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+## Mypy 1.8
+
+We’ve just uploaded mypy 1.8 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Type-checking Improvements
+ * Do not intersect types in isinstance checks if at least one is final (Christoph Tyralla, PR [16330](https://github.com/python/mypy/pull/16330))
+ * Detect that `@final` class without `__bool__` cannot have falsey instances (Ilya Priven, PR [16566](https://github.com/python/mypy/pull/16566))
+ * Do not allow `TypedDict` classes with extra keywords (Nikita Sobolev, PR [16438](https://github.com/python/mypy/pull/16438))
+ * Do not allow class-level keywords for `NamedTuple` (Nikita Sobolev, PR [16526](https://github.com/python/mypy/pull/16526))
+ * Make imprecise constraints handling more robust (Ivan Levkivskyi, PR [16502](https://github.com/python/mypy/pull/16502))
+ * Fix strict-optional in extending generic TypedDict (Ivan Levkivskyi, PR [16398](https://github.com/python/mypy/pull/16398))
+ * Allow type ignores of PEP 695 constructs (Shantanu, PR [16608](https://github.com/python/mypy/pull/16608))
+ * Enable `type_check_only` support for `TypedDict` and `NamedTuple` (Nikita Sobolev, PR [16469](https://github.com/python/mypy/pull/16469))
+
+### Performance Improvements
+ * Add fast path to analyzing special form assignments (Jukka Lehtosalo, PR [16561](https://github.com/python/mypy/pull/16561))
+
+### Improvements to Error Reporting
+ * Don't show documentation links for plugin error codes (Ivan Levkivskyi, PR [16383](https://github.com/python/mypy/pull/16383))
+ * Improve error messages for `super` checks and add more tests (Nikita Sobolev, PR [16393](https://github.com/python/mypy/pull/16393))
+ * Add error code for mutable covariant override (Ivan Levkivskyi, PR [16399](https://github.com/python/mypy/pull/16399))
+
+### Stubgen Improvements
+ * Preserve simple defaults in function signatures (Ali Hamdan, PR [15355](https://github.com/python/mypy/pull/15355))
+ * Include `__all__` in output (Jelle Zijlstra, PR [16356](https://github.com/python/mypy/pull/16356))
+ * Fix stubgen regressions with pybind11 and mypy 1.7 (Chad Dombrova, PR [16504](https://github.com/python/mypy/pull/16504))
+
+### Stubtest Improvements
+ * Improve handling of unrepresentable defaults (Jelle Zijlstra, PR [16433](https://github.com/python/mypy/pull/16433))
+ * Print more helpful errors if a function is missing from stub (Alex Waygood, PR [16517](https://github.com/python/mypy/pull/16517))
+ * Support `@type_check_only` decorator (Nikita Sobolev, PR [16422](https://github.com/python/mypy/pull/16422))
+ * Warn about missing `__del__` (Shantanu, PR [16456](https://github.com/python/mypy/pull/16456))
+ * Fix crashes with some uses of `final` and `deprecated` (Shantanu, PR [16457](https://github.com/python/mypy/pull/16457))
+
+### Fixes to Crashes
+ * Fix crash with type alias to `Callable[[Unpack[Tuple[Any, ...]]], Any]` (Alex Waygood, PR [16541](https://github.com/python/mypy/pull/16541))
+ * Fix crash on TypeGuard in `__call__` (Ivan Levkivskyi, PR [16516](https://github.com/python/mypy/pull/16516))
+ * Fix crash on invalid enum in method (Ivan Levkivskyi, PR [16511](https://github.com/python/mypy/pull/16511))
+ * Fix crash on unimported Any in TypedDict (Ivan Levkivskyi, PR [16510](https://github.com/python/mypy/pull/16510))
+
+### Documentation Updates
+ * Update soft-error-limit default value to -1 (Sveinung Gundersen, PR [16542](https://github.com/python/mypy/pull/16542))
+ * Support Sphinx 7.x (Michael R. Crusoe, PR [16460](https://github.com/python/mypy/pull/16460))
+
+### Other Notable Changes and Fixes
+ * Allow mypy to output a junit file with per-file results (Matthew Wright, PR [16388](https://github.com/python/mypy/pull/16388))
+
+### Typeshed Updates
+
+Please see [git log](https://github.com/python/typeshed/commits/main?after=4a854366e03dee700109f8e758a08b2457ea2f51+0&branch=main&path=stdlib) for full list of standard library typeshed stub changes.
+
+### Acknowledgements
+
+​Thanks to all mypy contributors who contributed to this release:
+
+- Alex Waygood
+- Ali Hamdan
+- Chad Dombrova
+- Christoph Tyralla
+- Ilya Priven
+- Ivan Levkivskyi
+- Jelle Zijlstra
+- Jukka Lehtosalo
+- Marcel Telka
+- Matthew Wright
+- Michael R. Crusoe
+- Nikita Sobolev
+- Ole Peder Brandtzæg
+- robjhornby
+- Shantanu
+- Sveinung Gundersen
+- Valentin Stanciu
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+Posted by Wesley Collin Wright
+
+## Mypy 1.7
+
+We’ve just uploaded mypy 1.7 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Using TypedDict for `**kwargs` Typing
+
+Mypy now has support for using `Unpack[...]` with a TypedDict type to annotate `**kwargs` arguments enabled by default. Example:
+
+```python
+# Or 'from typing_extensions import ...'
+from typing import TypedDict, Unpack
+
+class Person(TypedDict):
+    name: str
+    age: int
+
+def foo(**kwargs: Unpack[Person]) -> None:
+    ...
+
+foo(name="x", age=1)  # Ok
+foo(name=1)  # Error
+```
+
+The definition of `foo` above is equivalent to the one below, with keyword-only arguments `name` and `age`:
+
+```python
+def foo(*, name: str, age: int) -> None:
+    ...
+```
+
+Refer to [PEP 692](https://peps.python.org/pep-0692/) for more information. Note that unlike in the current version of the PEP, mypy always treats signatures with `Unpack[SomeTypedDict]` as equivalent to their expanded forms with explicit keyword arguments, and there aren't special type checking rules for TypedDict arguments.
+
+This was contributed by Ivan Levkivskyi back in 2022 (PR [13471](https://github.com/python/mypy/pull/13471)).
+
+### TypeVarTuple Support Enabled (Experimental)
+
+Mypy now has support for variadic generics (TypeVarTuple) enabled by default, as an experimental feature. Refer to [PEP 646](https://peps.python.org/pep-0646/) for the details.
+
+TypeVarTuple was implemented by Jared Hance and Ivan Levkivskyi over several mypy releases, with help from Jukka Lehtosalo.
+
+Changes included in this release:
+
+ * Fix handling of tuple type context with unpacks (Ivan Levkivskyi, PR [16444](https://github.com/python/mypy/pull/16444))
+ * Handle TypeVarTuples when checking overload constraints (robjhornby, PR [16428](https://github.com/python/mypy/pull/16428))
+ * Enable Unpack/TypeVarTuple support (Ivan Levkivskyi, PR [16354](https://github.com/python/mypy/pull/16354))
+ * Fix crash on unpack call special-casing (Ivan Levkivskyi, PR [16381](https://github.com/python/mypy/pull/16381))
+ * Some final touches for variadic types support (Ivan Levkivskyi, PR [16334](https://github.com/python/mypy/pull/16334))
+ * Support PEP-646 and PEP-692 in the same callable (Ivan Levkivskyi, PR [16294](https://github.com/python/mypy/pull/16294))
+ * Support new `*` syntax for variadic types (Ivan Levkivskyi, PR [16242](https://github.com/python/mypy/pull/16242))
+ * Correctly handle variadic instances with empty arguments (Ivan Levkivskyi, PR [16238](https://github.com/python/mypy/pull/16238))
+ * Correctly handle runtime type applications of variadic types (Ivan Levkivskyi, PR [16240](https://github.com/python/mypy/pull/16240))
+ * Support variadic tuple packing/unpacking (Ivan Levkivskyi, PR [16205](https://github.com/python/mypy/pull/16205))
+ * Better support for variadic calls and indexing (Ivan Levkivskyi, PR [16131](https://github.com/python/mypy/pull/16131))
+ * Subtyping and inference of user-defined variadic types (Ivan Levkivskyi, PR [16076](https://github.com/python/mypy/pull/16076))
+ * Complete type analysis of variadic types (Ivan Levkivskyi, PR [15991](https://github.com/python/mypy/pull/15991))
+
+### New Way of Installing Mypyc Dependencies
+
+If you want to install package dependencies needed by mypyc (not just mypy), you should now install `mypy[mypyc]` instead of just `mypy`:
+
+```
+python3 -m pip install -U 'mypy[mypyc]'
+```
+
+Mypy has many more users than mypyc, so always installing mypyc dependencies would often bring unnecessary dependencies.
+
+This change was contributed by Shantanu (PR [16229](https://github.com/python/mypy/pull/16229)).
+
+### New Rules for Re-exports
+
+Mypy no longer considers an import such as `import a.b as b` as an explicit re-export. The old behavior was arguably inconsistent and surprising. This may impact some stub packages, such as older versions of `types-six`. You can change the import to `from a import b as b`, if treating the import as a re-export was intentional.
+
+This change was contributed by Anders Kaseorg (PR [14086](https://github.com/python/mypy/pull/14086)).
+
+### Improved Type Inference
+
+The new type inference algorithm that was recently introduced to mypy (but was not enabled by default) is now enabled by default. It improves type inference of calls to generic callables where an argument is also a generic callable, in particular. You can use `--old-type-inference` to disable the new behavior.
+
+The new algorithm can (rarely) produce different error messages, different error codes, or errors reported on different lines. This is more likely in cases where generic types were used incorrectly.
+
+The new type inference algorithm was contributed by Ivan Levkivskyi. PR [16345](https://github.com/python/mypy/pull/16345) enabled it by default.
+
+### Narrowing Tuple Types Using len()
+
+Mypy now can narrow tuple types using `len()` checks. Example:
+
+```python
+def f(t: tuple[int, int] | tuple[int, int, int]) -> None:
+    if len(t) == 2:
+        a, b = t   # Ok
+    ...
+```
+
+This feature was contributed by Ivan Levkivskyi (PR [16237](https://github.com/python/mypy/pull/16237)).
+
+### More Precise Tuple Lengths (Experimental)
+
+Mypy supports experimental, more precise checking of tuple type lengths through `--enable-incomplete-feature=PreciseTupleTypes`. Refer to the [documentation](https://mypy.readthedocs.io/en/latest/command_line.html#enabling-incomplete-experimental-features) for more information.
+
+More generally, we are planning to use `--enable-incomplete-feature` to introduce experimental features that would benefit from community feedback.
+
+This feature was contributed by Ivan Levkivskyi (PR [16237](https://github.com/python/mypy/pull/16237)).
+
+### Mypy Changelog
+
+We now maintain a [changelog](https://github.com/python/mypy/blob/master/CHANGELOG.md) in the mypy Git repository. It mirrors the contents of [mypy release blog posts](https://mypy-lang.blogspot.com/). We will continue to also publish release blog posts. In the future, release blog posts will be created based on the changelog near a release date.
+
+This was contributed by Shantanu (PR [16280](https://github.com/python/mypy/pull/16280)).
+
+### Mypy Daemon Improvements
+
+ * Fix daemon crash caused by deleted submodule (Jukka Lehtosalo, PR [16370](https://github.com/python/mypy/pull/16370))
+ * Fix file reloading in dmypy with --export-types (Ivan Levkivskyi, PR [16359](https://github.com/python/mypy/pull/16359))
+ * Fix dmypy inspect on Windows (Ivan Levkivskyi, PR [16355](https://github.com/python/mypy/pull/16355))
+ * Fix dmypy inspect for namespace packages (Ivan Levkivskyi, PR [16357](https://github.com/python/mypy/pull/16357))
+ * Fix return type change to optional in generic function (Jukka Lehtosalo, PR [16342](https://github.com/python/mypy/pull/16342))
+ * Fix daemon false positives related to module-level `__getattr__` (Jukka Lehtosalo, PR [16292](https://github.com/python/mypy/pull/16292))
+ * Fix daemon crash related to ABCs (Jukka Lehtosalo, PR [16275](https://github.com/python/mypy/pull/16275))
+ * Stream dmypy output instead of dumping everything at the end (Valentin Stanciu, PR [16252](https://github.com/python/mypy/pull/16252))
+ * Make sure all dmypy errors are shown (Valentin Stanciu, PR [16250](https://github.com/python/mypy/pull/16250))
+
+### Mypyc Improvements
+
+ * Generate error on duplicate function definitions (Jukka Lehtosalo, PR [16309](https://github.com/python/mypy/pull/16309))
+ * Don't crash on unreachable statements (Jukka Lehtosalo, PR [16311](https://github.com/python/mypy/pull/16311))
+ * Avoid cyclic reference in nested functions (Jukka Lehtosalo, PR [16268](https://github.com/python/mypy/pull/16268))
+ * Fix direct `__dict__` access on inner functions in new Python (Shantanu, PR [16084](https://github.com/python/mypy/pull/16084))
+ * Make tuple packing and unpacking more efficient (Jukka Lehtosalo, PR [16022](https://github.com/python/mypy/pull/16022))
+
+### Improvements to Error Reporting
+
+ * Update starred expression error message to match CPython (Cibin Mathew, PR [16304](https://github.com/python/mypy/pull/16304))
+ * Fix error code of "Maybe you forgot to use await" note (Jelle Zijlstra, PR [16203](https://github.com/python/mypy/pull/16203))
+ * Use error code `[unsafe-overload]` for unsafe overloads, instead of `[misc]` (Randolf Scholz, PR [16061](https://github.com/python/mypy/pull/16061))
+ * Reword the error message related to void functions (Albert Tugushev, PR [15876](https://github.com/python/mypy/pull/15876))
+ * Represent bottom type as Never in messages (Shantanu, PR [15996](https://github.com/python/mypy/pull/15996))
+ * Add hint for AsyncIterator incompatible return type (Ilya Priven, PR [15883](https://github.com/python/mypy/pull/15883))
+ * Don't suggest stubs packages where the runtime package now ships with types (Alex Waygood, PR [16226](https://github.com/python/mypy/pull/16226))
+
+### Performance Improvements
+
+ * Speed up type argument checking (Jukka Lehtosalo, PR [16353](https://github.com/python/mypy/pull/16353))
+ * Add fast path for checking self types (Jukka Lehtosalo, PR [16352](https://github.com/python/mypy/pull/16352))
+ * Cache information about whether file is typeshed file (Jukka Lehtosalo, PR [16351](https://github.com/python/mypy/pull/16351))
+ * Skip expensive `repr()` in logging call when not needed (Jukka Lehtosalo, PR [16350](https://github.com/python/mypy/pull/16350))
+
+### Attrs and Dataclass Improvements
+
+ * `dataclass.replace`: Allow transformed classes (Ilya Priven, PR [15915](https://github.com/python/mypy/pull/15915))
+ * `dataclass.replace`: Fall through to typeshed signature (Ilya Priven, PR [15962](https://github.com/python/mypy/pull/15962))
+ * Document `dataclass_transform` behavior (Ilya Priven, PR [16017](https://github.com/python/mypy/pull/16017))
+ * `attrs`: Remove fields type check (Ilya Priven, PR [15983](https://github.com/python/mypy/pull/15983))
+ * `attrs`, `dataclasses`: Don't enforce slots when base class doesn't (Ilya Priven, PR [15976](https://github.com/python/mypy/pull/15976))
+ * Fix crash on dataclass field / property collision (Nikita Sobolev, PR [16147](https://github.com/python/mypy/pull/16147))
+
+### Stubgen Improvements
+
+ * Write stubs with utf-8 encoding (Jørgen Lind, PR [16329](https://github.com/python/mypy/pull/16329))
+ * Fix missing property setter in semantic analysis mode (Ali Hamdan, PR [16303](https://github.com/python/mypy/pull/16303))
+ * Unify C extension and pure python stub generators with object oriented design (Chad Dombrova, PR [15770](https://github.com/python/mypy/pull/15770))
+ * Multiple fixes to the generated imports (Ali Hamdan, PR [15624](https://github.com/python/mypy/pull/15624))
+ * Generate valid dataclass stubs (Ali Hamdan, PR [15625](https://github.com/python/mypy/pull/15625))
+
+### Fixes to Crashes
+
+ * Fix incremental mode crash on TypedDict in method (Ivan Levkivskyi, PR [16364](https://github.com/python/mypy/pull/16364))
+ * Fix crash on star unpack in TypedDict (Ivan Levkivskyi, PR [16116](https://github.com/python/mypy/pull/16116))
+ * Fix crash on malformed TypedDict in incremental mode (Ivan Levkivskyi, PR [16115](https://github.com/python/mypy/pull/16115))
+ * Fix crash with report generation on namespace packages (Shantanu, PR [16019](https://github.com/python/mypy/pull/16019))
+ * Fix crash when parsing error code config with typo (Shantanu, PR [16005](https://github.com/python/mypy/pull/16005))
+ * Fix `__post_init__()` internal error (Ilya Priven, PR [16080](https://github.com/python/mypy/pull/16080))
+
+### Documentation Updates
+
+ * Make it easier to copy commands from README (Hamir Mahal, PR [16133](https://github.com/python/mypy/pull/16133))
+ * Document and rename `[overload-overlap]` error code (Shantanu, PR [16074](https://github.com/python/mypy/pull/16074))
+ * Document `--force-uppercase-builtins` and `--force-union-syntax` (Nikita Sobolev, PR [16049](https://github.com/python/mypy/pull/16049))
+ * Document `force_union_syntax` and `force_uppercase_builtins` (Nikita Sobolev, PR [16048](https://github.com/python/mypy/pull/16048))
+ * Document we're not tracking relationships between symbols (Ilya Priven, PR [16018](https://github.com/python/mypy/pull/16018))
+
+### Other Notable Changes and Fixes
+
+ * Propagate narrowed types to lambda expressions (Ivan Levkivskyi, PR [16407](https://github.com/python/mypy/pull/16407))
+ * Avoid importing from `setuptools._distutils` (Shantanu, PR [16348](https://github.com/python/mypy/pull/16348))
+ * Delete recursive aliases flags (Ivan Levkivskyi, PR [16346](https://github.com/python/mypy/pull/16346))
+ * Properly use proper subtyping for callables (Ivan Levkivskyi, PR [16343](https://github.com/python/mypy/pull/16343))
+ * Use upper bound as inference fallback more consistently (Ivan Levkivskyi, PR [16344](https://github.com/python/mypy/pull/16344))
+ * Add `[unimported-reveal]` error code (Nikita Sobolev, PR [16271](https://github.com/python/mypy/pull/16271))
+ * Add `|=` and `|` operators support for `TypedDict` (Nikita Sobolev, PR [16249](https://github.com/python/mypy/pull/16249))
+ * Clarify variance convention for Parameters (Ivan Levkivskyi, PR [16302](https://github.com/python/mypy/pull/16302))
+ * Correctly recognize `typing_extensions.NewType` (Ganden Schaffner, PR [16298](https://github.com/python/mypy/pull/16298))
+ * Fix partially defined in the case of missing type maps (Shantanu, PR [15995](https://github.com/python/mypy/pull/15995))
+ * Use SPDX license identifier (Nikita Sobolev, PR [16230](https://github.com/python/mypy/pull/16230))
+ * Make `__qualname__` and `__module__` available in class bodies (Anthony Sottile, PR [16215](https://github.com/python/mypy/pull/16215))
+ * stubtest: Hint when args in stub need to be keyword-only (Alex Waygood, PR [16210](https://github.com/python/mypy/pull/16210))
+ * Tuple slice should not propagate fallback (Thomas Grainger, PR [16154](https://github.com/python/mypy/pull/16154))
+ * Fix cases of type object handling for overloads (Shantanu, PR [16168](https://github.com/python/mypy/pull/16168))
+ * Fix walrus interaction with empty collections (Ivan Levkivskyi, PR [16197](https://github.com/python/mypy/pull/16197))
+ * Use type variable bound when it appears as actual during inference (Ivan Levkivskyi, PR [16178](https://github.com/python/mypy/pull/16178))
+ * Use upper bounds as fallback solutions for inference (Ivan Levkivskyi, PR [16184](https://github.com/python/mypy/pull/16184))
+ * Special-case type inference of empty collections (Ivan Levkivskyi, PR [16122](https://github.com/python/mypy/pull/16122))
+ * Allow TypedDict unpacking in Callable types (Ivan Levkivskyi, PR [16083](https://github.com/python/mypy/pull/16083))
+ * Fix inference for overloaded `__call__` with generic self (Shantanu, PR [16053](https://github.com/python/mypy/pull/16053))
+ * Call dynamic class hook on generic classes (Petter Friberg, PR [16052](https://github.com/python/mypy/pull/16052))
+ * Preserve implicitly exported types via attribute access (Shantanu, PR [16129](https://github.com/python/mypy/pull/16129))
+ * Fix a stubtest bug (Alex Waygood)
+ * Fix `tuple[Any, ...]` subtyping (Shantanu, PR [16108](https://github.com/python/mypy/pull/16108))
+ * Lenient handling of trivial Callable suffixes (Ivan Levkivskyi, PR [15913](https://github.com/python/mypy/pull/15913))
+ * Add `add_overloaded_method_to_class` helper for plugins (Nikita Sobolev, PR [16038](https://github.com/python/mypy/pull/16038))
+ * Bundle `misc/proper_plugin.py` as a part of `mypy` (Nikita Sobolev, PR [16036](https://github.com/python/mypy/pull/16036))
+ * Fix `case Any()` in match statement (DS/Charlie, PR [14479](https://github.com/python/mypy/pull/14479))
+ * Make iterable logic more consistent (Shantanu, PR [16006](https://github.com/python/mypy/pull/16006))
+ * Fix inference for properties with `__call__` (Shantanu, PR [15926](https://github.com/python/mypy/pull/15926))
+
+### Typeshed Updates
+
+Please see [git log](https://github.com/python/typeshed/commits/main?after=4a854366e03dee700109f8e758a08b2457ea2f51+0&branch=main&path=stdlib) for full list of standard library typeshed stub changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+* Albert Tugushev
+* Alex Waygood
+* Ali Hamdan
+* Anders Kaseorg
+* Anthony Sottile
+* Chad Dombrova
+* Cibin Mathew
+* dinaldoap
+* DS/Charlie
+* Eli Schwartz
+* Ganden Schaffner
+* Hamir Mahal
+* Ihor
+* Ikko Eltociear Ashimine
+* Ilya Priven
+* Ivan Levkivskyi
+* Jelle Zijlstra
+* Jukka Lehtosalo
+* Jørgen Lind
+* KotlinIsland
+* Matt Bogosian
+* Nikita Sobolev
+* Petter Friberg
+* Randolf Scholz
+* Shantanu
+* Thomas Grainger
+* Valentin Stanciu
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+Posted by Jukka Lehtosalo
+
+## Mypy 1.6
+
+[Tuesday, 10 October 2023](https://mypy-lang.blogspot.com/2023/10/mypy-16-released.html)
+
+We’ve just uploaded mypy 1.6 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Introduce Error Subcodes for Import Errors
+
+Mypy now uses the error code import-untyped if an import targets an installed library that doesn’t support static type checking, and no stub files are available. Other invalid imports produce the import-not-found error code. They both are subcodes of the import error code, which was previously used for both kinds of import-related errors.
+
+Use \--disable-error-code=import-untyped to only ignore import errors about installed libraries without stubs. This way mypy will still report errors about typos in import statements, for example.
+
+If you use \--warn-unused-ignore or \--strict, mypy will complain if you use \# type: ignore\[import\] to ignore an import error. You are expected to use one of the more specific error codes instead. Otherwise, ignoring the import error code continues to silence both errors.
+
+This feature was contributed by Shantanu (PR [15840](https://github.com/python/mypy/pull/15840), PR [14740](https://github.com/python/mypy/pull/14740)).
+
+### Remove Support for Targeting Python 3.6 and Earlier
+
+Running mypy with \--python-version 3.6, for example, is no longer supported. Python 3.6 hasn’t been properly supported by mypy for some time now, and this makes it explicit. This was contributed by Nikita Sobolev (PR [15668](https://github.com/python/mypy/pull/15668)).
+
+### Selective Filtering of \--disallow-untyped-calls Targets
+
+Using \--disallow-untyped-calls could be annoying when using libraries with missing type information, as mypy would generate many errors about code that uses the library. Now you can use \--untyped-calls-exclude=acme, for example, to disable these errors about calls targeting functions defined in the acme package. Refer to the [documentation](https://mypy.readthedocs.io/en/latest/command_line.html#cmdoption-mypy-untyped-calls-exclude) for more information.
+
+This feature was contributed by Ivan Levkivskyi (PR [15845](https://github.com/python/mypy/pull/15845)).
+
+### Improved Type Inference between Callable Types
+
+Mypy now does a better job inferring type variables inside arguments of callable types. For example, this code fragment now type checks correctly:
+
+```python
+def f(c: Callable[[T, S], None]) -> Callable[[str, T, S], None]: ...
+def g(*x: int) -> None: ...
+
+reveal_type(f(g))  # Callable[[str, int, int], None]
+```
+
+This was contributed by Ivan Levkivskyi (PR [15910](https://github.com/python/mypy/pull/15910)).
+
+### Don’t Consider None and TypeVar to Overlap in Overloads
+
+Mypy now doesn’t consider an overload item with an argument type None to overlap with a type variable:
+
+```python
+@overload
+def f(x: None) -> None: ..
+@overload
+def f(x: T) -> Foo[T]: ...
+...
+```
+
+Previously mypy would generate an error about the definition of f above. This is slightly unsafe if the upper bound of T is object, since the value of the type variable could be None. We relaxed the rules a little, since this solves a common issue.
+
+This feature was contributed by Ivan Levkivskyi (PR [15846](https://github.com/python/mypy/pull/15846)).
+
+### Improvements to \--new-type-inference
+
+The experimental new type inference algorithm (polymorphic inference) introduced as an opt-in feature in mypy 1.5 has several improvements:
+
+*   Improve transitive closure computation during constraint solving (Ivan Levkivskyi, PR [15754](https://github.com/python/mypy/pull/15754))
+*   Add support for upper bounds and values with \--new-type-inference (Ivan Levkivskyi, PR [15813](https://github.com/python/mypy/pull/15813))
+*   Basic support for variadic types with \--new-type-inference (Ivan Levkivskyi, PR [15879](https://github.com/python/mypy/pull/15879))
+*   Polymorphic inference: support for parameter specifications and lambdas (Ivan Levkivskyi, PR [15837](https://github.com/python/mypy/pull/15837))
+*   Invalidate cache when adding \--new-type-inference (Marc Mueller, PR [16059](https://github.com/python/mypy/pull/16059))
+
+**Note:** We are planning to enable \--new-type-inference by default in mypy 1.7. Please try this out and let us know if you encounter any issues.
+
+### ParamSpec Improvements
+
+*   Support self-types containing ParamSpec (Ivan Levkivskyi, PR [15903](https://github.com/python/mypy/pull/15903))
+*   Allow “…” in Concatenate, and clean up ParamSpec literals (Ivan Levkivskyi, PR [15905](https://github.com/python/mypy/pull/15905))
+*   Fix ParamSpec inference for callback protocols (Ivan Levkivskyi, PR [15986](https://github.com/python/mypy/pull/15986))
+*   Infer ParamSpec constraint from arguments (Ivan Levkivskyi, PR [15896](https://github.com/python/mypy/pull/15896))
+*   Fix crash on invalid type variable with ParamSpec (Ivan Levkivskyi, PR [15953](https://github.com/python/mypy/pull/15953))
+*   Fix subtyping between ParamSpecs (Ivan Levkivskyi, PR [15892](https://github.com/python/mypy/pull/15892))
+
+### Stubgen Improvements
+
+*   Add option to include docstrings with stubgen (chylek, PR [13284](https://github.com/python/mypy/pull/13284))
+*   Add required ... initializer to NamedTuple fields with default values (Nikita Sobolev, PR [15680](https://github.com/python/mypy/pull/15680))
+
+### Stubtest Improvements
+
+*   Fix \_\_mypy-replace false positives (Alex Waygood, PR [15689](https://github.com/python/mypy/pull/15689))
+*   Fix edge case for bytes enum subclasses (Alex Waygood, PR [15943](https://github.com/python/mypy/pull/15943))
+*   Generate error if typeshed is missing modules from the stdlib (Alex Waygood, PR [15729](https://github.com/python/mypy/pull/15729))
+*   Fixes to new check for missing stdlib modules (Alex Waygood, PR [15960](https://github.com/python/mypy/pull/15960))
+*   Fix stubtest enum.Flag edge case (Alex Waygood, PR [15933](https://github.com/python/mypy/pull/15933))
+
+### Documentation Improvements
+
+*   Do not advertise to create your own assert\_never helper (Nikita Sobolev, PR [15947](https://github.com/python/mypy/pull/15947))
+*   Fix all the missing references found within the docs (Albert Tugushev, PR [15875](https://github.com/python/mypy/pull/15875))
+*   Document await-not-async error code (Shantanu, PR [15858](https://github.com/python/mypy/pull/15858))
+*   Improve documentation of disabling error codes (Shantanu, PR [15841](https://github.com/python/mypy/pull/15841))
+
+### Other Notable Changes and Fixes
+
+*   Make unsupported PEP 695 features (introduced in Python 3.12) give a reasonable error message (Shantanu, PR [16013](https://github.com/python/mypy/pull/16013))
+*   Remove the \--py2 command-line argument (Marc Mueller, PR [15670](https://github.com/python/mypy/pull/15670))
+*   Change empty tuple from tuple\[\] to tuple\[()\] in error messages (Nikita Sobolev, PR [15783](https://github.com/python/mypy/pull/15783))
+*   Fix assert\_type failures when some nodes are deferred (Nikita Sobolev, PR [15920](https://github.com/python/mypy/pull/15920))
+*   Generate error on unbound TypeVar with values (Nikita Sobolev, PR [15732](https://github.com/python/mypy/pull/15732))
+*   Fix over-eager types-google-cloud-ndb suggestion (Shantanu, PR [15347](https://github.com/python/mypy/pull/15347))
+*   Fix type narrowing of \== None and in (None,) conditions (Marti Raudsepp, PR [15760](https://github.com/python/mypy/pull/15760))
+*   Fix inference for attrs.fields (Shantanu, PR [15688](https://github.com/python/mypy/pull/15688))
+*   Make “await in non-async function” a non-blocking error and give it an error code (Gregory Santosa, PR [15384](https://github.com/python/mypy/pull/15384))
+*   Add basic support for decorated overloads (Ivan Levkivskyi, PR [15898](https://github.com/python/mypy/pull/15898))
+*   Fix TypeVar regression with self types (Ivan Levkivskyi, PR [15945](https://github.com/python/mypy/pull/15945))
+*   Add \_\_match\_args\_\_ to dataclasses with no fields (Ali Hamdan, PR [15749](https://github.com/python/mypy/pull/15749))
+*   Include stdout and stderr in dmypy verbose output (Valentin Stanciu, PR [15881](https://github.com/python/mypy/pull/15881))
+*   Improve match narrowing and reachability analysis (Shantanu, PR [15882](https://github.com/python/mypy/pull/15882))
+*   Support \_\_bool\_\_ with Literal in \--warn-unreachable (Jannic Warken, PR [15645](https://github.com/python/mypy/pull/15645))
+*   Fix inheriting from generic @frozen attrs class (Ilya Priven, PR [15700](https://github.com/python/mypy/pull/15700))
+*   Correctly narrow types for tuple\[type\[X\], ...\] (Nikita Sobolev, PR [15691](https://github.com/python/mypy/pull/15691))
+*   Don't flag intentionally empty generators unreachable (Ilya Priven, PR [15722](https://github.com/python/mypy/pull/15722))
+*   Add tox.ini to mypy sdist (Marcel Telka, PR [15853](https://github.com/python/mypy/pull/15853))
+*   Fix mypyc regression with pretty (Shantanu, PR [16124](https://github.com/python/mypy/pull/16124))
+
+### Typeshed Updates
+
+Typeshed is now modular and distributed as separate PyPI packages for everything except the standard library stubs. Please see [git log](https://github.com/python/typeshed/commits/main?after=6a8d653a671925b0a3af61729ff8cf3f90c9c662+0&branch=main&path=stdlib) for full list of typeshed changes.
+
+### Acknowledgements
+
+Thanks to Max Murin, who did most of the release manager work for this release (I just did the final steps).
+
+Thanks to all mypy contributors who contributed to this release:
+
+*   Albert Tugushev
+*   Alex Waygood
+*   Ali Hamdan
+*   chylek
+*   EXPLOSION
+*   Gregory Santosa
+*   Ilya Priven
+*   Ivan Levkivskyi
+*   Jannic Warken
+*   KotlinIsland
+*   Marc Mueller
+*   Marcel Johannesmann
+*   Marcel Telka
+*   Mark Byrne
+*   Marti Raudsepp
+*   Max Murin
+*   Nikita Sobolev
+*   Shantanu
+*   Valentin Stanciu
+
+Posted by Jukka Lehtosalo
+
+
+## Mypy 1.5
+
+[Thursday, 10 August 2023](https://mypy-lang.blogspot.com/2023/08/mypy-15-released.html)
+
+We’ve just uploaded mypy 1.5 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, deprecations and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Drop Support for Python 3.7
+
+Mypy no longer supports running with Python 3.7, which has reached end-of-life. This was contributed by Shantanu (PR [15566](https://github.com/python/mypy/pull/15566)).
+
+### Optional Check to Require Explicit @override
+
+If you enable the explicit-override error code, mypy will generate an error if a method override doesn’t use the @typing.override decorator (as discussed in [PEP 698](https://peps.python.org/pep-0698/#strict-enforcement-per-project)). This way mypy will detect accidentally introduced overrides. Example:
+
+```python
+# mypy: enable-error-code="explicit-override"
+
+from typing_extensions import override
+
+class C:
+    def foo(self) -> None: pass
+    def bar(self) -> None: pass
+
+class D(C):
+    # Error: Method "foo" is not using @override but is
+    # overriding a method
+    def foo(self) -> None:
+        ...
+
+    @override
+    def bar(self) -> None:  # OK
+        ...
+```
+
+You can enable the error code via \--enable-error-code=explicit-override on the mypy command line or enable\_error\_code = explicit-override in the mypy config file.
+
+The override decorator will be available in typing in Python 3.12, but you can also use the backport from a recent version of `typing_extensions` on all supported Python versions.
+
+This feature was contributed by Marc Mueller(PR [15512](https://github.com/python/mypy/pull/15512)).
+
+### More Flexible TypedDict Creation and Update
+
+Mypy was previously overly strict when type checking TypedDict creation and update operations. Though these checks were often technically correct, they sometimes triggered for apparently valid code. These checks have now been relaxed by default. You can enable stricter checking by using the new \--extra-checks flag.
+
+Construction using the `**` syntax is now more flexible:
+
+```python
+from typing import TypedDict
+
+class A(TypedDict):
+    foo: int
+    bar: int
+
+class B(TypedDict):
+    foo: int
+
+a: A = {"foo": 1, "bar": 2}
+b: B = {"foo": 3}
+a2: A = { **a, **b}  # OK (previously an error)
+```
+
+You can also call update() with a TypedDict argument that contains a subset of the keys in the updated TypedDict:
+```python
+a.update(b)  # OK (previously an error)
+```
+
+This feature was contributed by Ivan Levkivskyi (PR [15425](https://github.com/python/mypy/pull/15425)).
+
+### Deprecated Flag: \--strict-concatenate
+
+The behavior of \--strict-concatenate is now included in the new \--extra-checks flag, and the old flag is deprecated.
+
+### Optionally Show Links to Error Code Documentation
+
+If you use \--show-error-code-links, mypy will add documentation links to (many) reported errors. The links are not shown for error messages that are sufficiently obvious, and they are shown once per error code only.
+
+Example output:
+```
+a.py:1: error: Need type annotation for "foo" (hint: "x: List[<type>] = ...")  [var-annotated]
+a.py:1: note: See https://mypy.rtfd.io/en/stable/_refs.html#code-var-annotated for more info
+```
+This was contributed by Ivan Levkivskyi (PR [15449](https://github.com/python/mypy/pull/15449)).
+
+### Consistently Avoid Type Checking Unreachable Code
+
+If a module top level has unreachable code, mypy won’t type check the unreachable statements. This is consistent with how functions behave. The behavior of \--warn-unreachable is also more consistent now.
+
+This was contributed by Ilya Priven (PR [15386](https://github.com/python/mypy/pull/15386)).
+
+### Experimental Improved Type Inference for Generic Functions
+
+You can use \--new-type-inference to opt into an experimental new type inference algorithm. It fixes issues when calling a generic functions with an argument that is also a generic function, in particular. This current implementation is still incomplete, but we encourage trying it out and reporting bugs if you encounter regressions. We are planning to enable the new algorithm by default in a future mypy release.
+
+This feature was contributed by Ivan Levkivskyi (PR [15287](https://github.com/python/mypy/pull/15287)).
+
+### Partial Support for Python 3.12
+
+Mypy and mypyc now support running on recent Python 3.12 development versions. Not all new Python 3.12 features are supported, and we don’t ship compiled wheels for Python 3.12 yet.
+
+*   Fix ast warnings for Python 3.12 (Nikita Sobolev, PR [15558](https://github.com/python/mypy/pull/15558))
+*   mypyc: Fix multiple inheritance with a protocol on Python 3.12 (Jukka Lehtosalo, PR [15572](https://github.com/python/mypy/pull/15572))
+*   mypyc: Fix self-compilation on Python 3.12 (Jukka Lehtosalo, PR [15582](https://github.com/python/mypy/pull/15582))
+*   mypyc: Fix 3.12 issue with pickling of instances with \_\_dict\_\_ (Jukka Lehtosalo, PR [15574](https://github.com/python/mypy/pull/15574))
+*   mypyc: Fix i16 on Python 3.12 (Jukka Lehtosalo, PR [15510](https://github.com/python/mypy/pull/15510))
+*   mypyc: Fix int operations on Python 3.12 (Jukka Lehtosalo, PR [15470](https://github.com/python/mypy/pull/15470))
+*   mypyc: Fix generators on Python 3.12 (Jukka Lehtosalo, PR [15472](https://github.com/python/mypy/pull/15472))
+*   mypyc: Fix classes with \_\_dict\_\_ on 3.12 (Jukka Lehtosalo, PR [15471](https://github.com/python/mypy/pull/15471))
+*   mypyc: Fix coroutines on Python 3.12 (Jukka Lehtosalo, PR [15469](https://github.com/python/mypy/pull/15469))
+*   mypyc: Don't use \_PyErr\_ChainExceptions on 3.12, since it's deprecated (Jukka Lehtosalo, PR [15468](https://github.com/python/mypy/pull/15468))
+*   mypyc: Add Python 3.12 feature macro (Jukka Lehtosalo, PR [15465](https://github.com/python/mypy/pull/15465))
+
+### Improvements to Dataclasses
+
+*   Improve signature of dataclasses.replace (Ilya Priven, PR [14849](https://github.com/python/mypy/pull/14849))
+*   Fix dataclass/protocol crash on joining types (Ilya Priven, PR [15629](https://github.com/python/mypy/pull/15629))
+*   Fix strict optional handling in dataclasses (Ivan Levkivskyi, PR [15571](https://github.com/python/mypy/pull/15571))
+*   Support optional types for custom dataclass descriptors (Marc Mueller, PR [15628](https://github.com/python/mypy/pull/15628))
+*   Add `__slots__` attribute to dataclasses (Nikita Sobolev, PR [15649](https://github.com/python/mypy/pull/15649))
+*   Support better \_\_post\_init\_\_ method signature for dataclasses (Nikita Sobolev, PR [15503](https://github.com/python/mypy/pull/15503))
+
+### Mypyc Improvements
+
+*   Support unsigned 8-bit native integer type: mypy\_extensions.u8 (Jukka Lehtosalo, PR [15564](https://github.com/python/mypy/pull/15564))
+*   Support signed 16-bit native integer type: mypy\_extensions.i16 (Jukka Lehtosalo, PR [15464](https://github.com/python/mypy/pull/15464))
+*   Define mypy\_extensions.i16 in stubs (Jukka Lehtosalo, PR [15562](https://github.com/python/mypy/pull/15562))
+*   Document more unsupported features and update supported features (Richard Si, PR [15524](https://github.com/python/mypy/pull/15524))
+*   Fix final NamedTuple classes (Richard Si, PR [15513](https://github.com/python/mypy/pull/15513))
+*   Use C99 compound literals for undefined tuple values (Jukka Lehtosalo, PR [15453](https://github.com/python/mypy/pull/15453))
+*   Don't explicitly assign NULL values in setup functions (Logan Hunt, PR [15379](https://github.com/python/mypy/pull/15379))
+
+### Stubgen Improvements
+
+*   Teach stubgen to work with complex and unary expressions (Nikita Sobolev, PR [15661](https://github.com/python/mypy/pull/15661))
+*   Support ParamSpec and TypeVarTuple (Ali Hamdan, PR [15626](https://github.com/python/mypy/pull/15626))
+*   Fix crash on non-str docstring (Ali Hamdan, PR [15623](https://github.com/python/mypy/pull/15623))
+
+### Documentation Updates
+
+*   Add documentation for additional error codes (Ivan Levkivskyi, PR [15539](https://github.com/python/mypy/pull/15539))
+*   Improve documentation of type narrowing (Ilya Priven, PR [15652](https://github.com/python/mypy/pull/15652))
+*   Small improvements to protocol documentation (Shantanu, PR [15460](https://github.com/python/mypy/pull/15460))
+*   Remove confusing instance variable example in cheat sheet (Adel Atallah, PR [15441](https://github.com/python/mypy/pull/15441))
+
+### Other Notable Fixes and Improvements
+
+*   Constant fold additional unary and binary expressions (Richard Si, PR [15202](https://github.com/python/mypy/pull/15202))
+*   Exclude the same special attributes from Protocol as CPython (Kyle Benesch, PR [15490](https://github.com/python/mypy/pull/15490))
+*   Change the default value of the slots argument of attrs.define to True, to match runtime behavior (Ilya Priven, PR [15642](https://github.com/python/mypy/pull/15642))
+*   Fix type of class attribute if attribute is defined in both class and metaclass (Alex Waygood, PR [14988](https://github.com/python/mypy/pull/14988))
+*   Handle type the same as typing.Type in the first argument of classmethods (Erik Kemperman, PR [15297](https://github.com/python/mypy/pull/15297))
+*   Fix \--find-occurrences flag (Shantanu, PR [15528](https://github.com/python/mypy/pull/15528))
+*   Fix error location for class patterns (Nikita Sobolev, PR [15506](https://github.com/python/mypy/pull/15506))
+*   Fix re-added file with errors in mypy daemon (Ivan Levkivskyi, PR [15440](https://github.com/python/mypy/pull/15440))
+*   Fix dmypy run on Windows (Ivan Levkivskyi, PR [15429](https://github.com/python/mypy/pull/15429))
+*   Fix abstract and non-abstract variant error for property deleter (Shantanu, PR [15395](https://github.com/python/mypy/pull/15395))
+*   Remove special casing for "cannot" in error messages (Ilya Priven, PR [15428](https://github.com/python/mypy/pull/15428))
+*   Add runtime `__slots__` attribute to attrs classes (Nikita Sobolev, PR [15651](https://github.com/python/mypy/pull/15651))
+*   Add get\_expression\_type to CheckerPluginInterface (Ilya Priven, PR [15369](https://github.com/python/mypy/pull/15369))
+*   Remove parameters that no longer exist from NamedTuple.\_make() (Alex Waygood, PR [15578](https://github.com/python/mypy/pull/15578))
+*   Allow using typing.Self in `__all__` with an explicit @staticmethod decorator (Erik Kemperman, PR [15353](https://github.com/python/mypy/pull/15353))
+*   Fix self types in subclass methods without Self annotation (Ivan Levkivskyi, PR [15541](https://github.com/python/mypy/pull/15541))
+*   Check for abstract class objects in tuples (Nikita Sobolev, PR [15366](https://github.com/python/mypy/pull/15366))
+
+### Typeshed Updates
+
+Typeshed is now modular and distributed as separate PyPI packages for everything except the standard library stubs. Please see [git log](https://github.com/python/typeshed/commits/main?after=fc7d4722eaa54803926cee5730e1f784979c0531+0&branch=main&path=stdlib) for full list of typeshed changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+*   Adel Atallah
+*   Alex Waygood
+*   Ali Hamdan
+*   Erik Kemperman
+*   Federico Padua
+*   Ilya Priven
+*   Ivan Levkivskyi
+*   Jelle Zijlstra
+*   Jared Hance
+*   Jukka Lehtosalo
+*   Kyle Benesch
+*   Logan Hunt
+*   Marc Mueller
+*   Nikita Sobolev
+*   Richard Si
+*   Shantanu
+*   Stavros Ntentos
+*   Valentin Stanciu
+
+Posted by Valentin Stanciu
+
+
+## Mypy 1.4
+
+[Tuesday, 20 June 2023](https://mypy-lang.blogspot.com/2023/06/mypy-140-released.html)
+
+We’ve just uploaded mypy 1.4 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### The Override Decorator
+
+Mypy can now ensure that when renaming a method, overrides are also renamed. You can explicitly mark a method as overriding a base class method by using the @typing.override decorator ([PEP 698](https://peps.python.org/pep-0698/)). If the method is then renamed in the base class while the method override is not, mypy will generate an error. The decorator will be available in typing in Python 3.12, but you can also use the backport from a recent version of `typing_extensions` on all supported Python versions.
+
+This feature was contributed byThomas M Kehrenberg (PR [14609](https://github.com/python/mypy/pull/14609)).
+
+### Propagating Type Narrowing to Nested Functions
+
+Previously, type narrowing was not propagated to nested functions because it would not be sound if the narrowed variable changed between the definition of the nested function and the call site. Mypy will now propagate the narrowed type if the variable is not assigned to after the definition of the nested function:
+
+```python
+def outer(x: str | None = None) -> None:
+    if x is None:
+        x = calculate_default()
+    reveal_type(x)  # "str" (narrowed)
+
+    def nested() -> None:
+        reveal_type(x)  # Now "str" (used to be "str | None")
+
+    nested()
+```
+
+This may generate some new errors because asserts that were previously necessary may become tautological or no-ops.
+
+This was contributed by Jukka Lehtosalo (PR [15133](https://github.com/python/mypy/pull/15133)).
+
+### Narrowing Enum Values Using “==”
+
+Mypy now allows narrowing enum types using the \== operator. Previously this was only supported when using the is operator. This makes exhaustiveness checking with enum types more usable, as the requirement to use the is operator was not very intuitive. In this example mypy can detect that the developer forgot to handle the value MyEnum.C in example
+
+```python
+from enum import Enum
+
+class MyEnum(Enum):
+    A = 0
+    B = 1
+    C = 2
+
+def example(e: MyEnum) -> str:  # Error: Missing return statement
+    if e == MyEnum.A:
+        return 'x'
+    elif e == MyEnum.B:
+        return 'y'
+```
+
+Adding an extra elif case resolves the error:
+
+```python
+...
+def example(e: MyEnum) -> str:  # No error -- all values covered
+    if e == MyEnum.A:
+        return 'x'
+    elif e == MyEnum.B:
+        return 'y'
+    elif e == MyEnum.C:
+        return 'z'
+```
+
+This change can cause false positives in test cases that have assert statements like assert o.x == SomeEnum.X when using \--strict-equality. Example:
+
+```python
+# mypy: strict-equality
+
+from enum import Enum
+
+class MyEnum(Enum):
+    A = 0
+    B = 1
+
+class C:
+    x: MyEnum
+    ...
+
+def test_something() -> None:
+    c = C(...)
+    assert c.x == MyEnum.A
+    c.do_something_that_changes_x()
+    assert c.x == MyEnum.B  # Error: Non-overlapping equality check
+```
+
+These errors can be ignored using \# type: ignore\[comparison-overlap\], or you can perform the assertion using a temporary variable as a workaround:
+
+```python
+...
+def test_something() -> None:
+    ...
+    x = c.x
+    assert x == MyEnum.A  # Does not narrow c.x
+    c.do_something_that_changes_x()
+    x = c.x
+    assert x == MyEnum.B  # OK
+```
+
+This feature was contributed by Shantanu (PR [11521](https://github.com/python/mypy/pull/11521)).
+
+### Performance Improvements
+
+*   Speed up simplification of large union types and also fix a recursive tuple crash (Shantanu, PR [15128](https://github.com/python/mypy/pull/15128))
+*   Speed up union subtyping (Shantanu, PR [15104](https://github.com/python/mypy/pull/15104))
+*   Don't type check most function bodies when type checking third-party library code, or generally when ignoring errors (Jukka Lehtosalo, PR [14150](https://github.com/python/mypy/pull/14150))
+
+### Improvements to Plugins
+
+*   attrs.evolve: Support generics and unions (Ilya Konstantinov, PR [15050](https://github.com/python/mypy/pull/15050))
+*   Fix ctypes plugin (Alex Waygood)
+
+### Fixes to Crashes
+
+*   Fix a crash when function-scope recursive alias appears as upper bound (Ivan Levkivskyi, PR [15159](https://github.com/python/mypy/pull/15159))
+*   Fix crash on follow\_imports\_for\_stubs (Ivan Levkivskyi, PR [15407](https://github.com/python/mypy/pull/15407))
+*   Fix stubtest crash in explicit init subclass (Shantanu, PR [15399](https://github.com/python/mypy/pull/15399))
+*   Fix crash when indexing TypedDict with empty key (Shantanu, PR [15392](https://github.com/python/mypy/pull/15392))
+*   Fix crash on NamedTuple as attribute (Ivan Levkivskyi, PR [15404](https://github.com/python/mypy/pull/15404))
+*   Correctly track loop depth for nested functions/classes (Ivan Levkivskyi, PR [15403](https://github.com/python/mypy/pull/15403))
+*   Fix crash on joins with recursive tuples (Ivan Levkivskyi, PR [15402](https://github.com/python/mypy/pull/15402))
+*   Fix crash with custom ErrorCode subclasses (Marc Mueller, PR [15327](https://github.com/python/mypy/pull/15327))
+*   Fix crash in dataclass protocol with self attribute assignment (Ivan Levkivskyi, PR [15157](https://github.com/python/mypy/pull/15157))
+*   Fix crash on lambda in generic context with generic method in body (Ivan Levkivskyi, PR [15155](https://github.com/python/mypy/pull/15155))
+*   Fix recursive type alias crash in make\_simplified\_union (Ivan Levkivskyi, PR [15216](https://github.com/python/mypy/pull/15216))
+
+### Improvements to Error Messages
+
+*   Use lower-case built-in collection types such as list\[…\] instead of List\[…\] in errors when targeting Python 3.9+ (Max Murin, PR [15070](https://github.com/python/mypy/pull/15070))
+*   Use X | Y union syntax in error messages when targeting Python 3.10+ (Omar Silva, PR [15102](https://github.com/python/mypy/pull/15102))
+*   Use type instead of Type in errors when targeting Python 3.9+ (Rohit Sanjay, PR [15139](https://github.com/python/mypy/pull/15139))
+*   Do not show unused-ignore errors in unreachable code, and make it a real error code (Ivan Levkivskyi, PR [15164](https://github.com/python/mypy/pull/15164))
+*   Don’t limit the number of errors shown by default (Rohit Sanjay, PR [15138](https://github.com/python/mypy/pull/15138))
+*   Improver message for truthy functions (madt2709, PR [15193](https://github.com/python/mypy/pull/15193))
+*   Output distinct types when type names are ambiguous (teresa0605, PR [15184](https://github.com/python/mypy/pull/15184))
+*   Update message about invalid exception type in try (AJ Rasmussen, PR [15131](https://github.com/python/mypy/pull/15131))
+*   Add explanation if argument type is incompatible because of an unsupported numbers type (Jukka Lehtosalo, PR [15137](https://github.com/python/mypy/pull/15137))
+*   Add more detail to 'signature incompatible with supertype' messages for non-callables (Ilya Priven, PR [15263](https://github.com/python/mypy/pull/15263))
+
+### Documentation Updates
+
+*   Add \--local-partial-types note to dmypy docs (Alan Du, PR [15259](https://github.com/python/mypy/pull/15259))
+*   Update getting started docs for mypyc for Windows (Valentin Stanciu, PR [15233](https://github.com/python/mypy/pull/15233))
+*   Clarify usage of callables regarding type object in docs (Viicos, PR [15079](https://github.com/python/mypy/pull/15079))
+*   Clarify difference between disallow\_untyped\_defs and disallow\_incomplete\_defs (Ilya Priven, PR [15247](https://github.com/python/mypy/pull/15247))
+*   Use attrs and @attrs.define in documentation and tests (Ilya Priven, PR [15152](https://github.com/python/mypy/pull/15152))
+
+### Mypyc Improvements
+
+*   Fix unexpected TypeError for certain variables with an inferred optional type (Richard Si, PR [15206](https://github.com/python/mypy/pull/15206))
+*   Inline math literals (Logan Hunt, PR [15324](https://github.com/python/mypy/pull/15324))
+*   Support unpacking mappings in dict display (Richard Si, PR [15203](https://github.com/python/mypy/pull/15203))
+
+### Changes to Stubgen
+
+*   Do not remove Generic from base classes (Ali Hamdan, PR [15316](https://github.com/python/mypy/pull/15316))
+*   Support yield from statements (Ali Hamdan, PR [15271](https://github.com/python/mypy/pull/15271))
+*   Fix missing total from TypedDict class (Ali Hamdan, PR [15208](https://github.com/python/mypy/pull/15208))
+*   Fix call-based namedtuple omitted from class bases (Ali Hamdan, PR [14680](https://github.com/python/mypy/pull/14680))
+*   Support TypedDict alternative syntax (Ali Hamdan, PR [14682](https://github.com/python/mypy/pull/14682))
+*   Make stubgen respect MYPY\_CACHE\_DIR (Henrik Bäärnhielm, PR [14722](https://github.com/python/mypy/pull/14722))
+*   Fixes and simplifications (Ali Hamdan, PR [15232](https://github.com/python/mypy/pull/15232))
+
+### Other Notable Fixes and Improvements
+
+*   Fix nested async functions when using TypeVar value restriction (Jukka Lehtosalo, PR [14705](https://github.com/python/mypy/pull/14705))
+*   Always allow returning Any from lambda (Ivan Levkivskyi, PR [15413](https://github.com/python/mypy/pull/15413))
+*   Add foundation for TypeVar defaults (PEP 696) (Marc Mueller, PR [14872](https://github.com/python/mypy/pull/14872))
+*   Update semantic analyzer for TypeVar defaults (PEP 696) (Marc Mueller, PR [14873](https://github.com/python/mypy/pull/14873))
+*   Make dict expression inference more consistent (Ivan Levkivskyi, PR [15174](https://github.com/python/mypy/pull/15174))
+*   Do not block on duplicate base classes (Nikita Sobolev, PR [15367](https://github.com/python/mypy/pull/15367))
+*   Generate an error when both staticmethod and classmethod decorators are used (Juhi Chandalia, PR [15118](https://github.com/python/mypy/pull/15118))
+*   Fix assert\_type behaviour with literals (Carl Karsten, PR [15123](https://github.com/python/mypy/pull/15123))
+*   Fix match subject ignoring redefinitions (Vincent Vanlaer, PR [15306](https://github.com/python/mypy/pull/15306))
+*   Support `__all__`.remove (Shantanu, PR [15279](https://github.com/python/mypy/pull/15279))
+
+### Typeshed Updates
+
+Typeshed is now modular and distributed as separate PyPI packages for everything except the standard library stubs. Please see [git log](https://github.com/python/typeshed/commits/main?after=877e06ad1cfd9fd9967c0b0340a86d0c23ea89ce+0&branch=main&path=stdlib) for full list of typeshed changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+*   Adrian Garcia Badaracco
+*   AJ Rasmussen
+*   Alan Du
+*   Alex Waygood
+*   Ali Hamdan
+*   Carl Karsten
+*   dosisod
+*   Ethan Smith
+*   Gregory Santosa
+*   Heather White
+*   Henrik Bäärnhielm
+*   Ilya Konstantinov
+*   Ilya Priven
+*   Ivan Levkivskyi
+*   Juhi Chandalia
+*   Jukka Lehtosalo
+*   Logan Hunt
+*   madt2709
+*   Marc Mueller
+*   Max Murin
+*   Nikita Sobolev
+*   Omar Silva
+*   Özgür
+*   Richard Si
+*   Rohit Sanjay
+*   Shantanu
+*   teresa0605
+*   Thomas M Kehrenberg
+*   Tin Tvrtković
+*   Tushar Sadhwani
+*   Valentin Stanciu
+*   Viicos
+*   Vincent Vanlaer
+*   Wesley Collin Wright
+*   William Santosa
+*   yaegassy
+
+I’d also like to thank my employer, Dropbox, for supporting mypy development.
+
+Posted by Jared Hance
+
+
+## Mypy 1.3
+
+[Wednesday, 10 May 2023](https://mypy-lang.blogspot.com/2023/05/mypy-13-released.html)
+
+ We’ve just uploaded mypy 1.3 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Performance Improvements
+
+*   Improve performance of union subtyping (Shantanu, PR [15104](https://github.com/python/mypy/pull/15104))
+*   Add negative subtype caches (Ivan Levkivskyi, PR [14884](https://github.com/python/mypy/pull/14884))
+
+### Stub Tooling Improvements
+
+*   Stubtest: Check that the stub is abstract if the runtime is, even when the stub is an overloaded method (Alex Waygood, PR [14955](https://github.com/python/mypy/pull/14955))
+*   Stubtest: Verify stub methods or properties are decorated with @final if they are decorated with @final at runtime (Alex Waygood, PR [14951](https://github.com/python/mypy/pull/14951))
+*   Stubtest: Fix stubtest false positives with TypedDicts at runtime (Alex Waygood, PR [14984](https://github.com/python/mypy/pull/14984))
+*   Stubgen: Support @functools.cached\_property (Nikita Sobolev, PR [14981](https://github.com/python/mypy/pull/14981))
+*   Improvements to stubgenc (Chad Dombrova, PR [14564](https://github.com/python/mypy/pull/14564))
+
+### Improvements to attrs
+
+*   Add support for converters with TypeVars on generic attrs classes (Chad Dombrova, PR [14908](https://github.com/python/mypy/pull/14908))
+*   Fix attrs.evolve on bound TypeVar (Ilya Konstantinov, PR [15022](https://github.com/python/mypy/pull/15022))
+
+### Documentation Updates
+
+*   Improve async documentation (Shantanu, PR [14973](https://github.com/python/mypy/pull/14973))
+*   Improvements to cheat sheet (Shantanu, PR [14972](https://github.com/python/mypy/pull/14972))
+*   Add documentation for bytes formatting error code (Shantanu, PR [14971](https://github.com/python/mypy/pull/14971))
+*   Convert insecure links to use HTTPS (Marti Raudsepp, PR [14974](https://github.com/python/mypy/pull/14974))
+*   Also mention overloads in async iterator documentation (Shantanu, PR [14998](https://github.com/python/mypy/pull/14998))
+*   stubtest: Improve allowlist documentation (Shantanu, PR [15008](https://github.com/python/mypy/pull/15008))
+*   Clarify "Using types... but not at runtime" (Jon Shea, PR [15029](https://github.com/python/mypy/pull/15029))
+*   Fix alignment of cheat sheet example (Ondřej Cvacho, PR [15039](https://github.com/python/mypy/pull/15039))
+*   Fix error for callback protocol matching against callable type object (Shantanu, PR [15042](https://github.com/python/mypy/pull/15042))
+
+### Error Reporting Improvements
+
+*   Improve bytes formatting error (Shantanu, PR [14959](https://github.com/python/mypy/pull/14959))
+
+### Mypyc Improvements
+
+*   Fix unions of bools and ints (Tomer Chachamu, PR [15066](https://github.com/python/mypy/pull/15066))
+
+### Other Fixes and Improvements
+
+*   Fix narrowing union types that include Self with isinstance (Christoph Tyralla, PR [14923](https://github.com/python/mypy/pull/14923))
+*   Allow objects matching SupportsKeysAndGetItem to be unpacked (Bryan Forbes, PR [14990](https://github.com/python/mypy/pull/14990))
+*   Check type guard validity for staticmethods (EXPLOSION, PR [14953](https://github.com/python/mypy/pull/14953))
+*   Fix sys.platform when cross-compiling with emscripten (Ethan Smith, PR [14888](https://github.com/python/mypy/pull/14888))
+
+### Typeshed Updates
+
+Typeshed is now modular and distributed as separate PyPI packages for everything except the standard library stubs. Please see [git log](https://github.com/python/typeshed/commits/main?after=b0ed50e9392a23e52445b630a808153e0e256976+0&branch=main&path=stdlib) for full list of typeshed changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+*   Alex Waygood
+*   Amin Alaee
+*   Bryan Forbes
+*   Chad Dombrova
+*   Charlie Denton
+*   Christoph Tyralla
+*   dosisod
+*   Ethan Smith
+*   EXPLOSION
+*   Ilya Konstantinov
+*   Ivan Levkivskyi
+*   Jon Shea
+*   Jukka Lehtosalo
+*   KotlinIsland
+*   Marti Raudsepp
+*   Nikita Sobolev
+*   Ondřej Cvacho
+*   Shantanu
+*   sobolevn
+*   Tomer Chachamu
+*   Yaroslav Halchenko
+
+Posted by Wesley Collin Wright.
+
+
+## Mypy 1.2
+
+[Thursday, 6 April 2023](https://mypy-lang.blogspot.com/2023/04/mypy-12-released.html)
+
+We’ve just uploaded mypy 1.2 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Improvements to Dataclass Transforms
+
+*   Support implicit default for "init" parameter in field specifiers (Wesley Collin Wright and Jukka Lehtosalo, PR [15010](https://github.com/python/mypy/pull/15010))
+*   Support descriptors in dataclass transform (Jukka Lehtosalo, PR [15006](https://github.com/python/mypy/pull/15006))
+*   Fix frozen\_default in incremental mode (Wesley Collin Wright)
+*   Fix frozen behavior for base classes with direct metaclasses (Wesley Collin Wright, PR [14878](https://github.com/python/mypy/pull/14878))
+
+### Mypyc: Native Floats
+
+Mypyc now uses a native, unboxed representation for values of type float. Previously these were heap-allocated Python objects. Native floats are faster and use less memory. Code that uses floating-point operations heavily can be several times faster when using native floats.
+
+Various float operations and math functions also now have optimized implementations. Refer to the [documentation](https://mypyc.readthedocs.io/en/latest/float_operations.html) for a full list.
+
+This can change the behavior of existing code that uses subclasses of float. When assigning an instance of a subclass of float to a variable with the float type, it gets implicitly converted to a float instance when compiled:
+
+```python
+from lib import MyFloat  # MyFloat ia a subclass of "float"
+
+def example() -> None:
+    x = MyFloat(1.5)
+    y: float = x  # Implicit conversion from MyFloat to float
+    print(type(y))  # float, not MyFloat
+```
+
+Previously, implicit conversions were applied to int subclasses but not float subclasses.
+
+Also, int values can no longer be assigned to a variable with type float in compiled code, since these types now have incompatible representations. An explicit conversion is required:
+
+```python
+def example(n: int) -> None:
+    a: float = 1  # Error: cannot assign "int" to "float"
+    b: float = 1.0  # OK
+    c: float = n  # Error
+    d: float = float(n)  # OK
+```
+
+This restriction only applies to assignments, since they could otherwise narrow down the type of a variable from float to int. int values can still be implicitly converted to float when passed as arguments to functions that expect float values.
+
+Note that mypyc still doesn’t support arrays of unboxed float values. Using list\[float\] involves heap-allocated float objects, since list can only store boxed values. Support for efficient floating point arrays is one of the next major planned mypyc features.
+
+Related changes:
+
+*   Use a native unboxed representation for floats (Jukka Lehtosalo, PR [14880](https://github.com/python/mypy/pull/14880))
+*   Document native floats and integers (Jukka Lehtosalo, PR [14927](https://github.com/python/mypy/pull/14927))
+*   Fixes to float to int conversion (Jukka Lehtosalo, PR [14936](https://github.com/python/mypy/pull/14936))
+
+### Mypyc: Native Integers
+
+Mypyc now supports signed 32-bit and 64-bit integer types in addition to the arbitrary-precision int type. You can use the types mypy\_extensions.i32 and mypy\_extensions.i64 to speed up code that uses integer operations heavily.
+
+Simple example:
+```python
+from mypy_extensions import i64
+
+def inc(x: i64) -> i64:
+    return x + 1
+```
+
+Refer to the [documentation](https://mypyc.readthedocs.io/en/latest/using_type_annotations.html#native-integer-types) for more information. This feature was contributed by Jukka Lehtosalo.
+
+### Other Mypyc Fixes and Improvements
+
+*   Support iterating over a TypedDict (Richard Si, PR [14747](https://github.com/python/mypy/pull/14747))
+*   Faster coercions between different tuple types (Jukka Lehtosalo, PR [14899](https://github.com/python/mypy/pull/14899))
+*   Faster calls via type aliases (Jukka Lehtosalo, PR [14784](https://github.com/python/mypy/pull/14784))
+*   Faster classmethod calls via cls (Jukka Lehtosalo, PR [14789](https://github.com/python/mypy/pull/14789))
+
+### Fixes to Crashes
+
+*   Fix crash on class-level import in protocol definition (Ivan Levkivskyi, PR [14926](https://github.com/python/mypy/pull/14926))
+*   Fix crash on single item union of alias (Ivan Levkivskyi, PR [14876](https://github.com/python/mypy/pull/14876))
+*   Fix crash on ParamSpec in incremental mode (Ivan Levkivskyi, PR [14885](https://github.com/python/mypy/pull/14885))
+
+### Documentation Updates
+
+*   Update adopting \--strict documentation for 1.0 (Shantanu, PR [14865](https://github.com/python/mypy/pull/14865))
+*   Some minor documentation tweaks (Jukka Lehtosalo, PR [14847](https://github.com/python/mypy/pull/14847))
+*   Improve documentation of top level mypy: disable-error-code comment (Nikita Sobolev, PR [14810](https://github.com/python/mypy/pull/14810))
+
+### Error Reporting Improvements
+
+*   Add error code to `typing_extensions` suggestion (Shantanu, PR [14881](https://github.com/python/mypy/pull/14881))
+*   Add a separate error code for top-level await (Nikita Sobolev, PR [14801](https://github.com/python/mypy/pull/14801))
+*   Don’t suggest two obsolete stub packages (Jelle Zijlstra, PR [14842](https://github.com/python/mypy/pull/14842))
+*   Add suggestions for pandas-stubs and lxml-stubs (Shantanu, PR [14737](https://github.com/python/mypy/pull/14737))
+
+### Other Fixes and Improvements
+
+*   Multiple inheritance considers callable objects as subtypes of functions (Christoph Tyralla, PR [14855](https://github.com/python/mypy/pull/14855))
+*   stubtest: Respect @final runtime decorator and enforce it in stubs (Nikita Sobolev, PR [14922](https://github.com/python/mypy/pull/14922))
+*   Fix false positives related to type\[<type-var>\] (sterliakov, PR [14756](https://github.com/python/mypy/pull/14756))
+*   Fix duplication of ParamSpec prefixes and properly substitute ParamSpecs (EXPLOSION, PR [14677](https://github.com/python/mypy/pull/14677))
+*   Fix line number if `__iter__` is incorrectly reported as missing (Jukka Lehtosalo, PR [14893](https://github.com/python/mypy/pull/14893))
+*   Fix incompatible overrides of overloaded generics with self types (Shantanu, PR [14882](https://github.com/python/mypy/pull/14882))
+*   Allow SupportsIndex in slice expressions (Shantanu, PR [14738](https://github.com/python/mypy/pull/14738))
+*   Support if statements in bodies of dataclasses and classes that use dataclass\_transform (Jacek Chałupka, PR [14854](https://github.com/python/mypy/pull/14854))
+*   Allow iterable class objects to be unpacked (including enums) (Alex Waygood, PR [14827](https://github.com/python/mypy/pull/14827))
+*   Fix narrowing for walrus expressions used in match statements (Shantanu, PR [14844](https://github.com/python/mypy/pull/14844))
+*   Add signature for attr.evolve (Ilya Konstantinov, PR [14526](https://github.com/python/mypy/pull/14526))
+*   Fix Any inference when unpacking iterators that don't directly inherit from typing.Iterator (Alex Waygood, PR [14821](https://github.com/python/mypy/pull/14821))
+*   Fix unpack with overloaded `__iter__` method (Nikita Sobolev, PR [14817](https://github.com/python/mypy/pull/14817))
+*   Reduce size of JSON data in mypy cache (dosisod, PR [14808](https://github.com/python/mypy/pull/14808))
+*   Improve “used before definition” checks when a local definition has the same name as a global definition (Stas Ilinskiy, PR [14517](https://github.com/python/mypy/pull/14517))
+*   Honor NoReturn as \_\_setitem\_\_ return type to mark unreachable code (sterliakov, PR [12572](https://github.com/python/mypy/pull/12572))
+
+### Typeshed Updates
+
+Typeshed is now modular and distributed as separate PyPI packages for everything except the standard library stubs. Please see [git log](https://github.com/python/typeshed/commits/main?after=a544b75320e97424d2d927605316383c755cdac0+0&branch=main&path=stdlib) for full list of typeshed changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+*   Alex Waygood
+*   Avasam
+*   Christoph Tyralla
+*   dosisod
+*   EXPLOSION
+*   Ilya Konstantinov
+*   Ivan Levkivskyi
+*   Jacek Chałupka
+*   Jelle Zijlstra
+*   Jukka Lehtosalo
+*   Marc Mueller
+*   Max Murin
+*   Nikita Sobolev
+*   Richard Si
+*   Shantanu
+*   Stas Ilinskiy
+*   sterliakov
+*   Wesley Collin Wright
+
+Posted by Jukka Lehtosalo
+
+
+## Mypy 1.1.1
+
+[Monday, 6 March 2023](https://mypy-lang.blogspot.com/2023/03/mypy-111-released.html)
+
+ We’ve just uploaded mypy 1.1.1 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### Support for `dataclass_transform``
+
+This release adds full support for the dataclass\_transform decorator defined in [PEP 681](https://peps.python.org/pep-0681/#decorator-function-example). This allows decorators, base classes, and metaclasses that generate a \_\_init\_\_ method or other methods based on the properties of that class (similar to dataclasses) to have those methods recognized by mypy.
+
+This was contributed by Wesley Collin Wright.
+
+### Dedicated Error Code for Method Assignments
+
+Mypy can’t safely check all assignments to methods (a form of monkey patching), so mypy generates an error by default. To make it easier to ignore this error, mypy now uses the new error code method-assign for this. By disabling this error code in a file or globally, mypy will no longer complain about assignments to methods if the signatures are compatible.
+
+Mypy also supports the old error code assignment for these assignments to prevent a backward compatibility break. More generally, we can use this mechanism in the future if we wish to split or rename another existing error code without causing backward compatibility issues.
+
+This was contributed by Ivan Levkivskyi (PR [14570](https://github.com/python/mypy/pull/14570)).
+
+### Fixes to Crashes
+
+*   Fix a crash on walrus in comprehension at class scope (Ivan Levkivskyi, PR [14556](https://github.com/python/mypy/pull/14556))
+*   Fix crash related to value-constrained TypeVar (Shantanu, PR [14642](https://github.com/python/mypy/pull/14642))
+
+### Fixes to Cache Corruption
+
+*   Fix generic TypedDict/NamedTuple caching (Ivan Levkivskyi, PR [14675](https://github.com/python/mypy/pull/14675))
+
+### Mypyc Fixes and Improvements
+
+*   Raise "non-trait base must be first..." error less frequently (Richard Si, PR [14468](https://github.com/python/mypy/pull/14468))
+*   Generate faster code for bool comparisons and arithmetic (Jukka Lehtosalo, PR [14489](https://github.com/python/mypy/pull/14489))
+*   Optimize \_\_(a)enter\_\_/\_\_(a)exit\_\_ for native classes (Jared Hance, PR [14530](https://github.com/python/mypy/pull/14530))
+*   Detect if attribute definition conflicts with base class/trait (Jukka Lehtosalo, PR [14535](https://github.com/python/mypy/pull/14535))
+*   Support \_\_(r)divmod\_\_ dunders (Richard Si, PR [14613](https://github.com/python/mypy/pull/14613))
+*   Support \_\_pow\_\_, \_\_rpow\_\_, and \_\_ipow\_\_ dunders (Richard Si, PR [14616](https://github.com/python/mypy/pull/14616))
+*   Fix crash on star unpacking to underscore (Ivan Levkivskyi, PR [14624](https://github.com/python/mypy/pull/14624))
+*   Fix iterating over a union of dicts (Richard Si, PR [14713](https://github.com/python/mypy/pull/14713))
+
+### Fixes to Detecting Undefined Names (used-before-def)
+
+*   Correctly handle walrus operator (Stas Ilinskiy, PR [14646](https://github.com/python/mypy/pull/14646))
+*   Handle walrus declaration in match subject correctly (Stas Ilinskiy, PR [14665](https://github.com/python/mypy/pull/14665))
+
+### Stubgen Improvements
+
+Stubgen is a tool for automatically generating draft stubs for libraries.
+
+*   Allow aliases below the top level (Chad Dombrova, PR [14388](https://github.com/python/mypy/pull/14388))
+*   Fix crash with PEP 604 union in type variable bound (Shantanu, PR [14557](https://github.com/python/mypy/pull/14557))
+*   Preserve PEP 604 unions in generated .pyi files (hamdanal, PR [14601](https://github.com/python/mypy/pull/14601))
+
+### Stubtest Improvements
+
+Stubtest is a tool for testing that stubs conform to the implementations.
+
+*   Update message format so that it’s easier to go to error location (Avasam, PR [14437](https://github.com/python/mypy/pull/14437))
+*   Handle name-mangling edge cases better (Alex Waygood, PR [14596](https://github.com/python/mypy/pull/14596))
+
+### Changes to Error Reporting and Messages
+
+*   Add new TypedDict error code typeddict-unknown-key (JoaquimEsteves, PR [14225](https://github.com/python/mypy/pull/14225))
+*   Give arguments a more reasonable location in error messages (Max Murin, PR [14562](https://github.com/python/mypy/pull/14562))
+*   In error messages, quote just the module's name (Ilya Konstantinov, PR [14567](https://github.com/python/mypy/pull/14567))
+*   Improve misleading message about Enum() (Rodrigo Silva, PR [14590](https://github.com/python/mypy/pull/14590))
+*   Suggest importing from `typing_extensions` if definition is not in typing (Shantanu, PR [14591](https://github.com/python/mypy/pull/14591))
+*   Consistently use type-abstract error code (Ivan Levkivskyi, PR [14619](https://github.com/python/mypy/pull/14619))
+*   Consistently use literal-required error code for TypedDicts (Ivan Levkivskyi, PR [14621](https://github.com/python/mypy/pull/14621))
+*   Adjust inconsistent dataclasses plugin error messages (Wesley Collin Wright, PR [14637](https://github.com/python/mypy/pull/14637))
+*   Consolidate literal bool argument error messages (Wesley Collin Wright, PR [14693](https://github.com/python/mypy/pull/14693))
+
+### Other Fixes and Improvements
+
+*   Check that type guards accept a positional argument (EXPLOSION, PR [14238](https://github.com/python/mypy/pull/14238))
+*   Fix bug with in operator used with a union of Container and Iterable (Max Murin, PR [14384](https://github.com/python/mypy/pull/14384))
+*   Support protocol inference for type\[T\] via metaclass (Ivan Levkivskyi, PR [14554](https://github.com/python/mypy/pull/14554))
+*   Allow overlapping comparisons between bytes-like types (Shantanu, PR [14658](https://github.com/python/mypy/pull/14658))
+*   Fix mypy daemon documentation link in README (Ivan Levkivskyi, PR [14644](https://github.com/python/mypy/pull/14644))
+
+### Typeshed Updates
+
+Typeshed is now modular and distributed as separate PyPI packages for everything except the standard library stubs. Please see [git log](https://github.com/python/typeshed/commits/main?after=5ebf892d0710a6e87925b8d138dfa597e7bb11cc+0&branch=main&path=stdlib) for full list of typeshed changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+*   Alex Waygood
+*   Avasam
+*   Chad Dombrova
+*   dosisod
+*   EXPLOSION
+*   hamdanal
+*   Ilya Konstantinov
+*   Ivan Levkivskyi
+*   Jared Hance
+*   JoaquimEsteves
+*   Jukka Lehtosalo
+*   Marc Mueller
+*   Max Murin
+*   Michael Lee
+*   Michael R. Crusoe
+*   Richard Si
+*   Rodrigo Silva
+*   Shantanu
+*   Stas Ilinskiy
+*   Wesley Collin Wright
+*   Yilei "Dolee" Yang
+*   Yurii Karabas
+
+We’d also like to thank our employer, Dropbox, for funding the mypy core team.
+
+Posted by Max Murin
+
+
+## Mypy 1.0
+
+[Monday, 6 February 2023](https://mypy-lang.blogspot.com/2023/02/mypy-10-released.html)
+
+We’ve just uploaded mypy 1.0 to the Python Package Index ([PyPI](https://pypi.org/project/mypy/)). Mypy is a static type checker for Python. This release includes new features, performance improvements and bug fixes. You can install it as follows:
+
+    python3 -m pip install -U mypy
+
+You can read the full documentation for this release on [Read the Docs](http://mypy.readthedocs.io).
+
+### New Release Versioning Scheme
+
+Now that mypy reached 1.0, we’ll switch to a new versioning scheme. Mypy version numbers will be of form x.y.z.
+
+Rules:
+
+*   The major release number (x) is incremented if a feature release includes a significant backward incompatible change that affects a significant fraction of users.
+*   The minor release number (y) is incremented on each feature release. Minor releases include updated stdlib stubs from typeshed.
+*   The point release number (z) is incremented when there are fixes only.
+
+Mypy doesn't use SemVer, since most minor releases have at least minor backward incompatible changes in typeshed, at the very least. Also, many type checking features find new legitimate issues in code. These are not considered backward incompatible changes, unless the number of new errors is very high.
+
+Any significant backward incompatible change must be announced in the blog post for the previous feature release, before making the change. The previous release must also provide a flag to explicitly enable or disable the new behavior (whenever practical), so that users will be able to prepare for the changes and report issues. We should keep the feature flag for at least a few releases after we've switched the default.
+
+See [”Release Process” in the mypy wiki](https://github.com/python/mypy/wiki/Release-Process) for more details and for the most up-to-date version of the versioning scheme.
+
+### Performance Improvements
+
+Mypy 1.0 is up to 40% faster than mypy 0.991 when type checking the Dropbox internal codebase. We also set up a daily job to measure the performance of the most recent development version of mypy to make it easier to track changes in performance.
+
+Many optimizations contributed to this improvement:
+
+*   Improve performance for errors on class with many attributes (Shantanu, PR [14379](https://github.com/python/mypy/pull/14379))
+*   Speed up make\_simplified\_union (Jukka Lehtosalo, PR [14370](https://github.com/python/mypy/pull/14370))
+*   Micro-optimize get\_proper\_type(s) (Jukka Lehtosalo, PR [14369](https://github.com/python/mypy/pull/14369))
+*   Micro-optimize flatten\_nested\_unions (Jukka Lehtosalo, PR [14368](https://github.com/python/mypy/pull/14368))
+*   Some semantic analyzer micro-optimizations (Jukka Lehtosalo, PR [14367](https://github.com/python/mypy/pull/14367))
+*   A few miscellaneous micro-optimizations (Jukka Lehtosalo, PR [14366](https://github.com/python/mypy/pull/14366))
+*   Optimization: Avoid a few uses of contextmanagers in semantic analyzer (Jukka Lehtosalo, PR [14360](https://github.com/python/mypy/pull/14360))
+*   Optimization: Enable always defined attributes in Type subclasses (Jukka Lehtosalo, PR [14356](https://github.com/python/mypy/pull/14356))
+*   Optimization: Remove expensive context manager in type analyzer (Jukka Lehtosalo, PR [14357](https://github.com/python/mypy/pull/14357))
+*   subtypes: fast path for Union/Union subtype check (Hugues, PR [14277](https://github.com/python/mypy/pull/14277))
+*   Micro-optimization: avoid Bogus\[int\] types that cause needless boxing (Jukka Lehtosalo, PR [14354](https://github.com/python/mypy/pull/14354))
+*   Avoid slow error message logic if errors not shown to user (Jukka Lehtosalo, PR [14336](https://github.com/python/mypy/pull/14336))
+*   Speed up the implementation of hasattr() checks (Jukka Lehtosalo, PR [14333](https://github.com/python/mypy/pull/14333))
+*   Avoid the use of a context manager in hot code path (Jukka Lehtosalo, PR [14331](https://github.com/python/mypy/pull/14331))
+*   Change various type queries into faster bool type queries (Jukka Lehtosalo, PR [14330](https://github.com/python/mypy/pull/14330))
+*   Speed up recursive type check (Jukka Lehtosalo, PR [14326](https://github.com/python/mypy/pull/14326))
+*   Optimize subtype checking by avoiding a nested function (Jukka Lehtosalo, PR [14325](https://github.com/python/mypy/pull/14325))
+*   Optimize type parameter checks in subtype checking (Jukka Lehtosalo, PR [14324](https://github.com/python/mypy/pull/14324))
+*   Speed up freshening type variables (Jukka Lehtosalo, PR [14323](https://github.com/python/mypy/pull/14323))
+*   Optimize implementation of TypedDict types for \*\*kwds (Jukka Lehtosalo, PR [14316](https://github.com/python/mypy/pull/14316))
+
+### Warn About Variables Used Before Definition
+
+Mypy will now generate an error if you use a variable before it’s defined. This feature is enabled by default. By default mypy reports an error when it infers that a variable is always undefined.
+```python
+y = x  # E: Name "x" is used before definition [used-before-def]
+x = 0
+```
+This feature was contributed by Stas Ilinskiy.
+
+### Detect Possibly Undefined Variables (Experimental)
+
+A new experimental possibly-undefined error code is now available that will detect variables that may be undefined:
+```python
+    if b:
+        x = 0
+    print(x)  # Error: Name "x" may be undefined [possibly-undefined]
+```
+The error code is disabled be default, since it can generate false positives.
+
+This feature was contributed by Stas Ilinskiy.
+
+### Support the “Self” Type
+
+There is now a simpler syntax for declaring [generic self types](https://mypy.readthedocs.io/en/stable/generics.html#generic-methods-and-generic-self) introduced in [PEP 673](https://peps.python.org/pep-0673/): the Self type. You no longer have to define a type variable to use “self types”, and you can use them with attributes. Example from mypy documentation:
+```python
+from typing import Self
+
+class Friend:
+    other: Self | None = None
+
+    @classmethod
+    def make_pair(cls) -> tuple[Self, Self]:
+        a, b = cls(), cls()
+        a.other = b
+        b.other = a
+        return a, b
+
+class SuperFriend(Friend):
+    pass
+
+# a and b have the inferred type "SuperFriend", not "Friend"
+a, b = SuperFriend.make_pair()
+```
+The feature was introduced in Python 3.11. In earlier Python versions a backport of Self is available in `typing_extensions`.
+
+This was contributed by Ivan Levkivskyi (PR [14041](https://github.com/python/mypy/pull/14041)).
+
+### Support ParamSpec in Type Aliases
+
+ParamSpec and Concatenate can now be used in type aliases. Example:
+```python
+from typing import ParamSpec, Callable
+
+P = ParamSpec("P")
+A = Callable[P, None]
+
+def f(c: A[int, str]) -> None:
+    c(1, "x")
+```
+This feature was contributed by Ivan Levkivskyi (PR [14159](https://github.com/python/mypy/pull/14159)).
+
+### ParamSpec and Generic Self Types No Longer Experimental
+
+Support for ParamSpec ([PEP 612](https://www.python.org/dev/peps/pep-0612/)) and generic self types are no longer considered experimental.
+
+### Miscellaneous New Features
+
+*   Minimal, partial implementation of dataclass\_transform ([PEP 681](https://peps.python.org/pep-0681/)) (Wesley Collin Wright, PR [14523](https://github.com/python/mypy/pull/14523))
+*   Add basic support for `typing_extensions`.TypeVar (Marc Mueller, PR [14313](https://github.com/python/mypy/pull/14313))
+*   Add \--debug-serialize option (Marc Mueller, PR [14155](https://github.com/python/mypy/pull/14155))
+*   Constant fold initializers of final variables (Jukka Lehtosalo, PR [14283](https://github.com/python/mypy/pull/14283))
+*   Enable Final instance attributes for attrs (Tin Tvrtković, PR [14232](https://github.com/python/mypy/pull/14232))
+*   Allow function arguments as base classes (Ivan Levkivskyi, PR [14135](https://github.com/python/mypy/pull/14135))
+*   Allow super() with mixin protocols (Ivan Levkivskyi, PR [14082](https://github.com/python/mypy/pull/14082))
+*   Add type inference for dict.keys membership (Matthew Hughes, PR [13372](https://github.com/python/mypy/pull/13372))
+*   Generate error for class attribute access if attribute is defined with `__slots__` (Harrison McCarty, PR [14125](https://github.com/python/mypy/pull/14125))
+*   Support additional attributes in callback protocols (Ivan Levkivskyi, PR [14084](https://github.com/python/mypy/pull/14084))
+
+### Fixes to Crashes
+
+*   Fix crash on prefixed ParamSpec with forward reference (Ivan Levkivskyi, PR [14569](https://github.com/python/mypy/pull/14569))
+*   Fix internal crash when resolving the same partial type twice (Shantanu, PR [14552](https://github.com/python/mypy/pull/14552))
+*   Fix crash in daemon mode on new import cycle (Ivan Levkivskyi, PR [14508](https://github.com/python/mypy/pull/14508))
+*   Fix crash in mypy daemon (Ivan Levkivskyi, PR [14497](https://github.com/python/mypy/pull/14497))
+*   Fix crash on Any metaclass in incremental mode (Ivan Levkivskyi, PR [14495](https://github.com/python/mypy/pull/14495))
+*   Fix crash in await inside comprehension outside function (Ivan Levkivskyi, PR [14486](https://github.com/python/mypy/pull/14486))
+*   Fix crash in Self type on forward reference in upper bound (Ivan Levkivskyi, PR [14206](https://github.com/python/mypy/pull/14206))
+*   Fix a crash when incorrect super() is used outside a method (Ivan Levkivskyi, PR [14208](https://github.com/python/mypy/pull/14208))
+*   Fix crash on overriding with frozen attrs (Ivan Levkivskyi, PR [14186](https://github.com/python/mypy/pull/14186))
+*   Fix incremental mode crash on generic function appearing in nested position (Ivan Levkivskyi, PR [14148](https://github.com/python/mypy/pull/14148))
+*   Fix daemon crash on malformed NamedTuple (Ivan Levkivskyi, PR [14119](https://github.com/python/mypy/pull/14119))
+*   Fix crash during ParamSpec inference (Ivan Levkivskyi, PR [14118](https://github.com/python/mypy/pull/14118))
+*   Fix crash on nested generic callable (Ivan Levkivskyi, PR [14093](https://github.com/python/mypy/pull/14093))
+*   Fix crashes with unpacking SyntaxError (Shantanu, PR [11499](https://github.com/python/mypy/pull/11499))
+*   Fix crash on partial type inference within a lambda (Ivan Levkivskyi, PR [14087](https://github.com/python/mypy/pull/14087))
+*   Fix crash with enums (Michael Lee, PR [14021](https://github.com/python/mypy/pull/14021))
+*   Fix crash with malformed TypedDicts and disllow-any-expr (Michael Lee, PR [13963](https://github.com/python/mypy/pull/13963))
+
+### Error Reporting Improvements
+
+*   More helpful error for missing self (Shantanu, PR [14386](https://github.com/python/mypy/pull/14386))
+*   Add error-code truthy-iterable (Marc Mueller, PR [13762](https://github.com/python/mypy/pull/13762))
+*   Fix pluralization in error messages (KotlinIsland, PR [14411](https://github.com/python/mypy/pull/14411))
+
+### Mypyc: Support Match Statement
+
+Mypyc can now compile Python 3.10 match statements.
+
+This was contributed by dosisod (PR [13953](https://github.com/python/mypy/pull/13953)).
+
+### Other Mypyc Fixes and Improvements
+
+*   Optimize int(x)/float(x)/complex(x) on instances of native classes (Richard Si, PR [14450](https://github.com/python/mypy/pull/14450))
+*   Always emit warnings (Richard Si, PR [14451](https://github.com/python/mypy/pull/14451))
+*   Faster bool and integer conversions (Jukka Lehtosalo, PR [14422](https://github.com/python/mypy/pull/14422))
+*   Support attributes that override properties (Jukka Lehtosalo, PR [14377](https://github.com/python/mypy/pull/14377))
+*   Precompute set literals for "in" operations and iteration (Richard Si, PR [14409](https://github.com/python/mypy/pull/14409))
+*   Don't load targets with forward references while setting up non-extension class `__all__` (Richard Si, PR [14401](https://github.com/python/mypy/pull/14401))
+*   Compile away NewType type calls (Richard Si, PR [14398](https://github.com/python/mypy/pull/14398))
+*   Improve error message for multiple inheritance (Joshua Bronson, PR [14344](https://github.com/python/mypy/pull/14344))
+*   Simplify union types (Jukka Lehtosalo, PR [14363](https://github.com/python/mypy/pull/14363))
+*   Fixes to union simplification (Jukka Lehtosalo, PR [14364](https://github.com/python/mypy/pull/14364))
+*   Fix for typeshed changes to Collection (Shantanu, PR [13994](https://github.com/python/mypy/pull/13994))
+*   Allow use of enum.Enum (Shantanu, PR [13995](https://github.com/python/mypy/pull/13995))
+*   Fix compiling on Arch Linux (dosisod, PR [13978](https://github.com/python/mypy/pull/13978))
+
+### Documentation Improvements
+
+*   Various documentation and error message tweaks (Jukka Lehtosalo, PR [14574](https://github.com/python/mypy/pull/14574))
+*   Improve Generics documentation (Shantanu, PR [14587](https://github.com/python/mypy/pull/14587))
+*   Improve protocols documentation (Shantanu, PR [14577](https://github.com/python/mypy/pull/14577))
+*   Improve dynamic typing documentation (Shantanu, PR [14576](https://github.com/python/mypy/pull/14576))
+*   Improve the Common Issues page (Shantanu, PR [14581](https://github.com/python/mypy/pull/14581))
+*   Add a top-level TypedDict page (Shantanu, PR [14584](https://github.com/python/mypy/pull/14584))
+*   More improvements to getting started documentation (Shantanu, PR [14572](https://github.com/python/mypy/pull/14572))
+*   Move truthy-function documentation from “optional checks” to “enabled by default” (Anders Kaseorg, PR [14380](https://github.com/python/mypy/pull/14380))
+*   Avoid use of implicit optional in decorator factory documentation (Tom Schraitle, PR [14156](https://github.com/python/mypy/pull/14156))
+*   Clarify documentation surrounding install-types (Shantanu, PR [14003](https://github.com/python/mypy/pull/14003))
+*   Improve searchability for module level type ignore errors (Shantanu, PR [14342](https://github.com/python/mypy/pull/14342))
+*   Advertise mypy daemon in README (Ivan Levkivskyi, PR [14248](https://github.com/python/mypy/pull/14248))
+*   Add link to error codes in README (Ivan Levkivskyi, PR [14249](https://github.com/python/mypy/pull/14249))
+*   Document that report generation disables cache (Ilya Konstantinov, PR [14402](https://github.com/python/mypy/pull/14402))
+*   Stop saying mypy is beta software (Ivan Levkivskyi, PR [14251](https://github.com/python/mypy/pull/14251))
+*   Flycheck-mypy is deprecated, since its functionality was merged to Flycheck (Ivan Levkivskyi, PR [14247](https://github.com/python/mypy/pull/14247))
+*   Update code example in "Declaring decorators" (ChristianWitzler, PR [14131](https://github.com/python/mypy/pull/14131))
+
+### Stubtest Improvements
+
+Stubtest is a tool for testing that stubs conform to the implementations.
+
+*   Improve error message for `__all__`\-related errors (Alex Waygood, PR [14362](https://github.com/python/mypy/pull/14362))
+*   Improve heuristics for determining whether global-namespace names are imported (Alex Waygood, PR [14270](https://github.com/python/mypy/pull/14270))
+*   Catch BaseException on module imports (Shantanu, PR [14284](https://github.com/python/mypy/pull/14284))
+*   Associate exported symbol error with `__all__` object\_path (Nikita Sobolev, PR [14217](https://github.com/python/mypy/pull/14217))
+*   Add \_\_warningregistry\_\_ to the list of ignored module dunders (Nikita Sobolev, PR [14218](https://github.com/python/mypy/pull/14218))
+*   If a default is present in the stub, check that it is correct (Jelle Zijlstra, PR [14085](https://github.com/python/mypy/pull/14085))
+
+### Stubgen Improvements
+
+Stubgen is a tool for automatically generating draft stubs for libraries.
+
+*   Treat dlls as C modules (Shantanu, PR [14503](https://github.com/python/mypy/pull/14503))
+
+### Other Notable Fixes and Improvements
+
+*   Update stub suggestions based on recent typeshed changes (Alex Waygood, PR [14265](https://github.com/python/mypy/pull/14265))
+*   Fix attrs protocol check with cache (Marc Mueller, PR [14558](https://github.com/python/mypy/pull/14558))
+*   Fix strict equality check if operand item type has custom \_\_eq\_\_ (Jukka Lehtosalo, PR [14513](https://github.com/python/mypy/pull/14513))
+*   Don't consider object always truthy (Jukka Lehtosalo, PR [14510](https://github.com/python/mypy/pull/14510))
+*   Properly support union of TypedDicts as dict literal context (Ivan Levkivskyi, PR [14505](https://github.com/python/mypy/pull/14505))
+*   Properly expand type in generic class with Self and TypeVar with values (Ivan Levkivskyi, PR [14491](https://github.com/python/mypy/pull/14491))
+*   Fix recursive TypedDicts/NamedTuples defined with call syntax (Ivan Levkivskyi, PR [14488](https://github.com/python/mypy/pull/14488))
+*   Fix type inference issue when a class inherits from Any (Shantanu, PR [14404](https://github.com/python/mypy/pull/14404))
+*   Fix false positive on generic base class with six (Ivan Levkivskyi, PR [14478](https://github.com/python/mypy/pull/14478))
+*   Don't read scripts without extensions as modules in namespace mode (Tim Geypens, PR [14335](https://github.com/python/mypy/pull/14335))
+*   Fix inference for constrained type variables within unions (Christoph Tyralla, PR [14396](https://github.com/python/mypy/pull/14396))
+*   Fix Unpack imported from typing (Marc Mueller, PR [14378](https://github.com/python/mypy/pull/14378))
+*   Allow trailing commas in ini configuration of multiline values (Nikita Sobolev, PR [14240](https://github.com/python/mypy/pull/14240))
+*   Fix false negatives involving Unions and generators or coroutines (Shantanu, PR [14224](https://github.com/python/mypy/pull/14224))
+*   Fix ParamSpec constraint for types as callable (Vincent Vanlaer, PR [14153](https://github.com/python/mypy/pull/14153))
+*   Fix type aliases with fixed-length tuples (Jukka Lehtosalo, PR [14184](https://github.com/python/mypy/pull/14184))
+*   Fix issues with type aliases and new style unions (Jukka Lehtosalo, PR [14181](https://github.com/python/mypy/pull/14181))
+*   Simplify unions less aggressively (Ivan Levkivskyi, PR [14178](https://github.com/python/mypy/pull/14178))
+*   Simplify callable overlap logic (Ivan Levkivskyi, PR [14174](https://github.com/python/mypy/pull/14174))
+*   Try empty context when assigning to union typed variables (Ivan Levkivskyi, PR [14151](https://github.com/python/mypy/pull/14151))
+*   Improvements to recursive types (Ivan Levkivskyi, PR [14147](https://github.com/python/mypy/pull/14147))
+*   Make non-numeric non-empty FORCE\_COLOR truthy (Shantanu, PR [14140](https://github.com/python/mypy/pull/14140))
+*   Fix to recursive type aliases (Ivan Levkivskyi, PR [14136](https://github.com/python/mypy/pull/14136))
+*   Correctly handle Enum name on Python 3.11 (Ivan Levkivskyi, PR [14133](https://github.com/python/mypy/pull/14133))
+*   Fix class objects falling back to metaclass for callback protocol (Ivan Levkivskyi, PR [14121](https://github.com/python/mypy/pull/14121))
+*   Correctly support self types in callable ClassVar (Ivan Levkivskyi, PR [14115](https://github.com/python/mypy/pull/14115))
+*   Fix type variable clash in nested positions and in attributes (Ivan Levkivskyi, PR [14095](https://github.com/python/mypy/pull/14095))
+*   Allow class variable as implementation for read only attribute (Ivan Levkivskyi, PR [14081](https://github.com/python/mypy/pull/14081))
+*   Prevent warnings from causing dmypy to fail (Andrzej Bartosiński, PR [14102](https://github.com/python/mypy/pull/14102))
+*   Correctly process nested definitions in mypy daemon (Ivan Levkivskyi, PR [14104](https://github.com/python/mypy/pull/14104))
+*   Don't consider a branch unreachable if there is a possible promotion (Ivan Levkivskyi, PR [14077](https://github.com/python/mypy/pull/14077))
+*   Fix incompatible overrides of overloaded methods in concrete subclasses (Shantanu, PR [14017](https://github.com/python/mypy/pull/14017))
+*   Fix new style union syntax in type aliases (Jukka Lehtosalo, PR [14008](https://github.com/python/mypy/pull/14008))
+*   Fix and optimise overload compatibility checking (Shantanu, PR [14018](https://github.com/python/mypy/pull/14018))
+*   Improve handling of redefinitions through imports (Shantanu, PR [13969](https://github.com/python/mypy/pull/13969))
+*   Preserve (some) implicitly exported types (Shantanu, PR [13967](https://github.com/python/mypy/pull/13967))
+
+### Typeshed Updates
+
+Typeshed is now modular and distributed as separate PyPI packages for everything except the standard library stubs. Please see [git log](https://github.com/python/typeshed/commits/main?after=ea0ae2155e8a04c9837903c3aff8dd5ad5f36ebc+0&branch=main&path=stdlib) for full list of typeshed changes.
+
+### Acknowledgements
+
+Thanks to all mypy contributors who contributed to this release:
+
+*   Alessio Izzo
+*   Alex Waygood
+*   Anders Kaseorg
+*   Andrzej Bartosiński
+*   Avasam
+*   ChristianWitzler
+*   Christoph Tyralla
+*   dosisod
+*   Harrison McCarty
+*   Hugo van Kemenade
+*   Hugues
+*   Ilya Konstantinov
+*   Ivan Levkivskyi
+*   Jelle Zijlstra
+*   jhance
+*   johnthagen
+*   Jonathan Daniel
+*   Joshua Bronson
+*   Jukka Lehtosalo
+*   KotlinIsland
+*   Lakshay Bisht
+*   Lefteris Karapetsas
+*   Marc Mueller
+*   Matthew Hughes
+*   Michael Lee
+*   Nick Drozd
+*   Nikita Sobolev
+*   Richard Si
+*   Shantanu
+*   Stas Ilinskiy
+*   Tim Geypens
+*   Tin Tvrtković
+*   Tom Schraitle
+*   Valentin Stanciu
+*   Vincent Vanlaer
+
+We’d also like to thank our employer, Dropbox, for funding the mypy core team.
+
+Posted by Stas Ilinskiy
+
+## Previous releases
+
+For information about previous releases, refer to the posts at https://mypy-lang.blogspot.com/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d169d7f3159e..8d7dd2d1e886 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -18,7 +18,7 @@ articulated in the [Python Community Code of Conduct](https://www.python.org/psf
 
 #### (1) Fork the mypy repository
 
-Within Github, navigate to <https://github.com/python/mypy> and fork the repository.
+Within GitHub, navigate to <https://github.com/python/mypy> and fork the repository.
 
 #### (2) Clone the mypy repository and enter into it
 
@@ -30,22 +30,28 @@ cd mypy
 #### (3) Create then activate a virtual environment
 
 ```bash
-# On Windows, the commands may be slightly different. For more details, see
-# https://docs.python.org/3/library/venv.html#creating-virtual-environments
 python3 -m venv venv
 source venv/bin/activate
 ```
 
+```bash
+# For Windows use
+python -m venv venv
+. venv/Scripts/activate
+
+# For more details, see https://docs.python.org/3/library/venv.html#creating-virtual-environments
+```
+
 #### (4) Install the test requirements and the project
 
 ```bash
-python3 -m pip install -r test-requirements.txt
-python3 -m pip install -e .
+python -m pip install -r test-requirements.txt
+python -m pip install -e .
 hash -r  # This resets shell PATH cache, not necessary on Windows
 ```
 
 > **Note**
-> You'll need Python 3.8 or higher to install all requirements listed in
+> You'll need Python 3.9 or higher to install all requirements listed in
 > test-requirements.txt
 
 ### Running tests
@@ -59,45 +65,64 @@ However, if you wish to do so, you can run the full test suite
 like this:
 
 ```bash
-python3 runtests.py
-```
-
-You can also use `tox` to run tests (`tox` handles setting up the test environment for you):
-
-```bash
-tox run -e py
-
-# Or some specific python version:
-tox run -e py39
-
-# Or some specific command:
-tox run -e lint
+python runtests.py
 ```
 
 Some useful commands for running specific tests include:
 
 ```bash
 # Use mypy to check mypy's own code
-python3 runtests.py self
+python runtests.py self
 # or equivalently:
-python3 -m mypy --config-file mypy_self_check.ini -p mypy
+python -m mypy --config-file mypy_self_check.ini -p mypy
 
-# Run a single test from the test suite
-pytest -n0 -k 'test_name'
+# Run a single test from the test suite (uses pytest substring expression matching)
+python runtests.py test_name
+# or equivalently:
+pytest -n0 -k test_name
 
 # Run all test cases in the "test-data/unit/check-dataclasses.test" file
+python runtests.py check-dataclasses.test
+# or equivalently:
 pytest mypy/test/testcheck.py::TypeCheckSuite::check-dataclasses.test
 
-# Run the linter
-flake8
-
-# Run formatters
-black . && isort .
+# Run the formatters and linters
+python runtests.py lint
 ```
 
 For an in-depth guide on running and writing tests,
 see [the README in the test-data directory](test-data/unit/README.md).
 
+#### Using `tox`
+
+You can also use [`tox`](https://tox.wiki/en/latest/) to run tests and other commands.
+`tox` handles setting up test environments for you.
+
+```bash
+# Run tests
+tox run -e py
+
+# Run tests using some specific Python version
+tox run -e py311
+
+# Run a specific command
+tox run -e lint
+
+# Run a single test from the test suite
+tox run -e py -- -n0 -k 'test_name'
+
+# Run all test cases in the "test-data/unit/check-dataclasses.test" file using
+# Python 3.11 specifically
+tox run -e py311 -- mypy/test/testcheck.py::TypeCheckSuite::check-dataclasses.test
+
+# Set up a development environment with all the project libraries and run a command
+tox -e dev -- mypy --verbose test_case.py
+tox -e dev --override testenv:dev.allowlist_externals+=env -- env  # inspect the environment
+```
+
+If you don't already have `tox` installed, you can use a virtual environment as
+described above to install `tox` via `pip` (e.g., ``python -m pip install tox``).
+
 ## First time contributors
 
 If you're looking for things to help with, browse our [issue tracker](https://github.com/python/mypy/issues)!
@@ -154,10 +179,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/CREDITS b/CREDITS
index fb2fe155a9b8..cbe5954c81b2 100644
--- a/CREDITS
+++ b/CREDITS
@@ -15,7 +15,7 @@ Dropbox core team:
 
 Non-Dropbox core team members:
 
-  Ethan Smith
+  Emma Harper Smith <emma@python.org>
   Guido van Rossum <guido@python.org>
   Jelle Zijlstra <jelle.zijlstra@gmail.com>
   Michael J. Sullivan <sully@msully.net>
diff --git a/LICENSE b/LICENSE
index 991496cb4878..55d01ee19ad8 100644
--- a/LICENSE
+++ b/LICENSE
@@ -4,8 +4,8 @@ Mypy (and mypyc) are licensed under the terms of the MIT license, reproduced bel
 
 The MIT License
 
-Copyright (c) 2012-2022 Jukka Lehtosalo and contributors
-Copyright (c) 2015-2022 Dropbox, Inc.
+Copyright (c) 2012-2023 Jukka Lehtosalo and contributors
+Copyright (c) 2015-2023 Dropbox, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),
diff --git a/MANIFEST.in b/MANIFEST.in
index 1c26ae16fc78..f36c98f4dd3b 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -9,6 +9,7 @@ recursive-include mypy/typeshed *.pyi
 
 # mypy and mypyc
 include mypy/py.typed
+include mypyc/py.typed
 recursive-include mypy *.py
 recursive-include mypyc *.py
 
@@ -25,23 +26,26 @@ prune docs/source/_build
 # assorted mypyc requirements
 graft mypyc/external
 graft mypyc/lib-rt
+graft mypyc/test
 graft mypyc/test-data
 graft mypyc/doc
+prune mypyc/doc/build
 
 # files necessary for testing sdist
 include mypy-requirements.txt
 include build-requirements.txt
+include test-requirements.in
 include test-requirements.txt
 include mypy_self_check.ini
 prune misc
-include misc/proper_plugin.py
 graft test-data
+graft mypy/test
 include conftest.py
 include runtests.py
-include pytest.ini
+include tox.ini
 
-include LICENSE mypyc/README.md
-exclude .gitmodules CONTRIBUTING.md CREDITS ROADMAP.md tox.ini action.yml .editorconfig
+include LICENSE mypyc/README.md CHANGELOG.md
+exclude .gitmodules CONTRIBUTING.md CREDITS ROADMAP.md action.yml .editorconfig
 exclude .git-blame-ignore-revs .pre-commit-config.yaml
 
 global-exclude *.py[cod]
diff --git a/README.md b/README.md
index 164957b1491a..45b71c8a4824 100644
--- a/README.md
+++ b/README.md
@@ -10,15 +10,15 @@ 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?
 ---------------
 
 We are always happy to answer questions! Here are some good places to ask them:
 
-- for anything you're curious about, try [gitter chat](https://gitter.im/python/typing)
 - for general questions about Python typing, try [typing discussions](https://github.com/python/typing/discussions)
+- for anything you're curious about, try [gitter chat](https://gitter.im/python/typing)
 
 If you're just getting started,
 [the documentation](https://mypy.readthedocs.io/en/stable/index.html)
@@ -30,7 +30,6 @@ If you think you've found a bug:
 - check our [common issues page](https://mypy.readthedocs.io/en/stable/common_issues.html)
 - search our [issue tracker](https://github.com/python/mypy/issues) to see if
   it's already been reported
-- consider asking on [gitter chat](https://gitter.im/python/typing)
 
 To report a bug or request an enhancement:
 
@@ -41,8 +40,8 @@ To report a bug or request an enhancement:
 
 To discuss a new type system feature:
 
-- discuss at [typing-sig mailing list](https://mail.python.org/archives/list/typing-sig@python.org/)
-- there is also some historical discussion [here](https://github.com/python/typing/issues)
+- discuss at [discuss.python.org](https://discuss.python.org/c/typing/32)
+- there is also some historical discussion at the [typing-sig mailing list](https://mail.python.org/archives/list/typing-sig@python.org/) and the [python/typing repo](https://github.com/python/typing/issues)
 
 What is mypy?
 -------------
@@ -101,8 +100,6 @@ repo directly:
 
 ```bash
 python3 -m pip install -U git+https://github.com/python/mypy.git
-# or if you don't have 'git' installed
-python3 -m pip install -U https://github.com/python/mypy/zipball/master
 ```
 
 Now you can type-check the [statically typed parts] of a program like this:
@@ -118,14 +115,16 @@ programs, even if mypy reports type errors:
 python3 PROGRAM
 ```
 
-You can also try mypy in an [online playground](https://mypy-play.net/) (developed by
-Yusuke Miyazaki). If you are working with large code bases, you can run mypy in
+If you are working with large code bases, you can run mypy in
 [daemon mode], that will give much faster (often sub-second) incremental updates:
 
 ```bash
 dmypy run -- PROGRAM
 ```
 
+You can also try mypy in an [online playground](https://mypy-play.net/) (developed by
+Yusuke Miyazaki).
+
 [statically typed parts]: https://mypy.readthedocs.io/en/latest/getting_started.html#function-signatures-and-dynamic-vs-static-typing
 [daemon mode]: https://mypy.readthedocs.io/en/stable/mypy_daemon.html
 
@@ -134,6 +133,7 @@ Integrations
 
 Mypy can be integrated into popular IDEs:
 
+- VS Code: provides [basic integration](https://code.visualstudio.com/docs/python/linting#_mypy) with mypy.
 - Vim:
   - Using [Syntastic](https://github.com/vim-syntastic/syntastic): in `~/.vimrc` add
     `let g:syntastic_python_checkers=['mypy']`
@@ -141,11 +141,9 @@ Mypy can be integrated into popular IDEs:
     or can be explicitly enabled by adding `let b:ale_linters = ['mypy']` in `~/vim/ftplugin/python.vim`
 - Emacs: using [Flycheck](https://github.com/flycheck/)
 - Sublime Text: [SublimeLinter-contrib-mypy](https://github.com/fredcallaway/SublimeLinter-contrib-mypy)
-- Atom: [linter-mypy](https://atom.io/packages/linter-mypy)
-- PyCharm: [mypy plugin](https://github.com/dropbox/mypy-PyCharm-plugin) (PyCharm integrates
-  [its own implementation](https://www.jetbrains.com/help/pycharm/type-hinting-in-product.html) of [PEP 484](https://peps.python.org/pep-0484/))
-- VS Code: provides [basic integration](https://code.visualstudio.com/docs/python/linting#_mypy) with mypy.
-- pre-commit: use [pre-commit mirrors-mypy](https://github.com/pre-commit/mirrors-mypy).
+- PyCharm: [mypy plugin](https://github.com/dropbox/mypy-PyCharm-plugin)
+- pre-commit: use [pre-commit mirrors-mypy](https://github.com/pre-commit/mirrors-mypy), although
+  note by default this will limit mypy's ability to analyse your third party dependencies.
 
 Web site and documentation
 --------------------------
@@ -171,8 +169,6 @@ contributors of all experience levels.
 
 To get started with developing mypy, see [CONTRIBUTING.md](CONTRIBUTING.md).
 
-If you need help getting started, don't hesitate to ask on [gitter](https://gitter.im/python/typing).
-
 Mypyc and compiled version of mypy
 ----------------------------------
 
@@ -190,4 +186,4 @@ To use a compiled version of a development
 version of mypy, directly install a binary from
 <https://github.com/mypyc/mypy_mypyc-wheels/releases/latest>.
 
-To contribute to the mypyc project, check out <https://github.com/mypyc/mypyc>
+To contribute to the mypyc project, check out the issue tracker at <https://github.com/mypyc/mypyc>
diff --git a/action.yml b/action.yml
index df8715327830..732929412651 100644
--- a/action.yml
+++ b/action.yml
@@ -32,7 +32,7 @@ branding:
 runs:
   using: composite
   steps:
-    - name: mypy setup
+    - name: mypy setup  # zizmor: ignore[template-injection]
       shell: bash
       run: |
         echo ::group::Installing mypy...
diff --git a/build-requirements.txt b/build-requirements.txt
index 0b1e6d43103a..aac1b95eddf7 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/README.md b/docs/README.md
index 0d574c9213a5..e72164c78560 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -15,13 +15,13 @@ Install Sphinx and other dependencies (i.e. theme) needed for the documentation.
 From the `docs` directory, use `pip`:
 
 ```
-$ pip install -r requirements-docs.txt
+pip install -r requirements-docs.txt
 ```
 
 Build the documentation like this:
 
 ```
-$ make html
+make html
 ```
 
 The built documentation will be placed in the `docs/build` directory. Open
@@ -33,13 +33,13 @@ Helpful documentation build commands
 Clean the documentation build:
 
 ```
-$ make clean
+make clean
 ```
 
 Test and check the links found in the documentation:
 
 ```
-$ make linkcheck
+make linkcheck
 ```
 
 Documentation on Read The Docs
diff --git a/docs/requirements-docs.txt b/docs/requirements-docs.txt
index 395964ad9d44..747f376a8f5a 100644
--- a/docs/requirements-docs.txt
+++ b/docs/requirements-docs.txt
@@ -1,2 +1,4 @@
-sphinx>=4.2.0,<5.0.0
+sphinx>=8.1.0
 furo>=2022.3.4
+myst-parser>=4.0.0
+sphinx_inline_tabs>=2023.04.21
diff --git a/docs/source/additional_features.rst b/docs/source/additional_features.rst
index 10122e9b2fa9..e7c162a0b0df 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
 
@@ -47,21 +46,18 @@ define dataclasses. For example:
     UnorderedPoint(1, 2) < UnorderedPoint(3, 4)  # Error: Unsupported operand types
 
 Dataclasses can be generic and can be used in any other way a normal
-class can be used:
+class can be used (Python 3.12 syntax):
 
 .. code-block:: python
 
     from dataclasses import dataclass
-    from typing import Generic, TypeVar
-
-    T = TypeVar('T')
 
     @dataclass
-    class BoxedData(Generic[T]):
+    class BoxedData[T]:
         data: T
         label: str
 
-    def unbox(bd: BoxedData[T]) -> T:
+    def unbox[T](bd: BoxedData[T]) -> T:
         ...
 
     val = unbox(BoxedData(42, "<important>"))  # OK, inferred type is int
@@ -72,12 +68,12 @@ and :pep:`557`.
 Caveats/Known Issues
 ====================
 
-Some functions in the :py:mod:`dataclasses` module, such as :py:func:`~dataclasses.replace` and :py:func:`~dataclasses.asdict`,
+Some functions in the :py:mod:`dataclasses` module, such as :py:func:`~dataclasses.asdict`,
 have imprecise (too permissive) types. This will be fixed in future releases.
 
 Mypy does not yet recognize aliases of :py:func:`dataclasses.dataclass <dataclasses.dataclass>`, and will
-probably never recognize dynamically computed decorators. The following examples
-do **not** work:
+probably never recognize dynamically computed decorators. The following example
+does **not** work:
 
 .. code-block:: python
 
@@ -95,16 +91,36 @@ do **not** work:
       """
       attribute: int
 
-    @dataclass_wrapper
-    class DynamicallyDecorated:
-      """
-      Mypy doesn't recognize this as a dataclass because it is decorated by a
-      function returning `dataclass` rather than by `dataclass` itself.
-      """
-      attribute: int
-
     AliasDecorated(attribute=1) # error: Unexpected keyword argument
-    DynamicallyDecorated(attribute=1) # error: Unexpected keyword argument
+
+
+To have Mypy recognize a wrapper of :py:func:`dataclasses.dataclass <dataclasses.dataclass>`
+as a dataclass decorator, consider using the :py:func:`~typing.dataclass_transform`
+decorator (example uses Python 3.12 syntax):
+
+.. code-block:: python
+
+    from dataclasses import dataclass, Field
+    from typing import dataclass_transform
+
+    @dataclass_transform(field_specifiers=(Field,))
+    def my_dataclass[T](cls: type[T]) -> type[T]:
+        ...
+        return dataclass(cls)
+
+
+Data Class Transforms
+*********************
+
+Mypy supports the :py:func:`~typing.dataclass_transform` decorator as described in
+`PEP 681 <https://www.python.org/dev/peps/pep-0681/#the-dataclass-transform-decorator>`_.
+
+.. note::
+
+    Pragmatically, mypy will assume such classes have the internal attribute :code:`__dataclass_fields__`
+    (even though they might lack it in runtime) and will assume functions such as :py:func:`dataclasses.is_dataclass`
+    and :py:func:`dataclasses.fields` treat them as if they were dataclasses
+    (even though they may fail at runtime).
 
 .. _attrs_package:
 
@@ -347,20 +363,20 @@ Extended Callable types
    This feature is deprecated.  You can use
    :ref:`callback protocols <callback_protocols>` as a replacement.
 
-As an experimental mypy extension, you can specify :py:data:`~typing.Callable` types
+As an experimental mypy extension, you can specify :py:class:`~collections.abc.Callable` types
 that support keyword arguments, optional arguments, and more.  When
-you specify the arguments of a :py:data:`~typing.Callable`, you can choose to supply just
+you specify the arguments of a :py:class:`~collections.abc.Callable`, you can choose to supply just
 the type of a nameless positional argument, or an "argument specifier"
 representing a more complicated form of argument.  This allows one to
 more closely emulate the full range of possibilities given by the
 ``def`` statement in Python.
 
 As an example, here's a complicated function definition and the
-corresponding :py:data:`~typing.Callable`:
+corresponding :py:class:`~collections.abc.Callable`:
 
 .. code-block:: python
 
-   from typing import Callable
+   from collections.abc import Callable
    from mypy_extensions import (Arg, DefaultArg, NamedArg,
                                 DefaultNamedArg, VarArg, KwArg)
 
@@ -433,7 +449,7 @@ purpose:
 In all cases, the ``type`` argument defaults to ``Any``, and if the
 ``name`` argument is omitted the argument has no name (the name is
 required for ``NamedArg`` and ``DefaultNamedArg``).  A basic
-:py:data:`~typing.Callable` such as
+:py:class:`~collections.abc.Callable` such as
 
 .. code-block:: python
 
@@ -445,7 +461,7 @@ is equivalent to the following:
 
    MyFunc = Callable[[Arg(int), Arg(str), Arg(int)], float]
 
-A :py:data:`~typing.Callable` with unspecified argument types, such as
+A :py:class:`~collections.abc.Callable` with unspecified argument types, such as
 
 .. code-block:: python
 
diff --git a/docs/source/changelog.md b/docs/source/changelog.md
new file mode 100644
index 000000000000..a490ada727a6
--- /dev/null
+++ b/docs/source/changelog.md
@@ -0,0 +1,3 @@
+<!-- This file includes mypy/CHANGELOG.md into mypy documentation -->
+```{include} ../../CHANGELOG.md
+```
diff --git a/docs/source/cheat_sheet_py3.rst b/docs/source/cheat_sheet_py3.rst
index 31242d0ad0bc..7385a66863bf 100644
--- a/docs/source/cheat_sheet_py3.rst
+++ b/docs/source/cheat_sheet_py3.rst
@@ -72,9 +72,9 @@ Useful built-in types
    # On earlier versions, use Union
    x: list[Union[int, str]] = [3, 5, "test", "fun"]
 
-   # Use Optional[X] for a value that could be None
-   # Optional[X] is the same as X | None or Union[X, None]
-   x: Optional[str] = "something" if some_condition() else None
+   # Use X | None for a value that could be None on Python 3.10+
+   # Use Optional[X] on 3.9 and earlier; Optional[X] is the same as 'X | None'
+   x: str | None = "something" if some_condition() else None
    if x is not None:
        # Mypy understands x won't be None here because of the if-statement
        print(x.upper())
@@ -88,7 +88,8 @@ Functions
 
 .. code-block:: python
 
-   from typing import Callable, Iterator, Union, Optional
+   from collections.abc import Iterator, Callable
+   from typing import Union, Optional
 
    # This is how you annotate a function definition
    def stringify(num: int) -> str:
@@ -104,7 +105,7 @@ Functions
        print(value + "!" * excitement)
 
    # Note that arguments without a type are dynamically typed (treated as Any)
-   # and that functions without any annotations not checked
+   # and that functions without any annotations are not checked
    def untyped(x):
        x.anything() + 1 + "string"  # no errors
 
@@ -121,13 +122,14 @@ Functions
            i += 1
 
    # You can of course split a function annotation over multiple lines
-   def send_email(address: Union[str, list[str]],
-                  sender: str,
-                  cc: Optional[list[str]],
-                  bcc: Optional[list[str]],
-                  subject: str = '',
-                  body: Optional[list[str]] = None
-                  ) -> bool:
+   def send_email(
+       address: str | list[str],
+       sender: str,
+       cc: list[str] | None,
+       bcc: list[str] | None,
+       subject: str = '',
+       body: list[str] | None = None,
+   ) -> bool:
        ...
 
    # Mypy understands positional-only and keyword-only arguments
@@ -152,6 +154,8 @@ Classes
 
 .. code-block:: python
 
+   from typing import ClassVar
+
    class BankAccount:
        # The "__init__" method doesn't return anything, so it gets return
        # type "None" just like any other method that doesn't return anything
@@ -178,8 +182,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)
@@ -211,6 +213,7 @@ Classes
        # This will allow access to any A.x, if x is compatible with the return type
        def __getattr__(self, name: str) -> int: ...
 
+   a = A()
    a.foo = 42  # Works
    a.bar = 'Ex-parrot'  # Fails type checking
 
@@ -229,7 +232,7 @@ When you're puzzled or when things are complicated
    # If you initialize a variable with an empty container or "None"
    # you may have to help mypy a bit by providing an explicit type annotation
    x: list[str] = []
-   x: Optional[str] = None
+   x: str | None = None
 
    # Use Any if you don't know the type of something or it's too
    # dynamic to write a type for
@@ -273,7 +276,8 @@ that are common in idiomatic Python are standardized.
 
 .. code-block:: python
 
-   from typing import Mapping, MutableMapping, Sequence, Iterable
+   from collections.abc import Mapping, MutableMapping, Sequence, Iterable
+   # or 'from typing import ...' (required in Python 3.8)
 
    # Use Iterable for generic iterables (anything usable in "for"),
    # and Sequence where a sequence (supporting "len" and "__getitem__") is
@@ -348,11 +352,26 @@ Decorators
 **********
 
 Decorator functions can be expressed via generics. See
-:ref:`declaring-decorators` for more details.
+:ref:`declaring-decorators` for more details. Example using Python 3.12
+syntax:
+
+.. code-block:: python
+
+    from collections.abc import Callable
+    from typing import Any
+
+    def bare_decorator[F: Callable[..., Any]](func: F) -> F:
+        ...
+
+    def decorator_args[F: Callable[..., Any]](url: str) -> Callable[[F], F]:
+        ...
+
+The same example using pre-3.12 syntax:
 
 .. code-block:: python
 
-    from typing import Any, Callable, TypeVar
+    from collections.abc import Callable
+    from typing import Any, TypeVar
 
     F = TypeVar('F', bound=Callable[..., Any])
 
diff --git a/docs/source/class_basics.rst b/docs/source/class_basics.rst
index 82bbf00b830d..241dbeae0f44 100644
--- a/docs/source/class_basics.rst
+++ b/docs/source/class_basics.rst
@@ -152,7 +152,8 @@ between class and instance variables with callable types. For example:
 
 .. code-block:: python
 
-   from typing import Callable, ClassVar
+   from collections.abc import Callable
+   from typing import ClassVar
 
    class A:
        foo: Callable[[int], None]
@@ -210,7 +211,9 @@ override has a compatible signature:
 
 In order to ensure that your code remains correct when renaming methods,
 it can be helpful to explicitly mark a method as overriding a base
-method. This can be done with the ``@override`` decorator. If the base
+method. This can be done with the ``@override`` decorator. ``@override``
+can be imported from ``typing`` starting with Python 3.12 or from
+``typing_extensions`` for use with older Python versions. If the base
 method is then renamed while the overriding method is not, mypy will
 show an error:
 
@@ -233,6 +236,11 @@ show an error:
        def g(self, y: str) -> None:   # Error: no corresponding base method found
            ...
 
+.. note::
+
+   Use :ref:`--enable-error-code explicit-override <code-explicit-override>` to require
+   that method overrides use the ``@override`` decorator. Emit an error if it is missing.
+
 You can also override a statically typed method with a dynamically
 typed one. This allows dynamically typed code to override methods
 defined in library classes without worrying about their type
@@ -256,7 +264,7 @@ effect at runtime:
 Abstract base classes and multiple inheritance
 **********************************************
 
-Mypy supports Python :doc:`abstract base classes <library/abc>` (ABCs). Abstract classes
+Mypy supports Python :doc:`abstract base classes <python:library/abc>` (ABCs). Abstract classes
 have at least one abstract method or property that must be implemented
 by any *concrete* (non-abstract) subclass. You can define abstract base
 classes using the :py:class:`abc.ABCMeta` metaclass and the :py:func:`@abc.abstractmethod <abc.abstractmethod>`
@@ -364,8 +372,7 @@ property or an instance variable.
 Slots
 *****
 
-When a class has explicitly defined
-`__slots__ <https://docs.python.org/3/reference/datamodel.html#slots>`_,
+When a class has explicitly defined :std:term:`__slots__`,
 mypy will check that all attributes assigned to are members of ``__slots__``:
 
 .. code-block:: python
diff --git a/docs/source/command_line.rst b/docs/source/command_line.rst
index 2809294092ab..dfed280d12ed 100644
--- a/docs/source/command_line.rst
+++ b/docs/source/command_line.rst
@@ -68,10 +68,11 @@ for full details, see :ref:`running-mypy`.
     checked. For instance, ``mypy --exclude '/setup.py$'
     but_still_check/setup.py``.
 
-    In particular, ``--exclude`` does not affect mypy's :ref:`import following
-    <follow-imports>`. You can use a per-module :confval:`follow_imports` config
-    option to additionally avoid mypy from following imports and checking code
-    you do not wish to be checked.
+    In particular, ``--exclude`` does not affect mypy's discovery of files
+    via :ref:`import following <follow-imports>`. You can use a per-module
+    :confval:`ignore_errors` config option to silence errors from a given module,
+    or a per-module :confval:`follow_imports` config option to additionally avoid
+    mypy from following imports and checking code you do not wish to be checked.
 
     Note that mypy will never recursively discover files and directories named
     "site-packages", "node_modules" or "__pycache__", or those whose name starts
@@ -80,6 +81,10 @@ for full details, see :ref:`running-mypy`.
     never recursively discover files with extensions other than ``.py`` or
     ``.pyi``.
 
+.. option:: --exclude-gitignore
+
+    This flag will add everything that matches ``.gitignore`` file(s) to :option:`--exclude`.
+
 
 Optional arguments
 ******************
@@ -96,6 +101,10 @@ Optional arguments
 
     Show program's version number and exit.
 
+.. option:: -O FORMAT, --output FORMAT {json}
+
+    Set a custom output format.
+
 .. _config-file-flag:
 
 Config file
@@ -133,7 +142,7 @@ imports.
 
     This flag tells mypy that top-level packages will be based in either the
     current directory, or a member of the ``MYPYPATH`` environment variable or
-    :confval:`mypy_path` config option. This option is only useful in
+    :confval:`mypy_path` config option. This option is only useful
     in the absence of `__init__.py`. See :ref:`Mapping file
     paths to modules <mapping-paths-to-modules>` for details.
 
@@ -162,6 +171,17 @@ imports.
 
     For more details, see :ref:`ignore-missing-imports`.
 
+.. option:: --follow-untyped-imports
+
+    This flag makes mypy analyze imports from installed packages even if
+    missing a :ref:`py.typed marker or stubs <installed-packages>`.
+
+    .. warning::
+
+        Note that analyzing all unannotated modules might result in issues
+        when analyzing code not designed to be type checked and may significantly
+        increase how long mypy takes to run.
+
 .. option:: --follow-imports {normal,silent,skip,error}
 
     This flag adjusts how mypy follows imported modules that were not
@@ -350,6 +370,34 @@ definitions or calls.
     This flag reports an error whenever a function with type annotations
     calls a function defined without annotations.
 
+.. option:: --untyped-calls-exclude
+
+    This flag allows to selectively disable :option:`--disallow-untyped-calls`
+    for functions and methods defined in specific packages, modules, or classes.
+    Note that each exclude entry acts as a prefix. For example (assuming there
+    are no type annotations for ``third_party_lib`` available):
+
+    .. code-block:: python
+
+        # mypy --disallow-untyped-calls
+        #      --untyped-calls-exclude=third_party_lib.module_a
+        #      --untyped-calls-exclude=foo.A
+        from third_party_lib.module_a import some_func
+        from third_party_lib.module_b import other_func
+        import foo
+
+        some_func()  # OK, function comes from module `third_party_lib.module_a`
+        other_func()  # E: Call to untyped function "other_func" in typed context
+
+        foo.A().meth()  # OK, method was defined in class `foo.A`
+        foo.B().meth()  # E: Call to untyped function "meth" in typed context
+
+        # file foo.py
+        class A:
+            def meth(self): pass
+        class B:
+            def meth(self): pass
+
 .. option:: --disallow-untyped-defs
 
     This flag reports an error whenever it encounters a function definition
@@ -387,17 +435,16 @@ None and Optional handling
 **************************
 
 The following flags adjust how mypy handles values of type ``None``.
-For more details, see :ref:`no_strict_optional`.
 
 .. _implicit-optional:
 
 .. option:: --implicit-optional
 
-    This flag causes mypy to treat arguments with a ``None``
-    default value as having an implicit :py:data:`~typing.Optional` type.
+    This flag causes mypy to treat parameters with a ``None``
+    default value as having an implicit optional type (``T | None``).
 
     For example, if this flag is set, mypy would assume that the ``x``
-    parameter is actually of type ``Optional[int]`` in the code snippet below
+    parameter is actually of type ``int | None`` in the code snippet below,
     since the default parameter is ``None``:
 
     .. code-block:: python
@@ -407,16 +454,19 @@ For more details, see :ref:`no_strict_optional`.
 
     **Note:** This was disabled by default starting in mypy 0.980.
 
+.. _no_strict_optional:
+
 .. option:: --no-strict-optional
 
-    This flag disables strict checking of :py:data:`~typing.Optional`
+    This flag effectively disables checking of optional
     types and ``None`` values. With this option, mypy doesn't
-    generally check the use of ``None`` values -- they are valid
-    everywhere. See :ref:`no_strict_optional` for more about this feature.
+    generally check the use of ``None`` values -- it is treated
+    as compatible with every type.
+
+    .. warning::
 
-    **Note:** Strict optional checking was enabled by default starting in
-    mypy 0.600, and in previous versions it had to be explicitly enabled
-    using ``--strict-optional`` (which is still accepted).
+        ``--no-strict-optional`` is evil. Avoid using it and definitely do
+        not use it without understanding what it does.
 
 
 .. _configuring-warnings:
@@ -503,6 +553,32 @@ potentially problematic or redundant in some way.
 
         This limitation will be removed in future releases of mypy.
 
+.. option:: --report-deprecated-as-note
+
+    If error code ``deprecated`` is enabled, mypy emits errors if your code
+    imports or uses deprecated features. This flag converts such errors to
+    notes, causing mypy to eventually finish with a zero exit code. Features
+    are considered deprecated when decorated with ``warnings.deprecated``.
+
+.. option:: --deprecated-calls-exclude
+
+    This flag allows to selectively disable :ref:`deprecated<code-deprecated>` warnings
+    for functions and methods defined in specific packages, modules, or classes.
+    Note that each exclude entry acts as a prefix. For example (assuming ``foo.A.func`` is deprecated):
+
+    .. code-block:: python
+
+        # mypy --enable-error-code deprecated
+        #      --deprecated-calls-exclude=foo.A
+        import foo
+
+        foo.A().func()  # OK, the deprecated warning is ignored
+
+        # file foo.py
+        from typing_extensions import deprecated
+        class A:
+            @deprecated("Use A.func2 instead")
+            def func(self): pass
 
 .. _miscellaneous-strictness-flags:
 
@@ -517,12 +593,58 @@ of the above sections.
     This flag causes mypy to suppress errors caused by not being able to fully
     infer the types of global and class variables.
 
-.. option:: --allow-redefinition
+.. option:: --allow-redefinition-new
 
     By default, mypy won't allow a variable to be redefined with an
-    unrelated type. This flag enables redefinition of a variable with an
+    unrelated type. This *experimental* flag enables the redefinition of
+    unannotated variables with an arbitrary type. You will also need to enable
+    :option:`--local-partial-types <mypy --local-partial-types>`.
+    Example:
+
+    .. code-block:: python
+
+        def maybe_convert(n: int, b: bool) -> int | str:
+            if b:
+                x = str(n)  # Assign "str"
+            else:
+                x = n       # Assign "int"
+            # Type of "x" is "int | str" here.
+            return x
+
+    Without the new flag, mypy only supports inferring optional types
+    (``X | None``) from multiple assignments. With this option enabled,
+    mypy can infer arbitrary union types.
+
+    This also enables an unannotated variable to have different types in different
+    code locations:
+
+    .. code-block:: python
+
+        if check():
+            for x in range(n):
+                # Type of "x" is "int" here.
+                ...
+        else:
+            for x in ['a', 'b']:
+                # Type of "x" is "str" here.
+                ...
+
+    Note: We are planning to turn this flag on by default in a future mypy
+    release, along with :option:`--local-partial-types <mypy --local-partial-types>`.
+    The feature is still experimental, and the semantics may still change.
+
+.. option:: --allow-redefinition
+
+    This is an older variant of
+    :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`.
+    This flag enables redefinition of a variable with an
     arbitrary type *in some contexts*: only redefinitions within the
     same block and nesting depth as the original definition are allowed.
+
+    We have no plans to remove this flag, but we expect that
+    :option:`--allow-redefinition-new <mypy --allow-redefinition-new>`
+    will replace this flag for new use cases eventually.
+
     Example where this can be useful:
 
     .. code-block:: python
@@ -545,26 +667,24 @@ of the above sections.
 .. option:: --local-partial-types
 
     In mypy, the most common cases for partial types are variables initialized using ``None``,
-    but without explicit ``Optional`` annotations. By default, mypy won't check partial types
+    but without explicit ``X | None`` annotations. By default, mypy won't check partial types
     spanning module top level or class top level. This flag changes the behavior to only allow
     partial types at local level, therefore it disallows inferring variable type for ``None``
     from two assignments in different scopes. For example:
 
     .. code-block:: python
 
-        from typing import Optional
-
         a = None  # Need type annotation here if using --local-partial-types
-        b: Optional[int] = None
+        b: int | None = None
 
         class Foo:
             bar = None  # Need type annotation here if using --local-partial-types
-            baz: Optional[int] = None
+            baz: int | None = None
 
             def __init__(self) -> None:
                 self.bar = 1
 
-        reveal_type(Foo().bar)  # Union[int, None] without --local-partial-types
+        reveal_type(Foo().bar)  # 'int | None' without --local-partial-types
 
     Note: this option is always implicitly enabled in mypy daemon and will become
     enabled by default for mypy in a future release.
@@ -600,22 +720,94 @@ of the above sections.
 
     .. code-block:: python
 
-       from typing import Text
-
        items: list[int]
        if 'some string' in items:  # Error: non-overlapping container check!
            ...
 
-       text: Text
+       text: str
        if text != b'other bytes':  # Error: non-overlapping equality check!
            ...
 
        assert text is not None  # OK, check against None is allowed as a special case.
 
+
+.. option:: --strict-bytes
+
+    By default, mypy treats ``bytearray`` and ``memoryview`` as subtypes of ``bytes`` which
+    is not true at runtime. Use this flag to disable this behavior. ``--strict-bytes`` will
+    be enabled by default in *mypy 2.0*.
+
+    .. code-block:: python
+
+       def f(buf: bytes) -> None:
+           assert isinstance(buf, bytes)  # Raises runtime AssertionError with bytearray/memoryview
+           with open("binary_file", "wb") as fp:
+               fp.write(buf)
+
+       f(bytearray(b""))  # error: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+       f(memoryview(b""))  # error: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
+
+       # If `f` accepts any object that implements the buffer protocol, consider using:
+       from collections.abc import Buffer  # "from typing_extensions" in Python 3.11 and earlier
+
+       def f(buf: Buffer) -> None:
+           with open("binary_file", "wb") as fp:
+               fp.write(buf)
+
+       f(b"")  # Ok
+       f(bytearray(b""))  # Ok
+       f(memoryview(b""))  # Ok
+
+
+.. option:: --extra-checks
+
+    This flag enables additional checks that are technically correct but may be
+    impractical. 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)
+
+    In future more checks may be added to this flag if:
+
+    * The corresponding use cases are rare, thus not justifying a dedicated
+      strictness flag.
+
+    * The new check cannot be supported as an opt-in error code.
+
 .. option:: --strict
 
-    This flag mode enables all optional error checking flags.  You can see the
-    list of flags enabled by strict mode in the full :option:`mypy --help` output.
+    This flag mode enables a defined subset of optional error-checking flags.
+    This subset primarily includes checks for inadvertent type unsoundness (i.e
+    strict will catch type errors as long as intentional methods like type ignore
+    or casting were not used.)
+
+    Note: the :option:`--warn-unreachable` flag
+    is not automatically enabled by the strict flag.
+
+    The strict flag does not take precedence over other strict-related flags.
+    Directly specifying a flag of alternate behavior will override the
+    behavior of strict, regardless of the order in which they are passed.
+    You can see the list of flags enabled by strict mode in the full
+    :option:`mypy --help` output.
 
     Note: the exact list of flags enabled by running :option:`--strict` may change
     over time.
@@ -689,6 +881,17 @@ in error messages.
 
         main.py:12:9: error: Unsupported operand types for / ("int" and "str")
 
+.. option:: --show-error-code-links
+
+    This flag will also display a link to error code documentation, anchored to the error code reported by mypy.
+    The corresponding error code will be highlighted within the documentation page.
+    If we enable this flag, the error message now looks like this::
+
+        main.py:3: error: Unsupported operand types for - ("int" and "str")  [operator]
+        main.py:3: note: See 'https://mypy.rtfd.io/en/stable/_refs.html#code-operator' for more info
+
+
+
 .. option:: --show-error-end
 
     This flag will make mypy show not just that start position where
@@ -731,7 +934,18 @@ in error messages.
     disable reporting most additional errors. The limit only applies
     if it seems likely that most of the remaining errors will not be
     useful or they may be overly noisy. If ``N`` is negative, there is
-    no limit. The default limit is 200.
+    no limit. The default limit is -1.
+
+.. option:: --force-uppercase-builtins
+
+    Always use ``List`` instead of ``list`` in error messages,
+    even on Python 3.9+.
+
+.. option:: --force-union-syntax
+
+    Always use ``Union[]`` and ``Optional[]`` for union types
+    in error messages (instead of the ``|`` operator),
+    even on Python 3.10+.
 
 
 .. _incremental:
@@ -924,6 +1138,66 @@ format into the specified directory.
     library or specify mypy installation with the setuptools extra
     ``mypy[reports]``.
 
+
+Enabling incomplete/experimental features
+*****************************************
+
+.. option:: --enable-incomplete-feature {PreciseTupleTypes, InlineTypedDict}
+
+    Some features may require several mypy releases to implement, for example
+    due to their complexity, potential for backwards incompatibility, or
+    ambiguous semantics that would benefit from feedback from the community.
+    You can enable such features for early preview using this flag. Note that
+    it is not guaranteed that all features will be ultimately enabled by
+    default. In *rare cases* we may decide to not go ahead with certain
+    features.
+
+List of currently incomplete/experimental features:
+
+* ``PreciseTupleTypes``: this feature will infer more precise tuple types in
+  various scenarios. Before variadic types were added to the Python type system
+  by :pep:`646`, it was impossible to express a type like "a tuple with
+  at least two integers". The best type available was ``tuple[int, ...]``.
+  Therefore, mypy applied very lenient checking for variable-length tuples.
+  Now this type can be expressed as ``tuple[int, int, *tuple[int, ...]]``.
+  For such more precise types (when explicitly *defined* by a user) mypy,
+  for example, warns about unsafe index access, and generally handles them
+  in a type-safe manner. However, to avoid problems in existing code, mypy
+  does not *infer* these precise types when it technically can. Here are
+  notable examples where ``PreciseTupleTypes`` infers more precise types:
+
+  .. code-block:: python
+
+     numbers: tuple[int, ...]
+
+     more_numbers = (1, *numbers, 1)
+     reveal_type(more_numbers)
+     # Without PreciseTupleTypes: tuple[int, ...]
+     # With PreciseTupleTypes: tuple[int, *tuple[int, ...], int]
+
+     other_numbers = (1, 1) + numbers
+     reveal_type(other_numbers)
+     # Without PreciseTupleTypes: tuple[int, ...]
+     # With PreciseTupleTypes: tuple[int, int, *tuple[int, ...]]
+
+     if len(numbers) > 2:
+         reveal_type(numbers)
+         # Without PreciseTupleTypes: tuple[int, ...]
+         # With PreciseTupleTypes: tuple[int, int, int, *tuple[int, ...]]
+     else:
+         reveal_type(numbers)
+         # Without PreciseTupleTypes: tuple[int, ...]
+         # With PreciseTupleTypes: tuple[()] | tuple[int] | tuple[int, int]
+
+* ``InlineTypedDict``: this feature enables non-standard syntax for inline
+  :ref:`TypedDicts <typeddict>`, for example:
+
+  .. code-block:: python
+
+     def test_values() -> {"int": int, "str": str}:
+         return {"int": 42, "str": "test"}
+
+
 Miscellaneous
 *************
 
diff --git a/docs/source/common_issues.rst b/docs/source/common_issues.rst
index e6570b7eef5b..96d73e5f0399 100644
--- a/docs/source/common_issues.rst
+++ b/docs/source/common_issues.rst
@@ -41,7 +41,7 @@ once you add annotations:
 
     def foo(a: str) -> str:
         return '(' + a.split() + ')'
-    # error: Unsupported operand types for + ("str" and List[str])
+    # error: Unsupported operand types for + ("str" and "list[str]")
 
 If you don't know what types to add, you can use ``Any``, but beware:
 
@@ -119,7 +119,7 @@ and mypy doesn't complain**.
         return None  # No error!
 
 You may have disabled strict optional checking (see
-:ref:`no_strict_optional` for more).
+:ref:`--no-strict-optional <no_strict_optional>` for more).
 
 .. _silencing_checker:
 
@@ -226,7 +226,7 @@ dict to a new variable, as mentioned earlier:
 
 .. code-block:: python
 
-   a: List[int] = []
+   a: list[int] = []
 
 Without the annotation mypy can't always figure out the
 precise type of ``a``.
@@ -238,7 +238,7 @@ modification operation in the same scope (such as ``append`` for a list):
 
 .. code-block:: python
 
-   a = []  # Okay because followed by append, inferred type List[int]
+   a = []  # Okay because followed by append, inferred type list[int]
    for i in range(n):
        a.append(i * i)
 
@@ -276,7 +276,7 @@ not support ``sort()``) as a list and sort it in-place:
     def f(x: Sequence[int]) -> None:
         # Type of x is Sequence[int] here; we don't know the concrete type.
         x = list(x)
-        # Type of x is List[int] here.
+        # Type of x is list[int] here.
         x.sort()  # Okay!
 
 See :ref:`type-narrowing` for more information.
@@ -296,8 +296,8 @@ unexpected errors when combined with type inference. For example:
    class A: ...
    class B(A): ...
 
-   lst = [A(), A()]  # Inferred type is List[A]
-   new_lst = [B(), B()]  # inferred type is List[B]
+   lst = [A(), A()]  # Inferred type is list[A]
+   new_lst = [B(), B()]  # inferred type is list[B]
    lst = new_lst  # mypy will complain about this, because List is invariant
 
 Possible strategies in such situations are:
@@ -306,7 +306,7 @@ Possible strategies in such situations are:
 
   .. code-block:: python
 
-     new_lst: List[A] = [B(), B()]
+     new_lst: list[A] = [B(), B()]
      lst = new_lst  # OK
 
 * Make a copy of the right hand side:
@@ -319,7 +319,7 @@ Possible strategies in such situations are:
 
   .. code-block:: python
 
-     def f_bad(x: List[A]) -> A:
+     def f_bad(x: list[A]) -> A:
          return x[0]
      f_bad(new_lst) # Fails
 
@@ -363,7 +363,8 @@ explicit type cast:
 
 .. code-block:: python
 
-  from typing import Sequence, cast
+  from collections.abc import Sequence
+  from typing import cast
 
   def find_first_str(a: Sequence[object]) -> str:
       index = next((i for i, s in enumerate(a) if isinstance(s, str)), -1)
@@ -426,8 +427,8 @@ More specifically, mypy will understand the use of :py:data:`sys.version_info` a
    import sys
 
    # Distinguishing between different versions of Python:
-   if sys.version_info >= (3, 8):
-       # Python 3.8+ specific definitions and imports
+   if sys.version_info >= (3, 13):
+       # Python 3.13+ specific definitions and imports
    else:
        # Other definitions and imports
 
@@ -454,7 +455,7 @@ Example:
    # The rest of this file doesn't apply to Windows.
 
 Some other expressions exhibit similar behavior; in particular,
-:py:data:`~typing.TYPE_CHECKING`, variables named ``MYPY``, and any variable
+:py:data:`~typing.TYPE_CHECKING`, variables named ``MYPY`` or ``TYPE_CHECKING``, and any variable
 whose name is passed to :option:`--always-true <mypy --always-true>` or :option:`--always-false <mypy --always-false>`.
 (However, ``True`` and ``False`` are not treated specially!)
 
@@ -489,7 +490,7 @@ understand how mypy handles a particular piece of code. Example:
 
 .. code-block:: python
 
-   reveal_type((1, 'hello'))  # Revealed type is "Tuple[builtins.int, builtins.str]"
+   reveal_type((1, 'hello'))  # Revealed type is "tuple[builtins.int, builtins.str]"
 
 You can also use ``reveal_locals()`` at any line in a file
 to see the types of all local variables at once. Example:
@@ -541,7 +542,7 @@ Consider this example:
 
 .. code-block:: python
 
-   from typing_extensions import Protocol
+   from typing import Protocol
 
    class P(Protocol):
        x: float
@@ -561,7 +562,7 @@ the protocol definition:
 
 .. code-block:: python
 
-   from typing_extensions import Protocol
+   from typing import Protocol
 
    class P(Protocol):
        @property
@@ -622,16 +623,16 @@ instructions at the `mypyc wheels repo <https://github.com/mypyc/mypy_mypyc-whee
 Variables vs type aliases
 -------------------------
 
-Mypy has both *type aliases* and variables with types like ``Type[...]``. These are
+Mypy has both *type aliases* and variables with types like ``type[...]``. These are
 subtly different, and it's important to understand how they differ to avoid pitfalls.
 
-1. A variable with type ``Type[...]`` is defined using an assignment with an
+1. A variable with type ``type[...]`` is defined using an assignment with an
    explicit type annotation:
 
    .. code-block:: python
 
      class A: ...
-     tp: Type[A] = A
+     tp: type[A] = A
 
 2. You can define a type alias using an assignment without an explicit type annotation
    at the top level of a module:
@@ -670,7 +671,7 @@ can't be defined conditionally (unless using
          # explicit "Type[...]" annotation
          Alias = B
 
-     tp: Type[object]  # "tp" is a variable with a type object value
+     tp: type[object]  # "tp" is a variable with a type object value
      if random() > 0.5:
          tp = A
      else:
@@ -700,7 +701,7 @@ This example demonstrates both safe and unsafe overrides:
 
 .. code-block:: python
 
-    from typing import Sequence, List, Iterable
+    from collections.abc import Sequence, Iterable
 
     class A:
         def test(self, t: Sequence[int]) -> Sequence[str]:
@@ -713,7 +714,7 @@ This example demonstrates both safe and unsafe overrides:
 
     class NarrowerArgument(A):
         # A more specific argument type isn't accepted
-        def test(self, t: List[int]) -> Sequence[str]:  # Error
+        def test(self, t: list[int]) -> Sequence[str]:  # Error
             ...
 
     class NarrowerReturn(A):
@@ -756,7 +757,7 @@ type check such code. Consider this example:
         x: int = 'abc'  # Unreachable -- no error
 
 It's easy to see that any statement after ``return`` is unreachable,
-and hence mypy will not complain about the mis-typed code below
+and hence mypy will not complain about the mistyped code below
 it. For a more subtle example, consider this code:
 
 .. code-block:: python
@@ -802,7 +803,7 @@ This is best understood via an example:
 
 .. code-block:: python
 
-    def foo(x: Optional[int]) -> Callable[[], int]:
+    def foo(x: int | None) -> Callable[[], int]:
         if x is None:
             x = 5
         print(x + 1)  # mypy correctly deduces x must be an int here
@@ -818,3 +819,30 @@ This is best understood via an example:
 To get this code to type check, you could assign ``y = x`` after ``x`` has been
 narrowed, and use ``y`` in the inner function, or add an assert in the inner
 function.
+
+.. _incorrect-self:
+
+Incorrect use of ``Self``
+-------------------------
+
+``Self`` is not the type of the current class; it's a type variable with upper
+bound of the current class. That is, it represents the type of the current class
+or of potential subclasses.
+
+.. code-block:: python
+
+    from typing import Self
+
+    class Foo:
+        @classmethod
+        def constructor(cls) -> Self:
+            # Instead, either call cls() or change the annotation to -> Foo
+            return Foo()  # error: Incompatible return value type (got "Foo", expected "Self")
+
+    class Bar(Foo):
+        ...
+
+    reveal_type(Foo.constructor())  # note: Revealed type is "Foo"
+    # In the context of the subclass Bar, the Self return type promises
+    # that the return value will be Bar
+    reveal_type(Bar.constructor())  # note: Revealed type is "Bar"
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 80097ef5b3a8..79a5c0619615 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -35,7 +35,12 @@
 # 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",
+    "sphinx_inline_tabs",
+    "docs.source.html_builder",
+    "myst_parser",
+]
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["_templates"]
@@ -51,7 +56,7 @@
 
 # General information about the project.
 project = "mypy"
-copyright = "2012-2022 Jukka Lehtosalo and mypy contributors"
+copyright = "2012-%Y Jukka Lehtosalo and mypy contributors"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -92,7 +97,7 @@
 # show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
+# pygments_style = "sphinx"
 
 # A list of ignored prefixes for module index sorting.
 # modindex_common_prefix = []
@@ -107,6 +112,12 @@
 # a list of builtin themes.
 html_theme = "furo"
 
+html_theme_options = {
+    "source_repository": "https://github.com/python/mypy",
+    "source_branch": "master",
+    "source_directory": "docs/source",
+}
+
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
@@ -266,7 +277,6 @@
 
 intersphinx_mapping = {
     "python": ("https://docs.python.org/3", None),
-    "six": ("https://six.readthedocs.io", None),
     "attrs": ("https://www.attrs.org/en/stable/", None),
     "cython": ("https://docs.cython.org/en/latest", None),
     "monkeytype": ("https://monkeytype.readthedocs.io/en/latest", None),
diff --git a/docs/source/config_file.rst b/docs/source/config_file.rst
index 9e79ff99937b..9f23617b9481 100644
--- a/docs/source/config_file.rst
+++ b/docs/source/config_file.rst
@@ -3,22 +3,34 @@
 The mypy configuration file
 ===========================
 
-Mypy supports reading configuration settings from a file with the following precedence order:
+Mypy is very configurable. This is most useful when introducing typing to
+an existing codebase. See :ref:`existing-code` for concrete advice for
+that situation.
 
-    1. ``./mypy.ini``
-    2. ``./.mypy.ini``
-    3. ``./pyproject.toml``
-    4. ``./setup.cfg``
-    5. ``$XDG_CONFIG_HOME/mypy/config``
-    6. ``~/.config/mypy/config``
-    7. ``~/.mypy.ini``
+Mypy supports reading configuration settings from a file. By default, mypy will
+discover configuration files by walking up the file system (up until the root of
+a repository or the root of the filesystem). In each directory, it will look for
+the following configuration files (in this order):
+
+    1. ``mypy.ini``
+    2. ``.mypy.ini``
+    3. ``pyproject.toml`` (containing a ``[tool.mypy]`` section)
+    4. ``setup.cfg`` (containing a ``[mypy]`` section)
+
+If no configuration file is found by this method, mypy will then look for
+configuration files in the following locations (in this order):
+
+    1. ``$XDG_CONFIG_HOME/mypy/config``
+    2. ``~/.config/mypy/config``
+    3. ``~/.mypy.ini``
+
+The :option:`--config-file <mypy --config-file>` command-line flag has the
+highest precedence and must point towards a valid configuration file;
+otherwise mypy will report an error and exit. Without the command line option,
+mypy will look for configuration files in the precedence order above.
 
 It is important to understand that there is no merging of configuration
-files, as it would lead to ambiguity. The :option:`--config-file <mypy --config-file>`
-command-line flag has the highest precedence and
-must be correct; otherwise mypy will report an error and exit. Without the
-command line option, mypy will look for configuration files in the
-precedence order above.
+files, as it would lead to ambiguity.
 
 Most flags correspond closely to :ref:`command-line flags
 <command-line>` but there are some differences in flag names and some
@@ -238,10 +250,8 @@ section of the command line docs.
     Crafting a single regular expression that excludes multiple files while remaining
     human-readable can be a challenge. The above example demonstrates one approach.
     ``(?x)`` enables the ``VERBOSE`` flag for the subsequent regular expression, which
-    `ignores most whitespace and supports comments`__. The above is equivalent to:
-    ``(^one\.py$|two\.pyi$|^three\.)``.
-
-    .. __: https://docs.python.org/3/library/re.html#re.X
+    :py:data:`ignores most whitespace and supports comments <re.VERBOSE>`.
+    The above is equivalent to: ``(^one\.py$|two\.pyi$|^three\.)``.
 
     For more details, see :option:`--exclude <mypy --exclude>`.
 
@@ -278,6 +288,14 @@ section of the command line docs.
 
        See :ref:`using-a-pyproject-toml`.
 
+.. confval:: exclude_gitignore
+
+    :type: boolean
+    :default: False
+
+    This flag will add everything that matches ``.gitignore`` file(s) to :confval:`exclude`.
+    This option may only be set in the global section (``[mypy]``).
+
 .. confval:: namespace_packages
 
     :type: boolean
@@ -313,6 +331,24 @@ section of the command line docs.
     match the name of the *imported* module, not the module containing the
     import statement.
 
+.. confval:: follow_untyped_imports
+
+    :type: boolean
+    :default: False
+
+    Makes mypy analyze imports from installed packages even if missing a
+    :ref:`py.typed marker or stubs <installed-packages>`.
+
+    If this option is used in a per-module section, the module name should
+    match the name of the *imported* module, not the module containing the
+    import statement.
+
+    .. warning::
+
+        Note that analyzing all unannotated modules might result in issues
+        when analyzing code not designed to be type checked and may significantly
+        increase how long mypy takes to run.
+
 .. confval:: follow_imports
 
     :type: string
@@ -396,7 +432,7 @@ Platform configuration
 
     Specifies the Python version used to parse and check the target
     program.  The string should be in the format ``MAJOR.MINOR`` --
-    for example ``2.7``.  The default is the version of the Python
+    for example ``3.9``.  The default is the version of the Python
     interpreter used to run mypy.
 
     This option may only be set in the global section (``[mypy]``).
@@ -490,7 +526,38 @@ section of the command line docs.
     :default: False
 
     Disallows calling functions without type annotations from functions with type
-    annotations.
+    annotations. Note that when used in per-module options, it enables/disables
+    this check **inside** the module(s) specified, not for functions that come
+    from that module(s), for example config like this:
+
+    .. code-block:: ini
+
+        [mypy]
+        disallow_untyped_calls = True
+
+        [mypy-some.library.*]
+        disallow_untyped_calls = False
+
+    will disable this check inside ``some.library``, not for your code that
+    imports ``some.library``. If you want to selectively disable this check for
+    all your code that imports ``some.library`` you should instead use
+    :confval:`untyped_calls_exclude`, for example:
+
+    .. code-block:: ini
+
+        [mypy]
+        disallow_untyped_calls = True
+        untyped_calls_exclude = some.library
+
+.. confval:: untyped_calls_exclude
+
+    :type: comma-separated list of strings
+
+    Selectively excludes functions and methods defined in specific packages,
+    modules, and classes from action of :confval:`disallow_untyped_calls`.
+    This also applies to all submodules of packages (i.e. everything inside
+    a given prefix). Note, this option does not support per-file configuration,
+    the exclusions list is defined globally for all your code.
 
 .. confval:: disallow_untyped_defs
 
@@ -541,8 +608,8 @@ section of the command line docs.
     :type: boolean
     :default: False
 
-    Causes mypy to treat arguments with a ``None``
-    default value as having an implicit :py:data:`~typing.Optional` type.
+    Causes mypy to treat parameters with a ``None``
+    default value as having an implicit optional type (``T | None``).
 
     **Note:** This was True by default in mypy versions 0.980 and earlier.
 
@@ -551,10 +618,15 @@ section of the command line docs.
     :type: boolean
     :default: True
 
-    Enables or disables strict Optional checks. If False, mypy treats ``None``
+    Effectively disables checking of optional
+    types and ``None`` values. With this option, mypy doesn't
+    generally check the use of ``None`` values -- it is treated
     as compatible with every type.
 
-    **Note:** This was False by default in mypy versions earlier than 0.600.
+    .. warning::
+
+        ``strict_optional = false`` is evil. Avoid using it and definitely do
+        not use it without understanding what it does.
 
 
 Configuring warnings
@@ -602,6 +674,16 @@ section of the command line docs.
     Shows a warning when encountering any code inferred to be unreachable or
     redundant after performing type analysis.
 
+.. confval:: deprecated_calls_exclude
+
+    :type: comma-separated list of strings
+
+    Selectively excludes functions and methods defined in specific packages,
+    modules, and classes from the :ref:`deprecated<code-deprecated>` error code.
+    This also applies to all submodules of packages (i.e. everything inside
+    a given prefix). Note, this option does not support per-file configuration,
+    the exclusions list is defined globally for all your code.
+
 
 Suppressing errors
 ******************
@@ -631,6 +713,44 @@ section of the command line docs.
     Causes mypy to suppress errors caused by not being able to fully
     infer the types of global and class variables.
 
+.. confval:: allow_redefinition_new
+
+    :type: boolean
+    :default: False
+
+    By default, mypy won't allow a variable to be redefined with an
+    unrelated type. This *experimental* flag enables the redefinition of
+    unannotated variables with an arbitrary type. You will also need to enable
+    :confval:`local_partial_types`.
+    Example:
+
+    .. code-block:: python
+
+        def maybe_convert(n: int, b: bool) -> int | str:
+            if b:
+                x = str(n)  # Assign "str"
+            else:
+                x = n       # Assign "int"
+            # Type of "x" is "int | str" here.
+            return x
+
+    This also enables an unannotated variable to have different types in different
+    code locations:
+
+    .. code-block:: python
+
+        if check():
+            for x in range(n):
+                # Type of "x" is "int" here.
+                ...
+        else:
+            for x in ['a', 'b']:
+                # Type of "x" is "str" here.
+                ...
+
+    Note: We are planning to turn this flag on by default in a future mypy
+    release, along with :confval:`local_partial_types`.
+
 .. confval:: allow_redefinition
 
     :type: boolean
@@ -664,6 +784,7 @@ section of the command line docs.
 
     Disallows inferring variable type for ``None`` from two assignments in different scopes.
     This is always implicitly enabled when using the :ref:`mypy daemon <mypy_daemon>`.
+    This will be enabled by default in a future mypy release.
 
 .. confval:: disable_error_code
 
@@ -679,6 +800,14 @@ section of the command line docs.
 
     Note: This option will override disabled error codes from the disable_error_code option.
 
+.. confval:: extra_checks
+
+   :type: boolean
+   :default: False
+
+   This flag enables additional checks that are technically correct but may be impractical.
+   See :option:`mypy --extra-checks` for more info.
+
 .. confval:: implicit_reexport
 
     :type: boolean
@@ -699,25 +828,26 @@ section of the command line docs.
        from foo import bar
        __all__ = ['bar']
 
-.. confval:: strict_concatenate
-
-    :type: boolean
-    :default: False
-
-    Make arguments prepended via ``Concatenate`` be truly positional-only.
-
 .. confval:: strict_equality
 
-    :type: boolean
-    :default: False
+   :type: boolean
+   :default: False
 
    Prohibit equality checks, identity checks, and container checks between
    non-overlapping types.
 
+.. confval:: strict_bytes
+
+   :type: boolean
+   :default: False
+
+   Disable treating ``bytearray`` and ``memoryview`` as subtypes of ``bytes``.
+   This will be enabled by default in *mypy 2.0*.
+
 .. confval:: strict
 
-    :type: boolean
-    :default: False
+   :type: boolean
+   :default: False
 
    Enable all optional error checking flags.  You can see the list of
    flags enabled by strict mode in the full :option:`mypy --help`
@@ -749,6 +879,13 @@ These options may only be set in the global section (``[mypy]``).
 
     Shows column numbers in error messages.
 
+.. confval:: show_error_code_links
+
+    :type: boolean
+    :default: False
+
+    Shows documentation link to corresponding error code.
+
 .. confval:: hide_error_codes
 
     :type: boolean
@@ -785,6 +922,22 @@ These options may only be set in the global section (``[mypy]``).
 
     Show absolute paths to files.
 
+.. confval:: force_uppercase_builtins
+
+    :type: boolean
+    :default: False
+
+    Always use ``List`` instead of ``list`` in error messages,
+    even on Python 3.9+.
+
+.. confval:: force_union_syntax
+
+    :type: boolean
+    :default: False
+
+    Always use ``Union[]`` and ``Optional[]`` for union types
+    in error messages (instead of the ``|`` operator),
+    even on Python 3.10+.
 
 Incremental mode
 ****************
@@ -1082,7 +1235,7 @@ of your repo (or append it to the end of an existing ``pyproject.toml`` file) an
     # mypy global options:
 
     [tool.mypy]
-    python_version = "2.7"
+    python_version = "3.9"
     warn_return_any = true
     warn_unused_configs = true
     exclude = [
diff --git a/docs/source/dynamic_typing.rst b/docs/source/dynamic_typing.rst
index d3476de2ca64..304e25c085a8 100644
--- a/docs/source/dynamic_typing.rst
+++ b/docs/source/dynamic_typing.rst
@@ -81,14 +81,12 @@ treated as ``Any``:
 
 .. code-block:: python
 
-    from typing import List
-
-    def f(x: List) -> None:
+    def f(x: list) -> None:
         reveal_type(x)        # Revealed type is "builtins.list[Any]"
         reveal_type(x[0])     # Revealed type is "Any"
         x[0].anything_goes()  # OK
 
-You can make mypy warn you about untyped function parameters using the
+You can make mypy warn you about missing generic parameters using the
 :option:`--disallow-any-generics <mypy --disallow-any-generics>` flag.
 
 Finally, another major source of ``Any`` types leaking into your program is from
diff --git a/docs/source/error_code_list.rst b/docs/source/error_code_list.rst
index 54dc31f2cfcb..49cb8a0c06c1 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]
 -----------------------------------------------------------
 
@@ -55,8 +59,6 @@ Example:
 
 .. code-block:: python
 
-   from typing import Union
-
    class Cat:
        def sleep(self) -> None: ...
        def miaow(self) -> None: ...
@@ -65,16 +67,18 @@ Example:
        def sleep(self) -> None: ...
        def follow_me(self) -> None: ...
 
-   def func(animal: Union[Cat, Dog]) -> None:
+   def func(animal: Cat | Dog) -> None:
        # OK: 'sleep' is defined for both Cat and Dog
        animal.sleep()
-       # Error: Item "Cat" of "Union[Cat, Dog]" has no attribute "follow_me"  [union-attr]
+       # Error: Item "Cat" of "Cat | Dog" has no attribute "follow_me"  [union-attr]
        animal.follow_me()
 
 You can often work around these errors by using ``assert isinstance(obj, ClassName)``
 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 +93,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 +110,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]
 -----------------------------------
@@ -116,14 +122,14 @@ Example:
 
 .. code-block:: python
 
-    from typing import Sequence
-
     def greet(name: str) -> None:
          print('hello', name)
 
     greet('jack')  # OK
     greet('jill', 'jack')  # Error: Too many arguments for "greet"  [call-arg]
 
+.. _code-arg-type:
+
 Check argument types [arg-type]
 -------------------------------
 
@@ -134,9 +140,7 @@ Example:
 
 .. code-block:: python
 
-    from typing import Optional
-
-    def first(x: list[int]) -> Optional[int]:
+    def first(x: list[int]) -> int:
         return x[0] if x else 0
 
     t = (5, 4)
@@ -144,6 +148,8 @@ Example:
     #        expected "list[int]"  [arg-type]
     print(first(t))
 
+.. _code-call-overload:
+
 Check calls to overloaded functions [call-overload]
 ---------------------------------------------------
 
@@ -155,7 +161,7 @@ Example:
 
 .. code-block:: python
 
-   from typing import overload, Optional
+   from typing import overload
 
    @overload
    def inc_maybe(x: None) -> None: ...
@@ -163,7 +169,7 @@ Example:
    @overload
    def inc_maybe(x: int) -> int: ...
 
-   def inc_maybe(x: Optional[int]) -> Optional[int]:
+   def inc_maybe(x: int | None) -> int | None:
         if x is None:
             return None
         else:
@@ -175,6 +181,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]
 ------------------------------------
 
@@ -196,17 +204,19 @@ This example incorrectly uses the function ``log`` as a type:
         for x in objs:
             f(x)
 
-You can use :py:data:`~typing.Callable` as the type for callable objects:
+You can use :py:class:`~collections.abc.Callable` as the type for callable objects:
 
 .. code-block:: python
 
-    from typing import Callable
+    from collections.abc import Callable
 
     # OK
     def log_all(objs: list[object], f: Callable[[object], None]) -> None:
         for x in objs:
             f(x)
 
+.. _code-var-annotated:
+
 Require annotation if variable type is unclear [var-annotated]
 --------------------------------------------------------------
 
@@ -239,6 +249,8 @@ To address this, we add an explicit annotation:
 
    reveal_type(Bundle().items)  # list[str]
 
+.. _code-override:
+
 Check validity of overrides [override]
 --------------------------------------
 
@@ -257,16 +269,14 @@ Example:
 
 .. code-block:: python
 
-   from typing import Optional, Union
-
    class Base:
        def method(self,
-                  arg: int) -> Optional[int]:
+                  arg: int) -> int | None:
            ...
 
    class Derived(Base):
        def method(self,
-                  arg: Union[int, str]) -> int:  # OK
+                  arg: int | str) -> int:  # OK
            ...
 
    class DerivedBad(Base):
@@ -275,6 +285,8 @@ Example:
                   arg: bool) -> int:
            ...
 
+.. _code-return:
+
 Check that function returns a value [return]
 --------------------------------------------
 
@@ -303,6 +315,40 @@ 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]
 ----------------------------------------------------
 
@@ -317,6 +363,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 +387,8 @@ Example:
     #        variable has type "str")  [assignment]
     r.name = 5
 
+.. _code-method-assign:
+
 Check that assignment target is not a method [method-assign]
 ------------------------------------------------------------
 
@@ -368,21 +418,19 @@ 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]
 -------------------------------------
 
 Mypy checks that value of a type variable is compatible with a value
 restriction or the upper bound type.
 
-Example:
+Example (Python 3.12 syntax):
 
 .. code-block:: python
 
-    from typing import TypeVar
-
-    T1 = TypeVar('T1', int, float)
-
-    def add(x: T1, y: T1) -> T1:
+    def add[T1: (int, float)](x: T1, y: T1) -> T1:
         return x + y
 
     add(4, 5.5)  # OK
@@ -390,6 +438,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 +454,8 @@ Example:
    # Error: Unsupported operand types for + ("int" and "str")  [operator]
    1 + 'x'
 
+.. _code-index:
+
 Check indexing operations [index]
 ---------------------------------
 
@@ -425,6 +477,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 +493,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 +509,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]
 --------------------------------------
 
@@ -467,7 +525,7 @@ Example:
 
 .. code-block:: python
 
-    from typing_extensions import TypedDict
+    from typing import TypedDict
 
     class Point(TypedDict):
         x: int
@@ -477,6 +535,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]
 --------------------------------------------
 
@@ -490,7 +550,7 @@ to have been validated at the point of construction. Example:
 
 .. code-block:: python
 
-    from typing_extensions import TypedDict
+    from typing import TypedDict
 
     class Point(TypedDict):
         x: int
@@ -533,6 +593,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,8 +634,20 @@ the issue:
        def set_y(self) -> None:
            self.y: int = self.x  # Added annotation here
 
-Check that import target can be found [import]
-----------------------------------------------
+.. _code-import:
+
+Check for an issue with imports [import]
+----------------------------------------
+
+Mypy generates an error if it can't resolve an `import` statement.
+This is a parent error code of `import-not-found` and `import-untyped`
+
+See :ref:`ignore-missing-imports` for how to work around these errors.
+
+.. _code-import-not-found:
+
+Check that import target can be found [import-not-found]
+--------------------------------------------------------
 
 Mypy generates an error if it can't find the source code or a stub file
 for an imported module.
@@ -582,11 +656,33 @@ Example:
 
 .. code-block:: python
 
-    # Error: Cannot find implementation or library stub for module named 'acme'  [import]
-    import acme
+    # Error: Cannot find implementation or library stub for module named "m0dule_with_typo"  [import-not-found]
+    import m0dule_with_typo
 
 See :ref:`ignore-missing-imports` for how to work around these errors.
 
+.. _code-import-untyped:
+
+Check that import target can be found [import-untyped]
+--------------------------------------------------------
+
+Mypy generates an error if it can find the source code for an imported module,
+but that module does not provide type annotations (via :ref:`PEP 561 <installed-packages>`).
+
+Example:
+
+.. code-block:: python
+
+    # Error: Library stubs not installed for "bs4"  [import-untyped]
+    import bs4
+    # Error: Skipping analyzing "no_py_typed": module is installed, but missing library stubs or py.typed marker  [import-untyped]
+    import no_py_typed
+
+In some cases, these errors can be fixed by installing an appropriate
+stub package. See :ref:`ignore-missing-imports` for more details.
+
+.. _code-no-redef:
+
 Check that each name is defined once [no-redef]
 -----------------------------------------------
 
@@ -613,6 +709,8 @@ Example:
    #        (the first definition wins!)
    A('x')
 
+.. _code-func-returns-value:
+
 Check that called function returns a value [func-returns-value]
 ---------------------------------------------------------------
 
@@ -631,10 +729,12 @@ returns ``None``:
    # OK: we don't do anything with the return value
    f()
 
-   # Error: "f" does not return a value  [func-returns-value]
+   # Error: "f" does not return a value (it only ever returns None)  [func-returns-value]
    if f():
         print("not false")
 
+.. _code-abstract:
+
 Check instantiation of abstract classes [abstract]
 --------------------------------------------------
 
@@ -666,32 +766,34 @@ 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]
 -----------------------------------------------------------
 
-Mypy always allows instantiating (calling) type objects typed as ``Type[t]``,
+Mypy always allows instantiating (calling) type objects typed as ``type[t]``,
 even if it is not known that ``t`` is non-abstract, since it is a common
 pattern to create functions that act as object factories (custom constructors).
 Therefore, to prevent issues described in the above section, when an abstract
-type object is passed where ``Type[t]`` is expected, mypy will give an error.
-Example:
+type object is passed where ``type[t]`` is expected, mypy will give an error.
+Example (Python 3.12 syntax):
 
 .. code-block:: python
 
    from abc import ABCMeta, abstractmethod
-   from typing import List, Type, TypeVar
 
    class Config(metaclass=ABCMeta):
        @abstractmethod
        def get_value(self, attr: str) -> str: ...
 
-   T = TypeVar("T")
-   def make_many(typ: Type[T], n: int) -> List[T]:
+   def make_many[T](typ: type[T], n: int) -> list[T]:
        return [typ() for _ in range(n)]  # This will raise if typ is abstract
 
-   # Error: Only concrete class can be given where "Type[Config]" is expected [type-abstract]
+   # 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,10 +816,12 @@ 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]
 -------------------------------------------
 
-The target of a :py:func:`NewType <typing.NewType>` definition must be a class type. It can't
+The target of a :py:class:`~typing.NewType` definition must be a class type. It can't
 be a union type, ``Any``, or various other special types.
 
 You can also get this error if the target has been imported from a
@@ -738,6 +842,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]
 -----------------------------------------------
 
@@ -748,7 +854,7 @@ the return type affects which lines mypy thinks are reachable after a
 ``True`` may swallow exceptions. An imprecise return type can result
 in mysterious errors reported near ``with`` statements.
 
-To fix this, use either ``typing_extensions.Literal[False]`` or
+To fix this, use either ``typing.Literal[False]`` or
 ``None`` as the return type. Returning ``None`` is equivalent to
 returning ``False`` in this context, since both are treated as false
 values.
@@ -777,7 +883,7 @@ You can use ``Literal[False]`` to fix the error:
 
 .. code-block:: python
 
-   from typing_extensions import Literal
+   from typing import Literal
 
    class MyContext:
        ...
@@ -794,6 +900,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 +915,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 +946,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 +970,8 @@ implementation.
    def func(value):
        pass  # actual implementation
 
+.. _code-unused-coroutine:
+
 Check that coroutine return value is used [unused-coroutine]
 ------------------------------------------------------------
 
@@ -881,6 +995,41 @@ 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]
+
+.. _code-await-not-async:
+
+Warn about await expressions used outside of coroutines [await-not-async]
+-------------------------------------------------------------------------
+
+``await`` must be used inside a coroutine.
+
+.. code-block:: python
+
+   async def f() -> None:
+       ...
+
+   def g() -> None:
+       await f()  # Error: "await" outside coroutine ("async def")  [await-not-async]
+
+.. _code-assert-type:
+
 Check types in assert_type [assert-type]
 ----------------------------------------
 
@@ -895,6 +1044,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 +1059,29 @@ 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]
 -------------------------------------------------------------------
 
@@ -926,6 +1100,116 @@ 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-overload-overlap:
+
+Check that overloaded functions don't overlap [overload-overlap]
+----------------------------------------------------------------
+
+Warn if multiple ``@overload`` variants overlap in potentially unsafe ways.
+This guards against the following situation:
+
+.. code-block:: python
+
+    from typing import overload
+
+    class A: ...
+    class B(A): ...
+
+    @overload
+    def foo(x: B) -> int: ...  # Error: Overloaded function signatures 1 and 2 overlap with incompatible return types  [overload-overlap]
+    @overload
+    def foo(x: A) -> str: ...
+    def foo(x): ...
+
+    def takes_a(a: A) -> str:
+        return foo(a)
+
+    a: A = B()
+    value = takes_a(a)
+    # mypy will think that value is a str, but it could actually be an int
+    reveal_type(value) # Revealed type is "builtins.str"
+
+
+Note that in cases where you ignore this error, mypy will usually still infer the
+types you expect.
+
+See :ref:`overloading <function-overloading>` for more explanation.
+
+
+.. _code-overload-cannot-match:
+
+Check for overload signatures that cannot match [overload-cannot-match]
+--------------------------------------------------------------------------
+
+Warn if an ``@overload`` variant can never be matched, because an earlier
+overload has a wider signature. For example, this can happen if the two
+overloads accept the same parameters and each parameter on the first overload
+has the same type or a wider type than the corresponding parameter on the second
+overload.
+
+Example:
+
+.. code-block:: python
+
+    from typing import overload, Union
+
+    @overload
+    def process(response1: object, response2: object) -> object:
+        ...
+    @overload
+    def process(response1: int, response2: int) -> int: # E: Overloaded function signature 2 will never be matched: signature 1's parameter type(s) are the same or broader  [overload-cannot-match]
+        ...
+
+    def process(response1: object, response2: object) -> object:
+        return response1 + response2
+
+.. _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-prop-decorator:
+
+Decorator preceding property not supported [prop-decorator]
+-----------------------------------------------------------
+
+Mypy does not yet support analysis of decorators that precede the property
+decorator. If the decorator does not preserve the declared type of the property,
+mypy will not infer the correct type for the declaration. If the decorator cannot
+be moved after the ``@property`` decorator, then you must use a type ignore
+comment:
+
+.. code-block:: python
+
+    class MyClass:
+        @special  # type: ignore[prop-decorator]
+        @property
+        def magic(self) -> str:
+            return "xyzzy"
+
+.. note::
+
+    For backward compatibility, this error code is a subcode of the generic ``[misc]`` code.
+
+.. _code-syntax:
+
 Report syntax errors [syntax]
 -----------------------------
 
@@ -933,6 +1217,48 @@ 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-typeddict-readonly-mutated:
+
+ReadOnly key of a TypedDict is mutated [typeddict-readonly-mutated]
+-------------------------------------------------------------------
+
+Consider this example:
+
+.. code-block:: python
+
+    from datetime import datetime
+    from typing import TypedDict
+    from typing_extensions import ReadOnly
+
+    class User(TypedDict):
+        username: ReadOnly[str]
+        last_active: datetime
+
+    user: User = {'username': 'foobar', 'last_active': datetime.now()}
+    user['last_active'] = datetime.now()  # ok
+    user['username'] = 'other'  # error: ReadOnly TypedDict key "key" TypedDict is mutated  [typeddict-readonly-mutated]
+
+`PEP 705 <https://peps.python.org/pep-0705>`_ specifies
+how ``ReadOnly`` special form works for ``TypedDict`` objects.
+
+.. _code-narrowed-type-not-subtype:
+
+Check that ``TypeIs`` narrows types [narrowed-type-not-subtype]
+---------------------------------------------------------------
+
+:pep:`742` requires that when ``TypeIs`` is used, the narrowed
+type must be a subtype of the original type::
+
+    from typing_extensions import TypeIs
+
+    def f(x: int) -> TypeIs[str]:  # Error, str is not a subtype of int
+        ...
+
+    def g(x: object) -> TypeIs[str]:  # OK
+        ...
+
+.. _code-misc:
+
 Miscellaneous checks [misc]
 ---------------------------
 
diff --git a/docs/source/error_code_list2.rst b/docs/source/error_code_list2.rst
index 8be2ac0b1d73..dfe2e30874f7 100644
--- a/docs/source/error_code_list2.rst
+++ b/docs/source/error_code_list2.rst
@@ -5,8 +5,8 @@ Error codes for optional checks
 
 This section documents various errors codes that mypy generates only
 if you enable certain options. See :ref:`error-codes` for general
-documentation about error codes. :ref:`error-code-list` documents
-error codes that are enabled by default.
+documentation about error codes and their configuration.
+:ref:`error-code-list` documents error codes that are enabled by default.
 
 .. note::
 
@@ -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,48 @@ incorrect control flow or conditional checks that are accidentally always true o
         # Error: Statement is unreachable  [unreachable]
         print('unreachable')
 
+.. _code-deprecated:
+
+Check that imported or used feature is deprecated [deprecated]
+--------------------------------------------------------------
+
+If you use :option:`--enable-error-code deprecated <mypy --enable-error-code>`,
+mypy generates an error if your code imports a deprecated feature explicitly with a
+``from mod import depr`` statement or uses a deprecated feature imported otherwise or defined
+locally.  Features are considered deprecated when decorated with ``warnings.deprecated``, as
+specified in `PEP 702 <https://peps.python.org/pep-0702>`_.
+Use the :option:`--report-deprecated-as-note <mypy --report-deprecated-as-note>` option to
+turn all such errors into notes.
+Use :option:`--deprecated-calls-exclude <mypy --deprecated-calls-exclude>` to hide warnings
+for specific functions, classes and packages.
+
+.. note::
+
+    The ``warnings`` module provides the ``@deprecated`` decorator since Python 3.13.
+    To use it with older Python versions, import it from ``typing_extensions`` instead.
+
+Examples:
+
+.. code-block:: python
+
+    # mypy: report-deprecated-as-error
+
+    # Error: abc.abstractproperty is deprecated: Deprecated, use 'property' with 'abstractmethod' instead
+    from abc import abstractproperty
+
+    from typing_extensions import deprecated
+
+    @deprecated("use new_function")
+    def old_function() -> None:
+        print("I am old")
+
+    # Error: __main__.old_function is deprecated: use new_function
+    old_function()
+    old_function()  # type: ignore[deprecated]
+
+
+.. _code-redundant-expr:
+
 Check that expression is redundant [redundant-expr]
 ---------------------------------------------------
 
@@ -222,7 +281,7 @@ mypy generates an error if it thinks that an expression is redundant.
 
 .. code-block:: python
 
-    # Use "mypy --enable-error-code redundant-expr ..."
+    # mypy: enable-error-code="redundant-expr"
 
     def example(x: int) -> None:
         # Error: Left operand of "and" is always true  [redundant-expr]
@@ -236,6 +295,34 @@ 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
+
+    # mypy: enable-error-code="possibly-undefined"
+
+    from collections.abc 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]
 -----------------------------------------------------------------------------
 
@@ -250,7 +337,7 @@ Using an iterable value in a boolean context has a separate error code
 
 .. code-block:: python
 
-    # Use "mypy --enable-error-code truthy-bool ..."
+    # mypy: enable-error-code="truthy-bool"
 
     class Foo:
         pass
@@ -259,6 +346,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]
 -------------------------------------------------------------------------------
@@ -270,7 +358,7 @@ Example:
 
 .. code-block:: python
 
-    from typing import Iterable
+    from collections.abc import Iterable
 
     def transform(items: Iterable[int]) -> list[int]:
         # Error: "items" has type "Iterable[int]" which can always be true in boolean context. Consider using "Collection[int]" instead.  [truthy-iterable]
@@ -286,8 +374,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]
 -------------------------------------------------------------------------
@@ -300,7 +387,7 @@ Example:
 
 .. code-block:: python
 
-    # Use "mypy --enable-error-code ignore-without-code ..."
+    # mypy: enable-error-code="ignore-without-code"
 
     class Foo:
         def __init__(self, name: str) -> None:
@@ -319,6 +406,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]
 ------------------------------------------------------------
 
@@ -329,7 +418,7 @@ Example:
 
 .. code-block:: python
 
-    # Use "mypy --enable-error-code unused-awaitable ..."
+    # mypy: enable-error-code="unused-awaitable"
 
     import asyncio
 
@@ -340,7 +429,7 @@ Example:
         #        Are you missing an await?
         asyncio.create_task(f())
 
-You can assign the value to a temporary, otherwise unused to variable to
+You can assign the value to a temporary, otherwise unused variable to
 silence the error:
 
 .. code-block:: python
@@ -348,6 +437,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]
 -------------------------------------------------------------
 
@@ -391,3 +482,133 @@ Example:
         # The following will not generate an error on either
         # Python 3.8, or Python 3.9
         42 + "testing..."  # type: ignore
+
+.. _code-explicit-override:
+
+Check that ``@override`` is used when overriding a base class method [explicit-override]
+----------------------------------------------------------------------------------------
+
+If you use :option:`--enable-error-code explicit-override <mypy --enable-error-code>`
+mypy generates an error if you override a base class method without using the
+``@override`` decorator. An error will not be emitted for overrides of ``__init__``
+or ``__new__``. See `PEP 698 <https://peps.python.org/pep-0698/#strict-enforcement-per-project>`_.
+
+.. note::
+
+    Starting with Python 3.12, the ``@override`` decorator can be imported from ``typing``.
+    To use it with older Python versions, import it from ``typing_extensions`` instead.
+
+Example:
+
+.. code-block:: python
+
+    # mypy: enable-error-code="explicit-override"
+
+    from typing import override
+
+    class Parent:
+        def f(self, x: int) -> None:
+            pass
+
+        def g(self, y: int) -> None:
+            pass
+
+
+    class Child(Parent):
+        def f(self, x: int) -> None:  # Error: Missing @override decorator
+            pass
+
+        @override
+        def g(self, y: int) -> None:
+            pass
+
+.. _code-mutable-override:
+
+Check that overrides of mutable attributes are safe [mutable-override]
+----------------------------------------------------------------------
+
+`mutable-override` will enable the check for unsafe overrides of mutable attributes.
+For historical reasons, and because this is a relatively common pattern in Python,
+this check is not enabled by default. The example below is unsafe, and will be
+flagged when this error code is enabled:
+
+.. code-block:: python
+
+    from typing import Any
+
+    class C:
+        x: float
+        y: float
+        z: float
+
+    class D(C):
+        x: int  # Error: Covariant override of a mutable attribute
+                # (base class "C" defined the type as "float",
+                # expression has type "int")  [mutable-override]
+        y: float  # OK
+        z: Any  # OK
+
+    def f(c: C) -> None:
+        c.x = 1.1
+    d = D()
+    f(d)
+    d.x >> 1  # This will crash at runtime, because d.x is now float, not an int
+
+.. _code-unimported-reveal:
+
+Check that ``reveal_type`` is imported from typing or typing_extensions [unimported-reveal]
+-------------------------------------------------------------------------------------------
+
+Mypy used to have ``reveal_type`` as a special builtin
+that only existed during type-checking.
+In runtime it fails with expected ``NameError``,
+which can cause real problem in production, hidden from mypy.
+
+But, in Python3.11 :py:func:`typing.reveal_type` was added.
+``typing_extensions`` ported this helper to all supported Python versions.
+
+Now users can actually import ``reveal_type`` to make the runtime code safe.
+
+.. note::
+
+    Starting with Python 3.11, the ``reveal_type`` function can be imported from ``typing``.
+    To use it with older Python versions, import it from ``typing_extensions`` instead.
+
+.. code-block:: python
+
+    # mypy: enable-error-code="unimported-reveal"
+
+    x = 1
+    reveal_type(x)  # Note: Revealed type is "builtins.int" \
+                    # Error: Name "reveal_type" is not defined
+
+Correct usage:
+
+.. code-block:: python
+
+    # mypy: enable-error-code="unimported-reveal"
+    from typing import reveal_type   # or `typing_extensions`
+
+    x = 1
+    # This won't raise an error:
+    reveal_type(x)  # Note: Revealed type is "builtins.int"
+
+When this code is enabled, using ``reveal_locals`` is always an error,
+because there's no way one can import it.
+
+
+.. _code-explicit-any:
+
+Check that explicit Any type annotations are not allowed [explicit-any]
+-----------------------------------------------------------------------
+
+If you use :option:`--disallow-any-explicit <mypy --disallow-any-explicit>`, mypy generates an error
+if you use an explicit ``Any`` type annotation.
+
+Example:
+
+.. code-block:: python
+
+    # mypy: disallow-any-explicit
+    from typing import Any
+    x: Any = 1  # Error: Explicit "Any" type annotation  [explicit-any]
diff --git a/docs/source/error_codes.rst b/docs/source/error_codes.rst
index c8a2728b5697..485d70cb59bc 100644
--- a/docs/source/error_codes.rst
+++ b/docs/source/error_codes.rst
@@ -19,22 +19,6 @@ Most error codes are shared between multiple related error messages.
 Error codes may change in future mypy releases.
 
 
-
-Displaying error codes
-----------------------
-
-Error codes are displayed by default.  Use :option:`--hide-error-codes <mypy --hide-error-codes>`
-or config ``hide_error_codes = True`` to hide error codes. Error codes are shown inside square brackets:
-
-.. code-block:: text
-
-   $ mypy prog.py
-   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.
-
-
 .. _silence-error-codes:
 
 Silencing errors based on error codes
@@ -43,11 +27,7 @@ Silencing errors based on error codes
 You can use a special comment ``# type: ignore[code, ...]`` to only
 ignore errors with a specific error code (or codes) on a particular
 line.  This can be used even if you have not configured mypy to show
-error codes. Currently it's only possible to disable arbitrary error
-codes on individual lines using this comment.
-
-You can also use :option:`--disable-error-code <mypy --disable-error-code>`
-to disable specific error codes globally.
+error codes.
 
 This example shows how to ignore an error about an imported name mypy
 thinks is undefined:
@@ -58,17 +38,17 @@ thinks is undefined:
    # definition.
    from foolib import foo  # type: ignore[attr-defined]
 
-
-Enabling specific error codes
------------------------------
+Enabling/disabling specific error codes globally
+------------------------------------------------
 
 There are command-line flags and config file settings for enabling
 certain optional error codes, such as :option:`--disallow-untyped-defs <mypy --disallow-untyped-defs>`,
 which enables the ``no-untyped-def`` error code.
 
-You can use :option:`--enable-error-code <mypy --enable-error-code>` to
-enable specific error codes that don't have a dedicated command-line
-flag or config file setting.
+You can use :option:`--enable-error-code <mypy --enable-error-code>`
+and :option:`--disable-error-code <mypy --disable-error-code>`
+to enable or disable specific error codes that don't have a dedicated
+command-line flag or config file setting.
 
 Per-module enabling/disabling error codes
 -----------------------------------------
@@ -107,8 +87,13 @@ still keep the other two error codes enabled. The overall logic is following:
 
 * Individual config sections *adjust* them per glob/module
 
-* Inline ``# mypy: ...`` comments can further *adjust* them for a specific
-  module
+* Inline ``# mypy: disable-error-code="..."`` and ``# mypy: enable-error-code="..."``
+  comments can further *adjust* them for a specific file.
+  For example:
+
+.. code-block:: python
+
+  # mypy: enable-error-code="truthy-bool, ignore-without-code"
 
 So one can e.g. enable some code globally, disable it for all tests in
 the corresponding config section, and then re-enable it with an inline
@@ -124,3 +109,10 @@ Similar logic works for disabling error codes globally. If a given error code
 is a subcode of another one, it will be mentioned in the documentation for the narrower
 code. This hierarchy is not nested: there cannot be subcodes of other
 subcodes.
+
+
+Requiring error codes
+---------------------
+
+It's possible to require error codes be specified in ``type: ignore`` comments.
+See :ref:`ignore-without-code<code-ignore-without-code>` for more information.
diff --git a/docs/source/existing_code.rst b/docs/source/existing_code.rst
index c66008f4b782..dfdc7ef19e16 100644
--- a/docs/source/existing_code.rst
+++ b/docs/source/existing_code.rst
@@ -31,8 +31,8 @@ invocation to your codebase, or adding your mypy invocation to
 existing tools you use to run tests, like ``tox``.
 
 * Make sure everyone runs mypy with the same options. Checking a mypy
-  :ref:`configuration file <config-file>` into your codebase can help
-  with this.
+  :ref:`configuration file <config-file>` into your codebase is the
+  easiest way to do this.
 
 * Make sure everyone type checks the same set of files. See
   :ref:`specifying-code-to-be-checked` for details.
@@ -48,7 +48,7 @@ A simple CI script could look something like this:
 
 .. code-block:: text
 
-    python3 -m pip install mypy==0.971
+    python3 -m pip install mypy==1.8
     # Run your standardised mypy invocation, e.g.
     mypy my_project
     # This could also look like `scripts/run_mypy.sh`, `tox run -e mypy`, `make mypy`, etc
@@ -74,6 +74,11 @@ You could even invert this, by setting ``ignore_errors = True`` in your global
 config section and only enabling error reporting with ``ignore_errors = False``
 for the set of modules you are ready to type check.
 
+The per-module configuration that mypy's configuration file allows can be
+extremely useful. Many configuration options can be enabled or disabled
+only for specific modules. In particular, you can also enable or disable
+various error codes on a per-module basis, see :ref:`error-codes`.
+
 Fixing errors related to imports
 --------------------------------
 
@@ -89,7 +94,7 @@ that it can't find, that don't have types, or don't have stub files:
 Sometimes these can be fixed by installing the relevant packages or
 stub libraries in the environment you're running ``mypy`` in.
 
-See :ref:`ignore-missing-imports` for a complete reference on these errors
+See :ref:`fix-missing-imports` for a complete reference on these errors
 and the ways in which you can fix them.
 
 You'll likely find that you want to suppress all errors from importing
@@ -118,13 +123,15 @@ codebase, use a config like this:
    ignore_missing_imports = True
 
 If you get a large number of errors, you may want to ignore all errors
-about missing imports, for instance by setting :confval:`ignore_missing_imports`
-to true globally. This can hide errors later on, so we recommend avoiding this
+about missing imports, for instance by setting
+:option:`--disable-error-code=import-untyped <mypy --ignore-missing-imports>`.
+or setting :confval:`ignore_missing_imports` to true globally.
+This can hide errors later on, so we recommend avoiding this
 if possible.
 
 Finally, mypy allows fine-grained control over specific import following
 behaviour. It's very easy to silently shoot yourself in the foot when playing
-around with these, so it's mostly recommended as a last resort. For more
+around with these, so this should be a last resort. For more
 details, look :ref:`here <follow-imports>`.
 
 Prioritise annotating widely imported modules
@@ -192,9 +199,8 @@ The following config is equivalent to ``--strict`` (as of mypy 1.0):
    warn_redundant_casts = True
    warn_unused_ignores = True
 
-   # Getting these passing should be easy
+   # Getting this passing should be easy
    strict_equality = True
-   strict_concatenate = True
 
    # Strongly recommend enabling this one as soon as you can
    check_untyped_defs = True
@@ -216,6 +222,10 @@ The following config is equivalent to ``--strict`` (as of mypy 1.0):
    # This one can be tricky to get passing if you use a lot of untyped libraries
    warn_return_any = True
 
+   # This one is a catch-all flag for the rest of strict checks that are technically
+   # correct but may not be practical
+   extra_checks = True
+
 Note that you can also start with ``--strict`` and subtract, for instance:
 
 .. code-block:: text
diff --git a/docs/source/extending_mypy.rst b/docs/source/extending_mypy.rst
index daf863616334..0df45ea22d33 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.
@@ -179,7 +179,7 @@ mypy will call ``get_method_signature_hook("ctypes.Array.__setitem__")``
 so that the plugin can mimic the :py:mod:`ctypes` auto-convert behavior.
 
 **get_attribute_hook()** overrides instance member field lookups and property
-access (not assignments, and not method calls). This hook is only called for
+access (not method calls). This hook is only called for
 fields which already exist on the class. *Exception:* if :py:meth:`__getattr__ <object.__getattr__>` or
 :py:meth:`__getattribute__ <object.__getattribute__>` is a method on the class, the hook is called for all
 fields which do not refer to methods.
@@ -237,3 +237,12 @@ mypy's cache for that module so that it can be rechecked. This hook
 should be used to report to mypy any relevant configuration data,
 so that mypy knows to recheck the module if the configuration changes.
 The hooks should return data encodable as JSON.
+
+Useful tools
+************
+
+Mypy ships ``mypy.plugins.proper_plugin`` plugin which can be useful
+for plugin authors, since it finds missing ``get_proper_type()`` calls,
+which is a pretty common mistake.
+
+It is recommended to enable it as a part of your plugin's CI.
diff --git a/docs/source/faq.rst b/docs/source/faq.rst
index 195805382cd3..b7f5e3759a7e 100644
--- a/docs/source/faq.rst
+++ b/docs/source/faq.rst
@@ -102,8 +102,8 @@ Structural subtyping can be thought of as "static duck typing".
 Some argue that structural subtyping is better suited for languages with duck
 typing such as Python. Mypy however primarily uses nominal subtyping,
 leaving structural subtyping mostly opt-in (except for built-in protocols
-such as :py:class:`~typing.Iterable` that always support structural subtyping). Here are some
-reasons why:
+such as :py:class:`~collections.abc.Iterable` that always support structural
+subtyping). Here are some reasons why:
 
 1. It is easy to generate short and informative error messages when
    using a nominal type system. This is especially important when
@@ -140,13 +140,14 @@ How are mypy programs different from normal Python?
 Since you use a vanilla Python implementation to run mypy programs,
 mypy programs are also Python programs. The type checker may give
 warnings for some valid Python code, but the code is still always
-runnable. Also, some Python features and syntax are still not
+runnable. Also, a few Python features are still not
 supported by mypy, but this is gradually improving.
 
 The obvious difference is the availability of static type
 checking. The section :ref:`common_issues` mentions some
 modifications to Python code that may be required to make code type
-check without errors. Also, your code must make attributes explicit.
+check without errors. Also, your code must make defined
+attributes explicit.
 
 Mypy supports modular, efficient type checking, and this seems to
 rule out type checking some language features, such as arbitrary
diff --git a/docs/source/final_attrs.rst b/docs/source/final_attrs.rst
index 297b97eca787..81bfba650430 100644
--- a/docs/source/final_attrs.rst
+++ b/docs/source/final_attrs.rst
@@ -25,8 +25,8 @@ Final names
 
 You can use the ``typing.Final`` qualifier to indicate that
 a name or attribute should not be reassigned, redefined, or
-overridden.  This is often useful for module and class level constants
-as a way to prevent unintended modification.  Mypy will prevent
+overridden. This is often useful for module and class-level
+constants to prevent unintended modification. Mypy will prevent
 further assignments to final names in type-checked code:
 
 .. code-block:: python
@@ -70,7 +70,7 @@ You can use ``Final`` in one of these forms:
 
      ID: Final[int] = 1
 
-  Here mypy will infer type ``int`` for ``ID``.
+  Here, mypy will infer type ``int`` for ``ID``.
 
 * You can omit the type:
 
@@ -78,15 +78,15 @@ You can use ``Final`` in one of these forms:
 
      ID: Final = 1
 
-  Here mypy will infer type ``Literal[1]`` for ``ID``. Note that unlike for
-  generic classes this is *not* the same as ``Final[Any]``.
+  Here, mypy will infer type ``Literal[1]`` for ``ID``. Note that unlike for
+  generic classes, this is *not* the same as ``Final[Any]``.
 
-* In class bodies and stub files you can omit the right hand side and just write
+* In class bodies and stub files, you can omit the right-hand side and just write
   ``ID: Final[int]``.
 
 * Finally, you can write ``self.id: Final = 1`` (also optionally with
   a type in square brackets). This is allowed *only* in
-  :py:meth:`__init__ <object.__init__>` methods, so that the final instance attribute is
+  :py:meth:`__init__ <object.__init__>` methods so the final instance attribute is
   assigned only once when an instance is created.
 
 Details of using ``Final``
@@ -129,7 +129,7 @@ the scope of a final declaration automatically depending on whether it was
 initialized in the class body or in :py:meth:`__init__ <object.__init__>`.
 
 A final attribute can't be overridden by a subclass (even with another
-explicit final declaration). Note however that a final attribute can
+explicit final declaration). Note, however, that a final attribute can
 override a read-only property:
 
 .. code-block:: python
@@ -176,12 +176,12 @@ overriding. You can use the ``typing.final`` decorator for this purpose:
 This ``@final`` decorator can be used with instance methods, class methods,
 static methods, and properties.
 
-For overloaded methods you should add ``@final`` on the implementation
+For overloaded methods, you should add ``@final`` on the implementation
 to make it final (or on the first overload in stubs):
 
 .. code-block:: python
 
-   from typing import Any, overload
+   from typing import final, overload
 
    class Base:
        @overload
@@ -224,7 +224,7 @@ Here are some situations where using a final class may be useful:
 
 An abstract class that defines at least one abstract method or
 property and has ``@final`` decorator will generate an error from
-mypy, since those attributes could never be implemented.
+mypy since those attributes could never be implemented.
 
 .. code-block:: python
 
diff --git a/docs/source/generics.rst b/docs/source/generics.rst
index 9ac79f90121d..15538dea13bf 100644
--- a/docs/source/generics.rst
+++ b/docs/source/generics.rst
@@ -2,7 +2,7 @@ Generics
 ========
 
 This section explains how you can define your own generic classes that take
-one or more type parameters, similar to built-in types such as ``list[X]``.
+one or more type arguments, similar to built-in types such as ``list[T]``.
 User-defined generics are a moderately advanced feature and you can get far
 without ever using them -- feel free to skip this section and come back later.
 
@@ -12,18 +12,48 @@ Defining generic classes
 ************************
 
 The built-in collection classes are generic classes. Generic types
-have one or more type parameters, which can be arbitrary types. For
-example, ``dict[int, str]`` has the type parameters ``int`` and
-``str``, and ``list[int]`` has a type parameter ``int``.
+accept one or more type arguments within ``[...]``, which can be
+arbitrary types. For example, the type ``dict[int, str]`` has the
+type arguments ``int`` and ``str``, and ``list[int]`` has the type
+argument ``int``.
 
 Programs can also define new generic classes. Here is a very simple
-generic class that represents a stack:
+generic class that represents a stack (using the syntax introduced in
+Python 3.12):
+
+.. code-block:: python
+
+   class Stack[T]:
+       def __init__(self) -> None:
+           # Create an empty list with items of type T
+           self.items: list[T] = []
+
+       def push(self, item: T) -> None:
+           self.items.append(item)
+
+       def pop(self) -> T:
+           return self.items.pop()
+
+       def empty(self) -> bool:
+           return not self.items
+
+There are two syntax variants for defining generic classes in Python.
+Python 3.12 introduced a
+`new dedicated syntax <https://docs.python.org/3/whatsnew/3.12.html#pep-695-type-parameter-syntax>`_
+for defining generic classes (and also functions and type aliases, which
+we will discuss later). The above example used the new syntax. Most examples are
+given using both the new and the old (or legacy) syntax variants.
+Unless mentioned otherwise, they work the same -- but the new syntax
+is more readable and more convenient.
+
+Here is the same example using the old syntax (required for Python 3.11
+and earlier, but also supported on newer Python versions):
 
 .. code-block:: python
 
    from typing import TypeVar, Generic
 
-   T = TypeVar('T')
+   T = TypeVar('T')  # Define type variable "T"
 
    class Stack(Generic[T]):
        def __init__(self) -> None:
@@ -39,8 +69,16 @@ generic class that represents a stack:
        def empty(self) -> bool:
            return not self.items
 
+.. note::
+
+    There are currently no plans to deprecate the legacy syntax.
+    You can freely mix code using the new and old syntax variants,
+    even within a single file (but *not* within a single class).
+
 The ``Stack`` class can be used to represent a stack of any type:
-``Stack[int]``, ``Stack[tuple[int, str]]``, etc.
+``Stack[int]``, ``Stack[tuple[int, str]]``, etc. You can think of
+``Stack[int]`` as referring to the definition of ``Stack`` above,
+but with all instances of ``T`` replaced with ``int``.
 
 Using ``Stack`` is similar to built-in container types:
 
@@ -50,19 +88,49 @@ Using ``Stack`` is similar to built-in container types:
    stack = Stack[int]()
    stack.push(2)
    stack.pop()
-   stack.push('x')  # error: Argument 1 to "push" of "Stack" has incompatible type "str"; expected "int"
 
-Construction of instances of generic types is type checked:
+   # error: Argument 1 to "push" of "Stack" has incompatible type "str"; expected "int"
+   stack.push('x')
+
+   stack2: Stack[str] = Stack()
+   stack2.append('x')
+
+Construction of instances of generic types is type checked (Python 3.12 syntax):
 
 .. code-block:: python
 
-   class Box(Generic[T]):
+   class Box[T]:
        def __init__(self, content: T) -> None:
            self.content = content
 
    Box(1)       # OK, inferred type is Box[int]
    Box[int](1)  # Also OK
-   Box[int]('some string')  # error: Argument 1 to "Box" has incompatible type "str"; expected "int"
+
+   # error: Argument 1 to "Box" has incompatible type "str"; expected "int"
+   Box[int]('some string')
+
+Here is the definition of ``Box`` using the legacy syntax (Python 3.11 and earlier):
+
+.. code-block:: python
+
+   from typing import TypeVar, Generic
+
+   T = TypeVar('T')
+
+   class Box(Generic[T]):
+       def __init__(self, content: T) -> None:
+           self.content = content
+
+.. note::
+
+    Before moving on, let's clarify some terminology.
+    The name ``T`` in ``class Stack[T]`` or ``class Stack(Generic[T])``
+    declares a *type parameter* ``T`` (of class ``Stack``).
+    ``T`` is also called a *type variable*, especially in a type annotation,
+    such as in the signature of ``push`` above.
+    When the type ``Stack[...]`` is used in a type annotation, the type
+    within square brackets is called a *type argument*.
+    This is similar to the distinction between function parameters and arguments.
 
 .. _generic-subclasses:
 
@@ -70,7 +138,37 @@ Defining subclasses of generic classes
 **************************************
 
 User-defined generic classes and generic classes defined in :py:mod:`typing`
-can be used as a base class for another class (generic or non-generic). For example:
+can be used as a base class for another class (generic or non-generic). For
+example (Python 3.12 syntax):
+
+.. code-block:: python
+
+   from typing import Mapping, Iterator
+
+   # This is a generic subclass of Mapping
+   class MyMap[KT, VT](Mapping[KT, VT]):
+       def __getitem__(self, k: KT) -> VT: ...
+       def __iter__(self) -> Iterator[KT]: ...
+       def __len__(self) -> int: ...
+
+   items: MyMap[str, int]  # OK
+
+   # This is a non-generic subclass of dict
+   class StrDict(dict[str, str]):
+       def __str__(self) -> str:
+           return f'StrDict({super().__str__()})'
+
+   data: StrDict[int, int]  # Error! StrDict is not generic
+   data2: StrDict  # OK
+
+   # This is a user-defined generic class
+   class Receiver[T]:
+       def accept(self, value: T) -> None: ...
+
+   # This is a generic subclass of Receiver
+   class AdvancedReceiver[T](Receiver[T]): ...
+
+Here is the above example using the legacy syntax (Python 3.11 and earlier):
 
 .. code-block:: python
 
@@ -92,7 +190,6 @@ can be used as a base class for another class (generic or non-generic). For exam
        def __str__(self) -> str:
            return f'StrDict({super().__str__()})'
 
-
    data: StrDict[int, int]  # Error! StrDict is not generic
    data2: StrDict  # OK
 
@@ -105,25 +202,27 @@ can be used as a base class for another class (generic or non-generic). For exam
 
 .. note::
 
-    You have to add an explicit :py:class:`~typing.Mapping` base class
+    You have to add an explicit :py:class:`~collections.abc.Mapping` base class
     if you want mypy to consider a user-defined class as a mapping (and
-    :py:class:`~typing.Sequence` for sequences, etc.). This is because mypy doesn't use
-    *structural subtyping* for these ABCs, unlike simpler protocols
-    like :py:class:`~typing.Iterable`, which use :ref:`structural subtyping <protocol-types>`.
+    :py:class:`~collections.abc.Sequence` for sequences, etc.). This is because
+    mypy doesn't use *structural subtyping* for these ABCs, unlike simpler protocols
+    like :py:class:`~collections.abc.Iterable`, which use
+    :ref:`structural subtyping <protocol-types>`.
 
-:py:class:`Generic <typing.Generic>` can be omitted from bases if there are
+When using the legacy syntax, :py:class:`Generic <typing.Generic>` can be omitted
+from bases if there are
 other base classes that include type variables, such as ``Mapping[KT, VT]``
 in the above example. If you include ``Generic[...]`` in bases, then
 it should list all type variables present in other bases (or more,
-if needed). The order of type variables is defined by the following
+if needed). The order of type parameters is defined by the following
 rules:
 
-* If ``Generic[...]`` is present, then the order of variables is
+* If ``Generic[...]`` is present, then the order of parameters is
   always determined by their order in ``Generic[...]``.
-* If there are no ``Generic[...]`` in bases, then all type variables
+* If there are no ``Generic[...]`` in bases, then all type parameters
   are collected in the lexicographic order (i.e. by first appearance).
 
-For example:
+Example:
 
 .. code-block:: python
 
@@ -142,12 +241,26 @@ For example:
    x: First[int, str]        # Here T is bound to int, S is bound to str
    y: Second[int, str, Any]  # Here T is Any, S is int, and U is str
 
+When using the Python 3.12 syntax, all type parameters must always be
+explicitly defined immediately after the class name within ``[...]``, and the
+``Generic[...]`` base class is never used.
+
 .. _generic-functions:
 
 Generic functions
 *****************
 
-Type variables can be used to define generic functions:
+Functions can also be generic, i.e. they can have type parameters (Python 3.12 syntax):
+
+.. code-block:: python
+
+   from collections.abc import Sequence
+
+   # A generic function!
+   def first[T](seq: Sequence[T]) -> T:
+       return seq[0]
+
+Here is the same example using the legacy syntax (Python 3.11 and earlier):
 
 .. code-block:: python
 
@@ -159,24 +272,25 @@ Type variables can be used to define generic functions:
    def first(seq: Sequence[T]) -> T:
        return seq[0]
 
-As with generic classes, the type variable can be replaced with any
-type. That means ``first`` can be used with any sequence type, and the
-return type is derived from the sequence item type. For example:
+As with generic classes, the type parameter ``T`` can be replaced with any
+type. That means ``first`` can be passed an argument with any sequence type,
+and the return type is derived from the sequence item type. Example:
 
 .. code-block:: python
 
    reveal_type(first([1, 2, 3]))   # Revealed type is "builtins.int"
-   reveal_type(first(['a', 'b']))  # Revealed type is "builtins.str"
+   reveal_type(first(('a', 'b')))  # Revealed type is "builtins.str"
 
-Note also that a single definition of a type variable (such as ``T``
-above) can be used in multiple generic functions or classes. In this
-example we use the same type variable in two generic functions:
+When using the legacy syntax, a single definition of a type variable
+(such as ``T`` above) can be used in multiple generic functions or
+classes. In this example we use the same type variable in two generic
+functions to declare type parameters:
 
 .. code-block:: python
 
    from typing import TypeVar, Sequence
 
-   T = TypeVar('T')      # Declare type variable
+   T = TypeVar('T')      # Define type variable
 
    def first(seq: Sequence[T]) -> T:
        return seq[0]
@@ -184,20 +298,109 @@ example we use the same type variable in two generic functions:
    def last(seq: Sequence[T]) -> T:
        return seq[-1]
 
+Since the Python 3.12 syntax is more concise, it doesn't need (or have)
+an equivalent way of sharing type parameter definitions.
+
 A variable cannot have a type variable in its type unless the type
 variable is bound in a containing generic class or function.
 
+When calling a generic function, you can't explicitly pass the values of
+type parameters as type arguments. The values of type parameters are always
+inferred by mypy. This is not valid:
+
+.. code-block:: python
+
+    first[int]([1, 2])  # Error: can't use [...] with generic function
+
+If you really need this, you can define a generic class with a ``__call__``
+method.
+
+.. _type-variable-upper-bound:
+
+Type variables with upper bounds
+********************************
+
+A type variable can also be restricted to having values that are
+subtypes of a specific type. This type is called the upper bound of
+the type variable, and it is specified using ``T: <bound>`` when using the
+Python 3.12 syntax. In the definition of a generic function or a generic
+class that uses such a type variable ``T``, the type represented by ``T``
+is assumed to be a subtype of its upper bound, so you can use methods
+of the upper bound on values of type ``T`` (Python 3.12 syntax):
+
+.. code-block:: python
+
+   from typing import SupportsAbs
+
+   def max_by_abs[T: SupportsAbs[float]](*xs: T) -> T:
+       # We can use abs(), because T is a subtype of SupportsAbs[float].
+       return max(xs, key=abs)
+
+An upper bound can also be specified with the ``bound=...`` keyword
+argument to :py:class:`~typing.TypeVar`.
+Here is the example using the legacy syntax (Python 3.11 and earlier):
+
+.. code-block:: python
+
+   from typing import TypeVar, SupportsAbs
+
+   T = TypeVar('T', bound=SupportsAbs[float])
+
+   def max_by_abs(*xs: T) -> T:
+       return max(xs, key=abs)
+
+In a call to such a function, the type ``T`` must be replaced by a
+type that is a subtype of its upper bound. Continuing the example
+above:
+
+.. code-block:: python
+
+   max_by_abs(-3.5, 2)   # Okay, has type 'float'
+   max_by_abs(5+6j, 7)   # Okay, has type 'complex'
+   max_by_abs('a', 'b')  # Error: 'str' is not a subtype of SupportsAbs[float]
+
+Type parameters of generic classes may also have upper bounds, which
+restrict the valid values for the type parameter in the same way.
+
 .. _generic-methods-and-generic-self:
 
 Generic methods and generic self
 ********************************
 
-You can also define generic methods — just use a type variable in the
-method signature that is different from class type variables. In
-particular, the ``self`` argument may also be generic, allowing a
+You can also define generic methods. In
+particular, the ``self`` parameter may also be generic, allowing a
 method to return the most precise type known at the point of access.
 In this way, for example, you can type check a chain of setter
-methods:
+methods (Python 3.12 syntax):
+
+.. code-block:: python
+
+   class Shape:
+       def set_scale[T: Shape](self: T, scale: float) -> T:
+           self.scale = scale
+           return self
+
+   class Circle(Shape):
+       def set_radius(self, r: float) -> 'Circle':
+           self.radius = r
+           return self
+
+   class Square(Shape):
+       def set_width(self, w: float) -> 'Square':
+           self.width = w
+           return self
+
+   circle: Circle = Circle().set_scale(0.5).set_radius(2.7)
+   square: Square = Square().set_scale(0.5).set_width(3.2)
+
+Without using generic ``self``, the last two lines could not be type
+checked properly, since the return type of ``set_scale`` would be
+``Shape``, which doesn't define ``set_radius`` or ``set_width``.
+
+When using the legacy syntax, just use a type variable in the
+method signature that is different from class type parameters (if any
+are defined). Here is the above example using the legacy
+syntax (3.11 and earlier):
 
 .. code-block:: python
 
@@ -223,24 +426,40 @@ methods:
    circle: Circle = Circle().set_scale(0.5).set_radius(2.7)
    square: Square = Square().set_scale(0.5).set_width(3.2)
 
-Without using generic ``self``, the last two lines could not be type
-checked properly, since the return type of ``set_scale`` would be
-``Shape``, which doesn't define ``set_radius`` or ``set_width``.
+Other uses include factory methods, such as copy and deserialization methods.
+For class methods, you can also define generic ``cls``, using ``type[T]``
+or :py:class:`Type[T] <typing.Type>` (Python 3.12 syntax):
+
+.. code-block:: python
+
+   class Friend:
+       other: "Friend | None" = None
 
-Other uses are factory methods, such as copy and deserialization.
-For class methods, you can also define generic ``cls``, using :py:class:`Type[T] <typing.Type>`:
+       @classmethod
+       def make_pair[T: Friend](cls: type[T]) -> tuple[T, T]:
+           a, b = cls(), cls()
+           a.other = b
+           b.other = a
+           return a, b
+
+   class SuperFriend(Friend):
+       pass
+
+   a, b = SuperFriend.make_pair()
+
+Here is the same example using the legacy syntax (3.11 and earlier):
 
 .. code-block:: python
 
-   from typing import TypeVar, Type
+   from typing import TypeVar
 
    T = TypeVar('T', bound='Friend')
 
    class Friend:
-       other: "Friend" = None
+       other: "Friend | None" = None
 
        @classmethod
-       def make_pair(cls: Type[T]) -> tuple[T, T]:
+       def make_pair(cls: type[T]) -> tuple[T, T]:
            a, b = cls(), cls()
            a.other = b
            b.other = a
@@ -260,18 +479,15 @@ or a deserialization method returns the actual type of self. Therefore
 you may need to silence mypy inside these methods (but not at the call site),
 possibly by making use of the ``Any`` type or a ``# type: ignore`` comment.
 
-Note that mypy lets you use generic self types in certain unsafe ways
+Mypy lets you use generic self types in certain unsafe ways
 in order to support common idioms. For example, using a generic
-self type in an argument type is accepted even though it's unsafe:
+self type in an argument type is accepted even though it's unsafe (Python 3.12
+syntax):
 
 .. code-block:: python
 
-   from typing import TypeVar
-
-   T = TypeVar("T")
-
    class Base:
-       def compare(self: T, other: T) -> bool:
+       def compare[T: Base](self: T, other: T) -> bool:
            return False
 
    class Sub(Base):
@@ -280,7 +496,7 @@ self type in an argument type is accepted even though it's unsafe:
 
        # This is unsafe (see below) but allowed because it's
        # a common pattern and rarely causes issues in practice.
-       def compare(self, other: Sub) -> bool:
+       def compare(self, other: 'Sub') -> bool:
            return self.x > other.x
 
    b: Base = Sub(42)
@@ -293,12 +509,12 @@ Automatic self types using typing.Self
 
 Since the patterns described above are quite common, mypy supports a
 simpler syntax, introduced in :pep:`673`, to make them easier to use.
-Instead of defining a type variable and using an explicit annotation
+Instead of introducing a type parameter and using an explicit annotation
 for ``self``, you can import the special type ``typing.Self`` that is
-automatically transformed into a type variable with the current class
-as the upper bound, and you don't need an annotation for ``self`` (or
-``cls`` in class methods). The example from the previous section can
-be made simpler by using ``Self``:
+automatically transformed into a method-level type parameter with the
+current class as the upper bound, and you don't need an annotation for
+``self`` (or ``cls`` in class methods). The example from the previous
+section can be made simpler by using ``Self``:
 
 .. code-block:: python
 
@@ -319,7 +535,7 @@ be made simpler by using ``Self``:
 
    a, b = SuperFriend.make_pair()
 
-This is more compact than using explicit type variables. Also, you can
+This is more compact than using explicit type parameters. Also, you can
 use ``Self`` in attribute annotations in addition to methods.
 
 .. note::
@@ -354,10 +570,10 @@ Let us illustrate this by few simple examples:
     class Triangle(Shape): ...
     class Square(Shape): ...
 
-* Most immutable containers, such as :py:class:`~typing.Sequence` and
-  :py:class:`~typing.FrozenSet` are covariant. :py:data:`~typing.Union` is
-  also covariant in all variables: ``Union[Triangle, int]`` is
-  a subtype of ``Union[Shape, int]``.
+* Most immutable container types, such as :py:class:`~collections.abc.Sequence`
+  and :py:class:`~frozenset` are covariant. Union types are
+  also covariant in all union items: ``Triangle | int`` is
+  a subtype of ``Shape | int``.
 
   .. code-block:: python
 
@@ -367,7 +583,7 @@ Let us illustrate this by few simple examples:
     triangles: Sequence[Triangle]
     count_lines(triangles)  # OK
 
-    def foo(triangle: Triangle, num: int):
+    def foo(triangle: Triangle, num: int) -> None:
         shape_or_number: Union[Shape, int]
         # a Triangle is a Shape, and a Shape is a valid Union[Shape, int]
         shape_or_number = triangle
@@ -375,7 +591,7 @@ Let us illustrate this by few simple examples:
   Covariance should feel relatively intuitive, but contravariance and invariance
   can be harder to reason about.
 
-* :py:data:`~typing.Callable` is an example of type that behaves contravariant
+* :py:class:`~collections.abc.Callable` is an example of type that behaves contravariant
   in types of arguments. That is, ``Callable[[Shape], int]`` is a subtype of
   ``Callable[[Triangle], int]``, despite ``Shape`` being a supertype of
   ``Triangle``. To understand this, consider:
@@ -400,8 +616,8 @@ Let us illustrate this by few simple examples:
   triangle. If we give it a callable that can calculate the area of an
   arbitrary shape (not just triangles), everything still works.
 
-* :py:class:`~typing.List` is an invariant generic type. Naively, one would think
-  that it is covariant, like :py:class:`~typing.Sequence` above, but consider this code:
+* ``list`` is an invariant generic type. Naively, one would think
+  that it is covariant, like :py:class:`~collections.abc.Sequence` above, but consider this code:
 
   .. code-block:: python
 
@@ -416,107 +632,104 @@ Let us illustrate this by few simple examples:
      add_one(my_circles)     # This may appear safe, but...
      my_circles[-1].rotate()  # ...this will fail, since my_circles[0] is now a Shape, not a Circle
 
-  Another example of invariant type is :py:class:`~typing.Dict`. Most mutable containers
+  Another example of invariant type is ``dict``. Most mutable containers
   are invariant.
 
-By default, mypy assumes that all user-defined generics are invariant.
-To declare a given generic class as covariant or contravariant use
-type variables defined with special keyword arguments ``covariant`` or
-``contravariant``. For example:
+When using the Python 3.12 syntax for generics, mypy will automatically
+infer the most flexible variance for each class type variable. Here
+``Box`` will be inferred as covariant:
 
 .. code-block:: python
 
-   from typing import Generic, TypeVar
-
-   T_co = TypeVar('T_co', covariant=True)
-
-   class Box(Generic[T_co]):  # this type is declared covariant
-       def __init__(self, content: T_co) -> None:
+   class Box[T]:  # this type is implicitly covariant
+       def __init__(self, content: T) -> None:
            self._content = content
 
-       def get_content(self) -> T_co:
+       def get_content(self) -> T:
            return self._content
 
-   def look_into(box: Box[Animal]): ...
+   def look_into(box: Box[Shape]): ...
 
-   my_box = Box(Cat())
+   my_box = Box(Square())
    look_into(my_box)  # OK, but mypy would complain here for an invariant type
 
-.. _type-variable-upper-bound:
-
-Type variables with upper bounds
-********************************
-
-A type variable can also be restricted to having values that are
-subtypes of a specific type. This type is called the upper bound of
-the type variable, and is specified with the ``bound=...`` keyword
-argument to :py:class:`~typing.TypeVar`.
+Here the underscore prefix for ``_content`` is significant. Without an
+underscore prefix, the class would be invariant, as the attribute would
+be understood as a public, mutable attribute (a single underscore prefix
+has no special significance for mypy in most other contexts). By declaring
+the attribute as ``Final``, the class could still be made covariant:
 
 .. code-block:: python
 
-   from typing import TypeVar, SupportsAbs
+   from typing import Final
 
-   T = TypeVar('T', bound=SupportsAbs[float])
+   class Box[T]:  # this type is implicitly covariant
+       def __init__(self, content: T) -> None:
+           self.content: Final = content
+
+       def get_content(self) -> T:
+           return self.content
 
-In the definition of a generic function that uses such a type variable
-``T``, the type represented by ``T`` is assumed to be a subtype of
-its upper bound, so the function can use methods of the upper bound on
-values of type ``T``.
+When using the legacy syntax, mypy assumes that all user-defined generics
+are invariant by default. To declare a given generic class as covariant or
+contravariant, use type variables defined with special keyword arguments
+``covariant`` or ``contravariant``. For example (Python 3.11 or earlier):
 
 .. code-block:: python
 
-   def largest_in_absolute_value(*xs: T) -> T:
-       return max(xs, key=abs)  # Okay, because T is a subtype of SupportsAbs[float].
+   from typing import Generic, TypeVar
 
-In a call to such a function, the type ``T`` must be replaced by a
-type that is a subtype of its upper bound. Continuing the example
-above:
+   T_co = TypeVar('T_co', covariant=True)
 
-.. code-block:: python
+   class Box(Generic[T_co]):  # this type is declared covariant
+       def __init__(self, content: T_co) -> None:
+           self._content = content
 
-   largest_in_absolute_value(-3.5, 2)   # Okay, has type float.
-   largest_in_absolute_value(5+6j, 7)   # Okay, has type complex.
-   largest_in_absolute_value('a', 'b')  # Error: 'str' is not a subtype of SupportsAbs[float].
+       def get_content(self) -> T_co:
+           return self._content
 
-Type parameters of generic classes may also have upper bounds, which
-restrict the valid values for the type parameter in the same way.
+   def look_into(box: Box[Shape]): ...
+
+   my_box = Box(Square())
+   look_into(my_box)  # OK, but mypy would complain here for an invariant type
 
 .. _type-variable-value-restriction:
 
 Type variables with value restriction
 *************************************
 
-By default, a type variable can be replaced with any type. However, sometimes
+By default, a type variable can be replaced with any type -- or any type that
+is a subtype of the upper bound, which defaults to ``object``. However, sometimes
 it's useful to have a type variable that can only have some specific types
 as its value. A typical example is a type variable that can only have values
-``str`` and ``bytes``:
+``str`` and ``bytes``. This lets us define a function that can concatenate
+two strings or bytes objects, but it can't be called with other argument
+types (Python 3.12 syntax):
 
 .. code-block:: python
 
-   from typing import TypeVar
+   def concat[S: (str, bytes)](x: S, y: S) -> S:
+       return x + y
 
-   AnyStr = TypeVar('AnyStr', str, bytes)
+   concat('a', 'b')    # Okay
+   concat(b'a', b'b')  # Okay
+   concat(1, 2)        # Error!
 
-This is actually such a common type variable that :py:data:`~typing.AnyStr` is
-defined in :py:mod:`typing` and we don't need to define it ourselves.
 
-We can use :py:data:`~typing.AnyStr` to define a function that can concatenate
-two strings or bytes objects, but it can't be called with other
-argument types:
+The same thing is also possibly using the legacy syntax (Python 3.11 or earlier):
 
 .. code-block:: python
 
-   from typing import AnyStr
+   from typing import TypeVar
+
+   AnyStr = TypeVar('AnyStr', str, bytes)
 
    def concat(x: AnyStr, y: AnyStr) -> AnyStr:
        return x + y
 
-   concat('a', 'b')    # Okay
-   concat(b'a', b'b')  # Okay
-   concat(1, 2)        # Error!
-
-Importantly, this is different from a union type, since combinations
-of ``str`` and ``bytes`` are not accepted:
+No matter which syntax you use, such a type variable is called a type variable
+with a value restriction. Importantly, this is different from a union type,
+since combinations of ``str`` and ``bytes`` are not accepted:
 
 .. code-block:: python
 
@@ -524,11 +737,11 @@ of ``str`` and ``bytes`` are not accepted:
 
 In this case, this is exactly what we want, since it's not possible
 to concatenate a string and a bytes object! If we tried to use
-``Union``, the type checker would complain about this possibility:
+a union type, the type checker would complain about this possibility:
 
 .. code-block:: python
 
-   def union_concat(x: Union[str, bytes], y: Union[str, bytes]) -> Union[str, bytes]:
+   def union_concat(x: str | bytes, y: str | bytes) -> str | bytes:
        return x + y  # Error: can't concatenate str and bytes
 
 Another interesting special case is calling ``concat()`` with a
@@ -545,24 +758,28 @@ You may expect that the type of ``ss`` is ``S``, but the type is
 actually ``str``: a subtype gets promoted to one of the valid values
 for the type variable, which in this case is ``str``.
 
-This is thus
-subtly different from *bounded quantification* in languages such as
-Java, where the return type would be ``S``. The way mypy implements
-this is correct for ``concat``, since ``concat`` actually returns a
-``str`` instance in the above example:
+This is thus subtly different from using ``str | bytes`` as an upper bound,
+where the return type would be ``S`` (see :ref:`type-variable-upper-bound`).
+Using a value restriction is correct for ``concat``, since ``concat``
+actually returns a ``str`` instance in the above example:
 
 .. code-block:: python
 
     >>> print(type(ss))
     <class 'str'>
 
-You can also use a :py:class:`~typing.TypeVar` with a restricted set of possible
-values when defining a generic class. For example, mypy uses the type
-:py:class:`Pattern[AnyStr] <typing.Pattern>` for the return value of :py:func:`re.compile`,
-since regular expressions can be based on a string or a bytes pattern.
+You can also use type variables with a restricted set of possible
+values when defining a generic class. For example, the type
+:py:class:`Pattern[S] <typing.Pattern>` is used for the return
+value of :py:func:`re.compile`, where ``S`` can be either ``str``
+or ``bytes``. Regular expressions can be based on a string or a
+bytes pattern.
+
+A type variable may not have both a value restriction and an upper bound.
 
-A type variable may not have both a value restriction (see
-:ref:`type-variable-upper-bound`) and an upper bound.
+Note that you may come across :py:data:`~typing.AnyStr` imported from
+:py:mod:`typing`. This feature is now deprecated, but it means the same
+as our definition of ``AnyStr`` above.
 
 .. _declaring-decorators:
 
@@ -571,11 +788,12 @@ Declaring decorators
 
 Decorators are typically functions that take a function as an argument and
 return another function. Describing this behaviour in terms of types can
-be a little tricky; we'll show how you can use ``TypeVar`` and a special
+be a little tricky; we'll show how you can use type variables and a special
 kind of type variable called a *parameter specification* to do so.
 
 Suppose we have the following decorator, not type annotated yet,
-that preserves the original function's signature and merely prints the decorated function's name:
+that preserves the original function's signature and merely prints the decorated
+function's name:
 
 .. code-block:: python
 
@@ -585,7 +803,7 @@ that preserves the original function's signature and merely prints the decorated
            return func(*args, **kwds)
        return wrapper
 
-and we use it to decorate function ``add_forty_two``:
+We can use it to decorate function ``add_forty_two``:
 
 .. code-block:: python
 
@@ -611,11 +829,34 @@ Note that class decorators are handled differently than function decorators in
 mypy: decorating a class does not erase its type, even if the decorator has
 incomplete type annotations.
 
-Here's how one could annotate the decorator:
+Here's how one could annotate the decorator (Python 3.12 syntax):
 
 .. code-block:: python
 
-   from typing import Any, Callable, TypeVar, cast
+   from collections.abc import Callable
+   from typing import Any, cast
+
+   # A decorator that preserves the signature.
+   def printing_decorator[F: Callable[..., Any]](func: F) -> F:
+       def wrapper(*args, **kwds):
+           print("Calling", func)
+           return func(*args, **kwds)
+       return cast(F, wrapper)
+
+   @printing_decorator
+   def add_forty_two(value: int) -> int:
+       return value + 42
+
+   a = add_forty_two(3)
+   reveal_type(a)      # Revealed type is "builtins.int"
+   add_forty_two('x')  # Argument 1 to "add_forty_two" has incompatible type "str"; expected "int"
+
+Here is the example using the legacy syntax (Python 3.11 and earlier):
+
+.. code-block:: python
+
+   from collections.abc import Callable
+   from typing import Any, TypeVar, cast
 
    F = TypeVar('F', bound=Callable[..., Any])
 
@@ -636,19 +877,33 @@ Here's how one could annotate the decorator:
 
 This still has some shortcomings. First, we need to use the unsafe
 :py:func:`~typing.cast` to convince mypy that ``wrapper()`` has the same
-signature as ``func``. See :ref:`casts <casts>`.
+signature as ``func`` (see :ref:`casts <casts>`).
 
 Second, the ``wrapper()`` function is not tightly type checked, although
 wrapper functions are typically small enough that this is not a big
 problem. This is also the reason for the :py:func:`~typing.cast` call in the
 ``return`` statement in ``printing_decorator()``.
 
-However, we can use a parameter specification (:py:class:`~typing.ParamSpec`),
-for a more faithful type annotation:
+However, we can use a parameter specification, introduced using ``**P``,
+for a more faithful type annotation (Python 3.12 syntax):
+
+.. code-block:: python
+
+   from collections.abc import Callable
+
+   def printing_decorator[**P, T](func: Callable[P, T]) -> Callable[P, T]:
+       def wrapper(*args: P.args, **kwds: P.kwargs) -> T:
+           print("Calling", func)
+           return func(*args, **kwds)
+       return wrapper
+
+The same is possible using the legacy syntax with :py:class:`~typing.ParamSpec`
+(Python 3.11 and earlier):
 
 .. code-block:: python
 
-   from typing import Callable, TypeVar
+   from collections.abc import Callable
+   from typing import TypeVar
    from typing_extensions import ParamSpec
 
    P = ParamSpec('P')
@@ -661,18 +916,14 @@ for a more faithful type annotation:
        return wrapper
 
 Parameter specifications also allow you to describe decorators that
-alter the signature of the input function:
+alter the signature of the input function (Python 3.12 syntax):
 
 .. code-block:: python
 
-   from typing import Callable, TypeVar
-   from typing_extensions import ParamSpec
-
-   P = ParamSpec('P')
-   T = TypeVar('T')
+   from collections.abc import Callable
 
-    # We reuse 'P' in the return type, but replace 'T' with 'str'
-   def stringify(func: Callable[P, T]) -> Callable[P, str]:
+   # We reuse 'P' in the return type, but replace 'T' with 'str'
+   def stringify[**P, T](func: Callable[P, T]) -> Callable[P, str]:
        def wrapper(*args: P.args, **kwds: P.kwargs) -> str:
            return str(func(*args, **kwds))
        return wrapper
@@ -685,17 +936,31 @@ alter the signature of the input function:
     reveal_type(a)      # Revealed type is "builtins.str"
     add_forty_two('x')  # error: Argument 1 to "add_forty_two" has incompatible type "str"; expected "int"
 
-Or insert an argument:
+Here is the above example using the legacy syntax (Python 3.11 and earlier):
 
 .. code-block:: python
 
-    from typing import Callable, TypeVar
-    from typing_extensions import Concatenate, ParamSpec
+   from collections.abc import Callable
+   from typing import TypeVar
+   from typing_extensions import ParamSpec
 
-    P = ParamSpec('P')
-    T = TypeVar('T')
+   P = ParamSpec('P')
+   T = TypeVar('T')
 
-    def printing_decorator(func: Callable[P, T]) -> Callable[Concatenate[str, P], T]:
+   # We reuse 'P' in the return type, but replace 'T' with 'str'
+   def stringify(func: Callable[P, T]) -> Callable[P, str]:
+       def wrapper(*args: P.args, **kwds: P.kwargs) -> str:
+           return str(func(*args, **kwds))
+       return wrapper
+
+You can also insert an argument in a decorator (Python 3.12 syntax):
+
+.. code-block:: python
+
+    from collections.abc import Callable
+    from typing import Concatenate
+
+    def printing_decorator[**P, T](func: Callable[P, T]) -> Callable[Concatenate[str, P], T]:
         def wrapper(msg: str, /, *args: P.args, **kwds: P.kwargs) -> T:
             print("Calling", func, "with", msg)
             return func(*args, **kwds)
@@ -707,17 +972,54 @@ Or insert an argument:
 
     a = add_forty_two('three', 3)
 
+Here is the same function using the legacy syntax (Python 3.11 and earlier):
+
+.. code-block:: python
+
+    from collections.abc import Callable
+    from typing import TypeVar
+    from typing_extensions import Concatenate, ParamSpec
+
+    P = ParamSpec('P')
+    T = TypeVar('T')
+
+    def printing_decorator(func: Callable[P, T]) -> Callable[Concatenate[str, P], T]:
+        def wrapper(msg: str, /, *args: P.args, **kwds: P.kwargs) -> T:
+            print("Calling", func, "with", msg)
+            return func(*args, **kwds)
+        return wrapper
+
 .. _decorator-factories:
 
 Decorator factories
 -------------------
 
 Functions that take arguments and return a decorator (also called second-order decorators), are
-similarly supported via generics:
+similarly supported via generics (Python 3.12 syntax):
+
+.. code-block:: python
+
+    from collections.abc import Callable
+    from typing import Any
+
+    def route[F: Callable[..., Any]](url: str) -> Callable[[F], F]:
+        ...
+
+    @route(url='/')
+    def index(request: Any) -> str:
+        return 'Hello world'
+
+Note that mypy infers that ``F`` is used to make the ``Callable`` return value
+of ``route`` generic, instead of making ``route`` itself generic, since ``F`` is
+only used in the return type. Python has no explicit syntax to mark that ``F``
+is only bound in the return value.
+
+Here is the example using the legacy syntax (Python 3.11 and earlier):
 
 .. code-block:: python
 
-    from typing import Any, Callable, TypeVar
+    from collections.abc import Callable
+    from typing import Any, TypeVar
 
     F = TypeVar('F', bound=Callable[..., Any])
 
@@ -729,23 +1031,22 @@ similarly supported via generics:
         return 'Hello world'
 
 Sometimes the same decorator supports both bare calls and calls with arguments. This can be
-achieved by combining with :py:func:`@overload <typing.overload>`:
+achieved by combining with :py:func:`@overload <typing.overload>` (Python 3.12 syntax):
 
 .. code-block:: python
 
-    from typing import Any, Callable, Optional, TypeVar, overload
-
-    F = TypeVar('F', bound=Callable[..., Any])
+    from collections.abc import Callable
+    from typing import Any, overload
 
     # Bare decorator usage
     @overload
-    def atomic(__func: F) -> F: ...
+    def atomic[F: Callable[..., Any]](func: F, /) -> F: ...
     # Decorator with arguments
     @overload
-    def atomic(*, savepoint: bool = True) -> Callable[[F], F]: ...
+    def atomic[F: Callable[..., Any]](*, savepoint: bool = True) -> Callable[[F], F]: ...
 
     # Implementation
-    def atomic(__func: Optional[Callable[..., Any]] = None, *, savepoint: bool = True):
+    def atomic(func: Callable[..., Any] | None = None, /, *, savepoint: bool = True):
         def decorator(func: Callable[..., Any]):
             ...  # Code goes here
         if __func is not None:
@@ -760,22 +1061,41 @@ achieved by combining with :py:func:`@overload <typing.overload>`:
     @atomic(savepoint=False)
     def func2() -> None: ...
 
+Here is the decorator from the example using the legacy syntax
+(Python 3.11 and earlier):
+
+.. code-block:: python
+
+    from collections.abc import Callable
+    from typing import Any, Optional, TypeVar, overload
+
+    F = TypeVar('F', bound=Callable[..., Any])
+
+    # Bare decorator usage
+    @overload
+    def atomic(func: F, /) -> F: ...
+    # Decorator with arguments
+    @overload
+    def atomic(*, savepoint: bool = True) -> Callable[[F], F]: ...
+
+    # Implementation
+    def atomic(func: Optional[Callable[..., Any]] = None, /, *, savepoint: bool = True):
+        ...  # Same as above
+
 Generic protocols
 *****************
 
 Mypy supports generic protocols (see also :ref:`protocol-types`). Several
 :ref:`predefined protocols <predefined_protocols>` are generic, such as
-:py:class:`Iterable[T] <typing.Iterable>`, and you can define additional generic protocols. Generic
-protocols mostly follow the normal rules for generic classes. Example:
+:py:class:`Iterable[T] <collections.abc.Iterable>`, and you can define additional
+generic protocols. Generic protocols mostly follow the normal rules for
+generic classes. Example (Python 3.12 syntax):
 
 .. code-block:: python
 
-   from typing import TypeVar
-   from typing_extensions import Protocol
+   from typing import Protocol
 
-   T = TypeVar('T')
-
-   class Box(Protocol[T]):
+   class Box[T](Protocol):
        content: T
 
    def do_stuff(one: Box[str], other: Box[bytes]) -> None:
@@ -795,15 +1115,29 @@ protocols mostly follow the normal rules for generic classes. Example:
    y: Box[int] = ...
    x = y  # Error -- Box is invariant
 
+Here is the definition of ``Box`` from the above example using the legacy
+syntax (Python 3.11 and earlier):
+
+.. code-block:: python
+
+   from typing import Protocol, TypeVar
+
+   T = TypeVar('T')
+
+   class Box(Protocol[T]):
+       content: T
+
 Note that ``class ClassName(Protocol[T])`` is allowed as a shorthand for
-``class ClassName(Protocol, Generic[T])``, as per :pep:`PEP 544: Generic protocols <544#generic-protocols>`,
+``class ClassName(Protocol, Generic[T])`` when using the legacy syntax,
+as per :pep:`PEP 544: Generic protocols <544#generic-protocols>`.
+This form is only valid when using the legacy syntax.
 
-The main difference between generic protocols and ordinary generic
-classes is that mypy checks that the declared variances of generic
-type variables in a protocol match how they are used in the protocol
-definition.  The protocol in this example is rejected, since the type
-variable ``T`` is used covariantly as a return type, but the type
-variable is invariant:
+When using the legacy syntax, there is an important difference between
+generic protocols and ordinary generic classes: mypy checks that the
+declared variances of generic type variables in a protocol match how
+they are used in the protocol definition.  The protocol in this example
+is rejected, since the type variable ``T`` is used covariantly as
+a return type, but the type variable is invariant:
 
 .. code-block:: python
 
@@ -831,13 +1165,11 @@ This example correctly uses a covariant type variable:
 
 See :ref:`variance-of-generics` for more about variance.
 
-Generic protocols can also be recursive. Example:
+Generic protocols can also be recursive. Example (Python 3.12 synta):
 
 .. code-block:: python
 
-   T = TypeVar('T')
-
-   class Linked(Protocol[T]):
+   class Linked[T](Protocol):
        val: T
        def next(self) -> 'Linked[T]': ...
 
@@ -850,17 +1182,63 @@ Generic protocols can also be recursive. Example:
    result = last(L())
    reveal_type(result)  # Revealed type is "builtins.int"
 
+Here is the definition of ``Linked`` using the legacy syntax
+(Python 3.11 and earlier):
+
+.. code-block:: python
+
+   from typing import TypeVar
+
+   T = TypeVar('T')
+
+   class Linked(Protocol[T]):
+       val: T
+       def next(self) -> 'Linked[T]': ...
+
 .. _generic-type-aliases:
 
 Generic type aliases
 ********************
 
-Type aliases can be generic. In this case they can be used in two ways:
-Subscripted aliases are equivalent to original types with substituted type
-variables, so the number of type arguments must match the number of free type variables
-in the generic type alias. Unsubscripted aliases are treated as original types with free
-variables replaced with ``Any``. Examples (following :pep:`PEP 484: Type aliases
-<484#type-aliases>`):
+Type aliases can be generic. In this case they can be used in two ways.
+First, subscripted aliases are equivalent to original types with substituted type
+variables. Second, unsubscripted aliases are treated as original types with type
+parameters replaced with ``Any``.
+
+The ``type`` statement introduced in Python 3.12 is used to define generic
+type aliases (it also supports non-generic type aliases):
+
+.. code-block:: python
+
+    from collections.abc import Callable, Iterable
+
+    type TInt[S] = tuple[int, S]
+    type UInt[S] = S | int
+    type CBack[S] = Callable[..., S]
+
+    def response(query: str) -> UInt[str]:  # Same as str | int
+        ...
+    def activate[S](cb: CBack[S]) -> S:        # Same as Callable[..., S]
+        ...
+    table_entry: TInt  # Same as tuple[int, Any]
+
+    type Vec[T: (int, float, complex)] = Iterable[tuple[T, T]]
+
+    def inproduct[T: (int, float, complex)](v: Vec[T]) -> T:
+        return sum(x*y for x, y in v)
+
+    def dilate[T: (int, float, complex)](v: Vec[T], scale: T) -> Vec[T]:
+        return ((x * scale, y * scale) for x, y in v)
+
+    v1: Vec[int] = []      # Same as Iterable[tuple[int, int]]
+    v2: Vec = []           # Same as Iterable[tuple[Any, Any]]
+    v3: Vec[int, int] = [] # Error: Invalid alias, too many type arguments!
+
+There is also a legacy syntax that relies on ``TypeVar``.
+Here the number of type arguments must match the number of free type variables
+in the generic type alias definition. A type variables is free if it's not
+a type parameter of a surrounding class or function. Example (following
+:pep:`PEP 484: Type aliases <484#type-aliases>`, Python 3.11 and earlier):
 
 .. code-block:: python
 
@@ -868,7 +1246,7 @@ variables replaced with ``Any``. Examples (following :pep:`PEP 484: Type aliases
 
     S = TypeVar('S')
 
-    TInt = tuple[int, S]
+    TInt = tuple[int, S]  # 1 type parameter, since only S is free
     UInt = Union[S, int]
     CBack = Callable[..., S]
 
@@ -895,7 +1273,36 @@ variables replaced with ``Any``. Examples (following :pep:`PEP 484: Type aliases
 Type aliases can be imported from modules just like other names. An
 alias can also target another alias, although building complex chains
 of aliases is not recommended -- this impedes code readability, thus
-defeating the purpose of using aliases.  Example:
+defeating the purpose of using aliases.  Example (Python 3.12 syntax):
+
+.. code-block:: python
+
+    from example1 import AliasType
+    from example2 import Vec
+
+    # AliasType and Vec are type aliases (Vec as defined above)
+
+    def fun() -> AliasType:
+        ...
+
+    type OIntVec = Vec[int] | None
+
+Type aliases defined using the ``type`` statement are not valid as
+base classes, and they can't be used to construct instances:
+
+.. code-block:: python
+
+    from example1 import AliasType
+    from example2 import Vec
+
+    # AliasType and Vec are type aliases (Vec as defined above)
+
+    class NewVec[T](Vec[T]):  # Error: not valid as base class
+        ...
+
+    x = AliasType()  # Error: can't be used to create instances
+
+Here are examples using the legacy syntax (Python 3.11 and earlier):
 
 .. code-block:: python
 
@@ -908,18 +1315,49 @@ defeating the purpose of using aliases.  Example:
     def fun() -> AliasType:
         ...
 
+    OIntVec = Optional[Vec[int]]
+
     T = TypeVar('T')
 
+    # Old-style type aliases can be used as base classes and you can
+    # construct instances using them
+
     class NewVec(Vec[T]):
         ...
 
+    x = AliasType()
+
     for i, j in NewVec[int]():
         ...
 
-    OIntVec = Optional[Vec[int]]
+Using type variable bounds or value restriction in generic aliases has
+the same effect as in generic classes and functions.
+
+
+Differences between the new and old syntax
+******************************************
 
-Using type variable bounds or values in generic aliases has the same effect
-as in generic classes/functions.
+There are a few notable differences between the new (Python 3.12 and later)
+and the old syntax for generic classes, functions and type aliases, beyond
+the obvious syntactic differences:
+
+ * Type variables defined using the old syntax create definitions at runtime
+   in the surrounding namespace, whereas the type variables defined using the
+   new syntax are only defined within the class, function or type variable
+   that uses them.
+ * Type variable definitions can be shared when using the old syntax, but
+   the new syntax doesn't support this.
+ * When using the new syntax, the variance of class type variables is always
+   inferred.
+ * Type aliases defined using the new syntax can contain forward references
+   and recursive references without using string literal escaping. The
+   same is true for the bounds and constraints of type variables.
+ * The new syntax lets you define a generic alias where the definition doesn't
+   contain a reference to a type parameter. This is occasionally useful, at
+   least when conditionally defining type aliases.
+ * Type aliases defined using the new syntax can't be used as base classes
+   and can't be used to construct instances, unlike aliases defined using the
+   old syntax.
 
 
 Generic class internals
@@ -927,7 +1365,20 @@ Generic class internals
 
 You may wonder what happens at runtime when you index a generic class.
 Indexing returns a *generic alias* to the original class that returns instances
-of the original class on instantiation:
+of the original class on instantiation (Python 3.12 syntax):
+
+.. code-block:: python
+
+   >>> class Stack[T]: ...
+   >>> Stack
+   __main__.Stack
+   >>> Stack[int]
+   __main__.Stack[int]
+   >>> instance = Stack[int]()
+   >>> instance.__class__
+   __main__.Stack
+
+Here is the same example using the legacy syntax (Python 3.11 and earlier):
 
 .. code-block:: python
 
@@ -946,10 +1397,17 @@ Generic aliases can be instantiated or subclassed, similar to real
 classes, but the above examples illustrate that type variables are
 erased at runtime. Generic ``Stack`` instances are just ordinary
 Python objects, and they have no extra runtime overhead or magic due
-to being generic, other than a metaclass that overloads the indexing
-operator.
+to being generic, other than the ``Generic`` base class that overloads
+the indexing operator using ``__class_getitem__``. ``typing.Generic``
+is included as an implicit base class even when using the new syntax:
+
+.. code-block:: python
+
+   >>> class Stack[T]: ...
+   >>> Stack.mro()
+   [<class '__main__.Stack'>, <class 'typing.Generic'>, <class 'object'>]
 
-Note that in Python 3.8 and lower, the built-in types
+Note that in Python 3.8 and earlier, the built-in types
 :py:class:`list`, :py:class:`dict` and others do not support indexing.
 This is why we have the aliases :py:class:`~typing.List`,
 :py:class:`~typing.Dict` and so on in the :py:mod:`typing`
@@ -960,16 +1418,18 @@ class in more recent versions of Python:
 .. code-block:: python
 
    >>> # Only relevant for Python 3.8 and below
-   >>> # For Python 3.9 onwards, prefer `list[int]` syntax
+   >>> # If using Python 3.9 or newer, prefer the 'list[int]' syntax
    >>> from typing import List
    >>> List[int]
    typing.List[int]
 
 Note that the generic aliases in ``typing`` don't support constructing
-instances:
+instances, unlike the corresponding built-in classes:
 
 .. code-block:: python
 
+   >>> list[int]()
+   []
    >>> from typing import List
    >>> List[int]()
    Traceback (most recent call last):
diff --git a/docs/source/getting_started.rst b/docs/source/getting_started.rst
index 9b927097cfd2..9b510314fd8f 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.9 or later to run.  You can install mypy using pip:
 
 .. code-block:: shell
 
@@ -66,7 +66,7 @@ This is the case even if you misuse the function!
    def greeting(name):
        return 'Hello ' + name
 
-   # These calls will fail when the program run, but mypy does not report an error
+   # These calls will fail when the program runs, but mypy does not report an error
    # because "greeting" does not have type annotations.
    greeting(123)
    greeting(b"Alice")
@@ -186,19 +186,23 @@ For example, a ``RuntimeError`` instance can be passed to a function that is ann
 as taking an ``Exception``.
 
 As another example, suppose you want to write a function that can accept *either*
-ints or strings, but no other types. You can express this using the
-:py:data:`~typing.Union` type. For example, ``int`` is a subtype of ``Union[int, str]``:
+ints or strings, but no other types. You can express this using a
+union type. For example, ``int`` is a subtype of ``int | str``:
 
 .. code-block:: python
 
-   from typing import Union
-
-   def normalize_id(user_id: Union[int, str]) -> str:
+   def normalize_id(user_id: int | str) -> str:
        if isinstance(user_id, int):
            return f'user-{100_000 + user_id}'
        else:
            return user_id
 
+.. note::
+
+    If using Python 3.9 or earlier, use ``typing.Union[int, str]`` instead of
+    ``int | str``, or use ``from __future__ import annotations`` at the top of
+    the file (see :ref:`runtime_troubles`).
+
 The :py:mod:`typing` module contains many other useful types.
 
 For a quick overview, look through the :ref:`mypy cheatsheet <cheat-sheet-py3>`.
@@ -210,12 +214,12 @@ generic types or your own type aliases), look through the
 .. note::
 
    When adding types, the convention is to import types
-   using the form ``from typing import Union`` (as opposed to doing
+   using the form ``from typing import <name>`` (as opposed to doing
    just ``import typing`` or ``import typing as t`` or ``from typing import *``).
 
    For brevity, we often omit imports from :py:mod:`typing` or :py:mod:`collections.abc`
    in code examples, but mypy will give an error if you use types such as
-   :py:class:`~typing.Iterable` without first importing them.
+   :py:class:`~collections.abc.Iterable` without first importing them.
 
 .. note::
 
@@ -256,15 +260,14 @@ Mypy can also understand how to work with types from libraries that you use.
 
 For instance, mypy comes out of the box with an intimate knowledge of the
 Python standard library. For example, here is a function which uses the
-``Path`` object from the
-`pathlib standard library module <https://docs.python.org/3/library/pathlib.html>`_:
+``Path`` object from the :doc:`pathlib standard library module <python:library/pathlib>`:
 
 .. code-block:: python
 
     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)
diff --git a/docs/source/html_builder.py b/docs/source/html_builder.py
new file mode 100644
index 000000000000..ea3594e0617b
--- /dev/null
+++ b/docs/source/html_builder.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+import os
+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
+from sphinx.environment import BuildEnvironment
+
+
+class MypyHTMLBuilder(StandaloneHTMLBuilder):
+    def __init__(self, app: Sphinx, env: BuildEnvironment) -> None:
+        super().__init__(app, env)
+        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 _verify_error_codes(self) -> None:
+        from mypy.errorcodes import error_codes
+
+        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))}"
+            )
+
+    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>
+        <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}
diff --git a/docs/source/index.rst b/docs/source/index.rst
index c9dc6bc1f8c9..de3286d58ace 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -103,6 +103,7 @@ Contents
    error_code_list2
    additional_features
    faq
+   changelog
 
 .. toctree::
    :hidden:
diff --git a/docs/source/installed_packages.rst b/docs/source/installed_packages.rst
index b9a3b891c99c..fa4fae1a0b3e 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",
diff --git a/docs/source/kinds_of_types.rst b/docs/source/kinds_of_types.rst
index c3180850f119..54693cddf953 100644
--- a/docs/source/kinds_of_types.rst
+++ b/docs/source/kinds_of_types.rst
@@ -136,7 +136,7 @@ purpose. Example:
 .. note::
 
    Usually it's a better idea to use ``Sequence[T]`` instead of ``tuple[T, ...]``, as
-   :py:class:`~typing.Sequence` is also compatible with lists and other non-tuple sequences.
+   :py:class:`~collections.abc.Sequence` is also compatible with lists and other non-tuple sequences.
 
 .. note::
 
@@ -155,7 +155,7 @@ and returns ``Rt`` is ``Callable[[A1, ..., An], Rt]``. Example:
 
 .. code-block:: python
 
-   from typing import Callable
+   from collections.abc import Callable
 
    def twice(i: int, next: Callable[[int], int]) -> int:
        return next(next(i))
@@ -165,6 +165,11 @@ and returns ``Rt`` is ``Callable[[A1, ..., An], Rt]``. Example:
 
    print(twice(3, add))   # 5
 
+.. note::
+
+    Import :py:data:`Callable[...] <typing.Callable>` from ``typing`` instead
+    of ``collections.abc`` if you use Python 3.8 or earlier.
+
 You can only have positional arguments, and only ones without default
 values, in callable types. These cover the vast majority of uses of
 callable types, but sometimes this isn't quite enough. Mypy recognizes
@@ -178,7 +183,7 @@ Any)`` function signature. Example:
 
 .. code-block:: python
 
-   from typing import Callable
+   from collections.abc import Callable
 
    def arbitrary_call(f: Callable[..., int]) -> int:
        return f('x') + f(y=2)  # OK
@@ -205,7 +210,7 @@ Callables can also be used against type objects, matching their
 
 .. code-block:: python
 
-    from typing import Callable
+    from collections.abc import Callable
 
     class C:
         def __init__(self, app: str) -> None:
@@ -223,6 +228,7 @@ instance of ``C`` or the type of ``C`` itself. This also works with
 
 
 .. _union-types:
+.. _alternative_union_syntax:
 
 Union types
 ***********
@@ -231,8 +237,8 @@ Python functions often accept values of two or more different
 types. You can use :ref:`overloading <function-overloading>` to
 represent this, but union types are often more convenient.
 
-Use the ``Union[T1, ..., Tn]`` type constructor to construct a union
-type. For example, if an argument has type ``Union[int, str]``, both
+Use ``T1 | ... | Tn`` to construct a union
+type. For example, if an argument has type ``int | str``, both
 integers and strings are valid argument values.
 
 You can use an :py:func:`isinstance` check to narrow down a union type to a
@@ -240,9 +246,7 @@ more specific type:
 
 .. code-block:: python
 
-   from typing import Union
-
-   def f(x: Union[int, str]) -> None:
+   def f(x: int | str) -> None:
        x + 1     # Error: str + int is not valid
        if isinstance(x, int):
            # Here type of x is int.
@@ -264,20 +268,38 @@ more specific type:
     since the caller may have to use :py:func:`isinstance` before doing anything
     interesting with the value.
 
+Python 3.9 and older only partially support this syntax. Instead, you can
+use the legacy ``Union[T1, ..., Tn]`` type constructor. Example:
+
+.. code-block:: python
+
+   from typing import Union
+
+   def f(x: Union[int, str]) -> None:
+       ...
+
+It is also possible to use the new syntax with versions of Python where it
+isn't supported by the runtime with some limitations, if you use
+``from __future__ import annotations`` (see :ref:`runtime_troubles`):
+
+.. code-block:: python
+
+   from __future__ import annotations
+
+   def f(x: int | str) -> None:   # OK on Python 3.7 and later
+       ...
+
 .. _strict_optional:
 
 Optional types and the None type
 ********************************
 
-You can use the :py:data:`~typing.Optional` type modifier to define a type variant
-that allows ``None``, such as ``Optional[int]`` (``Optional[X]`` is
-the preferred shorthand for ``Union[X, None]``):
+You can use ``T | None`` to define a type variant that allows ``None`` values,
+such as ``int | None``. This is called an *optional type*:
 
 .. code-block:: python
 
-   from typing import Optional
-
-   def strlen(s: str) -> Optional[int]:
+   def strlen(s: str) -> int | None:
        if not s:
            return None  # OK
        return len(s)
@@ -287,12 +309,23 @@ the preferred shorthand for ``Union[X, None]``):
            return None  # Error: None not compatible with int
        return len(s)
 
-Most operations will not be allowed on unguarded ``None`` or :py:data:`~typing.Optional`
-values:
+To support Python 3.9 and earlier, you can use the :py:data:`~typing.Optional`
+type modifier instead, such as ``Optional[int]`` (``Optional[X]`` is
+the preferred shorthand for ``Union[X, None]``):
+
+.. code-block:: python
+
+   from typing import Optional
+
+   def strlen(s: str) -> Optional[int]:
+       ...
+
+Most operations will not be allowed on unguarded ``None`` or *optional* values
+(values with an optional type):
 
 .. code-block:: python
 
-   def my_inc(x: Optional[int]) -> int:
+   def my_inc(x: int | None) -> int:
        return x + 1  # Error: Cannot add None and int
 
 Instead, an explicit ``None`` check is required. Mypy has
@@ -302,7 +335,7 @@ recognizes ``is None`` checks:
 
 .. code-block:: python
 
-   def my_inc(x: Optional[int]) -> int:
+   def my_inc(x: int | None) -> int:
        if x is None:
            return 0
        else:
@@ -318,7 +351,7 @@ Other supported checks for guarding against a ``None`` value include
 
 .. code-block:: python
 
-   def concat(x: Optional[str], y: Optional[str]) -> Optional[str]:
+   def concat(x: str | None, y: str | None) -> str | None:
        if x is not None and y is not None:
            # Both x and y are not None here
            return x + y
@@ -335,7 +368,7 @@ will complain about the possible ``None`` value. You can use
 .. code-block:: python
 
    class Resource:
-       path: Optional[str] = None
+       path: str | None = None
 
        def initialize(self, path: str) -> None:
            self.path = path
@@ -358,7 +391,7 @@ This is why you need to annotate an attribute in cases like the class
 .. code-block:: python
 
     class Resource:
-        path: Optional[str] = None
+        path: str | None = None
         ...
 
 This also works for attributes defined within methods:
@@ -367,10 +400,11 @@ This also works for attributes defined within methods:
 
     class Counter:
         def __init__(self) -> None:
-            self.count: Optional[int] = None
+            self.count: int | None = None
 
-This is not a problem when using variable annotations, since no initial
-value is needed:
+Often it's easier to not use any initial value for an attribute.
+This way you don't need to use an optional type and can avoid ``assert ... is not None``
+checks. No initial value is needed if you annotate an attribute in the class body:
 
 .. code-block:: python
 
@@ -385,13 +419,13 @@ the right thing without an annotation:
 .. code-block:: python
 
    def f(i: int) -> None:
-       n = None  # Inferred type Optional[int] because of the assignment below
+       n = None  # Inferred type 'int | None' because of the assignment below
        if i > 0:
             n = i
        ...
 
 Sometimes you may get the error "Cannot determine type of <something>". In this
-case you should add an explicit ``Optional[...]`` annotation (or type comment).
+case you should add an explicit ``... | None`` annotation.
 
 .. note::
 
@@ -409,112 +443,31 @@ case you should add an explicit ``Optional[...]`` annotation (or type comment).
 
 .. note::
 
-    ``Optional[...]`` *does not* mean a function argument with a default value.
-    It simply means that ``None`` is a valid value for the argument. This is
-    a common confusion because ``None`` is a common default value for arguments.
-
-.. _alternative_union_syntax:
-
-X | Y syntax for Unions
------------------------
-
-:pep:`604` introduced an alternative way for spelling union types. In Python
-3.10 and later, you can write ``Union[int, str]`` as ``int | str``. It is
-possible to use this syntax in versions of Python where it isn't supported by
-the runtime with some limitations (see :ref:`runtime_troubles`).
-
-.. code-block:: python
-
-    t1: int | str  # equivalent to Union[int, str]
-
-    t2: int | None  # equivalent to Optional[int]
-
-.. _no_strict_optional:
-
-Disabling strict optional checking
-**********************************
-
-Mypy also has an option to treat ``None`` as a valid value for every
-type (in case you know Java, it's useful to think of it as similar to
-the Java ``null``). In this mode ``None`` is also valid for primitive
-types such as ``int`` and ``float``, and :py:data:`~typing.Optional` types are
-not required.
-
-The mode is enabled through the :option:`--no-strict-optional <mypy --no-strict-optional>` command-line
-option. In mypy versions before 0.600 this was the default mode. You
-can enable this option explicitly for backward compatibility with
-earlier mypy versions, in case you don't want to introduce optional
-types to your codebase yet.
-
-It will cause mypy to silently accept some buggy code, such as
-this example -- it's not recommended if you can avoid it:
-
-.. code-block:: python
-
-   def inc(x: int) -> int:
-       return x + 1
-
-   x = inc(None)  # No error reported by mypy if strict optional mode disabled!
-
-However, making code "optional clean" can take some work! You can also use
-:ref:`the mypy configuration file <config-file>` to migrate your code
-to strict optional checking one file at a time, since there exists
-the per-module flag
-:confval:`strict_optional` to control strict optional mode.
-
-Often it's still useful to document whether a variable can be
-``None``. For example, this function accepts a ``None`` argument,
-but it's not obvious from its signature:
-
-.. code-block:: python
-
-    def greeting(name: str) -> str:
-        if name:
-            return f'Hello, {name}'
-        else:
-            return 'Hello, stranger'
-
-    print(greeting('Python'))  # Okay!
-    print(greeting(None))      # Also okay!
-
-You can still use :py:data:`Optional[t] <typing.Optional>` to document that ``None`` is a
-valid argument type, even if strict ``None`` checking is not
-enabled:
-
-.. code-block:: python
-
-    from typing import Optional
-
-    def greeting(name: Optional[str]) -> str:
-        if name:
-            return f'Hello, {name}'
-        else:
-            return 'Hello, stranger'
-
-Mypy treats this as semantically equivalent to the previous example
-if strict optional checking is disabled, since ``None`` is implicitly
-valid for any type, but it's much more
-useful for a programmer who is reading the code. This also makes
-it easier to migrate to strict ``None`` checking in the future.
+    The type ``Optional[T]`` *does not* mean a function parameter with a default value.
+    It simply means that ``None`` is a valid argument value. This is
+    a common confusion because ``None`` is a common default value for parameters,
+    and parameters with default values are sometimes called *optional* parameters
+    (or arguments).
 
 .. _type-aliases:
 
 Type aliases
 ************
 
-In certain situations, type names may end up being long and painful to type:
+In certain situations, type names may end up being long and painful to type,
+especially if they are used frequently:
 
 .. code-block:: python
 
-   def f() -> Union[list[dict[tuple[int, str], set[int]]], tuple[str, list[str]]]:
+   def f() -> list[dict[tuple[int, str], set[int]]] | tuple[str, list[str]]:
        ...
 
 When cases like this arise, you can define a type alias by simply
-assigning the type to a variable:
+assigning the type to a variable (this is an *implicit type alias*):
 
 .. code-block:: python
 
-   AliasType = Union[list[dict[tuple[int, str], set[int]]], tuple[str, list[str]]]
+   AliasType = list[dict[tuple[int, str], set[int]]] | tuple[str, list[str]]
 
    # Now we can use AliasType in place of the full name:
 
@@ -527,8 +480,18 @@ assigning the type to a variable:
     another type -- it's equivalent to the target type except for
     :ref:`generic aliases <generic-type-aliases>`.
 
-Since Mypy 0.930 you can also use *explicit type aliases*, which were
-introduced in :pep:`613`.
+Python 3.12 introduced the ``type`` statement for defining *explicit type aliases*.
+Explicit type aliases are unambiguous and can also improve readability by
+making the intent clear:
+
+.. code-block:: python
+
+   type AliasType = list[dict[tuple[int, str], set[int]]] | tuple[str, list[str]]
+
+   # Now we can use AliasType in place of the full name:
+
+   def f() -> AliasType:
+       ...
 
 There can be confusion about exactly when an assignment defines an implicit type alias --
 for example, when the alias contains forward references, invalid types, or violates some other
@@ -537,14 +500,23 @@ distinction between an unannotated variable and a type alias is implicit,
 ambiguous or incorrect type alias declarations default to defining
 a normal variable instead of a type alias.
 
-Explicit type aliases are unambiguous and can also improve readability by
-making the intent clear:
+Aliases defined using the ``type`` statement have these properties, which
+distinguish them from implicit type aliases:
+
+* The definition may contain forward references without having to use string
+  literal escaping, since it is evaluated lazily.
+* The alias can be used in type annotations, type arguments, and casts, but
+  it can't be used in contexts which require a class object. For example, it's
+  not valid as a base class and it can't be used to construct instances.
+
+There is also use an older syntax for defining explicit type aliases, which was
+introduced in Python 3.10 (:pep:`613`):
 
 .. code-block:: python
 
    from typing import TypeAlias  # "from typing_extensions" in Python 3.9 and earlier
 
-   AliasType: TypeAlias = Union[list[dict[tuple[int, str], set[int]]], tuple[str, list[str]]]
+   AliasType: TypeAlias = list[dict[tuple[int, str], set[int]]] | tuple[str, list[str]]
 
 .. _named-tuples:
 
@@ -672,14 +644,21 @@ doesn't see that the ``buyer`` variable has type ``ProUser``:
    buyer.pay()  # Rejected, not a method on User
 
 However, using the ``type[C]`` syntax and a type variable with an upper bound (see
-:ref:`type-variable-upper-bound`) we can do better:
+:ref:`type-variable-upper-bound`) we can do better (Python 3.12 syntax):
+
+.. code-block:: python
+
+   def new_user[U: User](user_class: type[U]) -> U:
+       # Same implementation as before
+
+Here is the example using the legacy syntax (Python 3.11 and earlier):
 
 .. code-block:: python
 
    U = TypeVar('U', bound=User)
 
    def new_user(user_class: type[U]) -> U:
-       # Same  implementation as before
+       # Same implementation as before
 
 Now mypy will infer the correct type of the result when we call
 ``new_user()`` with a specific subclass of ``User``:
diff --git a/docs/source/literal_types.rst b/docs/source/literal_types.rst
index a66d300bd0fd..877ab5de9087 100644
--- a/docs/source/literal_types.rst
+++ b/docs/source/literal_types.rst
@@ -70,7 +70,7 @@ complex types involving literals a little more convenient.
 
 Literal types may also contain ``None``. Mypy will treat ``Literal[None]`` as being
 equivalent to just ``None``. This means that ``Literal[4, None]``,
-``Union[Literal[4], None]``, and ``Optional[Literal[4]]`` are all equivalent.
+``Literal[4] | None``, and ``Optional[Literal[4]]`` are all equivalent.
 
 Literals may also contain aliases to other literal types. For example, the
 following program is legal:
@@ -264,19 +264,15 @@ use the same technique with regular objects, tuples, or namedtuples.
 Similarly, tags do not need to be specifically str Literals: they can be any type
 you can normally narrow within ``if`` statements and the like. For example, you
 could have your tags be int or Enum Literals or even regular classes you narrow
-using ``isinstance()``:
+using ``isinstance()`` (Python 3.12 syntax):
 
 .. code-block:: python
 
-    from typing import Generic, TypeVar, Union
-
-    T = TypeVar('T')
-
-    class Wrapper(Generic[T]):
+    class Wrapper[T]:
         def __init__(self, inner: T) -> None:
             self.inner = inner
 
-    def process(w: Union[Wrapper[int], Wrapper[str]]) -> None:
+    def process(w: Wrapper[int] | Wrapper[str]) -> None:
         # Doing `if isinstance(w, Wrapper[int])` does not work: isinstance requires
         # that the second argument always be an *erased* type, with no generics.
         # This is because generics are a typing-only concept and do not exist at
@@ -329,13 +325,10 @@ perform an exhaustiveness check, you need to update your code to use an
 .. code-block:: python
 
   from typing import Literal, NoReturn
+  from typing_extensions import assert_never
 
   PossibleValues = Literal['one', 'two']
 
-  def assert_never(value: NoReturn) -> NoReturn:
-      # This also works at runtime as well
-      assert False, f'This code should never be reached, got: {value}'
-
   def validate(x: PossibleValues) -> bool:
       if x == 'one':
           return True
@@ -443,10 +436,7 @@ Let's start with a definition:
 
   from enum import Enum
   from typing import NoReturn
-
-  def assert_never(value: NoReturn) -> NoReturn:
-      # This also works in runtime as well:
-      assert False, f'This code should never be reached, got: {value}'
+  from typing_extensions import assert_never
 
   class Direction(Enum):
       up = 'up'
diff --git a/docs/source/metaclasses.rst b/docs/source/metaclasses.rst
index 396d7dbb42cc..dd77a2f90ed8 100644
--- a/docs/source/metaclasses.rst
+++ b/docs/source/metaclasses.rst
@@ -34,13 +34,14 @@ Mypy supports the lookup of attributes in the metaclass:
 
 .. code-block:: python
 
-    from typing import Type, TypeVar, ClassVar
-    T = TypeVar('T')
+    from typing import ClassVar, TypeVar
+
+    S = TypeVar("S")
 
     class M(type):
         count: ClassVar[int] = 0
 
-        def make(cls: Type[T]) -> T:
+        def make(cls: type[S]) -> S:
             M.count += 1
             return cls()
 
@@ -86,3 +87,6 @@ so it's better not to combine metaclasses and class hierarchies:
   such as ``class A(metaclass=f()): ...``
 * Mypy does not and cannot understand arbitrary metaclass code.
 * Mypy only recognizes subclasses of :py:class:`type` as potential metaclasses.
+* ``Self`` is not allowed as annotation in metaclasses as per `PEP 673`_.
+
+.. _PEP 673: https://peps.python.org/pep-0673/#valid-locations-for-self
diff --git a/docs/source/more_types.rst b/docs/source/more_types.rst
index 542ff1c57c71..0383c3448d06 100644
--- a/docs/source/more_types.rst
+++ b/docs/source/more_types.rst
@@ -2,7 +2,7 @@ More types
 ==========
 
 This section introduces a few additional kinds of types, including :py:data:`~typing.NoReturn`,
-:py:func:`NewType <typing.NewType>`, and types for async code. It also discusses
+:py:class:`~typing.NewType`, and types for async code. It also discusses
 how to give functions more precise types using overloads. All of these are only
 situationally useful, so feel free to skip this section and come back when you
 have a need for some of them.
@@ -11,7 +11,7 @@ Here's a quick summary of what's covered here:
 
 * :py:data:`~typing.NoReturn` lets you tell mypy that a function never returns normally.
 
-* :py:func:`NewType <typing.NewType>` lets you define a variant of a type that is treated as a
+* :py:class:`~typing.NewType` lets you define a variant of a type that is treated as a
   separate type by mypy but is identical to the original type at runtime.
   For example, you can have ``UserId`` as a variant of ``int`` that is
   just an ``int`` at runtime.
@@ -75,7 +75,7 @@ certain values from base class instances. Example:
         ...
 
 However, this approach introduces some runtime overhead. To avoid this, the typing
-module provides a helper object :py:func:`NewType <typing.NewType>` that creates simple unique types with
+module provides a helper object :py:class:`~typing.NewType` that creates simple unique types with
 almost zero runtime overhead. Mypy will treat the statement
 ``Derived = NewType('Derived', Base)`` as being roughly equivalent to the following
 definition:
@@ -113,12 +113,12 @@ implicitly casting from ``UserId`` where ``int`` is expected. Examples:
 
     num: int = UserId(5) + 1
 
-:py:func:`NewType <typing.NewType>` accepts exactly two arguments. The first argument must be a string literal
+:py:class:`~typing.NewType` accepts exactly two arguments. The first argument must be a string literal
 containing the name of the new type and must equal the name of the variable to which the new
 type is assigned. The second argument must be a properly subclassable class, i.e.,
-not a type construct like :py:data:`~typing.Union`, etc.
+not a type construct like a :ref:`union type <union-types>`, etc.
 
-The callable returned by :py:func:`NewType <typing.NewType>` accepts only one argument; this is equivalent to
+The callable returned by :py:class:`~typing.NewType` accepts only one argument; this is equivalent to
 supporting only one constructor accepting an instance of the base class (see above).
 Example:
 
@@ -139,12 +139,12 @@ Example:
     tcp_packet = TcpPacketId(127, 0)  # Fails in type checker and at runtime
 
 You cannot use :py:func:`isinstance` or :py:func:`issubclass` on the object returned by
-:py:func:`~typing.NewType`, nor can you subclass an object returned by :py:func:`~typing.NewType`.
+:py:class:`~typing.NewType`, nor can you subclass an object returned by :py:class:`~typing.NewType`.
 
 .. note::
 
-    Unlike type aliases, :py:func:`NewType <typing.NewType>` will create an entirely new and
-    unique type when used. The intended purpose of :py:func:`NewType <typing.NewType>` is to help you
+    Unlike type aliases, :py:class:`~typing.NewType` will create an entirely new and
+    unique type when used. The intended purpose of :py:class:`~typing.NewType` is to help you
     detect cases where you accidentally mixed together the old base type and the
     new derived type.
 
@@ -160,7 +160,7 @@ You cannot use :py:func:`isinstance` or :py:func:`issubclass` on the object retu
 
         name_by_id(3)  # ints and UserId are synonymous
 
-    But a similar example using :py:func:`NewType <typing.NewType>` will not typecheck:
+    But a similar example using :py:class:`~typing.NewType` will not typecheck:
 
     .. code-block:: python
 
@@ -179,7 +179,7 @@ Function overloading
 ********************
 
 Sometimes the arguments and types in a function depend on each other
-in ways that can't be captured with a :py:data:`~typing.Union`. For example, suppose
+in ways that can't be captured with a :ref:`union types <union-types>`. For example, suppose
 we want to write a function that can accept x-y coordinates. If we pass
 in just a single x-y coordinate, we return a ``ClickEvent`` object. However,
 if we pass in two x-y coordinates, we return a ``DragEvent`` object.
@@ -188,12 +188,10 @@ Our first attempt at writing this function might look like this:
 
 .. code-block:: python
 
-    from typing import Union, Optional
-
     def mouse_event(x1: int,
                     y1: int,
-                    x2: Optional[int] = None,
-                    y2: Optional[int] = None) -> Union[ClickEvent, DragEvent]:
+                    x2: int | None = None,
+                    y2: int | None = None) -> ClickEvent | DragEvent:
         if x2 is None and y2 is None:
             return ClickEvent(x1, y1)
         elif x2 is not None and y2 is not None:
@@ -213,7 +211,7 @@ to more accurately describe the function's behavior:
 
 .. code-block:: python
 
-    from typing import Union, overload
+    from typing import overload
 
     # Overload *variants* for 'mouse_event'.
     # These variants give extra information to the type checker.
@@ -236,8 +234,8 @@ to more accurately describe the function's behavior:
 
     def mouse_event(x1: int,
                     y1: int,
-                    x2: Optional[int] = None,
-                    y2: Optional[int] = None) -> Union[ClickEvent, DragEvent]:
+                    x2: int | None = None,
+                    y2: int | None = None) -> ClickEvent | DragEvent:
         if x2 is None and y2 is None:
             return ClickEvent(x1, y1)
         elif x2 is not None and y2 is not None:
@@ -253,14 +251,37 @@ calls like ``mouse_event(5, 25, 2)``.
 As another example, suppose we want to write a custom container class that
 implements the :py:meth:`__getitem__ <object.__getitem__>` method (``[]`` bracket indexing). If this
 method receives an integer we return a single item. If it receives a
-``slice``, we return a :py:class:`~typing.Sequence` of items.
+``slice``, we return a :py:class:`~collections.abc.Sequence` of items.
 
 We can precisely encode this relationship between the argument and the
-return type by using overloads like so:
+return type by using overloads like so (Python 3.12 syntax):
 
 .. code-block:: python
 
-    from typing import Sequence, TypeVar, Union, overload
+    from collections.abc import Sequence
+    from typing import overload
+
+    class MyList[T](Sequence[T]):
+        @overload
+        def __getitem__(self, index: int) -> T: ...
+
+        @overload
+        def __getitem__(self, index: slice) -> Sequence[T]: ...
+
+        def __getitem__(self, index: int | slice) -> T | Sequence[T]:
+            if isinstance(index, int):
+                # Return a T here
+            elif isinstance(index, slice):
+                # Return a sequence of Ts here
+            else:
+                raise TypeError(...)
+
+Here is the same example using the legacy syntax (Python 3.11 and earlier):
+
+.. code-block:: python
+
+    from collections.abc import Sequence
+    from typing import TypeVar, overload
 
     T = TypeVar('T')
 
@@ -271,7 +292,7 @@ return type by using overloads like so:
         @overload
         def __getitem__(self, index: slice) -> Sequence[T]: ...
 
-        def __getitem__(self, index: Union[int, slice]) -> Union[T, Sequence[T]]:
+        def __getitem__(self, index: int | slice) -> T | Sequence[T]:
             if isinstance(index, int):
                 # Return a T here
             elif isinstance(index, slice):
@@ -369,7 +390,7 @@ program:
 The ``summarize([])`` call matches both variants: an empty list could
 be either a ``list[int]`` or a ``list[str]``. In this case, mypy
 will break the tie by picking the first matching variant: ``output``
-will have an inferred type of ``float``. The implementor is responsible
+will have an inferred type of ``float``. The implementer is responsible
 for making sure ``summarize`` breaks ties in the same way at runtime.
 
 However, there are two exceptions to the "pick the first match" rule.
@@ -389,9 +410,9 @@ matching variant returns:
 
 .. code-block:: python
 
-    some_list: Union[list[int], list[str]]
+    some_list: list[int] | list[str]
 
-    # output3 is of type 'Union[float, str]'
+    # output3 is of type 'float | str'
     output3 = summarize(some_list)
 
 .. note::
@@ -418,7 +439,7 @@ types:
 
 .. code-block:: python
 
-    from typing import overload, Union
+    from typing import overload
 
     class Expression:
         # ...snip...
@@ -469,7 +490,7 @@ the following unsafe overload definition:
 
 .. code-block:: python
 
-    from typing import overload, Union
+    from typing import overload
 
     @overload
     def unsafe_func(x: int) -> int: ...
@@ -477,7 +498,7 @@ the following unsafe overload definition:
     @overload
     def unsafe_func(x: object) -> str: ...
 
-    def unsafe_func(x: object) -> Union[int, str]:
+    def unsafe_func(x: object) -> int | str:
         if isinstance(x, int):
             return 42
         else:
@@ -501,7 +522,7 @@ To prevent these kinds of issues, mypy will detect and prohibit inherently unsaf
 overlapping overloads on a best-effort basis. Two variants are considered unsafely
 overlapping when both of the following are true:
 
-1. All of the arguments of the first variant are compatible with the second.
+1. All of the arguments of the first variant are potentially compatible with the second.
 2. The return type of the first variant is *not* compatible with (e.g. is not a
    subtype of) the second.
 
@@ -510,6 +531,9 @@ the ``object`` argument in the second, yet the ``int`` return type is not a subt
 ``str``. Both conditions are true, so mypy will correctly flag ``unsafe_func`` as
 being unsafe.
 
+Note that in cases where you ignore the overlapping overload error, mypy will usually
+still infer the types you expect at callsites.
+
 However, mypy will not detect *all* unsafe uses of overloads. For example,
 suppose we modify the above snippet so it calls ``summarize`` instead of
 ``unsafe_func``:
@@ -543,8 +567,8 @@ Type checking the implementation
 The body of an implementation is type-checked against the
 type hints provided on the implementation. For example, in the
 ``MyList`` example up above, the code in the body is checked with
-argument list ``index: Union[int, slice]`` and a return type of
-``Union[T, Sequence[T]]``. If there are no annotations on the
+argument list ``index: int | slice`` and a return type of
+``T | Sequence[T]``. If there are no annotations on the
 implementation, then the body is not type checked. If you want to
 force mypy to check the body anyways, use the :option:`--check-untyped-defs <mypy --check-untyped-defs>`
 flag (:ref:`more details here <untyped-definitions-and-calls>`).
@@ -552,10 +576,10 @@ flag (:ref:`more details here <untyped-definitions-and-calls>`).
 The variants must also also be compatible with the implementation
 type hints. In the ``MyList`` example, mypy will check that the
 parameter type ``int`` and the return type ``T`` are compatible with
-``Union[int, slice]`` and ``Union[T, Sequence]`` for the
+``int | slice`` and ``T | Sequence`` for the
 first variant. For the second variant it verifies the parameter
 type ``slice`` and the return type ``Sequence[T]`` are compatible
-with ``Union[int, slice]`` and ``Union[T, Sequence]``.
+with ``int | slice`` and ``T | Sequence``.
 
 .. note::
 
@@ -694,14 +718,13 @@ Restricted methods in generic classes
 -------------------------------------
 
 In generic classes some methods may be allowed to be called only
-for certain values of type arguments:
+for certain values of type arguments (Python 3.12 syntax):
 
 .. code-block:: python
 
-   T = TypeVar('T')
-
-   class Tag(Generic[T]):
+   class Tag[T]:
        item: T
+
        def uppercase_item(self: Tag[str]) -> str:
            return self.item.upper()
 
@@ -711,18 +734,18 @@ for certain values of type arguments:
        ts.uppercase_item()  # This is OK
 
 This pattern also allows matching on nested types in situations where the type
-argument is itself generic:
+argument is itself generic (Python 3.12 syntax):
 
 .. code-block:: python
 
-  T = TypeVar('T', covariant=True)
-  S = TypeVar('S')
+   from collections.abc import Sequence
 
-   class Storage(Generic[T]):
+   class Storage[T]:
        def __init__(self, content: T) -> None:
-           self.content = content
-       def first_chunk(self: Storage[Sequence[S]]) -> S:
-           return self.content[0]
+           self._content = content
+
+       def first_chunk[S](self: Storage[Sequence[S]]) -> S:
+           return self._content[0]
 
    page: Storage[list[str]]
    page.first_chunk()  # OK, type is "str"
@@ -731,13 +754,14 @@ argument is itself generic:
                              # "first_chunk" with type "Callable[[Storage[Sequence[S]]], S]"
 
 Finally, one can use overloads on self-type to express precise types of
-some tricky methods:
+some tricky methods (Python 3.12 syntax):
 
 .. code-block:: python
 
-   T = TypeVar('T')
+   from collections.abc import Callable
+   from typing import overload
 
-   class Tag(Generic[T]):
+   class Tag[T]:
        @overload
        def export(self: Tag[str]) -> str: ...
        @overload
@@ -796,23 +820,22 @@ Precise typing of alternative constructors
 ------------------------------------------
 
 Some classes may define alternative constructors. If these
-classes are generic, self-type allows giving them precise signatures:
+classes are generic, self-type allows giving them precise
+signatures (Python 3.12 syntax):
 
 .. code-block:: python
 
-   T = TypeVar('T')
-
-   class Base(Generic[T]):
-       Q = TypeVar('Q', bound='Base[T]')
+   from typing import Self
 
+   class Base[T]:
        def __init__(self, item: T) -> None:
            self.item = item
 
        @classmethod
-       def make_pair(cls: Type[Q], item: T) -> tuple[Q, Q]:
+       def make_pair(cls, item: T) -> tuple[Self, Self]:
            return cls(item), cls(item)
 
-   class Sub(Base[T]):
+   class Sub[T](Base[T]):
        ...
 
    pair = Sub.make_pair('yes')  # Type is "tuple[Sub[str], Sub[str]]"
@@ -826,7 +849,7 @@ Typing async/await
 
 Mypy lets you type coroutines that use the ``async/await`` syntax.
 For more information regarding coroutines, see :pep:`492` and the
-`asyncio documentation <https://docs.python.org/3/library/asyncio.html>`_.
+`asyncio documentation <python:library/asyncio>`_.
 
 Functions defined using ``async def`` are typed similar to normal functions.
 The return type annotation should be the same as the type of the value you
@@ -851,8 +874,8 @@ expect to get back when ``await``-ing the coroutine.
 
 The result of calling an ``async def`` function *without awaiting* will
 automatically be inferred to be a value of type
-:py:class:`Coroutine[Any, Any, T] <typing.Coroutine>`, which is a subtype of
-:py:class:`Awaitable[T] <typing.Awaitable>`:
+:py:class:`Coroutine[Any, Any, T] <collections.abc.Coroutine>`, which is a subtype of
+:py:class:`Awaitable[T] <collections.abc.Awaitable>`:
 
 .. code-block:: python
 
@@ -865,11 +888,12 @@ Asynchronous iterators
 ----------------------
 
 If you have an asynchronous iterator, you can use the
-:py:class:`~typing.AsyncIterator` type in your annotations:
+:py:class:`~collections.abc.AsyncIterator` type in your annotations:
 
 .. code-block:: python
 
-   from typing import Optional, AsyncIterator
+   from collections.abc import AsyncIterator
+   from typing import Optional
    import asyncio
 
    class arange:
@@ -902,7 +926,8 @@ async iterators:
 
 .. code-block:: python
 
-   from typing import AsyncGenerator, Optional
+   from collections.abc import AsyncGenerator
+   from typing import Optional
    import asyncio
 
    # Could also type this as returning AsyncIterator[int]
@@ -919,7 +944,7 @@ One common confusion is that the presence of a ``yield`` statement in an
 
 .. code-block:: python
 
-   from typing import AsyncIterator
+   from collections.abc import AsyncIterator
 
    async def arange(stop: int) -> AsyncIterator[int]:
        # When called, arange gives you an async iterator
@@ -945,7 +970,8 @@ This can sometimes come up when trying to define base classes, Protocols or over
 
 .. code-block:: python
 
-    from typing import AsyncIterator, Protocol, overload
+    from collections.abc import AsyncIterator
+    from typing import Protocol, overload
 
     class LauncherIncorrect(Protocol):
         # Because launch does not have yield, this has type
diff --git a/docs/source/mypy_daemon.rst b/docs/source/mypy_daemon.rst
index 7586026b6c81..6c511e14eb95 100644
--- a/docs/source/mypy_daemon.rst
+++ b/docs/source/mypy_daemon.rst
@@ -61,7 +61,7 @@ you have a large codebase.)
 
 .. note::
 
-    The mypy daemon automatically enables ``--local-partial-types`` by default.
+    The mypy daemon requires ``--local-partial-types`` and automatically enables it.
 
 
 Daemon client commands
diff --git a/docs/source/protocols.rst b/docs/source/protocols.rst
index 95b870265f73..ed8d94f62ef1 100644
--- a/docs/source/protocols.rst
+++ b/docs/source/protocols.rst
@@ -3,44 +3,45 @@
 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
+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:
 
 Predefined protocols
 ********************
 
-The :py:mod:`typing` module defines various protocol classes that correspond
-to common Python protocols, such as :py:class:`Iterable[T] <typing.Iterable>`. If a class
+The :py:mod:`collections.abc`, :py:mod:`typing` and other stdlib modules define
+various protocol classes that correspond to common Python protocols, such as
+:py:class:`Iterable[T] <collections.abc.Iterable>`. If a class
 defines a suitable :py:meth:`__iter__ <object.__iter__>` method, mypy understands that it
-implements the iterable protocol and is compatible with :py:class:`Iterable[T] <typing.Iterable>`.
+implements the iterable protocol and is compatible with :py:class:`Iterable[T] <collections.abc.Iterable>`.
 For example, ``IntList`` below is iterable, over ``int`` values:
 
 .. code-block:: python
 
-   from typing import Iterator, Iterable, Optional
+   from __future__ import annotations
+
+   from collections.abc import Iterator, Iterable
 
    class IntList:
-       def __init__(self, value: int, next: Optional['IntList']) -> None:
+       def __init__(self, value: int, next: IntList | None) -> None:
            self.value = value
            self.next = next
 
@@ -58,10 +59,18 @@ For example, ``IntList`` below is iterable, over ``int`` values:
    print_numbered(x)  # OK
    print_numbered([4, 5])  # Also OK
 
-: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).
+:ref:`predefined_protocols_reference` lists various protocols defined in
+:py:mod:`collections.abc` and :py:mod:`typing` and the signatures of the corresponding methods
+you need to define to implement each protocol.
+
+.. note::
+    ``typing`` also contains deprecated aliases to protocols and ABCs defined in
+    :py:mod:`collections.abc`, such as :py:class:`Iterable[T] <typing.Iterable>`.
+    These are only necessary in Python 3.8 and earlier, since the protocols in
+    ``collections.abc`` didn't yet support subscripting (``[]``) in Python 3.8,
+    but the aliases in ``typing`` have always supported
+    subscripting. In Python 3.9 and later, the aliases in ``typing`` don't provide
+    any extra functionality.
 
 Simple user-defined protocols
 *****************************
@@ -71,8 +80,8 @@ class:
 
 .. code-block:: python
 
-   from typing import Iterable
-   from typing_extensions import Protocol
+   from collections.abc import Iterable
+   from typing import Protocol
 
    class SupportsClose(Protocol):
        # Empty method body (explicit '...')
@@ -89,18 +98,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 +174,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
 *********************************
 
@@ -228,23 +238,24 @@ such as trees and linked lists:
 
 .. code-block:: python
 
-   from typing import TypeVar, Optional
-   from typing_extensions import Protocol
+   from __future__ import annotations
+
+   from typing import Protocol
 
    class TreeLike(Protocol):
        value: int
 
        @property
-       def left(self) -> Optional['TreeLike']: ...
+       def left(self) -> TreeLike | None: ...
 
        @property
-       def right(self) -> Optional['TreeLike']: ...
+       def right(self) -> TreeLike | None: ...
 
    class SimpleTree:
        def __init__(self, value: int) -> None:
            self.value = value
-           self.left: Optional['SimpleTree'] = None
-           self.right: Optional['SimpleTree'] = None
+           self.left: SimpleTree | None = None
+           self.right: SimpleTree | None = None
 
    root: TreeLike = SimpleTree(0)  # OK
 
@@ -257,7 +268,7 @@ rudimentary support for runtime structural checks:
 
 .. code-block:: python
 
-   from typing_extensions import Protocol, runtime_checkable
+   from typing import Protocol, runtime_checkable
 
    @runtime_checkable
    class Portable(Protocol):
@@ -294,44 +305,46 @@ Callback protocols
 ******************
 
 Protocols can be used to define flexible callback types that are hard
-(or even impossible) to express using the :py:data:`Callable[...] <typing.Callable>` syntax, such as variadic,
-overloaded, and complex generic callbacks. They are defined with a special :py:meth:`__call__ <object.__call__>`
-member:
+(or even impossible) to express using the
+:py:class:`Callable[...] <collections.abc.Callable>` syntax,
+such as variadic, overloaded, and complex generic callbacks. They are defined with a
+special :py:meth:`__call__ <object.__call__>` member:
 
 .. code-block:: python
 
-   from typing import Optional, Iterable
-   from typing_extensions import Protocol
+   from collections.abc import Iterable
+   from typing import Optional, Protocol
 
    class Combiner(Protocol):
-       def __call__(self, *vals: bytes, maxlen: Optional[int] = None) -> list[bytes]: ...
+       def __call__(self, *vals: bytes, maxlen: int | None = None) -> list[bytes]: ...
 
    def batch_proc(data: Iterable[bytes], cb_results: Combiner) -> bytes:
        for item in data:
            ...
 
-   def good_cb(*vals: bytes, maxlen: Optional[int] = None) -> list[bytes]:
+   def good_cb(*vals: bytes, maxlen: int | None = None) -> list[bytes]:
        ...
-   def bad_cb(*vals: bytes, maxitems: Optional[int]) -> list[bytes]:
+   def bad_cb(*vals: bytes, maxitems: int | None) -> list[bytes]:
        ...
 
    batch_proc([], good_cb)  # OK
    batch_proc([], bad_cb)   # Error! Argument 2 has incompatible type because of
                             # different name and kind in the callback
 
-Callback protocols and :py:data:`~typing.Callable` types can be used mostly interchangeably.
-Argument names in :py:meth:`__call__ <object.__call__>` methods must be identical, unless
-a double underscore prefix is used. For example:
+Callback protocols and :py:class:`~collections.abc.Callable` types can be used mostly interchangeably.
+Parameter names in :py:meth:`__call__ <object.__call__>` methods must be identical, unless
+the parameters are positional-only. Example (using the legacy syntax for generic functions):
 
 .. code-block:: python
 
-   from typing import Callable, TypeVar
-   from typing_extensions import Protocol
+   from collections.abc import Callable
+   from typing import Protocol, TypeVar
 
    T = TypeVar('T')
 
    class Copy(Protocol):
-       def __call__(self, __origin: T) -> T: ...
+       # '/' marks the end of positional-only parameters
+       def __call__(self, origin: T, /) -> T: ...
 
    copy_a: Callable[[T], T]
    copy_b: Copy
@@ -350,8 +363,8 @@ Iteration protocols
 The iteration protocols are useful in many contexts. For example, they allow
 iteration of objects in for loops.
 
-Iterable[T]
------------
+collections.abc.Iterable[T]
+---------------------------
 
 The :ref:`example above <predefined_protocols>` has a simple implementation of an
 :py:meth:`__iter__ <object.__iter__>` method.
@@ -360,17 +373,17 @@ The :ref:`example above <predefined_protocols>` has a simple implementation of a
 
    def __iter__(self) -> Iterator[T]
 
-See also :py:class:`~typing.Iterable`.
+See also :py:class:`~collections.abc.Iterable`.
 
-Iterator[T]
------------
+collections.abc.Iterator[T]
+---------------------------
 
 .. code-block:: python
 
    def __next__(self) -> T
    def __iter__(self) -> Iterator[T]
 
-See also :py:class:`~typing.Iterator`.
+See also :py:class:`~collections.abc.Iterator`.
 
 Collection protocols
 ....................
@@ -379,8 +392,8 @@ Many of these are implemented by built-in container types such as
 :py:class:`list` and :py:class:`dict`, and these are also useful for user-defined
 collection objects.
 
-Sized
------
+collections.abc.Sized
+---------------------
 
 This is a type for objects that support :py:func:`len(x) <len>`.
 
@@ -388,10 +401,10 @@ This is a type for objects that support :py:func:`len(x) <len>`.
 
    def __len__(self) -> int
 
-See also :py:class:`~typing.Sized`.
+See also :py:class:`~collections.abc.Sized`.
 
-Container[T]
-------------
+collections.abc.Container[T]
+----------------------------
 
 This is a type for objects that support the ``in`` operator.
 
@@ -399,10 +412,10 @@ This is a type for objects that support the ``in`` operator.
 
    def __contains__(self, x: object) -> bool
 
-See also :py:class:`~typing.Container`.
+See also :py:class:`~collections.abc.Container`.
 
-Collection[T]
--------------
+collections.abc.Collection[T]
+-----------------------------
 
 .. code-block:: python
 
@@ -410,7 +423,7 @@ Collection[T]
    def __iter__(self) -> Iterator[T]
    def __contains__(self, x: object) -> bool
 
-See also :py:class:`~typing.Collection`.
+See also :py:class:`~collections.abc.Collection`.
 
 One-off protocols
 .................
@@ -418,8 +431,8 @@ One-off protocols
 These protocols are typically only useful with a single standard
 library function or class.
 
-Reversible[T]
--------------
+collections.abc.Reversible[T]
+-----------------------------
 
 This is a type for objects that support :py:func:`reversed(x) <reversed>`.
 
@@ -427,10 +440,10 @@ This is a type for objects that support :py:func:`reversed(x) <reversed>`.
 
    def __reversed__(self) -> Iterator[T]
 
-See also :py:class:`~typing.Reversible`.
+See also :py:class:`~collections.abc.Reversible`.
 
-SupportsAbs[T]
---------------
+typing.SupportsAbs[T]
+---------------------
 
 This is a type for objects that support :py:func:`abs(x) <abs>`. ``T`` is the type of
 value returned by :py:func:`abs(x) <abs>`.
@@ -441,8 +454,8 @@ value returned by :py:func:`abs(x) <abs>`.
 
 See also :py:class:`~typing.SupportsAbs`.
 
-SupportsBytes
--------------
+typing.SupportsBytes
+--------------------
 
 This is a type for objects that support :py:class:`bytes(x) <bytes>`.
 
@@ -454,8 +467,8 @@ See also :py:class:`~typing.SupportsBytes`.
 
 .. _supports-int-etc:
 
-SupportsComplex
----------------
+typing.SupportsComplex
+----------------------
 
 This is a type for objects that support :py:class:`complex(x) <complex>`. Note that no arithmetic operations
 are supported.
@@ -466,8 +479,8 @@ are supported.
 
 See also :py:class:`~typing.SupportsComplex`.
 
-SupportsFloat
--------------
+typing.SupportsFloat
+--------------------
 
 This is a type for objects that support :py:class:`float(x) <float>`. Note that no arithmetic operations
 are supported.
@@ -478,8 +491,8 @@ are supported.
 
 See also :py:class:`~typing.SupportsFloat`.
 
-SupportsInt
------------
+typing.SupportsInt
+------------------
 
 This is a type for objects that support :py:class:`int(x) <int>`. Note that no arithmetic operations
 are supported.
@@ -490,8 +503,8 @@ are supported.
 
 See also :py:class:`~typing.SupportsInt`.
 
-SupportsRound[T]
-----------------
+typing.SupportsRound[T]
+-----------------------
 
 This is a type for objects that support :py:func:`round(x) <round>`.
 
@@ -507,33 +520,33 @@ Async protocols
 These protocols can be useful in async code. See :ref:`async-and-await`
 for more information.
 
-Awaitable[T]
-------------
+collections.abc.Awaitable[T]
+----------------------------
 
 .. code-block:: python
 
    def __await__(self) -> Generator[Any, None, T]
 
-See also :py:class:`~typing.Awaitable`.
+See also :py:class:`~collections.abc.Awaitable`.
 
-AsyncIterable[T]
-----------------
+collections.abc.AsyncIterable[T]
+--------------------------------
 
 .. code-block:: python
 
    def __aiter__(self) -> AsyncIterator[T]
 
-See also :py:class:`~typing.AsyncIterable`.
+See also :py:class:`~collections.abc.AsyncIterable`.
 
-AsyncIterator[T]
-----------------
+collections.abc.AsyncIterator[T]
+--------------------------------
 
 .. code-block:: python
 
    def __anext__(self) -> Awaitable[T]
    def __aiter__(self) -> AsyncIterator[T]
 
-See also :py:class:`~typing.AsyncIterator`.
+See also :py:class:`~collections.abc.AsyncIterator`.
 
 Context manager protocols
 .........................
@@ -542,28 +555,28 @@ There are two protocols for context managers -- one for regular context
 managers and one for async ones. These allow defining objects that can
 be used in ``with`` and ``async with`` statements.
 
-ContextManager[T]
------------------
+contextlib.AbstractContextManager[T]
+------------------------------------
 
 .. code-block:: python
 
    def __enter__(self) -> T
    def __exit__(self,
-                exc_type: Optional[Type[BaseException]],
-                exc_value: Optional[BaseException],
-                traceback: Optional[TracebackType]) -> Optional[bool]
+                exc_type: type[BaseException] | None,
+                exc_value: BaseException | None,
+                traceback: TracebackType | None) -> bool | None
 
-See also :py:class:`~typing.ContextManager`.
+See also :py:class:`~contextlib.AbstractContextManager`.
 
-AsyncContextManager[T]
-----------------------
+contextlib.AbstractAsyncContextManager[T]
+-----------------------------------------
 
 .. code-block:: python
 
    def __aenter__(self) -> Awaitable[T]
    def __aexit__(self,
-                 exc_type: Optional[Type[BaseException]],
-                 exc_value: Optional[BaseException],
-                 traceback: Optional[TracebackType]) -> Awaitable[Optional[bool]]
+                 exc_type: type[BaseException] | None,
+                 exc_value: BaseException | None,
+                 traceback: TracebackType | None) -> Awaitable[bool | None]
 
-See also :py:class:`~typing.AsyncContextManager`.
+See also :py:class:`~contextlib.AbstractAsyncContextManager`.
diff --git a/docs/source/running_mypy.rst b/docs/source/running_mypy.rst
index b0cefec9dafa..9f7461d24f72 100644
--- a/docs/source/running_mypy.rst
+++ b/docs/source/running_mypy.rst
@@ -277,6 +277,31 @@ If you are getting this error, try to obtain type hints for the library you're u
     to the library -- see our documentation on creating
     :ref:`PEP 561 compliant packages <installed-packages>`.
 
+4.  Force mypy to analyze the library as best as it can (as if the library provided
+    a ``py.typed`` file), despite it likely missing any type annotations. In general,
+    the quality of type checking will be poor and mypy may have issues when
+    analyzing code not designed to be type checked.
+
+    You can do this via setting the
+    :option:`--follow-untyped-imports <mypy --follow-untyped-imports>`
+    command line flag or :confval:`follow_untyped_imports` config file option to True.
+    This option can be specified on a per-module basis as well:
+
+    .. tab:: mypy.ini
+
+        .. code-block:: ini
+
+            [mypy-untyped_package.*]
+            follow_untyped_imports = True
+
+    .. tab:: pyproject.toml
+
+        .. code-block:: toml
+
+            [[tool.mypy.overrides]]
+            module = ["untyped_package.*"]
+            follow_untyped_imports = true
+
 If you are unable to find any existing type hints nor have time to write your
 own, you can instead *suppress* the errors.
 
@@ -293,10 +318,22 @@ not catch errors in its use.
     suppose your codebase
     makes heavy use of an (untyped) library named ``foobar``. You can silence
     all import errors associated with that library and that library alone by
-    adding the following section to your config file::
+    adding the following section to your config file:
+
+    .. tab:: mypy.ini
+
+        .. code-block:: ini
+
+            [mypy-foobar.*]
+            ignore_missing_imports = True
+
+    .. tab:: pyproject.toml
+
+        .. code-block:: toml
 
-        [mypy-foobar.*]
-        ignore_missing_imports = True
+            [[tool.mypy.overrides]]
+            module = ["foobar.*"]
+            ignore_missing_imports = true
 
     Note: this option is equivalent to adding a ``# type: ignore`` to every
     import of ``foobar`` in your codebase. For more information, see the
@@ -305,16 +342,30 @@ not catch errors in its use.
     The ``.*`` after ``foobar`` will ignore imports of ``foobar`` modules
     and subpackages in addition to the ``foobar`` top-level package namespace.
 
-3.  To suppress *all* missing import errors for *all* libraries in your codebase,
-    invoke mypy with the :option:`--ignore-missing-imports <mypy --ignore-missing-imports>` command line flag or set
-    the :confval:`ignore_missing_imports`
-    config file option to True
-    in the *global* section of your mypy config file::
+3.  To suppress *all* missing import errors for *all* untyped libraries
+    in your codebase, use :option:`--disable-error-code=import-untyped <mypy --ignore-missing-imports>`.
+    See :ref:`code-import-untyped` for more details on this error code.
 
-        [mypy]
-        ignore_missing_imports = True
+    You can also set :confval:`disable_error_code`, like so:
 
-    We recommend using this approach only as a last resort: it's equivalent
+    .. tab:: mypy.ini
+
+        .. code-block:: ini
+
+            [mypy]
+            disable_error_code = import-untyped
+
+    .. tab:: pyproject.toml
+
+        .. code-block:: ini
+
+            [tool.mypy]
+            disable_error_code = ["import-untyped"]
+
+    You can also set the :option:`--ignore-missing-imports <mypy --ignore-missing-imports>`
+    command line flag or set the :confval:`ignore_missing_imports` config file
+    option to True in the *global* section of your mypy config file. We
+    recommend avoiding ``--ignore-missing-imports`` if possible: it's equivalent
     to adding a ``# type: ignore`` to all unresolved imports in your codebase.
 
 
@@ -387,11 +438,11 @@ this error, try:
     installing into the environment you expect by running pip like
     ``python -m pip ...``.
 
-2.  Reading the :ref:`finding-imports` section below to make sure you
+3.  Reading the :ref:`finding-imports` section below to make sure you
     understand how exactly mypy searches for and finds modules and modify
     how you're invoking mypy accordingly.
 
-3.  Directly specifying the directory containing the module you want to
+4.  Directly specifying the directory containing the module you want to
     type check from the command line, by using the :confval:`mypy_path`
     or :confval:`files` config file options,
     or by using the ``MYPYPATH`` environment variable.
@@ -401,7 +452,7 @@ this error, try:
     For example, suppose you are trying to add the module ``foo.bar.baz``
     which is located at ``~/foo-project/src/foo/bar/baz.py``. In this case,
     you must run ``mypy ~/foo-project/src`` (or set the ``MYPYPATH`` to
-    ``~/foo-project/src``.
+    ``~/foo-project/src``).
 
 .. _finding-imports:
 
@@ -499,7 +550,7 @@ accepts one of four string values:
         main.py:1: note: (Using --follow-imports=error, module not passed on command line)
 
 If you are starting a new codebase and plan on using type hints from
-the start, we recommend you use either :option:`--follow-imports=normal <mypy --follow-imports>`
+the start, we **recommend** you use either :option:`--follow-imports=normal <mypy --follow-imports>`
 (the default) or :option:`--follow-imports=error <mypy --follow-imports>`. Either option will help
 make sure you are not skipping checking any part of your codebase by
 accident.
@@ -510,16 +561,27 @@ files that do not use type hints) pass under :option:`--follow-imports=normal <m
 This is usually not too difficult to do: mypy is designed to report as
 few error messages as possible when it is looking at unannotated code.
 
-Only if doing this is intractable, we recommend passing mypy just the files
-you want to type check and use :option:`--follow-imports=silent <mypy --follow-imports>`. Even if
-mypy is unable to perfectly type check a file, it can still glean some
+Only if doing this is intractable, try passing mypy just the files
+you want to type check and using :option:`--follow-imports=silent <mypy --follow-imports>`.
+Even if mypy is unable to perfectly type check a file, it can still glean some
 useful information by parsing it (for example, understanding what methods
 a given object has). See :ref:`existing-code` for more recommendations.
 
-We do not recommend using ``skip`` unless you know what you are doing:
-while this option can be quite powerful, it can also cause many
-hard-to-debug errors.
-
 Adjusting import following behaviour is often most useful when restricted to
 specific modules. This can be accomplished by setting a per-module
 :confval:`follow_imports` config option.
+
+.. warning::
+
+    We do not recommend using ``follow_imports=skip`` unless you're really sure
+    you know what you are doing. This option greatly restricts the analysis mypy
+    can perform and you will lose a lot of the benefits of type checking.
+
+    This is especially true at the global level. Setting a per-module
+    ``follow_imports=skip`` for a specific problematic module can be
+    useful without causing too much harm.
+
+.. note::
+
+    If you're looking to resolve import errors related to libraries, try following
+    the advice in :ref:`fix-missing-imports` before messing with ``follow_imports``.
diff --git a/docs/source/runtime_troubles.rst b/docs/source/runtime_troubles.rst
index 909215a774a9..edc375e26485 100644
--- a/docs/source/runtime_troubles.rst
+++ b/docs/source/runtime_troubles.rst
@@ -8,10 +8,9 @@ version of Python considers legal code. This section describes these scenarios
 and explains how to get your code running again. Generally speaking, we have
 three tools at our disposal:
 
-* Use of ``from __future__ import annotations`` (:pep:`563`)
-  (this behaviour may eventually be made the default in a future Python version)
 * Use of string literal types or type comments
 * Use of ``typing.TYPE_CHECKING``
+* Use of ``from __future__ import annotations`` (:pep:`563`)
 
 We provide a description of these before moving onto discussion of specific
 problems you may encounter.
@@ -21,8 +20,9 @@ problems you may encounter.
 String literal types and type comments
 --------------------------------------
 
-Mypy allows you to add type annotations using ``# type:`` type comments.
-For example:
+Mypy lets you add type annotations using the (now deprecated) ``# type:``
+type comment syntax. These were required with Python versions older than 3.6,
+since they didn't support type annotations on variables. Example:
 
 .. code-block:: python
 
@@ -69,7 +69,7 @@ Future annotations import (PEP 563)
 -----------------------------------
 
 Many of the issues described here are caused by Python trying to evaluate
-annotations. Future Python versions (potentially Python 3.12) will by default no
+annotations. Future Python versions (potentially Python 3.14) will by default no
 longer attempt to evaluate function and variable annotations. This behaviour is
 made available in Python 3.7 and later through the use of
 ``from __future__ import annotations``.
@@ -84,15 +84,16 @@ required to be valid Python syntax. For more details, see :pep:`563`.
     still require string literals or result in errors, typically involving use
     of forward references or generics in:
 
-    * :ref:`type aliases <type-aliases>`;
+    * :ref:`type aliases <type-aliases>` not defined using the ``type`` statement;
     * :ref:`type narrowing <type-narrowing>`;
-    * type definitions (see :py:class:`~typing.TypeVar`, :py:func:`~typing.NewType`, :py:class:`~typing.NamedTuple`);
+    * type definitions (see :py:class:`~typing.TypeVar`, :py:class:`~typing.NewType`, :py:class:`~typing.NamedTuple`);
     * base classes.
 
     .. code-block:: python
 
         # base class example
         from __future__ import annotations
+
         class A(tuple['B', 'C']): ... # String literal types needed here
         class B: ...
         class C: ...
@@ -244,7 +245,8 @@ complicated and you need to use :ref:`typing.TYPE_CHECKING
    task_queue: Tasks
    reveal_type(task_queue.get())  # Reveals str
 
-If your subclass is also generic, you can use the following:
+If your subclass is also generic, you can use the following (using the
+legacy syntax for generic classes):
 
 .. code-block:: python
 
@@ -262,14 +264,16 @@ If your subclass is also generic, you can use the following:
    task_queue: MyQueue[str]
    reveal_type(task_queue.get())  # Reveals str
 
-In Python 3.9, we can just inherit directly from ``Queue[str]`` or ``Queue[T]``
-since its :py:class:`queue.Queue` implements :py:meth:`__class_getitem__`, so
-the class object can be subscripted at runtime without issue.
+In Python 3.9 and later, we can just inherit directly from ``Queue[str]`` or ``Queue[T]``
+since its :py:class:`queue.Queue` implements :py:meth:`~object.__class_getitem__`, so
+the class object can be subscripted at runtime. You may still encounter issues (even if
+you use a recent Python version) when subclassing generic classes defined in third-party
+libraries if types are generic only in stubs.
 
 Using types defined in stubs but not at runtime
 -----------------------------------------------
 
-Sometimes stubs that you're using may define types you wish to re-use that do
+Sometimes stubs that you're using may define types you wish to reuse that do
 not exist at runtime. Importing these types naively will cause your code to fail
 at runtime with ``ImportError`` or ``ModuleNotFoundError``. Similar to previous
 sections, these can be dealt with by using :ref:`typing.TYPE_CHECKING
@@ -315,8 +319,8 @@ notes at :ref:`future annotations import<future-annotations>`.
 Using X | Y syntax for Unions
 -----------------------------
 
-Starting with Python 3.10 (:pep:`604`), you can spell union types as ``x: int |
-str``, instead of ``x: typing.Union[int, str]``.
+Starting with Python 3.10 (:pep:`604`), you can spell union types as
+``x: int | str``, instead of ``x: typing.Union[int, str]``.
 
 There is limited support for using this syntax in Python 3.7 and later as well:
 if you use ``from __future__ import annotations``, mypy will understand this
@@ -330,16 +334,14 @@ Using new additions to the typing module
 ----------------------------------------
 
 You may find yourself wanting to use features added to the :py:mod:`typing`
-module in earlier versions of Python than the addition, for example, using any
-of ``Literal``, ``Protocol``, ``TypedDict`` with Python 3.6.
+module in earlier versions of Python than the addition.
 
 The easiest way to do this is to install and use the ``typing_extensions``
 package from PyPI for the relevant imports, for example:
 
 .. code-block:: python
 
-   from typing_extensions import Literal
-   x: Literal["open", "close"]
+   from typing_extensions import TypeIs
 
 If you don't want to rely on ``typing_extensions`` being installed on newer
 Pythons, you could alternatively use:
@@ -347,12 +349,10 @@ Pythons, you could alternatively use:
 .. code-block:: python
 
    import sys
-   if sys.version_info >= (3, 8):
-       from typing import Literal
+   if sys.version_info >= (3, 13):
+       from typing import TypeIs
    else:
-       from typing_extensions import Literal
-
-   x: Literal["open", "close"]
+       from typing_extensions import TypeIs
 
 This plays nicely well with following :pep:`508` dependency specification:
-``typing_extensions; python_version<"3.8"``
+``typing_extensions; python_version<"3.13"``
diff --git a/docs/source/stubgen.rst b/docs/source/stubgen.rst
index f06c9c066bb7..c9e52956379a 100644
--- a/docs/source/stubgen.rst
+++ b/docs/source/stubgen.rst
@@ -127,12 +127,22 @@ alter the default behavior:
     unwanted side effects, such as the running of tests. Stubgen tries to skip test
     modules even without this option, but this does not always work.
 
-.. option:: --parse-only
+.. option:: --no-analysis
 
     Don't perform semantic analysis of source files. This may generate
     worse stubs -- in particular, some module, class, and function aliases may
     be represented as variables with the ``Any`` type. This is generally only
-    useful if semantic analysis causes a critical mypy error.
+    useful if semantic analysis causes a critical mypy error.  Does not apply to
+    C extension modules.  Incompatible with :option:`--inspect-mode`.
+
+.. option:: --inspect-mode
+
+    Import and inspect modules instead of parsing source code. This is the default
+    behavior for C modules and pyc-only packages.  The flag is useful to force
+    inspection for pure Python modules that make use of dynamically generated
+    members that would otherwise be omitted when using the default behavior of
+    code parsing.  Implies :option:`--no-analysis` as analysis requires source
+    code.
 
 .. option:: --doc-dir PATH
 
@@ -163,6 +173,11 @@ Additional flags
     Instead, only export imported names that are not referenced in the module
     that contains the import.
 
+.. option:: --include-docstrings
+
+    Include docstrings in stubs. This will add docstrings to Python function and
+    classes stubs and to C extension function stubs.
+
 .. option:: --search-path PATH
 
     Specify module search directories, separated by colons (only used if
diff --git a/docs/source/stubs.rst b/docs/source/stubs.rst
index 7c84a9718b3e..c0a3f8b88111 100644
--- a/docs/source/stubs.rst
+++ b/docs/source/stubs.rst
@@ -114,7 +114,7 @@ For example:
 
 .. code-block:: python
 
-    from typing_extensions import Protocol
+    from typing import Protocol
 
     class Resource(Protocol):
         def ok_1(self, foo: list[str] = ...) -> None: ...
diff --git a/docs/source/type_inference_and_annotations.rst b/docs/source/type_inference_and_annotations.rst
index 6adb4e651224..318ca4cd9160 100644
--- a/docs/source/type_inference_and_annotations.rst
+++ b/docs/source/type_inference_and_annotations.rst
@@ -41,12 +41,10 @@ variable type annotation:
 
 .. code-block:: python
 
-   from typing import Union
-
-   x: Union[int, str] = 1
+   x: int | str = 1
 
 Without the type annotation, the type of ``x`` would be just ``int``. We
-use an annotation to give it a more general type ``Union[int, str]`` (this
+use an annotation to give it a more general type ``int | str`` (this
 type means that the value can be either an ``int`` or a ``str``).
 
 The best way to think about this is that the type annotation sets the type of
@@ -55,8 +53,8 @@ about the following code:
 
 .. code-block:: python
 
-   x: Union[int, str] = 1.1  # error: Incompatible types in assignment
-                             # (expression has type "float", variable has type "Union[int, str]")
+   x: int | str = 1.1  # error: Incompatible types in assignment
+                       # (expression has type "float", variable has type "int | str")
 
 .. note::
 
diff --git a/docs/source/type_narrowing.rst b/docs/source/type_narrowing.rst
index 72a816679140..ccd16ffbc0a3 100644
--- a/docs/source/type_narrowing.rst
+++ b/docs/source/type_narrowing.rst
@@ -3,21 +3,31 @@
 Type narrowing
 ==============
 
-This section is dedicated to  several type narrowing
+This section is dedicated to several type narrowing
 techniques which are supported by mypy.
 
 Type narrowing is when you convince a type checker that a broader type is actually more specific, for instance, that an object of type ``Shape`` is actually of the narrower type ``Square``.
 
+The following type narrowing techniques are available:
+
+- :ref:`type-narrowing-expressions`
+- :ref:`casts`
+- :ref:`type-guards`
+- :ref:`typeis`
+
+
+.. _type-narrowing-expressions:
 
 Type narrowing expressions
 --------------------------
 
 The simplest way to narrow a type is to use one of the supported expressions:
 
-- :py:func:`isinstance` like in ``isinstance(obj, float)`` will narrow ``obj`` to have ``float`` type
-- :py:func:`issubclass` like in ``issubclass(cls, MyClass)`` will narrow ``cls`` to be ``Type[MyClass]``
-- :py:class:`type` like in ``type(obj) is int`` will narrow ``obj`` to have ``int`` type
-- :py:func:`callable` like in ``callable(obj)`` will narrow object to callable type
+- :py:func:`isinstance` like in :code:`isinstance(obj, float)` will narrow ``obj`` to have ``float`` type
+- :py:func:`issubclass` like in :code:`issubclass(cls, MyClass)` will narrow ``cls`` to be ``Type[MyClass]``
+- :py:class:`type` like in :code:`type(obj) is int` will narrow ``obj`` to have ``int`` type
+- :py:func:`callable` like in :code:`callable(obj)` will narrow object to callable type
+- :code:`obj is not None` will narrow object to its :ref:`non-optional form <strict_optional>`
 
 Type narrowing is contextual. For example, based on the condition, mypy will narrow an expression only within an ``if`` branch:
 
@@ -83,6 +93,7 @@ We can also use ``assert`` to narrow types in the same context:
      reveal_type(x)  # Revealed type is "builtins.int"
      print(x + '!')  # Typechecks with `mypy`, but fails in runtime.
 
+
 issubclass
 ~~~~~~~~~~
 
@@ -112,7 +123,7 @@ So, we know what ``callable()`` will return. For example:
 
 .. code-block:: python
 
-  from typing import Callable
+  from collections.abc import Callable
 
   x: Callable[[], int]
 
@@ -121,14 +132,14 @@ So, we know what ``callable()`` will return. For example:
   else:
       ...  # Will never be executed and will raise error with `--warn-unreachable`
 
-``callable`` function can even split ``Union`` type
-for callable and non-callable parts:
+The ``callable`` function can even split union types into
+callable and non-callable parts:
 
 .. code-block:: python
 
-  from typing import Callable, Union
+  from collections.abc import Callable
 
-  x: Union[int, Callable[[], int]]
+  x: int | Callable[[], int]
 
   if callable(x):
       reveal_type(x)  # N: Revealed type is "def () -> builtins.int"
@@ -253,16 +264,13 @@ to the type specified as the first type parameter (``list[str]``).
 Generic TypeGuards
 ~~~~~~~~~~~~~~~~~~
 
-``TypeGuard`` can also work with generic types:
+``TypeGuard`` can also work with generic types (Python 3.12 syntax):
 
 .. code-block:: python
 
-  from typing import TypeVar
   from typing import TypeGuard  # use `typing_extensions` for `python<3.10`
 
-  _T = TypeVar("_T")
-
-  def is_two_element_tuple(val: tuple[_T, ...]) -> TypeGuard[tuple[_T, _T]]:
+  def is_two_element_tuple[T](val: tuple[T, ...]) -> TypeGuard[tuple[T, T]]:
       return len(val) == 2
 
   def func(names: tuple[str, ...]):
@@ -271,19 +279,16 @@ Generic TypeGuards
       else:
           reveal_type(names)  # tuple[str, ...]
 
-Typeguards with parameters
+TypeGuards with parameters
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Type guard functions can accept extra arguments:
+Type guard functions can accept extra arguments (Python 3.12 syntax):
 
 .. code-block:: python
 
-  from typing import Type, TypeVar
   from typing import TypeGuard  # use `typing_extensions` for `python<3.10`
 
-  _T = TypeVar("_T")
-
-  def is_set_of(val: set[Any], type: Type[_T]) -> TypeGuard[set[_T]]:
+  def is_set_of[T](val: set[Any], type: type[T]) -> TypeGuard[set[T]]:
       return all(isinstance(x, type) for x in val)
 
   items: set[Any]
@@ -293,7 +298,7 @@ Type guard functions can accept extra arguments:
 TypeGuards as methods
 ~~~~~~~~~~~~~~~~~~~~~
 
- A method can also serve as the ``TypeGuard``:
+A method can also serve as a ``TypeGuard``:
 
 .. code-block:: python
 
@@ -359,3 +364,204 @@ What happens here?
 .. note::
 
   The same will work with ``isinstance(x := a, float)`` as well.
+
+
+.. _typeis:
+
+TypeIs
+------
+
+Mypy supports TypeIs (:pep:`742`).
+
+A `TypeIs narrowing function <https://typing.readthedocs.io/en/latest/spec/narrowing.html#typeis>`_
+allows you to define custom type checks that can narrow the type of a variable
+in `both the if and else <https://docs.python.org/3.13/library/typing.html#typing.TypeIs>`_
+branches of a conditional, similar to how the built-in isinstance() function works.
+
+TypeIs is new in Python 3.13 — for use in older Python versions, use the backport
+from `typing_extensions <https://typing-extensions.readthedocs.io/en/latest/>`_
+
+Consider the following example using TypeIs:
+
+.. code-block:: python
+
+    from typing import TypeIs
+
+    def is_str(x: object) -> TypeIs[str]:
+        return isinstance(x, str)
+
+    def process(x: int | str) -> None:
+        if is_str(x):
+            reveal_type(x)  # Revealed type is 'str'
+            print(x.upper())  # Valid: x is str
+        else:
+            reveal_type(x)  # Revealed type is 'int'
+            print(x + 1)  # Valid: x is int
+
+In this example, the function is_str is a type narrowing function
+that returns TypeIs[str]. When used in an if statement, x is narrowed
+to str in the if branch and to int in the else branch.
+
+Key points:
+
+
+- The function must accept at least one positional argument.
+
+- The return type is annotated as ``TypeIs[T]``, where ``T`` is the type you
+  want to narrow to.
+
+- The function must return a ``bool`` value.
+
+- In the ``if`` branch (when the function returns ``True``), the type of the
+  argument is narrowed to the intersection of its original type and ``T``.
+
+- In the ``else`` branch (when the function returns ``False``), the type of
+  the argument is narrowed to the intersection of its original type and the
+  complement of ``T``.
+
+
+TypeIs vs TypeGuard
+~~~~~~~~~~~~~~~~~~~
+
+While both TypeIs and TypeGuard allow you to define custom type narrowing
+functions, they differ in important ways:
+
+- **Type narrowing behavior**: TypeIs narrows the type in both the if and else branches,
+  whereas TypeGuard narrows only in the if branch.
+
+- **Compatibility requirement**: TypeIs requires that the narrowed type T be
+  compatible with the input type of the function. TypeGuard does not have this restriction.
+
+- **Type inference**: With TypeIs, the type checker may infer a more precise type by
+  combining existing type information with T.
+
+Here's an example demonstrating the behavior with TypeGuard:
+
+.. code-block:: python
+
+    from typing import TypeGuard, reveal_type
+
+    def is_str(x: object) -> TypeGuard[str]:
+        return isinstance(x, str)
+
+    def process(x: int | str) -> None:
+        if is_str(x):
+            reveal_type(x)  # Revealed type is "builtins.str"
+            print(x.upper())  # ok: x is str
+        else:
+            reveal_type(x)  # Revealed type is "Union[builtins.int, builtins.str]"
+            print(x + 1)  # ERROR: Unsupported operand types for + ("str" and "int")  [operator]
+
+Generic TypeIs
+~~~~~~~~~~~~~~
+
+``TypeIs`` functions can also work with generic types:
+
+.. code-block:: python
+
+    from typing import TypeVar, TypeIs
+
+    T = TypeVar('T')
+
+    def is_two_element_tuple(val: tuple[T, ...]) -> TypeIs[tuple[T, T]]:
+        return len(val) == 2
+
+    def process(names: tuple[str, ...]) -> None:
+        if is_two_element_tuple(names):
+            reveal_type(names)  # Revealed type is 'tuple[str, str]'
+        else:
+            reveal_type(names)  # Revealed type is 'tuple[str, ...]'
+
+
+TypeIs with Additional Parameters
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+TypeIs functions can accept additional parameters beyond the first.
+The type narrowing applies only to the first argument.
+
+.. code-block:: python
+
+    from typing import Any, TypeVar, reveal_type, TypeIs
+
+    T = TypeVar('T')
+
+    def is_instance_of(val: Any, typ: type[T]) -> TypeIs[T]:
+        return isinstance(val, typ)
+
+    def process(x: Any) -> None:
+        if is_instance_of(x, int):
+            reveal_type(x)  # Revealed type is 'int'
+            print(x + 1)  # ok
+        else:
+            reveal_type(x)  # Revealed type is 'Any'
+
+TypeIs in Methods
+~~~~~~~~~~~~~~~~~
+
+A method can also serve as a ``TypeIs`` function. Note that in instance or
+class methods, the type narrowing applies to the second parameter
+(after ``self`` or ``cls``).
+
+.. code-block:: python
+
+    class Validator:
+        def is_valid(self, instance: object) -> TypeIs[str]:
+            return isinstance(instance, str)
+
+        def process(self, to_validate: object) -> None:
+            if Validator().is_valid(to_validate):
+                reveal_type(to_validate)  # Revealed type is 'str'
+                print(to_validate.upper())  # ok: to_validate is str
+
+
+Assignment Expressions with TypeIs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can use the assignment expression operator ``:=`` with ``TypeIs`` to create a new variable and narrow its type simultaneously.
+
+.. code-block:: python
+
+    from typing import TypeIs, reveal_type
+
+    def is_float(x: object) -> TypeIs[float]:
+        return isinstance(x, float)
+
+    def main(a: object) -> None:
+        if is_float(x := a):
+            reveal_type(x)  # Revealed type is 'float'
+            # x is narrowed to float in this block
+            print(x + 1.0)
+
+
+Limitations
+-----------
+
+Mypy's analysis is limited to individual symbols and it will not track
+relationships between symbols. For example, in the following code
+it's easy to deduce that if :code:`a` is None then :code:`b` must not be,
+therefore :code:`a or b` will always be an instance of :code:`C`,
+but Mypy will not be able to tell that:
+
+.. code-block:: python
+
+    class C:
+        pass
+
+    def f(a: C | None, b: C | None) -> C:
+        if a is not None or b is not None:
+            return a or b  # Incompatible return value type (got "C | None", expected "C")
+        return C()
+
+Tracking these sort of cross-variable conditions in a type checker would add significant complexity
+and performance overhead.
+
+You can use an ``assert`` to convince the type checker, override it with a :ref:`cast <casts>`
+or rewrite the function to be slightly more verbose:
+
+.. code-block:: python
+
+    def f(a: C | None, b: C | None) -> C:
+        if a is not None:
+            return a
+        elif b is not None:
+            return b
+        return C()
diff --git a/docs/source/typed_dict.rst b/docs/source/typed_dict.rst
index 19a717d7feb7..bbb10a12abe8 100644
--- a/docs/source/typed_dict.rst
+++ b/docs/source/typed_dict.rst
@@ -25,7 +25,7 @@ dictionary value depends on the key:
 
 .. code-block:: python
 
-   from typing_extensions import TypedDict
+   from typing import TypedDict
 
    Movie = TypedDict('Movie', {'name': str, 'year': int})
 
@@ -89,7 +89,7 @@ A ``TypedDict`` object is not a subtype of the regular ``dict[...]``
 type (and vice versa), since :py:class:`dict` allows arbitrary keys to be
 added and removed, unlike ``TypedDict``. However, any ``TypedDict`` object is
 a subtype of (that is, compatible with) ``Mapping[str, object]``, since
-:py:class:`~typing.Mapping` only provides read-only access to the dictionary items:
+:py:class:`~collections.abc.Mapping` only provides read-only access to the dictionary items:
 
 .. code-block:: python
 
@@ -158,7 +158,7 @@ You must use string literals as keys when calling most of the methods,
 as otherwise mypy won't be able to check that the key is valid. List
 of supported operations:
 
-* Anything included in :py:class:`~typing.Mapping`:
+* Anything included in :py:class:`~collections.abc.Mapping`:
 
   * ``d[key]``
   * ``key in d``
@@ -189,7 +189,7 @@ in Python 3.6 and later:
 
 .. code-block:: python
 
-   from typing_extensions import TypedDict
+   from typing import TypedDict  # "from typing_extensions" in Python 3.7 and earlier
 
    class Movie(TypedDict):
        name: str
@@ -236,6 +236,46 @@ another ``TypedDict`` if all required keys in the other ``TypedDict`` are requir
 first ``TypedDict``, and all non-required keys of the other ``TypedDict`` are also non-required keys
 in the first ``TypedDict``.
 
+Read-only items
+---------------
+
+You can use ``typing.ReadOnly``, introduced in Python 3.13, or
+``typing_extensions.ReadOnly`` to mark TypedDict items as read-only (:pep:`705`):
+
+.. code-block:: python
+
+    from typing import TypedDict
+
+    # Or "from typing ..." on Python 3.13+
+    from typing_extensions import ReadOnly
+
+    class Movie(TypedDict):
+        name: ReadOnly[str]
+        num_watched: int
+
+    m: Movie = {"name": "Jaws", "num_watched": 1}
+    m["name"] = "The Godfather"  # Error: "name" is read-only
+    m["num_watched"] += 1  # OK
+
+A TypedDict with a mutable item can be assigned to a TypedDict
+with a corresponding read-only item, and the type of the item can
+vary :ref:`covariantly <variance-of-generics>`:
+
+.. code-block:: python
+
+    class Entry(TypedDict):
+        name: ReadOnly[str | None]
+        year: ReadOnly[int]
+
+    class Movie(TypedDict):
+        name: str
+        year: int
+
+    def process_entry(i: Entry) -> None: ...
+
+    m: Movie = {"name": "Jaws", "year": 1975}
+    process_entry(m)  # OK
+
 Unions of TypedDicts
 --------------------
 
@@ -248,3 +288,41 @@ section of the docs has a full description with an example, but in short, you wi
 need to give each TypedDict the same key where each value has a unique
 :ref:`Literal type <literal_types>`. Then, check that key to distinguish
 between your TypedDicts.
+
+Inline TypedDict types
+----------------------
+
+.. note::
+
+    This is an experimental (non-standard) feature. Use
+    ``--enable-incomplete-feature=InlineTypedDict`` to enable.
+
+Sometimes you may want to define a complex nested JSON schema, or annotate
+a one-off function that returns a TypedDict. In such cases it may be convenient
+to use inline TypedDict syntax. For example:
+
+.. code-block:: python
+
+    def test_values() -> {"int": int, "str": str}:
+        return {"int": 42, "str": "test"}
+
+    class Response(TypedDict):
+        status: int
+        msg: str
+        # Using inline syntax here avoids defining two additional TypedDicts.
+        content: {"items": list[{"key": str, "value": str}]}
+
+Inline TypedDicts can also by used as targets of type aliases, but due to
+ambiguity with a regular variables it is only allowed for (newer) explicit
+type alias forms:
+
+.. code-block:: python
+
+    from typing import TypeAlias
+
+    X = {"a": int, "b": int}  # creates a variable with type dict[str, type[int]]
+    Y: TypeAlias = {"a": int, "b": int}  # creates a type alias
+    type Z = {"a": int, "b": int}  # same as above (Python 3.12+ only)
+
+Also, due to incompatibility with runtime type-checking it is strongly recommended
+to *not* use inline syntax in union types.
diff --git a/misc/analyze_cache.py b/misc/analyze_cache.py
index 45c44139b473..0a05493b77a3 100644
--- a/misc/analyze_cache.py
+++ b/misc/analyze_cache.py
@@ -6,12 +6,13 @@
 import os
 import os.path
 from collections import Counter
-from typing import Any, Dict, Iterable
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from collections.abc import Iterable
+from typing import Any, Final
+from typing_extensions import TypeAlias as _TypeAlias
 
 ROOT: Final = ".mypy_cache/3.5"
 
-JsonDict: _TypeAlias = Dict[str, Any]
+JsonDict: _TypeAlias = dict[str, Any]
 
 
 class CacheData:
diff --git a/misc/apply-cache-diff.py b/misc/apply-cache-diff.py
index 29c55247de92..8ede9766bd06 100644
--- a/misc/apply-cache-diff.py
+++ b/misc/apply-cache-diff.py
@@ -8,13 +8,13 @@
 from __future__ import annotations
 
 import argparse
-import json
 import os
 import sys
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from mypy.metastore import FilesystemMetadataStore, MetadataStore, SqliteMetadataStore
+from mypy.util import json_dumps, json_loads
 
 
 def make_cache(input_dir: str, sqlite: bool) -> MetadataStore:
@@ -26,10 +26,10 @@ def make_cache(input_dir: str, sqlite: bool) -> MetadataStore:
 
 def apply_diff(cache_dir: str, diff_file: str, sqlite: bool = False) -> None:
     cache = make_cache(cache_dir, sqlite)
-    with open(diff_file) as f:
-        diff = json.load(f)
+    with open(diff_file, "rb") as f:
+        diff = json_loads(f.read())
 
-    old_deps = json.loads(cache.read("@deps.meta.json"))
+    old_deps = json_loads(cache.read("@deps.meta.json"))
 
     for file, data in diff.items():
         if data is None:
@@ -37,10 +37,10 @@ def apply_diff(cache_dir: str, diff_file: str, sqlite: bool = False) -> None:
         else:
             cache.write(file, data)
             if file.endswith(".meta.json") and "@deps" not in file:
-                meta = json.loads(data)
+                meta = json_loads(data)
                 old_deps["snapshot"][meta["id"]] = meta["hash"]
 
-    cache.write("@deps.meta.json", json.dumps(old_deps))
+    cache.write("@deps.meta.json", json_dumps(old_deps))
 
     cache.commit()
 
diff --git a/misc/async_matrix.py b/misc/async_matrix.py
deleted file mode 100644
index d4612dd81799..000000000000
--- a/misc/async_matrix.py
+++ /dev/null
@@ -1,149 +0,0 @@
-#!/usr/bin/env python3
-"""Test various combinations of generators/coroutines.
-
-This was used to cross-check the errors in the test case
-testFullCoroutineMatrix in test-data/unit/check-async-await.test.
-"""
-
-from __future__ import annotations
-
-import sys
-from types import coroutine
-from typing import Any, Awaitable, Generator, Iterator
-
-# The various things you might try to use in `await` or `yield from`.
-
-
-def plain_generator() -> Generator[str, None, int]:
-    yield "a"
-    return 1
-
-
-async def plain_coroutine() -> int:
-    return 1
-
-
-@coroutine
-def decorated_generator() -> Generator[str, None, int]:
-    yield "a"
-    return 1
-
-
-@coroutine
-async def decorated_coroutine() -> int:
-    return 1
-
-
-class It(Iterator[str]):
-    stop = False
-
-    def __iter__(self) -> It:
-        return self
-
-    def __next__(self) -> str:
-        if self.stop:
-            raise StopIteration("end")
-        else:
-            self.stop = True
-            return "a"
-
-
-def other_iterator() -> It:
-    return It()
-
-
-class Aw(Awaitable[int]):
-    def __await__(self) -> Generator[str, Any, int]:
-        yield "a"
-        return 1
-
-
-def other_coroutine() -> Aw:
-    return Aw()
-
-
-# The various contexts in which `await` or `yield from` might occur.
-
-
-def plain_host_generator(func) -> Generator[str, None, None]:
-    yield "a"
-    x = 0
-    f = func()
-    try:
-        x = yield from f  # noqa: F841
-    finally:
-        try:
-            f.close()
-        except AttributeError:
-            pass
-
-
-async def plain_host_coroutine(func) -> None:
-    x = 0
-    x = await func()  # noqa: F841
-
-
-@coroutine
-def decorated_host_generator(func) -> Generator[str, None, None]:
-    yield "a"
-    x = 0
-    f = func()
-    try:
-        x = yield from f  # noqa: F841
-    finally:
-        try:
-            f.close()
-        except AttributeError:
-            pass
-
-
-@coroutine
-async def decorated_host_coroutine(func) -> None:
-    x = 0
-    x = await func()  # noqa: F841
-
-
-# Main driver.
-
-
-def main() -> None:
-    verbose = "-v" in sys.argv
-    for host in [
-        plain_host_generator,
-        plain_host_coroutine,
-        decorated_host_generator,
-        decorated_host_coroutine,
-    ]:
-        print()
-        print("==== Host:", host.__name__)
-        for func in [
-            plain_generator,
-            plain_coroutine,
-            decorated_generator,
-            decorated_coroutine,
-            other_iterator,
-            other_coroutine,
-        ]:
-            print("  ---- Func:", func.__name__)
-            try:
-                f = host(func)
-                for i in range(10):
-                    try:
-                        x = f.send(None)
-                        if verbose:
-                            print("    yield:", x)
-                    except StopIteration as e:
-                        if verbose:
-                            print("    stop:", e.value)
-                        break
-                else:
-                    if verbose:
-                        print("    ???? still going")
-            except Exception as e:
-                print("    error:", repr(e))
-
-
-# Run main().
-
-if __name__ == "__main__":
-    main()
diff --git a/misc/build-debug-python.sh b/misc/build-debug-python.sh
index f652d6ad9937..8dd1bff4c9ed 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/misc/cherry-pick-typeshed.py b/misc/cherry-pick-typeshed.py
index af08009c2a8f..7e3b8b56e65f 100644
--- a/misc/cherry-pick-typeshed.py
+++ b/misc/cherry-pick-typeshed.py
@@ -53,6 +53,7 @@ def main() -> None:
                 "--index",
                 "--directory=mypy/typeshed",
                 "--exclude=**/tests/**",
+                "--exclude=**/test_cases/**",
                 diff_file,
             ],
             check=True,
diff --git a/misc/diff-cache.py b/misc/diff-cache.py
index 15d3e5a83983..8441caf81304 100644
--- a/misc/diff-cache.py
+++ b/misc/diff-cache.py
@@ -8,7 +8,6 @@
 from __future__ import annotations
 
 import argparse
-import json
 import os
 import sys
 from collections import defaultdict
@@ -17,6 +16,7 @@
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from mypy.metastore import FilesystemMetadataStore, MetadataStore, SqliteMetadataStore
+from mypy.util import json_dumps, json_loads
 
 
 def make_cache(input_dir: str, sqlite: bool) -> MetadataStore:
@@ -33,7 +33,7 @@ def merge_deps(all: dict[str, set[str]], new: dict[str, set[str]]) -> None:
 
 def load(cache: MetadataStore, s: str) -> Any:
     data = cache.read(s)
-    obj = json.loads(data)
+    obj = json_loads(data)
     if s.endswith(".meta.json"):
         # For meta files, zero out the mtimes and sort the
         # dependencies to avoid spurious conflicts
@@ -73,7 +73,7 @@ def main() -> None:
     type_misses: dict[str, int] = defaultdict(int)
     type_hits: dict[str, int] = defaultdict(int)
 
-    updates: dict[str, str | None] = {}
+    updates: dict[str, bytes | None] = {}
 
     deps1: dict[str, set[str]] = {}
     deps2: dict[str, set[str]] = {}
@@ -96,7 +96,7 @@ def main() -> None:
             # so we can produce a much smaller direct diff of them.
             if ".deps." not in s:
                 if obj2 is not None:
-                    updates[s] = json.dumps(obj2)
+                    updates[s] = json_dumps(obj2)
                 else:
                     updates[s] = None
             elif obj2:
@@ -122,7 +122,7 @@ def main() -> None:
     merge_deps(new_deps, root_deps)
 
     new_deps_json = {k: list(v) for k, v in new_deps.items() if v}
-    updates["@root.deps.json"] = json.dumps(new_deps_json)
+    updates["@root.deps.json"] = json_dumps(new_deps_json)
 
     # Drop updates to deps.meta.json for size reasons. The diff
     # applier will manually fix it up.
@@ -136,8 +136,8 @@ def main() -> None:
         print("hits", type_hits)
         print("misses", type_misses)
 
-    with open(args.output, "w") as f:
-        json.dump(updates, f)
+    with open(args.output, "wb") as f:
+        f.write(json_dumps(updates))
 
 
 if __name__ == "__main__":
diff --git a/misc/docker/README.md b/misc/docker/README.md
index 839f9761cb03..0e9a3a80ff0e 100644
--- a/misc/docker/README.md
+++ b/misc/docker/README.md
@@ -12,7 +12,7 @@ Why use Docker?
 Mypyc tests can be significantly faster in a Docker container than
 running natively on macOS.
 
-Also, if it's inconvient to install the necessary dependencies on the
+Also, if it's inconvenient to install the necessary dependencies on the
 host operating system, or there are issues getting some tests to pass
 on the host operating system, using a container can be an easy
 workaround.
diff --git a/misc/dump-ast.py b/misc/dump-ast.py
index 6f70bbc8c9ed..7fdf905bae0b 100755
--- a/misc/dump-ast.py
+++ b/misc/dump-ast.py
@@ -9,7 +9,7 @@
 import sys
 
 from mypy import defaults
-from mypy.errors import CompileError
+from mypy.errors import CompileError, Errors
 from mypy.options import Options
 from mypy.parse import parse
 
@@ -19,7 +19,7 @@ def dump(fname: str, python_version: tuple[int, int], quiet: bool = False) -> No
     options.python_version = python_version
     with open(fname, "rb") as f:
         s = f.read()
-        tree = parse(s, fname, None, errors=None, options=options)
+        tree = parse(s, fname, None, errors=Errors(options), options=options)
         if not quiet:
             print(tree)
 
diff --git a/misc/fix_annotate.py b/misc/fix_annotate.py
deleted file mode 100644
index fc8ac27466d5..000000000000
--- a/misc/fix_annotate.py
+++ /dev/null
@@ -1,218 +0,0 @@
-"""Fixer for lib2to3 that inserts mypy annotations into all methods.
-
-The simplest way to run this is to copy it into lib2to3's "fixes"
-subdirectory and then run "2to3 -f annotate" over your files.
-
-The fixer transforms e.g.
-
-  def foo(self, bar, baz=12):
-      return bar + baz
-
-into
-
-  def foo(self, bar, baz=12):
-      # type: (Any, int) -> Any
-      return bar + baz
-
-It does not do type inference but it recognizes some basic default
-argument values such as numbers and strings (and assumes their type
-implies the argument type).
-
-It also uses some basic heuristics to decide whether to ignore the
-first argument:
-
-  - always if it's named 'self'
-  - if there's a @classmethod decorator
-
-Finally, it knows that __init__() is supposed to return None.
-"""
-
-from __future__ import annotations
-
-import os
-import re
-from lib2to3.fixer_base import BaseFix
-from lib2to3.fixer_util import syms, token, touch_import
-from lib2to3.patcomp import compile_pattern
-from lib2to3.pytree import Leaf, Node
-
-
-class FixAnnotate(BaseFix):
-    # This fixer is compatible with the bottom matcher.
-    BM_compatible = True
-
-    # This fixer shouldn't run by default.
-    explicit = True
-
-    # The pattern to match.
-    PATTERN = """
-              funcdef< 'def' name=any parameters< '(' [args=any] ')' > ':' suite=any+ >
-              """
-
-    counter = None if not os.getenv("MAXFIXES") else int(os.getenv("MAXFIXES"))
-
-    def transform(self, node, results):
-        if FixAnnotate.counter is not None:
-            if FixAnnotate.counter <= 0:
-                return
-        suite = results["suite"]
-        children = suite[0].children
-
-        # NOTE: I've reverse-engineered the structure of the parse tree.
-        # It's always a list of nodes, the first of which contains the
-        # entire suite.  Its children seem to be:
-        #
-        #   [0] NEWLINE
-        #   [1] INDENT
-        #   [2...n-2] statements (the first may be a docstring)
-        #   [n-1] DEDENT
-        #
-        # Comments before the suite are part of the INDENT's prefix.
-        #
-        # "Compact" functions (e.g. "def foo(x, y): return max(x, y)")
-        # have a different structure that isn't matched by PATTERN.
-        #
-        #   print('-'*60)
-        #   print(node)
-        #   for i, ch in enumerate(children):
-        #       print(i, repr(ch.prefix), repr(ch))
-        #
-        # Check if there's already an annotation.
-        for ch in children:
-            if ch.prefix.lstrip().startswith("# type:"):
-                return  # There's already a # type: comment here; don't change anything.
-
-        # Compute the annotation
-        annot = self.make_annotation(node, results)
-
-        # Insert '# type: {annot}' comment.
-        # For reference, see lib2to3/fixes/fix_tuple_params.py in stdlib.
-        if len(children) >= 2 and children[1].type == token.INDENT:
-            children[1].prefix = "{}# type: {}\n{}".format(
-                children[1].value, annot, children[1].prefix
-            )
-            children[1].changed()
-            if FixAnnotate.counter is not None:
-                FixAnnotate.counter -= 1
-
-        # Also add 'from typing import Any' at the top.
-        if "Any" in annot:
-            touch_import("typing", "Any", node)
-
-    def make_annotation(self, node, results):
-        name = results["name"]
-        assert isinstance(name, Leaf), repr(name)
-        assert name.type == token.NAME, repr(name)
-        decorators = self.get_decorators(node)
-        is_method = self.is_method(node)
-        if name.value == "__init__" or not self.has_return_exprs(node):
-            restype = "None"
-        else:
-            restype = "Any"
-        args = results.get("args")
-        argtypes = []
-        if isinstance(args, Node):
-            children = args.children
-        elif isinstance(args, Leaf):
-            children = [args]
-        else:
-            children = []
-        # Interpret children according to the following grammar:
-        # (('*'|'**')? NAME ['=' expr] ','?)*
-        stars = inferred_type = ""
-        in_default = False
-        at_start = True
-        for child in children:
-            if isinstance(child, Leaf):
-                if child.value in ("*", "**"):
-                    stars += child.value
-                elif child.type == token.NAME and not in_default:
-                    if not is_method or not at_start or "staticmethod" in decorators:
-                        inferred_type = "Any"
-                    else:
-                        # Always skip the first argument if it's named 'self'.
-                        # Always skip the first argument of a class method.
-                        if child.value == "self" or "classmethod" in decorators:
-                            pass
-                        else:
-                            inferred_type = "Any"
-                elif child.value == "=":
-                    in_default = True
-                elif in_default and child.value != ",":
-                    if child.type == token.NUMBER:
-                        if re.match(r"\d+[lL]?$", child.value):
-                            inferred_type = "int"
-                        else:
-                            inferred_type = "float"  # TODO: complex?
-                    elif child.type == token.STRING:
-                        if child.value.startswith(("u", "U")):
-                            inferred_type = "unicode"
-                        else:
-                            inferred_type = "str"
-                    elif child.type == token.NAME and child.value in ("True", "False"):
-                        inferred_type = "bool"
-                elif child.value == ",":
-                    if inferred_type:
-                        argtypes.append(stars + inferred_type)
-                    # Reset
-                    stars = inferred_type = ""
-                    in_default = False
-                    at_start = False
-        if inferred_type:
-            argtypes.append(stars + inferred_type)
-        return "(" + ", ".join(argtypes) + ") -> " + restype
-
-    # The parse tree has a different shape when there is a single
-    # decorator vs. when there are multiple decorators.
-    DECORATED = "decorated< (d=decorator | decorators< dd=decorator+ >) funcdef >"
-    decorated = compile_pattern(DECORATED)
-
-    def get_decorators(self, node):
-        """Return a list of decorators found on a function definition.
-
-        This is a list of strings; only simple decorators
-        (e.g. @staticmethod) are returned.
-
-        If the function is undecorated or only non-simple decorators
-        are found, return [].
-        """
-        if node.parent is None:
-            return []
-        results = {}
-        if not self.decorated.match(node.parent, results):
-            return []
-        decorators = results.get("dd") or [results["d"]]
-        decs = []
-        for d in decorators:
-            for child in d.children:
-                if isinstance(child, Leaf) and child.type == token.NAME:
-                    decs.append(child.value)
-        return decs
-
-    def is_method(self, node):
-        """Return whether the node occurs (directly) inside a class."""
-        node = node.parent
-        while node is not None:
-            if node.type == syms.classdef:
-                return True
-            if node.type == syms.funcdef:
-                return False
-            node = node.parent
-        return False
-
-    RETURN_EXPR = "return_stmt< 'return' any >"
-    return_expr = compile_pattern(RETURN_EXPR)
-
-    def has_return_exprs(self, node):
-        """Traverse the tree below node looking for 'return expr'.
-
-        Return True if at least 'return expr' is found, False if not.
-        (If both 'return' and 'return expr' are found, return True.)
-        """
-        results = {}
-        if self.return_expr.match(node, results):
-            return True
-        return any(
-            child.type not in (syms.funcdef, syms.classdef) and self.has_return_exprs(child)
-            for child in node.children
-        )
diff --git a/misc/gen_blog_post_html.py b/misc/gen_blog_post_html.py
new file mode 100644
index 000000000000..1c2d87648604
--- /dev/null
+++ b/misc/gen_blog_post_html.py
@@ -0,0 +1,193 @@
+"""Converter from CHANGELOG.md (Markdown) to HTML suitable for a mypy blog post.
+
+How to use:
+
+1. Write release notes in CHANGELOG.md.
+2. Make sure the heading for the next release is of form `## Mypy X.Y`.
+2. Run `misc/gen_blog_post_html.py X.Y > target.html`.
+4. Manually inspect and tweak the result.
+
+Notes:
+
+* There are some fragile assumptions. Double check the output.
+"""
+
+import argparse
+import html
+import os
+import re
+import sys
+
+
+def format_lists(h: str) -> str:
+    a = h.splitlines()
+    r = []
+    i = 0
+    bullets = ("- ", "* ", " * ")
+    while i < len(a):
+        if a[i].startswith(bullets):
+            r.append("<p><ul>")
+            while i < len(a) and a[i].startswith(bullets):
+                r.append("<li>%s" % a[i][2:].lstrip())
+                i += 1
+            r.append("</ul>")
+        else:
+            r.append(a[i])
+            i += 1
+    return "\n".join(r)
+
+
+def format_code(h: str) -> str:
+    a = h.splitlines()
+    r = []
+    i = 0
+    while i < len(a):
+        if a[i].startswith("    ") or a[i].startswith("```"):
+            indent = a[i].startswith("    ")
+            language: str = ""
+            if not indent:
+                language = a[i][3:]
+                i += 1
+            if language:
+                r.append(f'<pre><code class="language-{language}">')
+            else:
+                r.append("<pre><code>")
+            while i < len(a) and (
+                (indent and a[i].startswith("    ")) or (not indent and not a[i].startswith("```"))
+            ):
+                # Undo &gt; and &lt;
+                line = a[i].replace("&gt;", ">").replace("&lt;", "<")
+                if indent:
+                    # Undo this extra level of indentation so it looks nice with
+                    # syntax highlighting CSS.
+                    line = line[4:]
+                r.append(html.escape(line))
+                i += 1
+            r.append("</code></pre>")
+            if not indent and a[i].startswith("```"):
+                i += 1
+        else:
+            r.append(a[i])
+            i += 1
+    formatted = "\n".join(r)
+    # remove empty first line for code blocks
+    return re.sub(r"<code([^\>]*)>\n", r"<code\1>", formatted)
+
+
+def convert(src: str) -> str:
+    h = src
+
+    # Replace < and >.
+    h = re.sub(r"<", "&lt;", h)
+    h = re.sub(r">", "&gt;", h)
+
+    # Title
+    h = re.sub(r"^## (Mypy [0-9.]+)", r"<h1>\1 Released</h1>", h, flags=re.MULTILINE)
+
+    # Subheadings
+    h = re.sub(r"\n### ([A-Z`].*)\n", r"\n<h2>\1</h2>\n", h)
+
+    # Sub-subheadings
+    h = re.sub(r"\n\*\*([A-Z_`].*)\*\*\n", r"\n<h3>\1</h3>\n", h)
+    h = re.sub(r"\n`\*\*([A-Z_`].*)\*\*\n", r"\n<h3>`\1</h3>\n", h)
+
+    # Translate `**`
+    h = re.sub(r"`\*\*`", "<tt>**</tt>", h)
+
+    # Paragraphs
+    h = re.sub(r"\n\n([A-Z])", r"\n\n<p>\1", h)
+
+    # Bullet lists
+    h = format_lists(h)
+
+    # Code blocks
+    h = format_code(h)
+
+    # Code fragments
+    h = re.sub(r"``([^`]+)``", r"<tt>\1</tt>", h)
+    h = re.sub(r"`([^`]+)`", r"<tt>\1</tt>", h)
+
+    # Remove **** noise
+    h = re.sub(r"\*\*\*\*", "", h)
+
+    # Bold text
+    h = re.sub(r"\*\*([A-Za-z].*?)\*\*", r" <b>\1</b>", h)
+
+    # Emphasized text
+    h = re.sub(r" \*([A-Za-z].*?)\*", r" <i>\1</i>", h)
+
+    # Remove redundant PR links to avoid double links (they will be generated below)
+    h = re.sub(r"\[(#[0-9]+)\]\(https://github.com/python/mypy/pull/[0-9]+/?\)", r"\1", h)
+
+    # Issue and PR links
+    h = re.sub(r"\((#[0-9]+)\) +\(([^)]+)\)", r"(\2, \1)", h)
+    h = re.sub(
+        r"fixes #([0-9]+)",
+        r'fixes issue <a href="https://github.com/python/mypy/issues/\1">\1</a>',
+        h,
+    )
+    # Note the leading space to avoid stomping on strings that contain #\d in the middle (such as
+    # links to PRs in other repos)
+    h = re.sub(r" #([0-9]+)", r' PR <a href="https://github.com/python/mypy/pull/\1">\1</a>', h)
+    h = re.sub(r"\) \(PR", ", PR", h)
+
+    # Markdown links
+    h = re.sub(r"\[([^]]*)\]\(([^)]*)\)", r'<a href="\2">\1</a>', h)
+
+    # Add random links in case they are missing
+    h = re.sub(
+        r"contributors to typeshed:",
+        'contributors to <a href="https://github.com/python/typeshed">typeshed</a>:',
+        h,
+    )
+
+    # Add top-level HTML tags and headers for syntax highlighting css/js.
+    # We're configuring hljs to highlight python and bash code. We can remove
+    # this configure call to make it try all the languages it supports.
+    h = f"""<html>
+<meta charset="utf-8" />
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/a11y-light.min.css">
+<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
+<script>hljs.configure({{languages:["python","bash"]}});hljs.highlightAll();</script>
+<body>
+{h}
+</body>
+</html>"""
+
+    return h
+
+
+def extract_version(src: str, version: str) -> str:
+    a = src.splitlines()
+    i = 0
+    heading = f"## Mypy {version}"
+    while i < len(a):
+        if a[i].strip() == heading:
+            break
+        i += 1
+    else:
+        raise RuntimeError(f"Can't find heading {heading!r}")
+    j = i + 1
+    while not a[j].startswith("## "):
+        j += 1
+    return "\n".join(a[i:j])
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate HTML release blog post based on CHANGELOG.md and write to stdout."
+    )
+    parser.add_argument("version", help="mypy version, in form X.Y or X.Y.Z")
+    args = parser.parse_args()
+    version: str = args.version
+    if not re.match(r"[0-9]+(\.[0-9]+)+$", version):
+        sys.exit(f"error: Version must be of form X.Y or X.Y.Z, not {version!r}")
+    changelog_path = os.path.join(os.path.dirname(__file__), os.path.pardir, "CHANGELOG.md")
+    src = open(changelog_path).read()
+    src = extract_version(src, version)
+    dst = convert(src)
+    sys.stdout.write(dst)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/misc/generate_changelog.py b/misc/generate_changelog.py
new file mode 100644
index 000000000000..c53a06e39133
--- /dev/null
+++ b/misc/generate_changelog.py
@@ -0,0 +1,201 @@
+"""Generate the changelog for a mypy release."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+
+
+def find_all_release_branches() -> list[tuple[int, int]]:
+    result = subprocess.run(["git", "branch", "-r"], text=True, capture_output=True, check=True)
+    versions = []
+    for line in result.stdout.splitlines():
+        line = line.strip()
+        if m := re.match(r"origin/release-([0-9]+)\.([0-9]+)$", line):
+            major = int(m.group(1))
+            minor = int(m.group(2))
+            versions.append((major, minor))
+    return versions
+
+
+def git_merge_base(rev1: str, rev2: str) -> str:
+    result = subprocess.run(
+        ["git", "merge-base", rev1, rev2], text=True, capture_output=True, check=True
+    )
+    return result.stdout.strip()
+
+
+@dataclass
+class CommitInfo:
+    commit: str
+    author: str
+    title: str
+    pr_number: int | None
+
+
+def normalize_author(author: str) -> str:
+    # Some ad-hoc rules to get more consistent author names.
+    if author == "AlexWaygood":
+        return "Alex Waygood"
+    elif author == "jhance":
+        return "Jared Hance"
+    return author
+
+
+def git_commit_log(rev1: str, rev2: str) -> list[CommitInfo]:
+    result = subprocess.run(
+        ["git", "log", "--pretty=%H\t%an\t%s", f"{rev1}..{rev2}"],
+        text=True,
+        capture_output=True,
+        check=True,
+    )
+    commits = []
+    for line in result.stdout.splitlines():
+        commit, author, title = line.strip().split("\t", 2)
+        pr_number = None
+        if m := re.match(r".*\(#([0-9]+)\) *$", title):
+            pr_number = int(m.group(1))
+            title = re.sub(r" *\(#[0-9]+\) *$", "", title)
+
+        author = normalize_author(author)
+        entry = CommitInfo(commit, author, title, pr_number)
+        commits.append(entry)
+    return commits
+
+
+def filter_omitted_commits(commits: list[CommitInfo]) -> list[CommitInfo]:
+    result = []
+    for c in commits:
+        title = c.title
+        keep = True
+        if title.startswith("Sync typeshed"):
+            # Typeshed syncs aren't mentioned in release notes
+            keep = False
+        if title.startswith(
+            (
+                "Revert sum literal integer change",
+                "Remove use of LiteralString in builtins",
+                "Revert typeshed ctypes change",
+            )
+        ):
+            # These are generated by a typeshed sync.
+            keep = False
+        if re.search(r"(bump|update).*version.*\+dev", title.lower()):
+            # Version number updates aren't mentioned
+            keep = False
+        if "pre-commit autoupdate" in title:
+            keep = False
+        if title.startswith(("Update commit hashes", "Update hashes")):
+            # Internal tool change
+            keep = False
+        if keep:
+            result.append(c)
+    return result
+
+
+def normalize_title(title: str) -> str:
+    # We sometimes add a title prefix when cherry-picking commits to a
+    # release branch. Attempt to remove these prefixes so that we can
+    # match them to the corresponding master branch.
+    if m := re.match(r"\[release [0-9.]+\] *", title, flags=re.I):
+        title = title.replace(m.group(0), "")
+    return title
+
+
+def filter_out_commits_from_old_release_branch(
+    new_commits: list[CommitInfo], old_commits: list[CommitInfo]
+) -> list[CommitInfo]:
+    old_titles = {normalize_title(commit.title) for commit in old_commits}
+    result = []
+    for commit in new_commits:
+        drop = False
+        if normalize_title(commit.title) in old_titles:
+            drop = True
+        if normalize_title(f"{commit.title} (#{commit.pr_number})") in old_titles:
+            drop = True
+        if not drop:
+            result.append(commit)
+        else:
+            print(f'NOTE: Drop "{commit.title}", since it was in previous release branch')
+    return result
+
+
+def find_changes_between_releases(old_branch: str, new_branch: str) -> list[CommitInfo]:
+    merge_base = git_merge_base(old_branch, new_branch)
+    print(f"Merge base: {merge_base}")
+    new_commits = git_commit_log(merge_base, new_branch)
+    old_commits = git_commit_log(merge_base, old_branch)
+
+    # Filter out some commits that won't be mentioned in release notes.
+    new_commits = filter_omitted_commits(new_commits)
+
+    # Filter out commits cherry-picked to old branch.
+    new_commits = filter_out_commits_from_old_release_branch(new_commits, old_commits)
+
+    return new_commits
+
+
+def format_changelog_entry(c: CommitInfo) -> str:
+    """
+    s = f" * {c.commit[:9]} - {c.title}"
+    if c.pr_number:
+        s += f" (#{c.pr_number})"
+    s += f" ({c.author})"
+    """
+    title = c.title.removesuffix(".")
+    s = f" * {title} ({c.author}"
+    if c.pr_number:
+        s += f", PR [{c.pr_number}](https://github.com/python/mypy/pull/{c.pr_number})"
+    s += ")"
+
+    return s
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("version", help="target mypy version (form X.Y)")
+    parser.add_argument("--local", action="store_true")
+    args = parser.parse_args()
+    version: str = args.version
+    local: bool = args.local
+
+    if not re.match(r"[0-9]+\.[0-9]+$", version):
+        sys.exit(f"error: Release must be of form X.Y (not {version!r})")
+    major, minor = (int(component) for component in version.split("."))
+
+    if not local:
+        print("Running 'git fetch' to fetch all release branches...")
+        subprocess.run(["git", "fetch"], check=True)
+
+    if minor > 0:
+        prev_major = major
+        prev_minor = minor - 1
+    else:
+        # For a x.0 release, the previous release is the most recent (x-1).y release.
+        all_releases = sorted(find_all_release_branches())
+        if (major, minor) not in all_releases:
+            sys.exit(f"error: Can't find release branch for {major}.{minor} at origin")
+        for i in reversed(range(len(all_releases))):
+            if all_releases[i][0] == major - 1:
+                prev_major, prev_minor = all_releases[i]
+                break
+        else:
+            sys.exit("error: Could not determine previous release")
+    print(f"Generating changelog for {major}.{minor}")
+    print(f"Previous release was     {prev_major}.{prev_minor}")
+
+    new_branch = f"origin/release-{major}.{minor}"
+    old_branch = f"origin/release-{prev_major}.{prev_minor}"
+
+    changes = find_changes_between_releases(old_branch, new_branch)
+
+    print()
+    for c in changes:
+        print(format_changelog_entry(c))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/misc/incremental_checker.py b/misc/incremental_checker.py
index 85239b6462b8..a9ed61d13414 100755
--- a/misc/incremental_checker.py
+++ b/misc/incremental_checker.py
@@ -44,15 +44,15 @@
 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, 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"
 MYPY_TARGET_FILE: Final = "mypy"
 DAEMON_CMD: Final = ["python3", "-m", "mypy.dmypy"]
 
-JsonDict: _TypeAlias = Dict[str, Any]
+JsonDict: _TypeAlias = dict[str, Any]
 
 
 def print_offset(text: str, indent_length: int = 4) -> None:
diff --git a/misc/perf_compare.py b/misc/perf_compare.py
index be05bb6ddc32..025d4065561e 100644
--- a/misc/perf_compare.py
+++ b/misc/perf_compare.py
@@ -2,14 +2,14 @@
 
 Simple usage:
 
-  python misc/perf_compare.py my-branch master ...
+  python misc/perf_compare.py master my-branch ...
 
 What this does:
 
  * Create a temp clone of the mypy repo for each target commit to measure
  * Checkout a target commit in each of the clones
  * Compile mypyc in each of the clones *in parallel*
- * Create another temp clone of the mypy repo as the code to check
+ * Create another temp clone of the first provided revision (or, with -r, a foreign repo) as the code to check
  * Self check with each of the compiled mypys N times
  * Report the average runtimes and relative performance
  * Remove the temp clones
@@ -25,8 +25,8 @@
 import statistics
 import subprocess
 import sys
-import threading
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 
 def heading(s: str) -> None:
@@ -39,73 +39,157 @@ def build_mypy(target_dir: str) -> None:
     env = os.environ.copy()
     env["CC"] = "clang"
     env["MYPYC_OPT_LEVEL"] = "2"
+    env["PYTHONHASHSEED"] = "1"
     cmd = [sys.executable, "setup.py", "--use-mypyc", "build_ext", "--inplace"]
     subprocess.run(cmd, env=env, check=True, cwd=target_dir)
 
 
-def clone(target_dir: str, commit: str | None) -> None:
-    heading(f"Cloning mypy to {target_dir}")
-    repo_dir = os.getcwd()
+def clone(target_dir: str, commit: str | None, repo_source: str | None = None) -> None:
+    source_name = repo_source or "mypy"
+    heading(f"Cloning {source_name} to {target_dir}")
+    if repo_source is None:
+        repo_source = os.getcwd()
     if os.path.isdir(target_dir):
         print(f"{target_dir} exists: deleting")
         shutil.rmtree(target_dir)
-    subprocess.run(["git", "clone", repo_dir, target_dir], check=True)
+    subprocess.run(["git", "clone", repo_source, target_dir], check=True)
     if commit:
         subprocess.run(["git", "checkout", commit], check=True, cwd=target_dir)
 
 
-def run_benchmark(compiled_dir: str, check_dir: str) -> float:
+def edit_python_file(fnam: str) -> None:
+    with open(fnam) as f:
+        data = f.read()
+    data += "\n#"
+    with open(fnam, "w") as f:
+        f.write(data)
+
+
+def run_benchmark(
+    compiled_dir: str, check_dir: str, *, incremental: bool, code: str | None, foreign: bool | None
+) -> float:
     cache_dir = os.path.join(compiled_dir, ".mypy_cache")
-    if os.path.isdir(cache_dir):
+    if os.path.isdir(cache_dir) and not incremental:
         shutil.rmtree(cache_dir)
     env = os.environ.copy()
     env["PYTHONPATH"] = os.path.abspath(compiled_dir)
+    env["PYTHONHASHSEED"] = "1"
     abschk = os.path.abspath(check_dir)
-    cmd = [
-        sys.executable,
-        "-m",
-        "mypy",
-        "--config-file",
-        os.path.join(abschk, "mypy_self_check.ini"),
-    ]
-    cmd += glob.glob(os.path.join(abschk, "mypy/*.py"))
-    cmd += glob.glob(os.path.join(abschk, "mypy/*/*.py"))
+    cmd = [sys.executable, "-m", "mypy"]
+    if code:
+        cmd += ["-c", code]
+    elif foreign:
+        pass
+    else:
+        cmd += ["--config-file", os.path.join(abschk, "mypy_self_check.ini")]
+        cmd += glob.glob(os.path.join(abschk, "mypy/*.py"))
+        cmd += glob.glob(os.path.join(abschk, "mypy/*/*.py"))
+        if incremental:
+            # Update a few files to force non-trivial incremental run
+            edit_python_file(os.path.join(abschk, "mypy/__main__.py"))
+            edit_python_file(os.path.join(abschk, "mypy/test/testcheck.py"))
     t0 = time.time()
     # Ignore errors, since some commits being measured may generate additional errors.
-    subprocess.run(cmd, cwd=compiled_dir, env=env)
+    if foreign:
+        subprocess.run(cmd, cwd=check_dir, env=env)
+    else:
+        subprocess.run(cmd, cwd=compiled_dir, env=env)
     return time.time() - t0
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("commit", nargs="+")
+    whole_program_time_0 = time.time()
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description=__doc__,
+        epilog="Remember: you usually want the first argument to this command to be 'master'.",
+    )
+    parser.add_argument(
+        "--incremental",
+        default=False,
+        action="store_true",
+        help="measure incremental run (fully cached)",
+    )
+    parser.add_argument(
+        "--dont-setup",
+        default=False,
+        action="store_true",
+        help="don't make the clones or compile mypy, just run the performance measurement benchmark "
+        + "(this will fail unless the clones already exist, such as from a previous run that was canceled before it deleted them)",
+    )
+    parser.add_argument(
+        "--num-runs",
+        metavar="N",
+        default=15,
+        type=int,
+        help="set number of measurements to perform (default=15)",
+    )
+    parser.add_argument(
+        "-j",
+        metavar="N",
+        default=8,
+        type=int,
+        help="set maximum number of parallel builds (default=8)",
+    )
+    parser.add_argument(
+        "-r",
+        metavar="FOREIGN_REPOSITORY",
+        default=None,
+        type=str,
+        help="measure time to typecheck the project at FOREIGN_REPOSITORY instead of mypy self-check; "
+        + "the provided value must be the URL or path of a git repo "
+        + "(note that this script will take no special steps to *install* the foreign repo, so you will probably get a lot of missing import errors)",
+    )
+    parser.add_argument(
+        "-c",
+        metavar="CODE",
+        default=None,
+        type=str,
+        help="measure time to type check Python code fragment instead of mypy self-check",
+    )
+    parser.add_argument(
+        "commit",
+        nargs="+",
+        help="git revision(s), e.g. branch name or commit id, to measure the performance of",
+    )
     args = parser.parse_args()
+    incremental: bool = args.incremental
+    dont_setup: bool = args.dont_setup
     commits = args.commit
-    num_runs = 16
+    num_runs: int = args.num_runs + 1
+    max_workers: int = args.j
+    code: str | None = args.c
+    foreign_repo: str | None = args.r
 
     if not (os.path.isdir(".git") and os.path.isdir("mypyc")):
-        sys.exit("error: Run this the mypy repo root")
+        sys.exit("error: You must run this script from the mypy repo root")
 
-    build_threads = []
     target_dirs = []
     for i, commit in enumerate(commits):
         target_dir = f"mypy.{i}.tmpdir"
         target_dirs.append(target_dir)
-        clone(target_dir, commit)
-        t = threading.Thread(target=lambda: build_mypy(target_dir))
-        t.start()
-        build_threads.append(t)
+        if not dont_setup:
+            clone(target_dir, commit)
 
-    self_check_dir = "mypy.self.tmpdir"
-    clone(self_check_dir, commits[0])
+    if foreign_repo:
+        check_dir = "mypy.foreign.tmpdir"
+        if not dont_setup:
+            clone(check_dir, None, foreign_repo)
+    else:
+        check_dir = "mypy.self.tmpdir"
+        if not dont_setup:
+            clone(check_dir, commits[0])
 
-    heading("Compiling mypy")
-    print("(This will take a while...)")
+    if not dont_setup:
+        heading("Compiling mypy")
+        print("(This will take a while...)")
 
-    for t in build_threads:
-        t.join()
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(build_mypy, target_dir) for target_dir in target_dirs]
+            for future in as_completed(futures):
+                future.result()
 
-    print(f"Finished compiling mypy ({len(commits)} builds)")
+        print(f"Finished compiling mypy ({len(commits)} builds)")
 
     heading("Performing measurements")
 
@@ -118,7 +202,13 @@ def main() -> None:
         items = list(enumerate(commits))
         random.shuffle(items)
         for i, commit in items:
-            tt = run_benchmark(target_dirs[i], self_check_dir)
+            tt = run_benchmark(
+                target_dirs[i],
+                check_dir,
+                incremental=incremental,
+                code=code,
+                foreign=bool(foreign_repo),
+            )
             # Don't record the first warm-up run
             if n > 0:
                 print(f"{commit}: t={tt:.3f}s")
@@ -129,15 +219,28 @@ def main() -> None:
     first = -1.0
     for commit in commits:
         tt = statistics.mean(results[commit])
+        # pstdev (instead of stdev) is used here primarily to accommodate the case where num_runs=1
+        s = statistics.pstdev(results[commit]) if len(results[commit]) > 1 else 0
         if first < 0:
             delta = "0.0%"
             first = tt
         else:
             d = (tt / first) - 1
             delta = f"{d:+.1%}"
-        print(f"{commit:<25} {tt:.3f}s ({delta})")
-
-    shutil.rmtree(self_check_dir)
+        print(f"{commit:<25} {tt:.3f}s ({delta}) | stdev {s:.3f}s ")
+
+    t = int(time.time() - whole_program_time_0)
+    total_time_taken_formatted = ", ".join(
+        f"{v} {n if v==1 else n+'s'}"
+        for v, n in ((t // 3600, "hour"), (t // 60 % 60, "minute"), (t % 60, "second"))
+        if v
+    )
+    print(
+        "Total time taken by the whole benchmarking program (including any setup):",
+        total_time_taken_formatted,
+    )
+
+    shutil.rmtree(check_dir)
     for target_dir in target_dirs:
         shutil.rmtree(target_dir)
 
diff --git a/misc/remove-eol-whitespace.sh b/misc/remove-eol-whitespace.sh
deleted file mode 100644
index 5cf666997e34..000000000000
--- a/misc/remove-eol-whitespace.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh
-
-# Remove trailing whitespace from all non-binary files in a git repo.
-
-# From https://gist.github.com/dpaluy/3690668; originally from here:
-# https://unix.stackexchange.com/questions/36233/how-to-skip-file-in-sed-if-it-contains-regex/36240#36240
-
-git grep -I --name-only -z -e '' | xargs -0 sed -i -e 's/[ \t]\+\(\r\?\)$/\1/'
diff --git a/misc/sync-typeshed.py b/misc/sync-typeshed.py
index fc6cbc1d88e7..22023234710e 100644
--- a/misc/sync-typeshed.py
+++ b/misc/sync-typeshed.py
@@ -11,6 +11,7 @@
 
 import argparse
 import functools
+import glob
 import os
 import re
 import shutil
@@ -50,7 +51,9 @@ def update_typeshed(typeshed_dir: str, commit: str | None) -> str:
     # Remove existing stubs.
     shutil.rmtree(stdlib_dir)
     # Copy new stdlib stubs.
-    shutil.copytree(os.path.join(typeshed_dir, "stdlib"), stdlib_dir)
+    shutil.copytree(
+        os.path.join(typeshed_dir, "stdlib"), stdlib_dir, ignore=shutil.ignore_patterns("@tests")
+    )
     shutil.copy(os.path.join(typeshed_dir, "LICENSE"), os.path.join("mypy", "typeshed"))
     return commit
 
@@ -148,45 +151,66 @@ def main() -> None:
         if os.environ.get("GITHUB_TOKEN") is None:
             raise ValueError("GITHUB_TOKEN environment variable must be set")
 
-    branch_name = "mypybot/sync-typeshed"
-    subprocess.run(["git", "checkout", "-B", branch_name, "origin/master"], check=True)
-
-    if not args.typeshed_dir:
-        # Clone typeshed repo if no directory given.
-        with tempfile.TemporaryDirectory() as tempdir:
-            print(f"Cloning typeshed in {tempdir}...")
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Stash patches before checking out a new branch
+        typeshed_patches = os.path.join("misc", "typeshed_patches")
+        tmp_patches = os.path.join(tmpdir, "typeshed_patches")
+        shutil.copytree(typeshed_patches, tmp_patches)
+
+        branch_name = "mypybot/sync-typeshed"
+        subprocess.run(["git", "checkout", "-B", branch_name, "origin/master"], check=True)
+
+        # Copy the stashed patches back
+        shutil.rmtree(typeshed_patches, ignore_errors=True)
+        shutil.copytree(tmp_patches, typeshed_patches)
+        if subprocess.run(["git", "diff", "--quiet", "--exit-code"], check=False).returncode != 0:
+            subprocess.run(["git", "commit", "-am", "Update typeshed patches"], check=True)
+
+        if not args.typeshed_dir:
+            tmp_typeshed = os.path.join(tmpdir, "typeshed")
+            os.makedirs(tmp_typeshed)
+            # Clone typeshed repo if no directory given.
+            print(f"Cloning typeshed in {tmp_typeshed}...")
             subprocess.run(
-                ["git", "clone", "https://github.com/python/typeshed.git"], check=True, cwd=tempdir
+                ["git", "clone", "https://github.com/python/typeshed.git"],
+                check=True,
+                cwd=tmp_typeshed,
             )
-            repo = os.path.join(tempdir, "typeshed")
+            repo = os.path.join(tmp_typeshed, "typeshed")
             commit = update_typeshed(repo, args.commit)
-    else:
-        commit = update_typeshed(args.typeshed_dir, args.commit)
+        else:
+            commit = update_typeshed(args.typeshed_dir, args.commit)
 
-    assert commit
+        assert commit
 
-    # Create a commit
-    message = textwrap.dedent(
-        f"""\
-        Sync typeshed
+        # Create a commit
+        message = textwrap.dedent(
+            f"""\
+            Sync typeshed
 
-        Source commit:
-        https://github.com/python/typeshed/commit/{commit}
-        """
-    )
-    subprocess.run(["git", "add", "--all", os.path.join("mypy", "typeshed")], check=True)
-    subprocess.run(["git", "commit", "-m", message], check=True)
-    print("Created typeshed sync commit.")
-
-    commits_to_cherry_pick = [
-        "c844270a4",  # LiteralString reverts
-        "9ebe5fd49",  # sum reverts
-        "d1987191f",  # ctypes reverts
-        "b1761f4c9",  # ParamSpec for functools.wraps
-    ]
-    for commit in commits_to_cherry_pick:
-        subprocess.run(["git", "cherry-pick", commit], check=True)
-        print(f"Cherry-picked {commit}.")
+            Source commit:
+            https://github.com/python/typeshed/commit/{commit}
+            """
+        )
+        subprocess.run(["git", "add", "--all", os.path.join("mypy", "typeshed")], check=True)
+        subprocess.run(["git", "commit", "-m", message], check=True)
+        print("Created typeshed sync commit.")
+
+        patches = sorted(glob.glob(os.path.join(typeshed_patches, "*.patch")))
+        for patch in patches:
+            cmd = ["git", "am", "--3way", patch]
+            try:
+                subprocess.run(cmd, check=True)
+            except subprocess.CalledProcessError as e:
+                raise RuntimeError(
+                    f"\n\nFailed to apply patch {patch}\n"
+                    "1. Resolve the conflict, `git add --update`, then run `git am --continue`\n"
+                    "2. Run `git format-patch -1 -o misc/typeshed_patches <new_commit_sha>` "
+                    "to update the patch file.\n"
+                    "3. Re-run sync-typeshed.py"
+                ) from e
+
+            print(f"Applied patch {patch}")
 
     if args.make_pr:
         subprocess.run(["git", "push", "--force", "origin", branch_name], check=True)
diff --git a/misc/test-stubgenc.sh b/misc/test-stubgenc.sh
index 7da135f0bf16..ad66722628d8 100755
--- a/misc/test-stubgenc.sh
+++ b/misc/test-stubgenc.sh
@@ -3,17 +3,43 @@
 set -e
 set -x
 
-cd "$(dirname $0)/.."
+cd "$(dirname "$0")/.."
 
 # Install dependencies, demo project and mypy
 python -m pip install -r test-requirements.txt
-python -m pip install ./test-data/pybind11_mypy_demo
+python -m pip install ./test-data/pybind11_fixtures
 python -m pip install .
 
-# Remove expected stubs and generate new inplace
-STUBGEN_OUTPUT_FOLDER=./test-data/pybind11_mypy_demo/stubgen
-rm -rf $STUBGEN_OUTPUT_FOLDER/*
-stubgen -p pybind11_mypy_demo -o $STUBGEN_OUTPUT_FOLDER
+EXIT=0
 
-# Compare generated stubs to expected ones
-git diff --exit-code $STUBGEN_OUTPUT_FOLDER
+# performs the stubgenc test
+# first argument is the test result folder
+# everything else is passed to stubgen as its arguments
+function stubgenc_test() {
+    # Remove expected stubs and generate new inplace
+    STUBGEN_OUTPUT_FOLDER=./test-data/pybind11_fixtures/$1
+    rm -rf "${STUBGEN_OUTPUT_FOLDER:?}"
+
+    stubgen -o "$STUBGEN_OUTPUT_FOLDER" "${@:2}"
+
+    # Check if generated stubs can actually be type checked by mypy
+    if ! mypy "$STUBGEN_OUTPUT_FOLDER";
+    then
+        echo "Stubgen test failed, because generated stubs failed to type check."
+        EXIT=1
+    fi
+
+    # Compare generated stubs to expected ones
+    if ! git diff --exit-code "$STUBGEN_OUTPUT_FOLDER";
+    then
+        echo "Stubgen test failed, because generated stubs differ from expected outputs."
+        EXIT=1
+    fi
+}
+
+# create stubs without docstrings
+stubgenc_test expected_stubs_no_docs -p pybind11_fixtures
+# create stubs with docstrings
+stubgenc_test expected_stubs_with_docs -p pybind11_fixtures --include-docstrings
+
+exit $EXIT
diff --git a/misc/trigger_wheel_build.sh b/misc/trigger_wheel_build.sh
index c914a6e7cf86..a2608d93f349 100755
--- a/misc/trigger_wheel_build.sh
+++ b/misc/trigger_wheel_build.sh
@@ -3,7 +3,7 @@
 # Trigger a build of mypyc compiled mypy wheels by updating the mypy
 # submodule in the git repo that drives those builds.
 
-# $WHEELS_PUSH_TOKEN is stored in Github Settings and is an API token
+# $WHEELS_PUSH_TOKEN is stored in GitHub Settings and is an API token
 # for the mypy-build-bot account.
 
 git config --global user.email "nobody"
diff --git a/misc/typeshed_patches/0001-Partially-revert-Clean-up-argparse-hacks.patch b/misc/typeshed_patches/0001-Partially-revert-Clean-up-argparse-hacks.patch
new file mode 100644
index 000000000000..d0b1aca381df
--- /dev/null
+++ b/misc/typeshed_patches/0001-Partially-revert-Clean-up-argparse-hacks.patch
@@ -0,0 +1,45 @@
+From b5f2cc9633f9f6cd9326eee96a32efb3aff70701 Mon Sep 17 00:00:00 2001
+From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+Date: Sat, 15 Feb 2025 20:11:06 +0100
+Subject: [PATCH] Partially revert Clean up argparse hacks
+
+---
+ mypy/typeshed/stdlib/argparse.pyi | 8 +++++---
+ 1 file changed, 5 insertions(+), 3 deletions(-)
+
+diff --git a/mypy/typeshed/stdlib/argparse.pyi b/mypy/typeshed/stdlib/argparse.pyi
+index 029bfeefe..9dbd8c308 100644
+--- a/mypy/typeshed/stdlib/argparse.pyi
++++ b/mypy/typeshed/stdlib/argparse.pyi
+@@ -2,7 +2,7 @@ import sys
+ from _typeshed import SupportsWrite, sentinel
+ from collections.abc import Callable, Generator, Iterable, Sequence
+ from re import Pattern
+-from typing import IO, Any, ClassVar, Final, Generic, NoReturn, Protocol, TypeVar, overload
++from typing import IO, Any, ClassVar, Final, Generic, NewType, NoReturn, Protocol, TypeVar, overload
+ from typing_extensions import Self, TypeAlias, deprecated
+ 
+ __all__ = [
+@@ -38,7 +38,9 @@ ONE_OR_MORE: Final = "+"
+ OPTIONAL: Final = "?"
+ PARSER: Final = "A..."
+ REMAINDER: Final = "..."
+-SUPPRESS: Final = "==SUPPRESS=="
++_SUPPRESS_T = NewType("_SUPPRESS_T", str)
++SUPPRESS: _SUPPRESS_T | str  # not using Literal because argparse sometimes compares SUPPRESS with is
++# the | str is there so that foo = argparse.SUPPRESS; foo = "test" checks out in mypy
+ ZERO_OR_MORE: Final = "*"
+ _UNRECOGNIZED_ARGS_ATTR: Final = "_unrecognized_args"  # undocumented
+ 
+@@ -81,7 +83,7 @@ class _ActionsContainer:
+         # more precisely, Literal["?", "*", "+", "...", "A...", "==SUPPRESS=="],
+         # but using this would make it hard to annotate callers that don't use a
+         # literal argument and for subclasses to override this method.
+-        nargs: int | str | None = None,
++        nargs: int | str | _SUPPRESS_T | None = None,
+         const: Any = ...,
+         default: Any = ...,
+         type: _ActionType = ...,
+-- 
+2.48.1
+
diff --git a/misc/typeshed_patches/0001-Remove-use-of-LiteralString-in-builtins-13743.patch b/misc/typeshed_patches/0001-Remove-use-of-LiteralString-in-builtins-13743.patch
new file mode 100644
index 000000000000..91e255242ee9
--- /dev/null
+++ b/misc/typeshed_patches/0001-Remove-use-of-LiteralString-in-builtins-13743.patch
@@ -0,0 +1,197 @@
+From b4259edd94188f9e4cc77a22e768eea183a32053 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] Remove use of LiteralString in builtins (#13743)
+
+---
+ mypy/typeshed/stdlib/builtins.pyi | 100 +-----------------------------
+ 1 file changed, 1 insertion(+), 99 deletions(-)
+
+diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
+index 63c53a5f6..d55042b56 100644
+--- a/mypy/typeshed/stdlib/builtins.pyi
++++ b/mypy/typeshed/stdlib/builtins.pyi
+@@ -63,7 +63,6 @@ from typing import (  # noqa: Y022
+ from typing_extensions import (  # noqa: Y023
+     Concatenate,
+     Literal,
+-    LiteralString,
+     ParamSpec,
+     Self,
+     TypeAlias,
+@@ -438,31 +437,16 @@ 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, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int: ...
+     def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
+     def endswith(
+         self, suffix: str | tuple[str, ...], start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
+     ) -> bool: ...
+-    @overload
+-    def expandtabs(self: LiteralString, tabsize: SupportsIndex = 8) -> LiteralString: ...
+-    @overload
+     def expandtabs(self, tabsize: SupportsIndex = 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, mapping: _FormatMapMapping, /) -> str: ...
+     def index(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int: ...
+@@ -478,99 +462,35 @@ 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]
+     if sys.version_info >= (3, 13):
+-        @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]
+     else:
+-        @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
+@@ -581,39 +501,21 @@ 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]
+     def __eq__(self, value: object, /) -> bool: ...
+     def __ge__(self, value: str, /) -> bool: ...
+-    @overload
+-    def __getitem__(self: LiteralString, key: SupportsIndex | slice, /) -> LiteralString: ...
+-    @overload
+-    def __getitem__(self, key: SupportsIndex | slice, /) -> str: ...  # type: ignore[misc]
++    def __getitem__(self, key: SupportsIndex | slice, /) -> str: ...
+     def __gt__(self, value: str, /) -> bool: ...
+     def __hash__(self) -> int: ...
+-    @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]: ...
+ 
+-- 
+2.47.0
+
diff --git a/misc/typeshed_patches/0001-Revert-Remove-redundant-inheritances-from-Iterator.patch b/misc/typeshed_patches/0001-Revert-Remove-redundant-inheritances-from-Iterator.patch
new file mode 100644
index 000000000000..ef1d9f4d3fa3
--- /dev/null
+++ b/misc/typeshed_patches/0001-Revert-Remove-redundant-inheritances-from-Iterator.patch
@@ -0,0 +1,324 @@
+From abc5225e3c69d7ae8f3388c87260fe496efaecac Mon Sep 17 00:00:00 2001
+From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+Date: Sat, 21 Dec 2024 22:36:38 +0100
+Subject: [PATCH] Revert Remove redundant inheritances from Iterator in
+ builtins
+
+---
+ mypy/typeshed/stdlib/_asyncio.pyi             |  4 +-
+ mypy/typeshed/stdlib/builtins.pyi             | 10 ++---
+ mypy/typeshed/stdlib/csv.pyi                  |  4 +-
+ mypy/typeshed/stdlib/fileinput.pyi            |  6 +--
+ mypy/typeshed/stdlib/itertools.pyi            | 38 +++++++++----------
+ mypy/typeshed/stdlib/multiprocessing/pool.pyi |  4 +-
+ mypy/typeshed/stdlib/sqlite3/__init__.pyi     |  2 +-
+ 7 files changed, 34 insertions(+), 34 deletions(-)
+
+diff --git a/mypy/typeshed/stdlib/_asyncio.pyi b/mypy/typeshed/stdlib/_asyncio.pyi
+index 89cdff6cc..1397e579d 100644
+--- a/mypy/typeshed/stdlib/_asyncio.pyi
++++ b/mypy/typeshed/stdlib/_asyncio.pyi
+@@ -1,6 +1,6 @@
+ import sys
+ from asyncio.events import AbstractEventLoop
+-from collections.abc import Awaitable, Callable, Coroutine, Generator
++from collections.abc import Awaitable, Callable, Coroutine, Generator, Iterable
+ from contextvars import Context
+ from types import FrameType
+ from typing import Any, Literal, TextIO, TypeVar
+@@ -13,7 +13,7 @@ _T = TypeVar("_T")
+ _T_co = TypeVar("_T_co", covariant=True)
+ _TaskYieldType: TypeAlias = Future[object] | None
+
+-class Future(Awaitable[_T]):
++class Future(Awaitable[_T], Iterable[_T]):
+     _state: str
+     @property
+     def _exception(self) -> BaseException | None: ...
+diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
+index b75e34fc5..526406acc 100644
+--- a/mypy/typeshed/stdlib/builtins.pyi
++++ b/mypy/typeshed/stdlib/builtins.pyi
+@@ -1130,7 +1130,7 @@ class frozenset(AbstractSet[_T_co]):
+     if sys.version_info >= (3, 9):
+         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+-class enumerate(Generic[_T]):
++class enumerate(Iterator[tuple[int, _T]]):
+     def __new__(cls, iterable: Iterable[_T], start: int = 0) -> Self: ...
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> tuple[int, _T]: ...
+@@ -1324,7 +1324,7 @@ else:
+
+ exit: _sitebuiltins.Quitter
+
+-class filter(Generic[_T]):
++class filter(Iterator[_T]):
+     @overload
+     def __new__(cls, function: None, iterable: Iterable[_T | None], /) -> Self: ...
+     @overload
+@@ -1389,7 +1389,7 @@ license: _sitebuiltins._Printer
+
+ def locals() -> dict[str, Any]: ...
+
+-class map(Generic[_S]):
++class map(Iterator[_S]):
+     @overload
+     def __new__(cls, func: Callable[[_T1], _S], iterable: Iterable[_T1], /) -> Self: ...
+     @overload
+@@ -1632,7 +1632,7 @@ def pow(base: _SupportsSomeKindOfPow, exp: complex, mod: None = None) -> complex
+
+ quit: _sitebuiltins.Quitter
+
+-class reversed(Generic[_T]):
++class reversed(Iterator[_T]):
+     @overload
+     def __new__(cls, sequence: Reversible[_T], /) -> Iterator[_T]: ...  # type: ignore[misc]
+     @overload
+@@ -1693,7 +1693,7 @@ def vars(object: type, /) -> types.MappingProxyType[str, Any]: ...
+ @overload
+ def vars(object: Any = ..., /) -> dict[str, Any]: ...
+
+-class zip(Generic[_T_co]):
++class zip(Iterator[_T_co]):
+     if sys.version_info >= (3, 10):
+         @overload
+         def __new__(cls, *, strict: bool = ...) -> zip[Any]: ...
+diff --git a/mypy/typeshed/stdlib/csv.pyi b/mypy/typeshed/stdlib/csv.pyi
+index 4a82de638..ef93129d6 100644
+--- a/mypy/typeshed/stdlib/csv.pyi
++++ b/mypy/typeshed/stdlib/csv.pyi
+@@ -25,7 +25,7 @@ else:
+     from _csv import _reader as Reader, _writer as Writer
+
+ from _typeshed import SupportsWrite
+-from collections.abc import Collection, Iterable, Mapping, Sequence
++from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
+ from typing import Any, Generic, Literal, TypeVar, overload
+ from typing_extensions import Self
+
+@@ -75,7 +75,7 @@ class excel(Dialect): ...
+ class excel_tab(excel): ...
+ class unix_dialect(Dialect): ...
+
+-class DictReader(Generic[_T]):
++class DictReader(Iterator[dict[_T | Any, str | Any]], Generic[_T]):
+     fieldnames: Sequence[_T] | None
+     restkey: _T | None
+     restval: str | Any | None
+diff --git a/mypy/typeshed/stdlib/fileinput.pyi b/mypy/typeshed/stdlib/fileinput.pyi
+index bf6daad0a..1e6aa78e2 100644
+--- a/mypy/typeshed/stdlib/fileinput.pyi
++++ b/mypy/typeshed/stdlib/fileinput.pyi
+@@ -1,8 +1,8 @@
+ import sys
+ from _typeshed import AnyStr_co, StrOrBytesPath
+-from collections.abc import Callable, Iterable
++from collections.abc import Callable, Iterable, Iterator
+ from types import TracebackType
+-from typing import IO, Any, AnyStr, Generic, Literal, Protocol, overload
++from typing import IO, Any, AnyStr, Literal, Protocol, overload
+ from typing_extensions import Self, TypeAlias
+
+ if sys.version_info >= (3, 9):
+@@ -107,7 +107,7 @@ def fileno() -> int: ...
+ def isfirstline() -> bool: ...
+ def isstdin() -> bool: ...
+
+-class FileInput(Generic[AnyStr]):
++class FileInput(Iterator[AnyStr]):
+     if sys.version_info >= (3, 10):
+         # encoding and errors are added
+         @overload
+diff --git a/mypy/typeshed/stdlib/itertools.pyi b/mypy/typeshed/stdlib/itertools.pyi
+index 55b0814ac..675533d44 100644
+--- a/mypy/typeshed/stdlib/itertools.pyi
++++ b/mypy/typeshed/stdlib/itertools.pyi
+@@ -29,7 +29,7 @@ _Predicate: TypeAlias = Callable[[_T], object]
+
+ # Technically count can take anything that implements a number protocol and has an add method
+ # but we can't enforce the add method
+-class count(Generic[_N]):
++class count(Iterator[_N]):
+     @overload
+     def __new__(cls) -> count[int]: ...
+     @overload
+@@ -39,12 +39,12 @@ class count(Generic[_N]):
+     def __next__(self) -> _N: ...
+     def __iter__(self) -> Self: ...
+
+-class cycle(Generic[_T]):
++class cycle(Iterator[_T]):
+     def __new__(cls, iterable: Iterable[_T], /) -> Self: ...
+     def __next__(self) -> _T: ...
+     def __iter__(self) -> Self: ...
+
+-class repeat(Generic[_T]):
++class repeat(Iterator[_T]):
+     @overload
+     def __new__(cls, object: _T) -> Self: ...
+     @overload
+@@ -53,7 +53,7 @@ class repeat(Generic[_T]):
+     def __iter__(self) -> Self: ...
+     def __length_hint__(self) -> int: ...
+
+-class accumulate(Generic[_T]):
++class accumulate(Iterator[_T]):
+     @overload
+     def __new__(cls, iterable: Iterable[_T], func: None = None, *, initial: _T | None = ...) -> Self: ...
+     @overload
+@@ -61,7 +61,7 @@ class accumulate(Generic[_T]):
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T: ...
+
+-class chain(Generic[_T]):
++class chain(Iterator[_T]):
+     def __new__(cls, *iterables: Iterable[_T]) -> Self: ...
+     def __next__(self) -> _T: ...
+     def __iter__(self) -> Self: ...
+@@ -71,22 +71,22 @@ class chain(Generic[_T]):
+     if sys.version_info >= (3, 9):
+         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+-class compress(Generic[_T]):
++class compress(Iterator[_T]):
+     def __new__(cls, data: Iterable[_T], selectors: Iterable[Any]) -> Self: ...
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T: ...
+
+-class dropwhile(Generic[_T]):
++class dropwhile(Iterator[_T]):
+     def __new__(cls, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> Self: ...
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T: ...
+
+-class filterfalse(Generic[_T]):
++class filterfalse(Iterator[_T]):
+     def __new__(cls, function: _Predicate[_T] | None, iterable: Iterable[_T], /) -> Self: ...
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T: ...
+
+-class groupby(Generic[_T_co, _S_co]):
++class groupby(Iterator[tuple[_T_co, Iterator[_S_co]]], Generic[_T_co, _S_co]):
+     @overload
+     def __new__(cls, iterable: Iterable[_T1], key: None = None) -> groupby[_T1, _T1]: ...
+     @overload
+@@ -94,7 +94,7 @@ class groupby(Generic[_T_co, _S_co]):
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> tuple[_T_co, Iterator[_S_co]]: ...
+
+-class islice(Generic[_T]):
++class islice(Iterator[_T]):
+     @overload
+     def __new__(cls, iterable: Iterable[_T], stop: int | None, /) -> Self: ...
+     @overload
+@@ -102,19 +102,19 @@ class islice(Generic[_T]):
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T: ...
+
+-class starmap(Generic[_T_co]):
++class starmap(Iterator[_T_co]):
+     def __new__(cls, function: Callable[..., _T], iterable: Iterable[Iterable[Any]], /) -> starmap[_T]: ...
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T_co: ...
+
+-class takewhile(Generic[_T]):
++class takewhile(Iterator[_T]):
+     def __new__(cls, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> Self: ...
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T: ...
+
+ def tee(iterable: Iterable[_T], n: int = 2, /) -> tuple[Iterator[_T], ...]: ...
+
+-class zip_longest(Generic[_T_co]):
++class zip_longest(Iterator[_T_co]):
+     # one iterable (fillvalue doesn't matter)
+     @overload
+     def __new__(cls, iter1: Iterable[_T1], /, *, fillvalue: object = ...) -> zip_longest[tuple[_T1]]: ...
+@@ -192,7 +192,7 @@ class zip_longest(Generic[_T_co]):
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T_co: ...
+
+-class product(Generic[_T_co]):
++class product(Iterator[_T_co]):
+     @overload
+     def __new__(cls, iter1: Iterable[_T1], /) -> product[tuple[_T1]]: ...
+     @overload
+@@ -277,7 +277,7 @@ class product(Generic[_T_co]):
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T_co: ...
+
+-class permutations(Generic[_T_co]):
++class permutations(Iterator[_T_co]):
+     @overload
+     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> permutations[tuple[_T, _T]]: ...
+     @overload
+@@ -291,7 +291,7 @@ class permutations(Generic[_T_co]):
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T_co: ...
+
+-class combinations(Generic[_T_co]):
++class combinations(Iterator[_T_co]):
+     @overload
+     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ...
+     @overload
+@@ -305,7 +305,7 @@ class combinations(Generic[_T_co]):
+     def __iter__(self) -> Self: ...
+     def __next__(self) -> _T_co: ...
+
+-class combinations_with_replacement(Generic[_T_co]):
++class combinations_with_replacement(Iterator[_T_co]):
+     @overload
+     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations_with_replacement[tuple[_T, _T]]: ...
+     @overload
+@@ -320,13 +320,13 @@ class combinations_with_replacement(Generic[_T_co]):
+     def __next__(self) -> _T_co: ...
+
+ if sys.version_info >= (3, 10):
+-    class pairwise(Generic[_T_co]):
++    class pairwise(Iterator[_T_co]):
+         def __new__(cls, iterable: Iterable[_T], /) -> pairwise[tuple[_T, _T]]: ...
+         def __iter__(self) -> Self: ...
+         def __next__(self) -> _T_co: ...
+
+ if sys.version_info >= (3, 12):
+-    class batched(Generic[_T_co]):
++    class batched(Iterator[tuple[_T_co, ...]], Generic[_T_co]):
+         if sys.version_info >= (3, 13):
+             def __new__(cls, iterable: Iterable[_T_co], n: int, *, strict: bool = False) -> Self: ...
+         else:
+diff --git a/mypy/typeshed/stdlib/multiprocessing/pool.pyi b/mypy/typeshed/stdlib/multiprocessing/pool.pyi
+index 2937d45e3..93197e5d4 100644
+--- a/mypy/typeshed/stdlib/multiprocessing/pool.pyi
++++ b/mypy/typeshed/stdlib/multiprocessing/pool.pyi
+@@ -1,5 +1,5 @@
+ import sys
+-from collections.abc import Callable, Iterable, Mapping
++from collections.abc import Callable, Iterable, Iterator, Mapping
+ from multiprocessing.context import DefaultContext, Process
+ from types import TracebackType
+ from typing import Any, Final, Generic, TypeVar
+@@ -37,7 +37,7 @@ class MapResult(ApplyResult[list[_T]]):
+         error_callback: Callable[[BaseException], object] | None,
+     ) -> None: ...
+
+-class IMapIterator(Generic[_T]):
++class IMapIterator(Iterator[_T]):
+     def __init__(self, pool: Pool) -> None: ...
+     def __iter__(self) -> Self: ...
+     def next(self, timeout: float | None = None) -> _T: ...
+diff --git a/mypy/typeshed/stdlib/sqlite3/__init__.pyi b/mypy/typeshed/stdlib/sqlite3/__init__.pyi
+index b83516b4d..724bc3166 100644
+--- a/mypy/typeshed/stdlib/sqlite3/__init__.pyi
++++ b/mypy/typeshed/stdlib/sqlite3/__init__.pyi
+@@ -397,7 +397,7 @@ class Connection:
+         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None, /
+     ) -> Literal[False]: ...
+
+-class Cursor:
++class Cursor(Iterator[Any]):
+     arraysize: int
+     @property
+     def connection(self) -> Connection: ...
+--
+2.47.1
diff --git a/misc/typeshed_patches/0001-Revert-sum-literal-integer-change-13961.patch b/misc/typeshed_patches/0001-Revert-sum-literal-integer-change-13961.patch
new file mode 100644
index 000000000000..331628af1424
--- /dev/null
+++ b/misc/typeshed_patches/0001-Revert-sum-literal-integer-change-13961.patch
@@ -0,0 +1,36 @@
+From 58c6a6ab863c1c38e95ccafaf13792ed9c00e499 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] 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 | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
+index ea9f8c894..a6065cc67 100644
+--- a/mypy/typeshed/stdlib/builtins.pyi
++++ b/mypy/typeshed/stdlib/builtins.pyi
+@@ -1653,7 +1653,7 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
+ # without creating many false-positive errors (see #7578).
+ # Instead, we special-case the most common examples of this: bool and literal integers.
+ @overload
+-def sum(iterable: Iterable[bool | _LiteralInteger], /, start: int = 0) -> int: ...
++def sum(iterable: Iterable[bool], /, start: int = 0) -> int: ...
+ @overload
+ def sum(iterable: Iterable[_SupportsSumNoDefaultT], /) -> _SupportsSumNoDefaultT | Literal[0]: ...
+ @overload
+-- 
+2.46.0
+
diff --git a/misc/typeshed_patches/0001-Revert-typeshed-ctypes-change.patch b/misc/typeshed_patches/0001-Revert-typeshed-ctypes-change.patch
new file mode 100644
index 000000000000..27066bf3c25b
--- /dev/null
+++ b/misc/typeshed_patches/0001-Revert-typeshed-ctypes-change.patch
@@ -0,0 +1,32 @@
+From 61a490091d7c941780919660dc4fdfa88ae6474a Mon Sep 17 00:00:00 2001
+From: AlexWaygood <alex.waygood@gmail.com>
+Date: Mon, 1 May 2023 20:34:55 +0100
+Subject: [PATCH] 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 60bbc51d9..cf9cb81a4 100644
+--- a/mypy/typeshed/stdlib/_ctypes.pyi
++++ b/mypy/typeshed/stdlib/_ctypes.pyi
+@@ -169,11 +169,7 @@ class Array(_CData, Generic[_CT]):
+     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
+-- 
+2.39.3 (Apple Git-146)
+
diff --git a/misc/update-stubinfo.py b/misc/update-stubinfo.py
new file mode 100644
index 000000000000..beaed34a8a47
--- /dev/null
+++ b/misc/update-stubinfo.py
@@ -0,0 +1,67 @@
+import argparse
+from pathlib import Path
+
+import tomli as tomllib
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--typeshed", type=Path, required=True)
+    args = parser.parse_args()
+
+    typeshed_p_to_d = {}
+    for stub in (args.typeshed / "stubs").iterdir():
+        if not stub.is_dir():
+            continue
+        try:
+            metadata = tomllib.loads((stub / "METADATA.toml").read_text())
+        except FileNotFoundError:
+            continue
+        d = metadata.get("stub_distribution", f"types-{stub.name}")
+        for p in stub.iterdir():
+            if not p.stem.isidentifier():
+                continue
+            if p.is_dir() and not any(f.suffix == ".pyi" for f in p.iterdir()):
+                # ignore namespace packages
+                continue
+            if p.is_file() and p.suffix != ".pyi":
+                continue
+            typeshed_p_to_d[p.stem] = d
+
+    import mypy.stubinfo
+
+    mypy_p = set(mypy.stubinfo.non_bundled_packages_flat) | set(
+        mypy.stubinfo.legacy_bundled_packages
+    )
+
+    for p in typeshed_p_to_d.keys() & mypy_p:
+        mypy_d = mypy.stubinfo.non_bundled_packages_flat.get(p)
+        mypy_d = mypy_d or mypy.stubinfo.legacy_bundled_packages.get(p)
+        if mypy_d != typeshed_p_to_d[p]:
+            raise ValueError(
+                f"stub_distribution mismatch for {p}: {mypy_d} != {typeshed_p_to_d[p]}"
+            )
+
+    print("=" * 40)
+    print("Add the following to non_bundled_packages_flat:")
+    print("=" * 40)
+    for p in sorted(typeshed_p_to_d.keys() - mypy_p):
+        if p in {
+            "pika",  # see comment in stubinfo.py
+            "distutils",  # don't recommend types-setuptools here
+        }:
+            continue
+        print(f'"{p}": "{typeshed_p_to_d[p]}",')
+    print()
+
+    print("=" * 40)
+    print("Consider removing the following packages no longer in typeshed:")
+    print("=" * 40)
+    for p in sorted(mypy_p - typeshed_p_to_d.keys()):
+        if p in {"lxml", "pandas"}:  # never in typeshed
+            continue
+        print(p)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/misc/upload-pypi.py b/misc/upload-pypi.py
index 9d8827c5e46c..c9db475c14b4 100644
--- a/misc/upload-pypi.py
+++ b/misc/upload-pypi.py
@@ -16,9 +16,10 @@
 import tarfile
 import tempfile
 import venv
+from collections.abc import Iterator
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from typing import Any, Iterator
+from typing import Any
 from urllib.request import urlopen
 
 BASE = "https://api.github.com/repos"
@@ -26,17 +27,15 @@
 
 
 def is_whl_or_tar(name: str) -> bool:
-    return name.endswith(".tar.gz") or name.endswith(".whl")
+    return name.endswith((".tar.gz", ".whl"))
 
 
 def item_ok_for_pypi(name: str) -> bool:
     if not is_whl_or_tar(name):
         return False
 
-    if name.endswith(".tar.gz"):
-        name = name[:-7]
-    if name.endswith(".whl"):
-        name = name[:-4]
+    name = name.removesuffix(".tar.gz")
+    name = name.removesuffix(".whl")
 
     if name.endswith("wasm32"):
         return False
@@ -122,8 +121,7 @@ def upload_to_pypi(version: str, dry_run: bool = True) -> None:
     assert re.match(r"v?[1-9]\.[0-9]+\.[0-9](\+\S+)?$", version)
     if "dev" in version:
         assert dry_run, "Must use --dry-run with dev versions of mypy"
-    if version.startswith("v"):
-        version = version[1:]
+    version = version.removeprefix("v")
 
     target_dir = tempfile.mkdtemp()
     dist = Path(target_dir) / "dist"
diff --git a/mypy-requirements.txt b/mypy-requirements.txt
index 9a55446eb05a..8965a70c13b7 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>=3.10
+# and the pins in setup.py
+typing_extensions>=4.6.0
 mypy_extensions>=1.0.0
-typed_ast>=1.4.0,<2; python_version<'3.8'
+pathspec>=0.9.0
 tomli>=1.1.0; python_version<'3.11'
diff --git a/mypy/applytype.py b/mypy/applytype.py
index 55a51d4adbb6..e87bf939c81a 100644
--- a/mypy/applytype.py
+++ b/mypy/applytype.py
@@ -1,27 +1,34 @@
 from __future__ import annotations
 
-from typing import Callable, Sequence
+from collections.abc import Iterable, Sequence
+from typing import Callable
 
 import mypy.subtypes
-from mypy.expandtype import expand_type, expand_unpack_with_variables
-from mypy.nodes import ARG_STAR, Context
+from mypy.erasetype import erase_typevars
+from mypy.expandtype import expand_type
+from mypy.nodes import Context, TypeInfo
+from mypy.type_visitor import TypeTranslator
+from mypy.typeops import get_all_type_vars
 from mypy.types import (
     AnyType,
     CallableType,
     Instance,
     Parameters,
+    ParamSpecFlavor,
     ParamSpecType,
     PartialType,
-    TupleType,
+    ProperType,
     Type,
+    TypeAliasType,
     TypeVarId,
     TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
+    UninhabitedType,
     UnpackType,
     get_proper_type,
+    remove_dups,
 )
-from mypy.typevartuples import find_unpack_in_list, replace_starargs
 
 
 def get_target_type(
@@ -32,13 +39,15 @@ def get_target_type(
     context: Context,
     skip_unsatisfied: bool,
 ) -> Type | None:
+    p_type = get_proper_type(type)
+    if isinstance(p_type, UninhabitedType) and tvar.has_default():
+        return tvar.default
     if isinstance(tvar, ParamSpecType):
         return type
     if isinstance(tvar, TypeVarTupleType):
         return type
     assert isinstance(tvar, TypeVarType)
     values = tvar.values
-    p_type = get_proper_type(type)
     if values:
         if isinstance(p_type, AnyType):
             return type
@@ -63,6 +72,11 @@ def get_target_type(
         report_incompatible_typevar_value(callable, type, tvar.name, context)
     else:
         upper_bound = tvar.upper_bound
+        if tvar.name == "Self":
+            # Internally constructed Self-types contain class type variables in upper bound,
+            # so we need to erase them to avoid false positives. This is safe because we do
+            # not support type variables in upper bounds of user defined types.
+            upper_bound = erase_typevars(upper_bound)
         if not mypy.subtypes.is_subtype(type, upper_bound):
             if skip_unsatisfied:
                 return None
@@ -88,7 +102,7 @@ def apply_generic_arguments(
     bound or constraints, instead of giving an error.
     """
     tvars = callable.variables
-    assert len(tvars) == len(orig_types)
+    assert len(orig_types) <= len(tvars)
     # Check that inferred type variable values are compatible with allowed
     # values and bounds.  Also, promote subtype values to allowed values.
     # Create a map from type variable id to target type.
@@ -105,82 +119,186 @@ def apply_generic_arguments(
         if target_type is not None:
             id_to_type[tvar.id] = target_type
 
+    # TODO: validate arg_kinds/arg_names for ParamSpec and TypeVarTuple replacements,
+    # not just type variable bounds above.
     param_spec = callable.param_spec()
     if param_spec is not None:
         nt = id_to_type.get(param_spec.id)
         if nt is not None:
-            nt = get_proper_type(nt)
-            if isinstance(nt, (CallableType, Parameters)):
-                callable = callable.expand_param_spec(nt)
+            # ParamSpec expansion is special-cased, so we need to always expand callable
+            # as a whole, not expanding arguments individually.
+            callable = expand_type(callable, id_to_type)
+            assert isinstance(callable, CallableType)
+            return callable.copy_modified(
+                variables=[tv for tv in tvars if tv.id not in id_to_type]
+            )
 
     # Apply arguments to argument types.
     var_arg = callable.var_arg()
     if var_arg is not None and isinstance(var_arg.typ, UnpackType):
-        star_index = callable.arg_kinds.index(ARG_STAR)
-        callable = callable.copy_modified(
-            arg_types=(
-                [expand_type(at, id_to_type) for at in callable.arg_types[:star_index]]
-                + [callable.arg_types[star_index]]
-                + [expand_type(at, id_to_type) for at in callable.arg_types[star_index + 1 :]]
-            )
-        )
-
-        unpacked_type = get_proper_type(var_arg.typ.type)
-        if isinstance(unpacked_type, TupleType):
-            # Assuming for now that because we convert prefixes to positional arguments,
-            # the first argument is always an unpack.
-            expanded_tuple = expand_type(unpacked_type, id_to_type)
-            if isinstance(expanded_tuple, TupleType):
-                # TODO: handle the case where the tuple has an unpack. This will
-                # hit an assert below.
-                expanded_unpack = find_unpack_in_list(expanded_tuple.items)
-                if expanded_unpack is not None:
-                    callable = callable.copy_modified(
-                        arg_types=(
-                            callable.arg_types[:star_index]
-                            + [expanded_tuple]
-                            + callable.arg_types[star_index + 1 :]
-                        )
-                    )
-                else:
-                    callable = replace_starargs(callable, expanded_tuple.items)
-            else:
-                # TODO: handle the case for if we get a variable length tuple.
-                assert False, f"mypy bug: unimplemented case, {expanded_tuple}"
-        elif isinstance(unpacked_type, TypeVarTupleType):
-            expanded_tvt = expand_unpack_with_variables(var_arg.typ, id_to_type)
-            if isinstance(expanded_tvt, list):
-                for t in expanded_tvt:
-                    assert not isinstance(t, UnpackType)
-                callable = replace_starargs(callable, expanded_tvt)
-            else:
-                assert isinstance(expanded_tvt, Instance)
-                assert expanded_tvt.type.fullname == "builtins.tuple"
-                callable = callable.copy_modified(
-                    arg_types=(
-                        callable.arg_types[:star_index]
-                        + [expanded_tvt.args[0]]
-                        + callable.arg_types[star_index + 1 :]
-                    )
-                )
-        else:
-            assert False, "mypy bug: unhandled case applying unpack"
+        # Same as for ParamSpec, callable with variadic types needs to be expanded as a whole.
+        callable = expand_type(callable, id_to_type)
+        assert isinstance(callable, CallableType)
+        return callable.copy_modified(variables=[tv for tv in tvars if tv.id not in id_to_type])
     else:
         callable = callable.copy_modified(
             arg_types=[expand_type(at, id_to_type) for at in callable.arg_types]
         )
 
-    # Apply arguments to TypeGuard if any.
+    # Apply arguments to TypeGuard and TypeIs if any.
     if callable.type_guard is not None:
         type_guard = expand_type(callable.type_guard, id_to_type)
     else:
         type_guard = None
+    if callable.type_is is not None:
+        type_is = expand_type(callable.type_is, id_to_type)
+    else:
+        type_is = None
 
     # The callable may retain some type vars if only some were applied.
-    remaining_tvars = [tv for tv in tvars if tv.id not in id_to_type]
+    # TODO: move apply_poly() logic here when new inference
+    # becomes universally used (i.e. in all passes + in unification).
+    # With this new logic we can actually *add* some new free variables.
+    remaining_tvars: list[TypeVarLikeType] = []
+    for tv in tvars:
+        if tv.id in id_to_type:
+            continue
+        if not tv.has_default():
+            remaining_tvars.append(tv)
+            continue
+        # TypeVarLike isn't in id_to_type mapping.
+        # Only expand the TypeVar default here.
+        typ = expand_type(tv, id_to_type)
+        assert isinstance(typ, TypeVarLikeType)
+        remaining_tvars.append(typ)
 
     return callable.copy_modified(
         ret_type=expand_type(callable.ret_type, id_to_type),
         variables=remaining_tvars,
         type_guard=type_guard,
+        type_is=type_is,
     )
+
+
+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
+    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: Iterable[TypeVarLikeType],
+        bound_tvars: frozenset[TypeVarLikeType] = frozenset(),
+        seen_aliases: frozenset[TypeInfo] = frozenset(),
+    ) -> None:
+        super().__init__()
+        self.poly_tvars = set(poly_tvars)
+        # This is a simplified version of TypeVarScope used during semantic analysis.
+        self.bound_tvars = bound_tvars
+        self.seen_aliases = seen_aliases
+
+    def collect_vars(self, t: CallableType | Parameters) -> list[TypeVarLikeType]:
+        found_vars = []
+        for arg in t.arg_types:
+            for tv in get_all_type_vars(arg):
+                if isinstance(tv, ParamSpecType):
+                    normalized: TypeVarLikeType = tv.copy_modified(
+                        flavor=ParamSpecFlavor.BARE, prefix=Parameters([], [], [])
+                    )
+                else:
+                    normalized = tv
+                if normalized in self.poly_tvars and normalized not in self.bound_tvars:
+                    found_vars.append(normalized)
+        return remove_dups(found_vars)
+
+    def visit_callable_type(self, t: CallableType) -> Type:
+        found_vars = self.collect_vars(t)
+        self.bound_tvars |= set(found_vars)
+        result = super().visit_callable_type(t)
+        self.bound_tvars -= set(found_vars)
+
+        assert isinstance(result, ProperType) and isinstance(result, CallableType)
+        result.variables = list(result.variables) + 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:
+        if t in self.poly_tvars and t not in self.bound_tvars:
+            raise PolyTranslationError()
+        return super().visit_param_spec(t)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+        if t in self.poly_tvars and t not in self.bound_tvars:
+            raise PolyTranslationError()
+        return super().visit_type_var_tuple(t)
+
+    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:
+        if t.type.has_param_spec_type:
+            # We need this special-casing to preserve the possibility to store a
+            # generic function in an instance type. Things like
+            #     forall T . Foo[[x: T], T]
+            # are not really expressible in current type system, but this looks like
+            # a useful feature, so let's keep it.
+            param_spec_index = next(
+                i for (i, tv) in enumerate(t.type.defn.type_vars) if isinstance(tv, ParamSpecType)
+            )
+            p = get_proper_type(t.args[param_spec_index])
+            if isinstance(p, Parameters):
+                found_vars = self.collect_vars(p)
+                self.bound_tvars |= set(found_vars)
+                new_args = [a.accept(self) for a in t.args]
+                self.bound_tvars -= set(found_vars)
+
+                repl = new_args[param_spec_index]
+                assert isinstance(repl, ProperType) and isinstance(repl, Parameters)
+                repl.variables = list(repl.variables) + list(found_vars)
+                return t.copy_modified(args=new_args)
+        # There is the same problem with callback protocols as with aliases
+        # (callback protocols are essentially more flexible aliases to callables).
+        if t.args and t.type.is_protocol and t.type.protocol_members == ["__call__"]:
+            if t.type in self.seen_aliases:
+                raise PolyTranslationError()
+            call = mypy.subtypes.find_member("__call__", t, t, is_operator=True)
+            assert call is not None
+            return call.accept(
+                PolyTranslator(self.poly_tvars, self.bound_tvars, self.seen_aliases | {t.type})
+            )
+        return super().visit_instance(t)
diff --git a/mypy/argmap.py b/mypy/argmap.py
index ec8463fd0625..28fad1f093dd 100644
--- a/mypy/argmap.py
+++ b/mypy/argmap.py
@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Callable
 
 from mypy import nodes
 from mypy.maptype import map_instance_to_supertype
@@ -14,6 +15,8 @@
     Type,
     TypedDictType,
     TypeOfAny,
+    TypeVarTupleType,
+    UnpackType,
     get_proper_type,
 )
 
@@ -75,7 +78,7 @@ def map_actuals_to_formals(
         elif actual_kind.is_named():
             assert actual_names is not None, "Internal error: named kinds without names given"
             name = actual_names[ai]
-            if name in formal_names:
+            if name in formal_names and formal_kinds[formal_names.index(name)] != nodes.ARG_STAR:
                 formal_to_actual[formal_names.index(name)].append(ai)
             elif nodes.ARG_STAR2 in formal_kinds:
                 formal_to_actual[formal_kinds.index(nodes.ARG_STAR2)].append(ai)
@@ -174,6 +177,7 @@ def expand_actual_type(
         actual_kind: nodes.ArgKind,
         formal_name: str | None,
         formal_kind: nodes.ArgKind,
+        allow_unpack: bool = False,
     ) -> Type:
         """Return the actual (caller) type(s) of a formal argument with the given kinds.
 
@@ -189,6 +193,11 @@ def expand_actual_type(
         original_actual = actual_type
         actual_type = get_proper_type(actual_type)
         if actual_kind == nodes.ARG_STAR:
+            if isinstance(actual_type, TypeVarTupleType):
+                # This code path is hit when *Ts is passed to a callable and various
+                # special-handling didn't catch this. The best thing we can do is to use
+                # the upper bound.
+                actual_type = get_proper_type(actual_type.upper_bound)
             if isinstance(actual_type, Instance) and actual_type.args:
                 from mypy.subtypes import is_subtype
 
@@ -209,7 +218,20 @@ def expand_actual_type(
                     self.tuple_index = 1
                 else:
                     self.tuple_index += 1
-                return actual_type.items[self.tuple_index - 1]
+                item = actual_type.items[self.tuple_index - 1]
+                if isinstance(item, UnpackType) and not allow_unpack:
+                    # An unpack item that doesn't have special handling, use upper bound as above.
+                    unpacked = get_proper_type(item.type)
+                    if isinstance(unpacked, TypeVarTupleType):
+                        fallback = get_proper_type(unpacked.upper_bound)
+                    else:
+                        fallback = unpacked
+                    assert (
+                        isinstance(fallback, Instance)
+                        and fallback.type.fullname == "builtins.tuple"
+                    )
+                    item = fallback.args[0]
+                return item
             elif isinstance(actual_type, ParamSpecType):
                 # ParamSpec is valid in *args but it can't be unpacked.
                 return actual_type
@@ -227,10 +249,8 @@ def expand_actual_type(
                     formal_name = (set(actual_type.items.keys()) - self.kwargs_used).pop()
                 self.kwargs_used.add(formal_name)
                 return actual_type.items[formal_name]
-            elif (
-                isinstance(actual_type, Instance)
-                and len(actual_type.args) > 1
-                and is_subtype(actual_type, self.context.mapping_type)
+            elif isinstance(actual_type, Instance) and is_subtype(
+                actual_type, self.context.mapping_type
             ):
                 # Only `Mapping` type can be unpacked with `**`.
                 # Other types will produce an error somewhere else.
diff --git a/mypy/binder.py b/mypy/binder.py
index 37c0b6bb9006..d3482d1dad4f 100644
--- a/mypy/binder.py
+++ b/mypy/binder.py
@@ -1,23 +1,31 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import DefaultDict, Iterator, List, Optional, Tuple, Union, cast
+from typing import NamedTuple, Optional, Union
 from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.erasetype import remove_instance_last_known_values
-from mypy.join import join_simple
-from mypy.literals import Key, literal, literal_hash, subkeys
+from mypy.literals import Key, extract_var_from_literal_hash, literal, literal_hash, subkeys
 from mypy.nodes import Expression, IndexExpr, MemberExpr, NameExpr, RefExpr, TypeInfo, Var
+from mypy.options import Options
 from mypy.subtypes import is_same_type, is_subtype
+from mypy.typeops import make_simplified_union
 from mypy.types import (
     AnyType,
+    Instance,
     NoneType,
     PartialType,
+    ProperType,
+    TupleType,
     Type,
     TypeOfAny,
     TypeType,
+    TypeVarType,
     UnionType,
+    UnpackType,
+    find_unpack_in_list,
     get_proper_type,
 )
 from mypy.typevars import fill_typevars_with_any
@@ -25,65 +33,74 @@
 BindableExpression: _TypeAlias = Union[IndexExpr, MemberExpr, NameExpr]
 
 
+class CurrentType(NamedTuple):
+    type: Type
+    from_assignment: bool
+
+
 class Frame:
     """A Frame represents a specific point in the execution of a program.
+
     It carries information about the current types of expressions at
     that point, arising either from assignments to those expressions
-    or the result of isinstance checks. It also records whether it is
-    possible to reach that point at all.
+    or the result of isinstance checks and other type narrowing
+    operations. It also records whether it is possible to reach that
+    point at all.
+
+    We add a new frame wherenever there is a new scope or control flow
+    branching.
 
     This information is not copied into a new Frame when it is pushed
     onto the stack, so a given Frame only has information about types
     that were assigned in that frame.
+
+    Expressions are stored in dicts using 'literal hashes' as keys (type
+    "Key"). These are hashable values derived from expression AST nodes
+    (only those that can be narrowed). literal_hash(expr) is used to
+    calculate the hashes. Note that this isn't directly related to literal
+    types -- the concept predates literal types.
     """
 
     def __init__(self, id: int, conditional_frame: bool = False) -> None:
         self.id = id
-        self.types: dict[Key, Type] = {}
+        self.types: dict[Key, CurrentType] = {}
         self.unreachable = False
         self.conditional_frame = conditional_frame
-
-        # Should be set only if we're entering a frame where it's not
-        # possible to accurately determine whether or not contained
-        # statements will be unreachable or not.
-        #
-        # Long-term, we should improve mypy to the point where we no longer
-        # need this field.
         self.suppress_unreachable_warnings = False
 
     def __repr__(self) -> str:
         return f"Frame({self.id}, {self.types}, {self.unreachable}, {self.conditional_frame})"
 
 
-Assigns = DefaultDict[Expression, List[Tuple[Type, Optional[Type]]]]
+Assigns = defaultdict[Expression, list[tuple[Type, Optional[Type]]]]
 
 
 class ConditionalTypeBinder:
     """Keep track of conditional types of variables.
 
-    NB: Variables are tracked by literal expression, so it is possible
-    to confuse the binder; for example,
-
-    ```
-    class A:
-        a: Union[int, str] = None
-    x = A()
-    lst = [x]
-    reveal_type(x.a)      # Union[int, str]
-    x.a = 1
-    reveal_type(x.a)      # int
-    reveal_type(lst[0].a) # Union[int, str]
-    lst[0].a = 'a'
-    reveal_type(x.a)      # int
-    reveal_type(lst[0].a) # str
-    ```
+    NB: Variables are tracked by literal hashes of expressions, so it is
+    possible to confuse the binder when there is aliasing. Example:
+
+        class A:
+            a: int | str
+
+        x = A()
+        lst = [x]
+        reveal_type(x.a)      # int | str
+        x.a = 1
+        reveal_type(x.a)      # int
+        reveal_type(lst[0].a) # int | str
+        lst[0].a = 'a'
+        reveal_type(x.a)      # int
+        reveal_type(lst[0].a) # str
     """
 
     # Stored assignments for situations with tuple/list lvalue and rvalue of union type.
     # This maps an expression to a list of bound types for every item in the union type.
     type_assignments: Assigns | None = None
 
-    def __init__(self) -> None:
+    def __init__(self, options: Options) -> None:
+        # Each frame gets an increasing, distinct id.
         self.next_id = 1
 
         # The stack of frames currently used.  These map
@@ -111,10 +128,16 @@ def __init__(self) -> None:
         # Whether the last pop changed the newly top frame on exit
         self.last_pop_changed = False
 
+        # These are used to track control flow in try statements and loops.
         self.try_frames: set[int] = set()
         self.break_frames: list[int] = []
         self.continue_frames: list[int] = []
 
+        # If True, initial assignment to a simple variable (e.g. "x", but not "x.y")
+        # is added to the binder. This allows more precise narrowing and more
+        # flexible inference of variable types (--allow-redefinition-new).
+        self.bind_all = options.allow_redefinition_new
+
     def _get_id(self) -> int:
         self.next_id += 1
         return self.next_id
@@ -134,10 +157,10 @@ def push_frame(self, conditional_frame: bool = False) -> Frame:
         self.options_on_return.append([])
         return f
 
-    def _put(self, key: Key, type: Type, index: int = -1) -> None:
-        self.frames[index].types[key] = type
+    def _put(self, key: Key, type: Type, from_assignment: bool, index: int = -1) -> None:
+        self.frames[index].types[key] = CurrentType(type, from_assignment)
 
-    def _get(self, key: Key, index: int = -1) -> Type | None:
+    def _get(self, key: Key, index: int = -1) -> CurrentType | None:
         if index < 0:
             index += len(self.frames)
         for i in range(index, -1, -1):
@@ -145,7 +168,11 @@ def _get(self, key: Key, index: int = -1) -> Type | None:
                 return self.frames[i].types[key]
         return None
 
-    def put(self, expr: Expression, typ: Type) -> None:
+    def put(self, expr: Expression, typ: Type, *, from_assignment: bool = True) -> None:
+        """Directly set the narrowed type of expression (if it supports it).
+
+        This is used for isinstance() etc. Assignments should go through assign_type().
+        """
         if not isinstance(expr, (IndexExpr, MemberExpr, NameExpr)):
             return
         if not literal(expr):
@@ -155,7 +182,7 @@ def put(self, expr: Expression, typ: Type) -> None:
         if key not in self.declarations:
             self.declarations[key] = get_declaration(expr)
             self._add_dependencies(key)
-        self._put(key, typ)
+        self._put(key, typ, from_assignment)
 
     def unreachable(self) -> None:
         self.frames[-1].unreachable = True
@@ -166,7 +193,10 @@ def suppress_unreachable_warnings(self) -> None:
     def get(self, expr: Expression) -> Type | None:
         key = literal_hash(expr)
         assert key is not None, "Internal error: binder tried to get non-literal"
-        return self._get(key)
+        found = self._get(key)
+        if found is None:
+            return None
+        return found.type
 
     def is_unreachable(self) -> bool:
         # TODO: Copy the value of unreachable into new frames to avoid
@@ -174,7 +204,6 @@ def is_unreachable(self) -> bool:
         return any(f.unreachable for f in self.frames)
 
     def is_unreachable_warning_suppressed(self) -> bool:
-        # TODO: See todo in 'is_unreachable'
         return any(f.suppress_unreachable_warnings for f in self.frames)
 
     def cleanse(self, expr: Expression) -> None:
@@ -196,7 +225,7 @@ def update_from_options(self, frames: list[Frame]) -> bool:
         If a key is declared as AnyType, only update it if all the
         options are the same.
         """
-
+        all_reachable = all(not f.unreachable for f in frames)
         frames = [f for f in frames if not f.unreachable]
         changed = False
         keys = {key for f in frames for key in f.types}
@@ -204,25 +233,80 @@ def update_from_options(self, frames: list[Frame]) -> bool:
         for key in keys:
             current_value = self._get(key)
             resulting_values = [f.types.get(key, current_value) for f in frames]
-            if any(x is None for x in resulting_values):
+            # Keys can be narrowed using two different semantics. The new semantics
+            # is enabled for plain variables when bind_all is true, and it allows
+            # variable types to be widened using subsequent assignments. This is
+            # tricky to support for instance attributes (primarily due to deferrals),
+            # so we don't use it for them.
+            old_semantics = not self.bind_all or extract_var_from_literal_hash(key) is None
+            if old_semantics and any(x is None for x in resulting_values):
                 # We didn't know anything about key before
                 # (current_value must be None), and we still don't
                 # know anything about key in at least one possible frame.
                 continue
 
-            type = resulting_values[0]
-            assert type is not None
+            resulting_values = [x for x in resulting_values if x is not None]
+
+            if all_reachable and all(
+                x is not None and not x.from_assignment for x in resulting_values
+            ):
+                # Do not synthesize a new type if we encountered a conditional block
+                # (if, while or match-case) without assignments.
+                # See check-isinstance.test::testNoneCheckDoesNotMakeTypeVarOptional
+                # This is a safe assumption: the fact that we checked something with `is`
+                # or `isinstance` does not change the type of the value.
+                continue
+
+            current_type = resulting_values[0]
+            assert current_type is not None
+            type = current_type.type
             declaration_type = get_proper_type(self.declarations.get(key))
             if isinstance(declaration_type, AnyType):
                 # At this point resulting values can't contain None, see continue above
-                if not all(is_same_type(type, cast(Type, t)) for t in resulting_values[1:]):
+                if not all(
+                    t is not None and is_same_type(type, t.type) for t in resulting_values[1:]
+                ):
                     type = AnyType(TypeOfAny.from_another_any, source_any=declaration_type)
             else:
-                for other in resulting_values[1:]:
-                    assert other is not None
-                    type = join_simple(self.declarations[key], type, other)
-            if current_value is None or not is_same_type(type, current_value):
-                self._put(key, type)
+                possible_types = []
+                for t in resulting_values:
+                    assert t is not None
+                    possible_types.append(t.type)
+                if len(possible_types) == 1:
+                    # This is to avoid calling get_proper_type() unless needed, as this may
+                    # interfere with our (hacky) TypeGuard support.
+                    type = possible_types[0]
+                else:
+                    type = make_simplified_union(possible_types)
+                    # Legacy guard for corner case when the original type is TypeVarType.
+                    if isinstance(declaration_type, TypeVarType) and not is_subtype(
+                        type, declaration_type
+                    ):
+                        type = declaration_type
+                    # Try simplifying resulting type for unions involving variadic tuples.
+                    # Technically, everything is still valid without this step, but if we do
+                    # not do this, this may create long unions after exiting an if check like:
+                    #     x: tuple[int, ...]
+                    #     if len(x) < 10:
+                    #         ...
+                    # We want the type of x to be tuple[int, ...] after this block (if it is
+                    # still equivalent to such type).
+                    if isinstance(type, UnionType):
+                        type = collapse_variadic_union(type)
+                    if (
+                        old_semantics
+                        and isinstance(type, ProperType)
+                        and isinstance(type, UnionType)
+                    ):
+                        # Simplify away any extra Any's that were added to the declared
+                        # type when popping a frame.
+                        simplified = UnionType.make_union(
+                            [t for t in type.items if not isinstance(get_proper_type(t), AnyType)]
+                        )
+                        if simplified == self.declarations[key]:
+                            type = simplified
+            if current_value is None or not is_same_type(type, current_value.type):
+                self._put(key, type, from_assignment=True)
                 changed = True
 
         self.frames[-1].unreachable = not frames
@@ -263,9 +347,14 @@ def accumulate_type_assignments(self) -> Iterator[Assigns]:
         yield self.type_assignments
         self.type_assignments = old_assignments
 
-    def assign_type(
-        self, expr: Expression, type: Type, declared_type: Type | None, restrict_any: bool = False
-    ) -> None:
+    def assign_type(self, expr: Expression, type: Type, declared_type: Type | None) -> None:
+        """Narrow type of expression through an assignment.
+
+        Do nothing if the expression doesn't support narrowing.
+
+        When not narrowing though an assignment (isinstance() etc.), use put()
+        directly. This omits some special-casing logic for assignments.
+        """
         # We should erase last known value in binder, because if we are using it,
         # it means that the target is not final, and therefore can't hold a literal.
         type = remove_instance_last_known_values(type)
@@ -276,7 +365,7 @@ def assign_type(
             self.type_assignments[expr].append((type, declared_type))
             return
         if not isinstance(expr, (IndexExpr, MemberExpr, NameExpr)):
-            return None
+            return
         if not literal(expr):
             return
         self.invalidate_dependencies(expr)
@@ -296,41 +385,39 @@ def assign_type(
 
         p_declared = get_proper_type(declared_type)
         p_type = get_proper_type(type)
-        enclosing_type = get_proper_type(self.most_recent_enclosing_type(expr, type))
-        if isinstance(enclosing_type, AnyType) and not restrict_any:
-            # If x is Any and y is int, after x = y we do not infer that x is int.
-            # This could be changed.
-            # Instead, since we narrowed type from Any in a recent frame (probably an
-            # isinstance check), but now it is reassigned, we broaden back
-            # to Any (which is the most recent enclosing type)
-            self.put(expr, enclosing_type)
-        # As a special case, when assigning Any to a variable with a
-        # declared Optional type that has been narrowed to None,
-        # replace all the Nones in the declared Union type with Any.
-        # This overrides the normal behavior of ignoring Any assignments to variables
-        # in order to prevent false positives.
-        # (See discussion in #3526)
-        elif (
-            isinstance(p_type, AnyType)
-            and isinstance(p_declared, UnionType)
-            and any(isinstance(get_proper_type(item), NoneType) for item in p_declared.items)
-            and isinstance(
-                get_proper_type(self.most_recent_enclosing_type(expr, NoneType())), NoneType
-            )
-        ):
-            # Replace any Nones in the union type with Any
-            new_items = [
-                type if isinstance(get_proper_type(item), NoneType) else item
-                for item in p_declared.items
-            ]
-            self.put(expr, UnionType(new_items))
-        elif isinstance(p_type, AnyType) and not (
-            isinstance(p_declared, UnionType)
-            and any(isinstance(get_proper_type(item), AnyType) for item in p_declared.items)
-        ):
-            # Assigning an Any value doesn't affect the type to avoid false negatives, unless
-            # there is an Any item in a declared union type.
-            self.put(expr, declared_type)
+        if isinstance(p_type, AnyType):
+            # Any type requires some special casing, for both historical reasons,
+            # and to optimise user experience without sacrificing correctness too much.
+            if isinstance(expr, RefExpr) and isinstance(expr.node, Var) and expr.node.is_inferred:
+                # First case: a local/global variable without explicit annotation,
+                # in this case we just assign Any (essentially following the SSA logic).
+                self.put(expr, type)
+            elif isinstance(p_declared, UnionType) and any(
+                isinstance(get_proper_type(item), NoneType) for item in p_declared.items
+            ):
+                # Second case: explicit optional type, in this case we optimize for a common
+                # pattern when an untyped value used as a fallback replacing None.
+                new_items = [
+                    type if isinstance(get_proper_type(item), NoneType) else item
+                    for item in p_declared.items
+                ]
+                self.put(expr, UnionType(new_items))
+            elif isinstance(p_declared, UnionType) and any(
+                isinstance(get_proper_type(item), AnyType) for item in p_declared.items
+            ):
+                # Third case: a union already containing Any (most likely from an un-imported
+                # name), in this case we allow assigning Any as well.
+                self.put(expr, type)
+            else:
+                # In all other cases we don't narrow to Any to minimize false negatives.
+                self.put(expr, declared_type)
+        elif isinstance(p_declared, AnyType):
+            # Mirroring the first case above, we don't narrow to a precise type if the variable
+            # has an explicit `Any` type annotation.
+            if isinstance(expr, RefExpr) and isinstance(expr.node, Var) and expr.node.is_inferred:
+                self.put(expr, type)
+            else:
+                self.put(expr, declared_type)
         else:
             self.put(expr, type)
 
@@ -352,17 +439,6 @@ def invalidate_dependencies(self, expr: BindableExpression) -> None:
         for dep in self.dependencies.get(key, set()):
             self._cleanse_key(dep)
 
-    def most_recent_enclosing_type(self, expr: BindableExpression, type: Type) -> Type | None:
-        type = get_proper_type(type)
-        if isinstance(type, AnyType):
-            return get_declaration(expr)
-        key = literal_hash(expr)
-        assert key is not None
-        enclosers = [get_declaration(expr)] + [
-            f.types[key] for f in self.frames if key in f.types and is_subtype(type, f.types[key])
-        ]
-        return enclosers[-1]
-
     def allow_jump(self, index: int) -> None:
         # self.frames and self.options_on_return have different lengths
         # so make sure the index is positive
@@ -453,6 +529,11 @@ def top_frame_context(self) -> Iterator[Frame]:
 
 
 def get_declaration(expr: BindableExpression) -> Type | None:
+    """Get the declared or inferred type of a RefExpr expression.
+
+    Return None if there is no type or the expression is not a RefExpr.
+    This can return None if the type hasn't been inferred yet.
+    """
     if isinstance(expr, RefExpr):
         if isinstance(expr.node, Var):
             type = expr.node.type
@@ -461,3 +542,63 @@ def get_declaration(expr: BindableExpression) -> Type | None:
         elif isinstance(expr.node, TypeInfo):
             return TypeType(fill_typevars_with_any(expr.node))
     return None
+
+
+def collapse_variadic_union(typ: UnionType) -> Type:
+    """Simplify a union involving variadic tuple if possible.
+
+    This will collapse a type like e.g.
+        tuple[X, Z] | tuple[X, Y, Z] | tuple[X, Y, Y, *tuple[Y, ...], Z]
+    back to
+        tuple[X, *tuple[Y, ...], Z]
+    which is equivalent, but much simpler form of the same type.
+    """
+    tuple_items = []
+    other_items = []
+    for t in typ.items:
+        p_t = get_proper_type(t)
+        if isinstance(p_t, TupleType):
+            tuple_items.append(p_t)
+        else:
+            other_items.append(t)
+    if len(tuple_items) <= 1:
+        # This type cannot be simplified further.
+        return typ
+    tuple_items = sorted(tuple_items, key=lambda t: len(t.items))
+    first = tuple_items[0]
+    last = tuple_items[-1]
+    unpack_index = find_unpack_in_list(last.items)
+    if unpack_index is None:
+        return typ
+    unpack = last.items[unpack_index]
+    assert isinstance(unpack, UnpackType)
+    unpacked = get_proper_type(unpack.type)
+    if not isinstance(unpacked, Instance):
+        return typ
+    assert unpacked.type.fullname == "builtins.tuple"
+    suffix = last.items[unpack_index + 1 :]
+
+    # Check that first item matches the expected pattern and infer prefix.
+    if len(first.items) < len(suffix):
+        return typ
+    if suffix and first.items[-len(suffix) :] != suffix:
+        return typ
+    if suffix:
+        prefix = first.items[: -len(suffix)]
+    else:
+        prefix = first.items
+
+    # Check that all middle types match the expected pattern as well.
+    arg = unpacked.args[0]
+    for i, it in enumerate(tuple_items[1:-1]):
+        if it.items != prefix + [arg] * (i + 1) + suffix:
+            return typ
+
+    # Check the last item (the one with unpack), and choose an appropriate simplified type.
+    if last.items != prefix + [arg] * (len(typ.items) - 1) + [unpack] + suffix:
+        return typ
+    if len(first.items) == 0:
+        simplified: Type = unpacked.copy_modified()
+    else:
+        simplified = TupleType(prefix + [unpack] + suffix, fallback=last.partial_fallback)
+    return UnionType.make_union([simplified] + other_items)
diff --git a/mypy/build.py b/mypy/build.py
index c239afb56236..355ba861385e 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -8,6 +8,7 @@
 
 The function build() is the main interface to this module.
 """
+
 # TODO: More consistent terminology, e.g. path/fnam, module/id, state/file
 
 from __future__ import annotations
@@ -24,29 +25,25 @@
 import sys
 import time
 import types
+from collections.abc import Iterator, Mapping, Sequence, Set as AbstractSet
 from typing import (
     TYPE_CHECKING,
-    AbstractSet,
     Any,
     Callable,
     ClassVar,
-    Dict,
-    Iterable,
-    Iterator,
-    Mapping,
+    Final,
     NamedTuple,
     NoReturn,
-    Sequence,
     TextIO,
-    TypeVar,
+    TypedDict,
 )
-from typing_extensions import Final, TypeAlias as _TypeAlias
-
-from mypy_extensions import TypedDict
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.semanal_main
 from mypy.checker import TypeChecker
+from mypy.error_formatter import OUTPUT_CHOICES, ErrorFormatter
 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
@@ -57,10 +54,9 @@
     DecodeError,
     decode_python_encoding,
     get_mypy_comments,
-    get_top_two_prefixes,
     hash_digest,
     is_stub_package_file,
-    is_sub_path,
+    is_sub_path_normabs,
     is_typeshed_file,
     module_prefix,
     read_py_file,
@@ -93,14 +89,10 @@
 from mypy.plugins.default import DefaultPlugin
 from mypy.renaming import LimitedVariableRenameVisitor, VariableRenameVisitor
 from mypy.stats import dump_type_stats
-from mypy.stubinfo import (
-    is_legacy_bundled_package,
-    legacy_bundled_packages,
-    non_bundled_packages,
-    stub_package_name,
-)
+from mypy.stubinfo import is_module_from_legacy_bundled_package, stub_distribution_name
 from mypy.types import Type
 from mypy.typestate import reset_global_state, type_state
+from mypy.util import json_dumps, json_loads
 from mypy.version import __version__
 
 # Switch to True to produce debug output related to fine-grained incremental
@@ -116,13 +108,16 @@
     "types",
     "typing_extensions",
     "mypy_extensions",
-    "_importlib_modulespec",
+    "_typeshed",
+    "_collections_abc",
+    "collections",
+    "collections.abc",
     "sys",
     "abc",
 }
 
 
-Graph: _TypeAlias = Dict[str, "State"]
+Graph: _TypeAlias = dict[str, "State"]
 
 
 # TODO: Get rid of BuildResult.  We might as well return a BuildManager.
@@ -150,7 +145,7 @@ def build(
     sources: list[BuildSource],
     options: Options,
     alt_lib_path: str | None = None,
-    flush_errors: Callable[[list[str], bool], None] | None = None,
+    flush_errors: Callable[[str | None, list[str], bool], None] | None = None,
     fscache: FileSystemCache | None = None,
     stdout: TextIO | None = None,
     stderr: TextIO | None = None,
@@ -182,7 +177,9 @@ def build(
     # fields for callers that want the traditional API.
     messages = []
 
-    def default_flush_errors(new_messages: list[str], is_serious: bool) -> None:
+    def default_flush_errors(
+        filename: str | None, new_messages: list[str], is_serious: bool
+    ) -> None:
         messages.extend(new_messages)
 
     flush_errors = flush_errors or default_flush_errors
@@ -202,7 +199,7 @@ def default_flush_errors(new_messages: list[str], is_serious: bool) -> None:
         # Patch it up to contain either none or all none of the messages,
         # depending on whether we are flushing errors.
         serious = not e.use_stdout
-        flush_errors(e.messages, serious)
+        flush_errors(None, e.messages, serious)
         e.messages = messages
         raise
 
@@ -211,15 +208,16 @@ def _build(
     sources: list[BuildSource],
     options: Options,
     alt_lib_path: str | None,
-    flush_errors: Callable[[list[str], bool], None],
+    flush_errors: Callable[[str | None, list[str], bool], None],
     fscache: FileSystemCache | None,
     stdout: TextIO,
     stderr: TextIO,
     extra_plugins: Sequence[Plugin],
 ) -> BuildResult:
     if platform.python_implementation() == "CPython":
-        # This seems the most reasonable place to tune garbage collection.
-        gc.set_threshold(150 * 1000)
+        # Run gc less frequently, as otherwise we can spent a large fraction of
+        # cpu in gc. This seems the most reasonable place to tune garbage collection.
+        gc.set_threshold(200 * 1000, 30, 30)
 
     data_dir = default_data_dir()
     fscache = fscache or FileSystemCache()
@@ -255,12 +253,14 @@ def _build(
         plugin=plugin,
         plugins_snapshot=snapshot,
         errors=errors,
+        error_formatter=None if options.output is None else OUTPUT_CHOICES.get(options.output),
         flush_errors=flush_errors,
         fscache=fscache,
         stdout=stdout,
         stderr=stderr,
     )
-    manager.trace(repr(options))
+    if manager.verbosity() >= 2:
+        manager.trace(repr(options))
 
     reset_global_state()
     try:
@@ -341,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:
@@ -602,10 +604,11 @@ def __init__(
         plugin: Plugin,
         plugins_snapshot: dict[str, str],
         errors: Errors,
-        flush_errors: Callable[[list[str], bool], None],
+        flush_errors: Callable[[str | None, list[str], bool], None],
         fscache: FileSystemCache,
         stdout: TextIO,
         stderr: TextIO,
+        error_formatter: ErrorFormatter | None = None,
     ) -> None:
         self.stats: dict[str, Any] = {}  # Values are ints or floats
         self.stdout = stdout
@@ -614,6 +617,7 @@ def __init__(
         self.data_dir = data_dir
         self.errors = errors
         self.errors.set_ignore_prefix(ignore_prefix)
+        self.error_formatter = error_formatter
         self.search_paths = search_paths
         self.source_set = source_set
         self.reports = reports
@@ -659,9 +663,7 @@ 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)
+            path = self.find_module_cache.find_module(module, fast_path=True)
             if not isinstance(path, str):
                 raise CompileError(
                     [f"Failed to find builtin module {module}, perhaps typeshed is broken?"]
@@ -684,9 +686,7 @@ def __init__(
         # for efficient lookup
         self.shadow_map: dict[str, str] = {}
         if self.options.shadow_file is not None:
-            self.shadow_map = {
-                source_file: shadow_file for (source_file, shadow_file) in self.options.shadow_file
-            }
+            self.shadow_map = dict(self.options.shadow_file)
         # a mapping from each file being typechecked to its possible shadow file
         self.shadow_equivalence_map: dict[str, str | None] = {}
         self.plugin = plugin
@@ -735,8 +735,8 @@ def maybe_swap_for_shadow_path(self, path: str) -> str:
         shadow_file = self.shadow_equivalence_map.get(path)
         return shadow_file if shadow_file else path
 
-    def get_stat(self, path: str) -> os.stat_result:
-        return self.fscache.stat(self.maybe_swap_for_shadow_path(path))
+    def get_stat(self, path: str) -> os.stat_result | None:
+        return self.fscache.stat_or_none(self.maybe_swap_for_shadow_path(path))
 
     def getmtime(self, path: str) -> int:
         """Return a file's mtime; but 0 in bazel mode.
@@ -857,7 +857,7 @@ def load_fine_grained_deps(self, id: str) -> dict[str, set[str]]:
         t0 = time.time()
         if id in self.fg_deps_meta:
             # TODO: Assert deps file wasn't changed.
-            deps = json.loads(self.metastore.read(self.fg_deps_meta[id]["path"]))
+            deps = json_loads(self.metastore.read(self.fg_deps_meta[id]["path"]))
         else:
             deps = {}
         val = {k: set(v) for k, v in deps.items()}
@@ -910,8 +910,8 @@ def stats_summary(self) -> Mapping[str, object]:
         return self.stats
 
 
-def deps_to_json(x: dict[str, set[str]]) -> str:
-    return json.dumps({k: list(v) for k, v in x.items()}, separators=(",", ":"))
+def deps_to_json(x: dict[str, set[str]]) -> bytes:
+    return json_dumps({k: list(v) for k, v in x.items()})
 
 
 # File for storing metadata about all the fine-grained dependency caches
@@ -973,13 +973,15 @@ def write_deps_cache(
         if st.source_hash:
             hash = st.source_hash
         else:
-            assert st.meta, "Module must be either parsed or cached"
-            hash = st.meta.hash
+            if st.meta:
+                hash = st.meta.hash
+            else:
+                hash = ""
         meta_snapshot[id] = hash
 
     meta = {"snapshot": meta_snapshot, "deps_meta": fg_deps_meta}
 
-    if not metastore.write(DEPS_META_FILE, json.dumps(meta, separators=(",", ":"))):
+    if not metastore.write(DEPS_META_FILE, json_dumps(meta)):
         manager.log(f"Error writing fine-grained deps meta JSON file {DEPS_META_FILE}")
         error = True
 
@@ -1047,8 +1049,11 @@ def generate_deps_for_cache(manager: BuildManager, graph: Graph) -> dict[str, di
 
 def write_plugins_snapshot(manager: BuildManager) -> None:
     """Write snapshot of versions and hashes of currently active plugins."""
-    snapshot = json.dumps(manager.plugins_snapshot, separators=(",", ":"))
-    if not manager.metastore.write(PLUGIN_SNAPSHOT_FILE, snapshot):
+    snapshot = json_dumps(manager.plugins_snapshot)
+    if (
+        not manager.metastore.write(PLUGIN_SNAPSHOT_FILE, snapshot)
+        and manager.options.cache_dir != os.devnull
+    ):
         manager.errors.set_file(_cache_dir_prefix(manager.options), None, manager.options)
         manager.errors.report(0, 0, "Error writing plugins snapshot", blocker=True)
 
@@ -1064,7 +1069,7 @@ def read_plugins_snapshot(manager: BuildManager) -> dict[str, str] | None:
     if snapshot is None:
         return None
     if not isinstance(snapshot, dict):
-        manager.log(f"Could not load plugins snapshot: cache is not a dict: {type(snapshot)}")
+        manager.log(f"Could not load plugins snapshot: cache is not a dict: {type(snapshot)}")  # type: ignore[unreachable]
         return None
     return snapshot
 
@@ -1078,8 +1083,8 @@ def read_quickstart_file(
         # just ignore it.
         raw_quickstart: dict[str, Any] = {}
         try:
-            with open(options.quickstart_file) as f:
-                raw_quickstart = json.load(f)
+            with open(options.quickstart_file, "rb") as f:
+                raw_quickstart = json_loads(f.read())
 
             quickstart = {}
             for file, (x, y, z) in raw_quickstart.items():
@@ -1122,7 +1127,7 @@ def read_deps_cache(manager: BuildManager, graph: Graph) -> dict[str, FgDepMeta]
     module_deps_metas = deps_meta["deps_meta"]
     assert isinstance(module_deps_metas, dict)
     if not manager.options.skip_cache_mtime_checks:
-        for id, meta in module_deps_metas.items():
+        for meta in module_deps_metas.values():
             try:
                 matched = manager.getmtime(meta["path"]) == meta["mtime"]
             except FileNotFoundError:
@@ -1147,10 +1152,10 @@ def _load_json_file(
     manager.add_stats(metastore_read_time=time.time() - t0)
     # Only bother to compute the log message if we are logging it, since it could be big
     if manager.verbosity() >= 2:
-        manager.trace(log_success + data.rstrip())
+        manager.trace(log_success + data.rstrip().decode())
     try:
         t1 = time.time()
-        result = json.loads(data)
+        result = json_loads(data)
         manager.add_stats(data_json_load_time=time.time() - t1)
     except json.JSONDecodeError:
         manager.errors.set_file(file, None, manager.options)
@@ -1280,7 +1285,7 @@ def find_cache_meta(id: str, path: str, manager: BuildManager) -> CacheMeta | No
     if meta is None:
         return None
     if not isinstance(meta, dict):
-        manager.log(f"Could not load cache for {id}: meta cache is not a dict: {repr(meta)}")
+        manager.log(f"Could not load cache for {id}: meta cache is not a dict: {repr(meta)}")  # type: ignore[unreachable]
         return None
     m = cache_meta_from_dict(meta, data_json)
     t2 = time.time()
@@ -1342,8 +1347,8 @@ def find_cache_meta(id: str, path: str, manager: BuildManager) -> CacheMeta | No
     # So that plugins can return data with tuples in it without
     # things silently always invalidating modules, we round-trip
     # the config data. This isn't beautiful.
-    plugin_data = json.loads(
-        json.dumps(manager.plugin.report_config_data(ReportConfigContext(id, path, is_check=True)))
+    plugin_data = json_loads(
+        json_dumps(manager.plugin.report_config_data(ReportConfigContext(id, path, is_check=True)))
     )
     if m.plugin_data != plugin_data:
         manager.log(f"Metadata abandoned for {id}: plugin configuration differs")
@@ -1393,9 +1398,9 @@ def validate_meta(
     if bazel:
         # Normalize path under bazel to make sure it isn't absolute
         path = normpath(path, manager.options)
-    try:
-        st = manager.get_stat(path)
-    except OSError:
+
+    st = manager.get_stat(path)
+    if st is None:
         return None
     if not stat.S_ISDIR(st.st_mode) and not stat.S_ISREG(st.st_mode):
         manager.log(f"Metadata abandoned for {id}: file or directory {path} does not exist")
@@ -1477,10 +1482,7 @@ def validate_meta(
                 "ignore_all": meta.ignore_all,
                 "plugin_data": meta.plugin_data,
             }
-            if manager.options.debug_cache:
-                meta_str = json.dumps(meta_dict, indent=2, sort_keys=True)
-            else:
-                meta_str = json.dumps(meta_dict, separators=(",", ":"))
+            meta_bytes = json_dumps(meta_dict, manager.options.debug_cache)
             meta_json, _, _ = get_cache_names(id, path, manager.options)
             manager.log(
                 "Updating mtime for {}: file {}, meta {}, mtime {}".format(
@@ -1488,7 +1490,7 @@ def validate_meta(
                 )
             )
             t1 = time.time()
-            manager.metastore.write(meta_json, meta_str)  # Ignore errors, just an optimization.
+            manager.metastore.write(meta_json, meta_bytes)  # Ignore errors, just an optimization.
             manager.add_stats(validate_update_time=time.time() - t1, validate_munging_time=t1 - t0)
             return meta
 
@@ -1506,13 +1508,6 @@ def compute_hash(text: str) -> str:
     return hash_digest(text.encode("utf-8"))
 
 
-def json_dumps(obj: Any, debug_cache: bool) -> str:
-    if debug_cache:
-        return json.dumps(obj, indent=2, sort_keys=True)
-    else:
-        return json.dumps(obj, sort_keys=True, separators=(",", ":"))
-
-
 def write_cache(
     id: str,
     path: str,
@@ -1565,16 +1560,15 @@ def write_cache(
 
     # Serialize data and analyze interface
     data = tree.serialize()
-    data_str = json_dumps(data, manager.options.debug_cache)
-    interface_hash = compute_hash(data_str)
+    data_bytes = json_dumps(data, manager.options.debug_cache)
+    interface_hash = hash_digest(data_bytes)
 
     plugin_data = manager.plugin.report_config_data(ReportConfigContext(id, path, is_check=False))
 
     # Obtain and set up metadata
-    try:
-        st = manager.get_stat(path)
-    except OSError as err:
-        manager.log(f"Cannot get stat for {path}: {err}")
+    st = manager.get_stat(path)
+    if st is None:
+        manager.log(f"Cannot get stat for {path}")
         # Remove apparently-invalid cache files.
         # (This is purely an optimization.)
         for filename in [data_json, meta_json]:
@@ -1591,7 +1585,7 @@ def write_cache(
         manager.trace(f"Interface for {id} is unchanged")
     else:
         manager.trace(f"Interface for {id} has changed")
-        if not metastore.write(data_json, data_str):
+        if not metastore.write(data_json, data_bytes):
             # Most likely the error is the replace() call
             # (see https://github.com/python/mypy/issues/3215).
             manager.log(f"Error writing data JSON file {data_json}")
@@ -1996,7 +1990,7 @@ def __init__(
                 raise ModuleNotFound
 
             # Parse the file (and then some) to get the dependencies.
-            self.parse_file()
+            self.parse_file(temporary=temporary)
             self.compute_dependencies()
 
     @property
@@ -2095,7 +2089,7 @@ def load_tree(self, temporary: bool = False) -> None:
             self.meta.data_json, self.manager, "Load tree ", "Could not load tree: "
         )
         if data is None:
-            return None
+            return
 
         t0 = time.time()
         # TODO: Assert data file wasn't changed.
@@ -2114,7 +2108,7 @@ def fix_cross_refs(self) -> None:
 
     # Methods for processing modules from source code.
 
-    def parse_file(self) -> None:
+    def parse_file(self, *, temporary: bool = False) -> None:
         """Parse file and run first pass of semantic analysis.
 
         Everything done here is local to the file. Don't depend on imported
@@ -2149,10 +2143,12 @@ def parse_file(self) -> None:
                     # other systems, but os.strerror(ioerr.errno) does not, so we use that.
                     # (We want the error messages to be platform-independent so that the
                     # tests have predictable output.)
+                    assert ioerr.errno is not None
                     raise CompileError(
                         [
                             "mypy: can't read file '{}': {}".format(
-                                self.path, os.strerror(ioerr.errno)
+                                self.path.replace(os.getcwd() + os.sep, ""),
+                                os.strerror(ioerr.errno),
                             )
                         ],
                         module_with_blocker=self.id,
@@ -2176,8 +2172,8 @@ def parse_file(self) -> None:
                     self.id,
                     self.xpath,
                     source,
-                    self.ignore_all or self.options.ignore_errors,
-                    self.options,
+                    ignore_errors=self.ignore_all or self.options.ignore_errors,
+                    options=self.options,
                 )
 
             else:
@@ -2199,12 +2195,14 @@ def parse_file(self) -> None:
         else:
             self.early_errors = manager.ast_cache[self.id][1]
 
-        modules[self.id] = self.tree
+        if not temporary:
+            modules[self.id] = self.tree
 
         if not cached:
             self.semantic_analysis_pass1()
 
-        self.check_blockers()
+        if not temporary:
+            self.check_blockers()
 
         manager.ast_cache[self.id] = (self.tree, self.early_errors)
 
@@ -2238,12 +2236,14 @@ 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:
-            # Always perform some low-key variable renaming
-            self.tree.accept(LimitedVariableRenameVisitor())
+            if not self.options.allow_redefinition_new:
+                # Perform some low-key variable renaming when assignments can't
+                # widen inferred types
+                self.tree.accept(LimitedVariableRenameVisitor())
             if options.allow_redefinition:
                 # Perform more renaming across the AST to allow variable redefinitions
                 self.tree.accept(VariableRenameVisitor())
@@ -2375,23 +2375,20 @@ def finish_passes(self) -> None:
             # We should always patch indirect dependencies, even in full (non-incremental) builds,
             # because the cache still may be written, and it must be correct.
             # TODO: find a more robust way to traverse *all* relevant types?
-            expr_types = set(self.type_map().values())
-            symbol_types = set()
+            all_types = list(self.type_map().values())
             for _, sym, _ in self.tree.local_definitions():
                 if sym.type is not None:
-                    symbol_types.add(sym.type)
+                    all_types.append(sym.type)
                 if isinstance(sym.node, TypeInfo):
                     # TypeInfo symbols have some extra relevant types.
-                    symbol_types.update(sym.node.bases)
+                    all_types.extend(sym.node.bases)
                     if sym.node.metaclass_type:
-                        symbol_types.add(sym.node.metaclass_type)
+                        all_types.append(sym.node.metaclass_type)
                     if sym.node.typeddict_type:
-                        symbol_types.add(sym.node.typeddict_type)
+                        all_types.append(sym.node.typeddict_type)
                     if sym.node.tuple_type:
-                        symbol_types.add(sym.node.tuple_type)
-            self._patch_indirect_dependencies(
-                self.type_checker().module_refs, expr_types | symbol_types
-            )
+                        all_types.append(sym.node.tuple_type)
+            self._patch_indirect_dependencies(self.type_checker().module_refs, all_types)
 
             if self.options.dump_inference_stats:
                 dump_type_stats(
@@ -2420,7 +2417,7 @@ def free_state(self) -> None:
             self._type_checker.reset()
             self._type_checker = None
 
-    def _patch_indirect_dependencies(self, module_refs: set[str], types: set[Type]) -> None:
+    def _patch_indirect_dependencies(self, module_refs: set[str], types: list[Type]) -> None:
         assert None not in types
         valid = self.valid_references()
 
@@ -2637,7 +2634,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:
@@ -2664,14 +2661,14 @@ def find_module_and_diagnose(
         # search path or the module has not been installed.
 
         ignore_missing_imports = options.ignore_missing_imports
-        top_level, second_level = get_top_two_prefixes(id)
+
         # Don't honor a global (not per-module) ignore_missing_imports
         # setting for modules that used to have bundled stubs, as
         # otherwise updating mypy can silently result in new false
         # negatives. (Unless there are stubs but they are incomplete.)
         global_ignore_missing_imports = manager.options.ignore_missing_imports
         if (
-            (is_legacy_bundled_package(top_level) or is_legacy_bundled_package(second_level))
+            is_module_from_legacy_bundled_package(id)
             and global_ignore_missing_imports
             and not options.ignore_missing_imports_per_module
             and result is ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED
@@ -2719,7 +2716,9 @@ def exist_added_packages(suppressed: list[str], manager: BuildManager, options:
 
 def find_module_simple(id: str, manager: BuildManager) -> str | None:
     """Find a filesystem path for module `id` or `None` if not found."""
-    x = find_module_with_reason(id, manager)
+    t0 = time.time()
+    x = manager.find_module_cache.find_module(id, fast_path=True)
+    manager.add_stats(find_module_time=time.time() - t0, find_module_calls=1)
     if isinstance(x, ModuleNotFoundReason):
         return None
     return x
@@ -2728,7 +2727,7 @@ def find_module_simple(id: str, manager: BuildManager) -> str | None:
 def find_module_with_reason(id: str, manager: BuildManager) -> ModuleSearchResult:
     """Find a filesystem path for module `id` or the reason it can't be found."""
     t0 = time.time()
-    x = manager.find_module_cache.find_module(id)
+    x = manager.find_module_cache.find_module(id, fast_path=False)
     manager.add_stats(find_module_time=time.time() - t0, find_module_calls=1)
     return x
 
@@ -2779,16 +2778,26 @@ def module_not_found(
     else:
         daemon = manager.options.fine_grained_incremental
         msg, notes = reason.error_message_templates(daemon)
-        errors.report(line, 0, msg.format(module=target), code=codes.IMPORT)
-        top_level, second_level = get_top_two_prefixes(target)
-        if second_level in legacy_bundled_packages or second_level in non_bundled_packages:
-            top_level = second_level
+        if reason == ModuleNotFoundReason.NOT_FOUND:
+            code = codes.IMPORT_NOT_FOUND
+        elif (
+            reason == ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS
+            or reason == ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED
+        ):
+            code = codes.IMPORT_UNTYPED
+        else:
+            code = codes.IMPORT
+        errors.report(line, 0, msg.format(module=target), code=code)
+
+        dist = stub_distribution_name(target)
         for note in notes:
             if "{stub_dist}" in note:
-                note = note.format(stub_dist=stub_package_name(top_level))
-            errors.report(line, 0, note, severity="note", only_once=True, code=codes.IMPORT)
+                assert dist is not None
+                note = note.format(stub_dist=dist)
+            errors.report(line, 0, note, severity="note", only_once=True, code=code)
         if reason is ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED:
-            manager.missing_stub_packages.add(stub_package_name(top_level))
+            assert dist is not None
+            manager.missing_stub_packages.add(dist)
     errors.set_import_context(save_import_context)
 
 
@@ -2834,10 +2843,14 @@ def skipping_ancestor(manager: BuildManager, id: str, path: str, ancestor_for: S
 def log_configuration(manager: BuildManager, sources: list[BuildSource]) -> None:
     """Output useful configuration information to LOG and TRACE"""
 
+    config_file = manager.options.config_file
+    if config_file:
+        config_file = os.path.abspath(config_file)
+
     manager.log()
     configuration_vars = [
         ("Mypy Version", __version__),
-        ("Config File", (manager.options.config_file or "Default")),
+        ("Config File", (config_file or "Default")),
         ("Configured Executable", manager.options.python_executable or "None"),
         ("Current Executable", sys.executable),
         ("Cache Dir", manager.options.cache_dir),
@@ -2852,7 +2865,7 @@ def log_configuration(manager: BuildManager, sources: list[BuildSource]) -> None
         manager.log(f"{'Found source:':24}{source}")
 
     # Complete list of searched paths can get very long, put them under TRACE
-    for path_type, paths in manager.search_paths._asdict().items():
+    for path_type, paths in manager.search_paths.asdict().items():
         if not paths:
             manager.trace(f"No {path_type}")
             continue
@@ -3012,7 +3025,7 @@ def dump_graph(graph: Graph, stdout: TextIO | None = None) -> None:
             if state.path:
                 try:
                     size = os.path.getsize(state.path)
-                except os.error:
+                except OSError:
                     pass
             node.sizes[mod] = size
             for dep in state.dependencies:
@@ -3076,7 +3089,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 +3177,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",
                             )
@@ -3366,7 +3379,7 @@ def order_ascc(graph: Graph, ascc: AbstractSet[str], pri_max: int = PRI_ALL) ->
     strongly_connected_components() below for a reference.
     """
     if len(ascc) == 1:
-        return [s for s in ascc]
+        return list(ascc)
     pri_spread = set()
     for id in ascc:
         state = graph[id]
@@ -3443,7 +3456,11 @@ def process_stale_scc(graph: Graph, scc: list[str], manager: BuildManager) -> No
         for id in stale:
             graph[id].transitive_error = True
     for id in stale:
-        manager.flush_errors(manager.errors.file_messages(graph[id].xpath), False)
+        if graph[id].xpath not in manager.errors.ignored_files:
+            errors = manager.errors.file_messages(
+                graph[id].xpath, formatter=manager.error_formatter
+            )
+            manager.flush_errors(manager.errors.simplify_path(graph[id].xpath), errors, False)
         graph[id].write_cache()
         graph[id].mark_as_rechecked()
 
@@ -3465,15 +3482,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
@@ -3498,100 +3508,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")
 
@@ -3616,10 +3532,9 @@ def is_silent_import_module(manager: BuildManager, path: str) -> bool:
     if manager.options.no_silence_site_packages:
         return False
     # Silence errors in site-package dirs and typeshed
-    return any(
-        is_sub_path(path, dir)
-        for dir in manager.search_paths.package_path + manager.search_paths.typeshed_path
-    )
+    if any(is_sub_path_normabs(path, dir) for dir in manager.search_paths.package_path):
+        return True
+    return any(is_sub_path_normabs(path, dir) for dir in manager.search_paths.typeshed_path)
 
 
 def write_undocumented_ref_info(
@@ -3640,4 +3555,4 @@ def write_undocumented_ref_info(
     assert not ref_info_file.startswith(".")
 
     deps_json = get_undocumented_ref_info_json(state.tree, type_map)
-    metastore.write(ref_info_file, json.dumps(deps_json, separators=(",", ":")))
+    metastore.write(ref_info_file, json_dumps(deps_json))
diff --git a/mypy/checker.py b/mypy/checker.py
index c1c31538b7de..9c389cccd95f 100644
--- a/mypy/checker.py
+++ b/mypy/checker.py
@@ -4,51 +4,37 @@
 
 import itertools
 from collections import defaultdict
-from contextlib import contextmanager, nullcontext
-from typing import (
-    AbstractSet,
-    Callable,
-    Dict,
-    Generic,
-    Iterable,
-    Iterator,
-    Mapping,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from collections.abc import Iterable, Iterator, Mapping, Sequence, Set as AbstractSet
+from contextlib import ExitStack, contextmanager
+from typing import Callable, Final, Generic, NamedTuple, Optional, TypeVar, Union, cast, overload
+from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
 
 import mypy.checkexpr
-from mypy import errorcodes as codes, message_registry, nodes, operators
+from mypy import errorcodes as codes, join, message_registry, nodes, operators
 from mypy.binder import ConditionalTypeBinder, Frame, get_declaration
+from mypy.checker_shared import CheckerScope, TypeCheckerSharedApi, TypeRange
 from mypy.checkmember import (
     MemberContext,
-    analyze_decorator_or_funcbase_access,
-    analyze_descriptor_access,
+    analyze_class_attribute_access,
+    analyze_instance_member_access,
     analyze_member_access,
-    type_object_type,
+    is_instance_var,
 )
 from mypy.checkpattern import PatternChecker
 from mypy.constraints import SUPERTYPE_OF
 from mypy.erasetype import erase_type, erase_typevars, remove_instance_last_known_values
 from mypy.errorcodes import TYPE_VAR, UNUSED_AWAITABLE, UNUSED_COROUTINE, ErrorCode
 from mypy.errors import Errors, ErrorWatcher, report_internal_error
-from mypy.expandtype import expand_self_type, expand_type, expand_type_by_instance
-from mypy.join import join_types
+from mypy.expandtype import expand_type
 from mypy.literals import Key, extract_var_from_literal_hash, literal, literal_hash
 from mypy.maptype import map_instance_to_supertype
-from mypy.meet import is_overlapping_erased_types, is_overlapping_types
+from mypy.meet import is_overlapping_erased_types, is_overlapping_types, meet_types
 from mypy.message_registry import ErrorMessage
 from mypy.messages import (
     SUGGESTED_TEST_FIXTURES,
     MessageBuilder,
     append_invariance_notes,
+    append_union_note,
     format_type,
     format_type_bare,
     format_type_distinctly,
@@ -71,6 +57,7 @@
     LITERAL_TYPE,
     MDEF,
     NOT_ABSTRACT,
+    SYMBOL_FUNCBASE_TYPES,
     AssertStmt,
     AssignmentExpr,
     AssignmentStmt,
@@ -92,6 +79,7 @@
     FuncBase,
     FuncDef,
     FuncItem,
+    GlobalDecl,
     IfStmt,
     Import,
     ImportAll,
@@ -107,6 +95,7 @@
     MypyFile,
     NameExpr,
     Node,
+    NonlocalDecl,
     OperatorAssignmentStmt,
     OpExpr,
     OverloadedFuncDef,
@@ -125,17 +114,21 @@
     TryStmt,
     TupleExpr,
     TypeAlias,
+    TypeAliasStmt,
     TypeInfo,
     TypeVarExpr,
     UnaryExpr,
     Var,
     WhileStmt,
     WithStmt,
+    YieldExpr,
     is_final_node,
 )
-from mypy.options import Options
+from mypy.operators import flip_ops, int_op_to_method, neg_ops
+from mypy.options import PRECISE_TUPLE_TYPES, Options
 from mypy.patterns import AsPattern, StarredPattern
-from mypy.plugin import CheckerPluginInterface, Plugin
+from mypy.plugin import 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
@@ -143,6 +136,7 @@
 from mypy.state import state
 from mypy.subtypes import (
     find_member,
+    infer_class_variances,
     is_callable_compatible,
     is_equivalent,
     is_more_precise,
@@ -165,17 +159,16 @@
     false_only,
     fixup_partial_type,
     function_type,
-    get_type_vars,
     is_literal_type_like,
     is_singleton_type,
     make_simplified_union,
-    map_type_from_supertype,
     true_only,
     try_expanding_sum_type_to_union,
     try_getting_int_literals_from_type,
     try_getting_str_literals,
     try_getting_str_literals_from_type,
     tuple_fallback,
+    type_object_type,
 )
 from mypy.types import (
     ANY_STRATEGY,
@@ -203,37 +196,43 @@
     TypeType,
     TypeVarId,
     TypeVarLikeType,
+    TypeVarTupleType,
     TypeVarType,
     UnboundType,
     UninhabitedType,
     UnionType,
+    UnpackType,
+    find_unpack_in_list,
     flatten_nested_unions,
     get_proper_type,
     get_proper_types,
     is_literal_type,
     is_named_instance,
 )
-from mypy.types_utils import is_optional, remove_optional, store_argument_type, strip_type
+from mypy.types_utils import is_overlapping_none, remove_optional, store_argument_type, strip_type
 from mypy.typetraverser import TypeTraverserVisitor
 from mypy.typevars import fill_typevars, fill_typevars_with_any, has_no_typevars
-from mypy.util import is_dunder, is_sunder, is_typeshed_file
+from mypy.util import is_dunder, is_sunder
 from mypy.visitor import NodeVisitor
 
 T = TypeVar("T")
 
-DEFAULT_LAST_PASS: Final = 1  # Pass numbers start at 0
+DEFAULT_LAST_PASS: Final = 2  # Pass numbers start at 0
+
+# Maximum length of fixed tuple types inferred when narrowing from variadic tuples.
+MAX_PRECISE_TUPLE_SIZE: Final = 8
 
-DeferredNodeType: _TypeAlias = Union[FuncDef, LambdaExpr, OverloadedFuncDef, Decorator]
+DeferredNodeType: _TypeAlias = Union[FuncDef, OverloadedFuncDef, Decorator]
 FineGrainedDeferredNodeType: _TypeAlias = Union[FuncDef, MypyFile, OverloadedFuncDef]
 
 
 # A node which is postponed to be processed during the next pass.
 # In normal mode one can defer functions and methods (also decorated and/or overloaded)
-# and lambda expressions. Nested functions can't be deferred -- only top-level functions
+# but not lambda expressions. Nested functions can't be deferred -- only top-level functions
 # and methods of classes not defined within a function can be deferred.
 class DeferredNode(NamedTuple):
     node: DeferredNodeType
-    # And its TypeInfo (for semantic analysis self type handling
+    # And its TypeInfo (for semantic analysis self type handling)
     active_typeinfo: TypeInfo | None
 
 
@@ -257,14 +256,7 @@ class FineGrainedDeferredNode(NamedTuple):
 # (such as two references to the same variable). TODO: it would
 # probably be better to have the dict keyed by the nodes' literal_hash
 # field instead.
-TypeMap: _TypeAlias = Optional[Dict[Expression, Type]]
-
-
-# An object that represents either a precise type or a type with an upper bound;
-# it is important for correct type inference with isinstance.
-class TypeRange(NamedTuple):
-    item: Type
-    is_upper_bound: bool  # False => precise type
+TypeMap: _TypeAlias = Optional[dict[Expression, Type]]
 
 
 # Keeps track of partial types in a single scope. In fine-grained incremental
@@ -276,7 +268,7 @@ class PartialTypeScope(NamedTuple):
     is_local: bool
 
 
-class TypeChecker(NodeVisitor[None], CheckerPluginInterface):
+class TypeChecker(NodeVisitor[None], TypeCheckerSharedApi):
     """Mypy type checker.
 
     Type check mypy source files that have been semantically analyzed.
@@ -303,7 +295,7 @@ class TypeChecker(NodeVisitor[None], CheckerPluginInterface):
     # Helper for managing conditional types
     binder: ConditionalTypeBinder
     # Helper for type checking expressions
-    expr_checker: mypy.checkexpr.ExpressionChecker
+    _expr_checker: mypy.checkexpr.ExpressionChecker
 
     pattern_checker: PatternChecker
 
@@ -318,6 +310,9 @@ class TypeChecker(NodeVisitor[None], CheckerPluginInterface):
     # Vars for which partial type errors are already reported
     # (to avoid logically duplicate errors with different error context).
     partial_reported: set[Var]
+    # Short names of Var nodes whose previous inferred type has been widened via assignment.
+    # NOTE: The names might not be unique, they are only for debugging purposes.
+    widened_vars: list[str]
     globals: SymbolTable
     modules: dict[str, MypyFile]
     # Nodes that couldn't be checked because some types weren't available. We'll run
@@ -378,7 +373,7 @@ def __init__(
         self.plugin = plugin
         self.tscope = Scope()
         self.scope = CheckerScope(tree)
-        self.binder = ConditionalTypeBinder()
+        self.binder = ConditionalTypeBinder(options)
         self.globals = tree.names
         self.return_types = []
         self.dynamic_funcs = []
@@ -386,12 +381,13 @@ def __init__(
         self.partial_reported = set()
         self.var_decl_frames = {}
         self.deferred_nodes = []
+        self.widened_vars = []
         self._type_maps = [{}]
         self.module_refs = set()
         self.pass_num = 0
         self.current_node_deferred = False
         self.is_stub = tree.is_stub
-        self.is_typeshed_stub = is_typeshed_file(options.abs_custom_typeshed_dir, path)
+        self.is_typeshed_stub = tree.is_typeshed_file(options)
         self.inferred_attribute_types = None
 
         # If True, process function definitions. If False, don't. This is used
@@ -414,14 +410,18 @@ def __init__(
         self.allow_abstract_call = False
 
         # Child checker objects for specific AST node types
-        self.expr_checker = mypy.checkexpr.ExpressionChecker(
+        self._expr_checker = mypy.checkexpr.ExpressionChecker(
             self, self.msg, self.plugin, per_line_checking_time_ns
         )
         self.pattern_checker = PatternChecker(self, self.msg, self.plugin, options)
 
+    @property
+    def expr_checker(self) -> mypy.checkexpr.ExpressionChecker:
+        return self._expr_checker
+
     @property
     def type_context(self) -> list[Type | None]:
-        return self.expr_checker.type_context
+        return self._expr_checker.type_context
 
     def reset(self) -> None:
         """Cleanup stale state that might be left over from a typechecking run.
@@ -432,17 +432,15 @@ def reset(self) -> None:
         # TODO: verify this is still actually worth it over creating new checkers
         self.partial_reported.clear()
         self.module_refs.clear()
-        self.binder = ConditionalTypeBinder()
+        self.binder = ConditionalTypeBinder(self.options)
         self._type_maps[1:] = []
         self._type_maps[0].clear()
         self.temp_type_map = None
         self.expr_checker.reset()
-
-        assert self.inferred_attribute_types is None
-        assert self.partial_types == []
-        assert self.deferred_nodes == []
-        assert len(self.scope.stack) == 1
-        assert self.partial_types == []
+        self.deferred_nodes = []
+        self.partial_types = []
+        self.inferred_attribute_types = None
+        self.scope = CheckerScope(self.tree)
 
     def check_first_pass(self) -> None:
         """Type check the entire file, but defer functions with unresolved references.
@@ -462,14 +460,14 @@ def check_first_pass(self) -> None:
             with self.tscope.module_scope(self.tree.fullname):
                 with self.enter_partial_types(), self.binder.top_frame_context():
                     for d in self.tree.defs:
-                        if (
-                            self.binder.is_unreachable()
-                            and self.should_report_unreachable_issues()
-                            and not self.is_raising_or_empty(d)
-                        ):
-                            self.msg.unreachable_statement(d)
-                            break
-                        self.accept(d)
+                        if self.binder.is_unreachable():
+                            if not self.should_report_unreachable_issues():
+                                break
+                            if not self.is_noop_for_reachability(d):
+                                self.msg.unreachable_statement(d)
+                                break
+                        else:
+                            self.accept(d)
 
                 assert not self.current_node_deferred
 
@@ -517,23 +515,20 @@ def check_second_pass(
                     # print("XXX in pass %d, class %s, function %s" %
                     #       (self.pass_num, type_name, node.fullname or node.name))
                     done.add(node)
-                    with self.tscope.class_scope(
-                        active_typeinfo
-                    ) if active_typeinfo else nullcontext():
-                        with self.scope.push_class(
-                            active_typeinfo
-                        ) if active_typeinfo else nullcontext():
-                            self.check_partial(node)
+                    with ExitStack() as stack:
+                        if active_typeinfo:
+                            stack.enter_context(self.tscope.class_scope(active_typeinfo))
+                            stack.enter_context(self.scope.push_class(active_typeinfo))
+                        self.check_partial(node)
             return True
 
     def check_partial(self, node: DeferredNodeType | FineGrainedDeferredNodeType) -> None:
+        self.widened_vars = []
         if isinstance(node, MypyFile):
             self.check_top_level(node)
         else:
             self.recurse_into_functions = True
-            if isinstance(node, LambdaExpr):
-                self.expr_checker.accept(node)
-            else:
+            with self.binder.top_frame_context():
                 self.accept(node)
 
     def check_top_level(self, node: MypyFile) -> None:
@@ -561,13 +556,13 @@ def defer_node(self, node: DeferredNodeType, enclosing_class: TypeInfo | None) -
         self.deferred_nodes.append(DeferredNode(node, enclosing_class))
 
     def handle_cannot_determine_type(self, name: str, context: Context) -> None:
-        node = self.scope.top_non_lambda_function()
+        node = self.scope.top_level_function()
         if self.pass_num < self.last_pass and isinstance(node, FuncDef):
             # Don't report an error yet. Just defer. Note that we don't defer
             # lambdas because they are coupled to the surrounding function
             # through the binder and the inferred type of the lambda, so it
             # would get messy.
-            enclosing_class = self.scope.enclosing_class()
+            enclosing_class = self.scope.enclosing_class(node)
             self.defer_node(node, enclosing_class)
             # Set a marker so that we won't infer additional types in this
             # function. Any inferred types could be bogus, because there's at
@@ -589,22 +584,70 @@ def accept_loop(
         else_body: Statement | None = None,
         *,
         exit_condition: Expression | None = None,
+        on_enter_body: Callable[[], None] | None = None,
     ) -> None:
-        """Repeatedly type check a loop body until the frame doesn't change.
-        If exit_condition is set, assume it must be False on exit from the loop.
+        """Repeatedly type check a loop body until the frame doesn't change."""
 
-        Then check the else_body.
-        """
-        # The outer frame accumulates the results of all iterations
+        # The outer frame accumulates the results of all iterations:
         with self.binder.frame_context(can_skip=False, conditional_frame=True):
+            # Check for potential decreases in the number of partial types so as not to stop the
+            # iteration too early:
+            partials_old = sum(len(pts.map) for pts in self.partial_types)
+            # Check if assignment widened the inferred type of a variable; in this case we
+            # need to iterate again (we only do one extra iteration, since this could go
+            # on without bound otherwise)
+            widened_old = len(self.widened_vars)
+
+            # Disable error types that we cannot safely identify in intermediate iteration steps:
+            warn_unreachable = self.options.warn_unreachable
+            warn_redundant = codes.REDUNDANT_EXPR in self.options.enabled_error_codes
+            self.options.warn_unreachable = False
+            self.options.enabled_error_codes.discard(codes.REDUNDANT_EXPR)
+
+            iter = 1
             while True:
                 with self.binder.frame_context(can_skip=True, break_frame=2, continue_frame=1):
+                    if on_enter_body is not None:
+                        on_enter_body()
+
                     self.accept(body)
-                if not self.binder.last_pop_changed:
+                partials_new = sum(len(pts.map) for pts in self.partial_types)
+                widened_new = len(self.widened_vars)
+                # Perform multiple iterations if something changed that might affect
+                # inferred types. Also limit the number of iterations. The limits are
+                # somewhat arbitrary, but they were chosen to 1) avoid slowdown from
+                # multiple iterations in common cases and 2) support common, valid use
+                # cases. Limits are needed since otherwise we could infer infinitely
+                # complex types.
+                if (
+                    (partials_new == partials_old)
+                    and (not self.binder.last_pop_changed or iter > 3)
+                    and (widened_new == widened_old or iter > 1)
+                ):
                     break
+                partials_old = partials_new
+                widened_old = widened_new
+                iter += 1
+                if iter == 20:
+                    raise RuntimeError("Too many iterations when checking a loop")
+
+            # If necessary, reset the modified options and make up for the postponed error checks:
+            self.options.warn_unreachable = warn_unreachable
+            if warn_redundant:
+                self.options.enabled_error_codes.add(codes.REDUNDANT_EXPR)
+            if warn_unreachable or warn_redundant:
+                with self.binder.frame_context(can_skip=True, break_frame=2, continue_frame=1):
+                    if on_enter_body is not None:
+                        on_enter_body()
+
+                    self.accept(body)
+
+            # If exit_condition is set, assume it must be False on exit from the loop:
             if exit_condition:
                 _, else_map = self.find_isinstance_check(exit_condition)
                 self.push_type_map(else_map)
+
+            # Check the else body:
             if else_body:
                 self.accept(else_body)
 
@@ -623,7 +666,7 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         if not defn.items:
             # In this case we have already complained about none of these being
             # valid overloads.
-            return None
+            return
         if len(defn.items) == 1:
             self.fail(message_registry.MULTIPLE_OVERLOADS_REQUIRED, defn)
 
@@ -631,29 +674,150 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             # HACK: Infer the type of the property.
             assert isinstance(defn.items[0], Decorator)
             self.visit_decorator(defn.items[0])
-        for fdef in defn.items:
+            if defn.items[0].var.is_settable_property:
+                # TODO: here and elsewhere we assume setter immediately follows getter.
+                assert isinstance(defn.items[1], Decorator)
+                # Perform a reduced visit just to infer the actual setter type.
+                self.visit_decorator_inner(defn.items[1], skip_first_item=True)
+                setter_type = defn.items[1].var.type
+                # Check if the setter can accept two positional arguments.
+                any_type = AnyType(TypeOfAny.special_form)
+                fallback_setter_type = CallableType(
+                    arg_types=[any_type, any_type],
+                    arg_kinds=[ARG_POS, ARG_POS],
+                    arg_names=[None, None],
+                    ret_type=any_type,
+                    fallback=self.named_type("builtins.function"),
+                )
+                if setter_type and not is_subtype(setter_type, fallback_setter_type):
+                    self.fail("Invalid property setter signature", defn.items[1].func)
+                setter_type = self.extract_callable_type(setter_type, defn)
+                if not isinstance(setter_type, CallableType) or len(setter_type.arg_types) != 2:
+                    # TODO: keep precise type for callables with tricky but valid signatures.
+                    setter_type = fallback_setter_type
+                defn.items[0].var.setter_type = setter_type
+        for i, fdef in enumerate(defn.items):
             assert isinstance(fdef, Decorator)
-            self.check_func_item(fdef.func, name=fdef.func.name, allow_empty=True)
+            if defn.is_property:
+                assert isinstance(defn.items[0], Decorator)
+                settable = defn.items[0].var.is_settable_property
+                # Do not visit the second time the items we checked above.
+                if (settable and i > 1) or (not settable and i > 0):
+                    self.check_func_item(fdef.func, name=fdef.func.name, allow_empty=True)
+            else:
+                # Perform full check for real overloads to infer type of all decorated
+                # overload variants.
+                self.visit_decorator_inner(fdef, allow_empty=True)
             if fdef.func.abstract_status in (IS_ABSTRACT, IMPLICITLY_ABSTRACT):
                 num_abstract += 1
         if num_abstract not in (0, len(defn.items)):
             self.fail(message_registry.INCONSISTENT_ABSTRACT_OVERLOAD, defn)
         if defn.impl:
             defn.impl.accept(self)
+        if not defn.is_property:
+            self.check_overlapping_overloads(defn)
+            if defn.type is None:
+                item_types = []
+                for item in defn.items:
+                    assert isinstance(item, Decorator)
+                    item_type = self.extract_callable_type(item.var.type, item)
+                    if item_type is not None:
+                        item_types.append(item_type)
+                if item_types:
+                    defn.type = Overloaded(item_types)
+        elif defn.type is None:
+            # We store the getter type as an overall overload type, as some
+            # code paths are getting property type this way.
+            assert isinstance(defn.items[0], Decorator)
+            var_type = self.extract_callable_type(defn.items[0].var.type, defn)
+            if not isinstance(var_type, CallableType):
+                # Construct a fallback type, invalid types should be already reported.
+                any_type = AnyType(TypeOfAny.special_form)
+                var_type = CallableType(
+                    arg_types=[any_type],
+                    arg_kinds=[ARG_POS],
+                    arg_names=[None],
+                    ret_type=any_type,
+                    fallback=self.named_type("builtins.function"),
+                )
+            defn.type = Overloaded([var_type])
+        # Check override validity after we analyzed current definition.
         if defn.info:
-            found_base_method = self.check_method_override(defn)
-            if defn.is_explicit_override and found_base_method is False:
+            found_method_base_classes = self.check_method_override(defn)
+            if (
+                defn.is_explicit_override
+                and not found_method_base_classes
+                and found_method_base_classes is not None
+                # If the class has Any fallback, we can't be certain that a method
+                # is really missing - it might come from unfollowed import.
+                and not defn.info.fallback_to_any
+            ):
                 self.msg.no_overridable_method(defn.name, defn)
+            self.check_explicit_override_decorator(defn, found_method_base_classes, defn.impl)
             self.check_inplace_operator_method(defn)
-        if not defn.is_property:
-            self.check_overlapping_overloads(defn)
-        return None
+
+    def extract_callable_type(self, inner_type: Type | None, ctx: Context) -> CallableType | None:
+        """Get type as seen by an overload item caller."""
+        inner_type = get_proper_type(inner_type)
+        outer_type: FunctionLike | None = None
+        if inner_type is None or isinstance(inner_type, AnyType):
+            return None
+        if isinstance(inner_type, TypeVarLikeType):
+            inner_type = get_proper_type(inner_type.upper_bound)
+        if isinstance(inner_type, TypeType):
+            inner_type = get_proper_type(
+                self.expr_checker.analyze_type_type_callee(inner_type.item, ctx)
+            )
+
+        if isinstance(inner_type, FunctionLike):
+            outer_type = inner_type
+        elif isinstance(inner_type, Instance):
+            inner_call = get_proper_type(
+                analyze_member_access(
+                    name="__call__",
+                    typ=inner_type,
+                    context=ctx,
+                    is_lvalue=False,
+                    is_super=False,
+                    is_operator=True,
+                    original_type=inner_type,
+                    chk=self,
+                )
+            )
+            if isinstance(inner_call, FunctionLike):
+                outer_type = inner_call
+        elif isinstance(inner_type, UnionType):
+            union_type = make_simplified_union(inner_type.items)
+            if isinstance(union_type, UnionType):
+                items = []
+                for item in union_type.items:
+                    callable_item = self.extract_callable_type(item, ctx)
+                    if callable_item is None:
+                        break
+                    items.append(callable_item)
+                else:
+                    joined_type = get_proper_type(join.join_type_list(items))
+                    if isinstance(joined_type, FunctionLike):
+                        outer_type = joined_type
+            else:
+                return self.extract_callable_type(union_type, ctx)
+
+        if outer_type is None:
+            self.msg.not_callable(inner_type, ctx)
+            return None
+        if isinstance(outer_type, Overloaded):
+            return None
+
+        assert isinstance(outer_type, CallableType)
+        return outer_type
 
     def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
         # At this point we should have set the impl already, and all remaining
         # items are decorators
 
-        if self.msg.errors.file in self.msg.errors.ignored_files:
+        if self.msg.errors.file in self.msg.errors.ignored_files or (
+            self.is_typeshed_stub and self.options.test_env
+        ):
             # This is a little hacky, however, the quadratic check here is really expensive, this
             # method has no side effects, so we should skip it if we aren't going to report
             # anything. In some other places we swallow errors in stubs, but this error is very
@@ -672,40 +836,20 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
 
             # This can happen if we've got an overload with a different
             # decorator or if the implementation is untyped -- we gave up on the types.
-            inner_type = get_proper_type(inner_type)
-            if inner_type is not None and not isinstance(inner_type, AnyType):
-                if isinstance(inner_type, CallableType):
-                    impl_type = inner_type
-                elif isinstance(inner_type, Instance):
-                    inner_call = get_proper_type(
-                        analyze_member_access(
-                            name="__call__",
-                            typ=inner_type,
-                            context=defn.impl,
-                            is_lvalue=False,
-                            is_super=False,
-                            is_operator=True,
-                            msg=self.msg,
-                            original_type=inner_type,
-                            chk=self,
-                        )
-                    )
-                    if isinstance(inner_call, CallableType):
-                        impl_type = inner_call
-                if impl_type is None:
-                    self.msg.not_callable(inner_type, defn.impl)
+            impl_type = self.extract_callable_type(inner_type, defn.impl)
 
         is_descriptor_get = defn.info and defn.name == "__get__"
         for i, item in enumerate(defn.items):
-            # TODO overloads involving decorators
             assert isinstance(item, Decorator)
-            sig1 = self.function_type(item.func)
-            assert isinstance(sig1, CallableType)
+            sig1 = self.extract_callable_type(item.var.type, item)
+            if sig1 is None:
+                continue
 
             for j, item2 in enumerate(defn.items[i + 1 :]):
                 assert isinstance(item2, Decorator)
-                sig2 = self.function_type(item2.func)
-                assert isinstance(sig2, CallableType)
+                sig2 = self.extract_callable_type(item2.var.type, item2)
+                if sig2 is None:
+                    continue
 
                 if not are_argument_counts_overlapping(sig1, sig2):
                     continue
@@ -726,16 +870,39 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
                     #     def foo(x: str) -> str: ...
                     #
                     # See Python 2's map function for a concrete example of this kind of overload.
+                    current_class = self.scope.active_class()
+                    type_vars = current_class.defn.type_vars if current_class else []
                     with state.strict_optional_set(True):
-                        if is_unsafe_overlapping_overload_signatures(sig1, sig2):
-                            self.msg.overloaded_signatures_overlap(i + 1, i + j + 2, item.func)
+                        if is_unsafe_overlapping_overload_signatures(sig1, sig2, type_vars):
+                            flip_note = (
+                                j == 0
+                                and not is_unsafe_overlapping_overload_signatures(
+                                    sig2, sig1, type_vars
+                                )
+                                and not overload_can_never_match(sig2, sig1)
+                            )
+                            self.msg.overloaded_signatures_overlap(
+                                i + 1, i + j + 2, flip_note, item.func
+                            )
 
             if impl_type is not None:
                 assert defn.impl is not None
 
+                # This is what we want from implementation, it should accept all arguments
+                # of an overload, but the return types should go the opposite way.
+                if is_callable_compatible(
+                    impl_type,
+                    sig1,
+                    is_compat=is_subtype,
+                    is_proper_subtype=False,
+                    is_compat_return=lambda l, r: is_subtype(r, l),
+                ):
+                    continue
+                # If the above check didn't work, we repeat some key steps in
+                # is_callable_compatible() to give a better error message.
+
                 # We perform a unification step that's very similar to what
-                # 'is_callable_compatible' would have done if we had set
-                # 'unify_generics' to True -- the only difference is that
+                # 'is_callable_compatible' does -- the only difference is that
                 # we check and see if the impl_type's return value is a
                 # *supertype* of the overload alternative, not a *subtype*.
                 #
@@ -762,7 +929,7 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
 
                 # Is the overload alternative's arguments subtypes of the implementation's?
                 if not is_callable_compatible(
-                    impl, sig1, is_compat=is_subtype, ignore_return=True
+                    impl, sig1, is_compat=is_subtype, is_proper_subtype=False, ignore_return=True
                 ):
                     self.msg.overloaded_signatures_arg_specific(i + 1, defn.impl)
 
@@ -952,8 +1119,9 @@ def get_generator_return_type(self, return_type: Type, is_coroutine: bool) -> Ty
             # AwaitableGenerator, Generator: tr is args[2].
             return return_type.args[2]
         else:
-            # Supertype of Generator (Iterator, Iterable, object): tr is any.
-            return AnyType(TypeOfAny.special_form)
+            # We have a supertype of Generator (Iterator, Iterable, object)
+            # Treat `Iterator[X]` as a shorthand for `Generator[X, Any, None]`.
+            return NoneType()
 
     def visit_func_def(self, defn: FuncDef) -> None:
         if not self.recurse_into_functions:
@@ -965,56 +1133,18 @@ def _visit_func_def(self, defn: FuncDef) -> None:
         """Type check a function definition."""
         self.check_func_item(defn, name=defn.name)
         if defn.info:
-            if not defn.is_dynamic() and not defn.is_overload and not defn.is_decorated:
+            if not defn.is_overload and not defn.is_decorated:
                 # If the definition is the implementation for an
                 # overload, the legality of the override has already
                 # been typechecked, and decorated methods will be
                 # checked when the decorator is.
-                self.check_method_override(defn)
+                found_method_base_classes = self.check_method_override(defn)
+                self.check_explicit_override_decorator(defn, found_method_base_classes)
             self.check_inplace_operator_method(defn)
         if defn.original_def:
             # Override previous definition.
             new_type = self.function_type(defn)
-            if isinstance(defn.original_def, FuncDef):
-                # Function definition overrides function definition.
-                old_type = self.function_type(defn.original_def)
-                if not is_same_type(new_type, old_type):
-                    self.msg.incompatible_conditional_function_def(defn, old_type, new_type)
-            else:
-                # Function definition overrides a variable initialized via assignment or a
-                # decorated function.
-                orig_type = defn.original_def.type
-                if orig_type is None:
-                    # If other branch is unreachable, we don't type check it and so we might
-                    # not have a type for the original definition
-                    return
-                if isinstance(orig_type, PartialType):
-                    if orig_type.type is None:
-                        # Ah this is a partial type. Give it the type of the function.
-                        orig_def = defn.original_def
-                        if isinstance(orig_def, Decorator):
-                            var = orig_def.var
-                        else:
-                            var = orig_def
-                        partial_types = self.find_partial_types(var)
-                        if partial_types is not None:
-                            var.type = new_type
-                            del partial_types[var]
-                    else:
-                        # Trying to redefine something like partial empty list as function.
-                        self.fail(message_registry.INCOMPATIBLE_REDEFINITION, defn)
-                else:
-                    name_expr = NameExpr(defn.name)
-                    name_expr.node = defn.original_def
-                    self.binder.assign_type(name_expr, new_type, orig_type)
-                    self.check_subtype(
-                        new_type,
-                        orig_type,
-                        defn,
-                        message_registry.INCOMPATIBLE_REDEFINITION,
-                        "redefinition with type",
-                        "original type",
-                    )
+            self.check_func_def_override(defn, new_type)
 
     def check_func_item(
         self,
@@ -1029,6 +1159,7 @@ def check_func_item(
         """
         self.dynamic_funcs.append(defn.is_dynamic() and not type_override)
 
+        enclosing_node_deferred = self.current_node_deferred
         with self.enter_partial_types(is_function=True):
             typ = self.function_type(defn)
             if type_override:
@@ -1040,10 +1171,58 @@ def check_func_item(
                 raise RuntimeError("Not supported")
 
         self.dynamic_funcs.pop()
-        self.current_node_deferred = False
+        self.current_node_deferred = enclosing_node_deferred
 
         if name == "__exit__":
             self.check__exit__return_type(defn)
+        # TODO: the following logic should move to the dataclasses plugin
+        #  https://github.com/python/mypy/issues/15515
+        if name == "__post_init__":
+            if dataclasses_plugin.is_processed_dataclass(defn.info):
+                dataclasses_plugin.check_post_init(self, defn, defn.info)
+
+    def check_func_def_override(self, defn: FuncDef, new_type: FunctionLike) -> None:
+        assert defn.original_def is not None
+        if isinstance(defn.original_def, FuncDef):
+            # Function definition overrides function definition.
+            old_type = self.function_type(defn.original_def)
+            if not is_same_type(new_type, old_type):
+                self.msg.incompatible_conditional_function_def(defn, old_type, new_type)
+        else:
+            # Function definition overrides a variable initialized via assignment or a
+            # decorated function.
+            orig_type = defn.original_def.type
+            if orig_type is None:
+                # If other branch is unreachable, we don't type check it and so we might
+                # not have a type for the original definition
+                return
+            if isinstance(orig_type, PartialType):
+                if orig_type.type is None:
+                    # Ah this is a partial type. Give it the type of the function.
+                    orig_def = defn.original_def
+                    if isinstance(orig_def, Decorator):
+                        var = orig_def.var
+                    else:
+                        var = orig_def
+                    partial_types = self.find_partial_types(var)
+                    if partial_types is not None:
+                        var.type = new_type
+                        del partial_types[var]
+                else:
+                    # Trying to redefine something like partial empty list as function.
+                    self.fail(message_registry.INCOMPATIBLE_REDEFINITION, defn)
+            else:
+                name_expr = NameExpr(defn.name)
+                name_expr.node = defn.original_def
+                self.binder.assign_type(name_expr, new_type, orig_type)
+                self.check_subtype(
+                    new_type,
+                    orig_type,
+                    defn,
+                    message_registry.INCOMPATIBLE_REDEFINITION,
+                    "redefinition with type",
+                    "original type",
+                )
 
     @contextmanager
     def enter_attribute_inference_context(self) -> Iterator[None]:
@@ -1057,10 +1236,12 @@ def check_func_def(
     ) -> None:
         """Type check a function definition."""
         # Expand type variables with value restrictions to ordinary types.
+        self.check_typevar_defaults(typ.variables)
         expanded = self.expand_typevars(defn, typ)
+        original_typ = typ
         for item, typ in expanded:
             old_binder = self.binder
-            self.binder = ConditionalTypeBinder()
+            self.binder = ConditionalTypeBinder(self.options)
             with self.binder.top_frame_context():
                 defn.expanded.append(item)
 
@@ -1115,6 +1296,12 @@ def check_func_def(
                             message_registry.RETURN_TYPE_CANNOT_BE_CONTRAVARIANT, typ.ret_type
                         )
                     self.check_unbound_return_typevar(typ)
+                elif (
+                    isinstance(original_typ.ret_type, TypeVarType) and original_typ.ret_type.values
+                ):
+                    # Since type vars with values are expanded, the return type is changed
+                    # to a raw value. This is a hack to get it back.
+                    self.check_unbound_return_typevar(original_typ)
 
                 # Check that Generator functions have the appropriate return type.
                 if defn.is_generator:
@@ -1148,51 +1335,71 @@ def check_func_def(
                 # Push return type.
                 self.return_types.append(typ.ret_type)
 
+                with self.scope.push_function(defn):
+                    # We temporary push the definition to get the self type as
+                    # visible from *inside* of this function/method.
+                    ref_type: Type | None = self.scope.active_self_type()
+
+                if typ.type_is:
+                    arg_index = 0
+                    # For methods and classmethods, we want the second parameter
+                    if ref_type is not None and (not defn.is_static or defn.name == "__new__"):
+                        arg_index = 1
+                    if arg_index < len(typ.arg_types) and not is_subtype(
+                        typ.type_is, typ.arg_types[arg_index]
+                    ):
+                        self.fail(
+                            message_registry.NARROWED_TYPE_NOT_SUBTYPE.format(
+                                format_type(typ.type_is, self.options),
+                                format_type(typ.arg_types[arg_index], self.options),
+                            ),
+                            item,
+                        )
+
                 # Store argument types.
                 for i in range(len(typ.arg_types)):
                     arg_type = typ.arg_types[i]
-                    with self.scope.push_function(defn):
-                        # We temporary push the definition to get the self type as
-                        # visible from *inside* of this function/method.
-                        ref_type: Type | None = self.scope.active_self_type()
                     if (
                         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):
-                            if (
-                                isinstance(erased, Instance)
-                                and erased.type.is_protocol
-                                or isinstance(erased, TypeType)
-                                and isinstance(erased.item, Instance)
-                                and erased.item.type.is_protocol
-                            ):
-                                # We allow the explicit self-type to be not a supertype of
-                                # the current class if it is a protocol. For such cases
-                                # the consistency check will be performed at call sites.
-                                msg = None
-                            elif typ.arg_names[i] in {"self", "cls"}:
-                                msg = message_registry.ERASED_SELF_TYPE_NOT_SUPERTYPE.format(
-                                    erased.str_with_options(self.options),
-                                    ref_type.str_with_options(self.options),
-                                )
-                            else:
-                                msg = message_registry.MISSING_OR_INVALID_SELF_TYPE
-                            if msg:
-                                self.fail(msg, defn)
+                        if not is_same_type(arg_type, ref_type):
+                            # This level of erasure matches the one in checkmember.check_self_arg(),
+                            # better keep these two checks consistent.
+                            erased = get_proper_type(erase_typevars(erase_to_bound(arg_type)))
+                            if not is_subtype(ref_type, erased, ignore_type_params=True):
+                                if (
+                                    isinstance(erased, Instance)
+                                    and erased.type.is_protocol
+                                    or isinstance(erased, TypeType)
+                                    and isinstance(erased.item, Instance)
+                                    and erased.item.type.is_protocol
+                                ):
+                                    # We allow the explicit self-type to be not a supertype of
+                                    # the current class if it is a protocol. For such cases
+                                    # the consistency check will be performed at call sites.
+                                    msg = None
+                                elif typ.arg_names[i] in {"self", "cls"}:
+                                    msg = message_registry.ERASED_SELF_TYPE_NOT_SUPERTYPE.format(
+                                        erased.str_with_options(self.options),
+                                        ref_type.str_with_options(self.options),
+                                    )
+                                else:
+                                    msg = message_registry.MISSING_OR_INVALID_SELF_TYPE
+                                if msg:
+                                    self.fail(msg, defn)
                     elif isinstance(arg_type, TypeVarType):
                         # Refuse covariant parameter type variables
                         # TODO: check recursively for inner type variables
-                        if arg_type.variance == COVARIANT and defn.name not in (
-                            "__init__",
-                            "__new__",
+                        if (
+                            arg_type.variance == COVARIANT
+                            and defn.name not in ("__init__", "__new__", "__post_init__")
+                            and not is_private(defn.name)  # private methods are not inherited
                         ):
                             ctx: Context = arg_type
                             if ctx.line < 0:
@@ -1222,14 +1429,29 @@ def check_func_def(
                                 new_frame = self.binder.push_frame()
                             new_frame.types[key] = narrowed_type
                             self.binder.declarations[key] = old_binder.declarations[key]
+
+                if self.options.allow_redefinition_new and not self.is_stub:
+                    # Add formal argument types to the binder.
+                    for arg in defn.arguments:
+                        # TODO: Add these directly using a fast path (possibly "put")
+                        v = arg.variable
+                        if v.type is not None:
+                            n = NameExpr(v.name)
+                            n.node = v
+                            self.binder.assign_type(n, v.type, v.type)
+
                 with self.scope.push_function(defn):
-                    # We suppress reachability warnings when we use TypeVars with value
+                    # We suppress reachability warnings for empty generator functions
+                    # (return; yield) which have a "yield" that's unreachable by definition
+                    # since it's only there to promote the function into a generator function.
+                    #
+                    # We also suppress reachability warnings when we use TypeVars with value
                     # restrictions: we only want to report a warning if a certain statement is
                     # marked as being suppressed in *all* of the expansions, but we currently
                     # have no good way of doing this.
                     #
                     # TODO: Find a way of working around this limitation
-                    if len(expanded) >= 2:
+                    if _is_empty_generator_function(item) or len(expanded) >= 2:
                         self.binder.suppress_unreachable_warnings()
                     self.accept(item.body)
                 unreachable = self.binder.is_unreachable()
@@ -1333,6 +1555,10 @@ def is_var_redefined_in_outer_context(self, v: Var, after_line: int) -> bool:
         Note that this doesn't do a full CFG analysis but uses a line number based
         heuristic that isn't correct in some (rare) cases.
         """
+        if v.is_final:
+            # Final vars are definitely never reassigned.
+            return False
+
         outers = self.tscope.outer_functions()
         if not outers:
             # Top-level function -- outer context is top level, and we can't reason about
@@ -1542,7 +1768,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)
@@ -1655,6 +1881,8 @@ def is_unsafe_overlapping_op(
         # second operand is the right argument -- we switch the order of
         # the arguments of the reverse method.
 
+        # TODO: this manipulation is dangerous if callables are generic.
+        # Shuffling arguments between callables can create meaningless types.
         forward_tweaked = forward_item.copy_modified(
             arg_types=[forward_base_erased, forward_item.arg_types[0]],
             arg_kinds=[nodes.ARG_POS] * 2,
@@ -1679,7 +1907,11 @@ def is_unsafe_overlapping_op(
             first = forward_tweaked
             second = reverse_tweaked
 
-        return is_unsafe_overlapping_overload_signatures(first, second)
+        current_class = self.scope.active_class()
+        type_vars = current_class.defn.type_vars if current_class else []
+        return is_unsafe_overlapping_overload_signatures(
+            first, second, type_vars, partial_only=False
+        )
 
     def check_inplace_operator_method(self, defn: FuncBase) -> None:
         """Check an inplace operator method such as __iadd__.
@@ -1775,7 +2007,7 @@ def check_match_args(self, var: Var, typ: Type, context: Context) -> None:
             return
         typ = get_proper_type(typ)
         if not isinstance(typ, TupleType) or not all(
-            [is_string_literal(item) for item in typ.items]
+            is_string_literal(item) for item in typ.items
         ):
             self.msg.note(
                 "__match_args__ must be a tuple containing string literals for checking "
@@ -1793,7 +2025,6 @@ def expand_typevars(
         if defn.info:
             # Class type variables
             tvars += defn.info.defn.type_vars or []
-        # TODO(PEP612): audit for paramspec
         for tvar in tvars:
             if isinstance(tvar, TypeVarType) and tvar.values:
                 subst.append([(tvar.id, value) for value in tvar.values])
@@ -1809,26 +2040,66 @@ def expand_typevars(
         else:
             return [(defn, typ)]
 
-    def check_method_override(self, defn: FuncDef | OverloadedFuncDef | Decorator) -> bool | None:
+    def check_explicit_override_decorator(
+        self,
+        defn: FuncDef | OverloadedFuncDef,
+        found_method_base_classes: list[TypeInfo] | None,
+        context: Context | None = None,
+    ) -> None:
+        plugin_generated = False
+        if defn.info and (node := defn.info.get(defn.name)) and node.plugin_generated:
+            # Do not report issues for plugin generated nodes,
+            # they can't realistically use `@override` for their methods.
+            plugin_generated = True
+
+        if (
+            not plugin_generated
+            and found_method_base_classes
+            and not defn.is_explicit_override
+            and defn.name not in ("__init__", "__new__")
+            and not is_private(defn.name)
+        ):
+            self.msg.explicit_override_decorator_missing(
+                defn.name, found_method_base_classes[0].fullname, context or defn
+            )
+
+    def check_method_override(
+        self, defn: FuncDef | OverloadedFuncDef | Decorator
+    ) -> list[TypeInfo] | None:
         """Check if function definition is compatible with base classes.
 
         This may defer the method if a signature is not available in at least one base class.
         Return ``None`` if that happens.
 
-        Return ``True`` if an attribute with the method name was found in the base class.
+        Return a list of base classes which contain an attribute with the method name.
         """
         # Check against definitions in base classes.
-        found_base_method = False
+        check_override_compatibility = (
+            defn.name not in ("__init__", "__new__", "__init_subclass__", "__post_init__")
+            and (self.options.check_untyped_defs or not defn.is_dynamic())
+            and (
+                # don't check override for synthesized __replace__ methods from dataclasses
+                defn.name != "__replace__"
+                or defn.info.metadata.get("dataclass_tag") is None
+            )
+        )
+        found_method_base_classes: list[TypeInfo] = []
         for base in defn.info.mro[1:]:
-            result = self.check_method_or_accessor_override_for_base(defn, base)
+            result = self.check_method_or_accessor_override_for_base(
+                defn, base, check_override_compatibility
+            )
             if result is None:
                 # Node was deferred, we will have another attempt later.
                 return None
-            found_base_method |= result
-        return found_base_method
+            if result:
+                found_method_base_classes.append(base)
+        return found_method_base_classes
 
     def check_method_or_accessor_override_for_base(
-        self, defn: FuncDef | OverloadedFuncDef | Decorator, base: TypeInfo
+        self,
+        defn: FuncDef | OverloadedFuncDef | Decorator,
+        base: TypeInfo,
+        check_override_compatibility: bool,
     ) -> bool | None:
         """Check if method definition is compatible with a base class.
 
@@ -1843,16 +2114,14 @@ def check_method_or_accessor_override_for_base(
             base_attr = base.names.get(name)
             if base_attr:
                 # First, check if we override a final (always an error, even with Any types).
-                if is_final_node(base_attr.node):
+                if is_final_node(base_attr.node) and not is_private(name):
                     self.msg.cant_override_final(name, base.name, defn)
                 # Second, final can't override anything writeable independently of types.
                 if defn.is_final:
                     self.check_if_final_var_override_writable(name, base_attr.node, defn)
                 found_base_method = True
-
-            # Check the type of override.
-            if name not in ("__init__", "__new__", "__init_subclass__"):
-                # Check method override
+            if check_override_compatibility:
+                # Check compatibility of the override signature
                 # (__init__, __new__, __init_subclass__ are special).
                 if self.check_method_override_for_base_with_name(defn, name, base):
                     return None
@@ -1867,6 +2136,21 @@ def check_method_or_accessor_override_for_base(
                         return None
         return found_base_method
 
+    def check_setter_type_override(self, defn: OverloadedFuncDef, base: TypeInfo) -> None:
+        """Check override of a setter type of a mutable attribute.
+
+        Currently, this should be only called when either base node or the current node
+        is a custom settable property (i.e. where setter type is different from getter type).
+        Note that this check is contravariant.
+        """
+        typ, _ = self.node_type_from_base(defn.name, defn.info, defn, setter_type=True)
+        original_type, _ = self.node_type_from_base(defn.name, base, defn, setter_type=True)
+        # The caller should handle deferrals.
+        assert typ is not None and original_type is not None
+
+        if not is_subtype(original_type, typ):
+            self.msg.incompatible_setter_override(defn.items[1], typ, original_type, base)
+
     def check_method_override_for_base_with_name(
         self, defn: FuncDef | OverloadedFuncDef | Decorator, name: str, base: TypeInfo
     ) -> bool:
@@ -1875,173 +2159,176 @@ def check_method_override_for_base_with_name(
         Return True if the supertype node was not analysed yet, and `defn` was deferred.
         """
         base_attr = base.names.get(name)
-        if base_attr:
-            # The name of the method is defined in the base class.
+        if not base_attr:
+            return False
+        # The name of the method is defined in the base class.
 
-            # Point errors at the 'def' line (important for backward compatibility
-            # of type ignores).
-            if not isinstance(defn, Decorator):
-                context = defn
-            else:
-                context = defn.func
-
-            # Construct the type of the overriding method.
-            # TODO: this logic is much less complete than similar one in checkmember.py
-            if isinstance(defn, (FuncDef, OverloadedFuncDef)):
-                typ: Type = self.function_type(defn)
-                override_class_or_static = defn.is_class or defn.is_static
-                override_class = defn.is_class
-            else:
-                assert defn.var.is_ready
-                assert defn.var.type is not None
-                typ = defn.var.type
-                override_class_or_static = defn.func.is_class or defn.func.is_static
-                override_class = defn.func.is_class
-            typ = get_proper_type(typ)
-            if isinstance(typ, FunctionLike) and not is_static(context):
-                typ = bind_self(typ, self.scope.active_self_type(), is_classmethod=override_class)
-            # Map the overridden method type to subtype context so that
-            # it can be checked for compatibility.
-            original_type = get_proper_type(base_attr.type)
-            original_node = base_attr.node
-            # `original_type` can be partial if (e.g.) it is originally an
-            # instance variable from an `__init__` block that becomes deferred.
-            if original_type is None or isinstance(original_type, PartialType):
-                if self.pass_num < self.last_pass:
-                    # If there are passes left, defer this node until next pass,
-                    # otherwise try reconstructing the method type from available information.
+        # Point errors at the 'def' line (important for backward compatibility
+        # of type ignores).
+        if not isinstance(defn, Decorator):
+            context = defn
+        else:
+            context = defn.func
+
+        # Construct the type of the overriding method.
+        if isinstance(defn, (FuncDef, OverloadedFuncDef)):
+            override_class_or_static = defn.is_class or defn.is_static
+        else:
+            override_class_or_static = defn.func.is_class or defn.func.is_static
+        typ, _ = self.node_type_from_base(defn.name, defn.info, defn)
+        assert typ is not None
+
+        original_node = base_attr.node
+        # `original_type` can be partial if (e.g.) it is originally an
+        # instance variable from an `__init__` block that becomes deferred.
+        supertype_ready = True
+        original_type, _ = self.node_type_from_base(name, base, defn)
+        if original_type is None:
+            supertype_ready = False
+            if self.pass_num < self.last_pass:
+                # If there are passes left, defer this node until next pass,
+                # otherwise try reconstructing the method type from available information.
+                # For consistency, defer an enclosing top-level function (if any).
+                top_level = self.scope.top_level_function()
+                if isinstance(top_level, FuncDef):
+                    self.defer_node(top_level, self.scope.enclosing_class(top_level))
+                else:
+                    # Specify enclosing class explicitly, as we check type override before
+                    # entering e.g. decorators or overloads.
                     self.defer_node(defn, defn.info)
-                    return True
-                elif isinstance(original_node, (FuncDef, OverloadedFuncDef)):
-                    original_type = self.function_type(original_node)
-                elif isinstance(original_node, Decorator):
-                    original_type = self.function_type(original_node.func)
-                elif isinstance(original_node, Var):
-                    # Super type can define method as an attribute.
-                    # See https://github.com/python/mypy/issues/10134
-
-                    # We also check that sometimes `original_node.type` is None.
-                    # This is the case when we use something like `__hash__ = None`.
-                    if original_node.type is not None:
-                        original_type = get_proper_type(original_node.type)
-                    else:
-                        original_type = NoneType()
+                return True
+            elif isinstance(original_node, (FuncDef, OverloadedFuncDef)):
+                original_type = self.function_type(original_node)
+            elif isinstance(original_node, Decorator):
+                original_type = self.function_type(original_node.func)
+            elif isinstance(original_node, Var):
+                # Super type can define method as an attribute.
+                # See https://github.com/python/mypy/issues/10134
+
+                # We also check that sometimes `original_node.type` is None.
+                # This is the case when we use something like `__hash__ = None`.
+                if original_node.type is not None:
+                    original_type = get_proper_type(original_node.type)
                 else:
-                    # Will always fail to typecheck below, since we know the node is a method
                     original_type = NoneType()
-            if isinstance(original_node, (FuncDef, OverloadedFuncDef)):
-                original_class_or_static = original_node.is_class or original_node.is_static
-            elif isinstance(original_node, Decorator):
-                fdef = original_node.func
-                original_class_or_static = fdef.is_class or fdef.is_static
             else:
-                original_class_or_static = False  # a variable can't be class or static
+                # Will always fail to typecheck below, since we know the node is a method
+                original_type = NoneType()
 
-            if isinstance(original_type, FunctionLike):
-                original_type = self.bind_and_map_method(base_attr, original_type, defn.info, base)
-                if original_node and is_property(original_node):
-                    original_type = get_property_type(original_type)
+        always_allow_covariant = False
+        if is_settable_property(defn) and (
+            is_settable_property(original_node) or isinstance(original_node, Var)
+        ):
+            if is_custom_settable_property(defn) or (is_custom_settable_property(original_node)):
+                # Unlike with getter, where we try to construct some fallback type in case of
+                # deferral during last_pass, we can't make meaningful setter checks if the
+                # supertype is not known precisely.
+                if supertype_ready:
+                    always_allow_covariant = True
+                    self.check_setter_type_override(defn, base)
+
+        if isinstance(original_node, (FuncDef, OverloadedFuncDef)):
+            original_class_or_static = original_node.is_class or original_node.is_static
+        elif isinstance(original_node, Decorator):
+            fdef = original_node.func
+            original_class_or_static = fdef.is_class or fdef.is_static
+        else:
+            original_class_or_static = False  # a variable can't be class or static
 
-            if isinstance(typ, FunctionLike) and is_property(defn):
-                typ = get_property_type(typ)
-                if (
-                    isinstance(original_node, Var)
-                    and not original_node.is_final
-                    and (not original_node.is_property or original_node.is_settable_property)
-                    and isinstance(defn, Decorator)
-                ):
-                    # We only give an error where no other similar errors will be given.
-                    if not isinstance(original_type, AnyType):
-                        self.msg.fail(
-                            "Cannot override writeable attribute with read-only property",
-                            # Give an error on function line to match old behaviour.
-                            defn.func,
-                            code=codes.OVERRIDE,
-                        )
+        typ = get_proper_type(typ)
+        original_type = get_proper_type(original_type)
 
-            if isinstance(original_type, AnyType) or isinstance(typ, AnyType):
-                pass
-            elif isinstance(original_type, FunctionLike) and isinstance(typ, FunctionLike):
-                # Check that the types are compatible.
-                # TODO overloaded signatures
-                self.check_override(
-                    typ,
-                    original_type,
-                    defn.name,
-                    name,
-                    base.name,
-                    original_class_or_static,
-                    override_class_or_static,
-                    context,
+        if (
+            is_property(defn)
+            and isinstance(original_node, Var)
+            and not original_node.is_final
+            and (not original_node.is_property or original_node.is_settable_property)
+            and isinstance(defn, Decorator)
+        ):
+            # We only give an error where no other similar errors will be given.
+            if not isinstance(original_type, AnyType):
+                self.msg.fail(
+                    "Cannot override writeable attribute with read-only property",
+                    # Give an error on function line to match old behaviour.
+                    defn.func,
+                    code=codes.OVERRIDE,
                 )
-            elif is_equivalent(original_type, typ):
-                # Assume invariance for a non-callable attribute here. Note
-                # that this doesn't affect read-only properties which can have
-                # covariant overrides.
-                #
-                pass
-            elif (
+
+        if isinstance(original_type, AnyType) or isinstance(typ, AnyType):
+            pass
+        elif isinstance(original_type, FunctionLike) and isinstance(typ, FunctionLike):
+            # Check that the types are compatible.
+            ok = self.check_override(
+                typ,
+                original_type,
+                defn.name,
+                name,
+                base.name,
+                original_class_or_static,
+                override_class_or_static,
+                context,
+            )
+            # Check if this override is covariant.
+            if (
+                ok
+                and original_node
+                and codes.MUTABLE_OVERRIDE in self.options.enabled_error_codes
+                and self.is_writable_attribute(original_node)
+                and not always_allow_covariant
+                and not is_subtype(original_type, typ, ignore_pos_arg_names=True)
+            ):
+                base_str, override_str = format_type_distinctly(
+                    original_type, typ, options=self.options
+                )
+                msg = message_registry.COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE.with_additional_msg(
+                    f' (base class "{base.name}" defined the type as {base_str},'
+                    f" override has type {override_str})"
+                )
+                self.fail(msg, context)
+        elif isinstance(original_type, UnionType) and any(
+            is_subtype(typ, orig_typ, ignore_pos_arg_names=True)
+            for orig_typ in original_type.items
+        ):
+            # This method is a subtype of at least one union variant.
+            if (
                 original_node
-                and not self.is_writable_attribute(original_node)
-                and is_subtype(typ, original_type)
+                and codes.MUTABLE_OVERRIDE in self.options.enabled_error_codes
+                and self.is_writable_attribute(original_node)
+                and not always_allow_covariant
             ):
-                # If the attribute is read-only, allow covariance
-                pass
-            else:
-                self.msg.signature_incompatible_with_supertype(
-                    defn.name, name, base.name, context, original=original_type, override=typ
+                # Covariant override of mutable attribute.
+                base_str, override_str = format_type_distinctly(
+                    original_type, typ, options=self.options
                 )
-        return False
-
-    def bind_and_map_method(
-        self, sym: SymbolTableNode, typ: FunctionLike, sub_info: TypeInfo, super_info: TypeInfo
-    ) -> FunctionLike:
-        """Bind self-type and map type variables for a method.
-
-        Arguments:
-            sym: a symbol that points to method definition
-            typ: method type on the definition
-            sub_info: class where the method is used
-            super_info: class where the method was defined
-        """
-        if isinstance(sym.node, (FuncDef, OverloadedFuncDef, Decorator)) and not is_static(
-            sym.node
+                msg = message_registry.COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE.with_additional_msg(
+                    f' (base class "{base.name}" defined the type as {base_str},'
+                    f" override has type {override_str})"
+                )
+                self.fail(msg, context)
+        elif is_equivalent(original_type, typ):
+            # Assume invariance for a non-callable attribute here. Note
+            # that this doesn't affect read-only properties which can have
+            # covariant overrides.
+            pass
+        elif (
+            original_node
+            and (not self.is_writable_attribute(original_node) or always_allow_covariant)
+            and is_subtype(typ, original_type)
         ):
-            if isinstance(sym.node, Decorator):
-                is_class_method = sym.node.func.is_class
-            else:
-                is_class_method = sym.node.is_class
-
-            mapped_typ = cast(FunctionLike, map_type_from_supertype(typ, sub_info, super_info))
-            active_self_type = self.scope.active_self_type()
-            if isinstance(mapped_typ, Overloaded) and active_self_type:
-                # If we have an overload, filter to overloads that match the self type.
-                # This avoids false positives for concrete subclasses of generic classes,
-                # see testSelfTypeOverrideCompatibility for an example.
-                filtered_items = []
-                for item in mapped_typ.items:
-                    if not item.arg_types:
-                        filtered_items.append(item)
-                    item_arg = item.arg_types[0]
-                    if isinstance(item_arg, TypeVarType):
-                        item_arg = item_arg.upper_bound
-                    if is_subtype(active_self_type, item_arg):
-                        filtered_items.append(item)
-                # If we don't have any filtered_items, maybe it's always a valid override
-                # of the superclass? However if you get to that point you're in murky type
-                # territory anyway, so we just preserve the type and have the behaviour match
-                # that of older versions of mypy.
-                if filtered_items:
-                    mapped_typ = Overloaded(filtered_items)
-
-            return bind_self(mapped_typ, active_self_type, is_class_method)
+            # If the attribute is read-only, allow covariance
+            pass
         else:
-            return cast(FunctionLike, map_type_from_supertype(typ, sub_info, super_info))
+            self.msg.signature_incompatible_with_supertype(
+                defn.name, name, base.name, context, original=original_type, override=typ
+            )
+        return False
 
     def get_op_other_domain(self, tp: FunctionLike) -> Type | None:
         if isinstance(tp, CallableType):
             if tp.arg_kinds and tp.arg_kinds[0] == ARG_POS:
-                return tp.arg_types[0]
+                # For generic methods, domain comparison is tricky, as a first
+                # approximation erase all remaining type variables.
+                return erase_typevars(tp.arg_types[0], {v.id for v in tp.variables})
             return None
         elif isinstance(tp, Overloaded):
             raw_items = [self.get_op_other_domain(it) for it in tp.items]
@@ -2062,15 +2349,22 @@ def check_override(
         original_class_or_static: bool,
         override_class_or_static: bool,
         node: Context,
-    ) -> None:
+    ) -> bool:
         """Check a method override with given signatures.
 
         Arguments:
-          override:  The signature of the overriding method.
-          original:  The signature of the original supertype method.
-          name:      The name of the subtype. This and the next argument are
-                     only used for generating error messages.
-          supertype: The name of the supertype.
+          override:                 The signature of the overriding method.
+          original:                 The signature of the original supertype method.
+          name:                     The name of the overriding method.
+                                    Used primarily for generating error messages.
+          name_in_super:            The name of the overridden in the superclass.
+                                    Used for generating error messages only.
+          supertype:                The name of the supertype.
+          original_class_or_static: Indicates whether the original method (from the superclass)
+                                    is either a class method or a static method.
+          override_class_or_static: Indicates whether the overriding method (from the subclass)
+                                    is either a class method or a static method.
+          node:                     Context node.
         """
         # Use boolean variable to clarify code.
         fail = False
@@ -2095,6 +2389,8 @@ def check_override(
             elif isinstance(original, CallableType) and isinstance(override, CallableType):
                 if original.type_guard is not None and override.type_guard is None:
                     fail = True
+                if original.type_is is not None and override.type_is is None:
+                    fail = True
 
         if is_private(name):
             fail = False
@@ -2102,6 +2398,7 @@ def check_override(
         if fail:
             emitted_msg = False
 
+            offset_arguments = isinstance(override, CallableType) and override.unpack_kwargs
             # Normalize signatures, so we get better diagnostics.
             if isinstance(override, (CallableType, Overloaded)):
                 override = override.with_unpacked_kwargs()
@@ -2132,22 +2429,34 @@ def check_override(
                 def erase_override(t: Type) -> Type:
                     return erase_typevars(t, ids_to_erase=override_ids)
 
-                for i in range(len(override.arg_types)):
-                    if not is_subtype(
-                        original.arg_types[i], erase_override(override.arg_types[i])
-                    ):
-                        arg_type_in_super = original.arg_types[i]
-
-                        if isinstance(node, FuncDef):
-                            context: Context = node.arguments[i + len(override.bound_args)]
+                for i, (sub_kind, super_kind) in enumerate(
+                    zip(override.arg_kinds, original.arg_kinds)
+                ):
+                    if sub_kind.is_positional() and super_kind.is_positional():
+                        override_arg_type = override.arg_types[i]
+                        original_arg_type = original.arg_types[i]
+                    elif sub_kind.is_named() and super_kind.is_named() and not offset_arguments:
+                        arg_name = override.arg_names[i]
+                        if arg_name in original.arg_names:
+                            override_arg_type = override.arg_types[i]
+                            original_i = original.arg_names.index(arg_name)
+                            original_arg_type = original.arg_types[original_i]
                         else:
-                            context = node
+                            continue
+                    else:
+                        continue
+                    if not is_subtype(original_arg_type, erase_override(override_arg_type)):
+                        context: Context = node
+                        if isinstance(node, FuncDef) and not node.is_property:
+                            arg_node = node.arguments[i + len(override.bound_args)]
+                            if arg_node.line != -1:
+                                context = arg_node
                         self.msg.argument_incompatible_with_supertype(
                             i + 1,
                             name,
                             type_name,
                             name_in_super,
-                            arg_type_in_super,
+                            original_arg_type,
                             supertype,
                             context,
                             secondary_context=node,
@@ -2191,6 +2500,7 @@ def erase_override(t: Type) -> Type:
                     node,
                     code=codes.OVERRIDE,
                 )
+        return not fail
 
     def check__exit__return_type(self, defn: FuncItem) -> None:
         """Generate error if the return type of __exit__ is problematic.
@@ -2225,7 +2535,7 @@ def visit_class_def(self, defn: ClassDef) -> None:
                 self.fail(message_registry.CANNOT_INHERIT_FROM_FINAL.format(base.name), defn)
         with self.tscope.class_scope(defn.info), self.enter_partial_types(is_class=True):
             old_binder = self.binder
-            self.binder = ConditionalTypeBinder()
+            self.binder = ConditionalTypeBinder(self.options)
             with self.binder.top_frame_context():
                 with self.scope.push_class(defn.info):
                     self.accept(defn.defs)
@@ -2265,7 +2575,7 @@ def visit_class_def(self, defn: ClassDef) -> None:
                     self.allow_abstract_call = old_allow_abstract_call
                 # TODO: Apply the sig to the actual TypeInfo so we can handle decorators
                 # that completely swap out the type.  (e.g. Callable[[Type[A]], Type[B]])
-        if typ.defn.type_vars:
+        if typ.defn.type_vars and typ.defn.type_args is None:
             for base_inst in typ.bases:
                 for base_tvar, base_decl_tvar in zip(
                     base_inst.args, base_inst.type.defn.type_vars
@@ -2282,11 +2592,14 @@ def visit_class_def(self, defn: ClassDef) -> None:
                             context=defn,
                             code=codes.TYPE_VAR,
                         )
+        if typ.defn.type_vars:
+            self.check_typevar_defaults(typ.defn.type_vars)
 
         if typ.is_protocol and typ.defn.type_vars:
             self.check_protocol_variance(defn)
         if not defn.has_incompatible_baseclass and defn.info.is_enum:
             self.check_enum(defn)
+        infer_class_variances(defn.info)
 
     def check_final_deletable(self, typ: TypeInfo) -> None:
         # These checks are only for mypyc. Only perform some checks that are easier
@@ -2344,30 +2657,47 @@ def check_init_subclass(self, defn: ClassDef) -> None:
             # all other bases have already been checked.
             break
 
+    def check_typevar_defaults(self, tvars: Sequence[TypeVarLikeType]) -> None:
+        for tv in tvars:
+            if not (isinstance(tv, TypeVarType) and tv.has_default()):
+                continue
+            if not is_subtype(tv.default, tv.upper_bound):
+                self.fail("TypeVar default must be a subtype of the bound type", tv)
+            if tv.values and not any(tv.default == value for value in tv.values):
+                self.fail("TypeVar default must be one of the constraint types", tv)
+
     def check_enum(self, defn: ClassDef) -> None:
         assert defn.info.is_enum
-        if defn.info.fullname not in ENUM_BASES:
-            for sym in defn.info.names.values():
-                if (
-                    isinstance(sym.node, Var)
-                    and sym.node.has_explicit_value
-                    and sym.node.name == "__members__"
-                ):
-                    # `__members__` will always be overwritten by `Enum` and is considered
-                    # read-only so we disallow assigning a value to it
-                    self.fail(message_registry.ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDEN, sym.node)
+        if defn.info.fullname not in ENUM_BASES and "__members__" in defn.info.names:
+            sym = defn.info.names["__members__"]
+            if isinstance(sym.node, Var) and sym.node.has_explicit_value:
+                # `__members__` will always be overwritten by `Enum` and is considered
+                # read-only so we disallow assigning a value to it
+                self.fail(message_registry.ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDDEN, sym.node)
         for base in defn.info.mro[1:-1]:  # we don't need self and `object`
             if base.is_enum and base.fullname not in ENUM_BASES:
                 self.check_final_enum(defn, base)
 
+        if self.is_stub and self.tree.fullname not in {"enum", "_typeshed"}:
+            if not defn.info.enum_members:
+                self.fail(
+                    f'Detected enum "{defn.info.fullname}" in a type stub with zero members. '
+                    "There is a chance this is due to a recent change in the semantics of "
+                    "enum membership. If so, use `member = value` to mark an enum member, "
+                    "instead of `member: type`",
+                    defn,
+                )
+                self.note(
+                    "See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members",
+                    defn,
+                )
+
         self.check_enum_bases(defn)
         self.check_enum_new(defn)
 
     def check_final_enum(self, defn: ClassDef, base: TypeInfo) -> None:
-        for sym in base.names.values():
-            if self.is_final_enum_value(sym):
-                self.fail(f'Cannot extend enum with existing members: "{base.name}"', defn)
-                break
+        if base.enum_members:
+            self.fail(f'Cannot extend enum with existing members: "{base.name}"', defn)
 
     def is_final_enum_value(self, sym: SymbolTableNode) -> bool:
         if isinstance(sym.node, (FuncBase, Decorator)):
@@ -2457,10 +2787,16 @@ def check_protocol_variance(self, defn: ClassDef) -> None:
         if they are actually covariant/contravariant, since this may break
         transitivity of subtyping, see PEP 544.
         """
+        if defn.type_args is not None:
+            # Using new-style syntax (PEP 695), so variance will be inferred
+            return
         info = defn.info
         object_type = Instance(info.mro[-1], [])
         tvars = info.defn.type_vars
         for i, tvar in enumerate(tvars):
+            if not isinstance(tvar, TypeVarType):
+                # Variance of TypeVarTuple and ParamSpec is underspecified by PEPs.
+                continue
             up_args: list[Type] = [
                 object_type if i == j else AnyType(TypeOfAny.special_form)
                 for j, _ in enumerate(tvars)
@@ -2477,7 +2813,7 @@ def check_protocol_variance(self, defn: ClassDef) -> None:
                 expected = CONTRAVARIANT
             else:
                 expected = INVARIANT
-            if isinstance(tvar, TypeVarType) and expected != tvar.variance:
+            if expected != tvar.variance:
                 self.msg.bad_proto_variance(tvar.variance, tvar.name, expected, defn)
 
     def check_multiple_inheritance(self, typ: TypeInfo) -> None:
@@ -2487,24 +2823,26 @@ def check_multiple_inheritance(self, typ: TypeInfo) -> None:
             return
         # Verify that inherited attributes are compatible.
         mro = typ.mro[1:]
-        for i, base in enumerate(mro):
+        all_names = {name for base in mro for name in base.names}
+        for name in sorted(all_names - typ.names.keys()):
+            # Sort for reproducible message order.
             # Attributes defined in both the type and base are skipped.
             # Normal checks for attribute compatibility should catch any problems elsewhere.
-            non_overridden_attrs = base.names.keys() - typ.names.keys()
-            for name in non_overridden_attrs:
-                if is_private(name):
-                    continue
-                for base2 in mro[i + 1 :]:
-                    # We only need to check compatibility of attributes from classes not
-                    # in a subclass relationship. For subclasses, normal (single inheritance)
-                    # checks suffice (these are implemented elsewhere).
-                    if name in base2.names and base2 not in base.mro:
-                        self.check_compatibility(name, base, base2, typ)
+            if is_private(name):
+                continue
+            # Compare the first base defining a name with the rest.
+            # Remaining bases may not be pairwise compatible as the first base provides
+            # the used definition.
+            i, base = next((i, base) for i, base in enumerate(mro) if name in base.names)
+            for base2 in mro[i + 1 :]:
+                if name in base2.names and base2 not in base.mro:
+                    self.check_compatibility(name, base, base2, typ)
 
     def determine_type_of_member(self, sym: SymbolTableNode) -> Type | None:
+        # TODO: this duplicates both checkmember.py and analyze_ref_expr(), delete.
         if sym.type is not None:
             return sym.type
-        if isinstance(sym.node, FuncBase):
+        if isinstance(sym.node, SYMBOL_FUNCBASE_TYPES):
             return self.function_type(sym.node)
         if isinstance(sym.node, TypeInfo):
             if sym.node.typeddict_type:
@@ -2521,7 +2859,6 @@ def determine_type_of_member(self, sym: SymbolTableNode) -> Type | None:
                 # Suppress any errors, they will be given when analyzing the corresponding node.
                 # Here we may have incorrect options and location context.
                 return self.expr_checker.alias_type_in_runtime_context(sym.node, ctx=sym.node)
-        # TODO: handle more node kinds here.
         return None
 
     def check_compatibility(
@@ -2552,44 +2889,47 @@ class C(B, A[int]): ...  # this is unsafe because...
             return
         first = base1.names[name]
         second = base2.names[name]
-        first_type = get_proper_type(self.determine_type_of_member(first))
-        second_type = get_proper_type(self.determine_type_of_member(second))
-
-        # start with the special case that Instance can be a subtype of FunctionLike
-        call = None
-        if isinstance(first_type, Instance):
-            call = find_member("__call__", first_type, first_type, is_operator=True)
-        if call and isinstance(second_type, FunctionLike):
-            second_sig = self.bind_and_map_method(second, second_type, ctx, base2)
-            ok = is_subtype(call, second_sig, ignore_pos_arg_names=True)
-        elif isinstance(first_type, FunctionLike) and isinstance(second_type, FunctionLike):
-            if first_type.is_type_obj() and second_type.is_type_obj():
+        # Specify current_class explicitly as this function is called after leaving the class.
+        first_type, _ = self.node_type_from_base(name, base1, ctx, current_class=ctx)
+        second_type, _ = self.node_type_from_base(name, base2, ctx, current_class=ctx)
+
+        # TODO: use more principled logic to decide is_subtype() vs is_equivalent().
+        # We should rely on mutability of superclass node, not on types being Callable.
+        # (in particular handle settable properties with setter type different from getter).
+
+        p_first_type = get_proper_type(first_type)
+        p_second_type = get_proper_type(second_type)
+        if isinstance(p_first_type, FunctionLike) and isinstance(p_second_type, FunctionLike):
+            if p_first_type.is_type_obj() and p_second_type.is_type_obj():
                 # For class objects only check the subtype relationship of the classes,
                 # since we allow incompatible overrides of '__init__'/'__new__'
                 ok = is_subtype(
-                    left=fill_typevars_with_any(first_type.type_object()),
-                    right=fill_typevars_with_any(second_type.type_object()),
+                    left=fill_typevars_with_any(p_first_type.type_object()),
+                    right=fill_typevars_with_any(p_second_type.type_object()),
                 )
             else:
-                # First bind/map method types when necessary.
-                first_sig = self.bind_and_map_method(first, first_type, ctx, base1)
-                second_sig = self.bind_and_map_method(second, second_type, ctx, base2)
-                ok = is_subtype(first_sig, second_sig, ignore_pos_arg_names=True)
+                assert first_type and second_type
+                ok = is_subtype(first_type, second_type, ignore_pos_arg_names=True)
         elif first_type and second_type:
-            if isinstance(first.node, Var):
-                first_type = expand_self_type(first.node, first_type, fill_typevars(ctx))
-            if isinstance(second.node, Var):
-                second_type = expand_self_type(second.node, second_type, fill_typevars(ctx))
-            ok = is_equivalent(first_type, second_type)
-            if not ok:
-                second_node = base2[name].node
+            if second.node is not None and not self.is_writable_attribute(second.node):
+                ok = is_subtype(first_type, second_type)
+            else:
+                ok = is_equivalent(first_type, second_type)
+            if ok:
                 if (
-                    isinstance(second_type, FunctionLike)
-                    and second_node is not None
-                    and is_property(second_node)
+                    first.node
+                    and second.node
+                    and self.is_writable_attribute(second.node)
+                    and is_property(first.node)
+                    and isinstance(first.node, Decorator)
+                    and not isinstance(p_second_type, AnyType)
                 ):
-                    second_type = get_property_type(second_type)
-                    ok = is_subtype(first_type, second_type)
+                    self.msg.fail(
+                        f'Cannot override writeable attribute "{name}" in base "{base2.name}"'
+                        f' with read-only property in base "{base1.name}"',
+                        ctx,
+                        code=codes.OVERRIDE,
+                    )
         else:
             if first_type is None:
                 self.msg.cannot_determine_type_in_base(name, base1.name, ctx)
@@ -2598,7 +2938,7 @@ class C(B, A[int]): ...  # this is unsafe because...
             ok = True
         # Final attributes can never be overridden, but can override
         # non-final read-only attributes.
-        if is_final_node(second.node):
+        if is_final_node(second.node) and not is_private(name):
             self.msg.cant_override_final(name, base2.name, ctx)
         if is_final_node(first.node):
             self.check_if_final_var_override_writable(name, second.node, ctx)
@@ -2639,6 +2979,9 @@ def check_metaclass_compatibility(self, typ: TypeInfo) -> None:
         )
 
     def visit_import_from(self, node: ImportFrom) -> None:
+        for name, _ in node.names:
+            if (sym := self.globals.get(name)) is not None:
+                self.warn_deprecated(sym.node, node)
         self.check_import(node)
 
     def visit_import_all(self, node: ImportAll) -> None:
@@ -2678,10 +3021,13 @@ def visit_block(self, b: Block) -> None:
             return
         for s in b.body:
             if self.binder.is_unreachable():
-                if self.should_report_unreachable_issues() and not self.is_raising_or_empty(s):
+                if not self.should_report_unreachable_issues():
+                    break
+                if not self.is_noop_for_reachability(s):
                     self.msg.unreachable_statement(s)
-                break
-            self.accept(s)
+                    break
+            else:
+                self.accept(s)
 
     def should_report_unreachable_issues(self) -> bool:
         return (
@@ -2691,11 +3037,11 @@ def should_report_unreachable_issues(self) -> bool:
             and not self.binder.is_unreachable_warning_suppressed()
         )
 
-    def is_raising_or_empty(self, s: Statement) -> bool:
+    def is_noop_for_reachability(self, s: Statement) -> bool:
         """Returns 'true' if the given statement either throws an error of some kind
         or is a no-op.
 
-        We use this function mostly while handling the '--warn-unreachable' flag. When
+        We use this function while handling the '--warn-unreachable' flag. When
         that flag is present, we normally report an error on any unreachable statement.
         But if that statement is just something like a 'pass' or a just-in-case 'assert False',
         reporting an error would be annoying.
@@ -2724,6 +3070,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
 
         Handle all kinds of assignment statements (simple, indexed, multiple).
         """
+
         # Avoid type checking type aliases in stubs to avoid false
         # positives about modern type syntax available in stubs such
         # as X | Y.
@@ -2772,7 +3119,8 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
             self.msg.annotation_in_unchecked_function(context=s)
 
     def check_type_alias_rvalue(self, s: AssignmentStmt) -> None:
-        alias_type = self.expr_checker.accept(s.rvalue)
+        with self.msg.filter_errors():
+            alias_type = self.expr_checker.accept(s.rvalue)
         self.store_type(s.lvalues[-1], alias_type)
 
     def check_assignment(
@@ -2789,7 +3137,7 @@ def check_assignment(
             )
         else:
             self.try_infer_partial_generic_type_from_assignment(lvalue, rvalue, "=")
-            lvalue_type, index_lvalue, inferred = self.check_lvalue(lvalue)
+            lvalue_type, index_lvalue, inferred = self.check_lvalue(lvalue, rvalue)
             # If we're assigning to __getattr__ or similar methods, check that the signature is
             # valid.
             if isinstance(lvalue, NameExpr) and lvalue.node:
@@ -2812,16 +3160,10 @@ 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)
-
-            # Defer PartialType's super type checking.
-            if (
-                isinstance(lvalue, RefExpr)
-                and not (isinstance(lvalue_type, PartialType) and lvalue_type.type is None)
-                and not (isinstance(lvalue, NameExpr) and lvalue.name == "__match_args__")
-            ):
-                if self.check_compatibility_all_supers(lvalue, lvalue_type, rvalue):
-                    # We hit an error on this line; don't check for any others
-                    return
+                if name == "__post_init__":
+                    active_class = self.scope.active_class()
+                    if active_class and dataclasses_plugin.is_processed_dataclass(active_class):
+                        self.fail(message_registry.DATACLASS_POST_INIT_MUST_BE_A_FUNCTION, rvalue)
 
             if isinstance(lvalue, MemberExpr) and lvalue.name == "__match_args__":
                 self.fail(message_registry.CANNOT_MODIFY_MATCH_ARGS, lvalue)
@@ -2836,7 +3178,9 @@ def check_assignment(
                         return
 
                     var = lvalue_type.var
-                    if is_valid_inferred_type(rvalue_type, is_lvalue_final=var.is_final):
+                    if is_valid_inferred_type(
+                        rvalue_type, self.options, is_lvalue_final=var.is_final
+                    ):
                         partial_types = self.find_partial_types(var)
                         if partial_types is not None:
                             if not self.current_node_deferred:
@@ -2852,12 +3196,6 @@ def check_assignment(
                         # Try to infer a partial type. No need to check the return value, as
                         # an error will be reported elsewhere.
                         self.infer_partial_type(lvalue_type.var, lvalue, rvalue_type)
-                    # Handle None PartialType's super type checking here, after it's resolved.
-                    if isinstance(lvalue, RefExpr) and self.check_compatibility_all_supers(
-                        lvalue, lvalue_type, rvalue
-                    ):
-                        # We hit an error on this line; don't check for any others
-                        return
                 elif (
                     is_literal_none(rvalue)
                     and isinstance(lvalue, NameExpr)
@@ -2872,7 +3210,7 @@ def check_assignment(
                 ):  # Ignore member access to modules
                     instance_type = self.expr_checker.accept(lvalue.expr)
                     rvalue_type, lvalue_type, infer_lvalue_type = self.check_member_assignment(
-                        instance_type, lvalue_type, rvalue, context=rvalue
+                        lvalue, instance_type, lvalue_type, rvalue, context=rvalue
                     )
                 else:
                     # Hacky special case for assigning a literal None
@@ -2882,7 +3220,8 @@ def check_assignment(
                     # unpleasant, and a generalization of this would
                     # be an improvement!
                     if (
-                        is_literal_none(rvalue)
+                        not self.options.allow_redefinition_new
+                        and is_literal_none(rvalue)
                         and isinstance(lvalue, NameExpr)
                         and lvalue.kind == LDEF
                         and isinstance(lvalue.node, Var)
@@ -2902,14 +3241,19 @@ def check_assignment(
                             lvalue_type = make_optional_type(lvalue_type)
                             self.set_inferred_type(lvalue.node, lvalue, lvalue_type)
 
-                    rvalue_type = self.check_simple_assignment(lvalue_type, rvalue, context=rvalue)
+                    rvalue_type, lvalue_type = self.check_simple_assignment(
+                        lvalue_type, rvalue, context=rvalue, inferred=inferred, lvalue=lvalue
+                    )
+                    # The above call may update inferred variable type. Prevent further
+                    # inference.
+                    inferred = None
 
                 # Special case: only non-abstract non-protocol classes can be assigned to
                 # variables with explicit type Type[A], where A is protocol or abstract.
                 p_rvalue_type = get_proper_type(rvalue_type)
                 p_lvalue_type = get_proper_type(lvalue_type)
                 if (
-                    isinstance(p_rvalue_type, CallableType)
+                    isinstance(p_rvalue_type, FunctionLike)
                     and p_rvalue_type.is_type_obj()
                     and (
                         p_rvalue_type.type_object().is_abstract
@@ -2926,30 +3270,61 @@ def check_assignment(
                 if rvalue_type and infer_lvalue_type and not isinstance(lvalue_type, PartialType):
                     # Don't use type binder for definitions of special forms, like named tuples.
                     if not (isinstance(lvalue, NameExpr) and lvalue.is_special_form):
-                        self.binder.assign_type(lvalue, rvalue_type, lvalue_type, False)
+                        self.binder.assign_type(lvalue, rvalue_type, lvalue_type)
+                        if (
+                            isinstance(lvalue, NameExpr)
+                            and isinstance(lvalue.node, Var)
+                            and lvalue.node.is_inferred
+                            and lvalue.node.is_index_var
+                            and lvalue_type is not None
+                        ):
+                            lvalue.node.type = remove_instance_last_known_values(lvalue_type)
+                elif self.options.allow_redefinition_new and lvalue_type is not None:
+                    # TODO: Can we use put() here?
+                    self.binder.assign_type(lvalue, lvalue_type, lvalue_type)
 
             elif index_lvalue:
                 self.check_indexed_assignment(index_lvalue, rvalue, lvalue)
 
             if inferred:
-                type_context = self.get_variable_type_context(inferred)
+                type_context = self.get_variable_type_context(inferred, rvalue)
                 rvalue_type = self.expr_checker.accept(rvalue, type_context=type_context)
                 if not (
                     inferred.is_final
+                    or inferred.is_index_var
                     or (isinstance(lvalue, NameExpr) and lvalue.name == "__match_args__")
                 ):
                     rvalue_type = remove_instance_last_known_values(rvalue_type)
                 self.infer_variable_type(inferred, lvalue, rvalue_type, rvalue)
             self.check_assignment_to_slots(lvalue)
+            if isinstance(lvalue, RefExpr) and not (
+                isinstance(lvalue, NameExpr) and lvalue.name == "__match_args__"
+            ):
+                # We check override here at the end after storing the inferred type, since
+                # override check will try to access the current attribute via symbol tables
+                # (like a regular attribute access).
+                self.check_compatibility_all_supers(lvalue, rvalue)
 
     # (type, operator) tuples for augmented assignments supported with partial types
     partial_type_augmented_ops: Final = {("builtins.list", "+"), ("builtins.set", "|")}
 
-    def get_variable_type_context(self, inferred: Var) -> Type | None:
+    def get_variable_type_context(self, inferred: Var, rvalue: Expression) -> Type | None:
         type_contexts = []
         if inferred.info:
             for base in inferred.info.mro[1:]:
-                base_type, base_node = self.lvalue_type_from_base(inferred, base)
+                if inferred.name not in base.names:
+                    continue
+                # For inference within class body, get supertype attribute as it would look on
+                # a class object for lambdas overriding methods, etc.
+                base_node = base.names[inferred.name].node
+                base_type, _ = self.node_type_from_base(
+                    inferred.name,
+                    base,
+                    inferred,
+                    is_class=is_method(base_node)
+                    or isinstance(base_node, Var)
+                    and not is_instance_var(base_node),
+                )
                 if (
                     base_type
                     and not (isinstance(base_node, Var) and base_node.invalid_partial_type)
@@ -3007,22 +3382,30 @@ def try_infer_partial_generic_type_from_assignment(
             rvalue_type = self.expr_checker.accept(rvalue)
             rvalue_type = get_proper_type(rvalue_type)
             if isinstance(rvalue_type, Instance):
-                if rvalue_type.type == typ.type and is_valid_inferred_type(rvalue_type):
+                if rvalue_type.type == typ.type and is_valid_inferred_type(
+                    rvalue_type, self.options
+                ):
                     var.type = rvalue_type
                     del partial_types[var]
             elif isinstance(rvalue_type, AnyType):
                 var.type = fill_typevars_with_any(typ.type)
                 del partial_types[var]
 
-    def check_compatibility_all_supers(
-        self, lvalue: RefExpr, lvalue_type: Type | None, rvalue: Expression
-    ) -> bool:
+    def check_compatibility_all_supers(self, lvalue: RefExpr, rvalue: Expression) -> None:
         lvalue_node = lvalue.node
         # Check if we are a class variable with at least one base class
         if (
             isinstance(lvalue_node, Var)
-            and lvalue.kind in (MDEF, None)
-            and len(lvalue_node.info.bases) > 0  # None for Vars defined via self
+            # If we have explicit annotation, there is no point in checking the override
+            # for each assignment, so we check only for the first one.
+            # TODO: for some reason annotated attributes on self are stored as inferred vars.
+            and (
+                lvalue_node.line == lvalue.line
+                or lvalue_node.is_inferred
+                and not lvalue_node.explicit_self_type
+            )
+            and lvalue.kind in (MDEF, None)  # None for Vars defined via self
+            and len(lvalue_node.info.bases) > 0
         ):
             for base in lvalue_node.info.mro[1:]:
                 tnode = base.names.get(lvalue_node.name)
@@ -3038,6 +3421,21 @@ def check_compatibility_all_supers(
             direct_bases = lvalue_node.info.direct_base_classes()
             last_immediate_base = direct_bases[-1] if direct_bases else None
 
+            # The historical behavior for inferred vars was to compare rvalue type against
+            # the type declared in a superclass. To preserve this behavior, we temporarily
+            # store the rvalue type on the variable.
+            actual_lvalue_type = None
+            if lvalue_node.is_inferred and not lvalue_node.explicit_self_type:
+                rvalue_type = self.expr_checker.accept(rvalue, lvalue_node.type)
+                actual_lvalue_type = lvalue_node.type
+                lvalue_node.type = rvalue_type
+            lvalue_type, _ = self.node_type_from_base(lvalue_node.name, lvalue_node.info, lvalue)
+            if lvalue_node.is_inferred and not lvalue_node.explicit_self_type:
+                lvalue_node.type = actual_lvalue_type
+
+            if not lvalue_type:
+                return
+
             for base in lvalue_node.info.mro[1:]:
                 # The type of "__slots__" and some other attributes usually doesn't need to
                 # be compatible with a base class. We'll still check the type of "__slots__"
@@ -3050,135 +3448,137 @@ def check_compatibility_all_supers(
                 if is_private(lvalue_node.name):
                     continue
 
-                base_type, base_node = self.lvalue_type_from_base(lvalue_node, base)
+                base_type, base_node = self.node_type_from_base(lvalue_node.name, base, lvalue)
+                custom_setter = is_custom_settable_property(base_node)
                 if isinstance(base_type, PartialType):
                     base_type = None
 
                 if base_type:
                     assert base_node is not None
                     if not self.check_compatibility_super(
-                        lvalue, lvalue_type, rvalue, base, base_type, base_node
+                        lvalue_type,
+                        rvalue,
+                        base,
+                        base_type,
+                        base_node,
+                        always_allow_covariant=custom_setter,
                     ):
                         # Only show one error per variable; even if other
                         # base classes are also incompatible
-                        return True
+                        return
+                    if lvalue_type and custom_setter:
+                        base_type, _ = self.node_type_from_base(
+                            lvalue_node.name, base, lvalue, setter_type=True
+                        )
+                        # Setter type for a custom property must be ready if
+                        # the getter type is ready.
+                        assert base_type is not None
+                        if not is_subtype(base_type, lvalue_type):
+                            self.msg.incompatible_setter_override(
+                                lvalue, lvalue_type, base_type, base
+                            )
+                            return
                     if base is last_immediate_base:
                         # At this point, the attribute was found to be compatible with all
                         # immediate parents.
                         break
-        return False
 
     def check_compatibility_super(
         self,
-        lvalue: RefExpr,
-        lvalue_type: Type | None,
+        compare_type: Type,
         rvalue: Expression,
         base: TypeInfo,
         base_type: Type,
         base_node: Node,
+        always_allow_covariant: bool,
     ) -> bool:
-        lvalue_node = lvalue.node
-        assert isinstance(lvalue_node, Var)
-
-        # Do not check whether the rvalue is compatible if the
-        # lvalue had a type defined; this is handled by other
-        # parts, and all we have to worry about in that case is
-        # that lvalue is compatible with the base class.
-        compare_node = None
-        if lvalue_type:
-            compare_type = lvalue_type
-            compare_node = lvalue.node
-        else:
-            compare_type = self.expr_checker.accept(rvalue, base_type)
-            if isinstance(rvalue, NameExpr):
-                compare_node = rvalue.node
-                if isinstance(compare_node, Decorator):
-                    compare_node = compare_node.func
-
-        base_type = get_proper_type(base_type)
-        compare_type = get_proper_type(compare_type)
-        if compare_type:
-            if isinstance(base_type, CallableType) and isinstance(compare_type, CallableType):
-                base_static = is_node_static(base_node)
-                compare_static = is_node_static(compare_node)
-
-                # In case compare_static is unknown, also check
-                # if 'definition' is set. The most common case for
-                # this is with TempNode(), where we lose all
-                # information about the real rvalue node (but only get
-                # the rvalue type)
-                if compare_static is None and compare_type.definition:
-                    compare_static = is_node_static(compare_type.definition)
-
-                # Compare against False, as is_node_static can return None
-                if base_static is False and compare_static is False:
-                    # Class-level function objects and classmethods become bound
-                    # methods: the former to the instance, the latter to the
-                    # class
-                    base_type = bind_self(base_type, self.scope.active_self_type())
-                    compare_type = bind_self(compare_type, self.scope.active_self_type())
-
-                # If we are a static method, ensure to also tell the
-                # lvalue it now contains a static method
-                if base_static and compare_static:
-                    lvalue_node.is_staticmethod = True
-
-            return self.check_subtype(
-                compare_type,
+        # TODO: check __set__() type override for custom descriptors.
+        # TODO: for descriptors check also class object access override.
+        ok = self.check_subtype(
+            compare_type,
+            base_type,
+            rvalue,
+            message_registry.INCOMPATIBLE_TYPES_IN_ASSIGNMENT,
+            "expression has type",
+            f'base class "{base.name}" defined the type as',
+        )
+        if (
+            ok
+            and codes.MUTABLE_OVERRIDE in self.options.enabled_error_codes
+            and self.is_writable_attribute(base_node)
+            and not always_allow_covariant
+        ):
+            ok = self.check_subtype(
                 base_type,
+                compare_type,
                 rvalue,
-                message_registry.INCOMPATIBLE_TYPES_IN_ASSIGNMENT,
-                "expression has type",
+                message_registry.COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE,
                 f'base class "{base.name}" defined the type as',
+                "expression has type",
             )
-        return True
+        return ok
 
-    def lvalue_type_from_base(
-        self, expr_node: Var, base: TypeInfo
-    ) -> tuple[Type | None, Node | None]:
-        """For a NameExpr that is part of a class, walk all base classes and try
-        to find the first class that defines a Type for the same name."""
-        expr_name = expr_node.name
-        base_var = base.names.get(expr_name)
-
-        if base_var:
-            base_node = base_var.node
-            base_type = base_var.type
-            if isinstance(base_node, Var) and base_type is not None:
-                base_type = expand_self_type(base_node, base_type, fill_typevars(expr_node.info))
-            if isinstance(base_node, Decorator):
-                base_node = base_node.func
-                base_type = base_node.type
-
-            if base_type:
-                if not has_no_typevars(base_type):
-                    self_type = self.scope.active_self_type()
-                    assert self_type is not None, "Internal error: base lookup outside class"
-                    if isinstance(self_type, TupleType):
-                        instance = tuple_fallback(self_type)
-                    else:
-                        instance = self_type
-                    itype = map_instance_to_supertype(instance, base)
-                    base_type = expand_type_by_instance(base_type, itype)
-
-                base_type = get_proper_type(base_type)
-                if isinstance(base_type, CallableType) and isinstance(base_node, FuncDef):
-                    # If we are a property, return the Type of the return
-                    # value, not the Callable
-                    if base_node.is_property:
-                        base_type = get_proper_type(base_type.ret_type)
-                if isinstance(base_type, FunctionLike) and isinstance(
-                    base_node, OverloadedFuncDef
-                ):
-                    # Same for properties with setter
-                    if base_node.is_property:
-                        base_type = base_type.items[0].ret_type
+    def node_type_from_base(
+        self,
+        name: str,
+        base: TypeInfo,
+        context: Context,
+        *,
+        setter_type: bool = False,
+        is_class: bool = False,
+        current_class: TypeInfo | None = None,
+    ) -> tuple[Type | None, SymbolNode | None]:
+        """Find a type for a name in base class.
+
+        Return the type found and the corresponding node defining the name or None
+        for both if the name is not defined in base or the node type is not known (yet).
+        The type returned is already properly mapped/bound to the subclass.
+        If setter_type is True, return setter types for settable properties (otherwise the
+        getter type is returned).
+        """
+        base_node = base.names.get(name)
 
-                return base_type, base_node
+        # TODO: defer current node if the superclass node is not ready.
+        if (
+            not base_node
+            or isinstance(base_node.node, (Var, Decorator))
+            and not base_node.type
+            or isinstance(base_node.type, PartialType)
+            and base_node.type.type is not None
+        ):
+            return None, None
 
-        return None, None
+        if current_class is None:
+            self_type = self.scope.current_self_type()
+        else:
+            self_type = fill_typevars(current_class)
+        assert self_type is not None, "Internal error: base lookup outside class"
+        if isinstance(self_type, TupleType):
+            instance = tuple_fallback(self_type)
+        else:
+            instance = self_type
 
-    def check_compatibility_classvar_super(
+        mx = MemberContext(
+            is_lvalue=setter_type,
+            is_super=False,
+            is_operator=mypy.checkexpr.is_operator_method(name),
+            original_type=self_type,
+            context=context,
+            chk=self,
+            suppress_errors=True,
+        )
+        # TODO: we should not filter "cannot determine type" errors here.
+        with self.msg.filter_errors(filter_deprecated=True):
+            if is_class:
+                fallback = instance.type.metaclass_type or mx.named_type("builtins.type")
+                base_type = analyze_class_attribute_access(
+                    instance, name, mx, mcs_fallback=fallback, override_info=base
+                )
+            else:
+                base_type = analyze_instance_member_access(name, instance, mx, base)
+        return base_type, base_node.node
+
+    def check_compatibility_classvar_super(
         self, node: Var, base: TypeInfo, base_node: Node | None
     ) -> bool:
         if not isinstance(base_node, Var):
@@ -3205,6 +3605,8 @@ def check_compatibility_final_super(
         """
         if not isinstance(base_node, (Var, FuncBase, Decorator)):
             return True
+        if is_private(node.name):
+            return True
         if base_node.is_final and (node.is_final or not isinstance(base_node, Var)):
             # Give this error only for explicit override attempt with `Final`, or
             # if we are overriding a final method with variable.
@@ -3266,7 +3668,7 @@ def check_final(self, s: AssignmentStmt | OperatorAssignmentStmt | AssignmentExp
         else:
             lvs = [s.lvalue]
         is_final_decl = s.is_final_def if isinstance(s, AssignmentStmt) else False
-        if is_final_decl and self.scope.active_class():
+        if is_final_decl and (active_class := self.scope.active_class()):
             lv = lvs[0]
             assert isinstance(lv, RefExpr)
             if lv.node is not None:
@@ -3274,12 +3676,15 @@ def check_final(self, s: AssignmentStmt | OperatorAssignmentStmt | AssignmentExp
                 if (
                     lv.node.final_unset_in_class
                     and not lv.node.final_set_in_init
-                    and not self.is_stub
-                    and  # It is OK to skip initializer in stub files.
+                    and not self.is_stub  # It is OK to skip initializer in stub files.
+                    and
                     # Avoid extra error messages, if there is no type in Final[...],
                     # then we already reported the error about missing r.h.s.
                     isinstance(s, AssignmentStmt)
                     and s.type is not None
+                    # Avoid extra error message for NamedTuples,
+                    # they were reported during semanal
+                    and not active_class.is_named_tuple
                 ):
                     self.msg.final_without_value(s)
         for lv in lvs:
@@ -3340,7 +3745,7 @@ def is_assignable_slot(self, lvalue: Lvalue, typ: Type | None) -> bool:
 
         typ = get_proper_type(typ)
         if typ is None or isinstance(typ, AnyType):
-            return True  # Any can be literally anything, like `@propery`
+            return True  # Any can be literally anything, like `@property`
         if isinstance(typ, Instance):
             # When working with instances, we need to know if they contain
             # `__set__` special method. Like `@property` does.
@@ -3353,6 +3758,37 @@ def is_assignable_slot(self, lvalue: Lvalue, typ: Type | None) -> bool:
             return all(self.is_assignable_slot(lvalue, u) for u in typ.items)
         return False
 
+    def flatten_rvalues(self, rvalues: list[Expression]) -> list[Expression]:
+        """Flatten expression list by expanding those * items that have tuple type.
+
+        For each regular type item in the tuple type use a TempNode(), for an Unpack
+        item use a corresponding StarExpr(TempNode()).
+        """
+        new_rvalues = []
+        for rv in rvalues:
+            if not isinstance(rv, StarExpr):
+                new_rvalues.append(rv)
+                continue
+            typ = get_proper_type(self.expr_checker.accept(rv.expr))
+            if not isinstance(typ, TupleType):
+                new_rvalues.append(rv)
+                continue
+            for t in typ.items:
+                if not isinstance(t, UnpackType):
+                    new_rvalues.append(TempNode(t))
+                else:
+                    unpacked = get_proper_type(t.type)
+                    if isinstance(unpacked, TypeVarTupleType):
+                        fallback = unpacked.upper_bound
+                    else:
+                        assert (
+                            isinstance(unpacked, Instance)
+                            and unpacked.type.fullname == "builtins.tuple"
+                        )
+                        fallback = unpacked
+                    new_rvalues.append(StarExpr(TempNode(fallback)))
+        return new_rvalues
+
     def check_assignment_to_multiple_lvalues(
         self,
         lvalues: list[Lvalue],
@@ -3362,18 +3798,16 @@ def check_assignment_to_multiple_lvalues(
     ) -> None:
         if isinstance(rvalue, (TupleExpr, ListExpr)):
             # Recursively go into Tuple or List expression rhs instead of
-            # using the type of rhs, because this allowed more fine grained
+            # using the type of rhs, because this allows more fine-grained
             # control in cases like: a, b = [int, str] where rhs would get
             # type List[object]
             rvalues: list[Expression] = []
             iterable_type: Type | None = None
             last_idx: int | None = None
-            for idx_rval, rval in enumerate(rvalue.items):
+            for idx_rval, rval in enumerate(self.flatten_rvalues(rvalue.items)):
                 if isinstance(rval, StarExpr):
                     typs = get_proper_type(self.expr_checker.accept(rval.expr))
-                    if isinstance(typs, TupleType):
-                        rvalues.extend([TempNode(typ) for typ in typs.items])
-                    elif self.type_is_iterable(typs) and isinstance(typs, Instance):
+                    if self.type_is_iterable(typs) and isinstance(typs, Instance):
                         if iterable_type is not None and iterable_type != self.iterable_item_type(
                             typs, rvalue
                         ):
@@ -3440,8 +3874,32 @@ def check_assignment_to_multiple_lvalues(
             self.check_multi_assignment(lvalues, rvalue, context, infer_lvalue_type)
 
     def check_rvalue_count_in_assignment(
-        self, lvalues: list[Lvalue], rvalue_count: int, context: Context
+        self,
+        lvalues: list[Lvalue],
+        rvalue_count: int,
+        context: Context,
+        rvalue_unpack: int | None = None,
     ) -> bool:
+        if rvalue_unpack is not None:
+            if not any(isinstance(e, StarExpr) for e in lvalues):
+                self.fail("Variadic tuple unpacking requires a star target", context)
+                return False
+            if len(lvalues) > rvalue_count:
+                self.fail(message_registry.TOO_MANY_TARGETS_FOR_VARIADIC_UNPACK, context)
+                return False
+            left_star_index = next(i for i, lv in enumerate(lvalues) if isinstance(lv, StarExpr))
+            left_prefix = left_star_index
+            left_suffix = len(lvalues) - left_star_index - 1
+            right_prefix = rvalue_unpack
+            right_suffix = rvalue_count - rvalue_unpack - 1
+            if left_suffix > right_suffix or left_prefix > right_prefix:
+                # Case of asymmetric unpack like:
+                #     rv: tuple[int, *Ts, int, int]
+                #     x, y, *xs, z = rv
+                # it is technically valid, but is tricky to reason about.
+                # TODO: support this (at least if the r.h.s. unpack is a homogeneous tuple).
+                self.fail(message_registry.TOO_MANY_TARGETS_FOR_VARIADIC_UNPACK, context)
+            return True
         if any(isinstance(lvalue, StarExpr) for lvalue in lvalues):
             if len(lvalues) - 1 > rvalue_count:
                 self.msg.wrong_number_values_to_unpack(rvalue_count, len(lvalues) - 1, context)
@@ -3475,6 +3933,13 @@ def check_multi_assignment(
             if len(relevant_items) == 1:
                 rvalue_type = get_proper_type(relevant_items[0])
 
+        if (
+            isinstance(rvalue_type, TupleType)
+            and find_unpack_in_list(rvalue_type.items) is not None
+        ):
+            # Normalize for consistent handling with "old-style" homogeneous tuples.
+            rvalue_type = expand_type(rvalue_type, {})
+
         if isinstance(rvalue_type, AnyType):
             for lv in lvalues:
                 if isinstance(lv, StarExpr):
@@ -3543,7 +4008,7 @@ def check_multi_assignment_from_union(
             if isinstance(expr, StarExpr):
                 expr = expr.expr
 
-            # TODO: See todo in binder.py, ConditionalTypeBinder.assign_type
+            # TODO: See comment in binder.py, ConditionalTypeBinder.assign_type
             # It's unclear why the 'declared_type' param is sometimes 'None'
             clean_items: list[tuple[Type, Type]] = []
             for type, declared_type in items:
@@ -3555,7 +4020,6 @@ def check_multi_assignment_from_union(
                 expr,
                 make_simplified_union(list(types)),
                 make_simplified_union(list(declared_types)),
-                False,
             )
         for union, lv in zip(union_types, self.flatten_lvalues(lvalues)):
             # Properly store the inferred types.
@@ -3586,7 +4050,10 @@ def check_multi_assignment_from_tuple(
         undefined_rvalue: bool,
         infer_lvalue_type: bool = True,
     ) -> None:
-        if self.check_rvalue_count_in_assignment(lvalues, len(rvalue_type.items), context):
+        rvalue_unpack = find_unpack_in_list(rvalue_type.items)
+        if self.check_rvalue_count_in_assignment(
+            lvalues, len(rvalue_type.items), context, rvalue_unpack=rvalue_unpack
+        ):
             star_index = next(
                 (i for i, lv in enumerate(lvalues) if isinstance(lv, StarExpr)), len(lvalues)
             )
@@ -3602,6 +4069,8 @@ def check_multi_assignment_from_tuple(
                     self.expr_checker.accept(rvalue, lvalue_type)
                 )
 
+                if isinstance(reinferred_rvalue_type, TypeVarLikeType):
+                    reinferred_rvalue_type = get_proper_type(reinferred_rvalue_type.upper_bound)
                 if isinstance(reinferred_rvalue_type, UnionType):
                     # If this is an Optional type in non-strict Optional code, unwrap it.
                     relevant_items = reinferred_rvalue_type.relevant_items()
@@ -3631,12 +4100,39 @@ def check_multi_assignment_from_tuple(
                 self.check_assignment(lv, self.temp_node(rv_type, context), infer_lvalue_type)
             if star_lv:
                 list_expr = ListExpr(
-                    [self.temp_node(rv_type, context) for rv_type in star_rv_types]
+                    [
+                        (
+                            self.temp_node(rv_type, context)
+                            if not isinstance(rv_type, UnpackType)
+                            else StarExpr(self.temp_node(rv_type.type, context))
+                        )
+                        for rv_type in star_rv_types
+                    ]
                 )
                 list_expr.set_line(context)
                 self.check_assignment(star_lv.expr, list_expr, infer_lvalue_type)
             for lv, rv_type in zip(right_lvs, right_rv_types):
                 self.check_assignment(lv, self.temp_node(rv_type, context), infer_lvalue_type)
+        else:
+            # Store meaningful Any types for lvalues, errors are already given
+            # by check_rvalue_count_in_assignment()
+            if infer_lvalue_type:
+                for lv in lvalues:
+                    if (
+                        isinstance(lv, NameExpr)
+                        and isinstance(lv.node, Var)
+                        and lv.node.type is None
+                    ):
+                        lv.node.type = AnyType(TypeOfAny.from_error)
+                    elif isinstance(lv, StarExpr):
+                        if (
+                            isinstance(lv.expr, NameExpr)
+                            and isinstance(lv.expr.node, Var)
+                            and lv.expr.node.type is None
+                        ):
+                            lv.expr.node.type = self.named_generic_type(
+                                "builtins.list", [AnyType(TypeOfAny.from_error)]
+                            )
 
     def lvalue_type_for_inference(self, lvalues: list[Lvalue], rvalue_type: TupleType) -> Type:
         star_index = next(
@@ -3694,7 +4190,7 @@ def split_around_star(
 
     def type_is_iterable(self, type: Type) -> bool:
         type = get_proper_type(type)
-        if isinstance(type, CallableType) and type.is_type_obj():
+        if isinstance(type, FunctionLike) and type.is_type_obj():
             type = type.fallback
         return is_subtype(
             type, self.named_generic_type("typing.Iterable", [AnyType(TypeOfAny.special_form)])
@@ -3725,7 +4221,9 @@ def check_multi_assignment_from_iterable(
         else:
             self.msg.type_not_iterable(rvalue_type, context)
 
-    def check_lvalue(self, lvalue: Lvalue) -> tuple[Type | None, IndexExpr | None, Var | None]:
+    def check_lvalue(
+        self, lvalue: Lvalue, rvalue: Expression | None = None
+    ) -> tuple[Type | None, IndexExpr | None, Var | None]:
         lvalue_type = None
         index_lvalue = None
         inferred = None
@@ -3743,10 +4241,16 @@ def check_lvalue(self, lvalue: Lvalue) -> tuple[Type | None, IndexExpr | None, V
         elif isinstance(lvalue, IndexExpr):
             index_lvalue = lvalue
         elif isinstance(lvalue, MemberExpr):
-            lvalue_type = self.expr_checker.analyze_ordinary_member_access(lvalue, True)
+            lvalue_type = self.expr_checker.analyze_ordinary_member_access(lvalue, True, rvalue)
             self.store_type(lvalue, lvalue_type)
         elif isinstance(lvalue, NameExpr):
             lvalue_type = self.expr_checker.analyze_ref_expr(lvalue, lvalue=True)
+            if (
+                self.options.allow_redefinition_new
+                and isinstance(lvalue.node, Var)
+                and lvalue.node.is_inferred
+            ):
+                inferred = lvalue.node
             self.store_type(lvalue, lvalue_type)
         elif isinstance(lvalue, (TupleExpr, ListExpr)):
             types = [
@@ -3787,14 +4291,19 @@ def infer_variable_type(
         if isinstance(init_type, DeletedType):
             self.msg.deleted_as_rvalue(init_type, context)
         elif (
-            not is_valid_inferred_type(init_type, is_lvalue_final=name.is_final)
+            not is_valid_inferred_type(
+                init_type,
+                self.options,
+                is_lvalue_final=name.is_final,
+                is_lvalue_member=isinstance(lvalue, MemberExpr),
+            )
             and not self.no_partial_types
         ):
             # We cannot use the type of the initialization expression for full type
             # inference (it's not specific enough), but we might be able to give
             # partial type which will be made more specific later. A partial type
             # gets generated in assignment like 'x = []' where item type is not known.
-            if not self.infer_partial_type(name, lvalue, init_type):
+            if name.name != "_" and not self.infer_partial_type(name, lvalue, init_type):
                 self.msg.need_annotation_for_var(name, context, self.options.python_version)
                 self.set_inference_error_fallback_type(name, lvalue, init_type)
         elif (
@@ -3814,10 +4323,16 @@ def infer_variable_type(
             init_type = strip_type(init_type)
 
             self.set_inferred_type(name, lvalue, init_type)
+            if self.options.allow_redefinition_new:
+                self.binder.assign_type(lvalue, init_type, init_type)
 
     def infer_partial_type(self, name: Var, lvalue: Lvalue, init_type: Type) -> bool:
         init_type = get_proper_type(init_type)
-        if isinstance(init_type, NoneType):
+        if isinstance(init_type, NoneType) and (
+            isinstance(lvalue, MemberExpr) or not self.options.allow_redefinition_new
+        ):
+            # When using --allow-redefinition-new, None types aren't special
+            # when inferring simple variable types.
             partial_type = PartialType(None, name)
         elif isinstance(init_type, Instance):
             fullname = init_type.type.fullname
@@ -3861,7 +4376,7 @@ def is_valid_defaultdict_partial_value_type(self, t: ProperType) -> bool:
         Examples:
 
           * t is 'int' --> True
-          * t is 'list[<nothing>]' --> True
+          * t is 'list[Never]' --> True
           * t is 'dict[...]' --> False (only generic types with a single type
             argument supported)
         """
@@ -3871,11 +4386,12 @@ def is_valid_defaultdict_partial_value_type(self, t: ProperType) -> bool:
             return True
         if len(t.args) == 1:
             arg = get_proper_type(t.args[0])
-            # TODO: This is too permissive -- we only allow TypeVarType since
-            #       they leak in cases like defaultdict(list) due to a bug.
-            #       This can result in incorrect types being inferred, but only
-            #       in rare cases.
-            if isinstance(arg, (TypeVarType, UninhabitedType, NoneType)):
+            if self.options.old_type_inference:
+                # Allow leaked TypeVars for legacy inference logic.
+                allowed = isinstance(arg, (UninhabitedType, NoneType, TypeVarType))
+            else:
+                allowed = isinstance(arg, (UninhabitedType, NoneType))
+            if allowed:
                 return True
         return False
 
@@ -3886,6 +4402,7 @@ def set_inferred_type(self, var: Var, lvalue: Lvalue, type: Type) -> None:
         refers to the variable (lvalue). If var is None, do nothing.
         """
         if var and not self.current_node_deferred:
+            # TODO: should we also set 'is_ready = True' here?
             var.type = type
             var.is_inferred = True
             if var not in self.var_decl_frames:
@@ -3896,17 +4413,21 @@ def set_inferred_type(self, var: Var, lvalue: Lvalue, type: Type) -> None:
                 if lvalue.def_var is not None:
                     self.inferred_attribute_types[lvalue.def_var] = type
             self.store_type(lvalue, type)
+            p_type = get_proper_type(type)
+            if isinstance(p_type, CallableType) and is_node_static(p_type.definition):
+                # TODO: handle aliases to class methods (similarly).
+                var.is_staticmethod = True
 
     def set_inference_error_fallback_type(self, var: Var, lvalue: Lvalue, type: Type) -> None:
         """Store best known type for variable if type inference failed.
 
         If a program ignores error on type inference error, the variable should get some
-        inferred type so that if can used later on in the program. Example:
+        inferred type so that it can used later on in the program. Example:
 
           x = []  # type: ignore
           x.append(1)   # Should be ok!
 
-        We implement this here by giving x a valid type (replacing inferred <nothing> with Any).
+        We implement this here by giving x a valid type (replacing inferred Never with Any).
         """
         fallback = self.inference_error_fallback_type(type)
         self.set_inferred_type(var, lvalue, fallback)
@@ -3926,7 +4447,9 @@ def simple_rvalue(self, rvalue: Expression) -> bool:
         if isinstance(rvalue, (IntExpr, StrExpr, BytesExpr, FloatExpr, RefExpr)):
             return True
         if isinstance(rvalue, CallExpr):
-            if isinstance(rvalue.callee, RefExpr) and isinstance(rvalue.callee.node, FuncBase):
+            if isinstance(rvalue.callee, RefExpr) and isinstance(
+                rvalue.callee.node, SYMBOL_FUNCBASE_TYPES
+            ):
                 typ = rvalue.callee.node.type
                 if isinstance(typ, CallableType):
                     return not typ.variables
@@ -3944,21 +4467,68 @@ def check_simple_assignment(
         rvalue_name: str = "expression",
         *,
         notes: list[str] | None = None,
-    ) -> Type:
+        lvalue: Expression | None = None,
+        inferred: Var | None = None,
+    ) -> tuple[Type, Type | None]:
         if self.is_stub and isinstance(rvalue, EllipsisExpr):
             # '...' is always a valid initializer in a stub.
-            return AnyType(TypeOfAny.special_form)
+            return AnyType(TypeOfAny.special_form), lvalue_type
         else:
             always_allow_any = lvalue_type is not None and not isinstance(
                 get_proper_type(lvalue_type), AnyType
             )
+            if inferred is None or is_typeddict_type_context(lvalue_type):
+                type_context = lvalue_type
+            else:
+                type_context = None
             rvalue_type = self.expr_checker.accept(
-                rvalue, lvalue_type, always_allow_any=always_allow_any
+                rvalue, type_context=type_context, always_allow_any=always_allow_any
             )
+            if (
+                lvalue_type is not None
+                and type_context is None
+                and not is_valid_inferred_type(rvalue_type, self.options)
+            ):
+                # Inference in an empty type context didn't produce a valid type, so
+                # try using lvalue type as context instead.
+                rvalue_type = self.expr_checker.accept(
+                    rvalue, type_context=lvalue_type, always_allow_any=always_allow_any
+                )
+                if not is_valid_inferred_type(rvalue_type, self.options) and inferred is not None:
+                    self.msg.need_annotation_for_var(
+                        inferred, context, self.options.python_version
+                    )
+                    rvalue_type = rvalue_type.accept(SetNothingToAny())
+
+            if (
+                isinstance(lvalue, NameExpr)
+                and inferred is not None
+                and inferred.type is not None
+                and not inferred.is_final
+            ):
+                new_inferred = remove_instance_last_known_values(rvalue_type)
+                if not is_same_type(inferred.type, new_inferred):
+                    # Should we widen the inferred type or the lvalue? Variables defined
+                    # at module level or class bodies can't be widened in functions, or
+                    # in another module.
+                    if not self.refers_to_different_scope(lvalue):
+                        lvalue_type = make_simplified_union([inferred.type, new_inferred])
+                        if not is_same_type(lvalue_type, inferred.type) and not isinstance(
+                            inferred.type, PartialType
+                        ):
+                            # Widen the type to the union of original and new type.
+                            self.widened_vars.append(inferred.name)
+                            self.set_inferred_type(inferred, lvalue, lvalue_type)
+                            self.binder.put(lvalue, rvalue_type)
+                            # TODO: A bit hacky, maybe add a binder method that does put and
+                            #       updates declaration?
+                            lit = literal_hash(lvalue)
+                            if lit is not None:
+                                self.binder.declarations[lit] = lvalue_type
             if (
                 isinstance(get_proper_type(lvalue_type), UnionType)
                 # Skip literal types, as they have special logic (for better errors).
-                and not isinstance(get_proper_type(rvalue_type), LiteralType)
+                and not is_literal_type_like(rvalue_type)
                 and not self.simple_rvalue(rvalue)
             ):
                 # Try re-inferring r.h.s. in empty context, and use that if it
@@ -3974,7 +4544,7 @@ def check_simple_assignment(
                     not local_errors.has_new_errors()
                     # Skip Any type, since it is special cased in binder.
                     and not isinstance(get_proper_type(alt_rvalue_type), AnyType)
-                    and is_valid_inferred_type(alt_rvalue_type)
+                    and is_valid_inferred_type(alt_rvalue_type, self.options)
                     and is_proper_subtype(alt_rvalue_type, rvalue_type)
                 ):
                     rvalue_type = alt_rvalue_type
@@ -3994,10 +4564,27 @@ def check_simple_assignment(
                     f"{lvalue_name} has type",
                     notes=notes,
                 )
-            return rvalue_type
+            return rvalue_type, lvalue_type
+
+    def refers_to_different_scope(self, name: NameExpr) -> bool:
+        if name.kind == LDEF:
+            # TODO: Consider reference to outer function as a different scope?
+            return False
+        elif self.scope.top_level_function() is not None:
+            # A non-local reference from within a function must refer to a different scope
+            return True
+        elif name.kind == GDEF and name.fullname.rpartition(".")[0] != self.tree.fullname:
+            # Reference to global definition from another module
+            return True
+        return False
 
     def check_member_assignment(
-        self, instance_type: Type, attribute_type: Type, rvalue: Expression, context: Context
+        self,
+        lvalue: MemberExpr,
+        instance_type: Type,
+        attribute_type: Type,
+        rvalue: Expression,
+        context: Context,
     ) -> tuple[Type, Type, bool]:
         """Type member assignment.
 
@@ -4006,115 +4593,29 @@ def check_member_assignment(
 
         Return the inferred rvalue_type, inferred lvalue_type, and whether to use the binder
         for this assignment.
-
-        Note: this method exists here and not in checkmember.py, because we need to take
-        care about interaction between binder and __set__().
         """
         instance_type = get_proper_type(instance_type)
-        attribute_type = get_proper_type(attribute_type)
         # Descriptors don't participate in class-attribute access
         if (isinstance(instance_type, FunctionLike) and instance_type.is_type_obj()) or isinstance(
             instance_type, TypeType
         ):
-            rvalue_type = self.check_simple_assignment(attribute_type, rvalue, context)
-            return rvalue_type, attribute_type, True
-
-        if not isinstance(attribute_type, Instance):
-            # TODO: support __set__() for union types.
-            rvalue_type = self.check_simple_assignment(attribute_type, rvalue, context)
+            rvalue_type, _ = self.check_simple_assignment(attribute_type, rvalue, context)
             return rvalue_type, attribute_type, True
 
-        mx = MemberContext(
-            is_lvalue=False,
-            is_super=False,
-            is_operator=False,
-            original_type=instance_type,
-            context=context,
-            self_type=None,
-            msg=self.msg,
-            chk=self,
-        )
-        get_type = analyze_descriptor_access(attribute_type, mx)
-        if not attribute_type.type.has_readable_member("__set__"):
-            # If there is no __set__, we type-check that the assigned value matches
-            # the return type of __get__. This doesn't match the python semantics,
-            # (which allow you to override the descriptor with any value), but preserves
-            # the type of accessing the attribute (even after the override).
-            rvalue_type = self.check_simple_assignment(get_type, rvalue, context)
-            return rvalue_type, get_type, True
-
-        dunder_set = attribute_type.type.get_method("__set__")
-        if dunder_set is None:
-            self.fail(
-                message_registry.DESCRIPTOR_SET_NOT_CALLABLE.format(
-                    attribute_type.str_with_options(self.options)
-                ),
-                context,
+        with self.msg.filter_errors(filter_deprecated=True):
+            get_lvalue_type = self.expr_checker.analyze_ordinary_member_access(
+                lvalue, is_lvalue=False
             )
-            return AnyType(TypeOfAny.from_error), get_type, False
-
-        bound_method = analyze_decorator_or_funcbase_access(
-            defn=dunder_set,
-            itype=attribute_type,
-            info=attribute_type.type,
-            self_type=attribute_type,
-            name="__set__",
-            mx=mx,
-        )
-        typ = map_instance_to_supertype(attribute_type, dunder_set.info)
-        dunder_set_type = expand_type_by_instance(bound_method, typ)
-
-        callable_name = self.expr_checker.method_fullname(attribute_type, "__set__")
-        dunder_set_type = self.expr_checker.transform_callee_type(
-            callable_name,
-            dunder_set_type,
-            [TempNode(instance_type, context=context), rvalue],
-            [nodes.ARG_POS, nodes.ARG_POS],
-            context,
-            object_type=attribute_type,
-        )
 
-        # For non-overloaded setters, the result should be type-checked like a regular assignment.
-        # Hence, we first only try to infer the type by using the rvalue as type context.
-        type_context = rvalue
-        with self.msg.filter_errors():
-            _, inferred_dunder_set_type = self.expr_checker.check_call(
-                dunder_set_type,
-                [TempNode(instance_type, context=context), type_context],
-                [nodes.ARG_POS, nodes.ARG_POS],
-                context,
-                object_type=attribute_type,
-                callable_name=callable_name,
-            )
-
-        # And now we in fact type check the call, to show errors related to wrong arguments
-        # count, etc., replacing the type context for non-overloaded setters only.
-        inferred_dunder_set_type = get_proper_type(inferred_dunder_set_type)
-        if isinstance(inferred_dunder_set_type, CallableType):
-            type_context = TempNode(AnyType(TypeOfAny.special_form), context=context)
-        self.expr_checker.check_call(
-            dunder_set_type,
-            [TempNode(instance_type, context=context), type_context],
-            [nodes.ARG_POS, nodes.ARG_POS],
-            context,
-            object_type=attribute_type,
-            callable_name=callable_name,
-        )
-
-        # In the following cases, a message already will have been recorded in check_call.
-        if (not isinstance(inferred_dunder_set_type, CallableType)) or (
-            len(inferred_dunder_set_type.arg_types) < 2
-        ):
-            return AnyType(TypeOfAny.from_error), get_type, False
-
-        set_type = inferred_dunder_set_type.arg_types[1]
         # Special case: if the rvalue_type is a subtype of both '__get__' and '__set__' types,
         # and '__get__' type is narrower than '__set__', then we invoke the binder to narrow type
         # by this assignment. Technically, this is not safe, but in practice this is
         # what a user expects.
-        rvalue_type = self.check_simple_assignment(set_type, rvalue, context)
-        infer = is_subtype(rvalue_type, get_type) and is_subtype(get_type, set_type)
-        return rvalue_type if infer else set_type, get_type, infer
+        rvalue_type, _ = self.check_simple_assignment(attribute_type, rvalue, context)
+        infer = is_subtype(rvalue_type, get_lvalue_type) and is_subtype(
+            get_lvalue_type, attribute_type
+        )
+        return rvalue_type if infer else attribute_type, attribute_type, infer
 
     def check_indexed_assignment(
         self, lvalue: IndexExpr, rvalue: Expression, context: Context
@@ -4142,6 +4643,19 @@ def check_indexed_assignment(
         if isinstance(res_type, UninhabitedType) and not res_type.ambiguous:
             self.binder.unreachable()
 
+    def replace_partial_type(
+        self, var: Var, new_type: Type, partial_types: dict[Var, Context]
+    ) -> None:
+        """Replace the partial type of var with a non-partial type."""
+        var.type = new_type
+        del partial_types[var]
+        if self.options.allow_redefinition_new:
+            # When using --allow-redefinition-new, binder tracks all types of
+            # simple variables.
+            n = NameExpr(var.name)
+            n.node = var
+            self.binder.assign_type(n, new_type, new_type)
+
     def try_infer_partial_type_from_indexed_assignment(
         self, lvalue: IndexExpr, rvalue: Expression
     ) -> None:
@@ -4169,8 +4683,8 @@ def try_infer_partial_type_from_indexed_assignment(
                     key_type = self.expr_checker.accept(lvalue.index)
                     value_type = self.expr_checker.accept(rvalue)
                     if (
-                        is_valid_inferred_type(key_type)
-                        and is_valid_inferred_type(value_type)
+                        is_valid_inferred_type(key_type, self.options)
+                        and is_valid_inferred_type(value_type, self.options)
                         and not self.current_node_deferred
                         and not (
                             typename == "collections.defaultdict"
@@ -4178,8 +4692,8 @@ def try_infer_partial_type_from_indexed_assignment(
                             and not is_equivalent(value_type, var.type.value_type)
                         )
                     ):
-                        var.type = self.named_generic_type(typename, [key_type, value_type])
-                        del partial_types[var]
+                        new_type = self.named_generic_type(typename, [key_type, value_type])
+                        self.replace_partial_type(var, new_type, partial_types)
 
     def type_requires_usage(self, typ: Type) -> tuple[str, ErrorCode] | None:
         """Some types require usage in all cases. The classic example is
@@ -4216,7 +4730,7 @@ def visit_return_stmt(self, s: ReturnStmt) -> None:
         self.binder.unreachable()
 
     def check_return_stmt(self, s: ReturnStmt) -> None:
-        defn = self.scope.top_function()
+        defn = self.scope.current_function()
         if defn is not None:
             if defn.is_generator:
                 return_type = self.get_generator_return_type(
@@ -4228,12 +4742,14 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                 return_type = self.return_types[-1]
             return_type = get_proper_type(return_type)
 
+            is_lambda = isinstance(defn, LambdaExpr)
             if isinstance(return_type, UninhabitedType):
-                self.fail(message_registry.NO_RETURN_EXPECTED, s)
-                return
+                # Avoid extra error messages for failed inference in lambdas
+                if not is_lambda and not return_type.ambiguous:
+                    self.fail(message_registry.NO_RETURN_EXPECTED, s)
+                    return
 
             if s.expr:
-                is_lambda = isinstance(self.scope.top_function(), LambdaExpr)
                 declared_none_return = isinstance(return_type, NoneType)
                 declared_any_return = isinstance(return_type, AnyType)
 
@@ -4250,6 +4766,13 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                         s.expr, return_type, allow_none_return=allow_none_func_call
                     )
                 )
+                # Treat NotImplemented as having type Any, consistent with its
+                # definition in typeshed prior to python/typeshed#4222.
+                if (
+                    isinstance(typ, Instance)
+                    and typ.type.fullname == "builtins._NotImplementedType"
+                ):
+                    typ = AnyType(TypeOfAny.special_form)
 
                 if defn.is_async_generator:
                     self.fail(message_registry.RETURN_IN_ASYNC_GENERATOR, s)
@@ -4270,6 +4793,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
@@ -4323,11 +4847,11 @@ def visit_if_stmt(self, s: IfStmt) -> None:
 
                 # XXX Issue a warning if condition is always False?
                 with self.binder.frame_context(can_skip=True, fall_through=2):
-                    self.push_type_map(if_map)
+                    self.push_type_map(if_map, from_assignment=False)
                     self.accept(b)
 
                 # XXX Issue a warning if condition is always True?
-                self.push_type_map(else_map)
+                self.push_type_map(else_map, from_assignment=False)
 
             with self.binder.frame_context(can_skip=False, fall_through=2):
                 if s.else_body:
@@ -4352,6 +4876,16 @@ def visit_operator_assignment_stmt(self, s: OperatorAssignmentStmt) -> None:
         if inplace:
             # There is __ifoo__, treat as x = x.__ifoo__(y)
             rvalue_type, method_type = self.expr_checker.check_op(method, lvalue_type, s.rvalue, s)
+            if isinstance(inst := get_proper_type(lvalue_type), Instance) and isinstance(
+                defn := inst.type.get_method(method), OverloadedFuncDef
+            ):
+                for item in defn.items:
+                    if (
+                        isinstance(item, Decorator)
+                        and isinstance(typ := item.func.type, CallableType)
+                        and (bind_self(typ) == method_type)
+                    ):
+                        self.warn_deprecated(item.func, s)
             if not is_subtype(rvalue_type, lvalue_type):
                 self.msg.incompatible_operator_assignment(s.op, s)
         else:
@@ -4372,7 +4906,9 @@ def visit_assert_stmt(self, s: AssertStmt) -> None:
         # If this is asserting some isinstance check, bind that type in the following code
         true_map, else_map = self.find_isinstance_check(s.expr)
         if s.msg is not None:
-            self.expr_checker.analyze_cond_branch(else_map, s.msg, None)
+            self.expr_checker.analyze_cond_branch(
+                else_map, s.msg, None, suppress_unreachable_errors=False
+            )
         self.push_type_map(true_map)
 
     def visit_raise_stmt(self, s: RaiseStmt) -> None:
@@ -4404,6 +4940,14 @@ def type_check_raise(self, e: Expression, s: RaiseStmt, optional: bool = False)
             # https://github.com/python/mypy/issues/11089
             self.expr_checker.check_call(typ, [], [], e)
 
+        if isinstance(typ, Instance) and typ.type.fullname == "builtins._NotImplementedType":
+            self.fail(
+                message_registry.INVALID_EXCEPTION.with_additional_msg(
+                    '; did you mean "NotImplementedError"?'
+                ),
+                s,
+            )
+
     def visit_try_stmt(self, s: TryStmt) -> None:
         """Type check a try statement."""
         # Our enclosing frame will get the result if the try/except falls through.
@@ -4473,8 +5017,13 @@ def visit_try_without_finally(self, s: TryStmt, try_frame: bool) -> None:
                             # try/except block.
                             source = var.name
                             if isinstance(var.node, Var):
-                                var.node.type = DeletedType(source=source)
-                            self.binder.cleanse(var)
+                                new_type = DeletedType(source=source)
+                                var.node.type = new_type
+                                if self.options.allow_redefinition_new:
+                                    # TODO: Should we use put() here?
+                                    self.binder.assign_type(var, new_type, new_type)
+                            if not self.options.allow_redefinition_new:
+                                self.binder.cleanse(var)
             if s.else_body:
                 self.accept(s.else_body)
 
@@ -4560,8 +5109,14 @@ def visit_for_stmt(self, s: ForStmt) -> None:
             iterator_type, item_type = self.analyze_iterable_item_type(s.expr)
         s.inferred_item_type = item_type
         s.inferred_iterator_type = iterator_type
-        self.analyze_index_variables(s.index, item_type, s.index_type is None, s)
-        self.accept_loop(s.body, s.else_body)
+
+        self.accept_loop(
+            s.body,
+            s.else_body,
+            on_enter_body=lambda: self.analyze_index_variables(
+                s.index, item_type, s.index_type is None, s
+            ),
+        )
 
     def analyze_async_iterable_item_type(self, expr: Expression) -> tuple[Type, Type]:
         """Analyse async iterable expression and return iterator and iterator item types."""
@@ -4576,42 +5131,32 @@ def analyze_async_iterable_item_type(self, expr: Expression) -> tuple[Type, Type
 
     def analyze_iterable_item_type(self, expr: Expression) -> tuple[Type, Type]:
         """Analyse iterable expression and return iterator and iterator item types."""
-        echk = self.expr_checker
-        iterable = get_proper_type(echk.accept(expr))
-        iterator = echk.check_method_call_by_name("__iter__", iterable, [], [], expr)[0]
-
+        iterator, iterable = self.analyze_iterable_item_type_without_expression(
+            self.expr_checker.accept(expr), context=expr
+        )
         int_type = self.analyze_range_native_int_type(expr)
         if int_type:
             return iterator, int_type
-
-        if isinstance(iterable, TupleType):
-            joined: Type = UninhabitedType()
-            for item in iterable.items:
-                joined = join_types(joined, item)
-            return iterator, joined
-        else:
-            # Non-tuple iterable.
-            return iterator, echk.check_method_call_by_name("__next__", iterator, [], [], expr)[0]
+        return iterator, iterable
 
     def analyze_iterable_item_type_without_expression(
         self, type: Type, context: Context
     ) -> tuple[Type, Type]:
         """Analyse iterable type and return iterator and iterator item types."""
         echk = self.expr_checker
+        iterable: Type
         iterable = get_proper_type(type)
         iterator = echk.check_method_call_by_name("__iter__", iterable, [], [], context)[0]
 
-        if isinstance(iterable, TupleType):
-            joined: Type = UninhabitedType()
-            for item in iterable.items:
-                joined = join_types(joined, item)
-            return iterator, joined
+        if (
+            isinstance(iterable, TupleType)
+            and iterable.partial_fallback.type.fullname == "builtins.tuple"
+        ):
+            return iterator, tuple_fallback(iterable).args[0]
         else:
             # Non-tuple iterable.
-            return (
-                iterator,
-                echk.check_method_call_by_name("__next__", iterator, [], [], context)[0],
-            )
+            iterable = echk.check_method_call_by_name("__next__", iterator, [], [], context)[0]
+            return iterator, iterable
 
     def analyze_range_native_int_type(self, expr: Expression) -> Type | None:
         """Try to infer native int item type from arguments to range(...).
@@ -4683,7 +5228,7 @@ def visit_del_stmt(self, s: DelStmt) -> None:
             for elt in flatten(s.expr):
                 if isinstance(elt, NameExpr):
                     self.binder.assign_type(
-                        elt, DeletedType(source=elt.name), get_declaration(elt), False
+                        elt, DeletedType(source=elt.name), get_declaration(elt)
                     )
 
     def visit_decorator(self, e: Decorator) -> None:
@@ -4693,24 +5238,36 @@ def visit_decorator(self, e: Decorator) -> None:
                     e.var.type = AnyType(TypeOfAny.special_form)
                     e.var.is_ready = True
                     return
+        self.visit_decorator_inner(e)
 
+    def visit_decorator_inner(
+        self, e: Decorator, allow_empty: bool = False, skip_first_item: bool = False
+    ) -> None:
         if self.recurse_into_functions:
             with self.tscope.function_scope(e.func):
-                self.check_func_item(e.func, name=e.func.name)
+                self.check_func_item(e.func, name=e.func.name, allow_empty=allow_empty)
 
         # Process decorators from the inside out to determine decorated signature, which
         # may be different from the declared signature.
         sig: Type = self.function_type(e.func)
-        for d in reversed(e.decorators):
+        non_trivial_decorator = False
+        # For settable properties skip the first decorator (that is @foo.setter).
+        for d in reversed(e.decorators[1:] if skip_first_item else e.decorators):
+            if refers_to_fullname(d, "abc.abstractmethod"):
+                # This is a hack to avoid spurious errors because of incomplete type
+                # of @abstractmethod in the test fixtures.
+                continue
             if refers_to_fullname(d, OVERLOAD_NAMES):
-                self.fail(message_registry.MULTIPLE_OVERLOADS_REQUIRED, e)
+                if not allow_empty:
+                    self.fail(message_registry.MULTIPLE_OVERLOADS_REQUIRED, e)
                 continue
+            non_trivial_decorator = True
             dec = self.expr_checker.accept(d)
-            temp = self.temp_node(sig, context=e)
+            temp = self.temp_node(sig, context=d)
             fullname = None
             if isinstance(d, RefExpr):
                 fullname = d.fullname or None
-            # if this is a expression like @b.a where b is an object, get the type of b
+            # if this is an expression like @b.a where b is an object, get the type of b,
             # so we can pass it the method hook in the plugins
             object_type: Type | None = None
             if fullname is None and isinstance(d, MemberExpr) and self.has_type(d.expr):
@@ -4720,7 +5277,8 @@ def visit_decorator(self, e: Decorator) -> None:
             sig, t2 = self.expr_checker.check_call(
                 dec, [temp], [nodes.ARG_POS], e, callable_name=fullname, object_type=object_type
             )
-        self.check_untyped_after_decorator(sig, e.func)
+        if non_trivial_decorator:
+            self.check_untyped_after_decorator(sig, e.func)
         sig = set_callable_name(sig, e.func)
         e.var.type = sig
         e.var.is_ready = True
@@ -4729,16 +5287,30 @@ def visit_decorator(self, e: Decorator) -> None:
                 if len([k for k in sig.arg_kinds if k.is_required()]) > 1:
                     self.msg.fail("Too many arguments for property", e)
             self.check_incompatible_property_override(e)
-        # For overloaded functions we already checked override for overload as a whole.
-        if e.func.info and not e.func.is_dynamic() and not e.is_overload:
-            found_base_method = self.check_method_override(e)
-            if e.func.is_explicit_override and found_base_method is False:
+        # For overloaded functions/properties we already checked override for overload as a whole.
+        if allow_empty or skip_first_item:
+            return
+        if e.func.info and not e.is_overload:
+            found_method_base_classes = self.check_method_override(e)
+            if (
+                e.func.is_explicit_override
+                and not found_method_base_classes
+                and found_method_base_classes is not None
+                # If the class has Any fallback, we can't be certain that a method
+                # is really missing - it might come from unfollowed import.
+                and not e.func.info.fallback_to_any
+            ):
                 self.msg.no_overridable_method(e.func.name, e.func)
+            self.check_explicit_override_decorator(e.func, found_method_base_classes)
 
         if e.func.info and e.func.name in ("__init__", "__new__"):
             if e.type and not isinstance(get_proper_type(e.type), (FunctionLike, AnyType)):
                 self.fail(message_registry.BAD_CONSTRUCTOR_TYPE, e)
 
+        if e.func.original_def and isinstance(sig, FunctionLike):
+            # Function definition overrides function definition.
+            self.check_func_def_override(e.func, sig)
+
     def check_for_untyped_decorator(
         self, func: FuncDef, dec_type: Type, dec_expr: Expression
     ) -> None:
@@ -4746,6 +5318,7 @@ def check_for_untyped_decorator(
             self.options.disallow_untyped_decorators
             and is_typed_callable(func.type)
             and is_untyped_decorator(dec_type)
+            and not self.current_node_deferred
         ):
             self.msg.typed_function_untyped_decorator(func.name, dec_expr)
 
@@ -4845,9 +5418,24 @@ def visit_break_stmt(self, s: BreakStmt) -> None:
 
     def visit_continue_stmt(self, s: ContinueStmt) -> None:
         self.binder.handle_continue()
-        return None
+        return
 
     def visit_match_stmt(self, s: MatchStmt) -> None:
+        named_subject: Expression
+        if isinstance(s.subject, CallExpr):
+            # Create a dummy subject expression to handle cases where a match statement's subject
+            # is not a literal value. This lets us correctly narrow types and check exhaustivity
+            # This is hack!
+            if s.subject_dummy is None:
+                id = s.subject.callee.fullname if isinstance(s.subject.callee, RefExpr) else ""
+                name = "dummy-match-" + id
+                v = Var(name)
+                s.subject_dummy = NameExpr(name)
+                s.subject_dummy.node = v
+            named_subject = s.subject_dummy
+        else:
+            named_subject = s.subject
+
         with self.binder.frame_context(can_skip=False, fall_through=0):
             subject_type = get_proper_type(self.expr_checker.accept(s.subject))
 
@@ -4866,24 +5454,32 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
             # The second pass narrows down the types and type checks bodies.
             for p, g, b in zip(s.patterns, s.guards, s.bodies):
                 current_subject_type = self.expr_checker.narrow_type_from_binder(
-                    s.subject, subject_type
+                    named_subject, subject_type
                 )
                 pattern_type = self.pattern_checker.accept(p, current_subject_type)
                 with self.binder.frame_context(can_skip=True, fall_through=2):
                     if b.is_unreachable or isinstance(
                         get_proper_type(pattern_type.type), UninhabitedType
                     ):
-                        self.push_type_map(None)
+                        self.push_type_map(None, from_assignment=False)
                         else_map: TypeMap = {}
                     else:
                         pattern_map, else_map = conditional_types_to_typemaps(
-                            s.subject, pattern_type.type, pattern_type.rest_type
+                            named_subject, pattern_type.type, pattern_type.rest_type
                         )
+                        pattern_map = self.propagate_up_typemap_info(pattern_map)
+                        else_map = self.propagate_up_typemap_info(else_map)
                         self.remove_capture_conflicts(pattern_type.captures, inferred_types)
-                        self.push_type_map(pattern_map)
-                        self.push_type_map(pattern_type.captures)
+                        self.push_type_map(pattern_map, from_assignment=False)
+                        if pattern_map:
+                            for expr, typ in pattern_map.items():
+                                self.push_type_map(
+                                    self._get_recursive_sub_patterns_map(expr, typ),
+                                    from_assignment=False,
+                                )
+                        self.push_type_map(pattern_type.captures, from_assignment=False)
                     if g is not None:
-                        with self.binder.frame_context(can_skip=True, fall_through=3):
+                        with self.binder.frame_context(can_skip=False, fall_through=3):
                             gt = get_proper_type(self.expr_checker.accept(g))
 
                             if isinstance(gt, DeletedType):
@@ -4892,28 +5488,61 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
                             guard_map, guard_else_map = self.find_isinstance_check(g)
                             else_map = or_conditional_maps(else_map, guard_else_map)
 
-                            self.push_type_map(guard_map)
+                            # If the guard narrowed the subject, copy the narrowed types over
+                            if isinstance(p, AsPattern):
+                                case_target = p.pattern or p.name
+                                if isinstance(case_target, NameExpr):
+                                    for type_map in (guard_map, else_map):
+                                        if not type_map:
+                                            continue
+                                        for expr in list(type_map):
+                                            if not (
+                                                isinstance(expr, NameExpr)
+                                                and expr.fullname == case_target.fullname
+                                            ):
+                                                continue
+                                            type_map[named_subject] = type_map[expr]
+
+                            self.push_type_map(guard_map, from_assignment=False)
                             self.accept(b)
                     else:
                         self.accept(b)
-                self.push_type_map(else_map)
+                self.push_type_map(else_map, from_assignment=False)
 
             # This is needed due to a quirk in frame_context. Without it types will stay narrowed
             # after the match.
             with self.binder.frame_context(can_skip=False, fall_through=2):
                 pass
 
-    def infer_variable_types_from_type_maps(self, type_maps: list[TypeMap]) -> dict[Var, Type]:
-        all_captures: dict[Var, list[tuple[NameExpr, Type]]] = defaultdict(list)
+    def _get_recursive_sub_patterns_map(
+        self, expr: Expression, typ: Type
+    ) -> dict[Expression, Type]:
+        sub_patterns_map: dict[Expression, Type] = {}
+        typ_ = get_proper_type(typ)
+        if isinstance(expr, TupleExpr) and isinstance(typ_, TupleType):
+            # When matching a tuple expression with a sequence pattern, narrow individual tuple items
+            assert len(expr.items) == len(typ_.items)
+            for item_expr, item_typ in zip(expr.items, typ_.items):
+                sub_patterns_map[item_expr] = item_typ
+                sub_patterns_map.update(self._get_recursive_sub_patterns_map(item_expr, item_typ))
+
+        return sub_patterns_map
+
+    def infer_variable_types_from_type_maps(
+        self, type_maps: list[TypeMap]
+    ) -> dict[SymbolNode, Type]:
+        # Type maps may contain variables inherited from previous code which are not
+        # necessary `Var`s (e.g. a function defined earlier with the same name).
+        all_captures: dict[SymbolNode, list[tuple[NameExpr, Type]]] = defaultdict(list)
         for tm in type_maps:
             if tm is not None:
                 for expr, typ in tm.items():
                     if isinstance(expr, NameExpr):
                         node = expr.node
-                        assert isinstance(node, Var)
+                        assert node is not None
                         all_captures[node].append((expr, typ))
 
-        inferred_types: dict[Var, Type] = {}
+        inferred_types: dict[SymbolNode, Type] = {}
         for var, captures in all_captures.items():
             already_exists = False
             types: list[Type] = []
@@ -4937,19 +5566,29 @@ def infer_variable_types_from_type_maps(self, type_maps: list[TypeMap]) -> dict[
                 new_type = UnionType.make_union(types)
                 # Infer the union type at the first occurrence
                 first_occurrence, _ = captures[0]
+                # If it didn't exist before ``match``, it's a Var.
+                assert isinstance(var, Var)
                 inferred_types[var] = new_type
                 self.infer_variable_type(var, first_occurrence, new_type, first_occurrence)
         return inferred_types
 
-    def remove_capture_conflicts(self, type_map: TypeMap, inferred_types: dict[Var, Type]) -> None:
+    def remove_capture_conflicts(
+        self, type_map: TypeMap, inferred_types: dict[SymbolNode, Type]
+    ) -> None:
         if type_map:
             for expr, typ in list(type_map.items()):
                 if isinstance(expr, NameExpr):
                     node = expr.node
-                    assert isinstance(node, Var)
                     if node not in inferred_types or not is_subtype(typ, inferred_types[node]):
                         del type_map[expr]
 
+    def visit_type_alias_stmt(self, o: TypeAliasStmt) -> None:
+        if o.alias_node:
+            self.check_typevar_defaults(o.alias_node.alias_tvars)
+
+        with self.msg.filter_errors():
+            self.expr_checker.accept(o.value)
+
     def make_fake_typeinfo(
         self,
         curr_module_fullname: str,
@@ -4985,13 +5624,9 @@ def intersect_instances(
         theoretical subclass of the instances the user may be trying to use
         the generated intersection can serve as a placeholder.
 
-        This function will create a fresh subclass every time you call it,
-        even if you pass in the exact same arguments. So this means calling
-        `self.intersect_intersection([inst_1, inst_2], ctx)` twice will result
-        in instances of two distinct subclasses of inst_1 and inst_2.
-
-        This is by design: we want each ad-hoc intersection to be unique since
-        they're supposed represent some other unknown subclass.
+        This function will create a fresh subclass the first time you call it.
+        So this means calling `self.intersect_intersection([inst_1, inst_2], ctx)`
+        twice will return the same subclass of inst_1 and inst_2.
 
         Returns None if creating the subclass is impossible (e.g. due to
         MRO errors or incompatible signatures). If we do successfully create
@@ -5024,39 +5659,51 @@ def _get_base_classes(instances_: tuple[Instance, Instance]) -> list[Instance]:
             return base_classes_
 
         def _make_fake_typeinfo_and_full_name(
-            base_classes_: list[Instance], curr_module_: MypyFile
+            base_classes_: list[Instance], curr_module_: MypyFile, options: Options
         ) -> tuple[TypeInfo, str]:
-            names_list = pretty_seq([x.type.name for x in base_classes_], "and")
-            short_name = f"<subclass of {names_list}>"
-            full_name_ = gen_unique_name(short_name, curr_module_.names)
-            cdef, info_ = self.make_fake_typeinfo(
-                curr_module_.fullname, full_name_, short_name, base_classes_
-            )
-            return info_, full_name_
+            names = [format_type_bare(x, options=options, verbosity=2) for x in base_classes_]
+            name = f"<subclass of {pretty_seq(names, 'and')}>"
+            if (symbol := curr_module_.names.get(name)) is not None:
+                assert isinstance(symbol.node, TypeInfo)
+                return symbol.node, name
+            cdef, info_ = self.make_fake_typeinfo(curr_module_.fullname, name, name, base_classes_)
+            return info_, name
 
         base_classes = _get_base_classes(instances)
-        # We use the pretty_names_list for error messages but can't
-        # use it for the real name that goes into the symbol table
-        # because it can have dots in it.
+        # We use the pretty_names_list for error messages but for the real name that goes
+        # into the symbol table because it is not specific enough.
         pretty_names_list = pretty_seq(
             format_type_distinctly(*base_classes, options=self.options, bare=True), "and"
         )
+
+        new_errors = []
+        for base in base_classes:
+            if base.type.is_final:
+                new_errors.append((pretty_names_list, f'"{base.type.name}" is final'))
+        if new_errors:
+            errors.extend(new_errors)
+            return None
+
         try:
-            info, full_name = _make_fake_typeinfo_and_full_name(base_classes, curr_module)
+            info, full_name = _make_fake_typeinfo_and_full_name(
+                base_classes, curr_module, self.options
+            )
             with self.msg.filter_errors() as local_errors:
                 self.check_multiple_inheritance(info)
             if local_errors.has_new_errors():
                 # "class A(B, C)" unsafe, now check "class A(C, B)":
                 base_classes = _get_base_classes(instances[::-1])
-                info, full_name = _make_fake_typeinfo_and_full_name(base_classes, curr_module)
+                info, full_name = _make_fake_typeinfo_and_full_name(
+                    base_classes, curr_module, self.options
+                )
                 with self.msg.filter_errors() as local_errors:
                     self.check_multiple_inheritance(info)
             info.is_intersection = True
         except MroError:
-            errors.append((pretty_names_list, "inconsistent method resolution order"))
+            errors.append((pretty_names_list, "would have inconsistent method resolution order"))
             return None
         if local_errors.has_new_errors():
-            errors.append((pretty_names_list, "incompatible method signatures"))
+            errors.append((pretty_names_list, "would have incompatible method signatures"))
             return None
 
         curr_module.names[full_name] = SymbolTableNode(GDEF, info)
@@ -5148,7 +5795,7 @@ def partition_by_callable(
 
         if isinstance(typ, TypeVarType):
             # We could do better probably?
-            # Refine the the type variable's bound as our type in the case that
+            # Refine the type variable's bound as our type in the case that
             # callable() is true. This unfortunately loses the information that
             # the type is a type variable in that branch.
             # This matches what is done for isinstance, but it may be possible to
@@ -5274,7 +5921,16 @@ def _is_truthy_type(self, t: ProperType) -> bool:
             )
         )
 
-    def _check_for_truthy_type(self, t: Type, expr: Expression) -> None:
+    def check_for_truthy_type(self, t: Type, expr: Expression) -> None:
+        """
+        Check if a type can have a truthy value.
+
+        Used in checks like::
+
+            if x: # <---
+
+            not x  # <---
+        """
         if not state.strict_optional:
             return  # if everything can be None, all bets are off
 
@@ -5380,6 +6036,8 @@ def is_type_call(expr: CallExpr) -> bool:
 
         def combine_maps(list_maps: list[TypeMap]) -> TypeMap:
             """Combine all typemaps in list_maps into one typemap"""
+            if all(m is None for m in list_maps):
+                return None
             result_map = {}
             for d in list_maps:
                 if d is not None:
@@ -5397,10 +6055,12 @@ def combine_maps(list_maps: list[TypeMap]) -> TypeMap:
             else_map = {}
         return if_map, else_map
 
-    def find_isinstance_check(self, node: Expression) -> tuple[TypeMap, TypeMap]:
+    def find_isinstance_check(
+        self, node: Expression, *, in_boolean_context: bool = True
+    ) -> tuple[TypeMap, TypeMap]:
         """Find any isinstance checks (within a chain of ands).  Includes
         implicit and explicit checks for None and calls to callable.
-        Also includes TypeGuard functions.
+        Also includes TypeGuard and TypeIs functions.
 
         Return value is a map of variables to their types if the condition
         is true and a map of variables to their types if the condition is false.
@@ -5408,15 +6068,24 @@ def find_isinstance_check(self, node: Expression) -> tuple[TypeMap, TypeMap]:
         If either of the values in the tuple is None, then that particular
         branch can never occur.
 
+        If `in_boolean_context=True` is passed, it means that we handle
+        a walrus expression. We treat rhs values
+        in expressions like `(a := A())` specially:
+        for example, some errors are suppressed.
+
         May return {}, {}.
         Can return None, None in situations involving NoReturn.
         """
-        if_map, else_map = self.find_isinstance_check_helper(node)
+        if_map, else_map = self.find_isinstance_check_helper(
+            node, in_boolean_context=in_boolean_context
+        )
         new_if_map = self.propagate_up_typemap_info(if_map)
         new_else_map = self.propagate_up_typemap_info(else_map)
         return new_if_map, new_else_map
 
-    def find_isinstance_check_helper(self, node: Expression) -> tuple[TypeMap, TypeMap]:
+    def find_isinstance_check_helper(
+        self, node: Expression, *, in_boolean_context: bool = True
+    ) -> tuple[TypeMap, TypeMap]:
         if is_true_literal(node):
             return {}, None
         if is_false_literal(node):
@@ -5452,198 +6121,62 @@ def find_isinstance_check_helper(self, node: Expression) -> tuple[TypeMap, TypeM
                 if literal(expr) == LITERAL_TYPE and attr and len(attr) == 1:
                     return self.hasattr_type_maps(expr, self.lookup_type(expr), attr[0])
             elif isinstance(node.callee, RefExpr):
-                if node.callee.type_guard is not None:
+                if node.callee.type_guard is not None or node.callee.type_is is not None:
                     # TODO: Follow *args, **kwargs
                     if node.arg_kinds[0] != nodes.ARG_POS:
                         # the first argument might be used as a kwarg
                         called_type = get_proper_type(self.lookup_type(node.callee))
-                        assert isinstance(called_type, (CallableType, Overloaded))
+
+                        # TODO: there are some more cases in check_call() to handle.
+                        if isinstance(called_type, Instance):
+                            call = find_member(
+                                "__call__", called_type, called_type, is_operator=True
+                            )
+                            if call is not None:
+                                called_type = get_proper_type(call)
 
                         # *assuming* the overloaded function is correct, there's a couple cases:
                         #  1) The first argument has different names, but is pos-only. We don't
                         #     care about this case, the argument must be passed positionally.
                         #  2) The first argument allows keyword reference, therefore must be the
                         #     same between overloads.
-                        name = called_type.items[0].arg_names[0]
-
-                        if name in node.arg_names:
-                            idx = node.arg_names.index(name)
-                            # we want the idx-th variable to be narrowed
-                            expr = collapse_walrus(node.args[idx])
-                        else:
-                            self.fail(message_registry.TYPE_GUARD_POS_ARG_REQUIRED, node)
-                            return {}, {}
+                        if isinstance(called_type, (CallableType, Overloaded)):
+                            name = called_type.items[0].arg_names[0]
+                            if name in node.arg_names:
+                                idx = node.arg_names.index(name)
+                                # we want the idx-th variable to be narrowed
+                                expr = collapse_walrus(node.args[idx])
+                            else:
+                                kind = (
+                                    "guard" if node.callee.type_guard is not None else "narrower"
+                                )
+                                self.fail(
+                                    message_registry.TYPE_GUARD_POS_ARG_REQUIRED.format(kind), node
+                                )
+                                return {}, {}
                     if literal(expr) == LITERAL_TYPE:
                         # Note: we wrap the target type, so that we can special case later.
                         # Namely, for isinstance() we use a normal meet, while TypeGuard is
                         # considered "always right" (i.e. even if the types are not overlapping).
                         # Also note that a care must be taken to unwrap this back at read places
                         # where we use this to narrow down declared type.
-                        return {expr: TypeGuardedType(node.callee.type_guard)}, {}
-        elif isinstance(node, ComparisonExpr):
-            # Step 1: Obtain the types of each operand and whether or not we can
-            # narrow their types. (For example, we shouldn't try narrowing the
-            # types of literal string or enum expressions).
-
-            operands = [collapse_walrus(x) for x in node.operands]
-            operand_types = []
-            narrowable_operand_index_to_hash = {}
-            for i, expr in enumerate(operands):
-                if not self.has_type(expr):
-                    return {}, {}
-                expr_type = self.lookup_type(expr)
-                operand_types.append(expr_type)
-
-                if (
-                    literal(expr) == LITERAL_TYPE
-                    and not is_literal_none(expr)
-                    and not self.is_literal_enum(expr)
-                ):
-                    h = literal_hash(expr)
-                    if h is not None:
-                        narrowable_operand_index_to_hash[i] = h
-
-            # Step 2: Group operands chained by either the 'is' or '==' operands
-            # together. For all other operands, we keep them in groups of size 2.
-            # So the expression:
-            #
-            #   x0 == x1 == x2 < x3 < x4 is x5 is x6 is not x7 is not x8
-            #
-            # ...is converted into the simplified operator list:
-            #
-            #  [("==", [0, 1, 2]), ("<", [2, 3]), ("<", [3, 4]),
-            #   ("is", [4, 5, 6]), ("is not", [6, 7]), ("is not", [7, 8])]
-            #
-            # We group identity/equality expressions so we can propagate information
-            # we discover about one operand across the entire chain. We don't bother
-            # handling 'is not' and '!=' chains in a special way: those are very rare
-            # in practice.
-
-            simplified_operator_list = group_comparison_operands(
-                node.pairwise(), narrowable_operand_index_to_hash, {"==", "is"}
-            )
-
-            # Step 3: Analyze each group and infer more precise type maps for each
-            # assignable operand, if possible. We combine these type maps together
-            # in the final step.
-
-            partial_type_maps = []
-            for operator, expr_indices in simplified_operator_list:
-                if operator in {"is", "is not", "==", "!="}:
-                    # is_valid_target:
-                    #   Controls which types we're allowed to narrow exprs to. Note that
-                    #   we cannot use 'is_literal_type_like' in both cases since doing
-                    #   'x = 10000 + 1; x is 10001' is not always True in all Python
-                    #   implementations.
-                    #
-                    # coerce_only_in_literal_context:
-                    #   If true, coerce types into literal types only if one or more of
-                    #   the provided exprs contains an explicit Literal type. This could
-                    #   technically be set to any arbitrary value, but it seems being liberal
-                    #   with narrowing when using 'is' and conservative when using '==' seems
-                    #   to break the least amount of real-world code.
-                    #
-                    # should_narrow_by_identity:
-                    #   Set to 'false' only if the user defines custom __eq__ or __ne__ methods
-                    #   that could cause identity-based narrowing to produce invalid results.
-                    if operator in {"is", "is not"}:
-                        is_valid_target: Callable[[Type], bool] = is_singleton_type
-                        coerce_only_in_literal_context = False
-                        should_narrow_by_identity = True
-                    else:
-
-                        def is_exactly_literal_type(t: Type) -> bool:
-                            return isinstance(get_proper_type(t), LiteralType)
-
-                        def has_no_custom_eq_checks(t: Type) -> bool:
-                            return not custom_special_method(
-                                t, "__eq__", check_all=False
-                            ) and not custom_special_method(t, "__ne__", check_all=False)
-
-                        is_valid_target = is_exactly_literal_type
-                        coerce_only_in_literal_context = True
-
-                        expr_types = [operand_types[i] for i in expr_indices]
-                        should_narrow_by_identity = all(map(has_no_custom_eq_checks, expr_types))
-
-                    if_map: TypeMap = {}
-                    else_map: TypeMap = {}
-                    if should_narrow_by_identity:
-                        if_map, else_map = self.refine_identity_comparison_expression(
-                            operands,
-                            operand_types,
-                            expr_indices,
-                            narrowable_operand_index_to_hash.keys(),
-                            is_valid_target,
-                            coerce_only_in_literal_context,
-                        )
-
-                    # Strictly speaking, we should also skip this check if the objects in the expr
-                    # chain have custom __eq__ or __ne__ methods. But we (maybe optimistically)
-                    # assume nobody would actually create a custom objects that considers itself
-                    # equal to None.
-                    if if_map == {} and else_map == {}:
-                        if_map, else_map = self.refine_away_none_in_comparison(
-                            operands,
-                            operand_types,
-                            expr_indices,
-                            narrowable_operand_index_to_hash.keys(),
-                        )
-
-                    # If we haven't been able to narrow types yet, we might be dealing with a
-                    # explicit type(x) == some_type check
-                    if if_map == {} and else_map == {}:
-                        if_map, else_map = self.find_type_equals_check(node, expr_indices)
-                elif operator in {"in", "not in"}:
-                    assert len(expr_indices) == 2
-                    left_index, right_index = expr_indices
-                    item_type = operand_types[left_index]
-                    iterable_type = operand_types[right_index]
-
-                    if_map, else_map = {}, {}
-
-                    if left_index in narrowable_operand_index_to_hash:
-                        # We only try and narrow away 'None' for now
-                        if is_optional(item_type):
-                            collection_item_type = get_proper_type(
-                                builtin_item_type(iterable_type)
-                            )
-                            if (
-                                collection_item_type is not None
-                                and not is_optional(collection_item_type)
-                                and not (
-                                    isinstance(collection_item_type, Instance)
-                                    and collection_item_type.type.fullname == "builtins.object"
-                                )
-                                and is_overlapping_erased_types(item_type, collection_item_type)
-                            ):
-                                if_map[operands[left_index]] = remove_optional(item_type)
-
-                    if right_index in narrowable_operand_index_to_hash:
-                        if_type, else_type = self.conditional_types_for_iterable(
-                            item_type, iterable_type
-                        )
-                        expr = operands[right_index]
-                        if if_type is None:
-                            if_map = None
+                        if node.callee.type_guard is not None:
+                            return {expr: TypeGuardedType(node.callee.type_guard)}, {}
                         else:
-                            if_map[expr] = if_type
-                        if else_type is None:
-                            else_map = None
-                        else:
-                            else_map[expr] = else_type
-
-                else:
-                    if_map = {}
-                    else_map = {}
-
-                if operator in {"is not", "!=", "not in"}:
-                    if_map, else_map = else_map, if_map
-
-                partial_type_maps.append((if_map, else_map))
-
-            return reduce_conditional_maps(partial_type_maps)
+                            assert node.callee.type_is is not None
+                            return conditional_types_to_typemaps(
+                                expr,
+                                *self.conditional_types_with_intersection(
+                                    self.lookup_type(expr),
+                                    [TypeRange(node.callee.type_is, is_upper_bound=False)],
+                                    expr,
+                                ),
+                            )
+        elif isinstance(node, ComparisonExpr):
+            return self.comparison_type_narrowing_helper(node)
         elif isinstance(node, AssignmentExpr):
+            if_map: dict[Expression, Type] | None
+            else_map: dict[Expression, Type] | None
             if_map = {}
             else_map = {}
 
@@ -5654,7 +6187,9 @@ def has_no_custom_eq_checks(t: Type) -> bool:
             if else_assignment_map is not None:
                 else_map.update(else_assignment_map)
 
-            if_condition_map, else_condition_map = self.find_isinstance_check(node.value)
+            if_condition_map, else_condition_map = self.find_isinstance_check(
+                node.value, in_boolean_context=False
+            )
 
             if if_condition_map is not None:
                 if_map.update(if_condition_map)
@@ -5673,7 +6208,10 @@ def has_no_custom_eq_checks(t: Type) -> bool:
             # and false if at least one of e1 and e2 is false.
             return (
                 and_conditional_maps(left_if_vars, right_if_vars),
-                or_conditional_maps(left_else_vars, right_else_vars),
+                # Note that if left else type is Any, we can't add any additional
+                # types to it, since the right maps were computed assuming
+                # the left is True, which may be not the case in the else branch.
+                or_conditional_maps(left_else_vars, right_else_vars, coalesce_any=True),
             )
         elif isinstance(node, OpExpr) and node.op == "or":
             left_if_vars, left_else_vars = self.find_isinstance_check(node.left)
@@ -5688,11 +6226,35 @@ def has_no_custom_eq_checks(t: Type) -> bool:
         elif isinstance(node, UnaryExpr) and node.op == "not":
             left, right = self.find_isinstance_check(node.expr)
             return right, left
+        elif (
+            literal(node) == LITERAL_TYPE
+            and self.has_type(node)
+            and self.can_be_narrowed_with_len(self.lookup_type(node))
+            # Only translate `if x` to `if len(x) > 0` when possible.
+            and not custom_special_method(self.lookup_type(node), "__bool__")
+            and self.options.strict_optional
+        ):
+            # Combine a `len(x) > 0` check with the default logic below.
+            yes_type, no_type = self.narrow_with_len(self.lookup_type(node), ">", 0)
+            if yes_type is not None:
+                yes_type = true_only(yes_type)
+            else:
+                yes_type = UninhabitedType()
+            if no_type is not None:
+                no_type = false_only(no_type)
+            else:
+                no_type = UninhabitedType()
+            if_map = {node: yes_type} if not isinstance(yes_type, UninhabitedType) else None
+            else_map = {node: no_type} if not isinstance(no_type, UninhabitedType) else None
+            return if_map, else_map
 
         # Restrict the type of the variable to True-ish/False-ish in the if and else branches
         # respectively
         original_vartype = self.lookup_type(node)
-        self._check_for_truthy_type(original_vartype, node)
+        if in_boolean_context:
+            # We don't check `:=` values in expressions like `(a := A())`,
+            # because they produce two error messages.
+            self.check_for_truthy_type(original_vartype, node)
         vartype = try_expanding_sum_type_to_union(original_vartype, "builtins.bool")
 
         if_type = true_only(vartype)
@@ -5701,6 +6263,192 @@ def has_no_custom_eq_checks(t: Type) -> bool:
         else_map = {node: else_type} if not isinstance(else_type, UninhabitedType) else None
         return if_map, else_map
 
+    def comparison_type_narrowing_helper(self, node: ComparisonExpr) -> tuple[TypeMap, TypeMap]:
+        """Infer type narrowing from a comparison expression."""
+        # Step 1: Obtain the types of each operand and whether or not we can
+        # narrow their types. (For example, we shouldn't try narrowing the
+        # types of literal string or enum expressions).
+
+        operands = [collapse_walrus(x) for x in node.operands]
+        operand_types = []
+        narrowable_operand_index_to_hash = {}
+        for i, expr in enumerate(operands):
+            if not self.has_type(expr):
+                return {}, {}
+            expr_type = self.lookup_type(expr)
+            operand_types.append(expr_type)
+
+            if (
+                literal(expr) == LITERAL_TYPE
+                and not is_literal_none(expr)
+                and not self.is_literal_enum(expr)
+            ):
+                h = literal_hash(expr)
+                if h is not None:
+                    narrowable_operand_index_to_hash[i] = h
+
+        # Step 2: Group operands chained by either the 'is' or '==' operands
+        # together. For all other operands, we keep them in groups of size 2.
+        # So the expression:
+        #
+        #   x0 == x1 == x2 < x3 < x4 is x5 is x6 is not x7 is not x8
+        #
+        # ...is converted into the simplified operator list:
+        #
+        #  [("==", [0, 1, 2]), ("<", [2, 3]), ("<", [3, 4]),
+        #   ("is", [4, 5, 6]), ("is not", [6, 7]), ("is not", [7, 8])]
+        #
+        # We group identity/equality expressions so we can propagate information
+        # we discover about one operand across the entire chain. We don't bother
+        # handling 'is not' and '!=' chains in a special way: those are very rare
+        # in practice.
+
+        simplified_operator_list = group_comparison_operands(
+            node.pairwise(), narrowable_operand_index_to_hash, {"==", "is"}
+        )
+
+        # Step 3: Analyze each group and infer more precise type maps for each
+        # assignable operand, if possible. We combine these type maps together
+        # in the final step.
+
+        partial_type_maps = []
+        for operator, expr_indices in simplified_operator_list:
+            if operator in {"is", "is not", "==", "!="}:
+                if_map, else_map = self.equality_type_narrowing_helper(
+                    node,
+                    operator,
+                    operands,
+                    operand_types,
+                    expr_indices,
+                    narrowable_operand_index_to_hash,
+                )
+            elif operator in {"in", "not in"}:
+                assert len(expr_indices) == 2
+                left_index, right_index = expr_indices
+                item_type = operand_types[left_index]
+                iterable_type = operand_types[right_index]
+
+                if_map, else_map = {}, {}
+
+                if left_index in narrowable_operand_index_to_hash:
+                    # We only try and narrow away 'None' for now
+                    if is_overlapping_none(item_type):
+                        collection_item_type = get_proper_type(builtin_item_type(iterable_type))
+                        if (
+                            collection_item_type is not None
+                            and not is_overlapping_none(collection_item_type)
+                            and not (
+                                isinstance(collection_item_type, Instance)
+                                and collection_item_type.type.fullname == "builtins.object"
+                            )
+                            and is_overlapping_erased_types(item_type, collection_item_type)
+                        ):
+                            if_map[operands[left_index]] = remove_optional(item_type)
+
+                if right_index in narrowable_operand_index_to_hash:
+                    if_type, else_type = self.conditional_types_for_iterable(
+                        item_type, iterable_type
+                    )
+                    expr = operands[right_index]
+                    if if_type is None:
+                        if_map = None
+                    else:
+                        if_map[expr] = if_type
+                    if else_type is None:
+                        else_map = None
+                    else:
+                        else_map[expr] = else_type
+
+            else:
+                if_map = {}
+                else_map = {}
+
+            if operator in {"is not", "!=", "not in"}:
+                if_map, else_map = else_map, if_map
+
+            partial_type_maps.append((if_map, else_map))
+
+        # If we have found non-trivial restrictions from the regular comparisons,
+        # then return soon. Otherwise try to infer restrictions involving `len(x)`.
+        # TODO: support regular and len() narrowing in the same chain.
+        if any(m != ({}, {}) for m in partial_type_maps):
+            return reduce_conditional_maps(partial_type_maps)
+        else:
+            # Use meet for `and` maps to get correct results for chained checks
+            # like `if 1 < len(x) < 4: ...`
+            return reduce_conditional_maps(self.find_tuple_len_narrowing(node), use_meet=True)
+
+    def equality_type_narrowing_helper(
+        self,
+        node: ComparisonExpr,
+        operator: str,
+        operands: list[Expression],
+        operand_types: list[Type],
+        expr_indices: list[int],
+        narrowable_operand_index_to_hash: dict[int, tuple[Key, ...]],
+    ) -> tuple[TypeMap, TypeMap]:
+        """Calculate type maps for '==', '!=', 'is' or 'is not' expression."""
+        # is_valid_target:
+        #   Controls which types we're allowed to narrow exprs to. Note that
+        #   we cannot use 'is_literal_type_like' in both cases since doing
+        #   'x = 10000 + 1; x is 10001' is not always True in all Python
+        #   implementations.
+        #
+        # coerce_only_in_literal_context:
+        #   If true, coerce types into literal types only if one or more of
+        #   the provided exprs contains an explicit Literal type. This could
+        #   technically be set to any arbitrary value, but it seems being liberal
+        #   with narrowing when using 'is' and conservative when using '==' seems
+        #   to break the least amount of real-world code.
+        #
+        # should_narrow_by_identity:
+        #   Set to 'false' only if the user defines custom __eq__ or __ne__ methods
+        #   that could cause identity-based narrowing to produce invalid results.
+        if operator in {"is", "is not"}:
+            is_valid_target: Callable[[Type], bool] = is_singleton_type
+            coerce_only_in_literal_context = False
+            should_narrow_by_identity = True
+        else:
+
+            def is_exactly_literal_type(t: Type) -> bool:
+                return isinstance(get_proper_type(t), LiteralType)
+
+            def has_no_custom_eq_checks(t: Type) -> bool:
+                return not custom_special_method(
+                    t, "__eq__", check_all=False
+                ) and not custom_special_method(t, "__ne__", check_all=False)
+
+            is_valid_target = is_exactly_literal_type
+            coerce_only_in_literal_context = True
+
+            expr_types = [operand_types[i] for i in expr_indices]
+            should_narrow_by_identity = all(
+                map(has_no_custom_eq_checks, expr_types)
+            ) and not is_ambiguous_mix_of_enums(expr_types)
+
+        if_map: TypeMap = {}
+        else_map: TypeMap = {}
+        if should_narrow_by_identity:
+            if_map, else_map = self.refine_identity_comparison_expression(
+                operands,
+                operand_types,
+                expr_indices,
+                narrowable_operand_index_to_hash.keys(),
+                is_valid_target,
+                coerce_only_in_literal_context,
+            )
+
+        if if_map == {} and else_map == {}:
+            if_map, else_map = self.refine_away_none_in_comparison(
+                operands, operand_types, expr_indices, narrowable_operand_index_to_hash.keys()
+            )
+
+        # If we haven't been able to narrow types yet, we might be dealing with a
+        # explicit type(x) == some_type check
+        if if_map == {} and else_map == {}:
+            if_map, else_map = self.find_type_equals_check(node, expr_indices)
+        return if_map, else_map
+
     def propagate_up_typemap_info(self, new_types: TypeMap) -> TypeMap:
         """Attempts refining parent expressions of any MemberExpr or IndexExprs in new_types.
 
@@ -5777,7 +6525,6 @@ def replay_lookup(new_parent_type: ProperType) -> Type | None:
                             is_lvalue=False,
                             is_super=False,
                             is_operator=False,
-                            msg=self.msg,
                             original_type=new_parent_type,
                             chk=self,
                             in_literal_context=False,
@@ -6014,25 +6761,317 @@ def refine_away_none_in_comparison(
         For more details about what the different arguments mean, see the
         docstring of 'refine_identity_comparison_expression' up above.
         """
+
         non_optional_types = []
         for i in chain_indices:
             typ = operand_types[i]
-            if not is_optional(typ):
+            if not is_overlapping_none(typ):
                 non_optional_types.append(typ)
 
-        # Make sure we have a mixture of optional and non-optional types.
-        if len(non_optional_types) == 0 or len(non_optional_types) == len(chain_indices):
-            return {}, {}
+        if_map, else_map = {}, {}
 
-        if_map = {}
-        for i in narrowable_operand_indices:
-            expr_type = operand_types[i]
-            if not is_optional(expr_type):
+        if not non_optional_types or (len(non_optional_types) != len(chain_indices)):
+
+            # Narrow e.g. `Optional[A] == "x"` or `Optional[A] is "x"` to `A` (which may be
+            # convenient but is strictly not type-safe):
+            for i in narrowable_operand_indices:
+                expr_type = operand_types[i]
+                if not is_overlapping_none(expr_type):
+                    continue
+                if any(is_overlapping_erased_types(expr_type, t) for t in non_optional_types):
+                    if_map[operands[i]] = remove_optional(expr_type)
+
+            # Narrow e.g. `Optional[A] != None` to `A` (which is stricter than the above step and
+            # so type-safe but less convenient, because e.g. `Optional[A] == None` still results
+            # in `Optional[A]`):
+            if any(isinstance(get_proper_type(ot), NoneType) for ot in operand_types):
+                for i in narrowable_operand_indices:
+                    expr_type = operand_types[i]
+                    if is_overlapping_none(expr_type):
+                        else_map[operands[i]] = remove_optional(expr_type)
+
+        return if_map, else_map
+
+    def is_len_of_tuple(self, expr: Expression) -> bool:
+        """Is this expression a `len(x)` call where x is a tuple or union of tuples?"""
+        if not isinstance(expr, CallExpr):
+            return False
+        if not refers_to_fullname(expr.callee, "builtins.len"):
+            return False
+        if len(expr.args) != 1:
+            return False
+        expr = expr.args[0]
+        if literal(expr) != LITERAL_TYPE:
+            return False
+        if not self.has_type(expr):
+            return False
+        return self.can_be_narrowed_with_len(self.lookup_type(expr))
+
+    def can_be_narrowed_with_len(self, typ: Type) -> bool:
+        """Is this a type that can benefit from length check type restrictions?
+
+        Currently supported types are TupleTypes, Instances of builtins.tuple, and
+        unions involving such types.
+        """
+        if custom_special_method(typ, "__len__"):
+            # If user overrides builtin behavior, we can't do anything.
+            return False
+        p_typ = get_proper_type(typ)
+        # Note: we are conservative about tuple subclasses, because some code may rely on
+        # the fact that tuple_type of fallback TypeInfo matches the original TupleType.
+        if isinstance(p_typ, TupleType):
+            if any(isinstance(t, UnpackType) for t in p_typ.items):
+                return p_typ.partial_fallback.type.fullname == "builtins.tuple"
+            return True
+        if isinstance(p_typ, Instance):
+            return p_typ.type.has_base("builtins.tuple")
+        if isinstance(p_typ, UnionType):
+            return any(self.can_be_narrowed_with_len(t) for t in p_typ.items)
+        return False
+
+    def literal_int_expr(self, expr: Expression) -> int | None:
+        """Is this expression an int literal, or a reference to an int constant?
+
+        If yes, return the corresponding int value, otherwise return None.
+        """
+        if not self.has_type(expr):
+            return None
+        expr_type = self.lookup_type(expr)
+        expr_type = coerce_to_literal(expr_type)
+        proper_type = get_proper_type(expr_type)
+        if not isinstance(proper_type, LiteralType):
+            return None
+        if not isinstance(proper_type.value, int):
+            return None
+        return proper_type.value
+
+    def find_tuple_len_narrowing(self, node: ComparisonExpr) -> list[tuple[TypeMap, TypeMap]]:
+        """Top-level logic to find type restrictions from a length check on tuples.
+
+        We try to detect `if` checks like the following:
+            x: tuple[int, int] | tuple[int, int, int]
+            y: tuple[int, int] | tuple[int, int, int]
+            if len(x) == len(y) == 2:
+                a, b = x  # OK
+                c, d = y  # OK
+
+            z: tuple[int, ...]
+            if 1 < len(z) < 4:
+                x = z  # OK
+        and report corresponding type restrictions to the binder.
+        """
+        # First step: group consecutive `is` and `==` comparisons together.
+        # This is essentially a simplified version of group_comparison_operands(),
+        # tuned to the len()-like checks. Note that we don't propagate indirect
+        # restrictions like e.g. `len(x) > foo() > 1` yet, since it is tricky.
+        # TODO: propagate indirect len() comparison restrictions.
+        chained = []
+        last_group = set()
+        for op, left, right in node.pairwise():
+            if isinstance(left, AssignmentExpr):
+                left = left.value
+            if isinstance(right, AssignmentExpr):
+                right = right.value
+            if op in ("is", "=="):
+                last_group.add(left)
+                last_group.add(right)
+            else:
+                if last_group:
+                    chained.append(("==", list(last_group)))
+                    last_group = set()
+                if op in {"is not", "!=", "<", "<=", ">", ">="}:
+                    chained.append((op, [left, right]))
+        if last_group:
+            chained.append(("==", list(last_group)))
+
+        # Second step: infer type restrictions from each group found above.
+        type_maps = []
+        for op, items in chained:
+            # TODO: support unions of literal types as len() comparison targets.
+            if not any(self.literal_int_expr(it) is not None for it in items):
+                continue
+            if not any(self.is_len_of_tuple(it) for it in items):
                 continue
-            if any(is_overlapping_erased_types(expr_type, t) for t in non_optional_types):
-                if_map[operands[i]] = remove_optional(expr_type)
 
-        return if_map, {}
+            # At this step we know there is at least one len(x) and one literal in the group.
+            if op in ("is", "=="):
+                literal_values = set()
+                tuples = []
+                for it in items:
+                    lit = self.literal_int_expr(it)
+                    if lit is not None:
+                        literal_values.add(lit)
+                        continue
+                    if self.is_len_of_tuple(it):
+                        assert isinstance(it, CallExpr)
+                        tuples.append(it.args[0])
+                if len(literal_values) > 1:
+                    # More than one different literal value found, like 1 == len(x) == 2,
+                    # so the corresponding branch is unreachable.
+                    return [(None, {})]
+                size = literal_values.pop()
+                if size > MAX_PRECISE_TUPLE_SIZE:
+                    # Avoid creating huge tuples from checks like if len(x) == 300.
+                    continue
+                for tpl in tuples:
+                    yes_type, no_type = self.narrow_with_len(self.lookup_type(tpl), op, size)
+                    yes_map = None if yes_type is None else {tpl: yes_type}
+                    no_map = None if no_type is None else {tpl: no_type}
+                    type_maps.append((yes_map, no_map))
+            else:
+                left, right = items
+                if self.is_len_of_tuple(right):
+                    # Normalize `1 < len(x)` and similar as `len(x) > 1`.
+                    left, right = right, left
+                    op = flip_ops.get(op, op)
+                r_size = self.literal_int_expr(right)
+                assert r_size is not None
+                if r_size > MAX_PRECISE_TUPLE_SIZE:
+                    # Avoid creating huge unions from checks like if len(x) > 300.
+                    continue
+                assert isinstance(left, CallExpr)
+                yes_type, no_type = self.narrow_with_len(
+                    self.lookup_type(left.args[0]), op, r_size
+                )
+                yes_map = None if yes_type is None else {left.args[0]: yes_type}
+                no_map = None if no_type is None else {left.args[0]: no_type}
+                type_maps.append((yes_map, no_map))
+        return type_maps
+
+    def narrow_with_len(self, typ: Type, op: str, size: int) -> tuple[Type | None, Type | None]:
+        """Dispatch tuple type narrowing logic depending on the kind of type we got."""
+        typ = get_proper_type(typ)
+        if isinstance(typ, TupleType):
+            return self.refine_tuple_type_with_len(typ, op, size)
+        elif isinstance(typ, Instance):
+            return self.refine_instance_type_with_len(typ, op, size)
+        elif isinstance(typ, UnionType):
+            yes_types = []
+            no_types = []
+            other_types = []
+            for t in typ.items:
+                if not self.can_be_narrowed_with_len(t):
+                    other_types.append(t)
+                    continue
+                yt, nt = self.narrow_with_len(t, op, size)
+                if yt is not None:
+                    yes_types.append(yt)
+                if nt is not None:
+                    no_types.append(nt)
+            yes_types += other_types
+            no_types += other_types
+            if yes_types:
+                yes_type = make_simplified_union(yes_types)
+            else:
+                yes_type = None
+            if no_types:
+                no_type = make_simplified_union(no_types)
+            else:
+                no_type = None
+            return yes_type, no_type
+        else:
+            assert False, "Unsupported type for len narrowing"
+
+    def refine_tuple_type_with_len(
+        self, typ: TupleType, op: str, size: int
+    ) -> tuple[Type | None, Type | None]:
+        """Narrow a TupleType using length restrictions."""
+        unpack_index = find_unpack_in_list(typ.items)
+        if unpack_index is None:
+            # For fixed length tuple situation is trivial, it is either reachable or not,
+            # depending on the current length, expected length, and the comparison op.
+            method = int_op_to_method[op]
+            if method(typ.length(), size):
+                return typ, None
+            return None, typ
+        unpack = typ.items[unpack_index]
+        assert isinstance(unpack, UnpackType)
+        unpacked = get_proper_type(unpack.type)
+        if isinstance(unpacked, TypeVarTupleType):
+            # For tuples involving TypeVarTuple unpack we can't do much except
+            # inferring reachability, and recording the restrictions on TypeVarTuple
+            # for further "manual" use elsewhere.
+            min_len = typ.length() - 1 + unpacked.min_len
+            if op in ("==", "is"):
+                if min_len <= size:
+                    return typ, typ
+                return None, typ
+            elif op in ("<", "<="):
+                if op == "<=":
+                    size += 1
+                if min_len < size:
+                    prefix = typ.items[:unpack_index]
+                    suffix = typ.items[unpack_index + 1 :]
+                    # TODO: also record max_len to avoid false negatives?
+                    unpack = UnpackType(unpacked.copy_modified(min_len=size - typ.length() + 1))
+                    return typ, typ.copy_modified(items=prefix + [unpack] + suffix)
+                return None, typ
+            else:
+                yes_type, no_type = self.refine_tuple_type_with_len(typ, neg_ops[op], size)
+                return no_type, yes_type
+        # Homogeneous variadic item is the case where we are most flexible. Essentially,
+        # we adjust the variadic item by "eating away" from it to satisfy the restriction.
+        assert isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+        min_len = typ.length() - 1
+        arg = unpacked.args[0]
+        prefix = typ.items[:unpack_index]
+        suffix = typ.items[unpack_index + 1 :]
+        if op in ("==", "is"):
+            if min_len <= size:
+                # TODO: return fixed union + prefixed variadic tuple for no_type?
+                return typ.copy_modified(items=prefix + [arg] * (size - min_len) + suffix), typ
+            return None, typ
+        elif op in ("<", "<="):
+            if op == "<=":
+                size += 1
+            if min_len < size:
+                # Note: there is some ambiguity w.r.t. to where to put the additional
+                # items: before or after the unpack. However, such types are equivalent,
+                # so we always put them before for consistency.
+                no_type = typ.copy_modified(
+                    items=prefix + [arg] * (size - min_len) + [unpack] + suffix
+                )
+                yes_items = []
+                for n in range(size - min_len):
+                    yes_items.append(typ.copy_modified(items=prefix + [arg] * n + suffix))
+                return UnionType.make_union(yes_items, typ.line, typ.column), no_type
+            return None, typ
+        else:
+            yes_type, no_type = self.refine_tuple_type_with_len(typ, neg_ops[op], size)
+            return no_type, yes_type
+
+    def refine_instance_type_with_len(
+        self, typ: Instance, op: str, size: int
+    ) -> tuple[Type | None, Type | None]:
+        """Narrow a homogeneous tuple using length restrictions."""
+        base = map_instance_to_supertype(typ, self.lookup_typeinfo("builtins.tuple"))
+        arg = base.args[0]
+        # Again, we are conservative about subclasses until we gain more confidence.
+        allow_precise = (
+            PRECISE_TUPLE_TYPES in self.options.enable_incomplete_feature
+        ) and typ.type.fullname == "builtins.tuple"
+        if op in ("==", "is"):
+            # TODO: return fixed union + prefixed variadic tuple for no_type?
+            return TupleType(items=[arg] * size, fallback=typ), typ
+        elif op in ("<", "<="):
+            if op == "<=":
+                size += 1
+            if allow_precise:
+                unpack = UnpackType(self.named_generic_type("builtins.tuple", [arg]))
+                no_type: Type | None = TupleType(items=[arg] * size + [unpack], fallback=typ)
+            else:
+                no_type = typ
+            if allow_precise:
+                items = []
+                for n in range(size):
+                    items.append(TupleType([arg] * n, fallback=typ))
+                yes_type: Type | None = UnionType.make_union(items, typ.line, typ.column)
+            else:
+                yes_type = typ
+            return yes_type, no_type
+        else:
+            yes_type, no_type = self.refine_instance_type_with_len(typ, neg_ops[op], size)
+            return no_type, yes_type
 
     #
     # Helpers
@@ -6050,8 +7089,7 @@ def check_subtype(
         notes: list[str] | None = None,
         code: ErrorCode | None = None,
         outer_context: Context | None = None,
-    ) -> bool:
-        ...
+    ) -> bool: ...
 
     @overload
     def check_subtype(
@@ -6065,8 +7103,7 @@ def check_subtype(
         *,
         notes: list[str] | None = None,
         outer_context: Context | None = None,
-    ) -> bool:
-        ...
+    ) -> bool: ...
 
     def check_subtype(
         self,
@@ -6116,6 +7153,8 @@ def check_subtype(
             )
             if isinstance(subtype, Instance) and isinstance(supertype, Instance):
                 notes = append_invariance_notes(notes, subtype, supertype)
+            if isinstance(subtype, UnionType) and isinstance(supertype, UnionType):
+                notes = append_union_note(notes, subtype, supertype, self.options)
         if extra_info:
             msg = msg.with_additional_msg(" (" + ", ".join(extra_info) + ")")
 
@@ -6141,7 +7180,7 @@ def check_subtype(
                 assert call is not None
                 if not is_subtype(subtype, call, options=self.options):
                     self.msg.note_call(supertype, call, context, code=msg.code)
-        self.check_possible_missing_await(subtype, supertype, context)
+        self.check_possible_missing_await(subtype, supertype, context, code=msg.code)
         return False
 
     def get_precise_awaitable_type(self, typ: Type, local_errors: ErrorWatcher) -> Type | None:
@@ -6175,7 +7214,7 @@ def checking_await_set(self) -> Iterator[None]:
             self.checking_missing_await = False
 
     def check_possible_missing_await(
-        self, subtype: Type, supertype: Type, context: Context
+        self, subtype: Type, supertype: Type, context: Context, code: ErrorCode | None
     ) -> None:
         """Check if the given type becomes a subtype when awaited."""
         if self.checking_missing_await:
@@ -6189,20 +7228,7 @@ def check_possible_missing_await(
                 aw_type, supertype, context, msg=message_registry.INCOMPATIBLE_TYPES
             ):
                 return
-        self.msg.possible_missing_await(context)
-
-    def contains_none(self, t: Type) -> bool:
-        t = get_proper_type(t)
-        return (
-            isinstance(t, NoneType)
-            or (isinstance(t, UnionType) and any(self.contains_none(ut) for ut in t.items))
-            or (isinstance(t, TupleType) and any(self.contains_none(tt) for tt in t.items))
-            or (
-                isinstance(t, Instance)
-                and bool(t.args)
-                and any(self.contains_none(it) for it in t.args)
-            )
-        )
+        self.msg.possible_missing_await(context, code)
 
     def named_type(self, name: str) -> Instance:
         """Return an instance type with given name and implicit Any type args.
@@ -6509,12 +7535,12 @@ def iterable_item_type(
     def function_type(self, func: FuncBase) -> FunctionLike:
         return function_type(func, self.named_type("builtins.function"))
 
-    def push_type_map(self, type_map: TypeMap) -> None:
+    def push_type_map(self, type_map: TypeMap, *, from_assignment: bool = True) -> None:
         if type_map is None:
             self.binder.unreachable()
         else:
             for expr, type in type_map.items():
-                self.binder.put(expr, type)
+                self.binder.put(expr, type, from_assignment=from_assignment)
 
     def infer_issubclass_maps(self, node: CallExpr, expr: Expression) -> tuple[TypeMap, TypeMap]:
         """Infer type restrictions for an expression in issubclass call."""
@@ -6553,14 +7579,12 @@ def conditional_types_with_intersection(
         type_ranges: list[TypeRange] | None,
         ctx: Context,
         default: None = None,
-    ) -> tuple[Type | None, Type | None]:
-        ...
+    ) -> tuple[Type | None, Type | None]: ...
 
     @overload
     def conditional_types_with_intersection(
         self, expr_type: Type, type_ranges: list[TypeRange] | None, ctx: Context, default: Type
-    ) -> tuple[Type, Type]:
-        ...
+    ) -> tuple[Type, Type]: ...
 
     def conditional_types_with_intersection(
         self,
@@ -6591,9 +7615,10 @@ def conditional_types_with_intersection(
         possible_target_types = []
         for tr in type_ranges:
             item = get_proper_type(tr.item)
-            if not isinstance(item, Instance) or tr.is_upper_bound:
-                return yes_type, no_type
-            possible_target_types.append(item)
+            if isinstance(item, (Instance, NoneType)):
+                possible_target_types.append(item)
+        if not possible_target_types:
+            return yes_type, no_type
 
         out = []
         errors: list[tuple[str, str]] = []
@@ -6601,6 +7626,9 @@ def conditional_types_with_intersection(
             if not isinstance(v, Instance):
                 return yes_type, no_type
             for t in possible_target_types:
+                if isinstance(t, NoneType):
+                    errors.append((f'"{v.type.name}" and "NoneType"', '"NoneType" is final'))
+                    continue
                 intersection = self.intersect_instances((v, t), errors)
                 if intersection is None:
                     continue
@@ -6629,7 +7657,11 @@ def is_writable_attribute(self, node: Node) -> bool:
     def get_isinstance_type(self, expr: Expression) -> list[TypeRange] | None:
         if isinstance(expr, OpExpr) and expr.op == "|":
             left = self.get_isinstance_type(expr.left)
+            if left is None and is_literal_none(expr.left):
+                left = [TypeRange(NoneType(), is_upper_bound=False)]
             right = self.get_isinstance_type(expr.right)
+            if right is None and is_literal_none(expr.right):
+                right = [TypeRange(NoneType(), is_upper_bound=False)]
             if left is None or right is None:
                 return None
             return left + right
@@ -6644,10 +7676,16 @@ def get_isinstance_type(self, expr: Expression) -> list[TypeRange] | None:
             elif isinstance(typ, TypeType):
                 # Type[A] means "any type that is a subtype of A" rather than "precisely type A"
                 # we indicate this by setting is_upper_bound flag
-                types.append(TypeRange(typ.item, is_upper_bound=True))
+                is_upper_bound = True
+                if isinstance(typ.item, NoneType):
+                    # except for Type[None], because "'NoneType' is not an acceptable base type"
+                    is_upper_bound = False
+                types.append(TypeRange(typ.item, is_upper_bound=is_upper_bound))
             elif isinstance(typ, Instance) and typ.type.fullname == "builtins.type":
                 object_type = Instance(typ.type.mro[-1], [])
                 types.append(TypeRange(object_type, is_upper_bound=True))
+            elif isinstance(typ, Instance) and typ.type.fullname == "types.UnionType" and typ.args:
+                types.append(TypeRange(UnionType(typ.args), is_upper_bound=False))
             elif isinstance(typ, AnyType):
                 types.append(TypeRange(typ, is_upper_bound=False))
             else:  # we didn't see an actual type, but rather a variable with unknown value
@@ -6781,10 +7819,9 @@ def has_valid_attribute(self, typ: Type, name: str) -> bool:
                 name,
                 typ,
                 TempNode(AnyType(TypeOfAny.special_form)),
-                False,
-                False,
-                False,
-                self.msg,
+                is_lvalue=False,
+                is_super=False,
+                is_operator=False,
                 original_type=typ,
                 chk=self,
                 # This is not a real attribute lookup so don't mess with deferring nodes.
@@ -6793,6 +7830,64 @@ 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)
+
+    def check_deprecated(self, node: Node | None, context: Context) -> None:
+        """Warn if deprecated and not directly imported with a `from` statement."""
+        if isinstance(node, Decorator):
+            node = node.func
+        if isinstance(node, (FuncDef, OverloadedFuncDef, TypeInfo)) and (
+            node.deprecated is not None
+        ):
+            for imp in self.tree.imports:
+                if isinstance(imp, ImportFrom) and any(node.name == n[0] for n in imp.names):
+                    break
+            else:
+                self.warn_deprecated(node, context)
+
+    def warn_deprecated(self, node: Node | None, context: Context) -> None:
+        """Warn if deprecated."""
+        if isinstance(node, Decorator):
+            node = node.func
+        if (
+            isinstance(node, (FuncDef, OverloadedFuncDef, TypeInfo))
+            and ((deprecated := node.deprecated) is not None)
+            and not self.is_typeshed_stub
+            and not any(
+                node.fullname == p or node.fullname.startswith(f"{p}.")
+                for p in self.options.deprecated_calls_exclude
+            )
+        ):
+            warn = self.msg.note if self.options.report_deprecated_as_note else self.msg.fail
+            warn(deprecated, context, code=codes.DEPRECATED)
+
+    def warn_deprecated_overload_item(
+        self, node: Node | None, context: Context, *, target: Type, selftype: Type | None = None
+    ) -> None:
+        """Warn if the overload item corresponding to the given callable is deprecated."""
+        target = get_proper_type(target)
+        if isinstance(node, OverloadedFuncDef) and isinstance(target, CallableType):
+            for item in node.items:
+                if isinstance(item, Decorator) and isinstance(
+                    candidate := item.func.type, CallableType
+                ):
+                    if selftype is not None and not node.is_static:
+                        candidate = bind_self(candidate, selftype)
+                    if candidate == target:
+                        self.warn_deprecated(item.func, context)
+
+    # leafs
+
+    def visit_pass_stmt(self, o: PassStmt, /) -> None:
+        return None
+
+    def visit_nonlocal_decl(self, o: NonlocalDecl, /) -> None:
+        return None
+
+    def visit_global_decl(self, o: GlobalDecl, /) -> None:
+        return None
+
 
 class CollectArgTypeVarTypes(TypeTraverserVisitor):
     """Collects the non-nested argument types in a set."""
@@ -6807,15 +7902,13 @@ def visit_type_var(self, t: TypeVarType) -> None:
 @overload
 def conditional_types(
     current_type: Type, proposed_type_ranges: list[TypeRange] | None, default: None = None
-) -> tuple[Type | None, Type | None]:
-    ...
+) -> tuple[Type | None, Type | None]: ...
 
 
 @overload
 def conditional_types(
     current_type: Type, proposed_type_ranges: list[TypeRange] | None, default: Type
-) -> tuple[Type, Type]:
-    ...
+) -> tuple[Type, Type]: ...
 
 
 def conditional_types(
@@ -6849,9 +7942,7 @@ def conditional_types(
         ) and is_proper_subtype(current_type, proposed_type, ignore_promotions=True):
             # Expression is always of one of the types in proposed_type_ranges
             return default, UninhabitedType()
-        elif not is_overlapping_types(
-            current_type, proposed_type, prohibit_none_typevar_overlap=True, ignore_promotions=True
-        ):
+        elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
             # Expression is never of any type in proposed_type_ranges
             return UninhabitedType(), default
         else:
@@ -6885,7 +7976,7 @@ def conditional_types_to_typemaps(
             assert typ is not None
             maps.append({expr: typ})
 
-    return cast(Tuple[TypeMap, TypeMap], tuple(maps))
+    return cast(tuple[TypeMap, TypeMap], tuple(maps))
 
 
 def gen_unique_name(base: str, table: SymbolTable) -> str:
@@ -6917,6 +8008,22 @@ def is_literal_not_implemented(n: Expression) -> bool:
     return isinstance(n, NameExpr) and n.fullname == "builtins.NotImplemented"
 
 
+def _is_empty_generator_function(func: FuncItem) -> bool:
+    """
+    Checks whether a function's body is 'return; yield' (the yield being added only
+    to promote the function into a generator function).
+    """
+    body = func.body.body
+    return (
+        len(body) == 2
+        and isinstance(ret_stmt := body[0], ReturnStmt)
+        and (ret_stmt.expr is None or is_literal_none(ret_stmt.expr))
+        and isinstance(expr_stmt := body[1], ExpressionStmt)
+        and isinstance(yield_expr := expr_stmt.expr, YieldExpr)
+        and (yield_expr.expr is None or is_literal_none(yield_expr.expr))
+    )
+
+
 def builtin_item_type(tp: Type) -> Type | None:
     """Get the item type of a builtin container.
 
@@ -6948,10 +8055,22 @@ def builtin_item_type(tp: Type) -> Type | None:
                 return None
             if not isinstance(get_proper_type(tp.args[0]), AnyType):
                 return tp.args[0]
-    elif isinstance(tp, TupleType) and all(
-        not isinstance(it, AnyType) for it in get_proper_types(tp.items)
-    ):
-        return make_simplified_union(tp.items)  # this type is not externally visible
+    elif isinstance(tp, TupleType):
+        normalized_items = []
+        for it in tp.items:
+            # This use case is probably rare, but not handling unpacks here can cause crashes.
+            if isinstance(it, UnpackType):
+                unpacked = get_proper_type(it.type)
+                if isinstance(unpacked, TypeVarTupleType):
+                    unpacked = get_proper_type(unpacked.upper_bound)
+                assert (
+                    isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+                )
+                normalized_items.append(unpacked.args[0])
+            else:
+                normalized_items.append(it)
+        if all(not isinstance(it, AnyType) for it in get_proper_types(normalized_items)):
+            return make_simplified_union(normalized_items)  # this type is not externally visible
     elif isinstance(tp, TypedDictType):
         # TypedDict always has non-optional string keys. Find the key type from the Mapping
         # base class.
@@ -6962,7 +8081,7 @@ def builtin_item_type(tp: Type) -> Type | None:
     return None
 
 
-def and_conditional_maps(m1: TypeMap, m2: TypeMap) -> TypeMap:
+def and_conditional_maps(m1: TypeMap, m2: TypeMap, use_meet: bool = False) -> TypeMap:
     """Calculate what information we can learn from the truth of (e1 and e2)
     in terms of the information that we can learn from the truth of e1 and
     the truth of e2.
@@ -6972,22 +8091,31 @@ def and_conditional_maps(m1: TypeMap, m2: TypeMap) -> TypeMap:
         # One of the conditions can never be true.
         return None
     # Both conditions can be true; combine the information. Anything
-    # we learn from either conditions's truth is valid. If the same
+    # we learn from either conditions' truth is valid. If the same
     # expression's type is refined by both conditions, we somewhat
-    # arbitrarily give precedence to m2. (In the future, we could use
-    # an intersection type.)
+    # arbitrarily give precedence to m2 unless m1 value is Any.
+    # In the future, we could use an intersection type or meet_types().
     result = m2.copy()
     m2_keys = {literal_hash(n2) for n2 in m2}
     for n1 in m1:
-        if literal_hash(n1) not in m2_keys:
+        if literal_hash(n1) not in m2_keys or isinstance(get_proper_type(m1[n1]), AnyType):
             result[n1] = m1[n1]
+    if use_meet:
+        # For now, meet common keys only if specifically requested.
+        # This is currently used for tuple types narrowing, where having
+        # a precise result is important.
+        for n1 in m1:
+            for n2 in m2:
+                if literal_hash(n1) == literal_hash(n2):
+                    result[n1] = meet_types(m1[n1], m2[n2])
     return result
 
 
-def or_conditional_maps(m1: TypeMap, m2: TypeMap) -> TypeMap:
+def or_conditional_maps(m1: TypeMap, m2: TypeMap, coalesce_any: bool = False) -> TypeMap:
     """Calculate what information we can learn from the truth of (e1 or e2)
     in terms of the information that we can learn from the truth of e1 and
-    the truth of e2.
+    the truth of e2. If coalesce_any is True, consider Any a supertype when
+    joining restrictions.
     """
 
     if m1 is None:
@@ -7002,11 +8130,16 @@ def or_conditional_maps(m1: TypeMap, m2: TypeMap) -> TypeMap:
     for n1 in m1:
         for n2 in m2:
             if literal_hash(n1) == literal_hash(n2):
-                result[n1] = make_simplified_union([m1[n1], m2[n2]])
+                if coalesce_any and isinstance(get_proper_type(m1[n1]), AnyType):
+                    result[n1] = m1[n1]
+                else:
+                    result[n1] = make_simplified_union([m1[n1], m2[n2]])
     return result
 
 
-def reduce_conditional_maps(type_maps: list[tuple[TypeMap, TypeMap]]) -> tuple[TypeMap, TypeMap]:
+def reduce_conditional_maps(
+    type_maps: list[tuple[TypeMap, TypeMap]], use_meet: bool = False
+) -> tuple[TypeMap, TypeMap]:
     """Reduces a list containing pairs of if/else TypeMaps into a single pair.
 
     We "and" together all of the if TypeMaps and "or" together the else TypeMaps. So
@@ -7037,7 +8170,7 @@ def reduce_conditional_maps(type_maps: list[tuple[TypeMap, TypeMap]]) -> tuple[T
     else:
         final_if_map, final_else_map = type_maps[0]
         for if_map, else_map in type_maps[1:]:
-            final_if_map = and_conditional_maps(final_if_map, if_map)
+            final_if_map = and_conditional_maps(final_if_map, if_map, use_meet=use_meet)
             final_else_map = or_conditional_maps(final_else_map, else_map)
 
         return final_if_map, final_else_map
@@ -7052,7 +8185,7 @@ def convert_to_typetype(type_map: TypeMap) -> TypeMap:
         if isinstance(t, TypeVarType):
             t = t.upper_bound
         # TODO: should we only allow unions of instances as per PEP 484?
-        if not isinstance(get_proper_type(t), (UnionType, Instance)):
+        if not isinstance(get_proper_type(t), (UnionType, Instance, NoneType)):
             # unknown type; error was likely reported earlier
             return {}
         converted_type_map[expr] = TypeType.make_normalized(typ)
@@ -7074,6 +8207,8 @@ def flatten_types(t: Type) -> list[Type]:
     t = get_proper_type(t)
     if isinstance(t, TupleType):
         return [b for a in t.items for b in flatten_types(a)]
+    elif is_named_instance(t, "builtins.tuple"):
+        return [t.args[0]]
     else:
         return [t]
 
@@ -7101,104 +8236,125 @@ def are_argument_counts_overlapping(t: CallableType, s: CallableType) -> bool:
     return min_args <= max_args
 
 
+def expand_callable_variants(c: CallableType) -> list[CallableType]:
+    """Expand a generic callable using all combinations of type variables' values/bounds."""
+    for tv in c.variables:
+        # We need to expand self-type before other variables, because this is the only
+        # type variable that can have other type variables in the upper bound.
+        if tv.id.is_self():
+            c = expand_type(c, {tv.id: tv.upper_bound}).copy_modified(
+                variables=[v for v in c.variables if not v.id.is_self()]
+            )
+            break
+
+    if not c.is_generic():
+        # Fast path.
+        return [c]
+
+    tvar_values = []
+    for tvar in c.variables:
+        if isinstance(tvar, TypeVarType) and tvar.values:
+            tvar_values.append(tvar.values)
+        else:
+            tvar_values.append([tvar.upper_bound])
+
+    variants = []
+    for combination in itertools.product(*tvar_values):
+        tvar_map = {tv.id: subst for (tv, subst) in zip(c.variables, combination)}
+        variants.append(expand_type(c, tvar_map).copy_modified(variables=[]))
+    return variants
+
+
 def is_unsafe_overlapping_overload_signatures(
-    signature: CallableType, other: CallableType
+    signature: CallableType,
+    other: CallableType,
+    class_type_vars: list[TypeVarLikeType],
+    partial_only: bool = True,
 ) -> bool:
     """Check if two overloaded signatures are unsafely overlapping or partially overlapping.
 
-    We consider two functions 's' and 't' to be unsafely overlapping if both
-    of the following are true:
+    We consider two functions 's' and 't' to be unsafely overlapping if three
+    conditions hold:
+
+    1.  s's parameters are partially overlapping with t's. i.e. there are calls that are
+        valid for both signatures.
+    2.  for these common calls, some of t's parameters types are wider that s's.
+    3.  s's return type is NOT a subset of t's.
 
-    1.  s's parameters are all more precise or partially overlapping with t's
-    2.  s's return type is NOT a subtype of t's.
+    Note that we use subset rather than subtype relationship in these checks because:
+    * Overload selection happens at runtime, not statically.
+    * This results in more lenient behavior.
+    This can cause false negatives (e.g. if overloaded function returns an externally
+    visible attribute with invariant type), but such situations are rare. In general,
+    overloads in Python are generally unsafe, so we intentionally try to avoid giving
+    non-actionable errors (see more details in comments below).
 
     Assumes that 'signature' appears earlier in the list of overload
     alternatives then 'other' and that their argument counts are overlapping.
     """
     # Try detaching callables from the containing class so that all TypeVars
-    # are treated as being free.
-    #
-    # This lets us identify cases where the two signatures use completely
-    # incompatible types -- e.g. see the testOverloadingInferUnionReturnWithMixedTypevars
-    # test case.
-    signature = detach_callable(signature)
-    other = detach_callable(other)
-
-    # Note: We repeat this check twice in both directions due to a slight
-    # asymmetry in 'is_callable_compatible'. When checking for partial overlaps,
-    # we attempt to unify 'signature' and 'other' both against each other.
-    #
-    # If 'signature' cannot be unified with 'other', we end early. However,
-    # if 'other' cannot be modified with 'signature', the function continues
-    # using the older version of 'other'.
-    #
-    # This discrepancy is unfortunately difficult to get rid of, so we repeat the
-    # checks twice in both directions for now.
-    return is_callable_compatible(
-        signature,
-        other,
-        is_compat=is_overlapping_types_no_promote_no_uninhabited,
-        is_compat_return=lambda l, r: not is_subtype_no_promote(l, r),
-        ignore_return=False,
-        check_args_covariantly=True,
-        allow_partial_overlap=True,
-    ) or is_callable_compatible(
-        other,
-        signature,
-        is_compat=is_overlapping_types_no_promote_no_uninhabited,
-        is_compat_return=lambda l, r: not is_subtype_no_promote(r, l),
-        ignore_return=False,
-        check_args_covariantly=False,
-        allow_partial_overlap=True,
-    )
+    # are treated as being free, i.e. the signature is as seen from inside the class,
+    # where "self" is not yet bound to anything.
+    signature = detach_callable(signature, class_type_vars)
+    other = detach_callable(other, class_type_vars)
+
+    # Note: We repeat this check twice in both directions compensate for slight
+    # asymmetries in 'is_callable_compatible'.
+
+    for sig_variant in expand_callable_variants(signature):
+        for other_variant in expand_callable_variants(other):
+            # Using only expanded callables may cause false negatives, we can add
+            # more variants (e.g. using inference between callables) in the future.
+            if is_subset_no_promote(sig_variant.ret_type, other_variant.ret_type):
+                continue
+            if not (
+                is_callable_compatible(
+                    sig_variant,
+                    other_variant,
+                    is_compat=is_overlapping_types_for_overload,
+                    check_args_covariantly=False,
+                    is_proper_subtype=False,
+                    is_compat_return=lambda l, r: not is_subset_no_promote(l, r),
+                    allow_partial_overlap=True,
+                )
+                or is_callable_compatible(
+                    other_variant,
+                    sig_variant,
+                    is_compat=is_overlapping_types_for_overload,
+                    check_args_covariantly=True,
+                    is_proper_subtype=False,
+                    is_compat_return=lambda l, r: not is_subset_no_promote(r, l),
+                    allow_partial_overlap=True,
+                )
+            ):
+                continue
+            # Using the same `allow_partial_overlap` flag as before, can cause false
+            # negatives in case where star argument is used in a catch-all fallback overload.
+            # But again, practicality beats purity here.
+            if not partial_only or not is_callable_compatible(
+                other_variant,
+                sig_variant,
+                is_compat=is_subset_no_promote,
+                check_args_covariantly=True,
+                is_proper_subtype=False,
+                ignore_return=True,
+                allow_partial_overlap=True,
+            ):
+                return True
+    return False
 
 
-def detach_callable(typ: CallableType) -> CallableType:
+def detach_callable(typ: CallableType, class_type_vars: list[TypeVarLikeType]) -> CallableType:
     """Ensures that the callable's type variables are 'detached' and independent of the context.
 
     A callable normally keeps track of the type variables it uses within its 'variables' field.
     However, if the callable is from a method and that method is using a class type variable,
     the callable will not keep track of that type variable since it belongs to the class.
-
-    This function will traverse the callable and find all used type vars and add them to the
-    variables field if it isn't already present.
-
-    The caller can then unify on all type variables whether or not the callable is originally
-    from a class or not."""
-    type_list = typ.arg_types + [typ.ret_type]
-
-    appear_map: dict[str, list[int]] = {}
-    for i, inner_type in enumerate(type_list):
-        typevars_available = get_type_vars(inner_type)
-        for var in typevars_available:
-            if var.fullname not in appear_map:
-                appear_map[var.fullname] = []
-            appear_map[var.fullname].append(i)
-
-    used_type_var_names = set()
-    for var_name, appearances in appear_map.items():
-        used_type_var_names.add(var_name)
-
-    all_type_vars = get_type_vars(typ)
-    new_variables = []
-    for var in set(all_type_vars):
-        if var.fullname not in used_type_var_names:
-            continue
-        new_variables.append(
-            TypeVarType(
-                name=var.name,
-                fullname=var.fullname,
-                id=var.id,
-                values=var.values,
-                upper_bound=var.upper_bound,
-                default=var.default,
-                variance=var.variance,
-            )
-        )
-    out = typ.copy_modified(
-        variables=new_variables, arg_types=type_list[:-1], ret_type=type_list[-1]
-    )
-    return out
+    """
+    if not class_type_vars:
+        # Fast path, nothing to update.
+        return typ
+    return typ.copy_modified(variables=list(typ.variables) + class_type_vars)
 
 
 def overload_can_never_match(signature: CallableType, other: CallableType) -> bool:
@@ -7220,7 +8376,7 @@ def overload_can_never_match(signature: CallableType, other: CallableType) -> bo
         signature, {tvar.id: erase_def_to_union_or_bound(tvar) for tvar in signature.variables}
     )
     return is_callable_compatible(
-        exp_signature, other, is_compat=is_more_precise, ignore_return=True
+        exp_signature, other, is_compat=is_more_precise, is_proper_subtype=True, ignore_return=True
     )
 
 
@@ -7230,7 +8386,9 @@ def is_more_general_arg_prefix(t: FunctionLike, s: FunctionLike) -> bool:
     #      general than one with fewer items (or just one item)?
     if isinstance(t, CallableType):
         if isinstance(s, CallableType):
-            return is_callable_compatible(t, s, is_compat=is_proper_subtype, ignore_return=True)
+            return is_callable_compatible(
+                t, s, is_compat=is_proper_subtype, is_proper_subtype=True, ignore_return=True
+            )
     elif isinstance(t, FunctionLike):
         if isinstance(s, FunctionLike):
             if len(t.items) == len(s.items):
@@ -7245,6 +8403,7 @@ def is_same_arg_prefix(t: CallableType, s: CallableType) -> bool:
         t,
         s,
         is_compat=is_same_type,
+        is_proper_subtype=True,
         ignore_return=True,
         check_args_covariantly=True,
         ignore_pos_arg_names=True,
@@ -7259,15 +8418,28 @@ def infer_operator_assignment_method(typ: Type, operator: str) -> tuple[bool, st
     """
     typ = get_proper_type(typ)
     method = operators.op_methods[operator]
+    existing_method = None
     if isinstance(typ, Instance):
-        if operator in operators.ops_with_inplace_method:
-            inplace_method = "__i" + method[2:]
-            if typ.type.has_readable_member(inplace_method):
-                return True, inplace_method
+        existing_method = _find_inplace_method(typ, method, operator)
+    elif isinstance(typ, TypedDictType):
+        existing_method = _find_inplace_method(typ.fallback, method, operator)
+
+    if existing_method is not None:
+        return True, existing_method
     return False, method
 
 
-def is_valid_inferred_type(typ: Type, is_lvalue_final: bool = False) -> bool:
+def _find_inplace_method(inst: Instance, method: str, operator: str) -> str | None:
+    if operator in operators.ops_with_inplace_method:
+        inplace_method = "__i" + method[2:]
+        if inst.type.has_readable_member(inplace_method):
+            return inplace_method
+    return None
+
+
+def is_valid_inferred_type(
+    typ: Type, options: Options, is_lvalue_final: bool = False, is_lvalue_member: bool = False
+) -> bool:
     """Is an inferred type valid and needs no further refinement?
 
     Examples of invalid types include the None type (when we are not assigning
@@ -7286,7 +8458,7 @@ def is_valid_inferred_type(typ: Type, is_lvalue_final: bool = False) -> bool:
         # type could either be NoneType or an Optional type, depending on
         # the context. This resolution happens in leave_partial_types when
         # we pop a partial types scope.
-        return is_lvalue_final
+        return is_lvalue_final or (not is_lvalue_member and options.allow_redefinition_new)
     elif isinstance(proper_type, UninhabitedType):
         return False
     return not typ.accept(InvalidInferredTypes())
@@ -7295,7 +8467,7 @@ def is_valid_inferred_type(typ: Type, is_lvalue_final: bool = False) -> bool:
 class InvalidInferredTypes(BoolTypeQuery):
     """Find type components that are not valid for an inferred type.
 
-    These include <Erased> type, and any <nothing> types resulting from failed
+    These include <Erased> type, and any uninhabited types resulting from failed
     (ambiguous) type inference.
     """
 
@@ -7309,9 +8481,18 @@ def visit_erased_type(self, t: ErasedType) -> bool:
         # This can happen inside a lambda.
         return True
 
+    def visit_type_var(self, t: TypeVarType) -> bool:
+        # This is needed to prevent leaking into partial types during
+        # multi-step type inference.
+        return t.id.is_meta_var()
+
+    def visit_tuple_type(self, t: TupleType, /) -> bool:
+        # Exclude fallback to avoid bogus "need type annotation" errors
+        return self.query_types(t.items)
+
 
 class SetNothingToAny(TypeTranslator):
-    """Replace all ambiguous <nothing> types with Any (to avoid spurious extra errors)."""
+    """Replace all ambiguous Uninhabited types with Any (to avoid spurious extra errors)."""
 
     def visit_uninhabited_type(self, t: UninhabitedType) -> Type:
         if t.ambiguous:
@@ -7319,7 +8500,7 @@ def visit_uninhabited_type(self, t: UninhabitedType) -> Type:
         return t
 
     def visit_type_alias_type(self, t: TypeAliasType) -> Type:
-        # Target of the alias cannot be an ambiguous <nothing>, so we just
+        # Target of the alias cannot be an ambiguous UninhabitedType, so we just
         # replace the arguments.
         return t.copy_modified(args=[a.accept(self) for a in t.args])
 
@@ -7336,67 +8517,6 @@ def is_node_static(node: Node | None) -> bool | None:
     return None
 
 
-class CheckerScope:
-    # We keep two stacks combined, to maintain the relative order
-    stack: list[TypeInfo | FuncItem | MypyFile]
-
-    def __init__(self, module: MypyFile) -> None:
-        self.stack = [module]
-
-    def top_function(self) -> FuncItem | None:
-        for e in reversed(self.stack):
-            if isinstance(e, FuncItem):
-                return e
-        return None
-
-    def top_non_lambda_function(self) -> FuncItem | None:
-        for e in reversed(self.stack):
-            if isinstance(e, FuncItem) and not isinstance(e, LambdaExpr):
-                return e
-        return None
-
-    def active_class(self) -> TypeInfo | None:
-        if isinstance(self.stack[-1], TypeInfo):
-            return self.stack[-1]
-        return None
-
-    def enclosing_class(self) -> TypeInfo | None:
-        """Is there a class *directly* enclosing this function?"""
-        top = self.top_function()
-        assert top, "This method must be called from inside a function"
-        index = self.stack.index(top)
-        assert index, "CheckerScope stack must always start with a module"
-        enclosing = self.stack[index - 1]
-        if isinstance(enclosing, TypeInfo):
-            return enclosing
-        return None
-
-    def active_self_type(self) -> Instance | TupleType | None:
-        """An instance or tuple type representing the current class.
-
-        This returns None unless we are in class body or in a method.
-        In particular, inside a function nested in method this returns None.
-        """
-        info = self.active_class()
-        if not info and self.top_function():
-            info = self.enclosing_class()
-        if info:
-            return fill_typevars(info)
-        return None
-
-    @contextmanager
-    def push_function(self, item: FuncItem) -> Iterator[None]:
-        self.stack.append(item)
-        yield
-        self.stack.pop()
-
-    @contextmanager
-    def push_class(self, info: TypeInfo) -> Iterator[None]:
-        self.stack.append(info)
-        yield
-        self.stack.pop()
-
-
 TKey = TypeVar("TKey")
 TValue = TypeVar("TValue")
 
@@ -7509,7 +8629,7 @@ def group_comparison_operands(
 
         x0 == x1 == x2 < x3 < x4 is x5 is x6 is not x7 is not x8
 
-    If we get these expressions in a pairwise way (e.g. by calling ComparisionExpr's
+    If we get these expressions in a pairwise way (e.g. by calling ComparisonExpr's
     'pairwise()' method), we get the following as input:
 
         [('==', x0, x1), ('==', x1, x2), ('<', x2, x3), ('<', x3, x4),
@@ -7648,6 +8768,37 @@ def is_property(defn: SymbolNode) -> bool:
     return False
 
 
+def is_settable_property(defn: SymbolNode | None) -> TypeGuard[OverloadedFuncDef]:
+    if isinstance(defn, OverloadedFuncDef):
+        if defn.items and isinstance(defn.items[0], Decorator):
+            return defn.items[0].func.is_property
+    return False
+
+
+def is_custom_settable_property(defn: SymbolNode | None) -> bool:
+    """Check if a node is a settable property with a non-trivial setter type.
+
+    By non-trivial here we mean that it is known (i.e. definition was already type
+    checked), it is not Any, and it is different from the property getter type.
+    """
+    if defn is None:
+        return False
+    if not is_settable_property(defn):
+        return False
+    first_item = defn.items[0]
+    assert isinstance(first_item, Decorator)
+    if not first_item.var.is_settable_property:
+        return False
+    var = first_item.var
+    if var.type is None or var.setter_type is None or isinstance(var.type, PartialType):
+        # The caller should defer in case of partial types or not ready variables.
+        return False
+    setter_type = var.setter_type.arg_types[1]
+    if isinstance(get_proper_type(setter_type), AnyType):
+        return False
+    return not is_same_type(get_property_type(get_proper_type(var.type)), setter_type)
+
+
 def get_property_type(t: ProperType) -> ProperType:
     if isinstance(t, CallableType):
         return get_proper_type(t.ret_type)
@@ -7656,16 +8807,25 @@ def get_property_type(t: ProperType) -> ProperType:
     return t
 
 
-def is_subtype_no_promote(left: Type, right: Type) -> bool:
-    return is_subtype(left, right, ignore_promotions=True)
-
-
-def is_overlapping_types_no_promote_no_uninhabited(left: Type, right: Type) -> bool:
-    # For the purpose of unsafe overload checks we consider list[<nothing>] and list[int]
-    # non-overlapping. This is consistent with how we treat list[int] and list[str] as
-    # non-overlapping, despite [] belongs to both. Also this will prevent false positives
-    # for failed type inference during unification.
-    return is_overlapping_types(left, right, ignore_promotions=True, ignore_uninhabited=True)
+def is_subset_no_promote(left: Type, right: Type) -> bool:
+    return is_subtype(left, right, ignore_promotions=True, always_covariant=True)
+
+
+def is_overlapping_types_for_overload(left: Type, right: Type) -> bool:
+    # Note that among other effects 'overlap_for_overloads' flag will effectively
+    # ignore possible overlap between type variables and None. This is technically
+    # unsafe, but unsafety is tiny and this prevents some common use cases like:
+    #     @overload
+    #     def foo(x: None) -> None: ..
+    #     @overload
+    #     def foo(x: T) -> Foo[T]: ...
+    return is_overlapping_types(
+        left,
+        right,
+        ignore_promotions=True,
+        prohibit_none_typevar_overlap=True,
+        overlap_for_overloads=True,
+    )
 
 
 def is_private(node_name: str) -> bool:
@@ -7773,3 +8933,62 @@ def visit_starred_pattern(self, p: StarredPattern) -> None:
             self.lvalue = True
             p.capture.accept(self)
             self.lvalue = False
+
+
+def is_ambiguous_mix_of_enums(types: list[Type]) -> bool:
+    """Do types have IntEnum/StrEnum types that are potentially overlapping with other types?
+
+    If True, we shouldn't attempt type narrowing based on enum values, as it gets
+    too ambiguous.
+
+    For example, return True if there's an 'int' type together with an IntEnum literal.
+    However, IntEnum together with a literal of the same IntEnum type is not ambiguous.
+    """
+    # We need these things for this to be ambiguous:
+    #  (1) an IntEnum or StrEnum type
+    #  (2) either a different IntEnum/StrEnum type or a non-enum type ("<other>")
+    #
+    # It would be slightly more correct to calculate this separately for IntEnum and
+    # StrEnum related types, as an IntEnum can't be confused with a StrEnum.
+    return len(_ambiguous_enum_variants(types)) > 1
+
+
+def _ambiguous_enum_variants(types: list[Type]) -> set[str]:
+    result = set()
+    for t in types:
+        t = get_proper_type(t)
+        if isinstance(t, UnionType):
+            result.update(_ambiguous_enum_variants(t.items))
+        elif isinstance(t, Instance):
+            if t.last_known_value:
+                result.update(_ambiguous_enum_variants([t.last_known_value]))
+            elif t.type.is_enum and any(
+                base.fullname in ("enum.IntEnum", "enum.StrEnum") for base in t.type.mro
+            ):
+                result.add(t.type.fullname)
+            elif not t.type.is_enum:
+                # These might compare equal to IntEnum/StrEnum types (e.g. Decimal), so
+                # let's be conservative
+                result.add("<other>")
+        elif isinstance(t, LiteralType):
+            result.update(_ambiguous_enum_variants([t.fallback]))
+        elif isinstance(t, NoneType):
+            pass
+        else:
+            result.add("<other>")
+    return result
+
+
+def is_typeddict_type_context(lvalue_type: Type | None) -> bool:
+    if lvalue_type is None:
+        return False
+    lvalue_proper = get_proper_type(lvalue_type)
+    return isinstance(lvalue_proper, TypedDictType)
+
+
+def is_method(node: SymbolNode | None) -> bool:
+    if isinstance(node, OverloadedFuncDef):
+        return not node.is_property
+    if isinstance(node, Decorator):
+        return not node.var.is_property
+    return isinstance(node, FuncDef)
diff --git a/mypy/checker_shared.py b/mypy/checker_shared.py
new file mode 100644
index 000000000000..6c62af50466c
--- /dev/null
+++ b/mypy/checker_shared.py
@@ -0,0 +1,349 @@
+"""Shared definitions used by different parts of type checker."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Iterator, Sequence
+from contextlib import contextmanager
+from typing import NamedTuple, overload
+
+from mypy_extensions import trait
+
+from mypy.errorcodes import ErrorCode
+from mypy.errors import ErrorWatcher
+from mypy.message_registry import ErrorMessage
+from mypy.nodes import (
+    ArgKind,
+    Context,
+    Expression,
+    FuncItem,
+    LambdaExpr,
+    MypyFile,
+    Node,
+    RefExpr,
+    TypeAlias,
+    TypeInfo,
+    Var,
+)
+from mypy.plugin import CheckerPluginInterface, Plugin
+from mypy.types import (
+    CallableType,
+    Instance,
+    LiteralValue,
+    Overloaded,
+    PartialType,
+    TupleType,
+    Type,
+    TypedDictType,
+    TypeType,
+)
+from mypy.typevars import fill_typevars
+
+
+# An object that represents either a precise type or a type with an upper bound;
+# it is important for correct type inference with isinstance.
+class TypeRange(NamedTuple):
+    item: Type
+    is_upper_bound: bool  # False => precise type
+
+
+@trait
+class ExpressionCheckerSharedApi:
+    @abstractmethod
+    def accept(
+        self,
+        node: Expression,
+        type_context: Type | None = None,
+        allow_none_return: bool = False,
+        always_allow_any: bool = False,
+        is_callee: bool = False,
+    ) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def module_type(self, node: MypyFile) -> Instance:
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_call(
+        self,
+        callee: Type,
+        args: list[Expression],
+        arg_kinds: list[ArgKind],
+        context: Context,
+        arg_names: Sequence[str | None] | None = None,
+        callable_node: Expression | None = None,
+        callable_name: str | None = None,
+        object_type: Type | None = None,
+        original_type: Type | None = None,
+    ) -> tuple[Type, Type]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def transform_callee_type(
+        self,
+        callable_name: str | None,
+        callee: Type,
+        args: list[Expression],
+        arg_kinds: list[ArgKind],
+        context: Context,
+        arg_names: Sequence[str | None] | None = None,
+        object_type: Type | None = None,
+    ) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def method_fullname(self, object_type: Type, method_name: str) -> str | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_method_call_by_name(
+        self,
+        method: str,
+        base_type: Type,
+        args: list[Expression],
+        arg_kinds: list[ArgKind],
+        context: Context,
+        original_type: Type | None = None,
+    ) -> tuple[Type, Type]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def alias_type_in_runtime_context(
+        self, alias: TypeAlias, *, ctx: Context, alias_definition: bool = False
+    ) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_typeddict_index_expr(
+        self, td_type: TypedDictType, index: Expression, setitem: bool = False
+    ) -> tuple[Type, set[str]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def typeddict_callable(self, info: TypeInfo) -> CallableType:
+        raise NotImplementedError
+
+    @abstractmethod
+    def infer_literal_expr_type(self, value: LiteralValue, fallback_name: str) -> Type:
+        raise NotImplementedError
+
+
+@trait
+class TypeCheckerSharedApi(CheckerPluginInterface):
+    plugin: Plugin
+    module_refs: set[str]
+    scope: CheckerScope
+    checking_missing_await: bool
+
+    @property
+    @abstractmethod
+    def expr_checker(self) -> ExpressionCheckerSharedApi:
+        raise NotImplementedError
+
+    @abstractmethod
+    def named_type(self, name: str) -> Instance:
+        raise NotImplementedError
+
+    @abstractmethod
+    def lookup_typeinfo(self, fullname: str) -> TypeInfo:
+        raise NotImplementedError
+
+    @abstractmethod
+    def lookup_type(self, node: Expression) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    def handle_cannot_determine_type(self, name: str, context: Context) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def handle_partial_var_type(
+        self, typ: PartialType, is_lvalue: bool, node: Var, context: Context
+    ) -> Type:
+        raise NotImplementedError
+
+    @overload
+    @abstractmethod
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: str,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        notes: list[str] | None = None,
+        code: ErrorCode | None = None,
+        outer_context: Context | None = None,
+    ) -> bool: ...
+
+    @overload
+    @abstractmethod
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: ErrorMessage,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        notes: list[str] | None = None,
+        outer_context: Context | None = None,
+    ) -> bool: ...
+
+    # Unfortunately, mypyc doesn't support abstract overloads yet.
+    @abstractmethod
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: str | ErrorMessage,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        notes: list[str] | None = None,
+        code: ErrorCode | None = None,
+        outer_context: Context | None = None,
+    ) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_final_context(self) -> bool:
+        raise NotImplementedError
+
+    @overload
+    @abstractmethod
+    def conditional_types_with_intersection(
+        self,
+        expr_type: Type,
+        type_ranges: list[TypeRange] | None,
+        ctx: Context,
+        default: None = None,
+    ) -> tuple[Type | None, Type | None]: ...
+
+    @overload
+    @abstractmethod
+    def conditional_types_with_intersection(
+        self, expr_type: Type, type_ranges: list[TypeRange] | None, ctx: Context, default: Type
+    ) -> tuple[Type, Type]: ...
+
+    # Unfortunately, mypyc doesn't support abstract overloads yet.
+    @abstractmethod
+    def conditional_types_with_intersection(
+        self,
+        expr_type: Type,
+        type_ranges: list[TypeRange] | None,
+        ctx: Context,
+        default: Type | None = None,
+    ) -> tuple[Type | None, Type | None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_deprecated(self, node: Node | None, context: Context) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def warn_deprecated(self, node: Node | None, context: Context) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def warn_deprecated_overload_item(
+        self, node: Node | None, context: Context, *, target: Type, selftype: Type | None = None
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def type_is_iterable(self, type: Type) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def iterable_item_type(
+        self, it: Instance | CallableType | TypeType | Overloaded, context: Context
+    ) -> Type:
+        raise NotImplementedError
+
+    @abstractmethod
+    @contextmanager
+    def checking_await_set(self) -> Iterator[None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_precise_awaitable_type(self, typ: Type, local_errors: ErrorWatcher) -> Type | None:
+        raise NotImplementedError
+
+
+class CheckerScope:
+    # We keep two stacks combined, to maintain the relative order
+    stack: list[TypeInfo | FuncItem | MypyFile]
+
+    def __init__(self, module: MypyFile) -> None:
+        self.stack = [module]
+
+    def current_function(self) -> FuncItem | None:
+        for e in reversed(self.stack):
+            if isinstance(e, FuncItem):
+                return e
+        return None
+
+    def top_level_function(self) -> FuncItem | None:
+        """Return top-level non-lambda function."""
+        for e in self.stack:
+            if isinstance(e, FuncItem) and not isinstance(e, LambdaExpr):
+                return e
+        return None
+
+    def active_class(self) -> TypeInfo | None:
+        if isinstance(self.stack[-1], TypeInfo):
+            return self.stack[-1]
+        return None
+
+    def enclosing_class(self, func: FuncItem | None = None) -> TypeInfo | None:
+        """Is there a class *directly* enclosing this function?"""
+        func = func or self.current_function()
+        assert func, "This method must be called from inside a function"
+        index = self.stack.index(func)
+        assert index, "CheckerScope stack must always start with a module"
+        enclosing = self.stack[index - 1]
+        if isinstance(enclosing, TypeInfo):
+            return enclosing
+        return None
+
+    def active_self_type(self) -> Instance | TupleType | None:
+        """An instance or tuple type representing the current class.
+
+        This returns None unless we are in class body or in a method.
+        In particular, inside a function nested in method this returns None.
+        """
+        info = self.active_class()
+        if not info and self.current_function():
+            info = self.enclosing_class()
+        if info:
+            return fill_typevars(info)
+        return None
+
+    def current_self_type(self) -> Instance | TupleType | None:
+        """Same as active_self_type() but handle functions nested in methods."""
+        for item in reversed(self.stack):
+            if isinstance(item, TypeInfo):
+                return fill_typevars(item)
+        return None
+
+    @contextmanager
+    def push_function(self, item: FuncItem) -> Iterator[None]:
+        self.stack.append(item)
+        yield
+        self.stack.pop()
+
+    @contextmanager
+    def push_class(self, info: TypeInfo) -> Iterator[None]:
+        self.stack.append(info)
+        yield
+        self.stack.pop()
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
index cd0ff1100183..f375c14c5fc4 100644
--- a/mypy/checkexpr.py
+++ b/mypy/checkexpr.py
@@ -2,34 +2,45 @@
 
 from __future__ import annotations
 
+import enum
 import itertools
 import time
+from collections import defaultdict
+from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
-from typing import Callable, ClassVar, Iterator, List, Optional, Sequence, cast
-from typing_extensions import Final, TypeAlias as _TypeAlias, overload
+from typing import Callable, ClassVar, Final, Optional, cast, overload
+from typing_extensions import TypeAlias as _TypeAlias, assert_never
 
 import mypy.checker
 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.checker_shared import ExpressionCheckerSharedApi
+from mypy.checkmember import analyze_member_access
 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
-from mypy.expandtype import expand_type, expand_type_by_instance, freshen_function_type_vars
+from mypy.expandtype import (
+    expand_type,
+    expand_type_by_instance,
+    freshen_all_functions_type_vars,
+    freshen_function_type_vars,
+)
 from mypy.infer import ArgumentInferContext, infer_function_type_arguments, infer_type_arguments
 from mypy.literals import literal
 from mypy.maptype import map_instance_to_supertype
 from mypy.meet import is_overlapping_types, narrow_declared_type
 from mypy.message_registry import ErrorMessage
-from mypy.messages import MessageBuilder
+from mypy.messages import MessageBuilder, format_type
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
     ARG_STAR,
     ARG_STAR2,
     IMPLICITLY_ABSTRACT,
+    LAMBDA_NAME,
     LITERAL_TYPE,
+    REVEAL_LOCALS,
     REVEAL_TYPE,
     ArgKind,
     AssertTypeExpr,
@@ -89,6 +100,7 @@
     YieldExpr,
     YieldFromExpr,
 )
+from mypy.options import PRECISE_TUPLE_TYPES
 from mypy.plugin import (
     FunctionContext,
     FunctionSigContext,
@@ -98,22 +110,34 @@
 )
 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.typeanal import (
     check_for_explicit_any,
+    fix_instance,
     has_any_from_unimported_type,
     instantiate_type_alias,
     make_optional_type,
     set_any_tvars,
+    validate_instance,
 )
 from mypy.typeops import (
+    bind_self,
     callable_type,
     custom_special_method,
     erase_to_union_or_bound,
     false_only,
     fixup_partial_type,
+    freeze_all_type_vars,
     function_type,
+    get_all_type_vars,
+    get_type_vars,
     is_literal_type_like,
     make_simplified_union,
     simple_literal_type,
@@ -121,6 +145,7 @@
     try_expanding_sum_type_to_union,
     try_getting_str_literals,
     tuple_fallback,
+    type_object_type,
 )
 from mypy.types import (
     LITERAL_TYPE_NAMES,
@@ -136,6 +161,7 @@
     LiteralValue,
     NoneType,
     Overloaded,
+    Parameters,
     ParamSpecFlavor,
     ParamSpecType,
     PartialType,
@@ -146,23 +172,31 @@
     TypedDictType,
     TypeOfAny,
     TypeType,
+    TypeVarId,
     TypeVarTupleType,
     TypeVarType,
+    UnboundType,
     UninhabitedType,
     UnionType,
     UnpackType,
+    find_unpack_in_list,
     flatten_nested_tuples,
     flatten_nested_unions,
     get_proper_type,
     get_proper_types,
     has_recursive_types,
+    has_type_vars,
     is_named_instance,
     split_with_prefix_and_suffix,
 )
-from mypy.types_utils import is_generic_instance, is_optional, is_self_type_like, remove_optional
+from mypy.types_utils import (
+    is_generic_instance,
+    is_overlapping_none,
+    is_self_type_like,
+    remove_optional,
+)
 from mypy.typestate import type_state
 from mypy.typevars import fill_typevars
-from mypy.typevartuples import find_unpack_in_list
 from mypy.util import split_module_names
 from mypy.visitor import ExpressionVisitor
 
@@ -249,7 +283,21 @@ class Finished(Exception):
     """Raised if we can terminate overload argument check early (no match)."""
 
 
-class ExpressionChecker(ExpressionVisitor[Type]):
+@enum.unique
+class UseReverse(enum.Enum):
+    """Used in `visit_op_expr` to enable or disable reverse method checks."""
+
+    DEFAULT = 0
+    ALWAYS = 1
+    NEVER = 2
+
+
+USE_REVERSE_DEFAULT: Final = UseReverse.DEFAULT
+USE_REVERSE_ALWAYS: Final = UseReverse.ALWAYS
+USE_REVERSE_NEVER: Final = UseReverse.NEVER
+
+
+class ExpressionChecker(ExpressionVisitor[Type], ExpressionCheckerSharedApi):
     """Expression type checker.
 
     This class works closely together with checker.TypeChecker.
@@ -291,7 +339,7 @@ def __init__(
         # TODO: refactor this to use a pattern similar to one in
         # multiassign_from_union, or maybe even combine the two?
         self.type_overrides: dict[Expression, Type] = {}
-        self.strfrm_checker = StringFormatterChecker(self, self.chk, self.msg)
+        self.strfrm_checker = StringFormatterChecker(self.chk, self.msg)
 
         self.resolved_type = {}
 
@@ -300,6 +348,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 = not self.chk.options.old_type_inference
 
     def reset(self) -> None:
         self.resolved_type = {}
@@ -311,7 +360,9 @@ def visit_name_expr(self, e: NameExpr) -> Type:
         """
         self.chk.module_refs.update(extract_refexpr_names(e))
         result = self.analyze_ref_expr(e)
-        return self.narrow_type_from_binder(e, result)
+        narrowed = self.narrow_type_from_binder(e, result)
+        self.chk.check_deprecated(e.node, e)
+        return narrowed
 
     def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
         result: Type | None = None
@@ -329,17 +380,21 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
         elif isinstance(node, FuncDef):
             # Reference to a global function.
             result = function_type(node, self.named_type("builtins.function"))
-        elif isinstance(node, OverloadedFuncDef) and node.type is not None:
-            # node.type is None when there are multiple definitions of a function
-            # and it's decorated by something that is not typing.overload
-            # TODO: use a dummy Overloaded instead of AnyType in this case
-            # like we do in mypy.types.function_type()?
-            result = node.type
+        elif isinstance(node, OverloadedFuncDef):
+            if node.type is None:
+                if self.chk.in_checked_function() and node.items:
+                    self.chk.handle_cannot_determine_type(node.name, e)
+                result = AnyType(TypeOfAny.from_error)
+            else:
+                result = node.type
         elif isinstance(node, TypeInfo):
             # Reference to a type object.
             if node.typeddict_type:
                 # We special-case TypedDict, because they don't define any constructor.
                 result = self.typeddict_callable(node)
+            elif node.fullname == "types.NoneType":
+                # We special case NoneType, because its stub definition is not related to None.
+                result = TypeType(NoneType())
             else:
                 result = type_object_type(node, self.named_type)
             if isinstance(result, CallableType) and isinstance(  # type: ignore[misc]
@@ -349,8 +404,8 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
                 # TODO: always do this in type_object_type by passing the original context
                 result.ret_type.line = e.line
                 result.ret_type.column = e.column
-            if isinstance(get_proper_type(self.type_context[-1]), TypeType):
-                # This is the type in a Type[] expression, so substitute type
+            if is_type_type_context(self.type_context[-1]):
+                # This is the type in a type[] expression, so substitute type
                 # variables with Any.
                 result = erasetype.erase_typevars(result)
         elif isinstance(node, MypyFile):
@@ -365,7 +420,9 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
             result = self.alias_type_in_runtime_context(
                 node, ctx=e, alias_definition=e.is_alias_rvalue or lvalue
             )
-        elif isinstance(node, (TypeVarExpr, ParamSpecExpr)):
+        elif isinstance(node, TypeVarExpr):
+            return self.named_type("typing.TypeVar")
+        elif isinstance(node, (ParamSpecExpr, TypeVarTupleExpr)):
             result = self.object_type()
         else:
             if isinstance(node, PlaceholderNode):
@@ -380,6 +437,9 @@ def analyze_var_ref(self, var: Var, context: Context) -> Type:
         if var.type:
             var_type = get_proper_type(var.type)
             if isinstance(var_type, Instance):
+                if var.fullname == "typing.Any":
+                    # The typeshed type is 'object'; give a more useful type in runtime context
+                    return self.named_type("typing._SpecialForm")
                 if self.is_literal_context() and var_type.last_known_value is not None:
                     return var_type.last_known_value
                 if var.name in {"True", "False"}:
@@ -466,13 +526,13 @@ def visit_call_expr_inner(self, e: CallExpr, allow_none_return: bool = False) ->
                 if is_expr_literal_type(typ):
                     self.msg.cannot_use_function_with_type(e.callee.name, "Literal", e)
                     continue
-                if (
-                    node
-                    and isinstance(node.node, TypeAlias)
-                    and isinstance(get_proper_type(node.node.target), AnyType)
-                ):
-                    self.msg.cannot_use_function_with_type(e.callee.name, "Any", e)
-                    continue
+                if node and isinstance(node.node, TypeAlias):
+                    target = get_proper_type(node.node.target)
+                    if isinstance(target, AnyType):
+                        self.msg.cannot_use_function_with_type(e.callee.name, "Any", e)
+                        continue
+                    if isinstance(target, NoneType):
+                        continue
                 if (
                     isinstance(typ, IndexExpr)
                     and isinstance(typ.analyzed, (TypeApplication, TypeAliasExpr))
@@ -481,6 +541,10 @@ def visit_call_expr_inner(self, e: CallExpr, allow_none_return: bool = False) ->
                     and node
                     and isinstance(node.node, TypeAlias)
                     and not node.node.no_args
+                    and not (
+                        isinstance(union_target := get_proper_type(node.node.target), UnionType)
+                        and union_target.uses_pep604_syntax
+                    )
                 ):
                     self.msg.type_arguments_not_allowed(e)
                 if isinstance(typ, RefExpr) and isinstance(typ.node, TypeInfo):
@@ -513,13 +577,6 @@ def visit_call_expr_inner(self, e: CallExpr, allow_none_return: bool = False) ->
         callee_type = get_proper_type(
             self.accept(e.callee, type_context, always_allow_any=True, is_callee=True)
         )
-        if (
-            self.chk.options.disallow_untyped_calls
-            and self.chk.in_checked_function()
-            and isinstance(callee_type, CallableType)
-            and callee_type.implicit
-        ):
-            self.msg.untyped_function_call(callee_type, e)
 
         # Figure out the full name of the callee for plugin lookup.
         object_type = None
@@ -545,6 +602,23 @@ def visit_call_expr_inner(self, e: CallExpr, allow_none_return: bool = False) ->
             ):
                 member = e.callee.name
                 object_type = self.chk.lookup_type(e.callee.expr)
+
+        if (
+            self.chk.options.disallow_untyped_calls
+            and self.chk.in_checked_function()
+            and isinstance(callee_type, CallableType)
+            and callee_type.implicit
+            and callee_type.name != LAMBDA_NAME
+        ):
+            if fullname is None and member is not None:
+                assert object_type is not None
+                fullname = self.method_fullname(object_type, member)
+            if not fullname or not any(
+                fullname == p or fullname.startswith(f"{p}.")
+                for p in self.chk.options.untyped_calls_exclude
+            ):
+                self.msg.untyped_function_call(callee_type, e)
+
         ret_type = self.check_call_expr_with_callee_type(
             callee_type, e, fullname, object_type, member
         )
@@ -579,7 +653,17 @@ def check_str_format_call(self, e: CallExpr) -> None:
         if isinstance(e.callee.expr, StrExpr):
             format_value = e.callee.expr.value
         elif self.chk.has_type(e.callee.expr):
-            base_typ = try_getting_literal(self.chk.lookup_type(e.callee.expr))
+            typ = get_proper_type(self.chk.lookup_type(e.callee.expr))
+            if (
+                isinstance(typ, Instance)
+                and typ.type.is_enum
+                and isinstance(typ.last_known_value, LiteralType)
+                and isinstance(typ.last_known_value.value, str)
+            ):
+                value_type = typ.type.names[typ.last_known_value.value].type
+                if isinstance(value_type, Type):
+                    typ = get_proper_type(value_type)
+            base_typ = try_getting_literal(typ)
             if isinstance(base_typ, LiteralType) and isinstance(base_typ.value, str):
                 format_value = base_typ.value
         if format_value is not None:
@@ -661,7 +745,7 @@ def check_runtime_protocol_test(self, e: CallExpr) -> None:
         for expr in mypy.checker.flatten(e.args[1]):
             tp = get_proper_type(self.chk.lookup_type(expr))
             if (
-                isinstance(tp, CallableType)
+                isinstance(tp, FunctionLike)
                 and tp.is_type_obj()
                 and tp.type_object().is_protocol
                 and not tp.type_object().runtime_protocol
@@ -671,7 +755,7 @@ def check_runtime_protocol_test(self, e: CallExpr) -> None:
     def check_protocol_issubclass(self, e: CallExpr) -> None:
         for expr in mypy.checker.flatten(e.args[1]):
             tp = get_proper_type(self.chk.lookup_type(expr))
-            if isinstance(tp, CallableType) and tp.is_type_obj() and tp.type_object().is_protocol:
+            if isinstance(tp, FunctionLike) and tp.is_type_obj() and tp.type_object().is_protocol:
                 attr_members = non_method_protocol_members(tp.type_object())
                 if attr_members:
                     self.chk.msg.report_non_method_protocol(tp.type_object(), attr_members, e)
@@ -685,74 +769,182 @@ 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:
+                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 overridden 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.
+        """
+        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:
-                item_names.append(literal_value)
-        return dict(zip(item_names, item_args))
+                # 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)
@@ -784,7 +976,10 @@ def typeddict_callable(self, info: TypeInfo) -> CallableType:
     def typeddict_callable_from_context(self, callee: TypedDictType) -> CallableType:
         return CallableType(
             list(callee.items.values()),
-            [ArgKind.ARG_NAMED] * len(callee.items),
+            [
+                ArgKind.ARG_NAMED if name in callee.required_keys else ArgKind.ARG_NAMED_OPT
+                for name in callee.items
+            ],
             list(callee.items.keys()),
             callee,
             self.named_type("builtins.type"),
@@ -793,20 +988,41 @@ 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 callee.to_be_mutated:
+            assigned_readonly_keys = actual_keys & callee.readonly_keys
+            if assigned_readonly_keys:
+                self.msg.readonly_keys_mutated(assigned_readonly_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
@@ -829,7 +1045,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()),
@@ -846,17 +1065,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
 
@@ -908,8 +1128,7 @@ def try_infer_partial_type(self, e: CallExpr) -> None:
             typ = self.try_infer_partial_value_type_from_call(e, callee.name, var)
             # Var may be deleted from partial_types in try_infer_partial_value_type_from_call
             if typ is not None and var in partial_types:
-                var.type = typ
-                del partial_types[var]
+                self.chk.replace_partial_type(var, typ, partial_types)
         elif isinstance(callee.expr, IndexExpr) and isinstance(callee.expr.base, RefExpr):
             # Call 'x[y].method(...)'; may infer type of 'x' if it's a partial defaultdict.
             if callee.expr.analyzed is not None:
@@ -927,12 +1146,12 @@ def try_infer_partial_type(self, e: CallExpr) -> None:
             if value_type is not None:
                 # Infer key type.
                 key_type = self.accept(index)
-                if mypy.checker.is_valid_inferred_type(key_type):
+                if mypy.checker.is_valid_inferred_type(key_type, self.chk.options):
                     # Store inferred partial type.
                     assert partial_type.type is not None
                     typename = partial_type.type.fullname
-                    var.type = self.chk.named_generic_type(typename, [key_type, value_type])
-                    del partial_types[var]
+                    new_type = self.chk.named_generic_type(typename, [key_type, value_type])
+                    self.chk.replace_partial_type(var, new_type, partial_types)
 
     def get_partial_var(self, ref: RefExpr) -> tuple[Var, dict[Var, Context]] | None:
         var = ref.node
@@ -967,7 +1186,7 @@ def try_infer_partial_value_type_from_call(
             and e.arg_kinds == [ARG_POS]
         ):
             item_type = self.accept(e.args[0])
-            if mypy.checker.is_valid_inferred_type(item_type):
+            if mypy.checker.is_valid_inferred_type(item_type, self.chk.options):
                 return self.chk.named_generic_type(typename, [item_type])
         elif (
             typename in self.container_args
@@ -979,7 +1198,7 @@ def try_infer_partial_value_type_from_call(
                 arg_typename = arg_type.type.fullname
                 if arg_typename in self.container_args[typename][methodname]:
                     if all(
-                        mypy.checker.is_valid_inferred_type(item_type)
+                        mypy.checker.is_valid_inferred_type(item_type, self.chk.options)
                         for item_type in arg_type.args
                     ):
                         return self.chk.named_generic_type(typename, list(arg_type.args))
@@ -1022,6 +1241,8 @@ def apply_function_plugin(
                 formal_arg_exprs[formal].append(args[actual])
                 if arg_names:
                     formal_arg_names[formal].append(arg_names[actual])
+                else:
+                    formal_arg_names[formal].append(None)
                 formal_arg_kinds[formal].append(arg_kinds[actual])
 
         if object_type is None:
@@ -1030,14 +1251,14 @@ def apply_function_plugin(
             assert callback is not None  # Assume that caller ensures this
             return callback(
                 FunctionContext(
-                    formal_arg_types,
-                    formal_arg_kinds,
-                    callee.arg_names,
-                    formal_arg_names,
-                    callee.ret_type,
-                    formal_arg_exprs,
-                    context,
-                    self.chk,
+                    arg_types=formal_arg_types,
+                    arg_kinds=formal_arg_kinds,
+                    callee_arg_names=callee.arg_names,
+                    arg_names=formal_arg_names,
+                    default_return_type=callee.ret_type,
+                    args=formal_arg_exprs,
+                    context=context,
+                    api=self.chk,
                 )
             )
         else:
@@ -1047,15 +1268,15 @@ def apply_function_plugin(
             object_type = get_proper_type(object_type)
             return method_callback(
                 MethodContext(
-                    object_type,
-                    formal_arg_types,
-                    formal_arg_kinds,
-                    callee.arg_names,
-                    formal_arg_names,
-                    callee.ret_type,
-                    formal_arg_exprs,
-                    context,
-                    self.chk,
+                    type=object_type,
+                    arg_types=formal_arg_types,
+                    arg_kinds=formal_arg_kinds,
+                    callee_arg_names=callee.arg_names,
+                    arg_names=formal_arg_names,
+                    default_return_type=callee.ret_type,
+                    args=formal_arg_exprs,
+                    context=context,
+                    api=self.chk,
                 )
             )
 
@@ -1174,6 +1395,55 @@ def transform_callee_type(
 
         return callee
 
+    def is_generic_decorator_overload_call(
+        self, callee_type: CallableType, args: list[Expression]
+    ) -> Overloaded | None:
+        """Check if this looks like an application of a generic function to overload argument."""
+        assert callee_type.variables
+        if len(callee_type.arg_types) != 1 or len(args) != 1:
+            # TODO: can we handle more general cases?
+            return None
+        if not isinstance(get_proper_type(callee_type.arg_types[0]), CallableType):
+            return None
+        if not isinstance(get_proper_type(callee_type.ret_type), CallableType):
+            return None
+        with self.chk.local_type_map():
+            with self.msg.filter_errors():
+                arg_type = get_proper_type(self.accept(args[0], type_context=None))
+        if isinstance(arg_type, Overloaded):
+            return arg_type
+        return None
+
+    def handle_decorator_overload_call(
+        self, callee_type: CallableType, overloaded: Overloaded, ctx: Context
+    ) -> tuple[Type, Type] | None:
+        """Type-check application of a generic callable to an overload.
+
+        We check call on each individual overload item, and then combine results into a new
+        overload. This function should be only used if callee_type takes and returns a Callable.
+        """
+        result = []
+        inferred_args = []
+        for item in overloaded.items:
+            arg = TempNode(typ=item)
+            with self.msg.filter_errors() as err:
+                item_result, inferred_arg = self.check_call(callee_type, [arg], [ARG_POS], ctx)
+            if err.has_new_errors():
+                # This overload doesn't match.
+                continue
+            p_item_result = get_proper_type(item_result)
+            if not isinstance(p_item_result, CallableType):
+                continue
+            p_inferred_arg = get_proper_type(inferred_arg)
+            if not isinstance(p_inferred_arg, CallableType):
+                continue
+            inferred_args.append(p_inferred_arg)
+            result.append(p_item_result)
+        if not result or not inferred_args:
+            # None of the overload matched (or overload was initially malformed).
+            return None
+        return Overloaded(result), Overloaded(inferred_args)
+
     def check_call_expr_with_callee_type(
         self,
         callee_type: Type,
@@ -1216,13 +1486,21 @@ def check_call_expr_with_callee_type(
             object_type=object_type,
         )
         proper_callee = get_proper_type(callee_type)
-        if (
-            isinstance(e.callee, RefExpr)
-            and isinstance(proper_callee, CallableType)
-            and proper_callee.type_guard is not None
-        ):
+        if isinstance(e.callee, (NameExpr, MemberExpr)):
+            node = e.callee.node
+            if node is None and member is not None and isinstance(object_type, Instance):
+                if (symbol := object_type.type.get(member)) is not None:
+                    node = symbol.node
+            self.chk.check_deprecated(node, e)
+            self.chk.warn_deprecated_overload_item(
+                node, e, target=callee_type, selftype=object_type
+            )
+        if isinstance(e.callee, RefExpr) and isinstance(proper_callee, CallableType):
             # Cache it for find_isinstance_check()
-            e.callee.type_guard = proper_callee.type_guard
+            if proper_callee.type_guard is not None:
+                e.callee.type_guard = proper_callee.type_guard
+            if proper_callee.type_is is not None:
+                e.callee.type_is = proper_callee.type_is
         return ret_type
 
     def check_union_call_expr(self, e: CallExpr, object_type: UnionType, member: str) -> Type:
@@ -1235,10 +1513,9 @@ def check_union_call_expr(self, e: CallExpr, object_type: UnionType, member: str
                     member,
                     typ,
                     e,
-                    False,
-                    False,
-                    False,
-                    self.msg,
+                    is_lvalue=False,
+                    is_super=False,
+                    is_operator=False,
                     original_type=object_type,
                     chk=self.chk,
                     in_literal_context=self.is_literal_context(),
@@ -1264,6 +1541,7 @@ def check_call(
         callable_node: Expression | None = None,
         callable_name: str | None = None,
         object_type: Type | None = None,
+        original_type: Type | None = None,
     ) -> tuple[Type, Type]:
         """Type check a call.
 
@@ -1288,6 +1566,17 @@ def check_call(
         callee = get_proper_type(callee)
 
         if isinstance(callee, CallableType):
+            if callee.variables:
+                overloaded = self.is_generic_decorator_overload_call(callee, args)
+                if overloaded is not None:
+                    # Special casing for inline application of generic callables to overloads.
+                    # Supporting general case would be tricky, but this should cover 95% of cases.
+                    overloaded_result = self.handle_decorator_overload_call(
+                        callee, overloaded, context
+                    )
+                    if overloaded_result is not None:
+                        return overloaded_result
+
             return self.check_callable_call(
                 callee,
                 args,
@@ -1314,8 +1603,7 @@ def check_call(
                 is_lvalue=False,
                 is_super=False,
                 is_operator=True,
-                msg=self.msg,
-                original_type=callee,
+                original_type=original_type or callee,
                 chk=self.chk,
                 in_literal_context=self.is_literal_context(),
             )
@@ -1356,6 +1644,7 @@ def check_call(
                 callable_node,
                 callable_name,
                 object_type,
+                original_type=callee,
             )
         else:
             return self.msg.not_callable(callee, context), AnyType(TypeOfAny.from_error)
@@ -1376,7 +1665,7 @@ def check_callable_call(
         See the docstring of check_call for more information.
         """
         # Always unpack **kwargs before checking a call.
-        callee = callee.with_unpacked_kwargs()
+        callee = callee.with_unpacked_kwargs().with_normalized_var_args()
         if callable_name is None and callee.name:
             callable_name = callee.name
         ret_type = get_proper_type(callee.ret_type)
@@ -1416,6 +1705,27 @@ def check_callable_call(
                 callee.type_object().name, abstract_attributes, context
             )
 
+        var_arg = callee.var_arg()
+        if var_arg and isinstance(var_arg.typ, UnpackType):
+            # It is hard to support multiple variadic unpacks (except for old-style *args: int),
+            # fail gracefully to avoid crashes later.
+            seen_unpack = False
+            for arg, arg_kind in zip(args, arg_kinds):
+                if arg_kind != ARG_STAR:
+                    continue
+                arg_type = get_proper_type(self.accept(arg))
+                if not isinstance(arg_type, TupleType) or any(
+                    isinstance(t, UnpackType) for t in arg_type.items
+                ):
+                    if seen_unpack:
+                        self.msg.fail(
+                            "Passing multiple variadic unpacks in a call is not supported",
+                            context,
+                            code=codes.CALL_ARG,
+                        )
+                        return AnyType(TypeOfAny.from_error), callee
+                    seen_unpack = True
+
         formal_to_actual = map_actuals_to_formals(
             arg_kinds,
             arg_names,
@@ -1424,6 +1734,16 @@ def check_callable_call(
             lambda i: self.accept(args[i]),
         )
 
+        # This is tricky: return type may contain its own type variables, like in
+        # def [S] (S) -> def [T] (T) -> tuple[S, T], so we need to update their ids
+        # to avoid possible id clashes if this call itself appears in a generic
+        # function body.
+        ret_type = get_proper_type(callee.ret_type)
+        if isinstance(ret_type, CallableType) and ret_type.variables:
+            fresh_ret_type = freshen_all_functions_type_vars(callee.ret_type)
+            freeze_all_type_vars(fresh_ret_type)
+            callee = callee.copy_modified(ret_type=fresh_ret_type)
+
         if callee.is_generic():
             need_refresh = any(
                 isinstance(v, (ParamSpecType, TypeVarTupleType)) for v in callee.variables
@@ -1442,7 +1762,7 @@ def check_callable_call(
                     lambda i: self.accept(args[i]),
                 )
             callee = self.infer_function_type_arguments(
-                callee, args, arg_kinds, formal_to_actual, context
+                callee, args, arg_kinds, arg_names, formal_to_actual, need_refresh, context
             )
             if need_refresh:
                 formal_to_actual = map_actuals_to_formals(
@@ -1454,7 +1774,11 @@ def check_callable_call(
                 )
 
         param_spec = callee.param_spec()
-        if param_spec is not None and arg_kinds == [ARG_STAR, ARG_STAR2]:
+        if (
+            param_spec is not None
+            and arg_kinds == [ARG_STAR, ARG_STAR2]
+            and len(formal_to_actual) == 2
+        ):
             arg1 = self.accept(args[0])
             arg2 = self.accept(args[1])
             if (
@@ -1576,6 +1900,8 @@ def analyze_type_type_callee(self, item: ProperType, context: Context) -> Type:
         # We support Type of namedtuples but not of tuples in general
         if isinstance(item, TupleType) and tuple_fallback(item).type.fullname != "builtins.tuple":
             return self.analyze_type_type_callee(tuple_fallback(item), context)
+        if isinstance(item, TypedDictType):
+            return self.typeddict_callable_from_context(item)
 
         self.msg.unsupported_type_type(item, context)
         return AnyType(TypeOfAny.from_error)
@@ -1647,7 +1973,7 @@ def infer_arg_types_in_context(
             if not t:
                 res[i] = self.accept(args[i])
         assert all(tp is not None for tp in res)
-        return cast(List[Type], res)
+        return cast(list[Type], res)
 
     def infer_function_type_arguments_using_context(
         self, callable: CallableType, error_context: Context
@@ -1668,7 +1994,7 @@ def infer_function_type_arguments_using_context(
         # valid results.
         erased_ctx = replace_meta_vars(ctx, ErasedType())
         ret_type = callable.ret_type
-        if is_optional(ret_type) and is_optional(ctx):
+        if is_overlapping_none(ret_type) and is_overlapping_none(ctx):
             # If both the context and the return type are optional, unwrap the optional,
             # since in 99% cases this is what a user expects. In other words, we replace
             #     Optional[T] <: Optional[int]
@@ -1709,9 +2035,13 @@ def infer_function_type_arguments_using_context(
             #        def identity(x: T) -> T: return x
             #
             #        expects_literal(identity(3))  # Should type-check
+            # TODO: we may want to add similar exception if all arguments are lambdas, since
+            # in this case external context is almost everything we have.
             if not is_generic_instance(ctx) and not is_literal_type_like(ctx):
                 return callable.copy_modified()
-        args = infer_type_arguments(callable.type_var_ids(), ret_type, erased_ctx)
+        args = infer_type_arguments(
+            callable.variables, ret_type, erased_ctx, skip_unsatisfied=True
+        )
         # Only substitute non-Uninhabited and non-erased types.
         new_args: list[Type | None] = []
         for arg in args:
@@ -1730,7 +2060,9 @@ def infer_function_type_arguments(
         callee_type: CallableType,
         args: list[Expression],
         arg_kinds: list[ArgKind],
+        arg_names: Sequence[str | None] | None,
         formal_to_actual: list[list[int]],
+        need_refresh: bool,
         context: Context,
     ) -> CallableType:
         """Infer the type arguments for a generic callee type.
@@ -1750,7 +2082,7 @@ def infer_function_type_arguments(
                 )
 
             arg_pass_nums = self.get_arg_infer_passes(
-                callee_type.arg_types, formal_to_actual, len(args)
+                callee_type, args, arg_types, formal_to_actual, len(args)
             )
 
             pass1_args: list[Type | None] = []
@@ -1760,10 +2092,11 @@ def infer_function_type_arguments(
                 else:
                     pass1_args.append(arg)
 
-            inferred_args = infer_function_type_arguments(
+            inferred_args, _ = infer_function_type_arguments(
                 callee_type,
                 pass1_args,
                 arg_kinds,
+                arg_names,
                 formal_to_actual,
                 context=self.argument_infer_context(),
                 strict=self.chk.in_checked_function(),
@@ -1772,7 +2105,14 @@ def infer_function_type_arguments(
             if 2 in arg_pass_nums:
                 # Second pass of type inference.
                 (callee_type, inferred_args) = self.infer_function_type_arguments_pass2(
-                    callee_type, args, arg_kinds, formal_to_actual, inferred_args, context
+                    callee_type,
+                    args,
+                    arg_kinds,
+                    arg_names,
+                    formal_to_actual,
+                    inferred_args,
+                    need_refresh,
+                    context,
                 )
 
             if (
@@ -1791,6 +2131,63 @@ 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 not self.chk.options.old_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 need_refresh:
+                    # Technically we need to refresh formal_to_actual after *each* inference pass,
+                    # since each pass can expand ParamSpec or TypeVarTuple. Although such situations
+                    # are very rare, not doing this can cause crashes.
+                    formal_to_actual = map_actuals_to_formals(
+                        arg_kinds,
+                        arg_names,
+                        callee_type.arg_kinds,
+                        callee_type.arg_names,
+                        lambda a: self.accept(args[a]),
+                    )
+                # 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, free_vars = infer_function_type_arguments(
+                    callee_type,
+                    arg_types,
+                    arg_kinds,
+                    arg_names,
+                    formal_to_actual,
+                    context=self.argument_infer_context(),
+                    strict=self.chk.in_checked_function(),
+                    allow_polymorphic=True,
+                )
+                poly_callee_type = self.apply_generic_arguments(
+                    callee_type, poly_inferred_args, context
+                )
+                # 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 = applytype.apply_poly(poly_callee_type, free_vars)
+                if applied is not None and all(
+                    a is not None and not isinstance(get_proper_type(a), UninhabitedType)
+                    for a in poly_inferred_args
+                ):
+                    freeze_all_type_vars(applied)
+                    return applied
+                # If it didn't work, erase free variables as uninhabited, to avoid confusing errors.
+                unknown = UninhabitedType()
+                unknown.ambiguous = True
+                inferred_args = [
+                    (
+                        expand_type(
+                            a, {v.id: unknown for v in list(callee_type.variables) + free_vars}
+                        )
+                        if a is not None
+                        else None
+                    )
+                    for a in poly_inferred_args
+                ]
         else:
             # In dynamically typed functions use implicit 'Any' types for
             # type variables.
@@ -1802,8 +2199,10 @@ def infer_function_type_arguments_pass2(
         callee_type: CallableType,
         args: list[Expression],
         arg_kinds: list[ArgKind],
+        arg_names: Sequence[str | None] | None,
         formal_to_actual: list[list[int]],
         old_inferred_args: Sequence[Type | None],
+        need_refresh: bool,
         context: Context,
     ) -> tuple[CallableType, list[Type | None]]:
         """Perform second pass of generic function type argument inference.
@@ -1825,13 +2224,26 @@ def infer_function_type_arguments_pass2(
             if isinstance(arg, (NoneType, UninhabitedType)) or has_erased_component(arg):
                 inferred_args[i] = None
         callee_type = self.apply_generic_arguments(callee_type, inferred_args, context)
+        if need_refresh:
+            formal_to_actual = map_actuals_to_formals(
+                arg_kinds,
+                arg_names,
+                callee_type.arg_kinds,
+                callee_type.arg_names,
+                lambda a: self.accept(args[a]),
+            )
 
-        arg_types = self.infer_arg_types_in_context(callee_type, args, arg_kinds, formal_to_actual)
+        # Same as during first pass, disable type errors (we still have partial context).
+        with self.msg.filter_errors():
+            arg_types = self.infer_arg_types_in_context(
+                callee_type, args, arg_kinds, formal_to_actual
+            )
 
-        inferred_args = infer_function_type_arguments(
+        inferred_args, _ = infer_function_type_arguments(
             callee_type,
             arg_types,
             arg_kinds,
+            arg_names,
             formal_to_actual,
             context=self.argument_infer_context(),
         )
@@ -1844,7 +2256,12 @@ def argument_infer_context(self) -> ArgumentInferContext:
         )
 
     def get_arg_infer_passes(
-        self, arg_types: list[Type], formal_to_actual: list[list[int]], num_actuals: int
+        self,
+        callee: CallableType,
+        args: list[Expression],
+        arg_types: list[Type],
+        formal_to_actual: list[list[int]],
+        num_actuals: int,
     ) -> list[int]:
         """Return pass numbers for args for two-pass argument type inference.
 
@@ -1855,8 +2272,32 @@ def get_arg_infer_passes(
         lambdas more effectively.
         """
         res = [1] * num_actuals
-        for i, arg in enumerate(arg_types):
-            if arg.accept(ArgInferSecondPassQuery()):
+        for i, arg in enumerate(callee.arg_types):
+            skip_param_spec = False
+            p_formal = get_proper_type(callee.arg_types[i])
+            if isinstance(p_formal, CallableType) and p_formal.param_spec():
+                for j in formal_to_actual[i]:
+                    p_actual = get_proper_type(arg_types[j])
+                    # This is an exception from the usual logic where we put generic Callable
+                    # arguments in the second pass. If we have a non-generic actual, it is
+                    # likely to infer good constraints, for example if we have:
+                    #   def run(Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+                    #   def test(x: int, y: int) -> int: ...
+                    #   run(test, 1, 2)
+                    # we will use `test` for inference, since it will allow to infer also
+                    # argument *names* for P <: [x: int, y: int].
+                    if isinstance(p_actual, Instance):
+                        call_method = find_member("__call__", p_actual, p_actual, is_operator=True)
+                        if call_method is not None:
+                            p_actual = get_proper_type(call_method)
+                    if (
+                        isinstance(p_actual, CallableType)
+                        and not p_actual.variables
+                        and not isinstance(args[j], LambdaExpr)
+                    ):
+                        skip_param_spec = True
+                        break
+            if not skip_param_spec and arg.accept(ArgInferSecondPassQuery()):
                 for j in formal_to_actual[i]:
                     res[j] = 2
         return res
@@ -1917,7 +2358,8 @@ def check_argument_count(
 
         # Check for too many or few values for formals.
         for i, kind in enumerate(callee.arg_kinds):
-            if kind.is_required() and not formal_to_actual[i] and not is_unexpected_arg_error:
+            mapped_args = formal_to_actual[i]
+            if kind.is_required() and not mapped_args and not is_unexpected_arg_error:
                 # No actual for a mandatory formal
                 if kind.is_positional():
                     self.msg.too_few_arguments(callee, context, actual_names)
@@ -1928,21 +2370,36 @@ def check_argument_count(
                     self.msg.missing_named_argument(callee, context, argname)
                 ok = False
             elif not kind.is_star() and is_duplicate_mapping(
-                formal_to_actual[i], actual_types, actual_kinds
+                mapped_args, actual_types, actual_kinds
             ):
                 if self.chk.in_checked_function() or isinstance(
-                    get_proper_type(actual_types[formal_to_actual[i][0]]), TupleType
+                    get_proper_type(actual_types[mapped_args[0]]), TupleType
                 ):
                     self.msg.duplicate_argument_value(callee, i, context)
                     ok = False
             elif (
                 kind.is_named()
-                and formal_to_actual[i]
-                and actual_kinds[formal_to_actual[i][0]] not in [nodes.ARG_NAMED, nodes.ARG_STAR2]
+                and mapped_args
+                and actual_kinds[mapped_args[0]] not in [nodes.ARG_NAMED, nodes.ARG_STAR2]
             ):
                 # Positional argument when expecting a keyword argument.
                 self.msg.too_many_positional_arguments(callee, context)
                 ok = False
+            elif callee.param_spec() is not None:
+                if not mapped_args and callee.special_sig != "partial":
+                    self.msg.too_few_arguments(callee, context, actual_names)
+                    ok = False
+                elif len(mapped_args) > 1:
+                    paramspec_entries = sum(
+                        isinstance(get_proper_type(actual_types[k]), ParamSpecType)
+                        for k in mapped_args
+                    )
+                    if actual_kinds[mapped_args[0]] == nodes.ARG_STAR and paramspec_entries > 1:
+                        self.msg.fail("ParamSpec.args should only be passed once", context)
+                        ok = False
+                    if actual_kinds[mapped_args[0]] == nodes.ARG_STAR2 and paramspec_entries > 1:
+                        self.msg.fail("ParamSpec.kwargs should only be passed once", context)
+                        ok = False
         return ok
 
     def check_for_extra_actual_arguments(
@@ -2040,6 +2497,17 @@ def check_argument_types(
         check_arg = check_arg or self.check_arg
         # Keep track of consumed tuple *arg items.
         mapper = ArgTypeExpander(self.argument_infer_context())
+
+        for arg_type, arg_kind in zip(arg_types, arg_kinds):
+            arg_type = get_proper_type(arg_type)
+            if arg_kind == nodes.ARG_STAR and not self.is_valid_var_arg(arg_type):
+                self.msg.invalid_var_arg(arg_type, context)
+            if arg_kind == nodes.ARG_STAR2 and not self.is_valid_keyword_var_arg(arg_type):
+                is_mapping = is_subtype(
+                    arg_type, self.chk.named_type("_typeshed.SupportsKeysAndGetItem")
+                )
+                self.msg.invalid_keyword_var_arg(arg_type, is_mapping, context)
+
         for i, actuals in enumerate(formal_to_actual):
             orig_callee_arg_type = get_proper_type(callee.arg_types[i])
 
@@ -2051,30 +2519,28 @@ def check_argument_types(
             # the suffices to the tuple, e.g. a single actual like
             # Tuple[Unpack[Ts], int]
             expanded_tuple = False
+            actual_kinds = [arg_kinds[a] for a in actuals]
             if len(actuals) > 1:
-                first_actual_arg_type = get_proper_type(arg_types[actuals[0]])
+                p_actual_type = get_proper_type(arg_types[actuals[0]])
                 if (
-                    isinstance(first_actual_arg_type, TupleType)
-                    and len(first_actual_arg_type.items) == 1
-                    and isinstance(first_actual_arg_type.items[0], UnpackType)
+                    isinstance(p_actual_type, TupleType)
+                    and len(p_actual_type.items) == 1
+                    and isinstance(p_actual_type.items[0], UnpackType)
+                    and actual_kinds == [nodes.ARG_STAR] + [nodes.ARG_POS] * (len(actuals) - 1)
                 ):
-                    # TODO: use walrus operator
-                    actual_types = [first_actual_arg_type.items[0]] + [
-                        arg_types[a] for a in actuals[1:]
-                    ]
-                    actual_kinds = [nodes.ARG_STAR] + [nodes.ARG_POS] * (len(actuals) - 1)
-
-                    assert isinstance(orig_callee_arg_type, TupleType)
-                    assert orig_callee_arg_type.items
-                    callee_arg_types = orig_callee_arg_type.items
-                    callee_arg_kinds = [nodes.ARG_STAR] + [nodes.ARG_POS] * (
-                        len(orig_callee_arg_type.items) - 1
-                    )
-                    expanded_tuple = True
+                    actual_types = [p_actual_type.items[0]] + [arg_types[a] for a in actuals[1:]]
+                    if isinstance(orig_callee_arg_type, UnpackType):
+                        p_callee_type = get_proper_type(orig_callee_arg_type.type)
+                        if isinstance(p_callee_type, TupleType):
+                            assert p_callee_type.items
+                            callee_arg_types = p_callee_type.items
+                            callee_arg_kinds = [nodes.ARG_STAR] + [nodes.ARG_POS] * (
+                                len(p_callee_type.items) - 1
+                            )
+                            expanded_tuple = True
 
             if not expanded_tuple:
                 actual_types = [arg_types[a] for a in actuals]
-                actual_kinds = [arg_kinds[a] for a in actuals]
                 if isinstance(orig_callee_arg_type, UnpackType):
                     unpacked_type = get_proper_type(orig_callee_arg_type.type)
                     if isinstance(unpacked_type, TupleType):
@@ -2086,16 +2552,28 @@ def check_argument_types(
                             inner_unpack = unpacked_type.items[inner_unpack_index]
                             assert isinstance(inner_unpack, UnpackType)
                             inner_unpacked_type = get_proper_type(inner_unpack.type)
-                            # We assume heterogenous tuples are desugared earlier
-                            assert isinstance(inner_unpacked_type, Instance)
-                            assert inner_unpacked_type.type.fullname == "builtins.tuple"
-                            callee_arg_types = (
-                                unpacked_type.items[:inner_unpack_index]
-                                + [inner_unpacked_type.args[0]]
-                                * (len(actuals) - len(unpacked_type.items) + 1)
-                                + unpacked_type.items[inner_unpack_index + 1 :]
-                            )
-                            callee_arg_kinds = [ARG_POS] * len(actuals)
+                            if isinstance(inner_unpacked_type, TypeVarTupleType):
+                                # This branch mimics the expanded_tuple case above but for
+                                # the case where caller passed a single * unpacked tuple argument.
+                                callee_arg_types = unpacked_type.items
+                                callee_arg_kinds = [
+                                    ARG_POS if i != inner_unpack_index else ARG_STAR
+                                    for i in range(len(unpacked_type.items))
+                                ]
+                            else:
+                                # We assume heterogeneous tuples are desugared earlier.
+                                assert isinstance(inner_unpacked_type, Instance)
+                                assert inner_unpacked_type.type.fullname == "builtins.tuple"
+                                callee_arg_types = (
+                                    unpacked_type.items[:inner_unpack_index]
+                                    + [inner_unpacked_type.args[0]]
+                                    * (len(actuals) - len(unpacked_type.items) + 1)
+                                    + unpacked_type.items[inner_unpack_index + 1 :]
+                                )
+                                callee_arg_kinds = [ARG_POS] * len(actuals)
+                    elif isinstance(unpacked_type, TypeVarTupleType):
+                        callee_arg_types = [orig_callee_arg_type]
+                        callee_arg_kinds = [ARG_STAR]
                     else:
                         assert isinstance(unpacked_type, Instance)
                         assert unpacked_type.type.fullname == "builtins.tuple"
@@ -2108,8 +2586,10 @@ def check_argument_types(
             assert len(actual_types) == len(actuals) == len(actual_kinds)
 
             if len(callee_arg_types) != len(actual_types):
-                # TODO: Improve error message
-                self.chk.fail("Invalid number of arguments", context)
+                if len(actual_types) > len(callee_arg_types):
+                    self.chk.msg.too_many_arguments(callee, context)
+                else:
+                    self.chk.msg.too_few_arguments(callee, context, None)
                 continue
 
             assert len(callee_arg_types) == len(actual_types)
@@ -2117,20 +2597,13 @@ def check_argument_types(
             for actual, actual_type, actual_kind, callee_arg_type, callee_arg_kind in zip(
                 actuals, actual_types, actual_kinds, callee_arg_types, callee_arg_kinds
             ):
-                if actual_type is None:
-                    continue  # Some kind of error was already reported.
                 # Check that a *arg is valid as varargs.
-                if actual_kind == nodes.ARG_STAR and not self.is_valid_var_arg(actual_type):
-                    self.msg.invalid_var_arg(actual_type, context)
-                if actual_kind == nodes.ARG_STAR2 and not self.is_valid_keyword_var_arg(
-                    actual_type
-                ):
-                    is_mapping = is_subtype(
-                        actual_type, self.chk.named_type("_typeshed.SupportsKeysAndGetItem")
-                    )
-                    self.msg.invalid_keyword_var_arg(actual_type, is_mapping, context)
                 expanded_actual = mapper.expand_actual_type(
-                    actual_type, actual_kind, callee.arg_names[i], callee_arg_kind
+                    actual_type,
+                    actual_kind,
+                    callee.arg_names[i],
+                    callee_arg_kind,
+                    allow_unpack=isinstance(callee_arg_type, UnpackType),
                 )
                 check_arg(
                     expanded_actual,
@@ -2166,15 +2639,7 @@ def check_arg(
         if isinstance(caller_type, DeletedType):
             self.msg.deleted_as_rvalue(caller_type, context)
         # Only non-abstract non-protocol class can be given where Type[...] is expected...
-        elif (
-            isinstance(caller_type, CallableType)
-            and isinstance(callee_type, TypeType)
-            and caller_type.is_type_obj()
-            and (caller_type.type_object().is_abstract or caller_type.type_object().is_protocol)
-            and isinstance(callee_type.item, Instance)
-            and (callee_type.item.type.is_abstract or callee_type.item.type.is_protocol)
-            and not self.chk.allow_abstract_call
-        ):
+        elif self.has_abstract_type_part(caller_type, callee_type):
             self.msg.concrete_only_call(callee_type, context)
         elif not is_subtype(caller_type, callee_type, options=self.chk.options):
             code = self.msg.incompatible_argument(
@@ -2191,7 +2656,7 @@ def check_arg(
                 original_caller_type, callee_type, context, code=code
             )
             if not self.msg.prefer_simple_messages():
-                self.chk.check_possible_missing_await(caller_type, callee_type, context)
+                self.chk.check_possible_missing_await(caller_type, callee_type, context, code)
 
     def check_overload_call(
         self,
@@ -2219,6 +2684,11 @@ def check_overload_call(
         #         typevar. See https://github.com/python/mypy/issues/4063 for related discussion.
         erased_targets: list[CallableType] | None = None
         unioned_result: tuple[Type, Type] | None = None
+
+        # Determine whether we need to encourage union math. This should be generally safe,
+        # as union math infers better results in the vast majority of cases, but it is very
+        # computationally intensive.
+        none_type_var_overlap = self.possible_none_type_var_overlap(arg_types, plausible_targets)
         union_interrupted = False  # did we try all union combinations?
         if any(self.real_union(arg) for arg in arg_types):
             try:
@@ -2231,6 +2701,7 @@ def check_overload_call(
                         arg_names,
                         callable_name,
                         object_type,
+                        none_type_var_overlap,
                         context,
                     )
             except TooManyUnions:
@@ -2263,8 +2734,10 @@ def check_overload_call(
         # If any of checks succeed, stop early.
         if inferred_result is not None and unioned_result is not None:
             # Both unioned and direct checks succeeded, choose the more precise type.
-            if is_subtype(inferred_result[0], unioned_result[0]) and not isinstance(
-                get_proper_type(inferred_result[0]), AnyType
+            if (
+                is_subtype(inferred_result[0], unioned_result[0])
+                and not isinstance(get_proper_type(inferred_result[0]), AnyType)
+                and not none_type_var_overlap
             ):
                 return inferred_result
             return unioned_result
@@ -2314,7 +2787,8 @@ def check_overload_call(
             callable_name=callable_name,
             object_type=object_type,
         )
-        if union_interrupted:
+        # Do not show the extra error if the union math was forced.
+        if union_interrupted and not none_type_var_overlap:
             self.chk.fail(message_registry.TOO_MANY_UNION_COMBINATIONS, context)
         return result
 
@@ -2327,9 +2801,9 @@ def plausible_overload_call_targets(
     ) -> list[CallableType]:
         """Returns all overload call targets that having matching argument counts.
 
-        If the given args contains a star-arg (*arg or **kwarg argument), this method
-        will ensure all star-arg overloads appear at the start of the list, instead
-        of their usual location.
+        If the given args contains a star-arg (*arg or **kwarg argument, except for
+        ParamSpec), this method will ensure all star-arg overloads appear at the start
+        of the list, instead of their usual location.
 
         The only exception is if the starred argument is something like a Tuple or a
         NamedTuple, which has a definitive "shape". If so, we don't move the corresponding
@@ -2357,9 +2831,15 @@ def has_shape(typ: Type) -> bool:
             formal_to_actual = map_actuals_to_formals(
                 arg_kinds, arg_names, typ.arg_kinds, typ.arg_names, lambda i: arg_types[i]
             )
-
             with self.msg.filter_errors():
-                if self.check_argument_count(
+                if typ.param_spec() is not None:
+                    # ParamSpec can be expanded in a lot of different ways. We may try
+                    # to expand it here instead, but picking an impossible overload
+                    # is safe: it will be filtered out later.
+                    # Unlike other var-args signatures, ParamSpec produces essentially
+                    # a fixed signature, so there's no need to push them to the top.
+                    matches.append(typ)
+                elif self.check_argument_count(
                     typ, arg_types, arg_kinds, arg_names, formal_to_actual, None
                 ):
                     if args_have_var_arg and typ.is_var_arg:
@@ -2413,11 +2893,18 @@ def infer_overload_return_type(
                     )
             is_match = not w.has_new_errors()
             if is_match:
-                # Return early if possible; otherwise record info so we can
+                # Return early if possible; otherwise record info, so we can
                 # check for ambiguity due to 'Any' below.
                 if not args_contain_any:
+                    self.chk.store_types(m)
                     return ret_type, infer_type
-                matches.append(typ)
+                p_infer_type = get_proper_type(infer_type)
+                if isinstance(p_infer_type, CallableType):
+                    # Prefer inferred types if possible, this will avoid false triggers for
+                    # Any-ambiguity caused by arguments with Any passed to generic overloads.
+                    matches.append(p_infer_type)
+                else:
+                    matches.append(typ)
                 return_types.append(ret_type)
                 inferred_types.append(infer_type)
                 type_maps.append(m)
@@ -2469,6 +2956,44 @@ def overload_erased_call_targets(
                 matches.append(typ)
         return matches
 
+    def possible_none_type_var_overlap(
+        self, arg_types: list[Type], plausible_targets: list[CallableType]
+    ) -> bool:
+        """Heuristic to determine whether we need to try forcing union math.
+
+        This is needed to avoid greedy type variable match in situations like this:
+            @overload
+            def foo(x: None) -> None: ...
+            @overload
+            def foo(x: T) -> list[T]: ...
+
+            x: int | None
+            foo(x)
+        we want this call to infer list[int] | None, not list[int | None].
+        """
+        if not plausible_targets or not arg_types:
+            return False
+        has_optional_arg = False
+        for arg_type in get_proper_types(arg_types):
+            if not isinstance(arg_type, UnionType):
+                continue
+            for item in get_proper_types(arg_type.items):
+                if isinstance(item, NoneType):
+                    has_optional_arg = True
+                    break
+        if not has_optional_arg:
+            return False
+
+        min_prefix = min(len(c.arg_types) for c in plausible_targets)
+        for i in range(min_prefix):
+            if any(
+                isinstance(get_proper_type(c.arg_types[i]), NoneType) for c in plausible_targets
+            ) and any(
+                isinstance(get_proper_type(c.arg_types[i]), TypeVarType) for c in plausible_targets
+            ):
+                return True
+        return False
+
     def union_overload_result(
         self,
         plausible_targets: list[CallableType],
@@ -2478,6 +3003,7 @@ def union_overload_result(
         arg_names: Sequence[str | None] | None,
         callable_name: str | None,
         object_type: Type | None,
+        none_type_var_overlap: bool,
         context: Context,
         level: int = 0,
     ) -> list[tuple[Type, Type]] | None:
@@ -2517,20 +3043,23 @@ def union_overload_result(
 
         # Step 3: Try a direct match before splitting to avoid unnecessary union splits
         # and save performance.
-        with self.type_overrides_set(args, arg_types):
-            direct = self.infer_overload_return_type(
-                plausible_targets,
-                args,
-                arg_types,
-                arg_kinds,
-                arg_names,
-                callable_name,
-                object_type,
-                context,
-            )
-        if direct is not None and not isinstance(get_proper_type(direct[0]), (UnionType, AnyType)):
-            # We only return non-unions soon, to avoid greedy match.
-            return [direct]
+        if not none_type_var_overlap:
+            with self.type_overrides_set(args, arg_types):
+                direct = self.infer_overload_return_type(
+                    plausible_targets,
+                    args,
+                    arg_types,
+                    arg_kinds,
+                    arg_names,
+                    callable_name,
+                    object_type,
+                    context,
+                )
+            if direct is not None and not isinstance(
+                get_proper_type(direct[0]), (UnionType, AnyType)
+            ):
+                # We only return non-unions soon, to avoid greedy match.
+                return [direct]
 
         # Step 4: Split the first remaining union type in arguments into items and
         # try to match each item individually (recursive).
@@ -2548,6 +3077,7 @@ def union_overload_result(
                 arg_names,
                 callable_name,
                 object_type,
+                none_type_var_overlap,
                 context,
                 level + 1,
             )
@@ -2766,10 +3296,17 @@ def visit_member_expr(self, e: MemberExpr, is_lvalue: bool = False) -> Type:
         """Visit member expression (of form e.id)."""
         self.chk.module_refs.update(extract_refexpr_names(e))
         result = self.analyze_ordinary_member_access(e, is_lvalue)
-        return self.narrow_type_from_binder(e, result)
+        narrowed = self.narrow_type_from_binder(e, result)
+        self.chk.warn_deprecated(e.node, e)
+        return narrowed
 
-    def analyze_ordinary_member_access(self, e: MemberExpr, is_lvalue: bool) -> Type:
-        """Analyse member expression or member lvalue."""
+    def analyze_ordinary_member_access(
+        self, e: MemberExpr, is_lvalue: bool, rvalue: Expression | None = None
+    ) -> Type:
+        """Analyse member expression or member lvalue.
+
+        An rvalue can be provided optionally to infer better setter type when is_lvalue is True.
+        """
         if e.kind is not None:
             # This is a reference to a module attribute.
             return self.analyze_ref_expr(e)
@@ -2782,7 +3319,9 @@ def analyze_ordinary_member_access(self, e: MemberExpr, is_lvalue: bool) -> Type
             if isinstance(base, RefExpr) and isinstance(base.node, MypyFile):
                 module_symbol_table = base.node.names
             if isinstance(base, RefExpr) and isinstance(base.node, Var):
-                is_self = base.node.is_self
+                # This is needed to special case self-types, so we don't need to track
+                # these flags separately in checkmember.py.
+                is_self = base.node.is_self or base.node.is_cls
             else:
                 is_self = False
 
@@ -2790,15 +3329,15 @@ def analyze_ordinary_member_access(self, e: MemberExpr, is_lvalue: bool) -> Type
                 e.name,
                 original_type,
                 e,
-                is_lvalue,
-                False,
-                False,
-                self.msg,
+                is_lvalue=is_lvalue,
+                is_super=False,
+                is_operator=False,
                 original_type=original_type,
                 chk=self.chk,
                 in_literal_context=self.is_literal_context(),
                 module_symbol_table=module_symbol_table,
                 is_self=is_self,
+                rvalue=rvalue,
             )
 
             return member_type
@@ -2814,10 +3353,9 @@ def analyze_external_member_access(
             member,
             base_type,
             context,
-            False,
-            False,
-            False,
-            self.msg,
+            is_lvalue=False,
+            is_super=False,
+            is_operator=False,
             original_type=base_type,
             chk=self.chk,
             in_literal_context=self.is_literal_context(),
@@ -2855,6 +3393,7 @@ def infer_literal_expr_type(self, value: LiteralValue, fallback_name: str) -> Ty
 
     def concat_tuples(self, left: TupleType, right: TupleType) -> TupleType:
         """Concatenate two fixed length tuples."""
+        assert not (find_unpack_in_list(left.items) and find_unpack_in_list(right.items))
         return TupleType(
             items=left.items + right.items, fallback=self.named_type("builtins.tuple")
         )
@@ -2894,7 +3433,7 @@ def visit_op_expr(self, e: OpExpr) -> Type:
             # Expressions of form [...] * e get special type inference.
             return self.check_list_multiply(e)
         if e.op == "%":
-            if isinstance(e.left, BytesExpr) and self.chk.options.python_version >= (3, 5):
+            if isinstance(e.left, BytesExpr):
                 return self.strfrm_checker.check_str_interpolation(e.left, e.right)
             if isinstance(e.left, StrExpr):
                 return self.strfrm_checker.check_str_interpolation(e.left, e.right)
@@ -2908,11 +3447,85 @@ def visit_op_expr(self, e: OpExpr) -> Type:
                 if isinstance(proper_right_type, TupleType):
                     right_radd_method = proper_right_type.partial_fallback.type.get("__radd__")
                     if right_radd_method is None:
-                        return self.concat_tuples(proper_left_type, proper_right_type)
+                        # One cannot have two variadic items in the same tuple.
+                        if (
+                            find_unpack_in_list(proper_left_type.items) is None
+                            or find_unpack_in_list(proper_right_type.items) is None
+                        ):
+                            return self.concat_tuples(proper_left_type, proper_right_type)
+                elif (
+                    PRECISE_TUPLE_TYPES in self.chk.options.enable_incomplete_feature
+                    and isinstance(proper_right_type, Instance)
+                    and self.chk.type_is_iterable(proper_right_type)
+                ):
+                    # Handle tuple[X, Y] + tuple[Z, ...] = tuple[X, Y, *tuple[Z, ...]].
+                    right_radd_method = proper_right_type.type.get("__radd__")
+                    if (
+                        right_radd_method is None
+                        and proper_left_type.partial_fallback.type.fullname == "builtins.tuple"
+                        and find_unpack_in_list(proper_left_type.items) is None
+                    ):
+                        item_type = self.chk.iterable_item_type(proper_right_type, e)
+                        mapped = self.chk.named_generic_type("builtins.tuple", [item_type])
+                        return proper_left_type.copy_modified(
+                            items=proper_left_type.items + [UnpackType(mapped)]
+                        )
+
+        use_reverse: UseReverse = USE_REVERSE_DEFAULT
+        if e.op == "|":
+            if is_named_instance(proper_left_type, "builtins.dict"):
+                # This is a special case for `dict | TypedDict`.
+                # 1. Find `dict | TypedDict` case
+                # 2. Switch `dict.__or__` to `TypedDict.__ror__` (the same from both runtime and typing perspective)
+                proper_right_type = get_proper_type(self.accept(e.right))
+                if isinstance(proper_right_type, TypedDictType):
+                    use_reverse = USE_REVERSE_ALWAYS
+            if isinstance(proper_left_type, TypedDictType):
+                # This is the reverse case: `TypedDict | dict`,
+                # simply do not allow the reverse checking:
+                # do not call `__dict__.__ror__`.
+                proper_right_type = get_proper_type(self.accept(e.right))
+                if is_named_instance(proper_right_type, "builtins.dict"):
+                    use_reverse = USE_REVERSE_NEVER
+
+        if PRECISE_TUPLE_TYPES in self.chk.options.enable_incomplete_feature:
+            # Handle tuple[X, ...] + tuple[Y, Z] = tuple[*tuple[X, ...], Y, Z].
+            if (
+                e.op == "+"
+                and isinstance(proper_left_type, Instance)
+                and proper_left_type.type.fullname == "builtins.tuple"
+            ):
+                proper_right_type = get_proper_type(self.accept(e.right))
+                if (
+                    isinstance(proper_right_type, TupleType)
+                    and proper_right_type.partial_fallback.type.fullname == "builtins.tuple"
+                    and find_unpack_in_list(proper_right_type.items) is None
+                ):
+                    return proper_right_type.copy_modified(
+                        items=[UnpackType(proper_left_type)] + proper_right_type.items
+                    )
 
         if e.op in operators.op_methods:
             method = operators.op_methods[e.op]
-            result, method_type = self.check_op(method, left_type, e.right, e, allow_reverse=True)
+            if use_reverse is UseReverse.DEFAULT or use_reverse is UseReverse.NEVER:
+                result, method_type = self.check_op(
+                    method,
+                    base_type=left_type,
+                    arg=e.right,
+                    context=e,
+                    allow_reverse=use_reverse is UseReverse.DEFAULT,
+                )
+            elif use_reverse is UseReverse.ALWAYS:
+                result, method_type = self.check_op(
+                    # The reverse operator here gives better error messages:
+                    operators.reverse_op_methods[method],
+                    base_type=self.accept(e.right),
+                    arg=e.left,
+                    context=e,
+                    allow_reverse=False,
+                )
+            else:
+                assert_never(use_reverse)
             e.method_type = method_type
             return result
         else:
@@ -3087,8 +3700,9 @@ def dangerous_comparison(
         self,
         left: Type,
         right: Type,
-        original_container: Type | None = None,
         *,
+        original_container: Type | None = None,
+        seen_types: set[tuple[Type, Type]] | None = None,
         prefer_literal: bool = True,
     ) -> bool:
         """Check for dangerous non-overlapping comparisons like 42 == 'no'.
@@ -3109,6 +3723,12 @@ def dangerous_comparison(
         if not self.chk.options.strict_equality:
             return False
 
+        if seen_types is None:
+            seen_types = set()
+        if (left, right) in seen_types:
+            return False
+        seen_types.add((left, right))
+
         left, right = get_proper_types((left, right))
 
         # We suppress the error if there is a custom __eq__() method on either
@@ -3164,9 +3784,21 @@ def dangerous_comparison(
                 abstract_set = self.chk.lookup_typeinfo("typing.AbstractSet")
                 left = map_instance_to_supertype(left, abstract_set)
                 right = map_instance_to_supertype(right, abstract_set)
-                return self.dangerous_comparison(left.args[0], right.args[0])
+                return self.dangerous_comparison(
+                    left.args[0], right.args[0], seen_types=seen_types
+                )
+            elif left.type.has_base("typing.Mapping") and right.type.has_base("typing.Mapping"):
+                # Similar to above: Mapping ignores the classes, it just compares items.
+                abstract_map = self.chk.lookup_typeinfo("typing.Mapping")
+                left = map_instance_to_supertype(left, abstract_map)
+                right = map_instance_to_supertype(right, abstract_map)
+                return self.dangerous_comparison(
+                    left.args[0], right.args[0], seen_types=seen_types
+                ) or self.dangerous_comparison(left.args[1], right.args[1], seen_types=seen_types)
             elif left_name in ("builtins.list", "builtins.tuple") and right_name == left_name:
-                return self.dangerous_comparison(left.args[0], right.args[0])
+                return self.dangerous_comparison(
+                    left.args[0], right.args[0], seen_types=seen_types
+                )
             elif left_name in OVERLAPPING_BYTES_ALLOWLIST and right_name in (
                 OVERLAPPING_BYTES_ALLOWLIST
             ):
@@ -3175,6 +3807,18 @@ def dangerous_comparison(
             if isinstance(left.value, bool) and isinstance(right.value, bool):
                 # Comparing different booleans is not dangerous.
                 return False
+        if isinstance(left, LiteralType) and isinstance(right, Instance):
+            # bytes/bytearray comparisons are supported
+            if left.fallback.type.fullname == "builtins.bytes" and right.type.has_base(
+                "builtins.bytearray"
+            ):
+                return False
+        if isinstance(right, LiteralType) and isinstance(left, Instance):
+            # bytes/bytearray comparisons are supported
+            if right.fallback.type.fullname == "builtins.bytes" and left.type.has_base(
+                "builtins.bytearray"
+            ):
+                return False
         return not is_overlapping_types(left, right, ignore_promotions=False)
 
     def check_method_call_by_name(
@@ -3203,11 +3847,11 @@ def check_method_call_by_name(
             method,
             base_type,
             context,
-            False,
-            False,
-            True,
-            self.msg,
+            is_lvalue=False,
+            is_super=False,
+            is_operator=True,
             original_type=original_type,
+            self_type=base_type,
             chk=self.chk,
             in_literal_context=self.is_literal_context(),
         )
@@ -3300,7 +3944,6 @@ def lookup_operator(op_name: str, base_type: Type) -> Type | None:
                     is_operator=True,
                     original_type=base_type,
                     context=context,
-                    msg=self.msg,
                     chk=self.chk,
                     in_literal_context=self.is_literal_context(),
                 )
@@ -3359,7 +4002,7 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
             # This is the case even if the __add__ method is completely missing and the __radd__
             # method is defined.
 
-            variants_raw = [(left_op, left_type, right_expr)]
+            variants_raw = [(op_name, left_op, left_type, right_expr)]
         elif (
             is_subtype(right_type, left_type)
             and isinstance(left_type, Instance)
@@ -3380,19 +4023,25 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
             # As a special case, the alt_promote check makes sure that we don't use the
             # __radd__ method of int if the LHS is a native int type.
 
-            variants_raw = [(right_op, right_type, left_expr), (left_op, left_type, right_expr)]
+            variants_raw = [
+                (rev_op_name, right_op, right_type, left_expr),
+                (op_name, left_op, left_type, right_expr),
+            ]
         else:
             # In all other cases, we do the usual thing and call __add__ first and
             # __radd__ second when doing "A() + B()".
 
-            variants_raw = [(left_op, left_type, right_expr), (right_op, right_type, left_expr)]
+            variants_raw = [
+                (op_name, left_op, left_type, right_expr),
+                (rev_op_name, right_op, right_type, left_expr),
+            ]
 
         # STEP 3:
         # We now filter out all non-existent operators. The 'variants' list contains
         # all operator methods that are actually present, in the order that Python
         # attempts to invoke them.
 
-        variants = [(op, obj, arg) for (op, obj, arg) in variants_raw if op is not None]
+        variants = [(na, op, obj, arg) for (na, op, obj, arg) in variants_raw if op is not None]
 
         # STEP 4:
         # We now try invoking each one. If an operation succeeds, end early and return
@@ -3401,13 +4050,23 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
 
         errors = []
         results = []
-        for method, obj, arg in variants:
+        for name, method, obj, arg in variants:
             with self.msg.filter_errors(save_filtered_errors=True) as local_errors:
-                result = self.check_method_call(op_name, obj, method, [arg], [ARG_POS], context)
+                result = self.check_method_call(name, obj, method, [arg], [ARG_POS], context)
             if local_errors.has_new_errors():
                 errors.append(local_errors.filtered_errors())
                 results.append(result)
             else:
+                if isinstance(obj, Instance) and isinstance(
+                    defn := obj.type.get_method(name), OverloadedFuncDef
+                ):
+                    for item in defn.items:
+                        if (
+                            isinstance(item, Decorator)
+                            and isinstance(typ := item.func.type, CallableType)
+                            and bind_self(typ) == result[1]
+                        ):
+                            self.chk.check_deprecated(item.func, context)
                 return result
 
         # We finish invoking above operators and no early return happens. Therefore,
@@ -3468,9 +4127,7 @@ def check_op(
             left_variants = [base_type]
             base_type = get_proper_type(base_type)
             if isinstance(base_type, UnionType):
-                left_variants = [
-                    item for item in flatten_nested_unions(base_type.relevant_items())
-                ]
+                left_variants = list(flatten_nested_unions(base_type.relevant_items()))
             right_type = self.accept(arg)
 
             # Step 1: We first try leaving the right arguments alone and destructure
@@ -3609,11 +4266,7 @@ def check_boolean_op(self, e: OpExpr, context: Context) -> Type:
         ):
             self.msg.unreachable_right_operand(e.op, e.right)
 
-        # If right_map is None then we know mypy considers the right branch
-        # to be unreachable and therefore any errors found in the right branch
-        # should be suppressed.
-        with self.msg.filter_errors(filter_errors=right_map is None):
-            right_type = self.analyze_cond_branch(right_map, e.right, expanded_left_type)
+        right_type = self.analyze_cond_branch(right_map, e.right, expanded_left_type)
 
         if left_map is None and right_map is None:
             return UninhabitedType()
@@ -3663,7 +4316,10 @@ def visit_assignment_expr(self, e: AssignmentExpr) -> Type:
         value = self.accept(e.value)
         self.chk.check_assignment(e.target, e.value)
         self.chk.check_final(e)
-        self.chk.store_type(e.target, value)
+        if not has_uninhabited_component(value):
+            # TODO: can we get rid of this extra store_type()?
+            # Usually, check_assignment() already stores the lvalue type correctly.
+            self.chk.store_type(e.target, value)
         self.find_partial_type_ref_fast_path(e.target)
         return value
 
@@ -3673,6 +4329,7 @@ def visit_unary_expr(self, e: UnaryExpr) -> Type:
         op = e.op
         if op == "not":
             result: Type = self.bool_type()
+            self.chk.check_for_truthy_type(operand_type, e.expr)
         else:
             method = operators.unary_op_methods[op]
             result, method_type = self.check_method_call_by_name(method, operand_type, [], [], e)
@@ -3715,6 +4372,12 @@ def visit_index_with_type(
         # Visit the index, just to make sure we have a type for it available
         self.accept(index)
 
+        if isinstance(left_type, TupleType) and any(
+            isinstance(it, UnpackType) for it in left_type.items
+        ):
+            # Normalize variadic tuples for consistency.
+            left_type = expand_type(left_type, {})
+
         if isinstance(left_type, UnionType):
             original_type = original_type or left_type
             # Don't combine literal types, since we may need them for type narrowing.
@@ -3735,28 +4398,36 @@ def visit_index_with_type(
             if ns is not None:
                 out = []
                 for n in ns:
-                    if n < 0:
-                        n += len(left_type.items)
-                    if 0 <= n < len(left_type.items):
-                        out.append(left_type.items[n])
+                    item = self.visit_tuple_index_helper(left_type, n)
+                    if item is not None:
+                        out.append(item)
                     else:
                         self.chk.fail(message_registry.TUPLE_INDEX_OUT_OF_RANGE, e)
+                        if any(isinstance(t, UnpackType) for t in left_type.items):
+                            min_len = self.min_tuple_length(left_type)
+                            self.chk.note(f"Variadic tuple can have length {min_len}", e)
                         return AnyType(TypeOfAny.from_error)
                 return make_simplified_union(out)
             else:
                 return self.nonliteral_tuple_index_helper(left_type, index)
         elif isinstance(left_type, TypedDictType):
-            return self.visit_typeddict_index_expr(left_type, e.index)
-        elif (
-            isinstance(left_type, CallableType)
-            and left_type.is_type_obj()
-            and left_type.type_object().is_enum
-        ):
-            return self.visit_enum_index_expr(left_type.type_object(), e.index, e)
-        elif isinstance(left_type, TypeVarType) and not self.has_member(
+            return self.visit_typeddict_index_expr(left_type, e.index)[0]
+        elif isinstance(left_type, FunctionLike) and left_type.is_type_obj():
+            if left_type.type_object().is_enum:
+                return self.visit_enum_index_expr(left_type.type_object(), e.index, e)
+            elif self.chk.options.python_version >= (3, 9) and (
+                left_type.type_object().type_vars
+                or left_type.type_object().fullname == "builtins.type"
+            ):
+                return self.named_type("types.GenericAlias")
+
+        if isinstance(left_type, TypeVarType) and not self.has_member(
             left_type.upper_bound, "__getitem__"
         ):
             return self.visit_index_with_type(left_type.upper_bound, e, original_type)
+        elif isinstance(left_type, Instance) and left_type.type.fullname == "typing._SpecialForm":
+            # Allow special forms to be indexed and used to create union types
+            return self.named_type("typing._SpecialForm")
         else:
             result, method_type = self.check_method_call_by_name(
                 "__getitem__", left_type, [e.index], [ARG_POS], e, original_type=original_type
@@ -3764,6 +4435,64 @@ def visit_index_with_type(
             e.method_type = method_type
             return result
 
+    def min_tuple_length(self, left: TupleType) -> int:
+        unpack_index = find_unpack_in_list(left.items)
+        if unpack_index is None:
+            return left.length()
+        unpack = left.items[unpack_index]
+        assert isinstance(unpack, UnpackType)
+        if isinstance(unpack.type, TypeVarTupleType):
+            return left.length() - 1 + unpack.type.min_len
+        return left.length() - 1
+
+    def visit_tuple_index_helper(self, left: TupleType, n: int) -> Type | None:
+        unpack_index = find_unpack_in_list(left.items)
+        if unpack_index is None:
+            if n < 0:
+                n += len(left.items)
+            if 0 <= n < len(left.items):
+                return left.items[n]
+            return None
+        unpack = left.items[unpack_index]
+        assert isinstance(unpack, UnpackType)
+        unpacked = get_proper_type(unpack.type)
+        if isinstance(unpacked, TypeVarTupleType):
+            # Usually we say that TypeVarTuple can't be split, be in case of
+            # indexing it seems benign to just return the upper bound item, similar
+            # to what we do when indexing a regular TypeVar.
+            bound = get_proper_type(unpacked.upper_bound)
+            assert isinstance(bound, Instance)
+            assert bound.type.fullname == "builtins.tuple"
+            middle = bound.args[0]
+        else:
+            assert isinstance(unpacked, Instance)
+            assert unpacked.type.fullname == "builtins.tuple"
+            middle = unpacked.args[0]
+
+        extra_items = self.min_tuple_length(left) - left.length() + 1
+        if n >= 0:
+            if n >= self.min_tuple_length(left):
+                # For tuple[int, *tuple[str, ...], int] we allow either index 0 or 1,
+                # since variadic item may have zero items.
+                return None
+            if n < unpack_index:
+                return left.items[n]
+            return UnionType.make_union(
+                [middle]
+                + left.items[unpack_index + 1 : max(n - extra_items + 2, unpack_index + 1)],
+                left.line,
+                left.column,
+            )
+        n += self.min_tuple_length(left)
+        if n < 0:
+            # Similar to above, we only allow -1, and -2 for tuple[int, *tuple[str, ...], int]
+            return None
+        if n >= unpack_index + extra_items:
+            return left.items[n - extra_items + 1]
+        return UnionType.make_union(
+            left.items[min(n, unpack_index) : unpack_index] + [middle], left.line, left.column
+        )
+
     def visit_tuple_slice_helper(self, left_type: TupleType, slic: SliceExpr) -> Type:
         begin: Sequence[int | None] = [None]
         end: Sequence[int | None] = [None]
@@ -3789,7 +4518,11 @@ def visit_tuple_slice_helper(self, left_type: TupleType, slic: SliceExpr) -> Typ
 
         items: list[Type] = []
         for b, e, s in itertools.product(begin, end, stride):
-            items.append(left_type.slice(b, e, s))
+            item = left_type.slice(b, e, s, fallback=self.named_type("builtins.tuple"))
+            if item is None:
+                self.chk.fail(message_registry.AMBIGUOUS_SLICE_OF_VARIADIC_TUPLE, slic)
+                return AnyType(TypeOfAny.from_error)
+            items.append(item)
         return make_simplified_union(items)
 
     def try_getting_int_literals(self, index: Expression) -> list[int] | None:
@@ -3798,7 +4531,7 @@ def try_getting_int_literals(self, index: Expression) -> list[int] | None:
         Otherwise, returns None.
 
         Specifically, this function is guaranteed to return a list with
-        one or more ints if one one the following is true:
+        one or more ints if one the following is true:
 
         1. 'expr' is a IntExpr or a UnaryExpr backed by an IntExpr
         2. 'typ' is a LiteralType containing an int
@@ -3811,6 +4544,10 @@ def try_getting_int_literals(self, index: Expression) -> list[int] | None:
                 operand = index.expr
                 if isinstance(operand, IntExpr):
                     return [-1 * operand.value]
+            if index.op == "+":
+                operand = index.expr
+                if isinstance(operand, IntExpr):
+                    return [operand.value]
         typ = get_proper_type(self.accept(index))
         if isinstance(typ, Instance) and typ.last_known_value is not None:
             typ = typ.last_known_value
@@ -3829,14 +4566,33 @@ def try_getting_int_literals(self, index: Expression) -> list[int] | None:
     def nonliteral_tuple_index_helper(self, left_type: TupleType, index: Expression) -> Type:
         self.check_method_call_by_name("__getitem__", left_type, [index], [ARG_POS], context=index)
         # We could return the return type from above, but unions are often better than the join
-        union = make_simplified_union(left_type.items)
+        union = self.union_tuple_fallback_item(left_type)
         if isinstance(index, SliceExpr):
             return self.chk.named_generic_type("builtins.tuple", [union])
         return union
 
+    def union_tuple_fallback_item(self, left_type: TupleType) -> Type:
+        # TODO: this duplicates logic in typeops.tuple_fallback().
+        items = []
+        for item in left_type.items:
+            if isinstance(item, UnpackType):
+                unpacked_type = get_proper_type(item.type)
+                if isinstance(unpacked_type, TypeVarTupleType):
+                    unpacked_type = get_proper_type(unpacked_type.upper_bound)
+                if (
+                    isinstance(unpacked_type, Instance)
+                    and unpacked_type.type.fullname == "builtins.tuple"
+                ):
+                    items.append(unpacked_type.args[0])
+                else:
+                    raise NotImplementedError
+            else:
+                items.append(item)
+        return make_simplified_union(items)
+
     def visit_typeddict_index_expr(
         self, td_type: TypedDictType, index: Expression, setitem: bool = False
-    ) -> Type:
+    ) -> tuple[Type, set[str]]:
         if isinstance(index, StrExpr):
             key_names = [index.value]
         else:
@@ -3859,17 +4615,17 @@ def visit_typeddict_index_expr(
                     key_names.append(key_type.value)
                 else:
                     self.msg.typeddict_key_must_be_string_literal(td_type, index)
-                    return AnyType(TypeOfAny.from_error)
+                    return AnyType(TypeOfAny.from_error), set()
 
         value_types = []
         for key_name in key_names:
             value_type = td_type.items.get(key_name)
             if value_type is None:
                 self.msg.typeddict_key_not_found(td_type, key_name, index, setitem)
-                return AnyType(TypeOfAny.from_error)
+                return AnyType(TypeOfAny.from_error), set()
             else:
                 value_types.append(value_type)
-        return make_simplified_union(value_types)
+        return make_simplified_union(value_types), set(key_names)
 
     def visit_enum_index_expr(
         self, enum_type: TypeInfo, index: Expression, context: Context
@@ -3896,8 +4652,8 @@ def visit_cast_expr(self, expr: CastExpr) -> Type:
         options = self.chk.options
         if (
             options.warn_redundant_casts
-            and not isinstance(get_proper_type(target_type), AnyType)
-            and source_type == target_type
+            and not is_same_type(target_type, AnyType(TypeOfAny.special_form))
+            and is_same_type(source_type, target_type)
         ):
             self.msg.redundant_cast(target_type, expr)
         if options.disallow_any_unimported and has_any_from_unimported_type(target_type):
@@ -3914,6 +4670,9 @@ def visit_assert_type_expr(self, expr: AssertTypeExpr) -> Type:
             allow_none_return=True,
             always_allow_any=True,
         )
+        if self.chk.current_node_deferred:
+            return source_type
+
         target_type = expr.type
         proper_source_type = get_proper_type(source_type)
         if (
@@ -3943,6 +4702,7 @@ def visit_reveal_expr(self, expr: RevealExpr) -> Type:
                     self.msg.note(
                         "'reveal_type' always outputs 'Any' in unchecked functions", expr.expr
                     )
+                self.check_reveal_imported(expr)
             return revealed_type
         else:
             # REVEAL_LOCALS
@@ -3957,8 +4717,32 @@ def visit_reveal_expr(self, expr: RevealExpr) -> Type:
                 )
 
                 self.msg.reveal_locals(names_to_types, expr)
+                self.check_reveal_imported(expr)
             return NoneType()
 
+    def check_reveal_imported(self, expr: RevealExpr) -> None:
+        if codes.UNIMPORTED_REVEAL not in self.chk.options.enabled_error_codes:
+            return
+
+        name = ""
+        if expr.kind == REVEAL_LOCALS:
+            name = "reveal_locals"
+        elif expr.kind == REVEAL_TYPE and not expr.is_imported:
+            name = "reveal_type"
+        else:
+            return
+
+        self.chk.fail(f'Name "{name}" is not defined', expr, code=codes.UNIMPORTED_REVEAL)
+        if name == "reveal_type":
+            module = (
+                "typing" if self.chk.options.python_version >= (3, 11) else "typing_extensions"
+            )
+            hint = (
+                'Did you forget to import it from "{module}"?'
+                ' (Suggestion: "from {module} import {name}")'
+            ).format(module=module, name=name)
+            self.chk.note(hint, expr, code=codes.UNIMPORTED_REVEAL)
+
     def visit_type_application(self, tapp: TypeApplication) -> Type:
         """Type check a type application (expr[type, ...]).
 
@@ -3968,6 +4752,8 @@ def visit_type_application(self, tapp: TypeApplication) -> Type:
         is due to slight differences in how type arguments are applied and checked.
         """
         if isinstance(tapp.expr, RefExpr) and isinstance(tapp.expr.node, TypeAlias):
+            if tapp.expr.node.python_3_12_type_alias:
+                return self.type_alias_type_type()
             # Subscription of a (generic) alias in runtime context, expand the alias.
             item = instantiate_type_alias(
                 tapp.expr.node,
@@ -4030,6 +4816,8 @@ class LongName(Generic[T]): ...
             x = A()
             y = cast(A, ...)
         """
+        if alias.python_3_12_type_alias:
+            return self.type_alias_type_type()
         if isinstance(alias.target, Instance) and alias.target.invalid:  # type: ignore[misc]
             # An invalid alias, error already has been reported
             return AnyType(TypeOfAny.from_error)
@@ -4041,6 +4829,7 @@ class LongName(Generic[T]): ...
         item = get_proper_type(
             set_any_tvars(
                 alias,
+                [],
                 ctx.line,
                 ctx.column,
                 self.chk.options,
@@ -4064,8 +4853,16 @@ class LongName(Generic[T]): ...
             return type_object_type(tuple_fallback(item).type, self.named_type)
         elif isinstance(item, TypedDictType):
             return self.typeddict_callable_from_context(item)
+        elif isinstance(item, NoneType):
+            return TypeType(item, line=item.line, column=item.column)
         elif isinstance(item, AnyType):
             return AnyType(TypeOfAny.from_another_any, source_any=item)
+        elif (
+            isinstance(item, UnionType)
+            and item.uses_pep604_syntax
+            and self.chk.options.python_version >= (3, 10)
+        ):
+            return self.chk.named_generic_type("types.UnionType", item.items)
         else:
             if alias_definition:
                 return AnyType(TypeOfAny.special_form)
@@ -4085,17 +4882,44 @@ class C(Generic[T, Unpack[Ts]]): ...
         We simply group the arguments that need to go into Ts variable into a TupleType,
         similar to how it is done in other places using split_with_prefix_and_suffix().
         """
-        vars = t.variables
+        if t.is_type_obj():
+            # Type arguments must map to class type variables, ignoring constructor vars.
+            vars = t.type_object().defn.type_vars
+        else:
+            vars = list(t.variables)
+        args = flatten_nested_tuples(args)
+
+        # TODO: this logic is duplicated with semanal_typeargs.
+        for tv, arg in zip(t.variables, args):
+            if isinstance(tv, ParamSpecType):
+                if not isinstance(
+                    get_proper_type(arg), (Parameters, ParamSpecType, AnyType, UnboundType)
+                ):
+                    self.chk.fail(
+                        "Can only replace ParamSpec with a parameter types list or"
+                        f" another ParamSpec, got {format_type(arg, self.chk.options)}",
+                        ctx,
+                    )
+                    return [AnyType(TypeOfAny.from_error)] * len(vars)
+
         if not vars or not any(isinstance(v, TypeVarTupleType) for v in vars):
             return list(args)
+        # TODO: in future we may want to support type application to variadic functions.
+        assert t.is_type_obj()
+        info = t.type_object()
+        # We reuse the logic from semanal phase to reduce code duplication.
+        fake = Instance(info, args, line=ctx.line, column=ctx.column)
+        # This code can be only called either from checking a type application, or from
+        # checking a type alias (after the caller handles no_args aliases), so we know it
+        # was initially an IndexExpr, and we allow empty tuple type arguments.
+        if not validate_instance(fake, self.chk.fail, empty_tuple_index=True):
+            fix_instance(
+                fake, self.chk.fail, self.chk.note, disallow_any=False, options=self.chk.options
+            )
+            args = list(fake.args)
 
         prefix = next(i for (i, v) in enumerate(vars) if isinstance(v, TypeVarTupleType))
         suffix = len(vars) - prefix - 1
-        args = flatten_nested_tuples(args)
-        if len(args) < len(vars) - 1:
-            self.msg.incompatible_type_application(len(vars), len(args), ctx)
-            return [AnyType(TypeOfAny.from_error)] * len(vars)
-
         tvt = vars[prefix]
         assert isinstance(tvt, TypeVarTupleType)
         start, middle, end = split_with_prefix_and_suffix(tuple(args), prefix, suffix)
@@ -4114,21 +4938,60 @@ def apply_type_arguments_to_callable(
         tp = get_proper_type(tp)
 
         if isinstance(tp, CallableType):
-            if len(tp.variables) != len(args) and not any(
-                isinstance(v, TypeVarTupleType) for v in tp.variables
-            ):
+            if tp.is_type_obj():
+                # If we have a class object in runtime context, then the available type
+                # variables are those of the class, we don't include additional variables
+                # of the constructor. So that with
+                #     class C(Generic[T]):
+                #         def __init__(self, f: Callable[[S], T], x: S) -> None
+                # C[int] is valid
+                # C[int, str] is invalid (although C as a callable has 2 type variables)
+                # Note: various logic below and in applytype.py relies on the fact that
+                # class type variables appear *before* constructor variables.
+                type_vars = tp.type_object().defn.type_vars
+            else:
+                type_vars = list(tp.variables)
+            min_arg_count = sum(not v.has_default() for v in type_vars)
+            has_type_var_tuple = any(isinstance(v, TypeVarTupleType) for v in type_vars)
+            if (
+                len(args) < min_arg_count or len(args) > len(type_vars)
+            ) and not has_type_var_tuple:
                 if tp.is_type_obj() and tp.type_object().fullname == "builtins.tuple":
-                    # TODO: Specialize the callable for the type arguments
-                    return tp
-                self.msg.incompatible_type_application(len(tp.variables), len(args), ctx)
+                    # e.g. expression tuple[X, Y]
+                    # - want the type of the expression i.e. a function with that as its return type
+                    # - tp is type of tuple (note it won't have params as we are only called
+                    #   with generic callable type)
+                    # - tuple[X, Y]() takes a single arg that is a tuple containing an X and a Y
+                    return CallableType(
+                        [TupleType(list(args), self.chk.named_type("tuple"))],
+                        [ARG_POS],
+                        [None],
+                        TupleType(list(args), self.chk.named_type("tuple")),
+                        tp.fallback,
+                        name="tuple",
+                        definition=tp.definition,
+                        bound_args=tp.bound_args,
+                    )
+                self.msg.incompatible_type_application(
+                    min_arg_count, len(type_vars), len(args), ctx
+                )
                 return AnyType(TypeOfAny.from_error)
             return self.apply_generic_arguments(tp, self.split_for_callable(tp, args, ctx), ctx)
         if isinstance(tp, Overloaded):
             for it in tp.items:
-                if len(it.variables) != len(args) and not any(
-                    isinstance(v, TypeVarTupleType) for v in it.variables
-                ):
-                    self.msg.incompatible_type_application(len(it.variables), len(args), ctx)
+                if tp.is_type_obj():
+                    # Same as above.
+                    type_vars = tp.type_object().defn.type_vars
+                else:
+                    type_vars = list(it.variables)
+                min_arg_count = sum(not v.has_default() for v in type_vars)
+                has_type_var_tuple = any(isinstance(v, TypeVarTupleType) for v in type_vars)
+                if (
+                    len(args) < min_arg_count or len(args) > len(type_vars)
+                ) and not has_type_var_tuple:
+                    self.msg.incompatible_type_application(
+                        min_arg_count, len(type_vars), len(args), ctx
+                    )
                     return AnyType(TypeOfAny.from_error)
             return Overloaded(
                 [
@@ -4192,7 +5055,7 @@ def check_lst_expr(self, e: ListExpr | SetExpr | TupleExpr, fullname: str, tag:
         tv = TypeVarType(
             "T",
             "T",
-            id=-1,
+            id=TypeVarId(-1, namespace="<lst>"),
             values=[],
             upper_bound=self.object_type(),
             default=AnyType(TypeOfAny.from_omitted_generics),
@@ -4214,6 +5077,19 @@ def check_lst_expr(self, e: ListExpr | SetExpr | TupleExpr, fullname: str, tag:
         )[0]
         return remove_instance_last_known_values(out)
 
+    def tuple_context_matches(self, expr: TupleExpr, ctx: TupleType) -> bool:
+        ctx_unpack_index = find_unpack_in_list(ctx.items)
+        if ctx_unpack_index is None:
+            # For fixed tuples accept everything that can possibly match, even if this
+            # requires all star items to be empty.
+            return len([e for e in expr.items if not isinstance(e, StarExpr)]) <= len(ctx.items)
+        # For variadic context, the only easy case is when structure matches exactly.
+        # TODO: try using tuple type context in more cases.
+        if len([e for e in expr.items if isinstance(e, StarExpr)]) != 1:
+            return False
+        expr_star_index = next(i for i, lv in enumerate(expr.items) if isinstance(lv, StarExpr))
+        return len(expr.items) == len(ctx.items) and ctx_unpack_index == expr_star_index
+
     def visit_tuple_expr(self, e: TupleExpr) -> Type:
         """Type check a tuple expression."""
         # Try to determine type context for type inference.
@@ -4223,7 +5099,7 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
             tuples_in_context = [
                 t
                 for t in get_proper_types(type_context.items)
-                if (isinstance(t, TupleType) and len(t.items) == len(e.items))
+                if (isinstance(t, TupleType) and self.tuple_context_matches(e, t))
                 or is_named_instance(t, TUPLE_LIKE_INSTANCE_NAMES)
             ]
             if len(tuples_in_context) == 1:
@@ -4233,7 +5109,7 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
                 # more than one.  Either way, we can't decide on a context.
                 pass
 
-        if isinstance(type_context, TupleType):
+        if isinstance(type_context, TupleType) and self.tuple_context_matches(e, type_context):
             type_context_items = type_context.items
         elif type_context and is_named_instance(type_context, TUPLE_LIKE_INSTANCE_NAMES):
             assert isinstance(type_context, Instance)
@@ -4244,6 +5120,14 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
         # items that match a position in e, and we'll worry about type
         # mismatches later.
 
+        unpack_in_context = False
+        if type_context_items is not None:
+            unpack_in_context = find_unpack_in_list(type_context_items) is not None
+        seen_unpack_in_items = False
+        allow_precise_tuples = (
+            unpack_in_context or PRECISE_TUPLE_TYPES in self.chk.options.enable_incomplete_feature
+        )
+
         # Infer item types.  Give up if there's a star expression
         # that's not a Tuple.
         items: list[Type] = []
@@ -4256,12 +5140,41 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
                 # TupleExpr, flatten it, so we can benefit from the
                 # context?  Counterargument: Why would anyone write
                 # (1, *(2, 3)) instead of (1, 2, 3) except in a test?
-                tt = self.accept(item.expr)
+                if unpack_in_context:
+                    # Note: this logic depends on full structure match in tuple_context_matches().
+                    assert type_context_items
+                    ctx_item = type_context_items[j]
+                    assert isinstance(ctx_item, UnpackType)
+                    ctx = ctx_item.type
+                else:
+                    ctx = None
+                tt = self.accept(item.expr, ctx)
                 tt = get_proper_type(tt)
                 if isinstance(tt, TupleType):
+                    if find_unpack_in_list(tt.items) is not None:
+                        if seen_unpack_in_items:
+                            # Multiple unpack items are not allowed in tuples,
+                            # fall back to instance type.
+                            return self.check_lst_expr(e, "builtins.tuple", "<tuple>")
+                        else:
+                            seen_unpack_in_items = True
                     items.extend(tt.items)
-                    j += len(tt.items)
+                    # Note: this logic depends on full structure match in tuple_context_matches().
+                    if unpack_in_context:
+                        j += 1
+                    else:
+                        # If there is an unpack in expressions, but not in context, this will
+                        # result in an error later, just do something predictable here.
+                        j += len(tt.items)
                 else:
+                    if allow_precise_tuples and not seen_unpack_in_items:
+                        # Handle (x, *y, z), where y is e.g. tuple[Y, ...].
+                        if isinstance(tt, Instance) and self.chk.type_is_iterable(tt):
+                            item_type = self.chk.iterable_item_type(tt, e)
+                            mapped = self.chk.named_generic_type("builtins.tuple", [item_type])
+                            items.append(UnpackType(mapped))
+                            seen_unpack_in_items = True
+                            continue
                     # A star expression that's not a Tuple.
                     # Treat the whole thing as a variable-length tuple.
                     return self.check_lst_expr(e, "builtins.tuple", "<tuple>")
@@ -4274,7 +5187,13 @@ def visit_tuple_expr(self, e: TupleExpr) -> Type:
                 items.append(tt)
         # This is a partial fallback item type. A precise type will be calculated on demand.
         fallback_item = AnyType(TypeOfAny.special_form)
-        return TupleType(items, self.chk.named_generic_type("builtins.tuple", [fallback_item]))
+        result: ProperType = TupleType(
+            items, self.chk.named_generic_type("builtins.tuple", [fallback_item])
+        )
+        if seen_unpack_in_items:
+            # Return already normalized tuple type just in case.
+            result = expand_type(result, {})
+        return result
 
     def fast_dict_type(self, e: DictExpr) -> Type | None:
         """
@@ -4327,7 +5246,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):
@@ -4367,7 +5286,7 @@ def visit_dict_expr(self, e: DictExpr) -> Type:
         kt = TypeVarType(
             "KT",
             "KT",
-            id=-1,
+            id=TypeVarId(-1, namespace="<dict>"),
             values=[],
             upper_bound=self.object_type(),
             default=AnyType(TypeOfAny.from_omitted_generics),
@@ -4375,7 +5294,7 @@ def visit_dict_expr(self, e: DictExpr) -> Type:
         vt = TypeVarType(
             "VT",
             "VT",
-            id=-2,
+            id=TypeVarId(-2, namespace="<dict>"),
             values=[],
             upper_bound=self.object_type(),
             default=AnyType(TypeOfAny.from_omitted_generics),
@@ -4427,7 +5346,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.
@@ -4441,15 +5362,17 @@ def visit_lambda_expr(self, e: LambdaExpr) -> Type:
             self.chk.return_types.append(AnyType(TypeOfAny.special_form))
             # Type check everything in the body except for the final return
             # statement (it can contain tuple unpacking before return).
-            with self.chk.scope.push_function(e):
+            with (
+                self.chk.binder.frame_context(can_skip=True, fall_through=0),
+                self.chk.scope.push_function(e),
+            ):
                 # Lambdas can have more than one element in body,
-                # when we add "fictional" AssigmentStatement nodes, like in:
+                # when we add "fictional" AssignmentStatement nodes, like in:
                 # `lambda (a, b): a`
                 for stmt in e.body.body[:-1]:
                     stmt.accept(self.chk)
                 # Only type check the return expression, not the return statement.
-                # This is important as otherwise the following statements would be
-                # considered unreachable. There's no useful type context.
+                # There's no useful type context.
                 ret_type = self.accept(e.expr(), allow_none_return=True)
             fallback = self.named_type("builtins.function")
             self.chk.return_types.pop()
@@ -4457,10 +5380,12 @@ def visit_lambda_expr(self, e: LambdaExpr) -> Type:
         else:
             # Type context available.
             self.chk.return_types.append(inferred_type.ret_type)
-            self.chk.check_func_item(e, type_override=type_override)
+            with self.chk.tscope.function_scope(e):
+                self.chk.check_func_item(e, type_override=type_override)
             if not self.chk.has_type(e.expr()):
                 # TODO: return expression must be accepted before exiting function scope.
-                self.accept(e.expr(), allow_none_return=True)
+                with self.chk.binder.frame_context(can_skip=True, fall_through=0):
+                    self.accept(e.expr(), allow_none_return=True)
             ret_type = self.chk.lookup_type(e.expr())
             self.chk.return_types.pop()
             return replace_callable_return_type(inferred_type, ret_type)
@@ -4491,14 +5416,28 @@ def infer_lambda_type_using_context(
         # they must be considered as indeterminate. We use ErasedType since it
         # does not affect type inference results (it is for purposes like this
         # only).
-        callable_ctx = get_proper_type(replace_meta_vars(ctx, ErasedType()))
-        assert isinstance(callable_ctx, CallableType)
+        if not self.chk.options.old_type_inference:
+            # With new type inference we can preserve argument types even if they
+            # are generic, since new inference algorithm can handle constraints
+            # like S <: T (we still erase return type since it's ultimately unknown).
+            extra_vars = []
+            for arg in ctx.arg_types:
+                meta_vars = [tv for tv in get_all_type_vars(arg) if tv.id.is_meta_var()]
+                extra_vars.extend([tv for tv in meta_vars if tv not in extra_vars])
+            callable_ctx = ctx.copy_modified(
+                ret_type=replace_meta_vars(ctx.ret_type, ErasedType()),
+                variables=list(ctx.variables) + extra_vars,
+            )
+        else:
+            erased_ctx = replace_meta_vars(ctx, ErasedType())
+            assert isinstance(erased_ctx, ProperType) and isinstance(erased_ctx, CallableType)
+            callable_ctx = erased_ctx
 
         # The callable_ctx may have a fallback of builtins.type if the context
         # is a constructor -- but this fallback doesn't make sense for lambdas.
         callable_ctx = callable_ctx.copy_modified(fallback=self.named_type("builtins.function"))
 
-        if callable_ctx.type_guard is not None:
+        if callable_ctx.type_guard is not None or callable_ctx.type_is is not None:
             # Lambda's return type cannot be treated as a `TypeGuard`,
             # because it is implicit. And `TypeGuard`s must be explicit.
             # See https://github.com/python/mypy/issues/9927
@@ -4524,7 +5463,9 @@ def infer_lambda_type_using_context(
             self.chk.fail(message_registry.CANNOT_INFER_LAMBDA_TYPE, e)
             return None, None
 
-        return callable_ctx, callable_ctx
+        # Type of lambda must have correct argument names, to prevent false
+        # negatives when lambdas appear in `ParamSpec` context.
+        return callable_ctx.copy_modified(arg_names=e.arg_names), callable_ctx
 
     def visit_super_expr(self, e: SuperExpr) -> Type:
         """Type check a super expression (non-lvalue)."""
@@ -4557,7 +5498,7 @@ def visit_super_expr(self, e: SuperExpr) -> Type:
         if type_info in mro:
             index = mro.index(type_info)
         else:
-            method = self.chk.scope.top_function()
+            method = self.chk.scope.current_function()
             # Mypy explicitly allows supertype upper bounds (and no upper bound at all)
             # for annotating self-types. However, if such an annotation is used for
             # checking super() we will still get an error. So to be consistent, we also
@@ -4603,7 +5544,6 @@ def visit_super_expr(self, e: SuperExpr) -> Type:
                     original_type=instance_type,
                     override_info=base,
                     context=e,
-                    msg=self.msg,
                     chk=self.chk,
                     in_literal_context=self.is_literal_context(),
                 )
@@ -4632,7 +5572,7 @@ def _super_arg_types(self, e: SuperExpr) -> Type | tuple[Type, Type]:
             type_type: ProperType = TypeType(current_type)
 
             # Use the type of the self argument, in case it was annotated
-            method = self.chk.scope.top_function()
+            method = self.chk.scope.current_function()
             assert method is not None
             if method.arguments:
                 instance_type: Type = method.arguments[0].variable.type or current_type
@@ -4698,11 +5638,15 @@ def visit_slice_expr(self, e: SliceExpr) -> Type:
         except KeyError:
             supports_index = self.chk.named_type("builtins.int")  # thanks, fixture life
         expected = make_optional_type(supports_index)
+        type_args = []
         for index in [e.begin_index, e.end_index, e.stride]:
             if index:
                 t = self.accept(index)
                 self.chk.check_subtype(t, expected, index, message_registry.INVALID_SLICE_INDEX)
-        return self.named_type("builtins.slice")
+                type_args.append(t)
+            else:
+                type_args.append(NoneType())
+        return self.chk.named_generic_type("builtins.slice", type_args)
 
     def visit_list_comprehension(self, e: ListComprehension) -> Type:
         return self.check_generator_or_comprehension(
@@ -4716,8 +5660,13 @@ def visit_set_comprehension(self, e: SetComprehension) -> Type:
 
     def visit_generator_expr(self, e: GeneratorExpr) -> Type:
         # If any of the comprehensions use async for, the expression will return an async generator
-        # object, or if the left-side expression uses await.
-        if any(e.is_async) or has_await_expression(e.left_expr):
+        # object, or await is used anywhere but in the leftmost sequence.
+        if (
+            any(e.is_async)
+            or has_await_expression(e.left_expr)
+            or any(has_await_expression(sequence) for sequence in e.sequences[1:])
+            or any(has_await_expression(cond) for condlist in e.condlists for cond in condlist)
+        ):
             typ = "typing.AsyncGenerator"
             # received type is always None in async generator expressions
             additional_args: list[Type] = [NoneType()]
@@ -4746,7 +5695,7 @@ def check_generator_or_comprehension(
             tv = TypeVarType(
                 "T",
                 "T",
-                id=-1,
+                id=TypeVarId(-1, namespace="<genexp>"),
                 values=[],
                 upper_bound=self.object_type(),
                 default=AnyType(TypeOfAny.from_omitted_generics),
@@ -4773,7 +5722,7 @@ def visit_dictionary_comprehension(self, e: DictionaryComprehension) -> Type:
             ktdef = TypeVarType(
                 "KT",
                 "KT",
-                id=-1,
+                id=TypeVarId(-1, namespace="<dict>"),
                 values=[],
                 upper_bound=self.object_type(),
                 default=AnyType(TypeOfAny.from_omitted_generics),
@@ -4781,7 +5730,7 @@ def visit_dictionary_comprehension(self, e: DictionaryComprehension) -> Type:
             vtdef = TypeVarType(
                 "VT",
                 "VT",
-                id=-2,
+                id=TypeVarId(-2, namespace="<dict>"),
                 values=[],
                 upper_bound=self.object_type(),
                 default=AnyType(TypeOfAny.from_omitted_generics),
@@ -4812,6 +5761,14 @@ def check_for_comp(self, e: GeneratorExpr | DictionaryComprehension) -> None:
                 _, sequence_type = self.chk.analyze_async_iterable_item_type(sequence)
             else:
                 _, sequence_type = self.chk.analyze_iterable_item_type(sequence)
+                if (
+                    isinstance(get_proper_type(sequence_type), UninhabitedType)
+                    and isinstance(index, NameExpr)
+                    and index.name == "_"
+                ):
+                    # To preserve backward compatibility, avoid inferring Never for "_"
+                    sequence_type = AnyType(TypeOfAny.special_form)
+
             self.chk.analyze_index_variables(index, sequence_type, True, e)
             for condition in conditions:
                 self.accept(condition)
@@ -4855,7 +5812,7 @@ def visit_conditional_expr(self, e: ConditionalExpr, allow_none_return: bool = F
             else_map, e.else_expr, context=ctx, allow_none_return=allow_none_return
         )
 
-        if not mypy.checker.is_valid_inferred_type(if_type):
+        if not mypy.checker.is_valid_inferred_type(if_type, self.chk.options):
             # Analyze the right branch disregarding the left branch.
             else_type = full_context_else_type
             # we want to keep the narrowest value of else_type for union'ing the branches
@@ -4893,15 +5850,20 @@ def visit_conditional_expr(self, e: ConditionalExpr, allow_none_return: bool = F
                 allow_none_return=allow_none_return,
             )
 
-        # Only create a union type if the type context is a union, to be mostly
-        # compatible with older mypy versions where we always did a join.
-        #
-        # TODO: Always create a union or at least in more cases?
-        if isinstance(get_proper_type(self.type_context[-1]), UnionType):
-            res: Type = make_simplified_union([if_type, full_context_else_type])
-        else:
-            res = join.join_types(if_type, else_type)
+        # In most cases using if_type as a context for right branch gives better inferred types.
+        # This is however not the case for literal types, so use the full context instead.
+        if is_literal_type_like(full_context_else_type) and not is_literal_type_like(else_type):
+            else_type = full_context_else_type
 
+        res: Type = make_simplified_union([if_type, else_type])
+        if has_uninhabited_component(res) and not isinstance(
+            get_proper_type(self.type_context[-1]), UnionType
+        ):
+            # In rare cases with empty collections join may give a better result.
+            alternative = join.join_types(if_type, else_type)
+            p_alt = get_proper_type(alternative)
+            if not isinstance(p_alt, Instance) or p_alt.type.fullname != "builtins.object":
+                res = alternative
         return res
 
     def analyze_cond_branch(
@@ -4910,12 +5872,15 @@ def analyze_cond_branch(
         node: Expression,
         context: Type | None,
         allow_none_return: bool = False,
+        suppress_unreachable_errors: bool = True,
     ) -> Type:
         with self.chk.binder.frame_context(can_skip=True, fall_through=0):
             if map is None:
                 # We still need to type check node, in case we want to
-                # process it for isinstance checks later
-                self.accept(node, type_context=context, allow_none_return=allow_none_return)
+                # process it for isinstance checks later. Since the branch was
+                # determined to be unreachable, any errors should be suppressed.
+                with self.msg.filter_errors(filter_errors=suppress_unreachable_errors):
+                    self.accept(node, type_context=context, allow_none_return=allow_none_return)
                 return UninhabitedType()
             self.chk.push_type_map(map)
             return self.accept(node, type_context=context, allow_none_return=allow_none_return)
@@ -4993,6 +5958,12 @@ def named_type(self, name: str) -> Instance:
         """
         return self.chk.named_type(name)
 
+    def type_alias_type_type(self) -> Instance:
+        """Returns a `typing.TypeAliasType` or `typing_extensions.TypeAliasType`."""
+        if self.chk.options.python_version >= (3, 12):
+            return self.named_type("typing.TypeAliasType")
+        return self.named_type("typing_extensions.TypeAliasType")
+
     def is_valid_var_arg(self, typ: Type) -> bool:
         """Is a type valid as a *args argument?"""
         typ = get_proper_type(typ)
@@ -5149,6 +6120,7 @@ def visit_yield_from_expr(self, e: YieldFromExpr, allow_none_return: bool = Fals
             generic_generator_type = self.chk.named_generic_type(
                 "typing.Generator", [any_type, any_type, any_type]
             )
+            generic_generator_type.set_line(e)
             iter_type, _ = self.check_method_call_by_name(
                 "__iter__", subexpr_type, [], [], context=generic_generator_type
             )
@@ -5177,17 +6149,7 @@ def visit_yield_from_expr(self, e: YieldFromExpr, allow_none_return: bool = Fals
 
         # Determine the type of the entire yield from expression.
         iter_type = get_proper_type(iter_type)
-        if isinstance(iter_type, Instance) and iter_type.type.fullname == "typing.Generator":
-            expr_type = self.chk.get_generator_return_type(iter_type, False)
-        else:
-            # Non-Generators don't return anything from `yield from` expressions.
-            # However special-case Any (which might be produced by an error).
-            actual_item_type = get_proper_type(actual_item_type)
-            if isinstance(actual_item_type, AnyType):
-                expr_type = AnyType(TypeOfAny.from_another_any, source_any=actual_item_type)
-            else:
-                # Treat `Iterator[X]` as a shorthand for `Generator[X, None, Any]`.
-                expr_type = NoneType()
+        expr_type = self.chk.get_generator_return_type(iter_type, is_coroutine=False)
 
         if not allow_none_return and isinstance(get_proper_type(expr_type), NoneType):
             self.chk.msg.does_not_return_value(None, e)
@@ -5197,6 +6159,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:
@@ -5254,14 +6225,12 @@ def bool_type(self) -> Instance:
         return self.named_type("builtins.bool")
 
     @overload
-    def narrow_type_from_binder(self, expr: Expression, known_type: Type) -> Type:
-        ...
+    def narrow_type_from_binder(self, expr: Expression, known_type: Type) -> Type: ...
 
     @overload
     def narrow_type_from_binder(
         self, expr: Expression, known_type: Type, skip_non_overlapping: bool
-    ) -> Type | None:
-        ...
+    ) -> Type | None: ...
 
     def narrow_type_from_binder(
         self, expr: Expression, known_type: Type, skip_non_overlapping: bool = False
@@ -5284,9 +6253,35 @@ def narrow_type_from_binder(
                     known_type, restriction, prohibit_none_typevar_overlap=True
                 ):
                     return None
-                return narrow_declared_type(known_type, restriction)
+                narrowed = narrow_declared_type(known_type, restriction)
+                if isinstance(get_proper_type(narrowed), UninhabitedType):
+                    # If we hit this case, it means that we can't reliably mark the code as
+                    # unreachable, but the resulting type can't be expressed in type system.
+                    # Falling back to restriction is more intuitive in most cases.
+                    return restriction
+                return narrowed
         return known_type
 
+    def has_abstract_type_part(self, caller_type: ProperType, callee_type: ProperType) -> bool:
+        # TODO: support other possible types here
+        if isinstance(caller_type, TupleType) and isinstance(callee_type, TupleType):
+            return any(
+                self.has_abstract_type(get_proper_type(caller), get_proper_type(callee))
+                for caller, callee in zip(caller_type.items, callee_type.items)
+            )
+        return self.has_abstract_type(caller_type, callee_type)
+
+    def has_abstract_type(self, caller_type: ProperType, callee_type: ProperType) -> bool:
+        return (
+            isinstance(caller_type, FunctionLike)
+            and isinstance(callee_type, TypeType)
+            and caller_type.is_type_obj()
+            and (caller_type.type_object().is_abstract or caller_type.type_object().is_protocol)
+            and isinstance(callee_type.item, Instance)
+            and (callee_type.item.type.is_abstract or callee_type.item.type.is_protocol)
+            and not self.chk.allow_abstract_call
+        )
+
 
 def has_any_type(t: Type, ignore_in_type_obj: bool = False) -> bool:
     """Whether t contains an Any type"""
@@ -5396,17 +6391,8 @@ def __init__(self) -> None:
         super().__init__(types.ANY_STRATEGY)
 
     def visit_callable_type(self, t: CallableType) -> bool:
-        return self.query_types(t.arg_types) or t.accept(HasTypeVarQuery())
-
-
-class HasTypeVarQuery(types.BoolTypeQuery):
-    """Visitor for querying whether a type has a type variable component."""
-
-    def __init__(self) -> None:
-        super().__init__(types.ANY_STRATEGY)
-
-    def visit_type_var(self, t: TypeVarType) -> bool:
-        return True
+        # TODO: we need to check only for type variables of original callable.
+        return self.query_types(t.arg_types) or has_type_vars(t)
 
 
 def has_erased_component(t: Type | None) -> bool:
@@ -5595,8 +6581,8 @@ def merge_typevars_in_callables_by_name(
             for tv in target.variables:
                 name = tv.fullname
                 if name not in unique_typevars:
-                    # TODO(PEP612): fix for ParamSpecType
-                    if isinstance(tv, ParamSpecType):
+                    # TODO: support ParamSpecType and TypeVarTuple.
+                    if isinstance(tv, (ParamSpecType, TypeVarTupleType)):
                         continue
                     assert isinstance(tv, TypeVarType)
                     unique_typevars[name] = tv
@@ -5675,3 +6661,12 @@ def get_partial_instance_type(t: Type | None) -> PartialType | None:
     if t is None or not isinstance(t, PartialType) or t.type is None:
         return None
     return t
+
+
+def is_type_type_context(context: Type | None) -> bool:
+    context = get_proper_type(context)
+    if isinstance(context, TypeType):
+        return True
+    if isinstance(context, UnionType):
+        return any(is_type_type_context(item) for item in context.items)
+    return False
diff --git a/mypy/checkmember.py b/mypy/checkmember.py
index c2c6b3555805..cc104fed0752 100644
--- a/mypy/checkmember.py
+++ b/mypy/checkmember.py
@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Sequence, cast
+from collections.abc import Sequence
+from typing import Callable, TypeVar, cast
 
-from mypy import meet, message_registry, subtypes
+from mypy import message_registry, state, subtypes
+from mypy.checker_shared import TypeCheckerSharedApi
 from mypy.erasetype import erase_typevars
 from mypy.expandtype import (
     expand_self_type,
@@ -17,15 +19,17 @@
     ARG_POS,
     ARG_STAR,
     ARG_STAR2,
+    EXCLUDED_ENUM_ATTRIBUTES,
     SYMBOL_FUNCBASE_TYPES,
     Context,
     Decorator,
+    Expression,
     FuncBase,
     FuncDef,
     IndexExpr,
     MypyFile,
+    NameExpr,
     OverloadedFuncDef,
-    SymbolNode,
     SymbolTable,
     TempNode,
     TypeAlias,
@@ -37,17 +41,17 @@
 from mypy.plugin import AttributeContext
 from mypy.typeops import (
     bind_self,
-    class_callable,
     erase_to_bound,
+    freeze_all_type_vars,
     function_type,
+    get_all_type_vars,
     get_type_vars,
     make_simplified_union,
     supported_self_type,
     tuple_fallback,
-    type_object_type_from_function,
+    type_object_type,
 )
 from mypy.types import (
-    ENUM_REMOVED_PROPS,
     AnyType,
     CallableType,
     DeletedType,
@@ -70,12 +74,6 @@
     UnionType,
     get_proper_type,
 )
-from mypy.typetraverser import TypeTraverserVisitor
-
-if TYPE_CHECKING:  # import for forward declaration only
-    import mypy.checker
-
-from mypy import state
 
 
 class MemberContext:
@@ -86,17 +84,19 @@ class MemberContext:
 
     def __init__(
         self,
+        *,
         is_lvalue: bool,
         is_super: bool,
         is_operator: bool,
         original_type: Type,
         context: Context,
-        msg: MessageBuilder,
-        chk: mypy.checker.TypeChecker,
-        self_type: Type | None,
+        chk: TypeCheckerSharedApi,
+        self_type: Type | None = None,
         module_symbol_table: SymbolTable | None = None,
         no_deferral: bool = False,
         is_self: bool = False,
+        rvalue: Expression | None = None,
+        suppress_errors: bool = False,
     ) -> None:
         self.is_lvalue = is_lvalue
         self.is_super = is_super
@@ -104,11 +104,15 @@ def __init__(
         self.original_type = original_type
         self.self_type = self_type or original_type
         self.context = context  # Error context
-        self.msg = msg
         self.chk = chk
+        self.msg = chk.msg
         self.module_symbol_table = module_symbol_table
         self.no_deferral = no_deferral
         self.is_self = is_self
+        if rvalue is not None:
+            assert is_lvalue
+        self.rvalue = rvalue
+        self.suppress_errors = suppress_errors
 
     def named_type(self, name: str) -> Instance:
         return self.chk.named_type(name)
@@ -116,31 +120,36 @@ def named_type(self, name: str) -> Instance:
     def not_ready_callback(self, name: str, context: Context) -> None:
         self.chk.handle_cannot_determine_type(name, context)
 
+    def fail(self, msg: str) -> None:
+        if not self.suppress_errors:
+            self.msg.fail(msg, self.context)
+
     def copy_modified(
         self,
         *,
-        messages: MessageBuilder | None = None,
         self_type: Type | None = None,
         is_lvalue: bool | None = None,
+        original_type: Type | None = None,
     ) -> MemberContext:
         mx = MemberContext(
-            self.is_lvalue,
-            self.is_super,
-            self.is_operator,
-            self.original_type,
-            self.context,
-            self.msg,
-            self.chk,
-            self.self_type,
-            self.module_symbol_table,
-            self.no_deferral,
+            is_lvalue=self.is_lvalue,
+            is_super=self.is_super,
+            is_operator=self.is_operator,
+            original_type=self.original_type,
+            context=self.context,
+            chk=self.chk,
+            self_type=self.self_type,
+            module_symbol_table=self.module_symbol_table,
+            no_deferral=self.no_deferral,
+            rvalue=self.rvalue,
+            suppress_errors=self.suppress_errors,
         )
-        if messages is not None:
-            mx.msg = messages
         if self_type is not None:
             mx.self_type = self_type
         if is_lvalue is not None:
             mx.is_lvalue = is_lvalue
+        if original_type is not None:
+            mx.original_type = original_type
         return mx
 
 
@@ -148,19 +157,20 @@ def analyze_member_access(
     name: str,
     typ: Type,
     context: Context,
+    *,
     is_lvalue: bool,
     is_super: bool,
     is_operator: bool,
-    msg: MessageBuilder,
-    *,
     original_type: Type,
-    chk: mypy.checker.TypeChecker,
+    chk: TypeCheckerSharedApi,
     override_info: TypeInfo | None = None,
     in_literal_context: bool = False,
     self_type: Type | None = None,
     module_symbol_table: SymbolTable | None = None,
     no_deferral: bool = False,
     is_self: bool = False,
+    rvalue: Expression | None = None,
+    suppress_errors: bool = False,
 ) -> Type:
     """Return the type of attribute 'name' of 'typ'.
 
@@ -179,24 +189,33 @@ def analyze_member_access(
     of 'original_type'. 'original_type' is always preserved as the 'typ' type used in
     the initial, non-recursive call. The 'self_type' is a component of 'original_type'
     to which generic self should be bound (a narrower type that has a fallback to instance).
-    Currently this is used only for union types.
+    Currently, this is used only for union types.
 
-    'module_symbol_table' is passed to this function if 'typ' is actually a module
+    'module_symbol_table' is passed to this function if 'typ' is actually a module,
     and we want to keep track of the available attributes of the module (since they
     are not available via the type object directly)
+
+    'rvalue' can be provided optionally to infer better setter type when is_lvalue is True,
+    most notably this helps for descriptors with overloaded __set__() method.
+
+    'suppress_errors' will skip any logic that is only needed to generate error messages.
+    Note that this more of a performance optimization, one should not rely on this to not
+    show any messages, as some may be show e.g. by callbacks called here,
+    use msg.filter_errors(), if needed.
     """
     mx = MemberContext(
-        is_lvalue,
-        is_super,
-        is_operator,
-        original_type,
-        context,
-        msg,
+        is_lvalue=is_lvalue,
+        is_super=is_super,
+        is_operator=is_operator,
+        original_type=original_type,
+        context=context,
         chk=chk,
         self_type=self_type,
         module_symbol_table=module_symbol_table,
         no_deferral=no_deferral,
         is_self=is_self,
+        rvalue=rvalue,
+        suppress_errors=suppress_errors,
     )
     result = _analyze_member_access(name, typ, mx, override_info)
     possible_literal = get_proper_type(result)
@@ -244,7 +263,8 @@ def _analyze_member_access(
             )
         return _analyze_member_access(name, typ.upper_bound, mx, override_info)
     elif isinstance(typ, DeletedType):
-        mx.msg.deleted_as_rvalue(typ, mx.context)
+        if not mx.suppress_errors:
+            mx.msg.deleted_as_rvalue(typ, mx.context)
         return AnyType(TypeOfAny.from_error)
     return report_missing_attribute(mx.original_type, typ, name, mx)
 
@@ -260,7 +280,9 @@ def may_be_awaitable_attribute(
         aw_type = mx.chk.get_precise_awaitable_type(typ, local_errors)
         if aw_type is None:
             return False
-        _ = _analyze_member_access(name, aw_type, mx, override_info)
+        _ = _analyze_member_access(
+            name, aw_type, mx.copy_modified(self_type=aw_type), override_info
+        )
         return not local_errors.has_new_errors()
 
 
@@ -271,11 +293,13 @@ def report_missing_attribute(
     mx: MemberContext,
     override_info: TypeInfo | None = None,
 ) -> Type:
-    res_type = mx.msg.has_no_attr(original_type, typ, name, mx.context, mx.module_symbol_table)
+    if mx.suppress_errors:
+        return AnyType(TypeOfAny.from_error)
+    error_code = mx.msg.has_no_attr(original_type, typ, name, mx.context, mx.module_symbol_table)
     if not mx.msg.prefer_simple_messages():
         if may_be_awaitable_attribute(name, typ, mx, override_info):
-            mx.msg.possible_missing_await(mx.context)
-    return res_type
+            mx.msg.possible_missing_await(mx.context, error_code)
+    return AnyType(TypeOfAny.from_error)
 
 
 # The several functions that follow implement analyze_member_access for various
@@ -285,53 +309,64 @@ def report_missing_attribute(
 def analyze_instance_member_access(
     name: str, typ: Instance, mx: MemberContext, override_info: TypeInfo | None
 ) -> Type:
-    if name == "__init__" and not mx.is_super:
-        # Accessing __init__ in statically typed code would compromise
-        # type safety unless used via super().
-        mx.msg.fail(message_registry.CANNOT_ACCESS_INIT, mx.context)
-        return AnyType(TypeOfAny.from_error)
-
-    # The base object has an instance type.
-
     info = typ.type
     if override_info:
         info = override_info
 
+    method = info.get_method(name)
+
+    if name == "__init__" and not mx.is_super and not info.is_final:
+        if not method or not method.is_final:
+            # Accessing __init__ in statically typed code would compromise
+            # type safety unless used via super() or the method/class is final.
+            mx.fail(message_registry.CANNOT_ACCESS_INIT)
+            return AnyType(TypeOfAny.from_error)
+
+    # The base object has an instance type.
+
     if (
         state.find_occurrences
         and info.name == state.find_occurrences[0]
         and name == state.find_occurrences[1]
+        and not mx.suppress_errors
     ):
         mx.msg.note("Occurrence of '{}.{}'".format(*state.find_occurrences), mx.context)
 
     # Look up the member. First look up the method dictionary.
-    method = info.get_method(name)
     if method and not isinstance(method, Decorator):
-        if mx.is_super:
+        if mx.is_super and not mx.suppress_errors:
             validate_super_call(method, mx)
 
         if method.is_property:
             assert isinstance(method, OverloadedFuncDef)
-            first_item = method.items[0]
-            assert isinstance(first_item, Decorator)
-            return analyze_var(name, first_item.var, typ, info, mx)
-        if mx.is_lvalue:
+            getter = method.items[0]
+            assert isinstance(getter, Decorator)
+            if mx.is_lvalue and (len(items := method.items) > 1):
+                mx.chk.warn_deprecated(items[1], mx.context)
+            return analyze_var(name, getter.var, typ, mx)
+
+        if mx.is_lvalue and not mx.suppress_errors:
             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
+        if not isinstance(method, OverloadedFuncDef):
+            signature = function_type(method, mx.named_type("builtins.function"))
         else:
-            if name != "__call__":
-                # TODO: use proper treatment of special methods on unions instead
-                #       of this hack here and below (i.e. mx.self_type).
-                dispatched_type = meet.meet_types(mx.original_type, typ)
+            if method.type is None:
+                # Overloads may be not ready if they are decorated. Handle this in same
+                # manner as we would handle a regular decorated function: defer if possible.
+                if not mx.no_deferral and method.items:
+                    mx.not_ready_callback(method.name, mx.context)
+                return AnyType(TypeOfAny.special_form)
+            assert isinstance(method.type, Overloaded)
+            signature = method.type
+        signature = freshen_all_functions_type_vars(signature)
+        if not method.is_static:
+            if isinstance(method, (FuncDef, OverloadedFuncDef)) and method.is_trivial_self:
+                signature = bind_self_fast(signature, mx.self_type)
+            else:
                 signature = check_self_arg(
-                    signature, dispatched_type, method.is_class, mx.context, name, mx.msg
+                    signature, mx.self_type, method.is_class, mx.context, name, mx.msg
                 )
-            signature = bind_self(signature, mx.self_type, is_classmethod=method.is_class)
+                signature = bind_self(signature, mx.self_type, is_classmethod=method.is_class)
         # TODO: should we skip these steps for static methods as well?
         # Since generic static methods should not be allowed.
         typ = map_instance_to_supertype(typ, method.info)
@@ -347,19 +382,15 @@ def validate_super_call(node: FuncBase, mx: MemberContext) -> None:
     unsafe_super = False
     if isinstance(node, FuncDef) and node.is_trivial_body:
         unsafe_super = True
-        impl = node
     elif isinstance(node, OverloadedFuncDef):
         if node.impl:
             impl = node.impl if isinstance(node.impl, FuncDef) else node.impl.func
             unsafe_super = impl.is_trivial_body
+        elif not node.is_property and node.items:
+            assert isinstance(node.items[0], Decorator)
+            unsafe_super = node.items[0].func.is_trivial_body
     if unsafe_super:
-        ret_type = (
-            impl.type.ret_type
-            if isinstance(impl.type, CallableType)
-            else AnyType(TypeOfAny.unannotated)
-        )
-        if not subtypes.is_subtype(NoneType(), ret_type):
-            mx.msg.unsafe_super(node.name, node.info.name, mx.context)
+        mx.msg.unsafe_super(node.name, node.info.name, mx.context)
 
 
 def analyze_type_callable_member_access(name: str, typ: FunctionLike, mx: MemberContext) -> Type:
@@ -388,7 +419,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 +465,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)
@@ -484,13 +519,18 @@ def analyze_member_var_access(
     original_type is the type of E in the expression E.var
     """
     # It was not a method. Try looking up a variable.
-    v = lookup_member_var_or_accessor(info, name, mx.is_lvalue)
+    node = info.get(name)
+    v = node.node if node else None
+
+    mx.chk.warn_deprecated(v, mx.context)
 
     vv = v
+    is_trivial_self = False
     if isinstance(vv, Decorator):
         # The associated Var node of a decorator contains the type.
         v = vv.var
-        if mx.is_super:
+        is_trivial_self = vv.func.is_trivial_self and not vv.decorators
+        if mx.is_super and not mx.suppress_errors:
             validate_super_call(vv.func, mx)
 
     if isinstance(vv, TypeInfo):
@@ -521,12 +561,14 @@ def analyze_member_var_access(
         if mx.is_lvalue and not mx.chk.get_final_context():
             check_final_member(name, info, mx.msg, mx.context)
 
-        return analyze_var(name, v, itype, info, mx, implicit=implicit)
+        return analyze_var(name, v, itype, mx, implicit=implicit, is_trivial_self=is_trivial_self)
     elif isinstance(v, FuncDef):
         assert False, "Did not expect a function"
     elif isinstance(v, MypyFile):
         mx.chk.module_refs.add(v.fullname)
         return mx.chk.expr_checker.module_type(v)
+    elif isinstance(v, TypeVarExpr):
+        return mx.chk.named_type("typing.TypeVar")
     elif (
         not v
         and name not in ["__getattr__", "__setattr__", "__getattribute__"]
@@ -545,12 +587,7 @@ def analyze_member_var_access(
                 # that the attribute exists
                 if method and method.info.fullname != "builtins.object":
                     bound_method = analyze_decorator_or_funcbase_access(
-                        defn=method,
-                        itype=itype,
-                        info=info,
-                        self_type=mx.self_type,
-                        name=method_name,
-                        mx=mx,
+                        defn=method, itype=itype, name=method_name, mx=mx
                     )
                     typ = map_instance_to_supertype(itype, method.info)
                     getattr_type = get_proper_type(expand_type_by_instance(bound_method, typ))
@@ -565,7 +602,11 @@ def analyze_member_var_access(
                     if hook:
                         result = hook(
                             AttributeContext(
-                                get_proper_type(mx.original_type), result, mx.context, mx.chk
+                                get_proper_type(mx.original_type),
+                                result,
+                                mx.is_lvalue,
+                                mx.context,
+                                mx.chk,
                             )
                         )
                     return result
@@ -575,9 +616,7 @@ def analyze_member_var_access(
                 bound_type = analyze_decorator_or_funcbase_access(
                     defn=setattr_meth,
                     itype=itype,
-                    info=info,
-                    self_type=mx.self_type,
-                    name=name,
+                    name="__setattr__",
                     mx=mx.copy_modified(is_lvalue=False),
                 )
                 typ = map_instance_to_supertype(itype, setattr_meth.info)
@@ -594,11 +633,23 @@ def analyze_member_var_access(
         if not itype.extra_attrs.mod_name:
             return itype.extra_attrs.attrs[name]
 
-    if mx.is_super:
+    if mx.is_super and not mx.suppress_errors:
         mx.msg.undefined_in_superclass(name, mx.context)
         return AnyType(TypeOfAny.from_error)
     else:
-        return report_missing_attribute(mx.original_type, itype, name, mx)
+        ret = report_missing_attribute(mx.original_type, itype, name, mx)
+        # Avoid paying double jeopardy if we can't find the member due to --no-implicit-reexport
+        if (
+            mx.module_symbol_table is not None
+            and name in mx.module_symbol_table
+            and not mx.module_symbol_table[name].module_public
+        ):
+            v = mx.module_symbol_table[name].node
+            e = NameExpr(name)
+            e.set_line(mx.context)
+            e.node = v
+            return mx.chk.expr_checker.analyze_ref_expr(e, lvalue=mx.is_lvalue)
+        return ret
 
 
 def check_final_member(name: str, info: TypeInfo, msg: MessageBuilder, ctx: Context) -> None:
@@ -617,9 +668,9 @@ def analyze_descriptor_access(descriptor_type: Type, mx: MemberContext) -> Type:
             (the type of ``f`` in ``a.f`` when ``f`` is a descriptor).
         mx: The current member access context.
     Return:
-        The return type of the appropriate ``__get__`` overload for the descriptor.
+        The return type of the appropriate ``__get__/__set__`` overload for the descriptor.
     """
-    instance_type = get_proper_type(mx.original_type)
+    instance_type = get_proper_type(mx.self_type)
     orig_descriptor_type = descriptor_type
     descriptor_type = get_proper_type(descriptor_type)
 
@@ -631,26 +682,35 @@ def analyze_descriptor_access(descriptor_type: Type, mx: MemberContext) -> Type:
     elif not isinstance(descriptor_type, Instance):
         return orig_descriptor_type
 
-    if not descriptor_type.type.has_readable_member("__get__"):
+    if not mx.is_lvalue and not descriptor_type.type.has_readable_member("__get__"):
+        return orig_descriptor_type
+
+    # We do this check first to accommodate for descriptors with only __set__ method.
+    # If there is no __set__, we type-check that the assigned value matches
+    # the return type of __get__. This doesn't match the python semantics,
+    # (which allow you to override the descriptor with any value), but preserves
+    # the type of accessing the attribute (even after the override).
+    if mx.is_lvalue and descriptor_type.type.has_readable_member("__set__"):
+        return analyze_descriptor_assign(descriptor_type, mx)
+
+    if mx.is_lvalue and not descriptor_type.type.has_readable_member("__get__"):
+        # This turned out to be not a descriptor after all.
         return orig_descriptor_type
 
     dunder_get = descriptor_type.type.get_method("__get__")
     if dunder_get is None:
-        mx.msg.fail(
+        mx.fail(
             message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(
                 descriptor_type.str_with_options(mx.msg.options)
-            ),
-            mx.context,
+            )
         )
         return AnyType(TypeOfAny.from_error)
 
     bound_method = analyze_decorator_or_funcbase_access(
         defn=dunder_get,
         itype=descriptor_type,
-        info=descriptor_type.type,
-        self_type=descriptor_type,
         name="__get__",
-        mx=mx,
+        mx=mx.copy_modified(self_type=descriptor_type),
     )
 
     typ = map_instance_to_supertype(descriptor_type, dunder_get.info)
@@ -690,23 +750,99 @@ def analyze_descriptor_access(descriptor_type: Type, mx: MemberContext) -> Type:
         callable_name=callable_name,
     )
 
+    mx.chk.check_deprecated(dunder_get, mx.context)
+    mx.chk.warn_deprecated_overload_item(
+        dunder_get, mx.context, target=inferred_dunder_get_type, selftype=descriptor_type
+    )
+
     inferred_dunder_get_type = get_proper_type(inferred_dunder_get_type)
     if isinstance(inferred_dunder_get_type, AnyType):
         # check_call failed, and will have reported an error
         return inferred_dunder_get_type
 
     if not isinstance(inferred_dunder_get_type, CallableType):
-        mx.msg.fail(
+        mx.fail(
             message_registry.DESCRIPTOR_GET_NOT_CALLABLE.format(
                 descriptor_type.str_with_options(mx.msg.options)
-            ),
-            mx.context,
+            )
         )
         return AnyType(TypeOfAny.from_error)
 
     return inferred_dunder_get_type.ret_type
 
 
+def analyze_descriptor_assign(descriptor_type: Instance, mx: MemberContext) -> Type:
+    instance_type = get_proper_type(mx.self_type)
+    dunder_set = descriptor_type.type.get_method("__set__")
+    if dunder_set is None:
+        mx.fail(
+            message_registry.DESCRIPTOR_SET_NOT_CALLABLE.format(
+                descriptor_type.str_with_options(mx.msg.options)
+            ).value
+        )
+        return AnyType(TypeOfAny.from_error)
+
+    bound_method = analyze_decorator_or_funcbase_access(
+        defn=dunder_set,
+        itype=descriptor_type,
+        name="__set__",
+        mx=mx.copy_modified(is_lvalue=False, self_type=descriptor_type),
+    )
+    typ = map_instance_to_supertype(descriptor_type, dunder_set.info)
+    dunder_set_type = expand_type_by_instance(bound_method, typ)
+
+    callable_name = mx.chk.expr_checker.method_fullname(descriptor_type, "__set__")
+    rvalue = mx.rvalue or TempNode(AnyType(TypeOfAny.special_form), context=mx.context)
+    dunder_set_type = mx.chk.expr_checker.transform_callee_type(
+        callable_name,
+        dunder_set_type,
+        [TempNode(instance_type, context=mx.context), rvalue],
+        [ARG_POS, ARG_POS],
+        mx.context,
+        object_type=descriptor_type,
+    )
+
+    # For non-overloaded setters, the result should be type-checked like a regular assignment.
+    # Hence, we first only try to infer the type by using the rvalue as type context.
+    type_context = rvalue
+    with mx.msg.filter_errors():
+        _, inferred_dunder_set_type = mx.chk.expr_checker.check_call(
+            dunder_set_type,
+            [TempNode(instance_type, context=mx.context), type_context],
+            [ARG_POS, ARG_POS],
+            mx.context,
+            object_type=descriptor_type,
+            callable_name=callable_name,
+        )
+
+    # And now we in fact type check the call, to show errors related to wrong arguments
+    # count, etc., replacing the type context for non-overloaded setters only.
+    inferred_dunder_set_type = get_proper_type(inferred_dunder_set_type)
+    if isinstance(inferred_dunder_set_type, CallableType):
+        type_context = TempNode(AnyType(TypeOfAny.special_form), context=mx.context)
+    mx.chk.expr_checker.check_call(
+        dunder_set_type,
+        [TempNode(instance_type, context=mx.context), type_context],
+        [ARG_POS, ARG_POS],
+        mx.context,
+        object_type=descriptor_type,
+        callable_name=callable_name,
+    )
+
+    # Search for possible deprecations:
+    mx.chk.check_deprecated(dunder_set, mx.context)
+    mx.chk.warn_deprecated_overload_item(
+        dunder_set, mx.context, target=inferred_dunder_set_type, selftype=descriptor_type
+    )
+
+    # In the following cases, a message already will have been recorded in check_call.
+    if (not isinstance(inferred_dunder_set_type, CallableType)) or (
+        len(inferred_dunder_set_type.arg_types) < 2
+    ):
+        return AnyType(TypeOfAny.from_error)
+    return inferred_dunder_set_type.arg_types[1]
+
+
 def is_instance_var(var: Var) -> bool:
     """Return if var is an instance variable according to PEP 526."""
     return (
@@ -723,80 +859,69 @@ def analyze_var(
     name: str,
     var: Var,
     itype: Instance,
-    info: TypeInfo,
     mx: MemberContext,
     *,
     implicit: bool = False,
+    is_trivial_self: bool = False,
 ) -> Type:
     """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
+    if is_trivial_self is True, we can use fast path for bind_self().
     """
     # Found a member variable.
+    original_itype = itype
     itype = map_instance_to_supertype(itype, var.info)
-    typ = var.type
+    if var.is_settable_property and mx.is_lvalue:
+        typ: Type | None = var.setter_type
+        if typ is None and var.is_ready:
+            # Existing synthetic properties may not set setter type. Fall back to getter.
+            typ = var.type
+    else:
+        typ = var.type
     if typ:
         if isinstance(typ, PartialType):
             return mx.chk.handle_partial_var_type(typ, mx.is_lvalue, var, mx.context)
-        if mx.is_lvalue and var.is_property and not var.is_settable_property:
-            # TODO allow setting attributes in subclass (although it is probably an error)
-            mx.msg.read_only_property(name, itype.type, mx.context)
-        if mx.is_lvalue and var.is_classvar:
-            mx.msg.cant_assign_to_classvar(name, mx.context)
-        t = freshen_all_functions_type_vars(typ)
-        if not (mx.is_self or mx.is_super) or supported_self_type(
-            get_proper_type(mx.original_type)
-        ):
-            t = expand_self_type(var, t, mx.original_type)
-        t = get_proper_type(expand_type_by_instance(t, itype))
-        freeze_all_type_vars(t)
-        result: Type = t
-        typ = get_proper_type(typ)
-        if (
-            var.is_initialized_in_class
-            and (not is_instance_var(var) or mx.is_operator)
-            and isinstance(typ, FunctionLike)
-            and not typ.is_type_obj()
-        ):
-            if mx.is_lvalue:
-                if var.is_property:
-                    if not var.is_settable_property:
-                        mx.msg.read_only_property(name, itype.type, mx.context)
-                else:
-                    mx.msg.cant_assign_to_method(mx.context)
-
-            if not var.is_staticmethod:
-                # Class-level function objects and classmethods become bound methods:
-                # the former to the instance, the latter to the class.
-                functype = typ
-                # Use meet to narrow original_type to the dispatched type.
-                # For example, assume
-                # * A.f: Callable[[A1], None] where A1 <: A (maybe A1 == A)
-                # * B.f: Callable[[B1], None] where B1 <: B (maybe B1 == B)
-                # * x: Union[A1, B1]
-                # In `x.f`, when checking `x` against A1 we assume x is compatible with A
-                # and similarly for B1 when checking against B
-                dispatched_type = meet.meet_types(mx.original_type, itype)
-                signature = freshen_all_functions_type_vars(functype)
-                bound = get_proper_type(expand_self_type(var, signature, mx.original_type))
-                assert isinstance(bound, FunctionLike)
-                signature = bound
-                signature = check_self_arg(
-                    signature, dispatched_type, var.is_classmethod, mx.context, name, mx.msg
-                )
-                signature = bind_self(signature, mx.self_type, var.is_classmethod)
-                expanded_signature = expand_type_by_instance(signature, itype)
-                freeze_all_type_vars(expanded_signature)
-                if var.is_property:
-                    # A property cannot have an overloaded type => the cast is fine.
-                    assert isinstance(expanded_signature, CallableType)
-                    result = expanded_signature.ret_type
+        if mx.is_lvalue and not mx.suppress_errors:
+            if var.is_property and not var.is_settable_property:
+                mx.msg.read_only_property(name, itype.type, mx.context)
+            if var.is_classvar:
+                mx.msg.cant_assign_to_classvar(name, mx.context)
+        # This is the most common case for variables, so start with this.
+        result = expand_without_binding(typ, var, itype, original_itype, mx)
+
+        # A non-None value indicates that we should actually bind self for this variable.
+        call_type: ProperType | None = None
+        if var.is_initialized_in_class and (not is_instance_var(var) or mx.is_operator):
+            typ = get_proper_type(typ)
+            if isinstance(typ, FunctionLike) and not typ.is_type_obj():
+                call_type = typ
+            elif var.is_property:
+                deco_mx = mx.copy_modified(original_type=typ, self_type=typ, is_lvalue=False)
+                call_type = get_proper_type(_analyze_member_access("__call__", typ, deco_mx))
+            else:
+                call_type = typ
+
+        # Bound variables with callable types are treated like methods
+        # (these are usually method aliases like __rmul__ = __mul__).
+        if isinstance(call_type, FunctionLike) and not call_type.is_type_obj():
+            if mx.is_lvalue and not var.is_property and not mx.suppress_errors:
+                mx.msg.cant_assign_to_method(mx.context)
+
+        # Bind the self type for each callable component (when needed).
+        if call_type and not var.is_staticmethod:
+            bound_items = []
+            for ct in call_type.items if isinstance(call_type, UnionType) else [call_type]:
+                p_ct = get_proper_type(ct)
+                if isinstance(p_ct, FunctionLike) and not p_ct.is_type_obj():
+                    item = expand_and_bind_callable(p_ct, var, itype, name, mx, is_trivial_self)
                 else:
-                    result = expanded_signature
+                    item = expand_without_binding(ct, var, itype, original_itype, mx)
+                bound_items.append(item)
+            result = UnionType.make_union(bound_items)
     else:
         if not var.is_ready and not mx.no_deferral:
             mx.not_ready_callback(var.name, mx.context)
@@ -804,34 +929,98 @@ def analyze_var(
         result = AnyType(TypeOfAny.special_form)
     fullname = f"{var.info.fullname}.{name}"
     hook = mx.chk.plugin.get_attribute_hook(fullname)
-    if result and not mx.is_lvalue and not implicit:
+    if result and not (implicit or var.info.is_protocol and is_instance_var(var)):
         result = analyze_descriptor_access(result, mx)
     if hook:
         result = hook(
-            AttributeContext(get_proper_type(mx.original_type), result, mx.context, mx.chk)
+            AttributeContext(
+                get_proper_type(mx.original_type), result, mx.is_lvalue, mx.context, mx.chk
+            )
         )
     return result
 
 
-def freeze_all_type_vars(member_type: Type) -> None:
-    member_type.accept(FreezeTypeVarsVisitor())
+def expand_without_binding(
+    typ: Type, var: Var, itype: Instance, original_itype: Instance, mx: MemberContext
+) -> Type:
+    typ = freshen_all_functions_type_vars(typ)
+    typ = expand_self_type_if_needed(typ, mx, var, original_itype)
+    expanded = expand_type_by_instance(typ, itype)
+    freeze_all_type_vars(expanded)
+    return expanded
 
 
-class FreezeTypeVarsVisitor(TypeTraverserVisitor):
-    def visit_callable_type(self, t: CallableType) -> None:
-        for v in t.variables:
-            v.id.meta_level = 0
-        super().visit_callable_type(t)
+def expand_and_bind_callable(
+    functype: FunctionLike,
+    var: Var,
+    itype: Instance,
+    name: str,
+    mx: MemberContext,
+    is_trivial_self: bool,
+) -> Type:
+    functype = freshen_all_functions_type_vars(functype)
+    typ = get_proper_type(expand_self_type(var, functype, mx.original_type))
+    assert isinstance(typ, FunctionLike)
+    if is_trivial_self:
+        typ = bind_self_fast(typ, mx.self_type)
+    else:
+        typ = check_self_arg(typ, mx.self_type, var.is_classmethod, mx.context, name, mx.msg)
+        typ = bind_self(typ, mx.self_type, var.is_classmethod)
+    expanded = expand_type_by_instance(typ, itype)
+    freeze_all_type_vars(expanded)
+    if not var.is_property:
+        return expanded
+    # TODO: a decorated property can result in Overloaded here.
+    assert isinstance(expanded, CallableType)
+    if var.is_settable_property and mx.is_lvalue and var.setter_type is not None:
+        # TODO: use check_call() to infer better type, same as for __set__().
+        return expanded.arg_types[0]
+    else:
+        return expanded.ret_type
 
 
-def lookup_member_var_or_accessor(info: TypeInfo, name: str, is_lvalue: bool) -> SymbolNode | None:
-    """Find the attribute/accessor node that refers to a member of a type."""
-    # TODO handle lvalues
-    node = info.get(name)
-    if node:
-        return node.node
+def expand_self_type_if_needed(
+    t: Type, mx: MemberContext, var: Var, itype: Instance, is_class: bool = False
+) -> Type:
+    """Expand special Self type in a backwards compatible manner.
+
+    This should ensure that mixing old-style and new-style self-types work
+    seamlessly. Also, re-bind new style self-types in subclasses if needed.
+    """
+    original = get_proper_type(mx.self_type)
+    if not (mx.is_self or mx.is_super):
+        repl = mx.self_type
+        if is_class:
+            if isinstance(original, TypeType):
+                repl = original.item
+            elif isinstance(original, CallableType):
+                # Problematic access errors should have been already reported.
+                repl = erase_typevars(original.ret_type)
+            else:
+                repl = itype
+        return expand_self_type(var, t, repl)
+    elif supported_self_type(
+        # Support compatibility with plain old style T -> T and Type[T] -> T only.
+        get_proper_type(mx.self_type),
+        allow_instances=False,
+        allow_callable=False,
+    ):
+        repl = mx.self_type
+        if is_class and isinstance(original, TypeType):
+            repl = original.item
+        return expand_self_type(var, t, repl)
+    elif (
+        mx.is_self
+        and 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 itype.type.self_type is not None
+        # ...unless `self` has an explicit non-trivial annotation.
+        and itype == mx.chk.scope.active_self_type()
+    ):
+        return expand_self_type(var, t, itype.type.self_type)
     else:
-        return None
+        return t
 
 
 def check_self_arg(
@@ -847,13 +1036,9 @@ def check_self_arg(
     For example if the method is defined as:
         class A:
             def f(self: S) -> T: ...
-    then for 'x.f' we check that meet(type(x), A) <: S. If the method is overloaded, we
-    select only overloads items that satisfy this requirement. If there are no matching
+    then for 'x.f' we check that type(x) <: S. If the method is overloaded, we select
+    only overloads items that satisfy this requirement. If there are no matching
     overloads, an error is generated.
-
-    Note: dispatched_arg_type uses a meet to select a relevant item in case if the
-    original type of 'x' is a union. This is done because several special methods
-    treat union types in ad-hoc manner, so we can't use MemberContext.self_type yet.
     """
     items = functype.items
     if not items:
@@ -871,7 +1056,18 @@ def f(self: S) -> T: ...
             return functype
         else:
             selfarg = get_proper_type(item.arg_types[0])
-            if subtypes.is_subtype(dispatched_arg_type, erase_typevars(erase_to_bound(selfarg))):
+            # This level of erasure matches the one in checker.check_func_def(),
+            # better keep these two checks consistent.
+            if subtypes.is_subtype(
+                dispatched_arg_type,
+                erase_typevars(erase_to_bound(selfarg)),
+                # This is to work around the fact that erased ParamSpec and TypeVarTuple
+                # callables are not always compatible with non-erased ones both ways.
+                always_covariant=any(
+                    not isinstance(tv, TypeVarType) for tv in get_all_type_vars(selfarg)
+                ),
+                ignore_pos_arg_names=True,
+            ):
                 new_items.append(item)
             elif isinstance(selfarg, ParamSpecType):
                 # TODO: This is not always right. What's the most reasonable thing to do here?
@@ -893,6 +1089,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,24 +1117,40 @@ 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
+
+    mx.chk.warn_deprecated(node.node, mx.context)
+
     is_decorated = isinstance(node.node, Decorator)
     is_method = is_decorated or isinstance(node.node, FuncBase)
-    if mx.is_lvalue:
+    if mx.is_lvalue and not mx.suppress_errors:
         if is_method:
             mx.msg.cant_assign_to_method(mx.context)
         if isinstance(node.node, TypeInfo):
-            mx.msg.fail(message_registry.CANNOT_ASSIGN_TO_TYPE, mx.context)
+            mx.fail(message_registry.CANNOT_ASSIGN_TO_TYPE)
 
     # Refuse class attribute access if slot defined
     if info.slots and name in info.slots:
-        mx.msg.fail(message_registry.CLASS_VAR_CONFLICTS_SLOTS.format(name), mx.context)
+        mx.fail(message_registry.CLASS_VAR_CONFLICTS_SLOTS.format(name))
 
     # If a final attribute was declared on `self` in `__init__`, then it
     # can't be accessed on the class object.
     if node.implicit and isinstance(node.node, Var) and node.node.is_final:
-        mx.msg.fail(
-            message_registry.CANNOT_ACCESS_FINAL_INSTANCE_ATTR.format(node.node.name), mx.context
-        )
+        mx.fail(message_registry.CANNOT_ACCESS_FINAL_INSTANCE_ATTR.format(node.node.name))
 
     # An assignment to final attribute on class object is also always an error,
     # independently of types.
@@ -986,6 +1200,7 @@ def analyze_class_attribute_access(
             def_vars = set(node.node.info.defn.type_vars)
             if not node.node.is_classvar and node.node.info.self_type:
                 def_vars.add(node.node.info.self_type)
+            # TODO: should we include ParamSpec etc. here (i.e. use get_all_type_vars)?
             typ_vars = set(get_type_vars(t))
             if def_vars & typ_vars:
                 # Exception: access on Type[...], including first argument of class methods is OK.
@@ -994,24 +1209,39 @@ def analyze_class_attribute_access(
                         message = message_registry.GENERIC_CLASS_VAR_ACCESS
                     else:
                         message = message_registry.GENERIC_INSTANCE_VAR_CLASS_ACCESS
-                    mx.msg.fail(message, mx.context)
-
+                    mx.fail(message)
+            t = expand_self_type_if_needed(t, mx, node.node, itype, is_class=True)
             # Erase non-mapped variables, but keep mapped ones, even if there is an error.
             # In the above example this means that we infer following types:
             #     C.x -> Any
             #     C[int].x -> int
-            t = get_proper_type(expand_self_type(node.node, t, itype))
             t = erase_typevars(expand_type_by_instance(t, isuper), {tv.id for tv in def_vars})
 
         is_classmethod = (is_decorated and cast(Decorator, node.node).func.is_class) or (
-            isinstance(node.node, FuncBase) and node.node.is_class
+            isinstance(node.node, SYMBOL_FUNCBASE_TYPES) and node.node.is_class
+        )
+        is_staticmethod = (is_decorated and cast(Decorator, node.node).func.is_static) or (
+            isinstance(node.node, SYMBOL_FUNCBASE_TYPES) and node.node.is_static
         )
         t = get_proper_type(t)
-        if isinstance(t, FunctionLike) and is_classmethod:
+        is_trivial_self = False
+        if isinstance(node.node, Decorator):
+            # Use fast path if there are trivial decorators like @classmethod or @property
+            is_trivial_self = node.node.func.is_trivial_self and not node.node.decorators
+        elif isinstance(node.node, (FuncDef, OverloadedFuncDef)):
+            is_trivial_self = node.node.is_trivial_self
+        if isinstance(t, FunctionLike) and is_classmethod and not is_trivial_self:
             t = check_self_arg(t, mx.self_type, False, mx.context, name, mx.msg)
         result = add_class_tvars(
-            t, isuper, is_classmethod, mx.self_type, original_vars=original_vars
+            t,
+            isuper,
+            is_classmethod,
+            is_staticmethod,
+            mx.self_type,
+            original_vars=original_vars,
+            is_trivial_self=is_trivial_self,
         )
+        # __set__ is not called on class objects.
         if not mx.is_lvalue:
             result = analyze_descriptor_access(result, mx)
 
@@ -1021,13 +1251,19 @@ def analyze_class_attribute_access(
         return AnyType(TypeOfAny.special_form)
 
     if isinstance(node.node, TypeVarExpr):
-        mx.msg.fail(
-            message_registry.CANNOT_USE_TYPEVAR_AS_EXPRESSION.format(info.name, name), mx.context
-        )
+        mx.fail(message_registry.CANNOT_USE_TYPEVAR_AS_EXPRESSION.format(info.name, name))
         return AnyType(TypeOfAny.from_error)
 
+    # TODO: some logic below duplicates analyze_ref_expr in checkexpr.py
     if isinstance(node.node, TypeInfo):
-        return type_object_type(node.node, mx.named_type)
+        if node.node.typeddict_type:
+            # We special-case TypedDict, because they don't define any constructor.
+            return mx.chk.expr_checker.typeddict_callable(node.node)
+        elif node.node.fullname == "types.NoneType":
+            # We special case NoneType, because its stub definition is not related to None.
+            return TypeType(NoneType())
+        else:
+            return type_object_type(node.node, mx.named_type)
 
     if isinstance(node.node, MypyFile):
         # Reference to a module object.
@@ -1046,13 +1282,13 @@ def analyze_class_attribute_access(
             mx.not_ready_callback(name, mx.context)
             return AnyType(TypeOfAny.from_error)
     else:
-        assert isinstance(node.node, FuncBase)
+        assert isinstance(node.node, SYMBOL_FUNCBASE_TYPES)
         typ = function_type(node.node, mx.named_type("builtins.function"))
         # Note: if we are accessing class method on class object, the cls argument is bound.
         # Annotated and/or explicit class methods go through other code paths above, for
         # unannotated implicit class methods we do this here.
         if node.node.is_class:
-            typ = bind_self(typ, is_classmethod=True)
+            typ = bind_self_fast(typ)
         return apply_class_attr_hook(mx, hook, typ)
 
 
@@ -1061,7 +1297,9 @@ def apply_class_attr_hook(
 ) -> Type | None:
     if hook:
         result = hook(
-            AttributeContext(get_proper_type(mx.original_type), result, mx.context, mx.chk)
+            AttributeContext(
+                get_proper_type(mx.original_type), result, mx.is_lvalue, mx.context, mx.chk
+            )
         )
     return result
 
@@ -1070,12 +1308,23 @@ def analyze_enum_class_attribute_access(
     itype: Instance, name: str, mx: MemberContext
 ) -> Type | None:
     # Skip these since Enum will remove it
-    if name in ENUM_REMOVED_PROPS:
+    if name in EXCLUDED_ENUM_ATTRIBUTES:
         return report_missing_attribute(mx.original_type, itype, name, mx)
-    # For other names surrendered by underscores, we don't make them Enum members
-    if name.startswith("__") and name.endswith("__") and name.replace("_", "") != "":
+    # Dunders and private names are not Enum members
+    if name.startswith("__") and name.replace("_", "") != "":
         return None
 
+    node = itype.type.get(name)
+    if node and node.type:
+        proper = get_proper_type(node.type)
+        # Support `A = nonmember(1)` function call and decorator.
+        if (
+            isinstance(proper, Instance)
+            and proper.type.fullname == "enum.nonmember"
+            and proper.args
+        ):
+            return proper.args[0]
+
     enum_literal = LiteralType(name, fallback=itype)
     return itype.copy_modified(last_known_value=enum_literal)
 
@@ -1087,9 +1336,12 @@ def analyze_typeddict_access(
         if isinstance(mx.context, IndexExpr):
             # Since we can get this during `a['key'] = ...`
             # it is safe to assume that the context is `IndexExpr`.
-            item_type = mx.chk.expr_checker.visit_typeddict_index_expr(
+            item_type, key_names = mx.chk.expr_checker.visit_typeddict_index_expr(
                 typ, mx.context.index, setitem=True
             )
+            assigned_readonly_keys = typ.readonly_keys & key_names
+            if assigned_readonly_keys and not mx.suppress_errors:
+                mx.msg.readonly_keys_mutated(assigned_readonly_keys, context=mx.context)
         else:
             # It can also be `a.__setitem__(...)` direct call.
             # In this case `item_type` can be `Any`,
@@ -1120,8 +1372,10 @@ def add_class_tvars(
     t: ProperType,
     isuper: Instance | None,
     is_classmethod: bool,
+    is_staticmethod: bool,
     original_type: Type,
     original_vars: Sequence[TypeVarLikeType] | None = None,
+    is_trivial_self: bool = False,
 ) -> Type:
     """Instantiate type variables during analyze_class_attribute_access,
     e.g T and Q in the following:
@@ -1138,9 +1392,11 @@ class B(A[str]): pass
         isuper: Current instance mapped to the superclass where method was defined, this
             is usually done by map_instance_to_supertype()
         is_classmethod: True if this method is decorated with @classmethod
+        is_staticmethod: True if this method is decorated with @staticmethod
         original_type: The value of the type B in the expression B.foo() or the corresponding
             component in case of a union (this is used to bind the self-types)
         original_vars: Type variables of the class callable on which the method was accessed
+        is_trivial_self: if True, we can use fast path for bind_self().
     Returns:
         Expanded method type with added type variables (when needed).
     """
@@ -1160,12 +1416,16 @@ class B(A[str]): pass
     # (i.e. appear in the return type of the class object on which the method was accessed).
     if isinstance(t, CallableType):
         tvars = original_vars if original_vars is not None else []
+        t = freshen_all_functions_type_vars(t)
         if is_classmethod:
-            t = freshen_all_functions_type_vars(t)
-            t = bind_self(t, original_type, is_classmethod=True)
+            if is_trivial_self:
+                t = bind_self_fast(t, original_type)
+            else:
+                t = bind_self(t, original_type, is_classmethod=True)
+        if is_classmethod or is_staticmethod:
             assert isuper is not None
             t = expand_type_by_instance(t, isuper)
-            freeze_all_type_vars(t)
+        freeze_all_type_vars(t)
         return t.copy_modified(variables=list(tvars) + list(t.variables))
     elif isinstance(t, Overloaded):
         return Overloaded(
@@ -1173,7 +1433,12 @@ class B(A[str]): pass
                 cast(
                     CallableType,
                     add_class_tvars(
-                        item, isuper, is_classmethod, original_type, original_vars=original_vars
+                        item,
+                        isuper,
+                        is_classmethod,
+                        is_staticmethod,
+                        original_type,
+                        original_vars=original_vars,
                     ),
                 )
                 for item in t.items
@@ -1184,84 +1449,8 @@ class B(A[str]): pass
     return t
 
 
-def type_object_type(info: TypeInfo, named_type: Callable[[str], Instance]) -> ProperType:
-    """Return the type of a type object.
-
-    For a generic type G with type variables T and S the type is generally of form
-
-      Callable[..., G[T, S]]
-
-    where ... are argument types for the __init__/__new__ method (without the self
-    argument). Also, the fallback type will be 'type' instead of 'function'.
-    """
-
-    # We take the type from whichever of __init__ and __new__ is first
-    # in the MRO, preferring __init__ if there is a tie.
-    init_method = info.get("__init__")
-    new_method = info.get("__new__")
-    if not init_method or not is_valid_constructor(init_method.node):
-        # Must be an invalid class definition.
-        return AnyType(TypeOfAny.from_error)
-    # There *should* always be a __new__ method except the test stubs
-    # lack it, so just copy init_method in that situation
-    new_method = new_method or init_method
-    if not is_valid_constructor(new_method.node):
-        # Must be an invalid class definition.
-        return AnyType(TypeOfAny.from_error)
-
-    # The two is_valid_constructor() checks ensure this.
-    assert isinstance(new_method.node, (SYMBOL_FUNCBASE_TYPES, Decorator))
-    assert isinstance(init_method.node, (SYMBOL_FUNCBASE_TYPES, Decorator))
-
-    init_index = info.mro.index(init_method.node.info)
-    new_index = info.mro.index(new_method.node.info)
-
-    fallback = info.metaclass_type or named_type("builtins.type")
-    if init_index < new_index:
-        method: FuncBase | Decorator = init_method.node
-        is_new = False
-    elif init_index > new_index:
-        method = new_method.node
-        is_new = True
-    else:
-        if init_method.node.info.fullname == "builtins.object":
-            # Both are defined by object.  But if we've got a bogus
-            # base class, we can't know for sure, so check for that.
-            if info.fallback_to_any:
-                # Construct a universal callable as the prototype.
-                any_type = AnyType(TypeOfAny.special_form)
-                sig = CallableType(
-                    arg_types=[any_type, any_type],
-                    arg_kinds=[ARG_STAR, ARG_STAR2],
-                    arg_names=["_args", "_kwds"],
-                    ret_type=any_type,
-                    fallback=named_type("builtins.function"),
-                )
-                return class_callable(sig, info, fallback, None, is_new=False)
-
-        # Otherwise prefer __init__ in a tie. It isn't clear that this
-        # is the right thing, but __new__ caused problems with
-        # typeshed (#5647).
-        method = init_method.node
-        is_new = False
-    # Construct callable type based on signature of __init__. Adjust
-    # return type and insert type arguments.
-    if isinstance(method, FuncBase):
-        t = function_type(method, fallback)
-    else:
-        assert isinstance(method.type, ProperType)
-        assert isinstance(method.type, FunctionLike)  # is_valid_constructor() ensures this
-        t = method.type
-    return type_object_type_from_function(t, info, method.info, fallback, is_new)
-
-
 def analyze_decorator_or_funcbase_access(
-    defn: Decorator | FuncBase,
-    itype: Instance,
-    info: TypeInfo,
-    self_type: Type | None,
-    name: str,
-    mx: MemberContext,
+    defn: Decorator | FuncBase, itype: Instance, name: str, mx: MemberContext
 ) -> Type:
     """Analyzes the type behind method access.
 
@@ -1269,20 +1458,47 @@ def analyze_decorator_or_funcbase_access(
     See: https://github.com/python/mypy/issues/10409
     """
     if isinstance(defn, Decorator):
-        return analyze_var(name, defn.var, itype, info, mx)
-    return bind_self(
-        function_type(defn, mx.chk.named_type("builtins.function")), original_type=self_type
-    )
+        return analyze_var(name, defn.var, itype, mx)
+    typ = function_type(defn, mx.chk.named_type("builtins.function"))
+    is_trivial_self = False
+    if isinstance(defn, Decorator):
+        # Use fast path if there are trivial decorators like @classmethod or @property
+        is_trivial_self = defn.func.is_trivial_self and not defn.decorators
+    elif isinstance(defn, (FuncDef, OverloadedFuncDef)):
+        is_trivial_self = defn.is_trivial_self
+    if is_trivial_self:
+        return bind_self_fast(typ, mx.self_type)
+    typ = check_self_arg(typ, mx.self_type, defn.is_class, mx.context, name, mx.msg)
+    return bind_self(typ, original_type=mx.self_type, is_classmethod=defn.is_class)
+
 
+F = TypeVar("F", bound=FunctionLike)
 
-def is_valid_constructor(n: SymbolNode | None) -> bool:
-    """Does this node represents a valid constructor method?
 
-    This includes normal functions, overloaded functions, and decorators
-    that return a callable type.
+def bind_self_fast(method: F, original_type: Type | None = None) -> F:
+    """Return a copy of `method`, with the type of its first parameter (usually
+    self or cls) bound to original_type.
+
+    This is a faster version of mypy.typeops.bind_self() that can be used for methods
+    with trivial self/cls annotations.
     """
-    if isinstance(n, FuncBase):
-        return True
-    if isinstance(n, Decorator):
-        return isinstance(get_proper_type(n.type), FunctionLike)
-    return False
+    if isinstance(method, Overloaded):
+        items = [bind_self_fast(c, original_type) for c in method.items]
+        return cast(F, Overloaded(items))
+    assert isinstance(method, CallableType)
+    if not method.arg_types:
+        # Invalid method, return something.
+        return cast(F, method)
+    if method.arg_kinds[0] in (ARG_STAR, ARG_STAR2):
+        # See typeops.py for details.
+        return cast(F, method)
+    original_type = get_proper_type(original_type)
+    if isinstance(original_type, CallableType) and original_type.is_type_obj():
+        original_type = TypeType.make_normalized(original_type.ret_type)
+    res = method.copy_modified(
+        arg_types=method.arg_types[1:],
+        arg_kinds=method.arg_kinds[1:],
+        arg_names=method.arg_names[1:],
+        bound_args=[original_type],
+    )
+    return cast(F, res)
diff --git a/mypy/checkpattern.py b/mypy/checkpattern.py
index e132a23ff55f..4cf7c1ca7862 100644
--- a/mypy/checkpattern.py
+++ b/mypy/checkpattern.py
@@ -3,11 +3,10 @@
 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
+from mypy.checker_shared import TypeCheckerSharedApi, TypeRange
 from mypy.checkmember import analyze_member_access
 from mypy.expandtype import expand_type_by_instance
 from mypy.join import join_types
@@ -46,11 +45,16 @@
     Type,
     TypedDictType,
     TypeOfAny,
+    TypeVarTupleType,
+    TypeVarType,
     UninhabitedType,
     UnionType,
+    UnpackType,
+    find_unpack_in_list,
     get_proper_type,
+    split_with_prefix_and_suffix,
 )
-from mypy.typevars import fill_typevars
+from mypy.typevars import fill_typevars, fill_typevars_with_any
 from mypy.visitor import PatternVisitor
 
 self_match_type_names: Final = [
@@ -87,7 +91,7 @@ class PatternChecker(PatternVisitor[PatternType]):
     """
 
     # Some services are provided by a TypeChecker instance.
-    chk: mypy.checker.TypeChecker
+    chk: TypeCheckerSharedApi
     # This is shared with TypeChecker, but stored also here for convenience.
     msg: MessageBuilder
     # Currently unused
@@ -108,7 +112,7 @@ class PatternChecker(PatternVisitor[PatternType]):
     options: Options
 
     def __init__(
-        self, chk: mypy.checker.TypeChecker, msg: MessageBuilder, plugin: Plugin, options: Options
+        self, chk: TypeCheckerSharedApi, msg: MessageBuilder, plugin: Plugin, options: Options
     ) -> None:
         self.chk = chk
         self.msg = msg
@@ -155,7 +159,8 @@ def visit_or_pattern(self, o: OrPattern) -> PatternType:
         for pattern in o.patterns:
             pattern_type = self.accept(pattern, current_type)
             pattern_types.append(pattern_type)
-            current_type = pattern_type.rest_type
+            if not is_uninhabited(pattern_type.type):
+                current_type = pattern_type.rest_type
 
         #
         # Collect the final type
@@ -184,7 +189,7 @@ def visit_or_pattern(self, o: OrPattern) -> PatternType:
                 capture_types[node].append((expr, typ))
 
         captures: dict[Expression, Type] = {}
-        for var, capture_list in capture_types.items():
+        for capture_list in capture_types.values():
             typ = UninhabitedType()
             for _, other in capture_list:
                 typ = join_types(typ, other)
@@ -199,7 +204,7 @@ def visit_value_pattern(self, o: ValuePattern) -> PatternType:
         typ = self.chk.expr_checker.accept(o.expr)
         typ = coerce_to_literal(typ)
         narrowed_type, rest_type = self.chk.conditional_types_with_intersection(
-            current_type, [get_type_range(typ)], o, default=current_type
+            current_type, [get_type_range(typ)], o, default=get_proper_type(typ)
         )
         if not isinstance(get_proper_type(narrowed_type), (LiteralType, UninhabitedType)):
             return PatternType(narrowed_type, UnionType.make_union([narrowed_type, rest_type]), {})
@@ -240,13 +245,29 @@ def visit_sequence_pattern(self, o: SequencePattern) -> PatternType:
         #
         # get inner types of original type
         #
+        unpack_index = None
         if isinstance(current_type, TupleType):
             inner_types = current_type.items
-            size_diff = len(inner_types) - required_patterns
-            if size_diff < 0:
-                return self.early_non_match()
-            elif size_diff > 0 and star_position is None:
-                return self.early_non_match()
+            unpack_index = find_unpack_in_list(inner_types)
+            if unpack_index is None:
+                size_diff = len(inner_types) - required_patterns
+                if size_diff < 0:
+                    return self.early_non_match()
+                elif size_diff > 0 and star_position is None:
+                    return self.early_non_match()
+            else:
+                normalized_inner_types = []
+                for it in inner_types:
+                    # Unfortunately, it is not possible to "split" the TypeVarTuple
+                    # into individual items, so we just use its upper bound for the whole
+                    # analysis instead.
+                    if isinstance(it, UnpackType) and isinstance(it.type, TypeVarTupleType):
+                        it = UnpackType(it.type.upper_bound)
+                    normalized_inner_types.append(it)
+                inner_types = normalized_inner_types
+                current_type = current_type.copy_modified(items=normalized_inner_types)
+                if len(inner_types) - 1 > required_patterns and star_position is None:
+                    return self.early_non_match()
         else:
             inner_type = self.get_sequence_type(current_type, o)
             if inner_type is None:
@@ -271,10 +292,10 @@ def visit_sequence_pattern(self, o: SequencePattern) -> PatternType:
             self.update_type_map(captures, type_map)
 
         new_inner_types = self.expand_starred_pattern_types(
-            contracted_new_inner_types, star_position, len(inner_types)
+            contracted_new_inner_types, star_position, len(inner_types), unpack_index is not None
         )
         rest_inner_types = self.expand_starred_pattern_types(
-            contracted_rest_inner_types, star_position, len(inner_types)
+            contracted_rest_inner_types, star_position, len(inner_types), unpack_index is not None
         )
 
         #
@@ -282,15 +303,14 @@ def visit_sequence_pattern(self, o: SequencePattern) -> PatternType:
         #
         new_type: Type
         rest_type: Type = current_type
-        if isinstance(current_type, TupleType):
+        if isinstance(current_type, TupleType) and unpack_index is None:
             narrowed_inner_types = []
             inner_rest_types = []
             for inner_type, new_inner_type in zip(inner_types, new_inner_types):
-                (
-                    narrowed_inner_type,
-                    inner_rest_type,
-                ) = self.chk.conditional_types_with_intersection(
-                    new_inner_type, [get_type_range(inner_type)], o, default=new_inner_type
+                (narrowed_inner_type, inner_rest_type) = (
+                    self.chk.conditional_types_with_intersection(
+                        inner_type, [get_type_range(new_inner_type)], o, default=inner_type
+                    )
                 )
                 narrowed_inner_types.append(narrowed_inner_type)
                 inner_rest_types.append(inner_rest_type)
@@ -302,17 +322,33 @@ def visit_sequence_pattern(self, o: SequencePattern) -> PatternType:
             if all(is_uninhabited(typ) for typ in inner_rest_types):
                 # All subpatterns always match, so we can apply negative narrowing
                 rest_type = TupleType(rest_inner_types, current_type.partial_fallback)
+            elif sum(not is_uninhabited(typ) for typ in inner_rest_types) == 1:
+                # Exactly one subpattern may conditionally match, the rest always match.
+                # We can apply negative narrowing to this one position.
+                rest_type = TupleType(
+                    [
+                        curr if is_uninhabited(rest) else rest
+                        for curr, rest in zip(inner_types, inner_rest_types)
+                    ],
+                    current_type.partial_fallback,
+                )
+        elif isinstance(current_type, TupleType):
+            # For variadic tuples it is too tricky to match individual items like for fixed
+            # tuples, so we instead try to narrow the entire type.
+            # TODO: use more precise narrowing when possible (e.g. for identical shapes).
+            new_tuple_type = TupleType(new_inner_types, current_type.partial_fallback)
+            new_type, rest_type = self.chk.conditional_types_with_intersection(
+                new_tuple_type, [get_type_range(current_type)], o, default=new_tuple_type
+            )
         else:
             new_inner_type = UninhabitedType()
             for typ in new_inner_types:
                 new_inner_type = join_types(new_inner_type, typ)
-            new_type = self.construct_sequence_child(current_type, new_inner_type)
-            if is_subtype(new_type, current_type):
-                new_type, _ = self.chk.conditional_types_with_intersection(
-                    current_type, [get_type_range(new_type)], o, default=current_type
-                )
+            if isinstance(current_type, TypeVarType):
+                new_bound = self.narrow_sequence_child(current_type.upper_bound, new_inner_type, o)
+                new_type = current_type.copy_modified(upper_bound=new_bound)
             else:
-                new_type = current_type
+                new_type = self.narrow_sequence_child(current_type, new_inner_type, o)
         return PatternType(new_type, rest_type, captures)
 
     def get_sequence_type(self, t: Type, context: Context) -> Type | None:
@@ -346,17 +382,45 @@ def contract_starred_pattern_types(
 
         If star_pos in None the types are returned unchanged.
         """
-        if star_pos is None:
-            return types
-        new_types = types[:star_pos]
-        star_length = len(types) - num_patterns
-        new_types.append(make_simplified_union(types[star_pos : star_pos + star_length]))
-        new_types += types[star_pos + star_length :]
-
-        return new_types
+        unpack_index = find_unpack_in_list(types)
+        if unpack_index is not None:
+            # Variadic tuples require "re-shaping" to match the requested pattern.
+            unpack = types[unpack_index]
+            assert isinstance(unpack, UnpackType)
+            unpacked = get_proper_type(unpack.type)
+            # This should be guaranteed by the normalization in the caller.
+            assert isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+            if star_pos is None:
+                missing = num_patterns - len(types) + 1
+                new_types = types[:unpack_index]
+                new_types += [unpacked.args[0]] * missing
+                new_types += types[unpack_index + 1 :]
+                return new_types
+            prefix, middle, suffix = split_with_prefix_and_suffix(
+                tuple([UnpackType(unpacked) if isinstance(t, UnpackType) else t for t in types]),
+                star_pos,
+                num_patterns - star_pos,
+            )
+            new_middle = []
+            for m in middle:
+                # The existing code expects the star item type, rather than the type of
+                # the whole tuple "slice".
+                if isinstance(m, UnpackType):
+                    new_middle.append(unpacked.args[0])
+                else:
+                    new_middle.append(m)
+            return list(prefix) + [make_simplified_union(new_middle)] + list(suffix)
+        else:
+            if star_pos is None:
+                return types
+            new_types = types[:star_pos]
+            star_length = len(types) - num_patterns
+            new_types.append(make_simplified_union(types[star_pos : star_pos + star_length]))
+            new_types += types[star_pos + star_length :]
+            return new_types
 
     def expand_starred_pattern_types(
-        self, types: list[Type], star_pos: int | None, num_types: int
+        self, types: list[Type], star_pos: int | None, num_types: int, original_unpack: bool
     ) -> list[Type]:
         """Undoes the contraction done by contract_starred_pattern_types.
 
@@ -365,6 +429,17 @@ def expand_starred_pattern_types(
         """
         if star_pos is None:
             return types
+        if original_unpack:
+            # In the case where original tuple type has an unpack item, it is not practical
+            # to coerce pattern type back to the original shape (and may not even be possible),
+            # so we only restore the type of the star item.
+            res = []
+            for i, t in enumerate(types):
+                if i != star_pos:
+                    res.append(t)
+                else:
+                    res.append(UnpackType(self.chk.named_generic_type("builtins.tuple", [t])))
+            return res
         new_types = types[:star_pos]
         star_length = num_types - len(types) + 1
         new_types += [types[star_pos]] * star_length
@@ -372,6 +447,16 @@ def expand_starred_pattern_types(
 
         return new_types
 
+    def narrow_sequence_child(self, outer_type: Type, inner_type: Type, ctx: Context) -> Type:
+        new_type = self.construct_sequence_child(outer_type, inner_type)
+        if is_subtype(new_type, outer_type):
+            new_type, _ = self.chk.conditional_types_with_intersection(
+                outer_type, [get_type_range(new_type)], ctx, default=outer_type
+            )
+        else:
+            new_type = outer_type
+        return new_type
+
     def visit_starred_pattern(self, o: StarredPattern) -> PatternType:
         captures: dict[Expression, Type] = {}
         if o.capture is not None:
@@ -423,7 +508,7 @@ def get_mapping_item_type(
             with self.msg.filter_errors() as local_errors:
                 result: Type | None = self.chk.expr_checker.visit_typeddict_index_expr(
                     mapping_type, key
-                )
+                )[0]
                 has_local_errors = local_errors.has_new_errors()
             # If we can't determine the type statically fall back to treating it as a normal
             # mapping
@@ -459,16 +544,21 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
             self.msg.fail(message_registry.CLASS_PATTERN_GENERIC_TYPE_ALIAS, o)
             return self.early_non_match()
         if isinstance(type_info, TypeInfo):
-            any_type = AnyType(TypeOfAny.implementation_artifact)
-            typ: Type = Instance(type_info, [any_type] * len(type_info.defn.type_vars))
+            typ: Type = fill_typevars_with_any(type_info)
         elif isinstance(type_info, TypeAlias):
             typ = type_info.target
+        elif (
+            isinstance(type_info, Var)
+            and type_info.type is not None
+            and isinstance(get_proper_type(type_info.type), AnyType)
+        ):
+            typ = type_info.type
         else:
             if isinstance(type_info, Var) and type_info.type is not None:
                 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(
@@ -505,10 +595,9 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
                         "__match_args__",
                         typ,
                         o,
-                        False,
-                        False,
-                        False,
-                        self.msg,
+                        is_lvalue=False,
+                        is_super=False,
+                        is_operator=False,
                         original_type=typ,
                         chk=self.chk,
                     )
@@ -571,10 +660,9 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
                         keyword,
                         narrowed_type,
                         pattern,
-                        False,
-                        False,
-                        False,
-                        self.msg,
+                        is_lvalue=False,
+                        is_super=False,
+                        is_operator=False,
                         original_type=new_type,
                         chk=self.chk,
                     )
@@ -604,7 +692,11 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
 
     def should_self_match(self, typ: Type) -> bool:
         typ = get_proper_type(typ)
-        if isinstance(typ, Instance) and typ.type.is_named_tuple:
+        if isinstance(typ, TupleType):
+            typ = typ.partial_fallback
+        if isinstance(typ, Instance) and typ.type.get("__match_args__") is not None:
+            # Named tuples and other subtypes of builtins that define __match_args__
+            # should not self match.
             return False
         for other in self.self_match_types:
             if is_subtype(typ, other):
@@ -612,6 +704,8 @@ def should_self_match(self, typ: Type) -> bool:
         return False
 
     def can_match_sequence(self, typ: ProperType) -> bool:
+        if isinstance(typ, AnyType):
+            return True
         if isinstance(typ, UnionType):
             return any(self.can_match_sequence(get_proper_type(item)) for item in typ.items)
         for other in self.non_sequence_match_types:
@@ -662,6 +756,8 @@ def construct_sequence_child(self, outer_type: Type, inner_type: Type) -> Type:
         or class T(Sequence[Tuple[T, T]]), there is no way any of those can map to Sequence[str].
         """
         proper_type = get_proper_type(outer_type)
+        if isinstance(proper_type, AnyType):
+            return outer_type
         if isinstance(proper_type, UnionType):
             types = [
                 self.construct_sequence_child(item, inner_type)
@@ -671,7 +767,6 @@ def construct_sequence_child(self, outer_type: Type, inner_type: Type) -> Type:
             return make_simplified_union(types)
         sequence = self.chk.named_generic_type("typing.Sequence", [inner_type])
         if is_subtype(outer_type, self.chk.named_type("typing.Sequence")):
-            proper_type = get_proper_type(outer_type)
             if isinstance(proper_type, TupleType):
                 proper_type = tuple_fallback(proper_type)
             assert isinstance(proper_type, Instance)
@@ -707,7 +802,7 @@ def get_var(expr: Expression) -> Var:
     return node
 
 
-def get_type_range(typ: Type) -> mypy.checker.TypeRange:
+def get_type_range(typ: Type) -> TypeRange:
     typ = get_proper_type(typ)
     if (
         isinstance(typ, Instance)
@@ -715,7 +810,7 @@ def get_type_range(typ: Type) -> mypy.checker.TypeRange:
         and isinstance(typ.last_known_value.value, bool)
     ):
         typ = typ.last_known_value
-    return mypy.checker.TypeRange(typ, is_upper_bound=False)
+    return TypeRange(typ, is_upper_bound=False)
 
 
 def is_uninhabited(typ: Type) -> bool:
diff --git a/mypy/checkstrformat.py b/mypy/checkstrformat.py
index 974985d8b4fc..45075bd37552 100644
--- a/mypy/checkstrformat.py
+++ b/mypy/checkstrformat.py
@@ -13,11 +13,16 @@
 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 re import Match, Pattern
+from typing import Callable, Final, Union, cast
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.errorcodes as codes
+from mypy import message_registry
+from mypy.checker_shared import TypeCheckerSharedApi
 from mypy.errors import Errors
+from mypy.maptype import map_instance_to_supertype
+from mypy.messages import MessageBuilder
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
@@ -40,6 +45,9 @@
     TempNode,
     TupleExpr,
 )
+from mypy.parse import parse
+from mypy.subtypes import is_subtype
+from mypy.typeops import custom_special_method
 from mypy.types import (
     AnyType,
     Instance,
@@ -47,27 +55,18 @@
     TupleType,
     Type,
     TypeOfAny,
+    TypeVarTupleType,
     TypeVarType,
     UnionType,
+    UnpackType,
+    find_unpack_in_list,
     get_proper_type,
     get_proper_types,
 )
 
-if TYPE_CHECKING:
-    # break import cycle only needed for mypy
-    import mypy.checker
-    import mypy.checkexpr
-
-from mypy import message_registry
-from mypy.maptype import map_instance_to_supertype
-from mypy.messages import MessageBuilder
-from mypy.parse import parse
-from mypy.subtypes import is_subtype
-from mypy.typeops import custom_special_method
-
 FormatStringExpr: _TypeAlias = Union[StrExpr, BytesExpr]
-Checkers: _TypeAlias = Tuple[Callable[[Expression], None], Callable[[Type], bool]]
-MatchMap: _TypeAlias = Dict[Tuple[int, int], Match[str]]  # span -> match
+Checkers: _TypeAlias = tuple[Callable[[Expression], None], Callable[[Type], bool]]
+MatchMap: _TypeAlias = dict[tuple[int, int], Match[str]]  # span -> match
 
 
 def compile_format_re() -> Pattern[str]:
@@ -295,21 +294,13 @@ class StringFormatterChecker:
     """
 
     # Some services are provided by a TypeChecker instance.
-    chk: mypy.checker.TypeChecker
+    chk: TypeCheckerSharedApi
     # This is shared with TypeChecker, but stored also here for convenience.
     msg: MessageBuilder
-    # Some services are provided by a ExpressionChecker instance.
-    exprchk: mypy.checkexpr.ExpressionChecker
 
-    def __init__(
-        self,
-        exprchk: mypy.checkexpr.ExpressionChecker,
-        chk: mypy.checker.TypeChecker,
-        msg: MessageBuilder,
-    ) -> None:
+    def __init__(self, chk: TypeCheckerSharedApi, msg: MessageBuilder) -> None:
         """Construct an expression type checker."""
         self.chk = chk
-        self.exprchk = exprchk
         self.msg = msg
 
     def check_str_format_call(self, call: CallExpr, format_value: str) -> None:
@@ -369,7 +360,7 @@ def check_specs_in_format_call(
                 ):
                     # TODO: add support for some custom specs like datetime?
                     self.msg.fail(
-                        "Unrecognized format" ' specification "{}"'.format(spec.format_spec[1:]),
+                        f'Unrecognized format specification "{spec.format_spec[1:]}"',
                         call,
                         code=codes.STRING_FORMATTING,
                     )
@@ -390,8 +381,10 @@ def check_specs_in_format_call(
                 # If the explicit conversion is given, then explicit conversion is called _first_.
                 if spec.conversion[1] not in "rsa":
                     self.msg.fail(
-                        'Invalid conversion type "{}",'
-                        ' must be one of "r", "s" or "a"'.format(spec.conversion[1]),
+                        (
+                            f'Invalid conversion type "{spec.conversion[1]}", '
+                            f'must be one of "r", "s" or "a"'
+                        ),
                         call,
                         code=codes.STRING_FORMATTING,
                     )
@@ -469,8 +462,7 @@ def find_replacements_in_call(self, call: CallExpr, keys: list[str]) -> list[Exp
                 expr = self.get_expr_by_position(int(key), call)
                 if not expr:
                     self.msg.fail(
-                        "Cannot find replacement for positional"
-                        " format specifier {}".format(key),
+                        f"Cannot find replacement for positional format specifier {key}",
                         call,
                         code=codes.STRING_FORMATTING,
                     )
@@ -479,7 +471,7 @@ def find_replacements_in_call(self, call: CallExpr, keys: list[str]) -> list[Exp
                 expr = self.get_expr_by_name(key, call)
                 if not expr:
                     self.msg.fail(
-                        "Cannot find replacement for named" ' format specifier "{}"'.format(key),
+                        f'Cannot find replacement for named format specifier "{key}"',
                         call,
                         code=codes.STRING_FORMATTING,
                     )
@@ -613,7 +605,7 @@ def apply_field_accessors(
         # TODO: fix column to point to actual start of the format specifier _within_ string.
         temp_ast.line = ctx.line
         temp_ast.column = ctx.column
-        self.exprchk.accept(temp_ast)
+        self.chk.expr_checker.accept(temp_ast)
         return temp_ast
 
     def validate_and_transform_accessors(
@@ -651,8 +643,9 @@ class User(TypedDict):
                 assert spec.key, "Call this method only after auto-generating keys!"
                 assert spec.field
                 self.msg.fail(
-                    "Invalid index expression in format field"
-                    ' accessor "{}"'.format(spec.field[len(spec.key) :]),
+                    'Invalid index expression in format field accessor "{}"'.format(
+                        spec.field[len(spec.key) :]
+                    ),
                     ctx,
                     code=codes.STRING_FORMATTING,
                 )
@@ -679,17 +672,9 @@ def check_str_interpolation(self, expr: FormatStringExpr, replacements: Expressi
         """Check the types of the 'replacements' in a string interpolation
         expression: str % replacements.
         """
-        self.exprchk.accept(expr)
+        self.chk.expr_checker.accept(expr)
         specifiers = parse_conversion_specifiers(expr.value)
         has_mapping_keys = self.analyze_conversion_specifiers(specifiers, expr)
-        if isinstance(expr, BytesExpr) and self.chk.options.python_version < (3, 5):
-            self.msg.fail(
-                "Bytes formatting is only supported in Python 3.5 and later",
-                replacements,
-                code=codes.STRING_FORMATTING,
-            )
-            return AnyType(TypeOfAny.from_error)
-
         if has_mapping_keys is None:
             pass  # Error was reported
         elif has_mapping_keys:
@@ -736,6 +721,22 @@ def check_simple_str_interpolation(
         rep_types: list[Type] = []
         if isinstance(rhs_type, TupleType):
             rep_types = rhs_type.items
+            unpack_index = find_unpack_in_list(rep_types)
+            if unpack_index is not None:
+                # TODO: we should probably warn about potentially short tuple.
+                # However, without special-casing for tuple(f(i) for in other_tuple)
+                # this causes false positive on mypy self-check in report.py.
+                extras = max(0, len(checkers) - len(rep_types) + 1)
+                unpacked = rep_types[unpack_index]
+                assert isinstance(unpacked, UnpackType)
+                unpacked = get_proper_type(unpacked.type)
+                if isinstance(unpacked, TypeVarTupleType):
+                    unpacked = get_proper_type(unpacked.upper_bound)
+                assert (
+                    isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+                )
+                unpack_items = [unpacked.args[0]] * extras
+                rep_types = rep_types[:unpack_index] + unpack_items + rep_types[unpack_index + 1 :]
         elif isinstance(rhs_type, AnyType):
             return
         elif isinstance(rhs_type, Instance) and rhs_type.type.fullname == "builtins.tuple":
@@ -1023,13 +1024,6 @@ def conversion_type(
         NUMERIC_TYPES = NUMERIC_TYPES_NEW if format_call else NUMERIC_TYPES_OLD
         INT_TYPES = REQUIRE_INT_NEW if format_call else REQUIRE_INT_OLD
         if p == "b" and not format_call:
-            if self.chk.options.python_version < (3, 5):
-                self.msg.fail(
-                    'Format character "b" is only supported in Python 3.5 and later',
-                    context,
-                    code=codes.STRING_FORMATTING,
-                )
-                return None
             if not isinstance(expr, BytesExpr):
                 self.msg.fail(
                     'Format character "b" is only supported on bytes patterns',
diff --git a/mypy/config_parser.py b/mypy/config_parser.py
index 05af2ba6e21e..0e033471d2e9 100644
--- a/mypy/config_parser.py
+++ b/mypy/config_parser.py
@@ -15,26 +15,15 @@
 else:
     import tomli as tomllib
 
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    MutableMapping,
-    Sequence,
-    TextIO,
-    Tuple,
-    Union,
-)
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from collections.abc import Mapping, MutableMapping, Sequence
+from typing import Any, Callable, Final, TextIO, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy import defaults
 from mypy.options import PER_MODULE_OPTIONS, Options
 
 _CONFIG_VALUE_TYPES: _TypeAlias = Union[
-    str, bool, int, float, Dict[str, str], List[str], Tuple[int, int]
+    str, bool, int, float, dict[str, str], list[str], tuple[int, int]
 ]
 _INI_PARSER_CALLABLE: _TypeAlias = Callable[[Any], _CONFIG_VALUE_TYPES]
 
@@ -66,8 +55,10 @@ def parse_version(v: str | float) -> tuple[int, int]:
 def try_split(v: str | Sequence[str], split_regex: str = "[,]") -> list[str]:
     """Split and trim a str or list of str into a list of str"""
     if isinstance(v, str):
-        return [p.strip() for p in re.split(split_regex, v)]
-
+        items = [p.strip() for p in re.split(split_regex, v)]
+        if items and items[-1] == "":
+            items.pop(-1)
+        return items
     return [p.strip() for p in v]
 
 
@@ -80,6 +71,20 @@ def validate_codes(codes: list[str]) -> list[str]:
     return codes
 
 
+def validate_package_allow_list(allow_list: list[str]) -> list[str]:
+    for p in allow_list:
+        msg = f"Invalid allow list entry: {p}"
+        if "*" in p:
+            raise argparse.ArgumentTypeError(
+                f"{msg} (entries are already prefixes so must not contain *)"
+            )
+        if "\\" in p or "/" in p:
+            raise argparse.ArgumentTypeError(
+                f"{msg} (entries must be packages like foo.bar not directories or files)"
+            )
+    return allow_list
+
+
 def expand_path(path: str) -> str:
     """Expand the user home directory and any environment variables contained within
     the provided path.
@@ -123,7 +128,7 @@ def split_and_match_files(paths: str) -> list[str]:
     Returns a list of file paths
     """
 
-    return split_and_match_files_list(paths.split(","))
+    return split_and_match_files_list(split_commas(paths))
 
 
 def check_follow_imports(choice: str) -> str:
@@ -137,6 +142,17 @@ def check_follow_imports(choice: str) -> str:
     return choice
 
 
+def check_junit_format(choice: str) -> str:
+    choices = ["global", "per_file"]
+    if choice not in choices:
+        raise argparse.ArgumentTypeError(
+            "invalid choice '{}' (choose from {})".format(
+                choice, ", ".join(f"'{x}'" for x in choices)
+            )
+        )
+    return choice
+
+
 def split_commas(value: str) -> list[str]:
     # Uses a bit smarter technique to allow last trailing comma
     # and to remove last `""` item from the split.
@@ -158,11 +174,15 @@ def split_commas(value: str) -> list[str]:
     "files": split_and_match_files,
     "quickstart_file": expand_path,
     "junit_xml": expand_path,
+    "junit_format": check_junit_format,
     "follow_imports": check_follow_imports,
     "no_site_packages": bool,
     "plugins": lambda s: [p.strip() for p in split_commas(s)],
     "always_true": lambda s: [p.strip() for p in split_commas(s)],
     "always_false": lambda s: [p.strip() for p in split_commas(s)],
+    "untyped_calls_exclude": lambda s: validate_package_allow_list(
+        [p.strip() for p in split_commas(s)]
+    ),
     "enable_incomplete_feature": lambda s: [p.strip() for p in split_commas(s)],
     "disable_error_code": lambda s: validate_codes([p.strip() for p in split_commas(s)]),
     "enable_error_code": lambda s: validate_codes([p.strip() for p in split_commas(s)]),
@@ -182,10 +202,12 @@ def split_commas(value: str) -> list[str]:
         "python_version": parse_version,
         "mypy_path": lambda s: [expand_path(p) for p in try_split(s, "[,:]")],
         "files": lambda s: split_and_match_files_list(try_split(s)),
+        "junit_format": lambda s: check_junit_format(str(s)),
         "follow_imports": lambda s: check_follow_imports(str(s)),
         "plugins": try_split,
         "always_true": try_split,
         "always_false": try_split,
+        "untyped_calls_exclude": lambda s: validate_package_allow_list(try_split(s)),
         "enable_incomplete_feature": try_split,
         "disable_error_code": lambda s: validate_codes(try_split(s)),
         "enable_error_code": lambda s: validate_codes(try_split(s)),
@@ -197,6 +219,72 @@ def split_commas(value: str) -> list[str]:
 )
 
 
+def _parse_individual_file(
+    config_file: str, stderr: TextIO | None = None
+) -> tuple[MutableMapping[str, Any], dict[str, _INI_PARSER_CALLABLE], str] | None:
+
+    if not os.path.exists(config_file):
+        return None
+
+    parser: MutableMapping[str, Any]
+    try:
+        if is_toml(config_file):
+            with open(config_file, "rb") as f:
+                toml_data = tomllib.load(f)
+            # Filter down to just mypy relevant toml keys
+            toml_data = toml_data.get("tool", {})
+            if "mypy" not in toml_data:
+                return None
+            toml_data = {"mypy": toml_data["mypy"]}
+            parser = destructure_overrides(toml_data)
+            config_types = toml_config_types
+        else:
+            parser = configparser.RawConfigParser()
+            parser.read(config_file)
+            config_types = ini_config_types
+
+    except (tomllib.TOMLDecodeError, configparser.Error, ConfigTOMLValueError) as err:
+        print(f"{config_file}: {err}", file=stderr)
+        return None
+
+    if os.path.basename(config_file) in defaults.SHARED_CONFIG_NAMES and "mypy" not in parser:
+        return None
+
+    return parser, config_types, config_file
+
+
+def _find_config_file(
+    stderr: TextIO | None = None,
+) -> tuple[MutableMapping[str, Any], dict[str, _INI_PARSER_CALLABLE], str] | None:
+
+    current_dir = os.path.abspath(os.getcwd())
+
+    while True:
+        for name in defaults.CONFIG_NAMES + defaults.SHARED_CONFIG_NAMES:
+            config_file = os.path.relpath(os.path.join(current_dir, name))
+            ret = _parse_individual_file(config_file, stderr)
+            if ret is None:
+                continue
+            return ret
+
+        if any(
+            os.path.exists(os.path.join(current_dir, cvs_root)) for cvs_root in (".git", ".hg")
+        ):
+            break
+        parent_dir = os.path.dirname(current_dir)
+        if parent_dir == current_dir:
+            break
+        current_dir = parent_dir
+
+    for config_file in defaults.USER_CONFIG_FILES:
+        ret = _parse_individual_file(config_file, stderr)
+        if ret is None:
+            continue
+        return ret
+
+    return None
+
+
 def parse_config_file(
     options: Options,
     set_strict_flags: Callable[[], None],
@@ -213,47 +301,20 @@ def parse_config_file(
     stdout = stdout or sys.stdout
     stderr = stderr or sys.stderr
 
-    if filename is not None:
-        config_files: tuple[str, ...] = (filename,)
-    else:
-        config_files_iter: Iterable[str] = map(os.path.expanduser, defaults.CONFIG_FILES)
-        config_files = tuple(config_files_iter)
-
-    config_parser = configparser.RawConfigParser()
-
-    for config_file in config_files:
-        if not os.path.exists(config_file):
-            continue
-        try:
-            if is_toml(config_file):
-                with open(config_file, "rb") as f:
-                    toml_data = tomllib.load(f)
-                # Filter down to just mypy relevant toml keys
-                toml_data = toml_data.get("tool", {})
-                if "mypy" not in toml_data:
-                    continue
-                toml_data = {"mypy": toml_data["mypy"]}
-                parser: MutableMapping[str, Any] = destructure_overrides(toml_data)
-                config_types = toml_config_types
-            else:
-                config_parser.read(config_file)
-                parser = config_parser
-                config_types = ini_config_types
-        except (tomllib.TOMLDecodeError, configparser.Error, ConfigTOMLValueError) as err:
-            print(f"{config_file}: {err}", file=stderr)
-        else:
-            if config_file in defaults.SHARED_CONFIG_FILES and "mypy" not in parser:
-                continue
-            file_read = config_file
-            options.config_file = file_read
-            break
-    else:
+    ret = (
+        _parse_individual_file(filename, stderr)
+        if filename is not None
+        else _find_config_file(stderr)
+    )
+    if ret is None:
         return
+    parser, config_types, file_read = ret
 
-    os.environ["MYPY_CONFIG_FILE_DIR"] = os.path.dirname(os.path.abspath(config_file))
+    options.config_file = file_read
+    os.environ["MYPY_CONFIG_FILE_DIR"] = os.path.dirname(os.path.abspath(file_read))
 
     if "mypy" not in parser:
-        if filename or file_read not in defaults.SHARED_CONFIG_FILES:
+        if filename or os.path.basename(file_read) not in defaults.SHARED_CONFIG_NAMES:
             print(f"{file_read}: No [mypy] section in config file", file=stderr)
     else:
         section = parser["mypy"]
@@ -273,14 +334,18 @@ def parse_config_file(
             )
             if report_dirs:
                 print(
-                    "%sPer-module sections should not specify reports (%s)"
-                    % (prefix, ", ".join(s + "_report" for s in sorted(report_dirs))),
+                    prefix,
+                    "Per-module sections should not specify reports ({})".format(
+                        ", ".join(s + "_report" for s in sorted(report_dirs))
+                    ),
                     file=stderr,
                 )
             if set(updates) - PER_MODULE_OPTIONS:
                 print(
-                    "%sPer-module sections should only specify per-module flags (%s)"
-                    % (prefix, ", ".join(sorted(set(updates) - PER_MODULE_OPTIONS))),
+                    prefix,
+                    "Per-module sections should only specify per-module flags ({})".format(
+                        ", ".join(sorted(set(updates) - PER_MODULE_OPTIONS))
+                    ),
                     file=stderr,
                 )
                 updates = {k: v for k, v in updates.items() if k in PER_MODULE_OPTIONS}
@@ -296,8 +361,9 @@ def parse_config_file(
                     "*" in x and x != "*" for x in glob.split(".")
                 ):
                     print(
-                        "%sPatterns must be fully-qualified module names, optionally "
-                        "with '*' in some components (e.g spam.*.eggs.*)" % prefix,
+                        prefix,
+                        "Patterns must be fully-qualified module names, optionally "
+                        "with '*' in some components (e.g spam.*.eggs.*)",
                         file=stderr,
                     )
                 else:
@@ -310,7 +376,7 @@ def get_prefix(file_read: str, name: str) -> str:
     else:
         module_name_str = name
 
-    return f"{file_read}: [{module_name_str}]: "
+    return f"{file_read}: [{module_name_str}]:"
 
 
 def is_toml(filename: str) -> bool:
@@ -392,8 +458,7 @@ def destructure_overrides(toml_data: dict[str, Any]) -> dict[str, Any]:
                         raise ConfigTOMLValueError(
                             "toml config file contains "
                             "[[tool.mypy.overrides]] sections with conflicting "
-                            "values. Module '%s' has two different values for '%s'"
-                            % (module, new_key)
+                            f"values. Module '{module}' has two different values for '{new_key}'"
                         )
                     result[old_config_name][new_key] = new_value
 
@@ -415,18 +480,28 @@ def parse_section(
     """
     results: dict[str, object] = {}
     report_dirs: dict[str, str] = {}
+
+    # Because these fields exist on Options, without proactive checking, we would accept them
+    # and crash later
+    invalid_options = {
+        "enabled_error_codes": "enable_error_code",
+        "disabled_error_codes": "disable_error_code",
+    }
+
     for key in section:
         invert = False
         options_key = key
         if key in config_types:
             ct = config_types[key]
+        elif key in invalid_options:
+            print(
+                f"{prefix}Unrecognized option: {key} = {section[key]}"
+                f" (did you mean {invalid_options[key]}?)",
+                file=stderr,
+            )
+            continue
         else:
-            dv = None
-            # We have to keep new_semantic_analyzer in Options
-            # for plugin compatibility but it is not a valid option anymore.
-            assert hasattr(template, "new_semantic_analyzer")
-            if key != "new_semantic_analyzer":
-                dv = getattr(template, key, None)
+            dv = getattr(template, key, None)
             if dv is None:
                 if key.endswith("_report"):
                     report_type = key[:-7].replace("_", "-")
@@ -574,6 +649,11 @@ def parse_mypy_comments(
         # method is to create a config parser.
         parser = configparser.RawConfigParser()
         options, parse_errors = mypy_comments_to_config_map(line, template)
+
+        if "python_version" in options:
+            errors.append((lineno, "python_version not supported in inline configuration"))
+            del options["python_version"]
+
         parser["dummy"] = options
         errors.extend((lineno, x) for x in parse_errors)
 
diff --git a/mypy/constant_fold.py b/mypy/constant_fold.py
index a1011397eba8..4582b2a7396d 100644
--- a/mypy/constant_fold.py
+++ b/mypy/constant_fold.py
@@ -5,14 +5,23 @@
 
 from __future__ import annotations
 
-from typing import Union
-from typing_extensions import Final
-
-from mypy.nodes import Expression, FloatExpr, IntExpr, NameExpr, OpExpr, StrExpr, UnaryExpr, Var
+from typing import Final, Union
+
+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 +48,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 +67,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 +147,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/constraints.py b/mypy/constraints.py
index 33230871b505..8e7a30e05ffb 100644
--- a/mypy/constraints.py
+++ b/mypy/constraints.py
@@ -2,15 +2,25 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterable, List, Sequence, cast
-from typing_extensions import Final
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, Final, cast
+from typing_extensions import TypeGuard
 
 import mypy.subtypes
 import mypy.typeops
 from mypy.argmap import ArgTypeExpander
 from mypy.erasetype import erase_typevars
 from mypy.maptype import map_instance_to_supertype
-from mypy.nodes import ARG_OPT, ARG_POS, CONTRAVARIANT, COVARIANT, ArgKind
+from mypy.nodes import (
+    ARG_OPT,
+    ARG_POS,
+    ARG_STAR,
+    ARG_STAR2,
+    CONTRAVARIANT,
+    COVARIANT,
+    ArgKind,
+    TypeInfo,
+)
 from mypy.types import (
     TUPLE_LIKE_INSTANCE_NAMES,
     AnyType,
@@ -20,6 +30,7 @@
     Instance,
     LiteralType,
     NoneType,
+    NormalizedCallableType,
     Overloaded,
     Parameters,
     ParamSpecType,
@@ -41,7 +52,8 @@
     UninhabitedType,
     UnionType,
     UnpackType,
-    callable_with_ellipsis,
+    find_unpack_in_list,
+    flatten_nested_tuples,
     get_proper_type,
     has_recursive_types,
     has_type_vars,
@@ -50,7 +62,6 @@
 )
 from mypy.types_utils import is_union_with_any
 from mypy.typestate import type_state
-from mypy.typevartuples import extract_unpack, find_unpack_in_list, split_with_mapped_and_template
 
 if TYPE_CHECKING:
     from mypy.infer import ArgumentInferContext
@@ -72,8 +83,14 @@ class Constraint:
     def __init__(self, type_var: TypeVarLikeType, op: int, target: Type) -> None:
         self.type_var = type_var.id
         self.op = op
+        # TODO: should we add "assert not isinstance(target, UnpackType)"?
+        # UnpackType is a synthetic type, and is never valid as a constraint target.
         self.target = target
         self.origin_type_var = type_var
+        # These are additional type variables that should be solved for together with type_var.
+        # TODO: A cleaner solution may be to modify the return type of infer_constraints()
+        # to include these instead, but this is a rather big refactoring.
+        self.extra_tvars: list[TypeVarLikeType] = []
 
     def __repr__(self) -> str:
         op_str = "<:"
@@ -94,6 +111,7 @@ def infer_constraints_for_callable(
     callee: CallableType,
     arg_types: Sequence[Type | None],
     arg_kinds: list[ArgKind],
+    arg_names: Sequence[str | None] | None,
     formal_to_actual: list[list[int]],
     context: ArgumentInferContext,
 ) -> list[Constraint]:
@@ -104,30 +122,61 @@ def infer_constraints_for_callable(
     constraints: list[Constraint] = []
     mapper = ArgTypeExpander(context)
 
+    param_spec = callee.param_spec()
+    param_spec_arg_types = []
+    param_spec_arg_names = []
+    param_spec_arg_kinds = []
+
+    incomplete_star_mapping = False
+    for i, actuals in enumerate(formal_to_actual):  # TODO: isn't this `enumerate(arg_types)`?
+        for actual in actuals:
+            if actual is None and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2):  # type: ignore[unreachable]
+                # We can't use arguments to infer ParamSpec constraint, if only some
+                # are present in the current inference pass.
+                incomplete_star_mapping = True  # type: ignore[unreachable]
+                break
+
     for i, actuals in enumerate(formal_to_actual):
         if isinstance(callee.arg_types[i], UnpackType):
             unpack_type = callee.arg_types[i]
             assert isinstance(unpack_type, UnpackType)
 
-            # In this case we are binding all of the actuals to *args
+            # In this case we are binding all the actuals to *args,
             # and we want a constraint that the typevar tuple being unpacked
             # is equal to a type list of all the actuals.
             actual_types = []
+
+            unpacked_type = get_proper_type(unpack_type.type)
+            if isinstance(unpacked_type, TypeVarTupleType):
+                tuple_instance = unpacked_type.tuple_fallback
+            elif isinstance(unpacked_type, TupleType):
+                tuple_instance = unpacked_type.partial_fallback
+            else:
+                assert False, "mypy bug: unhandled constraint inference case"
+
             for actual in actuals:
                 actual_arg_type = arg_types[actual]
                 if actual_arg_type is None:
                     continue
 
-                actual_types.append(
-                    mapper.expand_actual_type(
-                        actual_arg_type,
-                        arg_kinds[actual],
-                        callee.arg_names[i],
-                        callee.arg_kinds[i],
-                    )
+                expanded_actual = mapper.expand_actual_type(
+                    actual_arg_type,
+                    arg_kinds[actual],
+                    callee.arg_names[i],
+                    callee.arg_kinds[i],
+                    allow_unpack=True,
                 )
 
-            unpacked_type = get_proper_type(unpack_type.type)
+                if arg_kinds[actual] != ARG_STAR or isinstance(
+                    get_proper_type(actual_arg_type), TupleType
+                ):
+                    actual_types.append(expanded_actual)
+                else:
+                    # If we are expanding an iterable inside * actual, append a homogeneous item instead
+                    actual_types.append(
+                        UnpackType(tuple_instance.copy_modified(args=[expanded_actual]))
+                    )
+
             if isinstance(unpacked_type, TypeVarTupleType):
                 constraints.append(
                     Constraint(
@@ -142,16 +191,33 @@ def infer_constraints_for_callable(
                 # not to hold we can always handle the prefixes too.
                 inner_unpack = unpacked_type.items[0]
                 assert isinstance(inner_unpack, UnpackType)
-                inner_unpacked_type = inner_unpack.type
-                assert isinstance(inner_unpacked_type, TypeVarTupleType)
+                inner_unpacked_type = get_proper_type(inner_unpack.type)
                 suffix_len = len(unpacked_type.items) - 1
-                constraints.append(
-                    Constraint(
-                        inner_unpacked_type,
-                        SUPERTYPE_OF,
-                        TupleType(actual_types[:-suffix_len], inner_unpacked_type.tuple_fallback),
+                if isinstance(inner_unpacked_type, TypeVarTupleType):
+                    # Variadic item can be either *Ts...
+                    constraints.append(
+                        Constraint(
+                            inner_unpacked_type,
+                            SUPERTYPE_OF,
+                            TupleType(
+                                actual_types[:-suffix_len], inner_unpacked_type.tuple_fallback
+                            ),
+                        )
                     )
-                )
+                else:
+                    # ...or it can be a homogeneous tuple.
+                    assert (
+                        isinstance(inner_unpacked_type, Instance)
+                        and inner_unpacked_type.type.fullname == "builtins.tuple"
+                    )
+                    for at in actual_types[:-suffix_len]:
+                        constraints.extend(
+                            infer_constraints(inner_unpacked_type.args[0], at, SUPERTYPE_OF)
+                        )
+                # Now handle the suffix (if any).
+                if suffix_len:
+                    for tt, at in zip(unpacked_type.items[1:], actual_types[-suffix_len:]):
+                        constraints.extend(infer_constraints(tt, at, SUPERTYPE_OF))
             else:
                 assert False, "mypy bug: unhandled constraint inference case"
         else:
@@ -160,16 +226,59 @@ def infer_constraints_for_callable(
                 if actual_arg_type is None:
                     continue
 
-                actual_type = mapper.expand_actual_type(
-                    actual_arg_type, arg_kinds[actual], callee.arg_names[i], callee.arg_kinds[i]
-                )
-                c = infer_constraints(callee.arg_types[i], actual_type, SUPERTYPE_OF)
-                constraints.extend(c)
-
+                if param_spec and callee.arg_kinds[i] in (ARG_STAR, ARG_STAR2):
+                    # If actual arguments are mapped to ParamSpec type, we can't infer individual
+                    # constraints, instead store them and infer single constraint at the end.
+                    # It is impossible to map actual kind to formal kind, so use some heuristic.
+                    # This inference is used as a fallback, so relying on heuristic should be OK.
+                    if not incomplete_star_mapping:
+                        param_spec_arg_types.append(
+                            mapper.expand_actual_type(
+                                actual_arg_type, arg_kinds[actual], None, arg_kinds[actual]
+                            )
+                        )
+                        actual_kind = arg_kinds[actual]
+                        param_spec_arg_kinds.append(
+                            ARG_POS if actual_kind not in (ARG_STAR, ARG_STAR2) else actual_kind
+                        )
+                        param_spec_arg_names.append(arg_names[actual] if arg_names else None)
+                else:
+                    actual_type = mapper.expand_actual_type(
+                        actual_arg_type,
+                        arg_kinds[actual],
+                        callee.arg_names[i],
+                        callee.arg_kinds[i],
+                    )
+                    c = infer_constraints(callee.arg_types[i], actual_type, SUPERTYPE_OF)
+                    constraints.extend(c)
+    if (
+        param_spec
+        and not any(c.type_var == param_spec.id for c in constraints)
+        and not incomplete_star_mapping
+    ):
+        # Use ParamSpec constraint from arguments only if there are no other constraints,
+        # since as explained above it is quite ad-hoc.
+        constraints.append(
+            Constraint(
+                param_spec,
+                SUPERTYPE_OF,
+                Parameters(
+                    arg_types=param_spec_arg_types,
+                    arg_kinds=param_spec_arg_kinds,
+                    arg_names=param_spec_arg_names,
+                    imprecise_arg_kinds=True,
+                ),
+            )
+        )
+    if any(isinstance(v, ParamSpecType) for v in callee.variables):
+        # As a perf optimization filter imprecise constraints only when we can have them.
+        constraints = filter_imprecise_kinds(constraints)
     return constraints
 
 
-def infer_constraints(template: Type, actual: Type, direction: int) -> list[Constraint]:
+def infer_constraints(
+    template: Type, actual: Type, direction: int, skip_neg_op: bool = False
+) -> list[Constraint]:
     """Infer type constraints.
 
     Match a template type, which may contain type variable references,
@@ -188,7 +297,9 @@ def infer_constraints(template: Type, actual: Type, direction: int) -> list[Cons
       ((T, S), (X, Y))  -->  T :> X and S :> Y
       (X[T], Any)       -->  T <: Any and T :> Any
 
-    The constraints are represented as Constraint objects.
+    The constraints are represented as Constraint objects. If skip_neg_op == True,
+    then skip adding reverse (polymorphic) constraints (since this is already a call
+    to infer such constraints).
     """
     if any(
         get_proper_type(template) == get_proper_type(t)
@@ -203,13 +314,15 @@ def infer_constraints(template: Type, actual: Type, direction: int) -> list[Cons
             # Return early on an empty branch.
             return []
         type_state.inferring.append((template, actual))
-        res = _infer_constraints(template, actual, direction)
+        res = _infer_constraints(template, actual, direction, skip_neg_op)
         type_state.inferring.pop()
         return res
-    return _infer_constraints(template, actual, direction)
+    return _infer_constraints(template, actual, direction, skip_neg_op)
 
 
-def _infer_constraints(template: Type, actual: Type, direction: int) -> list[Constraint]:
+def _infer_constraints(
+    template: Type, actual: Type, direction: int, skip_neg_op: bool
+) -> list[Constraint]:
     orig_template = template
     template = get_proper_type(template)
     actual = get_proper_type(actual)
@@ -229,6 +342,16 @@ def _infer_constraints(template: Type, actual: Type, direction: int) -> list[Con
     if isinstance(actual, AnyType) and actual.type_of_any == TypeOfAny.suggestion_engine:
         return []
 
+    # type[A | B] is always represented as type[A] | type[B] internally.
+    # This makes our constraint solver choke on type[T] <: type[A] | type[B],
+    # solving T as generic meet(A, B) which is often `object`. Force unwrap such unions
+    # if both sides are type[...] or unions thereof. See `testTypeVarType` test
+    type_type_unwrapped = False
+    if _is_type_type(template) and _is_type_type(actual):
+        type_type_unwrapped = True
+        template = _unwrap_type_type(template)
+        actual = _unwrap_type_type(actual)
+
     # If the template is simply a type variable, emit a Constraint directly.
     # We need to handle this case before handling Unions for two reasons:
     #  1. "T <: Union[U1, U2]" is not equivalent to "T <: U1 or T <: U2",
@@ -239,6 +362,18 @@ def _infer_constraints(template: Type, actual: Type, direction: int) -> list[Con
     if isinstance(template, TypeVarType):
         return [Constraint(template, direction, actual)]
 
+    if (
+        isinstance(actual, TypeVarType)
+        and not actual.id.is_meta_var()
+        and direction == SUPERTYPE_OF
+    ):
+        # Unless template is also a type variable (or a union that contains one), using the upper
+        # bound for inference will usually give better result for actual that is a type variable.
+        if not isinstance(template, UnionType) or not any(
+            isinstance(t, TypeVarType) for t in template.items
+        ):
+            actual = get_proper_type(actual.upper_bound)
+
     # Now handle the case of either template or actual being a Union.
     # For a Union to be a subtype of another type, every item of the Union
     # must be a subtype of that type, so concatenate the constraints.
@@ -250,6 +385,11 @@ def _infer_constraints(template: Type, actual: Type, direction: int) -> list[Con
     if direction == SUPERTYPE_OF and isinstance(actual, UnionType):
         res = []
         for a_item in actual.items:
+            # `orig_template` has to be preserved intact in case it's recursive.
+            # If we unwrapped ``type[...]`` previously, wrap the item back again,
+            # as ``type[...]`` can't be removed from `orig_template`.
+            if type_type_unwrapped:
+                a_item = TypeType.make_normalized(a_item)
             res.extend(infer_constraints(orig_template, a_item, direction))
         return res
 
@@ -285,7 +425,27 @@ def _infer_constraints(template: Type, actual: Type, direction: int) -> list[Con
         return []
 
     # Remaining cases are handled by ConstraintBuilderVisitor.
-    return template.accept(ConstraintBuilderVisitor(actual, direction))
+    return template.accept(ConstraintBuilderVisitor(actual, direction, skip_neg_op))
+
+
+def _is_type_type(tp: ProperType) -> TypeGuard[TypeType | UnionType]:
+    """Is ``tp`` a ``type[...]`` or a union thereof?
+
+    ``Type[A | B]`` is internally represented as ``type[A] | type[B]``, and this
+    troubles the solver sometimes.
+    """
+    return (
+        isinstance(tp, TypeType)
+        or isinstance(tp, UnionType)
+        and all(isinstance(get_proper_type(o), TypeType) for o in tp.items)
+    )
+
+
+def _unwrap_type_type(tp: TypeType | UnionType) -> ProperType:
+    """Extract the inner type from ``type[...]`` expression or a union thereof."""
+    if isinstance(tp, TypeType):
+        return tp.item
+    return UnionType.make_union([cast(TypeType, get_proper_type(o)).item for o in tp.items])
 
 
 def infer_constraints_if_possible(
@@ -352,7 +512,7 @@ def handle_recursive_union(template: UnionType, actual: Type, direction: int) ->
     ) or infer_constraints(UnionType.make_union(type_var_items), actual, direction)
 
 
-def any_constraints(options: list[list[Constraint] | None], eager: bool) -> list[Constraint]:
+def any_constraints(options: list[list[Constraint] | None], *, eager: bool) -> list[Constraint]:
     """Deduce what we can from a collection of constraint lists.
 
     It's a given that at least one of the lists must be satisfied. A
@@ -386,12 +546,8 @@ def any_constraints(options: list[list[Constraint] | None], eager: bool) -> list
             for option in valid_options:
                 if option in trivial_options:
                     continue
-                if option is not None:
-                    merged_option: list[Constraint] | None = [merge_with_any(c) for c in option]
-                else:
-                    merged_option = None
-                merged_options.append(merged_option)
-            return any_constraints(list(merged_options), eager)
+                merged_options.append([merge_with_any(c) for c in option])
+            return any_constraints(list(merged_options), eager=eager)
 
     # If normal logic didn't work, try excluding trivially unsatisfiable constraint (due to
     # upper bounds) from each option, and comparing them again.
@@ -399,6 +555,14 @@ def any_constraints(options: list[list[Constraint] | None], eager: bool) -> list
     if filtered_options != options:
         return any_constraints(filtered_options, eager=eager)
 
+    # Try harder: if that didn't work, try to strip typevars that aren't meta vars.
+    # Note this is what we would always do, but unfortunately some callers may not
+    # set the meta var status correctly (for historical reasons), so we use this as
+    # a fallback only.
+    filtered_options = [exclude_non_meta_vars(o) for o in options]
+    if filtered_options != options:
+        return any_constraints(filtered_options, eager=eager)
+
     # Otherwise, there are either no valid options or multiple, inconsistent valid
     # options. Give up and deduce nothing.
     return []
@@ -413,6 +577,7 @@ def filter_satisfiable(option: list[Constraint] | None) -> list[Constraint] | No
     """
     if not option:
         return option
+
     satisfiable = []
     for c in option:
         if isinstance(c.origin_type_var, TypeVarType) and c.origin_type_var.values:
@@ -427,6 +592,15 @@ def filter_satisfiable(option: list[Constraint] | None) -> list[Constraint] | No
     return satisfiable
 
 
+def exclude_non_meta_vars(option: list[Constraint] | None) -> list[Constraint] | None:
+    # If we had an empty list, keep it intact
+    if not option:
+        return option
+    # However, if none of the options actually references meta vars, better remove
+    # this constraint entirely.
+    return [c for c in option if c.type_var.is_meta_var()] or None
+
+
 def is_same_constraints(x: list[Constraint], y: list[Constraint]) -> bool:
     for c1 in x:
         if not any(is_same_constraint(c1, c2) for c2 in y):
@@ -504,17 +678,21 @@ def visit_uninhabited_type(self, t: UninhabitedType) -> bool:
         return False
 
 
-class ConstraintBuilderVisitor(TypeVisitor[List[Constraint]]):
+class ConstraintBuilderVisitor(TypeVisitor[list[Constraint]]):
     """Visitor class for inferring type constraints."""
 
     # The type that is compared against a template
     # TODO: The value may be None. Is that actually correct?
     actual: ProperType
 
-    def __init__(self, actual: ProperType, direction: int) -> None:
+    def __init__(self, actual: ProperType, direction: int, skip_neg_op: bool) -> None:
         # Direction must be SUBTYPE_OF or SUPERTYPE_OF.
         self.actual = actual
         self.direction = direction
+        # Whether to skip polymorphic inference (involves inference in opposite direction)
+        # this is used to prevent infinite recursion when both template and actual are
+        # generic callables.
+        self.skip_neg_op = skip_neg_op
 
     # Trivial leaf types
 
@@ -564,11 +742,20 @@ def visit_unpack_type(self, template: UnpackType) -> list[Constraint]:
         raise RuntimeError("Mypy bug: unpack should be handled at a higher level.")
 
     def visit_parameters(self, template: Parameters) -> list[Constraint]:
-        # constraining Any against C[P] turns into infer_against_any([P], Any)
-        # ... which seems like the only case this can happen. Better to fail loudly.
+        # Constraining Any against C[P] turns into infer_against_any([P], Any)
         if isinstance(self.actual, AnyType):
             return self.infer_against_any(template.arg_types, self.actual)
-        raise RuntimeError("Parameters cannot be constrained to")
+        if type_state.infer_polymorphic and isinstance(self.actual, Parameters):
+            # For polymorphic inference we need to be able to infer secondary constraints
+            # in situations like [x: T] <: P <: [x: int].
+            return infer_callable_arguments_constraints(template, self.actual, self.direction)
+        if type_state.infer_polymorphic and isinstance(self.actual, ParamSpecType):
+            # Similar for [x: T] <: Q <: Concatenate[int, P].
+            return infer_callable_arguments_constraints(
+                template, self.actual.prefix, self.direction
+            )
+        # There also may be unpatched types after a user error, simply ignore them.
+        return []
 
     # Non-leaf types
 
@@ -584,40 +771,40 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
                         "__call__", template, actual, is_operator=True
                     )
                     assert call is not None
-                    if mypy.subtypes.is_subtype(actual, erase_typevars(call)):
-                        subres = infer_constraints(call, actual, self.direction)
-                        res.extend(subres)
+                    if (
+                        self.direction == SUPERTYPE_OF
+                        and mypy.subtypes.is_subtype(actual, erase_typevars(call))
+                        or self.direction == SUBTYPE_OF
+                        and mypy.subtypes.is_subtype(erase_typevars(call), actual)
+                    ):
+                        res.extend(infer_constraints(call, actual, self.direction))
                     template.type.inferring.pop()
         if isinstance(actual, CallableType) and actual.fallback is not None:
-            if actual.is_type_obj() and template.type.is_protocol:
+            if (
+                actual.is_type_obj()
+                and template.type.is_protocol
+                and self.direction == SUPERTYPE_OF
+            ):
                 ret_type = get_proper_type(actual.ret_type)
                 if isinstance(ret_type, TupleType):
                     ret_type = mypy.typeops.tuple_fallback(ret_type)
                 if isinstance(ret_type, Instance):
-                    if self.direction == SUBTYPE_OF:
-                        subtype = template
-                    else:
-                        subtype = ret_type
                     res.extend(
                         self.infer_constraints_from_protocol_members(
-                            ret_type, template, subtype, template, class_obj=True
+                            ret_type, template, ret_type, template, class_obj=True
                         )
                     )
             actual = actual.fallback
         if isinstance(actual, TypeType) and template.type.is_protocol:
-            if isinstance(actual.item, Instance):
-                if self.direction == SUBTYPE_OF:
-                    subtype = template
-                else:
-                    subtype = actual.item
-                res.extend(
-                    self.infer_constraints_from_protocol_members(
-                        actual.item, template, subtype, template, class_obj=True
-                    )
-                )
             if self.direction == SUPERTYPE_OF:
-                # Infer constraints for Type[T] via metaclass of T when it makes sense.
                 a_item = actual.item
+                if isinstance(a_item, Instance):
+                    res.extend(
+                        self.infer_constraints_from_protocol_members(
+                            a_item, template, a_item, template, class_obj=True
+                        )
+                    )
+                # Infer constraints for Type[T] via metaclass of T when it makes sense.
                 if isinstance(a_item, TypeVarType):
                     a_item = get_proper_type(a_item.upper_bound)
                 if isinstance(a_item, Instance) and a_item.type.metaclass_type:
@@ -644,28 +831,23 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
                 tvars = mapped.type.defn.type_vars
 
                 if instance.type.has_type_var_tuple_type:
+                    # Variadic types need special handling to map each type argument to
+                    # the correct corresponding type variable.
                     assert instance.type.type_var_tuple_prefix is not None
                     assert instance.type.type_var_tuple_suffix is not None
-                    assert mapped.type.type_var_tuple_prefix is not None
-                    assert mapped.type.type_var_tuple_suffix is not None
-
-                    unpack_constraints, mapped_args, instance_args = build_constraints_for_unpack(
-                        mapped.args,
-                        mapped.type.type_var_tuple_prefix,
-                        mapped.type.type_var_tuple_suffix,
-                        instance.args,
-                        instance.type.type_var_tuple_prefix,
-                        instance.type.type_var_tuple_suffix,
-                        self.direction,
+                    prefix_len = instance.type.type_var_tuple_prefix
+                    suffix_len = instance.type.type_var_tuple_suffix
+                    tvt = instance.type.defn.type_vars[prefix_len]
+                    assert isinstance(tvt, TypeVarTupleType)
+                    fallback = tvt.tuple_fallback
+                    i_prefix, i_middle, i_suffix = split_with_prefix_and_suffix(
+                        instance.args, prefix_len, suffix_len
                     )
-                    res.extend(unpack_constraints)
-
-                    tvars_prefix, _, tvars_suffix = split_with_prefix_and_suffix(
-                        tuple(tvars),
-                        instance.type.type_var_tuple_prefix,
-                        instance.type.type_var_tuple_suffix,
+                    m_prefix, m_middle, m_suffix = split_with_prefix_and_suffix(
+                        mapped.args, prefix_len, suffix_len
                     )
-                    tvars = cast("list[TypeVarLikeType]", list(tvars_prefix + tvars_suffix))
+                    instance_args = i_prefix + (TupleType(list(i_middle), fallback),) + i_suffix
+                    mapped_args = m_prefix + (TupleType(list(m_middle), fallback),) + m_suffix
                 else:
                     mapped_args = mapped.args
                     instance_args = instance.args
@@ -673,7 +855,6 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
                 # N.B: We use zip instead of indexing because the lengths might have
                 # mismatches during daemon reprocessing.
                 for tvar, mapped_arg, instance_arg in zip(tvars, mapped_args, instance_args):
-                    # TODO(PEP612): More ParamSpec work (or is Parameters the only thing accepted)
                     if isinstance(tvar, TypeVarType):
                         # The constraints for generic type parameters depend on variance.
                         # Include constraints from both directions if invariant.
@@ -684,64 +865,60 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
                                 infer_constraints(mapped_arg, instance_arg, neg_op(self.direction))
                             )
                     elif isinstance(tvar, ParamSpecType) and isinstance(mapped_arg, ParamSpecType):
-                        suffix = get_proper_type(instance_arg)
-
-                        if isinstance(suffix, CallableType):
-                            prefix = mapped_arg.prefix
-                            from_concat = bool(prefix.arg_types) or suffix.from_concatenate
-                            suffix = suffix.copy_modified(from_concatenate=from_concat)
-
-                        if isinstance(suffix, (Parameters, CallableType)):
-                            # no such thing as variance for ParamSpecs
-                            # TODO: is there a case I am missing?
-                            # TODO: constraints between prefixes
-                            prefix = mapped_arg.prefix
-                            suffix = suffix.copy_modified(
-                                suffix.arg_types[len(prefix.arg_types) :],
-                                suffix.arg_kinds[len(prefix.arg_kinds) :],
-                                suffix.arg_names[len(prefix.arg_names) :],
+                        prefix = mapped_arg.prefix
+                        if isinstance(instance_arg, Parameters):
+                            # No such thing as variance for ParamSpecs, consider them invariant
+                            # TODO: constraints between prefixes using
+                            # infer_callable_arguments_constraints()
+                            suffix: Type = instance_arg.copy_modified(
+                                instance_arg.arg_types[len(prefix.arg_types) :],
+                                instance_arg.arg_kinds[len(prefix.arg_kinds) :],
+                                instance_arg.arg_names[len(prefix.arg_names) :],
                             )
+                            res.append(Constraint(mapped_arg, SUBTYPE_OF, suffix))
                             res.append(Constraint(mapped_arg, SUPERTYPE_OF, suffix))
-                        elif isinstance(suffix, ParamSpecType):
+                        elif isinstance(instance_arg, ParamSpecType):
+                            suffix = instance_arg.copy_modified(
+                                prefix=Parameters(
+                                    instance_arg.prefix.arg_types[len(prefix.arg_types) :],
+                                    instance_arg.prefix.arg_kinds[len(prefix.arg_kinds) :],
+                                    instance_arg.prefix.arg_names[len(prefix.arg_names) :],
+                                )
+                            )
+                            res.append(Constraint(mapped_arg, SUBTYPE_OF, suffix))
                             res.append(Constraint(mapped_arg, SUPERTYPE_OF, suffix))
-                    else:
-                        # This case should have been handled above.
-                        assert not isinstance(tvar, TypeVarTupleType)
+                    elif isinstance(tvar, TypeVarTupleType):
+                        # Handle variadic type variables covariantly for consistency.
+                        res.extend(infer_constraints(mapped_arg, instance_arg, self.direction))
 
                 return res
             elif self.direction == SUPERTYPE_OF and instance.type.has_base(template.type.fullname):
                 mapped = map_instance_to_supertype(instance, template.type)
                 tvars = template.type.defn.type_vars
                 if template.type.has_type_var_tuple_type:
-                    assert mapped.type.type_var_tuple_prefix is not None
-                    assert mapped.type.type_var_tuple_suffix is not None
+                    # Variadic types need special handling to map each type argument to
+                    # the correct corresponding type variable.
                     assert template.type.type_var_tuple_prefix is not None
                     assert template.type.type_var_tuple_suffix is not None
-
-                    unpack_constraints, mapped_args, template_args = build_constraints_for_unpack(
-                        mapped.args,
-                        mapped.type.type_var_tuple_prefix,
-                        mapped.type.type_var_tuple_suffix,
-                        template.args,
-                        template.type.type_var_tuple_prefix,
-                        template.type.type_var_tuple_suffix,
-                        self.direction,
+                    prefix_len = template.type.type_var_tuple_prefix
+                    suffix_len = template.type.type_var_tuple_suffix
+                    tvt = template.type.defn.type_vars[prefix_len]
+                    assert isinstance(tvt, TypeVarTupleType)
+                    fallback = tvt.tuple_fallback
+                    t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(
+                        template.args, prefix_len, suffix_len
                     )
-                    res.extend(unpack_constraints)
-
-                    tvars_prefix, _, tvars_suffix = split_with_prefix_and_suffix(
-                        tuple(tvars),
-                        template.type.type_var_tuple_prefix,
-                        template.type.type_var_tuple_suffix,
+                    m_prefix, m_middle, m_suffix = split_with_prefix_and_suffix(
+                        mapped.args, prefix_len, suffix_len
                     )
-                    tvars = cast("list[TypeVarLikeType]", list(tvars_prefix + tvars_suffix))
+                    template_args = t_prefix + (TupleType(list(t_middle), fallback),) + t_suffix
+                    mapped_args = m_prefix + (TupleType(list(m_middle), fallback),) + m_suffix
                 else:
                     mapped_args = mapped.args
                     template_args = template.args
                 # N.B: We use zip instead of indexing because the lengths might have
                 # mismatches during daemon reprocessing.
                 for tvar, mapped_arg, template_arg in zip(tvars, mapped_args, template_args):
-                    assert not isinstance(tvar, TypeVarTupleType)
                     if isinstance(tvar, TypeVarType):
                         # The constraints for generic type parameters depend on variance.
                         # Include constraints from both directions if invariant.
@@ -754,30 +931,32 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
                     elif isinstance(tvar, ParamSpecType) and isinstance(
                         template_arg, ParamSpecType
                     ):
-                        suffix = get_proper_type(mapped_arg)
-
-                        if isinstance(suffix, CallableType):
-                            prefix = template_arg.prefix
-                            from_concat = bool(prefix.arg_types) or suffix.from_concatenate
-                            suffix = suffix.copy_modified(from_concatenate=from_concat)
-
-                        if isinstance(suffix, (Parameters, CallableType)):
-                            # no such thing as variance for ParamSpecs
-                            # TODO: is there a case I am missing?
-                            # TODO: constraints between prefixes
-                            prefix = template_arg.prefix
-
-                            suffix = suffix.copy_modified(
-                                suffix.arg_types[len(prefix.arg_types) :],
-                                suffix.arg_kinds[len(prefix.arg_kinds) :],
-                                suffix.arg_names[len(prefix.arg_names) :],
+                        prefix = template_arg.prefix
+                        if isinstance(mapped_arg, Parameters):
+                            # No such thing as variance for ParamSpecs, consider them invariant
+                            # TODO: constraints between prefixes using
+                            # infer_callable_arguments_constraints()
+                            suffix = mapped_arg.copy_modified(
+                                mapped_arg.arg_types[len(prefix.arg_types) :],
+                                mapped_arg.arg_kinds[len(prefix.arg_kinds) :],
+                                mapped_arg.arg_names[len(prefix.arg_names) :],
                             )
+                            res.append(Constraint(template_arg, SUBTYPE_OF, suffix))
                             res.append(Constraint(template_arg, SUPERTYPE_OF, suffix))
-                        elif isinstance(suffix, ParamSpecType):
+                        elif isinstance(mapped_arg, ParamSpecType):
+                            suffix = mapped_arg.copy_modified(
+                                prefix=Parameters(
+                                    mapped_arg.prefix.arg_types[len(prefix.arg_types) :],
+                                    mapped_arg.prefix.arg_kinds[len(prefix.arg_kinds) :],
+                                    mapped_arg.prefix.arg_names[len(prefix.arg_names) :],
+                                )
+                            )
+                            res.append(Constraint(template_arg, SUBTYPE_OF, suffix))
                             res.append(Constraint(template_arg, SUPERTYPE_OF, suffix))
-                    else:
-                        # This case should have been handled above.
-                        assert not isinstance(tvar, TypeVarTupleType)
+                    elif isinstance(tvar, TypeVarTupleType):
+                        # Consider variadic type variables to be invariant.
+                        res.extend(infer_constraints(template_arg, mapped_arg, SUBTYPE_OF))
+                        res.extend(infer_constraints(template_arg, mapped_arg, SUPERTYPE_OF))
                 return res
             if (
                 template.type.is_protocol
@@ -829,13 +1008,23 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
             and self.direction == SUPERTYPE_OF
         ):
             for item in actual.items:
+                if isinstance(item, UnpackType):
+                    unpacked = get_proper_type(item.type)
+                    if isinstance(unpacked, TypeVarTupleType):
+                        # Cannot infer anything for T from [T, ...] <: *Ts
+                        continue
+                    assert (
+                        isinstance(unpacked, Instance)
+                        and unpacked.type.fullname == "builtins.tuple"
+                    )
+                    item = unpacked.args[0]
                 cb = infer_constraints(template.args[0], item, SUPERTYPE_OF)
                 res.extend(cb)
             return res
         elif isinstance(actual, TupleType) and self.direction == SUPERTYPE_OF:
             return infer_constraints(template, mypy.typeops.tuple_fallback(actual), self.direction)
         elif isinstance(actual, TypeVarType):
-            if not actual.values:
+            if not actual.values and not actual.id.is_meta_var():
                 return infer_constraints(template, actual.upper_bound, self.direction)
             return []
         elif isinstance(actual, ParamSpecType):
@@ -869,6 +1058,17 @@ def infer_constraints_from_protocol_members(
                 return []  # See #11020
             # The above is safe since at this point we know that 'instance' is a subtype
             # of (erased) 'template', therefore it defines all protocol members
+            if class_obj:
+                # For class objects we must only infer constraints if possible, otherwise it
+                # can lead to confusion between class and instance, for example StrEnum is
+                # Iterable[str] for an instance, but Iterable[StrEnum] for a class object.
+                if not mypy.subtypes.is_subtype(
+                    inst, erase_typevars(temp), ignore_pos_arg_names=True
+                ):
+                    continue
+            # This exception matches the one in subtypes.py, see PR #14121 for context.
+            if member == "__call__" and instance.type.is_metaclass():
+                continue
             res.extend(infer_constraints(temp, inst, self.direction))
             if mypy.subtypes.IS_SETTABLE in mypy.subtypes.get_member_flags(member, protocol):
                 # Settable members are invariant, add opposite constraints
@@ -879,83 +1079,126 @@ def visit_callable_type(self, template: CallableType) -> list[Constraint]:
         # Normalize callables before matching against each other.
         # Note that non-normalized callables can be created in annotations
         # using e.g. callback protocols.
-        template = template.with_unpacked_kwargs()
+        # TODO: check that callables match? Ideally we should not infer constraints
+        # callables that can never be subtypes of one another in given direction.
+        template = template.with_unpacked_kwargs().with_normalized_var_args()
+        extra_tvars = False
         if isinstance(self.actual, CallableType):
             res: list[Constraint] = []
-            cactual = self.actual.with_unpacked_kwargs()
+            cactual = self.actual.with_unpacked_kwargs().with_normalized_var_args()
             param_spec = template.param_spec()
+
+            template_ret_type, cactual_ret_type = template.ret_type, cactual.ret_type
+            if template.type_guard is not None and cactual.type_guard is not None:
+                template_ret_type = template.type_guard
+                cactual_ret_type = cactual.type_guard
+
+            if template.type_is is not None and cactual.type_is is not None:
+                template_ret_type = template.type_is
+                cactual_ret_type = cactual.type_is
+
+            res.extend(infer_constraints(template_ret_type, cactual_ret_type, self.direction))
+
             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 not self.skip_neg_op
+                    # 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.is_self() for tv in cactual.variables)
+                ):
+                    # If the actual callable is generic, infer constraints in the opposite
+                    # direction, and indicate to the solver there are extra type variables
+                    # to solve for (see more details in mypy/solve.py).
+                    res.extend(
+                        infer_constraints(
+                            cactual, template, neg_op(self.direction), skip_neg_op=True
+                        )
+                    )
+                    extra_tvars = True
 
                 # We can't infer constraints from arguments if the template is Callable[..., T]
                 # (with literal '...').
                 if not template.is_ellipsis_args:
-                    if find_unpack_in_list(template.arg_types) is not None:
-                        (
-                            unpack_constraints,
-                            cactual_args_t,
-                            template_args_t,
-                        ) = find_and_build_constraints_for_unpack(
-                            tuple(cactual.arg_types), tuple(template.arg_types), self.direction
+                    unpack_present = find_unpack_in_list(template.arg_types)
+                    # When both ParamSpec and TypeVarTuple are present, things become messy
+                    # quickly. For now, we only allow ParamSpec to "capture" TypeVarTuple,
+                    # but not vice versa.
+                    # TODO: infer more from prefixes when possible.
+                    if unpack_present is not None and not cactual.param_spec():
+                        # We need to re-normalize args to the form they appear in tuples,
+                        # for callables we always pack the suffix inside another tuple.
+                        unpack = template.arg_types[unpack_present]
+                        assert isinstance(unpack, UnpackType)
+                        tuple_type = get_tuple_fallback_from_unpack(unpack)
+                        template_types = repack_callable_args(template, tuple_type)
+                        actual_types = repack_callable_args(cactual, tuple_type)
+                        # Now we can use the same general helper as for tuple types.
+                        unpack_constraints = build_constraints_for_simple_unpack(
+                            template_types, actual_types, neg_op(self.direction)
                         )
-                        template_args = list(template_args_t)
-                        cactual_args = list(cactual_args_t)
                         res.extend(unpack_constraints)
-                        assert len(template_args) == len(cactual_args)
                     else:
-                        template_args = template.arg_types
-                        cactual_args = cactual.arg_types
-                    # The lengths should match, but don't crash (it will error elsewhere).
-                    for t, a in zip(template_args, cactual_args):
-                        # Negate direction due to function argument type contravariance.
-                        res.extend(infer_constraints(t, a, neg_op(self.direction)))
+                        # TODO: do we need some special-casing when unpack is present in actual
+                        # callable but not in template callable?
+                        res.extend(
+                            infer_callable_arguments_constraints(template, cactual, self.direction)
+                        )
             else:
-                # sometimes, it appears we try to get constraints between two paramspec callables?
-
-                # TODO: Direction
-                # TODO: check the prefixes match
                 prefix = param_spec.prefix
                 prefix_len = len(prefix.arg_types)
                 cactual_ps = cactual.param_spec()
 
-                if not cactual_ps:
-                    max_prefix_len = len([k for k in cactual.arg_kinds if k in (ARG_POS, ARG_OPT)])
-                    prefix_len = min(prefix_len, max_prefix_len)
-                    res.append(
-                        Constraint(
-                            param_spec,
-                            SUBTYPE_OF,
-                            cactual.copy_modified(
-                                arg_types=cactual.arg_types[prefix_len:],
-                                arg_kinds=cactual.arg_kinds[prefix_len:],
-                                arg_names=cactual.arg_names[prefix_len:],
-                                ret_type=UninhabitedType(),
-                            ),
+                if type_state.infer_polymorphic and cactual.variables and not self.skip_neg_op:
+                    # Similar logic to the branch above.
+                    res.extend(
+                        infer_constraints(
+                            cactual, template, neg_op(self.direction), skip_neg_op=True
                         )
                     )
-                else:
-                    res.append(Constraint(param_spec, SUBTYPE_OF, cactual_ps))
+                    extra_tvars = True
 
-                # compare prefixes
+                # Compare prefixes as well
                 cactual_prefix = cactual.copy_modified(
                     arg_types=cactual.arg_types[:prefix_len],
                     arg_kinds=cactual.arg_kinds[:prefix_len],
                     arg_names=cactual.arg_names[:prefix_len],
                 )
+                res.extend(
+                    infer_callable_arguments_constraints(prefix, cactual_prefix, self.direction)
+                )
 
-                # TODO: see above "FIX" comments for param_spec is None case
-                # TODO: this assumes positional arguments
-                for t, a in zip(prefix.arg_types, cactual_prefix.arg_types):
-                    res.extend(infer_constraints(t, a, neg_op(self.direction)))
-
-            template_ret_type, cactual_ret_type = template.ret_type, cactual.ret_type
-            if template.type_guard is not None:
-                template_ret_type = template.type_guard
-            if cactual.type_guard is not None:
-                cactual_ret_type = cactual.type_guard
-
-            res.extend(infer_constraints(template_ret_type, cactual_ret_type, self.direction))
+                param_spec_target: Type | None = None
+                if not cactual_ps:
+                    max_prefix_len = len([k for k in cactual.arg_kinds if k in (ARG_POS, ARG_OPT)])
+                    prefix_len = min(prefix_len, max_prefix_len)
+                    param_spec_target = Parameters(
+                        arg_types=cactual.arg_types[prefix_len:],
+                        arg_kinds=cactual.arg_kinds[prefix_len:],
+                        arg_names=cactual.arg_names[prefix_len:],
+                        variables=cactual.variables if not type_state.infer_polymorphic else [],
+                        imprecise_arg_kinds=cactual.imprecise_arg_kinds,
+                    )
+                else:
+                    if len(param_spec.prefix.arg_types) <= len(cactual_ps.prefix.arg_types):
+                        param_spec_target = cactual_ps.copy_modified(
+                            prefix=Parameters(
+                                arg_types=cactual_ps.prefix.arg_types[prefix_len:],
+                                arg_kinds=cactual_ps.prefix.arg_kinds[prefix_len:],
+                                arg_names=cactual_ps.prefix.arg_names[prefix_len:],
+                                imprecise_arg_kinds=cactual_ps.prefix.imprecise_arg_kinds,
+                            )
+                        )
+                if param_spec_target is not None:
+                    res.append(Constraint(param_spec, self.direction, param_spec_target))
+            if extra_tvars:
+                for c in res:
+                    c.extra_tvars += cactual.variables
             return res
         elif isinstance(self.actual, AnyType):
             param_spec = template.param_spec()
@@ -968,7 +1211,7 @@ def visit_callable_type(self, template: CallableType) -> list[Constraint]:
                     Constraint(
                         param_spec,
                         SUBTYPE_OF,
-                        callable_with_ellipsis(any_type, any_type, template.fallback),
+                        Parameters([any_type, any_type], [ARG_STAR, ARG_STAR2], [None, None]),
                     )
                 ]
             res.extend(infer_constraints(template.ret_type, any_type, self.direction))
@@ -1012,24 +1255,68 @@ def visit_tuple_type(self, template: TupleType) -> list[Constraint]:
             res: list[Constraint] = []
             if unpack_index is not None:
                 if is_varlength_tuple:
+                    # Variadic tuple can be only a supertype of a tuple type, but even if
+                    # direction is opposite, inferring something may give better error messages.
                     unpack_type = template.items[unpack_index]
                     assert isinstance(unpack_type, UnpackType)
-                    unpacked_type = unpack_type.type
-                    assert isinstance(unpacked_type, TypeVarTupleType)
-                    return [Constraint(type_var=unpacked_type, op=self.direction, target=actual)]
+                    unpacked_type = get_proper_type(unpack_type.type)
+                    if isinstance(unpacked_type, TypeVarTupleType):
+                        res = [
+                            Constraint(type_var=unpacked_type, op=self.direction, target=actual)
+                        ]
+                    else:
+                        assert (
+                            isinstance(unpacked_type, Instance)
+                            and unpacked_type.type.fullname == "builtins.tuple"
+                        )
+                        res = infer_constraints(unpacked_type, actual, self.direction)
+                    assert isinstance(actual, Instance)  # ensured by is_varlength_tuple == True
+                    for i, ti in enumerate(template.items):
+                        if i == unpack_index:
+                            # This one we just handled above.
+                            continue
+                        # For Tuple[T, *Ts, S] <: tuple[X, ...] infer also T <: X and S <: X.
+                        res.extend(infer_constraints(ti, actual.args[0], self.direction))
+                    return res
                 else:
                     assert isinstance(actual, TupleType)
-                    (
-                        unpack_constraints,
-                        actual_items,
-                        template_items,
-                    ) = find_and_build_constraints_for_unpack(
-                        tuple(actual.items), tuple(template.items), self.direction
+                    unpack_constraints = build_constraints_for_simple_unpack(
+                        template.items, actual.items, self.direction
                     )
+                    actual_items: tuple[Type, ...] = ()
+                    template_items: tuple[Type, ...] = ()
                     res.extend(unpack_constraints)
             elif isinstance(actual, TupleType):
-                actual_items = tuple(actual.items)
-                template_items = tuple(template.items)
+                a_unpack_index = find_unpack_in_list(actual.items)
+                if a_unpack_index is not None:
+                    # The case where template tuple doesn't have an unpack, but actual tuple
+                    # has an unpack. We can infer something if actual unpack is a variadic tuple.
+                    # Tuple[T, S, U] <: tuple[X, *tuple[Y, ...], Z] => T <: X, S <: Y, U <: Z.
+                    a_unpack = actual.items[a_unpack_index]
+                    assert isinstance(a_unpack, UnpackType)
+                    a_unpacked = get_proper_type(a_unpack.type)
+                    if len(actual.items) + 1 <= len(template.items):
+                        a_prefix_len = a_unpack_index
+                        a_suffix_len = len(actual.items) - a_unpack_index - 1
+                        t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(
+                            tuple(template.items), a_prefix_len, a_suffix_len
+                        )
+                        actual_items = tuple(actual.items[:a_prefix_len])
+                        if a_suffix_len:
+                            actual_items += tuple(actual.items[-a_suffix_len:])
+                        template_items = t_prefix + t_suffix
+                        if isinstance(a_unpacked, Instance):
+                            assert a_unpacked.type.fullname == "builtins.tuple"
+                            for tm in t_middle:
+                                res.extend(
+                                    infer_constraints(tm, a_unpacked.args[0], self.direction)
+                                )
+                    else:
+                        actual_items = ()
+                        template_items = ()
+                else:
+                    actual_items = tuple(actual.items)
+                    template_items = tuple(template.items)
             else:
                 return res
 
@@ -1079,9 +1366,16 @@ def visit_type_alias_type(self, template: TypeAliasType) -> list[Constraint]:
 
     def infer_against_any(self, types: Iterable[Type], any_type: AnyType) -> list[Constraint]:
         res: list[Constraint] = []
-        for t in types:
-            if isinstance(t, UnpackType) and isinstance(t.type, TypeVarTupleType):
-                res.append(Constraint(t.type, self.direction, any_type))
+        # Some items may be things like `*Tuple[*Ts, T]` for example from callable types with
+        # suffix after *arg, so flatten them.
+        for t in flatten_nested_tuples(types):
+            if isinstance(t, UnpackType):
+                if isinstance(t.type, TypeVarTupleType):
+                    res.append(Constraint(t.type, self.direction, any_type))
+                else:
+                    unpacked = get_proper_type(t.type)
+                    assert isinstance(unpacked, Instance)
+                    res.extend(infer_constraints(unpacked, any_type, self.direction))
             else:
                 # Note that we ignore variance and simply always use the
                 # original direction. This is because for Any targets direction is
@@ -1130,7 +1424,11 @@ def find_matching_overload_item(overloaded: Overloaded, template: CallableType)
         # Return type may be indeterminate in the template, so ignore it when performing a
         # subtype check.
         if mypy.subtypes.is_callable_compatible(
-            item, template, is_compat=mypy.subtypes.is_subtype, ignore_return=True
+            item,
+            template,
+            is_compat=mypy.subtypes.is_subtype,
+            is_proper_subtype=False,
+            ignore_return=True,
         ):
             return item
     # Fall back to the first item if we can't find a match. This is totally arbitrary --
@@ -1148,7 +1446,11 @@ def find_matching_overload_items(
         # Return type may be indeterminate in the template, so ignore it when performing a
         # subtype check.
         if mypy.subtypes.is_callable_compatible(
-            item, template, is_compat=mypy.subtypes.is_subtype, ignore_return=True
+            item,
+            template,
+            is_compat=mypy.subtypes.is_subtype,
+            is_proper_subtype=False,
+            ignore_return=True,
         ):
             res.append(item)
     if not res:
@@ -1158,83 +1460,246 @@ def find_matching_overload_items(
     return res
 
 
-def find_and_build_constraints_for_unpack(
-    mapped: tuple[Type, ...], template: tuple[Type, ...], direction: int
-) -> tuple[list[Constraint], tuple[Type, ...], tuple[Type, ...]]:
-    mapped_prefix_len = find_unpack_in_list(mapped)
-    if mapped_prefix_len is not None:
-        mapped_suffix_len: int | None = len(mapped) - mapped_prefix_len - 1
+def get_tuple_fallback_from_unpack(unpack: UnpackType) -> TypeInfo:
+    """Get builtins.tuple type from available types to construct homogeneous tuples."""
+    tp = get_proper_type(unpack.type)
+    if isinstance(tp, Instance) and tp.type.fullname == "builtins.tuple":
+        return tp.type
+    if isinstance(tp, TypeVarTupleType):
+        return tp.tuple_fallback.type
+    if isinstance(tp, TupleType):
+        for base in tp.partial_fallback.type.mro:
+            if base.fullname == "builtins.tuple":
+                return base
+    assert False, "Invalid unpack type"
+
+
+def repack_callable_args(callable: CallableType, tuple_type: TypeInfo) -> list[Type]:
+    """Present callable with star unpack in a normalized form.
+
+    Since positional arguments cannot follow star argument, they are packed in a suffix,
+    while prefix is represented as individual positional args. We want to put all in a single
+    list with unpack in the middle, and prefix/suffix on the sides (as they would appear
+    in e.g. a TupleType).
+    """
+    if ARG_STAR not in callable.arg_kinds:
+        return callable.arg_types
+    star_index = callable.arg_kinds.index(ARG_STAR)
+    arg_types = callable.arg_types[:star_index]
+    star_type = callable.arg_types[star_index]
+    suffix_types = []
+    if not isinstance(star_type, UnpackType):
+        # Re-normalize *args: X -> *args: *tuple[X, ...]
+        star_type = UnpackType(Instance(tuple_type, [star_type]))
     else:
-        mapped_suffix_len = None
-
-    template_prefix_len = find_unpack_in_list(template)
-    assert template_prefix_len is not None
-    template_suffix_len = len(template) - template_prefix_len - 1
-
-    return build_constraints_for_unpack(
-        mapped,
-        mapped_prefix_len,
-        mapped_suffix_len,
-        template,
-        template_prefix_len,
-        template_suffix_len,
-        direction,
+        tp = get_proper_type(star_type.type)
+        if isinstance(tp, TupleType):
+            assert isinstance(tp.items[0], UnpackType)
+            star_type = tp.items[0]
+            suffix_types = tp.items[1:]
+    return arg_types + [star_type] + suffix_types
+
+
+def build_constraints_for_simple_unpack(
+    template_args: list[Type], actual_args: list[Type], direction: int
+) -> list[Constraint]:
+    """Infer constraints between two lists of types with variadic items.
+
+    This function is only supposed to be called when a variadic item is present in templates.
+    If there is no variadic item the actuals, we simply use split_with_prefix_and_suffix()
+    and infer prefix <: prefix, suffix <: suffix, variadic <: middle. If there is a variadic
+    item in the actuals we need to be more careful, only common prefix/suffix can generate
+    constraints, also we can only infer constraints for variadic template item, if template
+    prefix/suffix are shorter that actual ones, otherwise there may be partial overlap
+    between variadic items, for example if template prefix is longer:
+
+        templates: T1, T2, Ts, Ts, Ts, ...
+        actuals:   A1, As, As, As, ...
+
+    Note: this function can only be called for builtin variadic constructors: Tuple and Callable.
+    For instances, you should first find correct type argument mapping.
+    """
+    template_unpack = find_unpack_in_list(template_args)
+    assert template_unpack is not None
+    template_prefix = template_unpack
+    template_suffix = len(template_args) - template_prefix - 1
+
+    t_unpack = None
+    res = []
+
+    actual_unpack = find_unpack_in_list(actual_args)
+    if actual_unpack is None:
+        t_unpack = template_args[template_unpack]
+        if template_prefix + template_suffix > len(actual_args):
+            # These can't be subtypes of each-other, return fast.
+            assert isinstance(t_unpack, UnpackType)
+            if isinstance(t_unpack.type, TypeVarTupleType):
+                # Set TypeVarTuple to empty to improve error messages.
+                return [
+                    Constraint(
+                        t_unpack.type, direction, TupleType([], t_unpack.type.tuple_fallback)
+                    )
+                ]
+            else:
+                return []
+        common_prefix = template_prefix
+        common_suffix = template_suffix
+    else:
+        actual_prefix = actual_unpack
+        actual_suffix = len(actual_args) - actual_prefix - 1
+        common_prefix = min(template_prefix, actual_prefix)
+        common_suffix = min(template_suffix, actual_suffix)
+        if actual_prefix >= template_prefix and actual_suffix >= template_suffix:
+            # This is the only case where we can guarantee there will be no partial overlap
+            # (note however partial overlap is OK for variadic tuples, it is handled below).
+            t_unpack = template_args[template_unpack]
+
+    # Handle constraints from prefixes/suffixes first.
+    start, middle, end = split_with_prefix_and_suffix(
+        tuple(actual_args), common_prefix, common_suffix
     )
+    for t, a in zip(template_args[:common_prefix], start):
+        res.extend(infer_constraints(t, a, direction))
+    if common_suffix:
+        for t, a in zip(template_args[-common_suffix:], end):
+            res.extend(infer_constraints(t, a, direction))
+
+    if t_unpack is not None:
+        # Add constraint(s) for variadic item when possible.
+        assert isinstance(t_unpack, UnpackType)
+        tp = get_proper_type(t_unpack.type)
+        if isinstance(tp, Instance) and tp.type.fullname == "builtins.tuple":
+            # Homogeneous case *tuple[T, ...] <: [X, Y, Z, ...].
+            for a in middle:
+                # TODO: should we use union instead of join here?
+                if not isinstance(a, UnpackType):
+                    res.extend(infer_constraints(tp.args[0], a, direction))
+                else:
+                    a_tp = get_proper_type(a.type)
+                    # This is the case *tuple[T, ...] <: *tuple[A, ...].
+                    if isinstance(a_tp, Instance) and a_tp.type.fullname == "builtins.tuple":
+                        res.extend(infer_constraints(tp.args[0], a_tp.args[0], direction))
+        elif isinstance(tp, TypeVarTupleType):
+            res.append(Constraint(tp, direction, TupleType(list(middle), tp.tuple_fallback)))
+    elif actual_unpack is not None:
+        # A special case for a variadic tuple unpack, we simply infer T <: X from
+        # Tuple[..., *tuple[T, ...], ...] <: Tuple[..., *tuple[X, ...], ...].
+        actual_unpack_type = actual_args[actual_unpack]
+        assert isinstance(actual_unpack_type, UnpackType)
+        a_unpacked = get_proper_type(actual_unpack_type.type)
+        if isinstance(a_unpacked, Instance) and a_unpacked.type.fullname == "builtins.tuple":
+            t_unpack = template_args[template_unpack]
+            assert isinstance(t_unpack, UnpackType)
+            tp = get_proper_type(t_unpack.type)
+            if isinstance(tp, Instance) and tp.type.fullname == "builtins.tuple":
+                res.extend(infer_constraints(tp.args[0], a_unpacked.args[0], direction))
+    return res
 
 
-def build_constraints_for_unpack(
-    mapped: tuple[Type, ...],
-    mapped_prefix_len: int | None,
-    mapped_suffix_len: int | None,
-    template: tuple[Type, ...],
-    template_prefix_len: int,
-    template_suffix_len: int,
+def infer_directed_arg_constraints(left: Type, right: Type, direction: int) -> list[Constraint]:
+    """Infer constraints between two arguments using direction between original callables."""
+    if isinstance(left, (ParamSpecType, UnpackType)) or isinstance(
+        right, (ParamSpecType, UnpackType)
+    ):
+        # This avoids bogus constraints like T <: P.args
+        # TODO: can we infer something useful for *T vs P?
+        return []
+    if direction == SUBTYPE_OF:
+        # We invert direction to account for argument contravariance.
+        return infer_constraints(left, right, neg_op(direction))
+    else:
+        return infer_constraints(right, left, neg_op(direction))
+
+
+def infer_callable_arguments_constraints(
+    template: NormalizedCallableType | Parameters,
+    actual: NormalizedCallableType | Parameters,
     direction: int,
-) -> tuple[list[Constraint], tuple[Type, ...], tuple[Type, ...]]:
-    if mapped_prefix_len is None:
-        mapped_prefix_len = template_prefix_len
-    if mapped_suffix_len is None:
-        mapped_suffix_len = template_suffix_len
-
-    split_result = split_with_mapped_and_template(
-        mapped,
-        mapped_prefix_len,
-        mapped_suffix_len,
-        template,
-        template_prefix_len,
-        template_suffix_len,
-    )
-    assert split_result is not None
-    (
-        mapped_prefix,
-        mapped_middle,
-        mapped_suffix,
-        template_prefix,
-        template_middle,
-        template_suffix,
-    ) = split_result
-
-    template_unpack = extract_unpack(template_middle)
-    res = []
+) -> list[Constraint]:
+    """Infer constraints between argument types of two callables.
 
-    if template_unpack is not None:
-        if isinstance(template_unpack, TypeVarTupleType):
-            res.append(
-                Constraint(
-                    template_unpack,
-                    direction,
-                    TupleType(list(mapped_middle), template_unpack.tuple_fallback),
+    This function essentially extracts four steps from are_parameters_compatible() in
+    subtypes.py that involve subtype checks between argument types. We keep the argument
+    matching logic, but ignore various strictness flags present there, and checks that
+    do not involve subtyping. Then in place of every subtype check we put an infer_constraints()
+    call for the same types.
+    """
+    res = []
+    if direction == SUBTYPE_OF:
+        left, right = template, actual
+    else:
+        left, right = actual, template
+    left_star = left.var_arg()
+    left_star2 = left.kw_arg()
+    right_star = right.var_arg()
+    right_star2 = right.kw_arg()
+
+    # Numbering of steps below matches the one in are_parameters_compatible() for convenience.
+    # Phase 1a: compare star vs star arguments.
+    if left_star is not None and right_star is not None:
+        res.extend(infer_directed_arg_constraints(left_star.typ, right_star.typ, direction))
+    if left_star2 is not None and right_star2 is not None:
+        res.extend(infer_directed_arg_constraints(left_star2.typ, right_star2.typ, direction))
+
+    # Phase 1b: compare left args with corresponding non-star right arguments.
+    for right_arg in right.formal_arguments():
+        left_arg = mypy.typeops.callable_corresponding_argument(left, right_arg)
+        if left_arg is None:
+            continue
+        res.extend(infer_directed_arg_constraints(left_arg.typ, right_arg.typ, direction))
+
+    # Phase 1c: compare left args with right *args.
+    if right_star is not None:
+        right_by_position = right.try_synthesizing_arg_from_vararg(None)
+        assert right_by_position is not None
+        i = right_star.pos
+        assert i is not None
+        while i < len(left.arg_kinds) and left.arg_kinds[i].is_positional():
+            left_by_position = left.argument_by_position(i)
+            assert left_by_position is not None
+            res.extend(
+                infer_directed_arg_constraints(
+                    left_by_position.typ, right_by_position.typ, direction
                 )
             )
-        elif (
-            isinstance(template_unpack, Instance)
-            and template_unpack.type.fullname == "builtins.tuple"
+            i += 1
+
+    # Phase 1d: compare left args with right **kwargs.
+    if right_star2 is not None:
+        right_names = {name for name in right.arg_names if name is not None}
+        left_only_names = set()
+        for name, kind in zip(left.arg_names, left.arg_kinds):
+            if name is None or kind.is_star() or name in right_names:
+                continue
+            left_only_names.add(name)
+
+        right_by_name = right.try_synthesizing_arg_from_kwarg(None)
+        assert right_by_name is not None
+        for name in left_only_names:
+            left_by_name = left.argument_by_name(name)
+            assert left_by_name is not None
+            res.extend(
+                infer_directed_arg_constraints(left_by_name.typ, right_by_name.typ, direction)
+            )
+    return res
+
+
+def filter_imprecise_kinds(cs: list[Constraint]) -> list[Constraint]:
+    """For each ParamSpec remove all imprecise constraints, if at least one precise available."""
+    have_precise = set()
+    for c in cs:
+        if not isinstance(c.origin_type_var, ParamSpecType):
+            continue
+        if (
+            isinstance(c.target, ParamSpecType)
+            or isinstance(c.target, Parameters)
+            and not c.target.imprecise_arg_kinds
         ):
-            for item in mapped_middle:
-                res.extend(infer_constraints(template_unpack.args[0], item, direction))
-
-        elif isinstance(template_unpack, TupleType):
-            if len(template_unpack.items) == len(mapped_middle):
-                for template_arg, item in zip(template_unpack.items, mapped_middle):
-                    res.extend(infer_constraints(template_arg, item, direction))
-    return (res, mapped_prefix + mapped_suffix, template_prefix + template_suffix)
+            have_precise.add(c.type_var)
+    new_cs = []
+    for c in cs:
+        if not isinstance(c.origin_type_var, ParamSpecType) or c.type_var not in have_precise:
+            new_cs.append(c)
+        if not isinstance(c.target, Parameters) or not c.target.imprecise_arg_kinds:
+            new_cs.append(c)
+    return new_cs
diff --git a/mypy/copytype.py b/mypy/copytype.py
index 0b63c8e07ae8..ecb1a89759b6 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:
@@ -53,7 +53,7 @@ def visit_none_type(self, t: NoneType) -> ProperType:
         return self.copy_common(t, NoneType())
 
     def visit_uninhabited_type(self, t: UninhabitedType) -> ProperType:
-        dup = UninhabitedType(t.is_noreturn)
+        dup = UninhabitedType()
         dup.ambiguous = t.ambiguous
         return self.copy_common(t, dup)
 
@@ -107,7 +107,9 @@ def visit_tuple_type(self, t: TupleType) -> ProperType:
         return self.copy_common(t, TupleType(t.items, t.partial_fallback, implicit=t.implicit))
 
     def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
-        return self.copy_common(t, TypedDictType(t.items, t.required_keys, t.fallback))
+        return self.copy_common(
+            t, TypedDictType(t.items, t.required_keys, t.readonly_keys, t.fallback)
+        )
 
     def visit_literal_type(self, t: LiteralType) -> ProperType:
         return self.copy_common(t, LiteralType(value=t.value, fallback=t.fallback))
diff --git a/mypy/defaults.py b/mypy/defaults.py
index d167997464f4..45ad6fe3076c 100644
--- a/mypy/defaults.py
+++ b/mypy/defaults.py
@@ -1,30 +1,26 @@
 from __future__ import annotations
 
 import os
-from typing_extensions import Final
-
-PYTHON2_VERSION: Final = (2, 7)
+from typing import Final
 
 # 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, 9)
 
 # Earliest Python 3.x version supported via --python-version 3.x. To run
 # mypy, at least version PYTHON3_VERSION is needed.
-PYTHON3_VERSION_MIN: Final = (3, 4)
+PYTHON3_VERSION_MIN: Final = (3, 8)  # Keep in sync with typeshed's python support
 
 CACHE_DIR: Final = ".mypy_cache"
-CONFIG_FILE: Final = ["mypy.ini", ".mypy.ini"]
-PYPROJECT_CONFIG_FILES: Final = ["pyproject.toml"]
-SHARED_CONFIG_FILES: Final = ["setup.cfg"]
-USER_CONFIG_FILES: Final = ["~/.config/mypy/config", "~/.mypy.ini"]
+
+CONFIG_NAMES: Final = ["mypy.ini", ".mypy.ini"]
+SHARED_CONFIG_NAMES: Final = ["pyproject.toml", "setup.cfg"]
+
+USER_CONFIG_FILES: list[str] = ["~/.config/mypy/config", "~/.mypy.ini"]
 if os.environ.get("XDG_CONFIG_HOME"):
     USER_CONFIG_FILES.insert(0, os.path.join(os.environ["XDG_CONFIG_HOME"], "mypy/config"))
-
-CONFIG_FILES: Final = (
-    CONFIG_FILE + PYPROJECT_CONFIG_FILES + SHARED_CONFIG_FILES + USER_CONFIG_FILES
-)
+USER_CONFIG_FILES = [os.path.expanduser(f) for f in USER_CONFIG_FILES]
 
 # This must include all reporters defined in mypy.report. This is defined here
 # to make reporter names available without importing mypy.report -- this speeds
diff --git a/mypy/dmypy/client.py b/mypy/dmypy/client.py
index 0e9120608509..90c3062bcbe5 100644
--- a/mypy/dmypy/client.py
+++ b/mypy/dmypy/client.py
@@ -14,11 +14,13 @@
 import sys
 import time
 import traceback
-from typing import Any, Callable, Mapping, NoReturn
+from collections.abc import Mapping
+from typing import Any, Callable, NoReturn
 
 from mypy.dmypy_os import alive, kill
-from mypy.dmypy_util import DEFAULT_STATUS_FILE, receive
+from mypy.dmypy_util import DEFAULT_STATUS_FILE, receive, send
 from mypy.ipc import IPCClient, IPCException
+from mypy.main import RECURSION_LIMIT
 from mypy.util import check_python_version, get_terminal_width, should_force_color
 from mypy.version import __version__
 
@@ -27,13 +29,16 @@
 
 
 class AugmentedHelpFormatter(argparse.RawDescriptionHelpFormatter):
-    def __init__(self, prog: str) -> None:
-        super().__init__(prog=prog, max_help_position=30)
+    def __init__(self, prog: str, **kwargs: Any) -> None:
+        super().__init__(prog=prog, max_help_position=30, **kwargs)
 
 
 parser = argparse.ArgumentParser(
     prog="dmypy", description="Client for mypy daemon mode", fromfile_prefix_chars="@"
 )
+if sys.version_info >= (3, 14):
+    parser.color = True  # Set as init arg in 3.14
+
 parser.set_defaults(action=None)
 parser.add_argument(
     "--status-file", default=DEFAULT_STATUS_FILE, help="status file to retrieve daemon details"
@@ -267,6 +272,10 @@ class BadStatus(Exception):
 def main(argv: list[str]) -> None:
     """The code is top-down."""
     check_python_version("dmypy")
+
+    # set recursion limit consistent with mypy/main.py
+    sys.setrecursionlimit(RECURSION_LIMIT)
+
     args = parser.parse_args(argv)
     if not args.action:
         parser.print_usage()
@@ -436,7 +445,7 @@ def do_status(args: argparse.Namespace) -> None:
     if args.verbose or "error" in response:
         show_stats(response)
     if "error" in response:
-        fail(f"Daemon is stuck; consider {sys.argv[0]} kill")
+        fail(f"Daemon may be busy processing; if this persists, consider {sys.argv[0]} kill")
     print("Daemon is up and running")
 
 
@@ -447,7 +456,7 @@ def do_stop(args: argparse.Namespace) -> None:
     response = request(args.status_file, "stop", timeout=5)
     if "error" in response:
         show_stats(response)
-        fail(f"Daemon is stuck; consider {sys.argv[0]} kill")
+        fail(f"Daemon may be busy processing; if this persists, consider {sys.argv[0]} kill")
     else:
         print("Daemon stopped")
 
@@ -562,6 +571,7 @@ def check_output(
     sys.stdout.write(out)
     sys.stdout.flush()
     sys.stderr.write(err)
+    sys.stderr.flush()
     if verbose:
         show_stats(response)
     if junit_xml:
@@ -572,7 +582,7 @@ def check_output(
         write_junit_xml(
             response["roundtrip_time"],
             bool(err),
-            messages,
+            {None: messages} if messages else {},
             junit_xml,
             response["python_version"],
             response["platform"],
@@ -588,13 +598,14 @@ def check_output(
 
 def show_stats(response: Mapping[str, object]) -> None:
     for key, value in sorted(response.items()):
-        if key not in ("out", "err"):
-            print("%-24s: %10s" % (key, "%.3f" % value if isinstance(value, float) else value))
-        else:
+        if key in ("out", "err", "stdout", "stderr"):
+            # Special case text output to display just 40 characters of text
             value = repr(value)[1:-1]
             if len(value) > 50:
-                value = value[:40] + " ..."
+                value = f"{value[:40]} ... {len(value)-40} more characters"
             print("%-24s: %s" % (key, value))
+            continue
+        print("%-24s: %10s" % (key, "%.3f" % value if isinstance(value, float) else value))
 
 
 @action(hang_parser)
@@ -657,26 +668,29 @@ def request(
     # so that it can format the type checking output accordingly.
     args["is_tty"] = sys.stdout.isatty() or should_force_color()
     args["terminal_width"] = get_terminal_width()
-    bdata = json.dumps(args).encode("utf8")
     _, name = get_status(status_file)
     try:
         with IPCClient(name, timeout) as client:
-            client.write(bdata)
-            response = receive(client)
+            send(client, args)
+
+            final = False
+            while not final:
+                response = receive(client)
+                final = bool(response.pop("final", False))
+                # Display debugging output written to stdout/stderr in the server process for convenience.
+                # This should not be confused with "out" and "err" fields in the response.
+                # Those fields hold the output of the "check" command, and are handled in check_output().
+                stdout = response.pop("stdout", None)
+                if stdout:
+                    sys.stdout.write(stdout)
+                stderr = response.pop("stderr", None)
+                if stderr:
+                    sys.stderr.write(stderr)
     except (OSError, IPCException) as err:
         return {"error": str(err)}
     # TODO: Other errors, e.g. ValueError, UnicodeError
-    else:
-        # Display debugging output written to stdout/stderr in the server process for convenience.
-        stdout = response.get("stdout")
-        if stdout:
-            sys.stdout.write(stdout)
-        stderr = response.get("stderr")
-        if stderr:
-            print("-" * 79)
-            print("stderr:")
-            sys.stdout.write(stderr)
-        return response
+
+    return response
 
 
 def get_status(status_file: str) -> tuple[int, str]:
diff --git a/mypy/dmypy_server.py b/mypy/dmypy_server.py
index c742f3116402..33e9e07477ca 100644
--- a/mypy/dmypy_server.py
+++ b/mypy/dmypy_server.py
@@ -16,14 +16,15 @@
 import sys
 import time
 import traceback
+from collections.abc import Sequence, Set as AbstractSet
 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 Any, Callable, Final
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.build
 import mypy.errors
 import mypy.main
-from mypy.dmypy_util import receive
+from mypy.dmypy_util import WriteToConn, receive, send
 from mypy.find_sources import InvalidSourceList, create_source_list
 from mypy.fscache import FileSystemCache
 from mypy.fswatcher import FileData, FileSystemWatcher
@@ -161,9 +162,9 @@ def ignore_suppressed_imports(module: str) -> bool:
     return module.startswith("encodings.")
 
 
-ModulePathPair: _TypeAlias = Tuple[str, str]
-ModulePathPairs: _TypeAlias = List[ModulePathPair]
-ChangesAndRemovals: _TypeAlias = Tuple[ModulePathPairs, ModulePathPairs]
+ModulePathPair: _TypeAlias = tuple[str, str]
+ModulePathPairs: _TypeAlias = list[ModulePathPair]
+ChangesAndRemovals: _TypeAlias = tuple[ModulePathPairs, ModulePathPairs]
 
 
 class Server:
@@ -208,8 +209,12 @@ def _response_metadata(self) -> dict[str, str]:
 
     def serve(self) -> None:
         """Serve requests, synchronously (no thread or fork)."""
+
         command = None
         server = IPCServer(CONNECTION_NAME, self.timeout)
+        orig_stdout = sys.stdout
+        orig_stderr = sys.stderr
+
         try:
             with open(self.status_file, "w") as f:
                 json.dump({"pid": os.getpid(), "connection_name": server.connection_name}, f)
@@ -217,10 +222,8 @@ def serve(self) -> None:
             while True:
                 with server:
                     data = receive(server)
-                    debug_stdout = io.StringIO()
-                    debug_stderr = io.StringIO()
-                    sys.stdout = debug_stdout
-                    sys.stderr = debug_stderr
+                    sys.stdout = WriteToConn(server, "stdout", sys.stdout.isatty())
+                    sys.stderr = WriteToConn(server, "stderr", sys.stderr.isatty())
                     resp: dict[str, Any] = {}
                     if "command" not in data:
                         resp = {"error": "No command found in request"}
@@ -237,21 +240,23 @@ def serve(self) -> None:
                                 tb = traceback.format_exception(*sys.exc_info())
                                 resp = {"error": "Daemon crashed!\n" + "".join(tb)}
                                 resp.update(self._response_metadata())
-                                resp["stdout"] = debug_stdout.getvalue()
-                                resp["stderr"] = debug_stderr.getvalue()
-                                server.write(json.dumps(resp).encode("utf8"))
+                                resp["final"] = True
+                                send(server, resp)
                                 raise
-                    resp["stdout"] = debug_stdout.getvalue()
-                    resp["stderr"] = debug_stderr.getvalue()
+                    resp["final"] = True
                     try:
                         resp.update(self._response_metadata())
-                        server.write(json.dumps(resp).encode("utf8"))
+                        send(server, resp)
                     except OSError:
                         pass  # Maybe the client hung up
                     if command == "stop":
                         reset_global_state()
                         sys.exit(0)
         finally:
+            # Revert stdout/stderr so we can see any errors.
+            sys.stdout = orig_stdout
+            sys.stderr = orig_stderr
+
             # If the final command is something other than a clean
             # stop, remove the status file. (We can't just
             # simplify the logic and always remove the file, since
@@ -330,7 +335,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"}
@@ -379,6 +384,9 @@ def cmd_recheck(
             removals = set(remove)
             sources = [s for s in sources if s.path and s.path not in removals]
         if update:
+            # Sort list of file updates by extension, so *.pyi files are first.
+            update.sort(key=lambda f: os.path.splitext(f)[1], reverse=True)
+
             known = {s.path for s in sources if s.path}
             added = [p for p in update if p not in known]
             try:
@@ -389,15 +397,21 @@ def cmd_recheck(
         t1 = time.time()
         manager = self.fine_grained_manager.manager
         manager.log(f"fine-grained increment: cmd_recheck: {t1 - t0:.3f}s")
-        self.options.export_types = export_types
+        old_export_types = self.options.export_types
+        self.options.export_types = self.options.export_types or export_types
         if not self.following_imports():
-            messages = self.fine_grained_increment(sources, remove, update)
+            messages = self.fine_grained_increment(
+                sources, remove, update, explicit_export_types=export_types
+            )
         else:
             assert remove is None and update is None
-            messages = self.fine_grained_increment_follow_imports(sources)
+            messages = self.fine_grained_increment_follow_imports(
+                sources, explicit_export_types=export_types
+            )
         res = self.increment_output(messages, sources, is_tty, terminal_width)
         self.flush_caches()
         self.update_stats(res)
+        self.options.export_types = old_export_types
         return res
 
     def check(
@@ -408,17 +422,21 @@ def check(
         If is_tty is True format the output nicely with colors and summary line
         (unless disabled in self.options). Also pass the terminal_width to formatter.
         """
-        self.options.export_types = export_types
+        old_export_types = self.options.export_types
+        self.options.export_types = self.options.export_types or export_types
         if not self.fine_grained_manager:
             res = self.initialize_fine_grained(sources, is_tty, terminal_width)
         else:
             if not self.following_imports():
-                messages = self.fine_grained_increment(sources)
+                messages = self.fine_grained_increment(sources, explicit_export_types=export_types)
             else:
-                messages = self.fine_grained_increment_follow_imports(sources)
+                messages = self.fine_grained_increment_follow_imports(
+                    sources, explicit_export_types=export_types
+                )
             res = self.increment_output(messages, sources, is_tty, terminal_width)
         self.flush_caches()
         self.update_stats(res)
+        self.options.export_types = old_export_types
         return res
 
     def flush_caches(self) -> None:
@@ -457,6 +475,7 @@ def initialize_fine_grained(
         messages = result.errors
         self.fine_grained_manager = FineGrainedBuildManager(result)
 
+        original_sources_len = len(sources)
         if self.following_imports():
             sources = find_all_sources_in_build(self.fine_grained_manager.graph, sources)
             self.update_sources(sources)
@@ -521,7 +540,8 @@ def initialize_fine_grained(
 
         __, n_notes, __ = count_stats(messages)
         status = 1 if messages and n_notes < len(messages) else 0
-        messages = self.pretty_messages(messages, len(sources), is_tty, terminal_width)
+        # We use explicit sources length to match the logic in non-incremental mode.
+        messages = self.pretty_messages(messages, original_sources_len, is_tty, terminal_width)
         return {"out": "".join(s + "\n" for s in messages), "err": "", "status": status}
 
     def fine_grained_increment(
@@ -529,6 +549,7 @@ def fine_grained_increment(
         sources: list[BuildSource],
         remove: list[str] | None = None,
         update: list[str] | None = None,
+        explicit_export_types: bool = False,
     ) -> list[str]:
         """Perform a fine-grained type checking increment.
 
@@ -539,6 +560,8 @@ def fine_grained_increment(
             sources: sources passed on the command line
             remove: paths of files that have been removed
             update: paths of files that have been changed or created
+            explicit_export_types: --export-type was passed in a check command
+              (as opposite to being set in dmypy start)
         """
         assert self.fine_grained_manager is not None
         manager = self.fine_grained_manager.manager
@@ -553,6 +576,10 @@ def fine_grained_increment(
             # Use the remove/update lists to update fswatcher.
             # This avoids calling stat() for unchanged files.
             changed, removed = self.update_changed(sources, remove or [], update or [])
+        if explicit_export_types:
+            # If --export-types is given, we need to force full re-checking of all
+            # explicitly passed files, since we need to visit each expression.
+            add_all_sources_to_changed(sources, changed)
         changed += self.find_added_suppressed(
             self.fine_grained_manager.graph, set(), manager.search_paths
         )
@@ -571,7 +598,9 @@ def fine_grained_increment(
         self.previous_sources = sources
         return messages
 
-    def fine_grained_increment_follow_imports(self, sources: list[BuildSource]) -> list[str]:
+    def fine_grained_increment_follow_imports(
+        self, sources: list[BuildSource], explicit_export_types: bool = False
+    ) -> list[str]:
         """Like fine_grained_increment, but follow imports."""
         t0 = time.time()
 
@@ -591,12 +620,20 @@ def fine_grained_increment_follow_imports(self, sources: list[BuildSource]) -> l
         t1 = time.time()
         manager.log(f"fine-grained increment: find_changed: {t1 - t0:.3f}s")
 
+        # Track all modules encountered so far. New entries for all dependencies
+        # are added below by other module finding methods below. All dependencies
+        # in graph but not in `seen` are considered deleted at the end of this method.
         seen = {source.module for source in sources}
 
         # Find changed modules reachable from roots (or in roots) already in graph.
         changed, new_files = self.find_reachable_changed_modules(
             sources, graph, seen, changed_paths
         )
+        # Same as in fine_grained_increment().
+        self.add_explicitly_new(sources, changed)
+        if explicit_export_types:
+            # Same as in fine_grained_increment().
+            add_all_sources_to_changed(sources, changed)
         sources.extend(new_files)
 
         # Process changes directly reachable from roots.
@@ -681,7 +718,7 @@ def refresh_file(module: str, path: str) -> list[str]:
             find_changes_time=t1 - t0,
             fg_update_time=t2 - t1,
             refresh_suppressed_time=t3 - t2,
-            find_added_supressed_time=t4 - t3,
+            find_added_suppressed_time=t4 - t3,
             cleanup_time=t5 - t4,
         )
 
@@ -702,7 +739,9 @@ def find_reachable_changed_modules(
         Args:
             roots: modules where to start search from
             graph: module graph to use for the search
-            seen: modules we've seen before that won't be visited (mutated here!!)
+            seen: modules we've seen before that won't be visited (mutated here!!).
+                  Needed to accumulate all modules encountered during update and remove
+                  everything that no longer exists.
             changed_paths: which paths have changed (stop search here and return any found)
 
         Return (encountered reachable changed modules,
@@ -722,7 +761,8 @@ def find_reachable_changed_modules(
                 changed.append((nxt.module, nxt.path))
             elif nxt.module in graph:
                 state = graph[nxt.module]
-                for dep in state.dependencies:
+                ancestors = state.ancestors or []
+                for dep in state.dependencies + ancestors:
                     if dep not in seen:
                         seen.add(dep)
                         worklist.append(BuildSource(graph[dep].path, graph[dep].id, followed=True))
@@ -741,7 +781,9 @@ def find_added_suppressed(
         """Find suppressed modules that have been added (and not included in seen).
 
         Args:
-            seen: reachable modules we've seen before (mutated here!!)
+            seen: reachable modules we've seen before (mutated here!!).
+                  Needed to accumulate all modules encountered during update and remove
+                  everything that no longer exists.
 
         Return suppressed, added modules.
         """
@@ -857,6 +899,8 @@ def _find_changed(
             assert path
             removed.append((source.module, path))
 
+        self.add_explicitly_new(sources, changed)
+
         # 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:
@@ -868,6 +912,24 @@ def _find_changed(
 
         return changed, removed
 
+    def add_explicitly_new(
+        self, sources: list[BuildSource], changed: list[tuple[str, str]]
+    ) -> None:
+        # 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
+            ]
+        )
+
     def cmd_inspect(
         self,
         show: str,
@@ -881,8 +943,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'
@@ -992,13 +1052,29 @@ def find_all_sources_in_build(
     return result
 
 
+def add_all_sources_to_changed(sources: list[BuildSource], changed: list[tuple[str, str]]) -> None:
+    """Add all (explicit) sources to the list changed files in place.
+
+    Use this when re-processing of unchanged files is needed (e.g. for
+    the purpose of exporting types for inspections).
+    """
+    changed_set = set(changed)
+    changed.extend(
+        [
+            (bs.module, bs.path)
+            for bs in sources
+            if bs.path and (bs.module, bs.path) not in changed_set
+        ]
+    )
+
+
 def fix_module_deps(graph: mypy.build.Graph) -> None:
     """After an incremental update, update module dependencies to reflect the new state.
 
     This can make some suppressed dependencies non-suppressed, and vice versa (if modules
     have been added to or removed from the build).
     """
-    for module, state in graph.items():
+    for state in graph.values():
         new_suppressed = []
         new_dependencies = []
         for dep in state.dependencies + state.suppressed:
diff --git a/mypy/dmypy_util.py b/mypy/dmypy_util.py
index a1b419617f73..eeb918b7877e 100644
--- a/mypy/dmypy_util.py
+++ b/mypy/dmypy_util.py
@@ -5,9 +5,11 @@
 
 from __future__ import annotations
 
+import io
 import json
-from typing import Any
-from typing_extensions import Final
+from collections.abc import Iterable, Iterator
+from types import TracebackType
+from typing import Any, Final, TextIO
 
 from mypy.ipc import IPCBase
 
@@ -15,7 +17,7 @@
 
 
 def receive(connection: IPCBase) -> Any:
-    """Receive JSON data from a connection until EOF.
+    """Receive single JSON data frame from a connection.
 
     Raise OSError if the data received is not valid JSON or if it is
     not a dict.
@@ -24,9 +26,92 @@ def receive(connection: IPCBase) -> Any:
     if not bdata:
         raise OSError("No data received")
     try:
-        data = json.loads(bdata.decode("utf8"))
+        data = json.loads(bdata)
     except Exception as e:
         raise OSError("Data received is not valid JSON") from e
     if not isinstance(data, dict):
         raise OSError(f"Data received is not a dict ({type(data)})")
     return data
+
+
+def send(connection: IPCBase, data: Any) -> None:
+    """Send data to a connection encoded and framed.
+
+    The data must be JSON-serializable. We assume that a single send call is a
+    single frame to be sent on the connect.
+    """
+    connection.write(json.dumps(data))
+
+
+class WriteToConn(TextIO):
+    """Helper class to write to a connection instead of standard output."""
+
+    def __init__(self, server: IPCBase, output_key: str, isatty: bool) -> None:
+        self.server = server
+        self.output_key = output_key
+        self._isatty = isatty
+
+    def __enter__(self) -> TextIO:
+        return self
+
+    def __exit__(
+        self,
+        t: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        pass
+
+    def __iter__(self) -> Iterator[str]:
+        raise io.UnsupportedOperation
+
+    def __next__(self) -> str:
+        raise io.UnsupportedOperation
+
+    def close(self) -> None:
+        pass
+
+    def fileno(self) -> int:
+        raise OSError
+
+    def flush(self) -> None:
+        pass
+
+    def isatty(self) -> bool:
+        return self._isatty
+
+    def read(self, n: int = 0) -> str:
+        raise io.UnsupportedOperation
+
+    def readable(self) -> bool:
+        return False
+
+    def readline(self, limit: int = 0) -> str:
+        raise io.UnsupportedOperation
+
+    def readlines(self, hint: int = 0) -> list[str]:
+        raise io.UnsupportedOperation
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        raise io.UnsupportedOperation
+
+    def seekable(self) -> bool:
+        return False
+
+    def tell(self) -> int:
+        raise io.UnsupportedOperation
+
+    def truncate(self, size: int | None = 0) -> int:
+        raise io.UnsupportedOperation
+
+    def write(self, output: str) -> int:
+        resp: dict[str, Any] = {self.output_key: output}
+        send(self.server, resp)
+        return len(output)
+
+    def writable(self) -> bool:
+        return True
+
+    def writelines(self, lines: Iterable[str]) -> None:
+        for s in lines:
+            self.write(s)
diff --git a/mypy/erasetype.py b/mypy/erasetype.py
index 6533d0c4e0f9..6c47670d6687 100644
--- a/mypy/erasetype.py
+++ b/mypy/erasetype.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Callable, Container, cast
+from collections.abc import Container
+from typing import Callable, cast
 
 from mypy.nodes import ARG_STAR, ARG_STAR2
 from mypy.types import (
@@ -34,6 +35,7 @@
     get_proper_type,
     get_proper_types,
 )
+from mypy.typevartuples import erased_vars
 
 
 def erase_type(typ: Type) -> ProperType:
@@ -71,13 +73,14 @@ def visit_erased_type(self, t: ErasedType) -> ProperType:
 
     def visit_partial_type(self, t: PartialType) -> ProperType:
         # Should not get here.
-        raise RuntimeError()
+        raise RuntimeError("Cannot erase partial types")
 
     def visit_deleted_type(self, t: DeletedType) -> ProperType:
         return t
 
     def visit_instance(self, t: Instance) -> ProperType:
-        return Instance(t.type, [AnyType(TypeOfAny.special_form)] * len(t.args), t.line)
+        args = erased_vars(t.type.defn.type_vars, TypeOfAny.special_form)
+        return Instance(t.type, args, t.line)
 
     def visit_type_var(self, t: TypeVarType) -> ProperType:
         return AnyType(TypeOfAny.special_form)
@@ -89,7 +92,9 @@ def visit_parameters(self, t: Parameters) -> ProperType:
         raise RuntimeError("Parameters should have been bound to a class")
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> ProperType:
-        return AnyType(TypeOfAny.special_form)
+        # Likely, we can never get here because of aggressive erasure of types that
+        # can contain this, but better still return a valid replacement.
+        return t.tuple_fallback.copy_modified(args=[AnyType(TypeOfAny.special_form)])
 
     def visit_unpack_type(self, t: UnpackType) -> ProperType:
         return AnyType(TypeOfAny.special_form)
@@ -157,6 +162,7 @@ class TypeVarEraser(TypeTranslator):
     """Implementation of type erasure"""
 
     def __init__(self, erase_id: Callable[[TypeVarId], bool], replacement: Type) -> None:
+        super().__init__()
         self.erase_id = erase_id
         self.replacement = replacement
 
@@ -165,9 +171,49 @@ def visit_type_var(self, t: TypeVarType) -> Type:
             return self.replacement
         return t
 
+    # TODO: below two methods duplicate some logic with expand_type().
+    # In fact, we may want to refactor this whole visitor to use expand_type().
+    def visit_instance(self, t: Instance) -> Type:
+        result = super().visit_instance(t)
+        assert isinstance(result, ProperType) and isinstance(result, Instance)
+        if t.type.fullname == "builtins.tuple":
+            # Normalize Tuple[*Tuple[X, ...], ...] -> Tuple[X, ...]
+            arg = result.args[0]
+            if isinstance(arg, UnpackType):
+                unpacked = get_proper_type(arg.type)
+                if isinstance(unpacked, Instance):
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    return unpacked
+        return result
+
+    def visit_tuple_type(self, t: TupleType) -> Type:
+        result = super().visit_tuple_type(t)
+        assert isinstance(result, ProperType) and isinstance(result, TupleType)
+        if len(result.items) == 1:
+            # Normalize Tuple[*Tuple[X, ...]] -> Tuple[X, ...]
+            item = result.items[0]
+            if isinstance(item, UnpackType):
+                unpacked = get_proper_type(item.type)
+                if isinstance(unpacked, Instance):
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    if result.partial_fallback.type.fullname != "builtins.tuple":
+                        # If it is a subtype (like named tuple) we need to preserve it,
+                        # this essentially mimics the logic in tuple_fallback().
+                        return result.partial_fallback.accept(self)
+                    return unpacked
+        return result
+
+    def visit_callable_type(self, t: CallableType) -> Type:
+        result = super().visit_callable_type(t)
+        assert isinstance(result, ProperType) and isinstance(result, CallableType)
+        # Usually this is done in semanal_typeargs.py, but erasure can create
+        # a non-normal callable from normal one.
+        result.normalize_trivial_unpack()
+        return result
+
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
         if self.erase_id(t.id):
-            return self.replacement
+            return t.tuple_fallback.copy_modified(args=[self.replacement])
         return t
 
     def visit_param_spec(self, t: ParamSpecType) -> Type:
diff --git a/mypy/error_formatter.py b/mypy/error_formatter.py
new file mode 100644
index 000000000000..ffc6b6747596
--- /dev/null
+++ b/mypy/error_formatter.py
@@ -0,0 +1,37 @@
+"""Defines the different custom formats in which mypy can output."""
+
+import json
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mypy.errors import MypyError
+
+
+class ErrorFormatter(ABC):
+    """Base class to define how errors are formatted before being printed."""
+
+    @abstractmethod
+    def report_error(self, error: "MypyError") -> str:
+        raise NotImplementedError
+
+
+class JSONFormatter(ErrorFormatter):
+    """Formatter for basic JSON output format."""
+
+    def report_error(self, error: "MypyError") -> str:
+        """Prints out the errors as simple, static JSON lines."""
+        return json.dumps(
+            {
+                "file": error.file_path,
+                "line": error.line,
+                "column": error.column,
+                "message": error.message,
+                "hint": None if len(error.hints) == 0 else "\n".join(error.hints),
+                "code": None if error.errorcode is None else error.errorcode.code,
+                "severity": error.severity,
+            }
+        )
+
+
+OUTPUT_CHOICES = {"json": JSONFormatter()}
diff --git a/mypy/errorcodes.py b/mypy/errorcodes.py
index 50a82be9816d..8f650aa30605 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
 
@@ -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")
@@ -99,6 +107,12 @@ def __str__(self) -> str:
 IMPORT: Final = ErrorCode(
     "import", "Require that imported module can be found or has stubs", "General"
 )
+IMPORT_NOT_FOUND: Final = ErrorCode(
+    "import-not-found", "Require that imported module can be found", "General", sub_code_of=IMPORT
+)
+IMPORT_UNTYPED: Final = ErrorCode(
+    "import-untyped", "Require that imported module has stubs", "General", sub_code_of=IMPORT
+)
 NO_REDEF: Final = ErrorCode("no-redef", "Check that each name is defined once", "General")
 FUNC_RETURNS_VALUE: Final = ErrorCode(
     "func-returns-value", "Check that called function returns a value in value context", "General"
@@ -136,9 +150,11 @@ def __str__(self) -> str:
     "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"
+)
+AWAIT_NOT_ASYNC: Final = ErrorCode(
+    "await-not-async", 'Warn about "await" outside coroutine ("async def")', "General"
 )
-
 # These error codes aren't enabled by default.
 NO_UNTYPED_DEF: Final[ErrorCode] = ErrorCode(
     "no-untyped-def", "Check that every function has an annotation", "General"
@@ -169,6 +185,9 @@ def __str__(self) -> str:
 ANNOTATION_UNCHECKED = ErrorCode(
     "annotation-unchecked", "Notify about type annotations in unchecked functions", "General"
 )
+TYPEDDICT_READONLY_MUTATED = ErrorCode(
+    "typeddict-readonly-mutated", "TypedDict's ReadOnly key is mutated", "General"
+)
 POSSIBLY_UNDEFINED: Final[ErrorCode] = ErrorCode(
     "possibly-undefined",
     "Warn about variables that are defined only in some execution paths",
@@ -227,7 +246,24 @@ def __str__(self) -> str:
 UNUSED_IGNORE: Final = ErrorCode(
     "unused-ignore", "Ensure that all type ignores are used", "General", default_enabled=False
 )
-
+EXPLICIT_OVERRIDE_REQUIRED: Final = ErrorCode(
+    "explicit-override",
+    "Require @override decorator if method is overriding a base class method",
+    "General",
+    default_enabled=False,
+)
+UNIMPORTED_REVEAL: Final = ErrorCode(
+    "unimported-reveal",
+    "Require explicit import from typing or typing_extensions for reveal_type",
+    "General",
+    default_enabled=False,
+)
+MUTABLE_OVERRIDE: Final[ErrorCode] = ErrorCode(
+    "mutable-override",
+    "Reject covariant overrides for mutable attributes",
+    "General",
+    default_enabled=False,
+)
 
 # Syntax errors are often blocking.
 SYNTAX: Final[ErrorCode] = ErrorCode("syntax", "Report syntax errors", "General")
@@ -238,4 +274,46 @@ def __str__(self) -> str:
 del error_codes[FILE.code]
 
 # This is a catch-all for remaining uncategorized errors.
-MISC: Final = ErrorCode("misc", "Miscellaneous other checks", "General")
+MISC: Final[ErrorCode] = ErrorCode("misc", "Miscellaneous other checks", "General")
+
+OVERLOAD_CANNOT_MATCH: Final[ErrorCode] = ErrorCode(
+    "overload-cannot-match",
+    "Warn if an @overload signature can never be matched",
+    "General",
+    sub_code_of=MISC,
+)
+
+
+OVERLOAD_OVERLAP: Final[ErrorCode] = ErrorCode(
+    "overload-overlap",
+    "Warn if multiple @overload variants overlap in unsafe ways",
+    "General",
+    sub_code_of=MISC,
+)
+
+PROPERTY_DECORATOR = ErrorCode(
+    "prop-decorator",
+    "Decorators on top of @property are not supported",
+    "General",
+    sub_code_of=MISC,
+)
+
+NARROWED_TYPE_NOT_SUBTYPE: Final[ErrorCode] = ErrorCode(
+    "narrowed-type-not-subtype",
+    "Warn if a TypeIs function's narrowed type is not a subtype of the original type",
+    "General",
+)
+
+EXPLICIT_ANY: Final = ErrorCode(
+    "explicit-any", "Warn about explicit Any type annotations", "General"
+)
+
+DEPRECATED: Final = ErrorCode(
+    "deprecated",
+    "Warn when importing or using deprecated (overloaded) functions, methods or classes",
+    "General",
+    default_enabled=False,
+)
+
+# This copy will not include any error codes defined later in the plugins.
+mypy_error_codes = error_codes.copy()
diff --git a/mypy/errors.py b/mypy/errors.py
index 9d29259e943c..c9510ae5f1eb 100644
--- a/mypy/errors.py
+++ b/mypy/errors.py
@@ -4,12 +4,13 @@
 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 collections.abc import Iterable
+from typing import Callable, Final, NoReturn, Optional, TextIO, TypeVar
+from typing_extensions import Literal, TypeAlias as _TypeAlias
 
 from mypy import errorcodes as codes
-from mypy.errorcodes import IMPORT, ErrorCode
-from mypy.message_registry import ErrorMessage
+from mypy.error_formatter import ErrorFormatter
+from mypy.errorcodes import IMPORT, IMPORT_NOT_FOUND, IMPORT_UNTYPED, ErrorCode, mypy_error_codes
 from mypy.options import Options
 from mypy.scope import Scope
 from mypy.util import DEFAULT_SOURCE_OFFSET, is_typeshed_file
@@ -19,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}
-allowed_duplicates: Final = ["@overload", "Got:", "Expected:"]
+SHOW_NOTE_CODES: Final = {codes.ANNOTATION_UNCHECKED, codes.DEPRECATED}
+
+# 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:", "Expected setter type:"]
+
+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.
@@ -90,6 +110,7 @@ class ErrorInfo:
     def __init__(
         self,
         import_ctx: list[tuple[str, int]],
+        *,
         file: str,
         module: str | None,
         typ: str | None,
@@ -106,6 +127,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
@@ -124,11 +146,12 @@ 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:
 #   (path, line, column, end_line, end_column, severity, message, allow_dups, code)
-ErrorTuple: _TypeAlias = Tuple[
+ErrorTuple: _TypeAlias = tuple[
     Optional[str], int, int, int, int, str, str, bool, Optional[ErrorCode]
 ]
 
@@ -148,10 +171,12 @@ def __init__(
         *,
         filter_errors: bool | Callable[[str, ErrorInfo], bool] = False,
         save_filtered_errors: bool = False,
-    ):
+        filter_deprecated: bool = False,
+    ) -> None:
         self.errors = errors
         self._has_new_errors = False
         self._filter = filter_errors
+        self._filter_deprecated = filter_deprecated
         self._filtered: list[ErrorInfo] | None = [] if save_filtered_errors else None
 
     def __enter__(self) -> ErrorWatcher:
@@ -171,6 +196,10 @@ def on_error(self, file: str, info: ErrorInfo) -> bool:
         Return True to filter out the error, preventing it from being seen by other
         ErrorWatcher further down the stack and from being recorded by Errors
         """
+        if info.code == codes.DEPRECATED:
+            # Deprecated is not a type error, so it is handled on opt-in basis here.
+            return self._filter_deprecated
+
         self._has_new_errors = True
         if isinstance(self._filter, bool):
             should_filter = self._filter
@@ -222,8 +251,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]]]
@@ -241,7 +271,7 @@ class Errors:
     show_column_numbers: bool = False
 
     # Set to True to show end line and end column in error messages.
-    # Ths implies `show_column_numbers`.
+    # This implies `show_column_numbers`.
     show_error_end: bool = False
 
     # Set to True to show absolute file paths in error messages.
@@ -280,7 +310,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()
@@ -329,8 +359,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.
@@ -415,21 +445,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(),
         )
@@ -446,7 +476,7 @@ def _add_error_info(self, file: str, info: ErrorInfo) -> None:
         self.error_info_map[file].append(info)
         if info.blocker:
             self.has_blockers.add(file)
-        if info.code is IMPORT:
+        if info.code in (IMPORT, IMPORT_UNTYPED, IMPORT_NOT_FOUND):
             self.seen_import_error = True
 
     def _filter_error(self, file: str, info: ErrorInfo) -> bool:
@@ -476,10 +506,13 @@ def add_error_info(self, info: ErrorInfo) -> None:
                 # line == end_line for most nodes, so we only loop once.
                 for scope_line in lines:
                     if self.is_ignored_error(scope_line, info, self.ignored_lines[file]):
+                        err_code = info.code or codes.MISC
+                        if not self.is_error_code_enabled(err_code):
+                            # Error code is disabled - don't mark the current
+                            # "type: ignore" comment as used.
+                            return
                         # Annotation requests us to ignore all errors on this line.
-                        self.used_ignored_lines[file][scope_line].append(
-                            (info.code or codes.MISC).code
-                        )
+                        self.used_ignored_lines[file][scope_line].append(err_code.code)
                         return
             if file in self.ignored_files:
                 return
@@ -487,7 +520,11 @@ def add_error_info(self, info: ErrorInfo) -> None:
             if info.message in self.only_once_messages:
                 return
             self.only_once_messages.add(info.message)
-        if self.seen_import_error and info.code is not IMPORT and self.has_many_errors():
+        if (
+            self.seen_import_error
+            and info.code not in (IMPORT, IMPORT_UNTYPED, IMPORT_NOT_FOUND)
+            and self.has_many_errors()
+        ):
             # Missing stubs can easily cause thousands of errors about
             # Any types, especially when upgrading to mypy 0.900,
             # which no longer bundles third-party library stubs. Avoid
@@ -511,23 +548,53 @@ 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,
                 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
+            and info.code.code in mypy_error_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:
@@ -630,7 +697,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
@@ -653,21 +720,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 +772,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)
 
@@ -745,7 +812,7 @@ def blocker_module(self) -> str | None:
 
     def is_errors_for_file(self, file: str) -> bool:
         """Are there any errors for the given file?"""
-        return file in self.error_info_map
+        return file in self.error_info_map and file not in self.ignored_files
 
     def prefer_simple_messages(self) -> bool:
         """Should we generate simple/fast error messages?
@@ -777,7 +844,7 @@ def raise_error(self, use_stdout: bool = True) -> NoReturn:
         )
 
     def format_messages(
-        self, error_info: list[ErrorInfo], source_lines: list[str] | None
+        self, error_tuples: list[ErrorTuple], source_lines: list[str] | None
     ) -> list[str]:
         """Return a string list that represents the error messages.
 
@@ -786,9 +853,6 @@ def format_messages(
         severity 'error').
         """
         a: list[str] = []
-        error_info = [info for info in error_info if not info.hidden]
-        errors = self.render_messages(self.sort_messages(error_info))
-        errors = self.remove_duplicates(errors)
         for (
             file,
             line,
@@ -799,7 +863,7 @@ def format_messages(
             message,
             allow_dups,
             code,
-        ) in errors:
+        ) in error_tuples:
             s = ""
             if file is not None:
                 if self.options.show_column_numbers and line >= 0 and column >= 0:
@@ -844,19 +908,44 @@ def format_messages(
                     a.append(" " * (DEFAULT_SOURCE_OFFSET + column) + marker)
         return a
 
-    def file_messages(self, path: str) -> list[str]:
+    def file_messages(self, path: str, formatter: ErrorFormatter | None = None) -> list[str]:
         """Return a string list of new error messages from a given file.
 
         Use a form suitable for displaying to the user.
         """
         if path not in self.error_info_map:
             return []
+
+        error_info = self.error_info_map[path]
+        error_info = [info for info in error_info if not info.hidden]
+        error_tuples = self.render_messages(self.sort_messages(error_info))
+        error_tuples = self.remove_duplicates(error_tuples)
+
+        if formatter is not None:
+            errors = create_errors(error_tuples)
+            return [formatter.report_error(err) for err in errors]
+
         self.flushed_files.add(path)
         source_lines = None
-        if self.options.pretty:
-            assert self.read_source
-            source_lines = self.read_source(path)
-        return self.format_messages(self.error_info_map[path], source_lines)
+        if self.options.pretty and self.read_source:
+            # Find shadow file mapping and read source lines if a shadow file exists for the given path.
+            # If shadow file mapping is not found, read source lines
+            mapped_path = self.find_shadow_file_mapping(path)
+            if mapped_path:
+                source_lines = self.read_source(mapped_path)
+            else:
+                source_lines = self.read_source(path)
+        return self.format_messages(error_tuples, source_lines)
+
+    def find_shadow_file_mapping(self, path: str) -> str | None:
+        """Return the shadow file path for a given source file path or None."""
+        if self.options.shadow_file is None:
+            return None
+
+        for i in self.options.shadow_file:
+            if i[0] == path:
+                return i[1]
+        return None
 
     def new_messages(self) -> list[str]:
         """Return a string list of new error messages.
@@ -982,34 +1071,19 @@ def render_messages(self, errors: list[ErrorInfo]) -> list[ErrorTuple]:
                         (file, -1, -1, -1, -1, "note", f'In class "{e.type}":', e.allow_dups, None)
                     )
 
-            if isinstance(e.message, ErrorMessage):
-                result.append(
-                    (
-                        file,
-                        e.line,
-                        e.column,
-                        e.end_line,
-                        e.end_column,
-                        e.severity,
-                        e.message.value,
-                        e.allow_dups,
-                        e.code,
-                    )
-                )
-            else:
-                result.append(
-                    (
-                        file,
-                        e.line,
-                        e.column,
-                        e.end_line,
-                        e.end_column,
-                        e.severity,
-                        e.message,
-                        e.allow_dups,
-                        e.code,
-                    )
+            result.append(
+                (
+                    file,
+                    e.line,
+                    e.column,
+                    e.end_line,
+                    e.end_column,
+                    e.severity,
+                    e.message,
+                    e.allow_dups,
+                    e.code,
                 )
+            )
 
             prev_import_context = e.import_ctx
             prev_function_or_member = e.function_or_member
@@ -1039,6 +1113,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
 
@@ -1194,3 +1296,56 @@ def report_internal_error(
     # Exit.  The caller has nothing more to say.
     # We use exit code 2 to signal that this is no ordinary error.
     raise SystemExit(2)
+
+
+class MypyError:
+    def __init__(
+        self,
+        file_path: str,
+        line: int,
+        column: int,
+        message: str,
+        errorcode: ErrorCode | None,
+        severity: Literal["error", "note"],
+    ) -> None:
+        self.file_path = file_path
+        self.line = line
+        self.column = column
+        self.message = message
+        self.errorcode = errorcode
+        self.severity = severity
+        self.hints: list[str] = []
+
+
+# (file_path, line, column)
+_ErrorLocation = tuple[str, int, int]
+
+
+def create_errors(error_tuples: list[ErrorTuple]) -> list[MypyError]:
+    errors: list[MypyError] = []
+    latest_error_at_location: dict[_ErrorLocation, MypyError] = {}
+
+    for error_tuple in error_tuples:
+        file_path, line, column, _, _, severity, message, _, errorcode = error_tuple
+        if file_path is None:
+            continue
+
+        assert severity in ("error", "note")
+        if severity == "note":
+            error_location = (file_path, line, column)
+            error = latest_error_at_location.get(error_location)
+            if error is None:
+                # This is purely a note, with no error correlated to it
+                error = MypyError(file_path, line, column, message, errorcode, severity="note")
+                errors.append(error)
+                continue
+
+            error.hints.append(message)
+
+        else:
+            error = MypyError(file_path, line, column, message, errorcode, severity="error")
+            errors.append(error)
+            error_location = (file_path, line, column)
+            latest_error_at_location[error_location] = error
+
+    return errors
diff --git a/mypy/evalexpr.py b/mypy/evalexpr.py
index 2bc6966fa2fa..e39c5840d47a 100644
--- a/mypy/evalexpr.py
+++ b/mypy/evalexpr.py
@@ -6,8 +6,9 @@
 put it in a mypyc-compiled file.
 
 """
+
 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 5bbdd5311da7..031f86e7dfff 100644
--- a/mypy/expandtype.py
+++ b/mypy/expandtype.py
@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from typing import Iterable, Mapping, Sequence, TypeVar, cast, overload
-from typing_extensions import Final
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Final, TypeVar, cast, overload
 
-from mypy.nodes import ARG_POS, ARG_STAR, ArgKind, Var
+from mypy.nodes import ARG_STAR, FakeInfo, Var
 from mypy.state import state
-from mypy.type_visitor import TypeTranslator
 from mypy.types import (
     ANY_STRATEGY,
     AnyType,
@@ -28,6 +27,7 @@
     Type,
     TypeAliasType,
     TypedDictType,
+    TypeOfAny,
     TypeType,
     TypeVarId,
     TypeVarLikeType,
@@ -37,12 +37,14 @@
     UninhabitedType,
     UnionType,
     UnpackType,
-    flatten_nested_tuples,
     flatten_nested_unions,
     get_proper_type,
     split_with_prefix_and_suffix,
 )
-from mypy.typevartuples import find_unpack_in_list, split_with_instance
+from mypy.typevartuples import 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.
@@ -50,18 +52,15 @@
 
 
 @overload
-def expand_type(typ: CallableType, env: Mapping[TypeVarId, Type]) -> CallableType:
-    ...
+def expand_type(typ: CallableType, env: Mapping[TypeVarId, Type]) -> CallableType: ...
 
 
 @overload
-def expand_type(typ: ProperType, env: Mapping[TypeVarId, Type]) -> ProperType:
-    ...
+def expand_type(typ: ProperType, env: Mapping[TypeVarId, Type]) -> ProperType: ...
 
 
 @overload
-def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
-    ...
+def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type: ...
 
 
 def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
@@ -72,24 +71,21 @@ def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
 
 
 @overload
-def expand_type_by_instance(typ: CallableType, instance: Instance) -> CallableType:
-    ...
+def expand_type_by_instance(typ: CallableType, instance: Instance) -> CallableType: ...
 
 
 @overload
-def expand_type_by_instance(typ: ProperType, instance: Instance) -> ProperType:
-    ...
+def expand_type_by_instance(typ: ProperType, instance: Instance) -> ProperType: ...
 
 
 @overload
-def expand_type_by_instance(typ: Type, instance: Instance) -> Type:
-    ...
+def expand_type_by_instance(typ: Type, instance: Instance) -> Type: ...
 
 
 def expand_type_by_instance(typ: Type, instance: Instance) -> Type:
     """Substitute type variables in type using values from an Instance.
     Type variables are considered to be bound by the class declaration."""
-    if not instance.args:
+    if not instance.args and not instance.type.has_type_var_tuple_type:
         return typ
     else:
         variables: dict[TypeVarId, Type] = {}
@@ -167,7 +163,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)
@@ -184,7 +180,9 @@ class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
     variables: Mapping[TypeVarId, Type]  # TypeVar id -> TypeVar value
 
     def __init__(self, variables: Mapping[TypeVarId, Type]) -> None:
+        super().__init__()
         self.variables = variables
+        self.recursive_tvar_guard: dict[TypeVarId, Type | None] = {}
 
     def visit_unbound_type(self, t: UnboundType) -> Type:
         return t
@@ -212,65 +210,87 @@ def visit_erased_type(self, t: ErasedType) -> Type:
 
     def visit_instance(self, t: Instance) -> Type:
         args = self.expand_types_with_unpack(list(t.args))
-        if isinstance(args, list):
+
+        if isinstance(t.type, FakeInfo):
+            # The type checker expands function definitions and bodies
+            # if they depend on constrained type variables but the body
+            # might contain a tuple type comment (e.g., # type: (int, float)),
+            # in which case 't.type' is not yet available.
+            #
+            # See: https://github.com/python/mypy/issues/16649
             return t.copy_modified(args=args)
-        else:
-            return args
+
+        if t.type.fullname == "builtins.tuple":
+            # Normalize Tuple[*Tuple[X, ...], ...] -> Tuple[X, ...]
+            arg = args[0]
+            if isinstance(arg, UnpackType):
+                unpacked = get_proper_type(arg.type)
+                if isinstance(unpacked, Instance):
+                    # TODO: this and similar asserts below may be unsafe because get_proper_type()
+                    # may be called during semantic analysis before all invalid types are removed.
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    args = list(unpacked.args)
+        return t.copy_modified(args=args)
 
     def visit_type_var(self, t: TypeVarType) -> Type:
         # Normally upper bounds can't contain other type variables, the only exception is
         # special type variable Self`0 <: C[T, S], where C is the class where Self is used.
-        if t.id.raw_id == 0:
+        if t.id.is_self():
             t = t.copy_modified(upper_bound=t.upper_bound.accept(self))
         repl = self.variables.get(t.id, t)
         if isinstance(repl, ProperType) and isinstance(repl, Instance):
             # TODO: do we really need to do this?
             # If I try to remove this special-casing ~40 tests fail on reveal_type().
             return repl.copy_modified(last_known_value=None)
+        if isinstance(repl, TypeVarType) and repl.has_default():
+            if (tvar_id := repl.id) in self.recursive_tvar_guard:
+                return self.recursive_tvar_guard[tvar_id] or repl
+            self.recursive_tvar_guard[tvar_id] = None
+            repl = repl.accept(self)
+            if isinstance(repl, TypeVarType):
+                repl.default = repl.default.accept(self)
+            self.recursive_tvar_guard[tvar_id] = repl
         return repl
 
     def visit_param_spec(self, t: ParamSpecType) -> Type:
-        # set prefix to something empty so we don't duplicate it
-        repl = get_proper_type(
-            self.variables.get(t.id, t.copy_modified(prefix=Parameters([], [], [])))
-        )
-        if isinstance(repl, Instance):
-            # TODO: what does prefix mean in this case?
-            # TODO: why does this case even happen? Instances aren't plural.
-            return repl
-        elif isinstance(repl, (ParamSpecType, Parameters, CallableType)):
-            if isinstance(repl, ParamSpecType):
-                return repl.copy_modified(
-                    flavor=t.flavor,
-                    prefix=t.prefix.copy_modified(
-                        arg_types=t.prefix.arg_types + repl.prefix.arg_types,
-                        arg_kinds=t.prefix.arg_kinds + repl.prefix.arg_kinds,
-                        arg_names=t.prefix.arg_names + repl.prefix.arg_names,
-                    ),
-                )
-            else:
-                # if the paramspec is *P.args or **P.kwargs:
-                if t.flavor != ParamSpecFlavor.BARE:
-                    assert isinstance(repl, CallableType), "Should not be able to get here."
-                    # Is this always the right thing to do?
-                    param_spec = repl.param_spec()
-                    if param_spec:
-                        return param_spec.with_flavor(t.flavor)
-                    else:
-                        return repl
-                else:
-                    return Parameters(
-                        t.prefix.arg_types + repl.arg_types,
-                        t.prefix.arg_kinds + repl.arg_kinds,
-                        t.prefix.arg_names + repl.arg_names,
-                        variables=[*t.prefix.variables, *repl.variables],
-                    )
-
+        # Set prefix to something empty, so we don't duplicate it below.
+        repl = self.variables.get(t.id, t.copy_modified(prefix=Parameters([], [], [])))
+        if isinstance(repl, ParamSpecType):
+            return repl.copy_modified(
+                flavor=t.flavor,
+                prefix=t.prefix.copy_modified(
+                    arg_types=self.expand_types(t.prefix.arg_types) + repl.prefix.arg_types,
+                    arg_kinds=t.prefix.arg_kinds + repl.prefix.arg_kinds,
+                    arg_names=t.prefix.arg_names + repl.prefix.arg_names,
+                ),
+            )
+        elif isinstance(repl, Parameters):
+            assert t.flavor == ParamSpecFlavor.BARE
+            return Parameters(
+                self.expand_types(t.prefix.arg_types) + repl.arg_types,
+                t.prefix.arg_kinds + repl.arg_kinds,
+                t.prefix.arg_names + repl.arg_names,
+                variables=[*t.prefix.variables, *repl.variables],
+                imprecise_arg_kinds=repl.imprecise_arg_kinds,
+            )
         else:
-            # TODO: should this branch be removed? better not to fail silently
+            # We could encode Any as trivial parameters etc., but it would be too verbose.
+            # TODO: assert this is a trivial type, like Any, Never, or object.
             return repl
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+        # Sometimes solver may need to expand a type variable with (a copy of) itself
+        # (usually together with other TypeVars, but it is hard to filter out TypeVarTuples).
+        repl = self.variables.get(t.id, t)
+        if isinstance(repl, TypeVarTupleType):
+            return repl
+        elif isinstance(repl, ProperType) and isinstance(repl, (AnyType, UninhabitedType)):
+            # Some failed inference scenarios will try to set all type variables to Never.
+            # Instead of being picky and require all the callers to wrap them,
+            # do this here instead.
+            # Note: most cases when this happens are handled in expand unpack below, but
+            # in rare cases (e.g. ParamSpec containing Unpack star args) it may be skipped.
+            return t.tuple_fallback.copy_modified(args=[repl])
         raise NotImplementedError
 
     def visit_unpack_type(self, t: UnpackType) -> Type:
@@ -280,108 +300,68 @@ def visit_unpack_type(self, t: UnpackType) -> Type:
         # Relevant sections that can call unpack should call expand_unpack()
         # instead.
         # However, if the item is a variadic tuple, we can simply carry it over.
-        # it is hard to assert this without getting proper type.
+        # In particular, if we expand A[*tuple[T, ...]] with substitutions {T: str},
+        # it is hard to assert this without getting proper type. Another important
+        # example is non-normalized types when called from semanal.py.
         return UnpackType(t.type.accept(self))
 
-    def expand_unpack(self, t: UnpackType) -> list[Type] | Instance | AnyType | None:
-        return expand_unpack_with_variables(t, self.variables)
+    def expand_unpack(self, t: UnpackType) -> list[Type]:
+        assert isinstance(t.type, TypeVarTupleType)
+        repl = get_proper_type(self.variables.get(t.type.id, t.type))
+        if isinstance(repl, UnpackType):
+            repl = get_proper_type(repl.type)
+        if isinstance(repl, TupleType):
+            return repl.items
+        elif (
+            isinstance(repl, Instance)
+            and repl.type.fullname == "builtins.tuple"
+            or isinstance(repl, TypeVarTupleType)
+        ):
+            return [UnpackType(typ=repl)]
+        elif isinstance(repl, (AnyType, UninhabitedType)):
+            # Replace *Ts = Any with *Ts = *tuple[Any, ...] and same for Never.
+            # These types may appear here as a result of user error or failed inference.
+            return [UnpackType(t.type.tuple_fallback.copy_modified(args=[repl]))]
+        else:
+            raise RuntimeError(f"Invalid type replacement to expand: {repl}")
 
     def visit_parameters(self, t: Parameters) -> Type:
         return t.copy_modified(arg_types=self.expand_types(t.arg_types))
 
-    def interpolate_args_for_unpack(
-        self, t: CallableType, var_arg: UnpackType
-    ) -> tuple[list[str | None], list[ArgKind], list[Type]]:
+    def interpolate_args_for_unpack(self, t: CallableType, var_arg: UnpackType) -> list[Type]:
         star_index = t.arg_kinds.index(ARG_STAR)
+        prefix = self.expand_types(t.arg_types[:star_index])
+        suffix = self.expand_types(t.arg_types[star_index + 1 :])
 
-        # We have something like Unpack[Tuple[X1, X2, Unpack[Ts], Y1, Y2]]
         var_arg_type = get_proper_type(var_arg.type)
+        new_unpack: Type
         if isinstance(var_arg_type, TupleType):
+            # We have something like Unpack[Tuple[Unpack[Ts], X1, X2]]
             expanded_tuple = var_arg_type.accept(self)
-            # TODO: handle the case that expanded_tuple is a variable length tuple.
             assert isinstance(expanded_tuple, ProperType) and isinstance(expanded_tuple, TupleType)
             expanded_items = expanded_tuple.items
+            fallback = var_arg_type.partial_fallback
+            new_unpack = UnpackType(TupleType(expanded_items, fallback))
+        elif isinstance(var_arg_type, TypeVarTupleType):
+            # We have plain Unpack[Ts]
+            fallback = var_arg_type.tuple_fallback
+            expanded_items = self.expand_unpack(var_arg)
+            new_unpack = UnpackType(TupleType(expanded_items, fallback))
+        # Since get_proper_type() may be called in semanal.py before callable
+        # normalization happens, we need to also handle non-normal cases here.
+        elif isinstance(var_arg_type, Instance):
+            # we have something like Unpack[Tuple[Any, ...]]
+            new_unpack = UnpackType(var_arg.type.accept(self))
         else:
-            expanded_items_res = self.expand_unpack(var_arg)
-            if isinstance(expanded_items_res, list):
-                expanded_items = expanded_items_res
-            elif (
-                isinstance(expanded_items_res, Instance)
-                and expanded_items_res.type.fullname == "builtins.tuple"
-            ):
-                # TODO: We shouldnt't simply treat this as a *arg because of suffix handling
-                # (there cannot be positional args after a *arg)
-                arg_types = (
-                    t.arg_types[:star_index]
-                    + [expanded_items_res.args[0]]
-                    + t.arg_types[star_index + 1 :]
-                )
-                return (t.arg_names, t.arg_kinds, arg_types)
-            else:
-                return (t.arg_names, t.arg_kinds, t.arg_types)
-
-        expanded_unpack_index = find_unpack_in_list(expanded_items)
-        # This is the case where we just have Unpack[Tuple[X1, X2, X3]]
-        # (for example if either the tuple had no unpacks, or the unpack in the
-        # tuple got fully expanded to something with fixed length)
-        if expanded_unpack_index is None:
-            arg_names = (
-                t.arg_names[:star_index]
-                + [None] * len(expanded_items)
-                + t.arg_names[star_index + 1 :]
-            )
-            arg_kinds = (
-                t.arg_kinds[:star_index]
-                + [ARG_POS] * len(expanded_items)
-                + t.arg_kinds[star_index + 1 :]
-            )
-            arg_types = (
-                self.expand_types(t.arg_types[:star_index])
-                + expanded_items
-                + self.expand_types(t.arg_types[star_index + 1 :])
-            )
-        else:
-            # If Unpack[Ts] simplest form still has an unpack or is a
-            # homogenous tuple, then only the prefix can be represented as
-            # positional arguments, and we pass Tuple[Unpack[Ts-1], Y1, Y2]
-            # as the star arg, for example.
-            expanded_unpack = expanded_items[expanded_unpack_index]
-            assert isinstance(expanded_unpack, UnpackType)
-
-            # Extract the typevartuple so we can get a tuple fallback from it.
-            expanded_unpacked_tvt = expanded_unpack.type
-            if isinstance(expanded_unpacked_tvt, TypeVarTupleType):
-                fallback = expanded_unpacked_tvt.tuple_fallback
-            else:
-                # This can happen when tuple[Any, ...] is used to "patch" a variadic
-                # generic type without type arguments provided.
-                assert isinstance(expanded_unpacked_tvt, ProperType)
-                assert isinstance(expanded_unpacked_tvt, Instance)
-                assert expanded_unpacked_tvt.type.fullname == "builtins.tuple"
-                fallback = expanded_unpacked_tvt
-
-            prefix_len = expanded_unpack_index
-            arg_names = t.arg_names[:star_index] + [None] * prefix_len + t.arg_names[star_index:]
-            arg_kinds = (
-                t.arg_kinds[:star_index] + [ARG_POS] * prefix_len + t.arg_kinds[star_index:]
-            )
-            arg_types = (
-                self.expand_types(t.arg_types[:star_index])
-                + expanded_items[:prefix_len]
-                # Constructing the Unpack containing the tuple without the prefix.
-                + [
-                    UnpackType(TupleType(expanded_items[prefix_len:], fallback))
-                    if len(expanded_items) - prefix_len > 1
-                    else expanded_items[0]
-                ]
-                + self.expand_types(t.arg_types[star_index + 1 :])
-            )
-        return (arg_names, arg_kinds, arg_types)
+            # We have invalid type in Unpack. This can happen when expanding aliases
+            # to Callable[[*Invalid], Ret]
+            new_unpack = AnyType(TypeOfAny.from_error, line=var_arg.line, column=var_arg.column)
+        return prefix + [new_unpack] + suffix
 
     def visit_callable_type(self, t: CallableType) -> CallableType:
         param_spec = t.param_spec()
         if param_spec is not None:
-            repl = get_proper_type(self.variables.get(param_spec.id))
+            repl = self.variables.get(param_spec.id)
             # If a ParamSpec in a callable type is substituted with a
             # callable type, we can't use normal substitution logic,
             # since ParamSpec is actually split into two components
@@ -389,52 +369,58 @@ def visit_callable_type(self, t: CallableType) -> CallableType:
             # must expand both of them with all the argument types,
             # kinds and names in the replacement. The return type in
             # the replacement is ignored.
-            if isinstance(repl, (CallableType, Parameters)):
-                # Substitute *args: P.args, **kwargs: P.kwargs
-                prefix = param_spec.prefix
-                # we need to expand the types in the prefix, so might as well
-                # not get them in the first place
-                t = t.expand_param_spec(repl, no_prefix=True)
-                return t.copy_modified(
-                    arg_types=self.expand_types(prefix.arg_types) + t.arg_types,
-                    arg_kinds=prefix.arg_kinds + t.arg_kinds,
-                    arg_names=prefix.arg_names + t.arg_names,
+            if isinstance(repl, Parameters):
+                # We need to expand both the types in the prefix and the ParamSpec itself
+                expanded = t.copy_modified(
+                    arg_types=self.expand_types(t.arg_types[:-2]) + repl.arg_types,
+                    arg_kinds=t.arg_kinds[:-2] + repl.arg_kinds,
+                    arg_names=t.arg_names[:-2] + repl.arg_names,
                     ret_type=t.ret_type.accept(self),
                     type_guard=(t.type_guard.accept(self) if t.type_guard is not None else None),
+                    type_is=(t.type_is.accept(self) if t.type_is is not None else None),
+                    imprecise_arg_kinds=(t.imprecise_arg_kinds or repl.imprecise_arg_kinds),
+                    variables=[*repl.variables, *t.variables],
                 )
-            # TODO: Conceptually, the "len(t.arg_types) == 2" should not be here. However, this
-            #       errors without it. Either figure out how to eliminate this or place an
-            #       explanation for why this is necessary.
-            elif isinstance(repl, ParamSpecType) and len(t.arg_types) == 2:
-                # We're substituting one paramspec for another; this can mean that the prefix
-                # changes. (e.g. sub Concatenate[int, P] for Q)
+                var_arg = expanded.var_arg()
+                if var_arg is not None and isinstance(var_arg.typ, UnpackType):
+                    # Sometimes we get new unpacks after expanding ParamSpec.
+                    expanded.normalize_trivial_unpack()
+                return expanded
+            elif isinstance(repl, ParamSpecType):
+                # We're substituting one ParamSpec for another; this can mean that the prefix
+                # changes, e.g. substitute Concatenate[int, P] in place of Q.
                 prefix = repl.prefix
-                old_prefix = param_spec.prefix
-
-                # Check assumptions. I'm not sure what order to place new prefix vs old prefix:
-                assert not old_prefix.arg_types or not prefix.arg_types
-
-                t = t.copy_modified(
-                    arg_types=prefix.arg_types + old_prefix.arg_types + t.arg_types,
-                    arg_kinds=prefix.arg_kinds + old_prefix.arg_kinds + t.arg_kinds,
-                    arg_names=prefix.arg_names + old_prefix.arg_names + t.arg_names,
+                clean_repl = repl.copy_modified(prefix=Parameters([], [], []))
+                return t.copy_modified(
+                    arg_types=self.expand_types(t.arg_types[:-2])
+                    + prefix.arg_types
+                    + [
+                        clean_repl.with_flavor(ParamSpecFlavor.ARGS),
+                        clean_repl.with_flavor(ParamSpecFlavor.KWARGS),
+                    ],
+                    arg_kinds=t.arg_kinds[:-2] + prefix.arg_kinds + t.arg_kinds[-2:],
+                    arg_names=t.arg_names[:-2] + prefix.arg_names + t.arg_names[-2:],
+                    ret_type=t.ret_type.accept(self),
+                    from_concatenate=t.from_concatenate or bool(repl.prefix.arg_types),
+                    imprecise_arg_kinds=(t.imprecise_arg_kinds or prefix.imprecise_arg_kinds),
                 )
 
         var_arg = t.var_arg()
+        needs_normalization = False
         if var_arg is not None and isinstance(var_arg.typ, UnpackType):
-            arg_names, arg_kinds, arg_types = self.interpolate_args_for_unpack(t, var_arg.typ)
+            needs_normalization = True
+            arg_types = self.interpolate_args_for_unpack(t, var_arg.typ)
         else:
-            arg_names = t.arg_names
-            arg_kinds = t.arg_kinds
             arg_types = self.expand_types(t.arg_types)
-
-        return t.copy_modified(
+        expanded = t.copy_modified(
             arg_types=arg_types,
-            arg_names=arg_names,
-            arg_kinds=arg_kinds,
             ret_type=t.ret_type.accept(self),
             type_guard=(t.type_guard.accept(self) if t.type_guard is not None else None),
+            type_is=(t.type_is.accept(self) if t.type_is is not None else None),
         )
+        if needs_normalization:
+            return expanded.with_normalized_var_args()
+        return expanded
 
     def visit_overloaded(self, t: Overloaded) -> Type:
         items: list[CallableType] = []
@@ -445,58 +431,54 @@ def visit_overloaded(self, t: Overloaded) -> Type:
             items.append(new_item)
         return Overloaded(items)
 
-    def expand_types_with_unpack(
-        self, typs: Sequence[Type]
-    ) -> list[Type] | AnyType | UninhabitedType | Instance:
-        """Expands a list of types that has an unpack.
-
-        In corner cases, this can return a type rather than a list, in which case this
-        indicates use of Any or some error occurred earlier. In this case callers should
-        simply propagate the resulting type.
-        """
-        # TODO: this will cause a crash on aliases like A = Tuple[int, Unpack[A]].
-        # Although it is unlikely anyone will write this, we should fail gracefully.
-        typs = flatten_nested_tuples(typs)
+    def expand_types_with_unpack(self, typs: Sequence[Type]) -> list[Type]:
+        """Expands a list of types that has an unpack."""
         items: list[Type] = []
         for item in typs:
             if isinstance(item, UnpackType) and isinstance(item.type, TypeVarTupleType):
-                unpacked_items = self.expand_unpack(item)
-                if unpacked_items is None:
-                    # TODO: better error, something like tuple of unknown?
-                    return UninhabitedType()
-                elif isinstance(unpacked_items, Instance):
-                    if len(typs) == 1:
-                        return unpacked_items
-                    else:
-                        assert False, "Invalid unpack of variable length tuple"
-                elif isinstance(unpacked_items, AnyType):
-                    return unpacked_items
-                else:
-                    items.extend(unpacked_items)
+                items.extend(self.expand_unpack(item))
             else:
-                # Must preserve original aliases when possible.
                 items.append(item.accept(self))
         return items
 
     def visit_tuple_type(self, t: TupleType) -> Type:
         items = self.expand_types_with_unpack(t.items)
-        if isinstance(items, list):
-            fallback = t.partial_fallback.accept(self)
-            assert isinstance(fallback, ProperType) and isinstance(fallback, Instance)
-            return t.copy_modified(items=items, fallback=fallback)
-        else:
-            return items
+        if len(items) == 1:
+            # Normalize Tuple[*Tuple[X, ...]] -> Tuple[X, ...]
+            item = items[0]
+            if isinstance(item, UnpackType):
+                unpacked = get_proper_type(item.type)
+                if isinstance(unpacked, Instance):
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    if t.partial_fallback.type.fullname != "builtins.tuple":
+                        # If it is a subtype (like named tuple) we need to preserve it,
+                        # this essentially mimics the logic in tuple_fallback().
+                        return t.partial_fallback.accept(self)
+                    return unpacked
+        fallback = t.partial_fallback.accept(self)
+        assert isinstance(fallback, ProperType) and isinstance(fallback, Instance)
+        return t.copy_modified(items=items, fallback=fallback)
 
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
+        if cached := self.get_cached(t):
+            return cached
         fallback = t.fallback.accept(self)
         assert isinstance(fallback, ProperType) and isinstance(fallback, Instance)
-        return t.copy_modified(item_types=self.expand_types(t.items.values()), fallback=fallback)
+        result = t.copy_modified(item_types=self.expand_types(t.items.values()), fallback=fallback)
+        self.set_cached(t, result)
+        return result
 
     def visit_literal_type(self, t: LiteralType) -> Type:
         # TODO: Verify this implementation is correct
         return t
 
     def visit_union_type(self, t: UnionType) -> Type:
+        # Use cache to avoid O(n**2) or worse expansion of types during translation
+        # (only for large unions, since caching adds overhead)
+        use_cache = len(t.items) > 3
+        if use_cache and (cached := self.get_cached(t)):
+            return cached
+
         expanded = self.expand_types(t.items)
         # After substituting for type variables in t.items, some resulting types
         # might be subtypes of others, however calling  make_simplified_union()
@@ -509,7 +491,11 @@ def visit_union_type(self, t: UnionType) -> Type:
         # otherwise a single item union of a type alias will break it. Note this should not
         # cause infinite recursion since pathological aliases like A = Union[A, B] are
         # banned at the semantic analysis level.
-        return get_proper_type(simplified)
+        result = get_proper_type(simplified)
+
+        if use_cache:
+            self.set_cached(t, result)
+        return result
 
     def visit_partial_type(self, t: PartialType) -> Type:
         return t
@@ -525,10 +511,8 @@ def visit_type_alias_type(self, t: TypeAliasType) -> Type:
         # Target of the type alias cannot contain type variables (not bound by the type
         # alias itself), so we just expand the arguments.
         args = self.expand_types_with_unpack(t.args)
-        if isinstance(args, list):
-            return t.copy_modified(args=args)
-        else:
-            return args
+        # TODO: normalize if target is Tuple, and args are [*tuple[X, ...]]?
+        return t.copy_modified(args=args)
 
     def expand_types(self, types: Iterable[Type]) -> list[Type]:
         a: list[Type] = []
@@ -537,42 +521,12 @@ def expand_types(self, types: Iterable[Type]) -> list[Type]:
         return a
 
 
-def expand_unpack_with_variables(
-    t: UnpackType, variables: Mapping[TypeVarId, Type]
-) -> list[Type] | Instance | AnyType | None:
-    """May return either a list of types to unpack to, any, or a single
-    variable length tuple. The latter may not be valid in all contexts.
-    """
-    if isinstance(t.type, TypeVarTupleType):
-        repl = get_proper_type(variables.get(t.type.id, t))
-        if isinstance(repl, TupleType):
-            return repl.items
-        elif isinstance(repl, Instance) and repl.type.fullname == "builtins.tuple":
-            return repl
-        elif isinstance(repl, AnyType):
-            # tuple[Any, ...] would be better, but we don't have
-            # the type info to construct that type here.
-            return repl
-        elif isinstance(repl, TypeVarTupleType):
-            return [UnpackType(typ=repl)]
-        elif isinstance(repl, UnpackType):
-            return [repl]
-        elif isinstance(repl, UninhabitedType):
-            return None
-        else:
-            raise NotImplementedError(f"Invalid type replacement to expand: {repl}")
-    else:
-        raise NotImplementedError(f"Invalid type to expand: {t.type}")
-
-
 @overload
-def expand_self_type(var: Var, typ: ProperType, replacement: ProperType) -> ProperType:
-    ...
+def expand_self_type(var: Var, typ: ProperType, replacement: ProperType) -> ProperType: ...
 
 
 @overload
-def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type:
-    ...
+def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type: ...
 
 
 def expand_self_type(var: Var, typ: Type, replacement: Type) -> Type:
diff --git a/mypy/exprtotype.py b/mypy/exprtotype.py
index bbc284a5188a..506194a4b285 100644
--- a/mypy/exprtotype.py
+++ b/mypy/exprtotype.py
@@ -2,11 +2,16 @@
 
 from __future__ import annotations
 
+from typing import Callable
+
 from mypy.fastparse import parse_type_string
 from mypy.nodes import (
+    MISSING_FALLBACK,
     BytesExpr,
     CallExpr,
     ComplexExpr,
+    Context,
+    DictExpr,
     EllipsisExpr,
     Expression,
     FloatExpr,
@@ -17,7 +22,9 @@
     NameExpr,
     OpExpr,
     RefExpr,
+    StarExpr,
     StrExpr,
+    SymbolTableNode,
     TupleExpr,
     UnaryExpr,
     get_member_expr_fullname,
@@ -28,13 +35,16 @@
     AnyType,
     CallableArgument,
     EllipsisType,
+    Instance,
     ProperType,
     RawExpressionType,
     Type,
+    TypedDictType,
     TypeList,
     TypeOfAny,
     UnboundType,
     UnionType,
+    UnpackType,
 )
 
 
@@ -53,17 +63,24 @@ def _extract_argument_name(expr: Expression) -> str | None:
 
 def expr_to_unanalyzed_type(
     expr: Expression,
-    options: Options | None = None,
+    options: Options,
     allow_new_syntax: bool = False,
     _parent: Expression | None = None,
+    allow_unpack: bool = False,
+    lookup_qualified: Callable[[str, Context], SymbolTableNode | None] | None = None,
 ) -> ProperType:
     """Translate an expression to the corresponding type.
 
     The result is not semantically analyzed. It can be UnboundType or TypeList.
     Raise TypeTranslationError if the expression cannot represent a type.
 
+    If lookup_qualified is not provided, the expression is expected to be semantically
+    analyzed.
+
     If allow_new_syntax is True, allow all type syntax independent of the target
     Python version (used in stubs).
+
+    # TODO: a lot of code here is duplicated in fastparse.py, refactor this.
     """
     # The `parent` parameter is used in recursive calls to provide context for
     # understanding whether an CallableArgument is ok.
@@ -92,16 +109,26 @@ def expr_to_unanalyzed_type(
             else:
                 args = [expr.index]
 
-            if isinstance(expr.base, RefExpr) and expr.base.fullname in ANNOTATED_TYPE_NAMES:
-                # TODO: this is not the optimal solution as we are basically getting rid
-                # of the Annotation definition and only returning the type information,
-                # losing all the annotations.
+            if isinstance(expr.base, RefExpr):
+                # Check if the type is Annotated[...]. For this we need the fullname,
+                # which must be looked up if the expression hasn't been semantically analyzed.
+                base_fullname = None
+                if lookup_qualified is not None:
+                    sym = lookup_qualified(base.name, expr)
+                    if sym and sym.node:
+                        base_fullname = sym.node.fullname
+                else:
+                    base_fullname = expr.base.fullname
 
-                return expr_to_unanalyzed_type(args[0], options, allow_new_syntax, expr)
-            else:
-                base.args = tuple(
-                    expr_to_unanalyzed_type(arg, options, allow_new_syntax, expr) for arg in args
-                )
+                if base_fullname is not None and base_fullname in ANNOTATED_TYPE_NAMES:
+                    # TODO: this is not the optimal solution as we are basically getting rid
+                    # of the Annotation definition and only returning the type information,
+                    # losing all the annotations.
+                    return expr_to_unanalyzed_type(args[0], options, allow_new_syntax, expr)
+            base.args = tuple(
+                expr_to_unanalyzed_type(arg, options, allow_new_syntax, expr, allow_unpack=True)
+                for arg in args
+            )
             if not base.args:
                 base.empty_tuple_index = True
             return base
@@ -110,13 +137,14 @@ def expr_to_unanalyzed_type(
     elif (
         isinstance(expr, OpExpr)
         and expr.op == "|"
-        and ((options and options.python_version >= (3, 10)) or allow_new_syntax)
+        and ((options.python_version >= (3, 10)) or allow_new_syntax)
     ):
         return UnionType(
             [
                 expr_to_unanalyzed_type(expr.left, options, allow_new_syntax),
                 expr_to_unanalyzed_type(expr.right, options, allow_new_syntax),
-            ]
+            ],
+            uses_pep604_syntax=True,
         )
     elif isinstance(expr, CallExpr) and isinstance(_parent, ListExpr):
         c = expr.callee
@@ -163,7 +191,10 @@ def expr_to_unanalyzed_type(
         return CallableArgument(typ, name, arg_const, expr.line, expr.column)
     elif isinstance(expr, ListExpr):
         return TypeList(
-            [expr_to_unanalyzed_type(t, options, allow_new_syntax, expr) for t in expr.items],
+            [
+                expr_to_unanalyzed_type(t, options, allow_new_syntax, expr, allow_unpack=True)
+                for t in expr.items
+            ],
             line=expr.line,
             column=expr.column,
         )
@@ -174,9 +205,12 @@ def expr_to_unanalyzed_type(
     elif isinstance(expr, UnaryExpr):
         typ = expr_to_unanalyzed_type(expr.expr, options, allow_new_syntax)
         if isinstance(typ, RawExpressionType):
-            if isinstance(typ.literal_value, int) and expr.op == "-":
-                typ.literal_value *= -1
-                return typ
+            if isinstance(typ.literal_value, int):
+                if expr.op == "-":
+                    typ.literal_value *= -1
+                    return typ
+                elif expr.op == "+":
+                    return typ
         raise TypeTranslationError()
     elif isinstance(expr, IntExpr):
         return RawExpressionType(expr.value, "builtins.int", line=expr.line, column=expr.column)
@@ -189,5 +223,30 @@ def expr_to_unanalyzed_type(
         return RawExpressionType(None, "builtins.complex", line=expr.line, column=expr.column)
     elif isinstance(expr, EllipsisExpr):
         return EllipsisType(expr.line)
+    elif allow_unpack and isinstance(expr, StarExpr):
+        return UnpackType(
+            expr_to_unanalyzed_type(expr.expr, options, allow_new_syntax), from_star_syntax=True
+        )
+    elif isinstance(expr, DictExpr):
+        if not expr.items:
+            raise TypeTranslationError()
+        items: dict[str, Type] = {}
+        extra_items_from = []
+        for item_name, value in expr.items:
+            if not isinstance(item_name, StrExpr):
+                if item_name is None:
+                    extra_items_from.append(
+                        expr_to_unanalyzed_type(value, options, allow_new_syntax, expr)
+                    )
+                    continue
+                raise TypeTranslationError()
+            items[item_name.value] = expr_to_unanalyzed_type(
+                value, options, allow_new_syntax, expr
+            )
+        result = TypedDictType(
+            items, set(), set(), Instance(MISSING_FALLBACK, ()), expr.line, expr.column
+        )
+        result.extra_items_from = extra_items_from
+        return result
     else:
         raise TypeTranslationError()
diff --git a/mypy/fastparse.py b/mypy/fastparse.py
index 902bde110421..aed04c6f2eb9 100644
--- a/mypy/fastparse.py
+++ b/mypy/fastparse.py
@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-import copy
 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 collections.abc import Sequence
+from typing import Any, Callable, Final, Literal, Optional, TypeVar, Union, cast, overload
 
 from mypy import defaults, errorcodes as codes, message_registry
 from mypy.errors import Errors
@@ -17,6 +16,10 @@
     ARG_POS,
     ARG_STAR,
     ARG_STAR2,
+    MISSING_FALLBACK,
+    PARAM_SPEC_KIND,
+    TYPE_VAR_KIND,
+    TYPE_VAR_TUPLE_KIND,
     ArgKind,
     Argument,
     AssertStmt,
@@ -39,7 +42,6 @@
     EllipsisExpr,
     Expression,
     ExpressionStmt,
-    FakeInfo,
     FloatExpr,
     ForStmt,
     FuncDef,
@@ -79,6 +81,8 @@
     TempNode,
     TryStmt,
     TupleExpr,
+    TypeAliasStmt,
+    TypeParam,
     UnaryExpr,
     Var,
     WhileStmt,
@@ -111,136 +115,83 @@
     RawExpressionType,
     TupleType,
     Type,
+    TypedDictType,
     TypeList,
     TypeOfAny,
     UnboundType,
     UnionType,
+    UnpackType,
 )
 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, UAdd, 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
+
+if sys.version_info >= (3, 12):
+    ast_TypeAlias = ast3.TypeAlias
+    ast_ParamSpec = ast3.ParamSpec
+    ast_TypeVar = ast3.TypeVar
+    ast_TypeVarTuple = ast3.TypeVarTuple
+else:
+    ast_TypeAlias = Any
+    ast_ParamSpec = Any
+    ast_TypeVar = Any
+    ast_TypeVarTuple = Any
 
 N = TypeVar("N", bound=Node)
 
 # There is no way to create reasonable fallbacks at this stage,
 # they must be patched later.
-MISSING_FALLBACK: Final = FakeInfo("fallback can't be filled out until semanal")
 _dummy_fallback: Final = Instance(MISSING_FALLBACK, [], -1)
 
 TYPE_IGNORE_PATTERN: Final = re.compile(r"[^#]*#\s*type:\s*ignore\s*(.*)")
@@ -250,7 +201,7 @@ def parse(
     source: str | bytes,
     fnam: str,
     module: str | None,
-    errors: Errors | None = None,
+    errors: Errors,
     options: Options | None = None,
 ) -> MypyFile:
     """Parse a source file, without doing any semantic analysis.
@@ -259,16 +210,13 @@ def parse(
     on failure. Otherwise, use the errors object to report parse errors.
     """
     ignore_errors = (options is not None and options.ignore_errors) or (
-        errors is not None and fnam in errors.ignored_files
+        fnam in errors.ignored_files
     )
     # If errors are ignored, we can drop many function bodies to speed up type checking.
     strip_function_bodies = ignore_errors and (options is None or not options.preserve_asts)
-    raise_on_error = False
+
     if options is None:
         options = Options()
-    if errors is None:
-        errors = Errors(options)
-        raise_on_error = True
     errors.set_file(fnam, module, options=options)
     is_stub_file = fnam.endswith(".pyi")
     if is_stub_file:
@@ -288,19 +236,33 @@ def parse(
             options=options,
             is_stub=is_stub_file,
             errors=errors,
-            ignore_errors=ignore_errors,
             strip_function_bodies=strip_function_bodies,
+            path=fnam,
         ).visit(ast)
-        tree.path = fnam
-        tree.is_stub = is_stub_file
+
+    except RecursionError as e:
+        # For very complex expressions it is possible to hit recursion limit
+        # before reaching a leaf node.
+        # Should reject at top level instead at bottom, since bottom would already
+        # be at the threshold of the recursion limit, and may fail again later.
+        # E.G. x1+x2+x3+...+xn -> BinOp(left=BinOp(left=BinOp(left=...
+        try:
+            # But to prove that is the cause of this particular recursion error,
+            # try to walk the tree using builtin visitor
+            ast3.NodeVisitor().visit(ast)
+        except RecursionError:
+            errors.report(
+                -1, -1, "Source expression too complex to parse", blocker=False, code=codes.MISC
+            )
+
+            tree = MypyFile([], [], False, {})
+
+        else:
+            # re-raise original recursion error if it *can* be unparsed,
+            # maybe this is some other issue that shouldn't be silenced/misdirected
+            raise e
+
     except SyntaxError as e:
-        # alias to please mypyc
-        is_py38_or_earlier = sys.version_info < (3, 9)
-        if is_py38_or_earlier and e.filename == "<fstring>":
-            # In Python 3.8 and earlier, syntax errors in f-strings have lineno relative to the
-            # start of the f-string. This would be misleading, as mypy will report the error as the
-            # lineno within the file.
-            e.lineno = None
         message = e.msg
         if feature_version > sys.version_info.minor and message.startswith("invalid syntax"):
             python_version_str = f"{options.python_version[0]}.{options.python_version[1]}"
@@ -314,9 +276,6 @@ def parse(
         )
         tree = MypyFile([], [], False, {})
 
-    if raise_on_error and errors.is_errors():
-        errors.raise_error()
-
     assert isinstance(tree, MypyFile)
     return tree
 
@@ -370,7 +329,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)
@@ -386,13 +345,11 @@ def parse_type_string(
     string expression "blah" using this function.
     """
     try:
-        _, node = parse_type_comment(expr_string.strip(), line=line, column=column, errors=None)
-        if isinstance(node, UnboundType) and node.original_str_expr is None:
+        _, node = parse_type_comment(f"({expr_string})", line=line, column=column, errors=None)
+        if isinstance(node, (UnboundType, UnionType)) and node.original_str_expr is None:
             node.original_str_expr = expr_string
             node.original_str_fallback = expr_fallback_name
             return node
-        elif isinstance(node, UnionType):
-            return node
         else:
             return RawExpressionType(expr_string, expr_fallback_name, line, column)
     except (SyntaxError, ValueError):
@@ -410,6 +367,15 @@ def is_no_type_check_decorator(expr: ast3.expr) -> bool:
     return False
 
 
+def find_disallowed_expression_in_annotation_scope(expr: ast3.expr | None) -> ast3.expr | None:
+    if expr is None:
+        return None
+    for node in ast3.walk(expr):
+        if isinstance(node, (ast3.Yield, ast3.YieldFrom, ast3.NamedExpr, ast3.Await)):
+            return node
+    return None
+
+
 class ASTConverter:
     def __init__(
         self,
@@ -417,8 +383,8 @@ def __init__(
         is_stub: bool,
         errors: Errors,
         *,
-        ignore_errors: bool,
         strip_function_bodies: bool,
+        path: str,
     ) -> None:
         # 'C' for class, 'D' for function signature, 'F' for function, 'L' for lambda
         self.class_and_function_stack: list[Literal["C", "D", "F", "L"]] = []
@@ -427,8 +393,8 @@ def __init__(
         self.options = options
         self.is_stub = is_stub
         self.errors = errors
-        self.ignore_errors = ignore_errors
         self.strip_function_bodies = strip_function_bodies
+        self.path = path
 
         self.type_ignores: dict[int, list[str]] = {}
 
@@ -438,8 +404,12 @@ def __init__(
     def note(self, msg: str, line: int, column: int) -> None:
         self.errors.report(line, column, msg, severity="note", code=codes.SYNTAX)
 
-    def fail(self, msg: ErrorMessage, line: int, column: int, blocker: bool = True) -> None:
+    def fail(self, msg: ErrorMessage, line: int, column: int, blocker: bool) -> None:
         if blocker or not self.options.ignore_errors:
+            # Make sure self.errors reflects any type ignores that we have parsed
+            self.errors.set_file_ignored_lines(
+                self.path, self.type_ignores, self.options.ignore_errors
+            )
             self.errors.report(line, column, msg.value, blocker=blocker, code=msg.code)
 
     def fail_merge_overload(self, node: IfStmt) -> None:
@@ -459,6 +429,7 @@ def visit(self, node: AST | None) -> Any:
             method = "visit_" + node.__class__.__name__
             visitor = getattr(self, method)
             self.visitor_cache[typeobj] = visitor
+
         return visitor(node)
 
     def set_line(self, node: N, n: AstNode) -> N:
@@ -477,7 +448,7 @@ def translate_opt_expr_list(self, l: Sequence[AST | None]) -> list[Expression |
         return res
 
     def translate_expr_list(self, l: Sequence[AST]) -> list[Expression]:
-        return cast(List[Expression], self.translate_opt_expr_list(l))
+        return cast(list[Expression], self.translate_opt_expr_list(l))
 
     def get_lineno(self, node: ast3.expr | ast3.stmt) -> int:
         if (
@@ -521,7 +492,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 +507,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(
@@ -602,7 +581,7 @@ def from_operator(self, op: ast3.operator) -> str:
         ast3.Is: "is",
         ast3.IsNot: "is not",
         ast3.In: "in",
-        ast3.NotIn: "not in",
+        ast3.NotIn: "not in",  # codespell:ignore notin
     }
 
     def from_comp_operator(self, op: ast3.cmpop) -> str:
@@ -664,10 +643,9 @@ def fix_function_overloads(self, stmts: list[Statement]) -> list[Statement]:
                 # Check IfStmt block to determine if function overloads can be merged
                 if_overload_name = self._check_ifstmt_for_overloads(stmt, current_overload_name)
                 if if_overload_name is not None:
-                    (
-                        if_block_with_overload,
-                        if_unknown_truth_value,
-                    ) = self._get_executable_if_block_with_overloads(stmt)
+                    (if_block_with_overload, if_unknown_truth_value) = (
+                        self._get_executable_if_block_with_overloads(stmt)
+                    )
 
             if (
                 current_overload_name is not None
@@ -713,7 +691,7 @@ def fix_function_overloads(self, stmts: list[Statement]) -> list[Statement]:
                         current_overload.append(last_if_overload)
                     last_if_stmt, last_if_overload = None, None
                 if isinstance(if_block_with_overload.body[-1], OverloadedFuncDef):
-                    skipped_if_stmts.extend(cast(List[IfStmt], if_block_with_overload.body[:-1]))
+                    skipped_if_stmts.extend(cast(list[IfStmt], if_block_with_overload.body[:-1]))
                     current_overload.extend(if_block_with_overload.body[-1].items)
                 else:
                     current_overload.append(
@@ -760,7 +738,7 @@ def fix_function_overloads(self, stmts: list[Statement]) -> list[Statement]:
                     last_if_stmt_overload_name = None
                     if if_block_with_overload is not None:
                         skipped_if_stmts.extend(
-                            cast(List[IfStmt], if_block_with_overload.body[:-1])
+                            cast(list[IfStmt], if_block_with_overload.body[:-1])
                         )
                         last_if_overload = cast(
                             Union[Decorator, FuncDef, OverloadedFuncDef],
@@ -910,8 +888,13 @@ def visit_Module(self, mod: ast3.Module) -> MypyFile:
                 self.type_ignores[ti.lineno] = parsed
             else:
                 self.fail(message_registry.INVALID_TYPE_IGNORE, ti.lineno, -1, blocker=False)
+
         body = self.fix_function_overloads(self.translate_stmt_list(mod.body, ismodule=True))
-        return MypyFile(body, self.imports, False, self.type_ignores)
+
+        ret = MypyFile(body, self.imports, False, ignored_lines=self.type_ignores)
+        ret.is_stub = self.is_stub
+        ret.path = self.path
+        return ret
 
     # --- stmt ---
     # FunctionDef(identifier name, arguments args,
@@ -943,6 +926,8 @@ def do_func_def(
 
         arg_kinds = [arg.kind for arg in args]
         arg_names = [None if arg.pos_only else arg.variable.name for arg in args]
+        # Type parameters, if using new syntax for generics (PEP 695)
+        explicit_type_params: list[TypeParam] | None = None
 
         arg_types: list[Type | None] = []
         if no_type_check:
@@ -953,27 +938,41 @@ 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
-                        self.fail(message_registry.DUPLICATE_TYPE_SIGNATURES, lineno, n.col_offset)
+                        self.fail(
+                            message_registry.DUPLICATE_TYPE_SIGNATURES,
+                            lineno,
+                            n.col_offset,
+                            blocker=False,
+                        )
                     arg_types = [
-                        a.type_annotation
-                        if a.type_annotation is not None
-                        else AnyType(TypeOfAny.unannotated)
+                        (
+                            a.type_annotation
+                            if a.type_annotation is not None
+                            else AnyType(TypeOfAny.unannotated)
+                        )
                         for a in args
                     ]
                 else:
                     # PEP 484 disallows both type annotations and type comments
                     if n.returns or any(a.type_annotation is not None for a in args):
-                        self.fail(message_registry.DUPLICATE_TYPE_SIGNATURES, lineno, n.col_offset)
+                        self.fail(
+                            message_registry.DUPLICATE_TYPE_SIGNATURES,
+                            lineno,
+                            n.col_offset,
+                            blocker=False,
+                        )
                     translated_args: list[Type] = TypeConverter(
                         self.errors, line=lineno, override_column=n.col_offset
                     ).translate_expr_list(func_type_ast.argtypes)
                     # Use a cast to work around `list` invariance
-                    arg_types = cast(List[Optional[Type]], translated_args)
+                    arg_types = cast(list[Optional[Type]], translated_args)
                 return_type = TypeConverter(self.errors, line=lineno).visit(func_type_ast.returns)
 
                 # add implicit self type
@@ -983,7 +982,7 @@ def do_func_def(
             except SyntaxError:
                 stripped_type = n.type_comment.split("#", 2)[0].strip()
                 err_msg = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)
-                self.fail(err_msg, lineno, n.col_offset)
+                self.fail(err_msg, lineno, n.col_offset, blocker=False)
                 if n.type_comment and n.type_comment[0] not in ["(", "#"]:
                     self.note(
                         "Suggestion: wrap argument types in parentheses", lineno, n.col_offset
@@ -991,6 +990,9 @@ def do_func_def(
                 arg_types = [AnyType(TypeOfAny.from_error)] * len(args)
                 return_type = AnyType(TypeOfAny.from_error)
         else:
+            if sys.version_info >= (3, 12) and n.type_params:
+                explicit_type_params = self.translate_type_params(n.type_params)
+
             arg_types = [a.type_annotation for a in args]
             return_type = TypeConverter(
                 self.errors, line=n.returns.lineno if n.returns else lineno
@@ -1002,7 +1004,12 @@ def do_func_def(
         func_type = None
         if any(arg_types) or return_type:
             if len(arg_types) != 1 and any(isinstance(t, EllipsisType) for t in arg_types):
-                self.fail(message_registry.ELLIPSIS_WITH_OTHER_TYPEARGS, lineno, n.col_offset)
+                self.fail(
+                    message_registry.ELLIPSIS_WITH_OTHER_TYPEARGS,
+                    lineno,
+                    n.col_offset,
+                    blocker=False,
+                )
             elif len(arg_types) > len(arg_kinds):
                 self.fail(
                     message_registry.TYPE_SIGNATURE_TOO_MANY_ARGS,
@@ -1033,7 +1040,7 @@ def do_func_def(
         self.class_and_function_stack.pop()
         self.class_and_function_stack.append("F")
         body = self.as_required_block(n.body, can_strip=True, is_coroutine=is_coroutine)
-        func_def = FuncDef(n.name, args, body, func_type)
+        func_def = FuncDef(n.name, args, body, func_type, explicit_type_params)
         if isinstance(func_def.type, CallableType):
             # semanal.py does some in-place modifications we want to avoid
             func_def.unanalyzed_type = func_def.type.copy_modified()
@@ -1041,35 +1048,25 @@ def do_func_def(
             func_def.is_coroutine = True
         if func_type is not None:
             func_type.definition = func_def
-            func_type.line = lineno
+            func_type.set_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
-
             var = Var(func_def.name)
             var.is_ready = False
             var.set_line(lineno)
 
             func_def.is_decorated = True
-            func_def.deco_line = deco_line
-            func_def.set_line(lineno, n.col_offset, end_line, end_column)
+            self.set_line(func_def, n)
 
             deco = Decorator(func_def, self.translate_expr_list(n.decorator_list), var)
             first = n.decorator_list[0]
             deco.set_line(first.lineno, first.col_offset, end_line, end_column)
             retval: FuncDef | Decorator = deco
         else:
-            # FuncDef overrides set_line -- can't use self.set_line
-            func_def.set_line(lineno, n.col_offset, end_line, end_column)
+            self.set_line(func_def, n)
             retval = func_def
+        if self.options.include_docstrings:
+            func_def.docstring = ast3.get_docstring(n, clean=False)
         self.class_and_function_stack.pop()
         return retval
 
@@ -1086,7 +1083,7 @@ def transform_args(
     ) -> list[Argument]:
         new_args = []
         names: list[ast3.arg] = []
-        posonlyargs = getattr(args, "posonlyargs", cast(List[ast3.arg], []))
+        posonlyargs = getattr(args, "posonlyargs", cast(list[ast3.arg], []))
         args_args = posonlyargs + args.args
         args_defaults = args.defaults
         num_no_defaults = len(args_args) - len(args_defaults)
@@ -1139,7 +1136,12 @@ def make_argument(
             annotation = arg.annotation
             type_comment = arg.type_comment
             if annotation is not None and type_comment is not None:
-                self.fail(message_registry.DUPLICATE_TYPE_SIGNATURES, arg.lineno, arg.col_offset)
+                self.fail(
+                    message_registry.DUPLICATE_TYPE_SIGNATURES,
+                    arg.lineno,
+                    arg.col_offset,
+                    blocker=False,
+                )
             arg_type = None
             if annotation is not None:
                 arg_type = TypeConverter(self.errors, line=arg.lineno).visit(annotation)
@@ -1148,7 +1150,9 @@ def make_argument(
         if argument_elide_name(arg.arg):
             pos_only = True
 
-        argument = Argument(Var(arg.arg), arg_type, self.visit(default), kind, pos_only)
+        var = Var(arg.arg, arg_type)
+        var.is_inferred = False
+        argument = Argument(var, arg_type, self.visit(default), kind, pos_only)
         argument.set_line(
             arg.lineno,
             arg.col_offset,
@@ -1158,7 +1162,7 @@ def make_argument(
         return argument
 
     def fail_arg(self, msg: str, arg: ast3.arg) -> None:
-        self.fail(ErrorMessage(msg), arg.lineno, arg.col_offset)
+        self.fail(ErrorMessage(msg), arg.lineno, arg.col_offset, blocker=True)
 
     # ClassDef(identifier name,
     #  expr* bases,
@@ -1169,6 +1173,12 @@ def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
         self.class_and_function_stack.append("C")
         keywords = [(kw.arg, self.visit(kw.value)) for kw in n.keywords if kw.arg]
 
+        # Type parameters, if using new syntax for generics (PEP 695)
+        explicit_type_params: list[TypeParam] | None = None
+
+        if sys.version_info >= (3, 12) and n.type_params:
+            explicit_type_params = self.translate_type_params(n.type_params)
+
         cdef = ClassDef(
             n.name,
             self.as_required_block(n.body),
@@ -1176,22 +1186,79 @@ def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
             self.translate_expr_list(n.bases),
             metaclass=dict(keywords).get("metaclass"),
             keywords=keywords,
+            type_args=explicit_type_params,
         )
         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
+        self.set_line(cdef, n)
+
+        if self.options.include_docstrings:
+            cdef.docstring = ast3.get_docstring(n, clean=False)
         cdef.column = n.col_offset
         cdef.end_line = getattr(n, "end_lineno", None)
         cdef.end_column = getattr(n, "end_col_offset", None)
         self.class_and_function_stack.pop()
         return cdef
 
+    def validate_type_param(self, type_param: ast_TypeVar) -> None:
+        incorrect_expr = find_disallowed_expression_in_annotation_scope(type_param.bound)
+        if incorrect_expr is None:
+            return
+        if isinstance(incorrect_expr, (ast3.Yield, ast3.YieldFrom)):
+            self.fail(
+                message_registry.TYPE_VAR_YIELD_EXPRESSION_IN_BOUND,
+                type_param.lineno,
+                type_param.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.NamedExpr):
+            self.fail(
+                message_registry.TYPE_VAR_NAMED_EXPRESSION_IN_BOUND,
+                type_param.lineno,
+                type_param.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.Await):
+            self.fail(
+                message_registry.TYPE_VAR_AWAIT_EXPRESSION_IN_BOUND,
+                type_param.lineno,
+                type_param.col_offset,
+                blocker=True,
+            )
+
+    def translate_type_params(self, type_params: list[Any]) -> list[TypeParam]:
+        explicit_type_params = []
+        for p in type_params:
+            bound: Type | None = None
+            values: list[Type] = []
+            default: Type | None = None
+            if sys.version_info >= (3, 13):
+                default = TypeConverter(self.errors, line=p.lineno).visit(p.default_value)
+            if isinstance(p, ast_ParamSpec):  # type: ignore[misc]
+                explicit_type_params.append(TypeParam(p.name, PARAM_SPEC_KIND, None, [], default))
+            elif isinstance(p, ast_TypeVarTuple):  # type: ignore[misc]
+                explicit_type_params.append(
+                    TypeParam(p.name, TYPE_VAR_TUPLE_KIND, None, [], default)
+                )
+            else:
+                if isinstance(p.bound, ast3.Tuple):
+                    if len(p.bound.elts) < 2:
+                        self.fail(
+                            message_registry.TYPE_VAR_TOO_FEW_CONSTRAINED_TYPES,
+                            p.lineno,
+                            p.col_offset,
+                            blocker=False,
+                        )
+                    else:
+                        conv = TypeConverter(self.errors, line=p.lineno)
+                        values = [conv.visit(t) for t in p.bound.elts]
+                elif p.bound is not None:
+                    self.validate_type_param(p)
+                    bound = TypeConverter(self.errors, line=p.lineno).visit(p.bound)
+                explicit_type_params.append(
+                    TypeParam(p.name, TYPE_VAR_KIND, bound, values, default)
+                )
+        return explicit_type_params
+
     # Return(expr? value)
     def visit_Return(self, n: ast3.Return) -> ReturnStmt:
         node = ReturnStmt(self.visit(n.value))
@@ -1220,8 +1287,7 @@ def visit_AnnAssign(self, n: ast3.AnnAssign) -> AssignmentStmt:
         line = n.lineno
         if n.value is None:  # always allow 'x: int'
             rvalue: Expression = TempNode(AnyType(TypeOfAny.special_form), no_rhs=True)
-            rvalue.line = line
-            rvalue.column = n.col_offset
+            self.set_line(rvalue, n)
         else:
             rvalue = self.visit(n.value)
         typ = TypeConverter(self.errors, line=line).visit(n.annotation)
@@ -1561,7 +1627,7 @@ def visit_Call(self, n: Call) -> CallExpr:
             self.visit(n.func),
             arg_types,
             arg_kinds,
-            cast("List[Optional[str]]", [None] * len(args)) + keyword_names,
+            cast("list[Optional[str]]", [None] * len(args)) + keyword_names,
         )
         return self.set_line(e, n)
 
@@ -1572,9 +1638,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):
@@ -1589,28 +1655,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
@@ -1622,6 +1666,12 @@ def visit_JoinedStr(self, n: ast3.JoinedStr) -> Expression:
         # Don't make unnecessary join call if there is only one str to join
         if len(strs_to_join.items) == 1:
             return self.set_line(strs_to_join.items[0], n)
+        elif len(strs_to_join.items) > 1:
+            last = strs_to_join.items[-1]
+            if isinstance(last, StrExpr) and last.value == "":
+                # 3.12 can add an empty literal at the end. Delete it for consistency
+                # between Python versions.
+                del strs_to_join.items[-1:]
         join_method = MemberExpr(empty_string, "join")
         join_method.set_line(empty_string)
         result_expression = CallExpr(join_method, [strs_to_join], [ARG_POS], [None])
@@ -1635,7 +1685,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)
@@ -1646,21 +1696,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
@@ -1679,19 +1714,7 @@ def visit_Attribute(self, n: Attribute) -> MemberExpr | SuperExpr:
     # Subscript(expr value, slice slice, expr_context ctx)
     def visit_Subscript(self, n: ast3.Subscript) -> IndexExpr:
         e = IndexExpr(self.visit(n.value), self.visit(n.slice))
-        self.set_line(e, n)
-        # alias to please mypyc
-        is_py38_or_earlier = sys.version_info < (3, 9)
-        if isinstance(n.slice, ast3.Slice) or (
-            is_py38_or_earlier and isinstance(n.slice, ast3.ExtSlice)
-        ):
-            # Before Python 3.9, Slice has no line/column in the raw ast. To avoid incompatibility
-            # visit_Slice doesn't set_line, even in Python 3.9 on.
-            # ExtSlice also has no line/column info. In Python 3.9 on, line/column is set for
-            # e.index when visiting n.slice.
-            e.index.line = e.line
-            e.index.column = e.column
-        return e
+        return self.set_line(e, n)
 
     # Starred(expr value, expr_context ctx)
     def visit_Starred(self, n: Starred) -> StarExpr:
@@ -1722,7 +1745,8 @@ def visit_Tuple(self, n: ast3.Tuple) -> TupleExpr:
 
     # Slice(expr? lower, expr? upper, expr? step)
     def visit_Slice(self, n: ast3.Slice) -> SliceExpr:
-        return SliceExpr(self.visit(n.lower), self.visit(n.upper), self.visit(n.step))
+        e = SliceExpr(self.visit(n.lower), self.visit(n.upper), self.visit(n.step))
+        return self.set_line(e, n)
 
     # ExtSlice(slice* dims)
     def visit_ExtSlice(self, n: ast3.ExtSlice) -> TupleExpr:
@@ -1808,6 +1832,47 @@ def visit_MatchOr(self, n: MatchOr) -> OrPattern:
         node = OrPattern([self.visit(pattern) for pattern in n.patterns])
         return self.set_line(node, n)
 
+    def validate_type_alias(self, n: ast_TypeAlias) -> None:
+        incorrect_expr = find_disallowed_expression_in_annotation_scope(n.value)
+        if incorrect_expr is None:
+            return
+        if isinstance(incorrect_expr, (ast3.Yield, ast3.YieldFrom)):
+            self.fail(
+                message_registry.TYPE_ALIAS_WITH_YIELD_EXPRESSION,
+                n.lineno,
+                n.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.NamedExpr):
+            self.fail(
+                message_registry.TYPE_ALIAS_WITH_NAMED_EXPRESSION,
+                n.lineno,
+                n.col_offset,
+                blocker=True,
+            )
+        if isinstance(incorrect_expr, ast3.Await):
+            self.fail(
+                message_registry.TYPE_ALIAS_WITH_AWAIT_EXPRESSION,
+                n.lineno,
+                n.col_offset,
+                blocker=True,
+            )
+
+    # TypeAlias(identifier name, type_param* type_params, expr value)
+    def visit_TypeAlias(self, n: ast_TypeAlias) -> TypeAliasStmt | AssignmentStmt:
+        node: TypeAliasStmt | AssignmentStmt
+        type_params = self.translate_type_params(n.type_params)
+        self.validate_type_alias(n)
+        value = self.visit(n.value)
+        # Since the value is evaluated lazily, wrap the value inside a lambda.
+        # This helps mypyc.
+        ret = ReturnStmt(value)
+        self.set_line(ret, n.value)
+        value_func = LambdaExpr(body=Block([ret]))
+        self.set_line(value_func, n.value)
+        node = TypeAliasStmt(self.visit_Name(n.name), type_params, value_func)
+        return self.set_line(node, n)
+
 
 class TypeConverter:
     def __init__(
@@ -1849,12 +1914,10 @@ def invalid_type(self, node: AST, note: str | None = None) -> RawExpressionType:
         )
 
     @overload
-    def visit(self, node: ast3.expr) -> ProperType:
-        ...
+    def visit(self, node: ast3.expr) -> ProperType: ...
 
     @overload
-    def visit(self, node: AST | None) -> ProperType | None:
-        ...
+    def visit(self, node: AST | None) -> ProperType | None: ...
 
     def visit(self, node: AST | None) -> ProperType | None:
         """Modified visit -- keep track of the stack of nodes"""
@@ -1947,9 +2010,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__),
@@ -1975,13 +2038,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
         if val is None:
@@ -1989,7 +2045,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)
@@ -2006,13 +2062,19 @@ def visit_Constant(self, n: Constant) -> Type:
 
     # UnaryOp(op, operand)
     def visit_UnaryOp(self, n: UnaryOp) -> Type:
-        # We support specifically Literal[-4] and nothing else.
-        # For example, Literal[+4] or Literal[~6] is not supported.
+        # We support specifically Literal[-4], Literal[+4], and nothing else.
+        # For example, Literal[~6] or Literal[not False] is not supported.
         typ = self.visit(n.operand)
-        if isinstance(typ, RawExpressionType) and isinstance(n.op, USub):
-            if isinstance(typ.literal_value, int):
+        if (
+            isinstance(typ, RawExpressionType)
+            # Use type() because we do not want to allow bools.
+            and type(typ.literal_value) is int
+        ):
+            if isinstance(n.op, USub):
                 typ.literal_value *= -1
                 return typ
+            if isinstance(n.op, UAdd):
+                return typ
         return self.invalid_type(n)
 
     def numeric_type(self, value: object, n: AST) -> Type:
@@ -2033,23 +2095,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)
@@ -2059,48 +2104,28 @@ def visit_Index(self, n: ast3.Index) -> Type:
     def visit_Slice(self, n: ast3.Slice) -> Type:
         return self.invalid_type(n, note="did you mean to use ',' instead of ':' ?")
 
-    # Subscript(expr value, slice slice, expr_context ctx)  # Python 3.8 and before
     # Subscript(expr value, expr slice, expr_context ctx)  # Python 3.9 and later
     def visit_Subscript(self, n: ast3.Subscript) -> Type:
-        if sys.version_info >= (3, 9):  # Really 3.9a5 or later
-            sliceval: Any = n.slice
-        # Python 3.8 or earlier use a different AST structure for subscripts
-        elif isinstance(n.slice, ast3.Index):
-            sliceval: Any = n.slice.value
-        elif isinstance(n.slice, ast3.Slice):
-            sliceval = copy.deepcopy(n.slice)  # so we don't mutate passed AST
-            if getattr(sliceval, "col_offset", None) is None:
-                # Fix column information so that we get Python 3.9+ message order
-                sliceval.col_offset = sliceval.lower.col_offset
-        else:
-            assert isinstance(n.slice, ast3.ExtSlice)
-            dims = copy.deepcopy(n.slice.dims)
-            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]
-                    elif isinstance(s, ast3.Slice):
-                        assert s.lower is not None
-                        s.col_offset = s.lower.col_offset  # type: ignore[attr-defined]
-            sliceval = ast3.Tuple(dims, n.ctx)
-
         empty_tuple_index = False
-        if isinstance(sliceval, ast3.Tuple):
-            params = self.translate_expr_list(sliceval.elts)
-            if len(sliceval.elts) == 0:
+        if isinstance(n.slice, ast3.Tuple):
+            params = self.translate_expr_list(n.slice.elts)
+            if len(n.slice.elts) == 0:
                 empty_tuple_index = True
         else:
-            params = [self.visit(sliceval)]
+            params = [self.visit(n.slice)]
 
         value = self.visit(n.value)
         if isinstance(value, UnboundType) and not value.args:
-            return UnboundType(
+            result = UnboundType(
                 value.name,
                 params,
                 line=self.line,
                 column=value.column,
                 empty_tuple_index=empty_tuple_index,
             )
+            result.end_column = getattr(n, "end_col_offset", None)
+            result.end_line = getattr(n, "end_lineno", None)
+            return result
         else:
             return self.invalid_type(n)
 
@@ -2113,23 +2138,40 @@ def visit_Tuple(self, n: ast3.Tuple) -> Type:
             column=self.convert_column(n.col_offset),
         )
 
+    def visit_Dict(self, n: ast3.Dict) -> Type:
+        if not n.keys:
+            return self.invalid_type(n)
+        items: dict[str, Type] = {}
+        extra_items_from = []
+        for item_name, value in zip(n.keys, n.values):
+            if not isinstance(item_name, ast3.Constant) or not isinstance(item_name.value, str):
+                if item_name is None:
+                    extra_items_from.append(self.visit(value))
+                    continue
+                return self.invalid_type(n)
+            items[item_name.value] = self.visit(value)
+        result = TypedDictType(items, set(), set(), _dummy_fallback, n.lineno, n.col_offset)
+        result.extra_items_from = extra_items_from
+        return result
+
     # Attribute(expr value, identifier attr, expr_context ctx)
     def visit_Attribute(self, n: Attribute) -> Type:
         before_dot = self.visit(n.value)
 
         if isinstance(before_dot, UnboundType) and not before_dot.args:
-            return UnboundType(f"{before_dot.name}.{n.attr}", line=self.line)
+            return UnboundType(f"{before_dot.name}.{n.attr}", line=self.line, column=n.col_offset)
         else:
             return self.invalid_type(n)
 
-    # Ellipsis
-    def visit_Ellipsis(self, n: ast3_Ellipsis) -> Type:
-        return EllipsisType(line=self.line)
+    # Used for Callable[[X *Ys, Z], R] etc.
+    def visit_Starred(self, n: ast3.Starred) -> Type:
+        return UnpackType(self.visit(n.value), from_star_syntax=True)
 
     # List(expr* elts, expr_context ctx)
     def visit_List(self, n: ast3.List) -> Type:
         assert isinstance(n.ctx, ast3.Load)
-        return self.translate_argument_list(n.elts)
+        result = self.translate_argument_list(n.elts)
+        return result
 
 
 def stringify_name(n: AST) -> str | None:
@@ -2189,7 +2231,7 @@ def visit_member_expr(self, e: MemberExpr) -> None:
 
 
 class FindYield(TraverserVisitor):
-    """Check if an AST contains yields or yield froms."""
+    """Check if an AST contains yields or yield froms."""  # codespell:ignore froms
 
     def __init__(self) -> None:
         self.found = False
diff --git a/mypy/find_sources.py b/mypy/find_sources.py
index a3ef2d3db052..ececbf9c1cb8 100644
--- a/mypy/find_sources.py
+++ b/mypy/find_sources.py
@@ -4,11 +4,17 @@
 
 import functools
 import os
-from typing import Sequence
-from typing_extensions import Final
+from collections.abc import Sequence
+from typing import Final
 
 from mypy.fscache import FileSystemCache
-from mypy.modulefinder import PYTHON_EXTENSIONS, BuildSource, matches_exclude, mypy_path
+from mypy.modulefinder import (
+    PYTHON_EXTENSIONS,
+    BuildSource,
+    matches_exclude,
+    matches_gitignore,
+    mypy_path,
+)
 from mypy.options import Options
 
 PY_EXTENSIONS: Final = tuple(PYTHON_EXTENSIONS)
@@ -94,6 +100,7 @@ def __init__(self, fscache: FileSystemCache, options: Options) -> None:
         self.explicit_package_bases = get_explicit_package_bases(options)
         self.namespace_packages = options.namespace_packages
         self.exclude = options.exclude
+        self.exclude_gitignore = options.exclude_gitignore
         self.verbosity = options.verbosity
 
     def is_explicit_package_base(self, path: str) -> bool:
@@ -113,6 +120,10 @@ def find_sources_in_dir(self, path: str) -> list[BuildSource]:
 
             if matches_exclude(subpath, self.exclude, self.fscache, self.verbosity >= 2):
                 continue
+            if self.exclude_gitignore and matches_gitignore(
+                subpath, self.fscache, self.verbosity >= 2
+            ):
+                continue
 
             if self.fscache.isdir(subpath):
                 sub_sources = self.find_sources_in_dir(subpath)
@@ -160,7 +171,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.
 
@@ -176,8 +187,7 @@ def _crawl_up_helper(self, dir: str) -> tuple[str, str] | None:
             return "", dir
 
         parent, name = os.path.split(dir)
-        if name.endswith("-stubs"):
-            name = name[:-6]  # PEP-561 stub-only directory
+        name = name.removesuffix("-stubs")  # PEP-561 stub-only directory
 
         # recurse if there's an __init__.py
         init_file = self.get_init_file(dir)
diff --git a/mypy/fixup.py b/mypy/fixup.py
index 15f4c13c20fa..8e7cd40544bf 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 (
@@ -82,11 +81,17 @@ def visit_type_info(self, info: TypeInfo) -> None:
                 info.update_tuple_type(info.tuple_type)
                 if info.special_alias:
                     info.special_alias.alias_tvars = list(info.defn.type_vars)
+                    for i, t in enumerate(info.defn.type_vars):
+                        if isinstance(t, TypeVarTupleType):
+                            info.special_alias.tvar_tuple_index = i
             if info.typeddict_type:
                 info.typeddict_type.accept(self.type_fixer)
                 info.update_typeddict_type(info.typeddict_type)
                 if info.special_alias:
                     info.special_alias.alias_tvars = list(info.defn.type_vars)
+                    for i, t in enumerate(info.defn.type_vars):
+                        if isinstance(t, TypeVarTupleType):
+                            info.special_alias.tvar_tuple_index = i
             if info.declared_metaclass:
                 info.declared_metaclass.accept(self.type_fixer)
             if info.metaclass_type:
@@ -112,7 +117,8 @@ def visit_type_info(self, info: TypeInfo) -> None:
     # NOTE: This method *definitely* isn't part of the NodeVisitor API.
     def visit_symbol_table(self, symtab: SymbolTable, table_fullname: str) -> None:
         # Copy the items because we may mutate symtab.
-        for key, value in list(symtab.items()):
+        for key in list(symtab):
+            value = symtab[key]
             cross_ref = value.cross_ref
             if cross_ref is not None:  # Fix up cross-reference.
                 value.cross_ref = None
@@ -123,8 +129,23 @@ def visit_symbol_table(self, symtab: SymbolTable, table_fullname: str) -> None:
                         cross_ref, self.modules, raise_on_missing=not self.allow_missing
                     )
                     if stnode is not None:
-                        assert stnode.node is not None, (table_fullname + "." + key, cross_ref)
-                        value.node = stnode.node
+                        if stnode is value:
+                            # The node seems to refer to itself, which can mean that
+                            # the target is a deleted submodule of the current module,
+                            # and thus lookup falls back to the symbol table of the parent
+                            # package. Here's how this may happen:
+                            #
+                            #   pkg/__init__.py:
+                            #     from pkg import sub
+                            #
+                            # Now if pkg.sub is deleted, the pkg.sub symbol table entry
+                            # appears to refer to itself. Replace the entry with a
+                            # placeholder to avoid a crash. We can't delete the entry,
+                            # as it would stop dependency propagation.
+                            value.node = Var(key + "@deleted")
+                        else:
+                            assert stnode.node is not None, (table_fullname + "." + key, cross_ref)
+                            value.node = stnode.node
                     elif not self.allow_missing:
                         assert False, f"Could not find cross-ref {cross_ref}"
                     else:
@@ -167,11 +188,7 @@ def visit_decorator(self, d: Decorator) -> None:
 
     def visit_class_def(self, c: ClassDef) -> None:
         for v in c.type_vars:
-            if isinstance(v, TypeVarType):
-                for value in v.values:
-                    value.accept(self.type_fixer)
-            v.upper_bound.accept(self.type_fixer)
-            v.default.accept(self.type_fixer)
+            v.accept(self.type_fixer)
 
     def visit_type_var_expr(self, tv: TypeVarExpr) -> None:
         for value in tv.values:
@@ -185,6 +202,7 @@ def visit_paramspec_expr(self, p: ParamSpecExpr) -> None:
 
     def visit_type_var_tuple_expr(self, tv: TypeVarTupleExpr) -> None:
         tv.upper_bound.accept(self.type_fixer)
+        tv.tuple_fallback.accept(self.type_fixer)
         tv.default.accept(self.type_fixer)
 
     def visit_var(self, v: Var) -> None:
@@ -192,6 +210,8 @@ def visit_var(self, v: Var) -> None:
             v.info = self.current_info
         if v.type is not None:
             v.type.accept(self.type_fixer)
+        if v.setter_type is not None:
+            v.setter_type.accept(self.type_fixer)
 
     def visit_type_alias(self, a: TypeAlias) -> None:
         a.target.accept(self.type_fixer)
@@ -222,6 +242,9 @@ def visit_instance(self, inst: Instance) -> None:
             a.accept(self)
         if inst.last_known_value is not None:
             inst.last_known_value.accept(self)
+        if inst.extra_attrs:
+            for v in inst.extra_attrs.attrs.values():
+                v.accept(self)
 
     def visit_type_alias_type(self, t: TypeAliasType) -> None:
         type_ref = t.type_ref
@@ -253,6 +276,8 @@ def visit_callable_type(self, ct: CallableType) -> None:
                 arg.accept(self)
         if ct.type_guard is not None:
             ct.type_guard.accept(self)
+        if ct.type_is is not None:
+            ct.type_is.accept(self)
 
     def visit_overloaded(self, t: Overloaded) -> None:
         for ct in t.items:
@@ -315,6 +340,7 @@ def visit_param_spec(self, p: ParamSpecType) -> None:
         p.default.accept(self)
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
+        t.tuple_fallback.accept(self)
         t.upper_bound.accept(self)
         t.default.accept(self)
 
@@ -337,9 +363,6 @@ def visit_union_type(self, ut: UnionType) -> None:
             for it in ut.items:
                 it.accept(self)
 
-    def visit_void(self, o: Any) -> None:
-        pass  # Nothing to descend into.
-
     def visit_type_type(self, t: TypeType) -> None:
         t.item.accept(self)
 
diff --git a/mypy/fscache.py b/mypy/fscache.py
index 15679ad03e85..8251f4bd9488 100644
--- a/mypy/fscache.py
+++ b/mypy/fscache.py
@@ -51,8 +51,8 @@ def set_package_root(self, package_root: list[str]) -> None:
 
     def flush(self) -> None:
         """Start another transaction and empty all caches."""
-        self.stat_cache: dict[str, os.stat_result] = {}
-        self.stat_error_cache: dict[str, OSError] = {}
+        self.stat_or_none_cache: dict[str, os.stat_result | None] = {}
+
         self.listdir_cache: dict[str, list[str]] = {}
         self.listdir_error_cache: dict[str, OSError] = {}
         self.isfile_case_cache: dict[str, bool] = {}
@@ -62,24 +62,21 @@ def flush(self) -> None:
         self.hash_cache: dict[str, str] = {}
         self.fake_package_cache: set[str] = set()
 
-    def stat(self, path: str) -> os.stat_result:
-        if path in self.stat_cache:
-            return self.stat_cache[path]
-        if path in self.stat_error_cache:
-            raise copy_os_error(self.stat_error_cache[path])
+    def stat_or_none(self, path: str) -> os.stat_result | None:
+        if path in self.stat_or_none_cache:
+            return self.stat_or_none_cache[path]
+
+        st = None
         try:
             st = os.stat(path)
-        except OSError as err:
+        except OSError:
             if self.init_under_package_root(path):
                 try:
-                    return self._fake_init(path)
+                    st = self._fake_init(path)
                 except OSError:
                     pass
-            # Take a copy to get rid of associated traceback and frame objects.
-            # Just assigning to __traceback__ doesn't free them.
-            self.stat_error_cache[path] = copy_os_error(err)
-            raise err
-        self.stat_cache[path] = st
+
+        self.stat_or_none_cache[path] = st
         return st
 
     def init_under_package_root(self, path: str) -> bool:
@@ -112,9 +109,9 @@ def init_under_package_root(self, path: str) -> bool:
         if not os.path.basename(dirname).isidentifier():
             # Can't put an __init__.py in a place that's not an identifier
             return False
-        try:
-            st = self.stat(dirname)
-        except OSError:
+
+        st = self.stat_or_none(dirname)
+        if st is None:
             return False
         else:
             if not stat.S_ISDIR(st.st_mode):
@@ -145,7 +142,7 @@ def _fake_init(self, path: str) -> os.stat_result:
         assert basename == "__init__.py", path
         assert not os.path.exists(path), path  # Not cached!
         dirname = os.path.normpath(dirname)
-        st = self.stat(dirname)  # May raise OSError
+        st = os.stat(dirname)  # May raise OSError
         # Get stat result as a list so we can modify it.
         seq: list[float] = list(st)
         seq[stat.ST_MODE] = stat.S_IFREG | 0o444
@@ -153,7 +150,6 @@ def _fake_init(self, path: str) -> os.stat_result:
         seq[stat.ST_NLINK] = 1
         seq[stat.ST_SIZE] = 0
         st = os.stat_result(seq)
-        self.stat_cache[path] = st
         # Make listdir() and read() also pretend this file exists.
         self.fake_package_cache.add(dirname)
         return st
@@ -181,9 +177,8 @@ def listdir(self, path: str) -> list[str]:
         return results
 
     def isfile(self, path: str) -> bool:
-        try:
-            st = self.stat(path)
-        except OSError:
+        st = self.stat_or_none(path)
+        if st is None:
             return False
         return stat.S_ISREG(st.st_mode)
 
@@ -248,18 +243,14 @@ def exists_case(self, path: str, prefix: str) -> bool:
         return res
 
     def isdir(self, path: str) -> bool:
-        try:
-            st = self.stat(path)
-        except OSError:
+        st = self.stat_or_none(path)
+        if st is None:
             return False
         return stat.S_ISDIR(st.st_mode)
 
     def exists(self, path: str) -> bool:
-        try:
-            self.stat(path)
-        except FileNotFoundError:
-            return False
-        return True
+        st = self.stat_or_none(path)
+        return st is not None
 
     def read(self, path: str) -> bytes:
         if path in self.read_cache:
@@ -269,7 +260,7 @@ def read(self, path: str) -> bytes:
 
         # Need to stat first so that the contents of file are from no
         # earlier instant than the mtime reported by self.stat().
-        self.stat(path)
+        self.stat_or_none(path)
 
         dirname, basename = os.path.split(path)
         dirname = os.path.normpath(dirname)
@@ -294,8 +285,10 @@ def hash_digest(self, path: str) -> str:
         return self.hash_cache[path]
 
     def samefile(self, f1: str, f2: str) -> bool:
-        s1 = self.stat(f1)
-        s2 = self.stat(f2)
+        s1 = self.stat_or_none(f1)
+        s2 = self.stat_or_none(f2)
+        if s1 is None or s2 is None:
+            return False
         return os.path.samestat(s1, s2)
 
 
diff --git a/mypy/fswatcher.py b/mypy/fswatcher.py
index a574a36a0cc5..d5873f3a0a99 100644
--- a/mypy/fswatcher.py
+++ b/mypy/fswatcher.py
@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from typing import AbstractSet, Iterable, NamedTuple
+import os
+from collections.abc import Iterable, Set as AbstractSet
+from typing import NamedTuple
 
 from mypy.fscache import FileSystemCache
 
@@ -56,8 +58,7 @@ def remove_watched_paths(self, paths: Iterable[str]) -> None:
                 del self._file_data[path]
         self._paths -= set(paths)
 
-    def _update(self, path: str) -> None:
-        st = self.fs.stat(path)
+    def _update(self, path: str, st: os.stat_result) -> None:
         hash_digest = self.fs.hash_digest(path)
         self._file_data[path] = FileData(st.st_mtime, st.st_size, hash_digest)
 
@@ -65,9 +66,8 @@ def _find_changed(self, paths: Iterable[str]) -> AbstractSet[str]:
         changed = set()
         for path in paths:
             old = self._file_data[path]
-            try:
-                st = self.fs.stat(path)
-            except FileNotFoundError:
+            st = self.fs.stat_or_none(path)
+            if st is None:
                 if old is not None:
                     # File was deleted.
                     changed.add(path)
@@ -76,13 +76,13 @@ def _find_changed(self, paths: Iterable[str]) -> AbstractSet[str]:
                 if old is None:
                     # File is new.
                     changed.add(path)
-                    self._update(path)
+                    self._update(path, st)
                 # Round mtimes down, to match the mtimes we write to meta files
                 elif st.st_size != old.st_size or int(st.st_mtime) != int(old.st_mtime):
                     # Only look for changes if size or mtime has changed as an
                     # optimization, since calculating hash is expensive.
                     new_hash = self.fs.hash_digest(path)
-                    self._update(path)
+                    self._update(path, st)
                     if st.st_size != old.st_size or new_hash != old.hash:
                         # Changed file.
                         changed.add(path)
diff --git a/mypy/gclogger.py b/mypy/gclogger.py
index 75f754ddf4d5..bc908bdb6107 100644
--- a/mypy/gclogger.py
+++ b/mypy/gclogger.py
@@ -2,7 +2,7 @@
 
 import gc
 import time
-from typing import Mapping
+from collections.abc import Mapping
 
 
 class GcLogger:
@@ -38,10 +38,11 @@ def __exit__(self, *args: object) -> None:
 
     def get_stats(self) -> Mapping[str, float]:
         end_time = time.time()
-        result = {}
-        result["gc_time"] = self.gc_time
-        result["gc_calls"] = self.gc_calls
-        result["gc_collected"] = self.gc_collected
-        result["gc_uncollectable"] = self.gc_uncollectable
-        result["build_time"] = end_time - self.start_time
+        result = {
+            "gc_time": self.gc_time,
+            "gc_calls": self.gc_calls,
+            "gc_collected": self.gc_collected,
+            "gc_uncollectable": self.gc_uncollectable,
+            "build_time": end_time - self.start_time,
+        }
         return result
diff --git a/mypy/graph_utils.py b/mypy/graph_utils.py
new file mode 100644
index 000000000000..154efcef48a9
--- /dev/null
+++ b/mypy/graph_utils.py
@@ -0,0 +1,117 @@
+"""Helpers for manipulations with graphs."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator, Set as AbstractSet
+from typing import 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 = {}
+    for scc in sccs:
+        scc_frozen = frozenset(scc)
+        for v in scc:
+            sccsmap[v] = scc_frozen
+    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/indirection.py b/mypy/indirection.py
index 00356d7a4ddb..4f455d2c1dc9 100644
--- a/mypy/indirection.py
+++ b/mypy/indirection.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable, Set
+from collections.abc import Iterable
 
 import mypy.types as types
 from mypy.types import TypeVisitor
@@ -17,105 +17,118 @@ def extract_module_names(type_name: str | None) -> list[str]:
         return []
 
 
-class TypeIndirectionVisitor(TypeVisitor[Set[str]]):
+class TypeIndirectionVisitor(TypeVisitor[None]):
     """Returns all module references within a particular type."""
 
     def __init__(self) -> None:
-        self.cache: dict[types.Type, set[str]] = {}
+        # Module references are collected here
+        self.modules: set[str] = set()
+        # User to avoid infinite recursion with recursive type aliases
         self.seen_aliases: set[types.TypeAliasType] = set()
+        # Used to avoid redundant work
+        self.seen_fullnames: set[str] = set()
 
     def find_modules(self, typs: Iterable[types.Type]) -> set[str]:
-        self.seen_aliases.clear()
-        return self._visit(typs)
+        self.modules = set()
+        self.seen_fullnames = set()
+        self.seen_aliases = set()
+        self._visit(typs)
+        return self.modules
 
-    def _visit(self, typ_or_typs: types.Type | Iterable[types.Type]) -> set[str]:
+    def _visit(self, typ_or_typs: types.Type | Iterable[types.Type]) -> None:
         typs = [typ_or_typs] if isinstance(typ_or_typs, types.Type) else typ_or_typs
-        output: set[str] = set()
         for typ in typs:
             if isinstance(typ, types.TypeAliasType):
                 # Avoid infinite recursion for recursive type aliases.
                 if typ in self.seen_aliases:
                     continue
                 self.seen_aliases.add(typ)
-            if typ in self.cache:
-                modules = self.cache[typ]
-            else:
-                modules = typ.accept(self)
-                self.cache[typ] = set(modules)
-            output.update(modules)
-        return output
+            typ.accept(self)
 
-    def visit_unbound_type(self, t: types.UnboundType) -> set[str]:
-        return self._visit(t.args)
+    def _visit_module_name(self, module_name: str) -> None:
+        if module_name not in self.modules:
+            self.modules.update(split_module_names(module_name))
 
-    def visit_any(self, t: types.AnyType) -> set[str]:
-        return set()
+    def visit_unbound_type(self, t: types.UnboundType) -> None:
+        self._visit(t.args)
 
-    def visit_none_type(self, t: types.NoneType) -> set[str]:
-        return set()
+    def visit_any(self, t: types.AnyType) -> None:
+        pass
 
-    def visit_uninhabited_type(self, t: types.UninhabitedType) -> set[str]:
-        return set()
+    def visit_none_type(self, t: types.NoneType) -> None:
+        pass
 
-    def visit_erased_type(self, t: types.ErasedType) -> set[str]:
-        return set()
+    def visit_uninhabited_type(self, t: types.UninhabitedType) -> None:
+        pass
 
-    def visit_deleted_type(self, t: types.DeletedType) -> set[str]:
-        return set()
+    def visit_erased_type(self, t: types.ErasedType) -> None:
+        pass
 
-    def visit_type_var(self, t: types.TypeVarType) -> set[str]:
-        return self._visit(t.values) | self._visit(t.upper_bound) | self._visit(t.default)
+    def visit_deleted_type(self, t: types.DeletedType) -> None:
+        pass
 
-    def visit_param_spec(self, t: types.ParamSpecType) -> set[str]:
-        return self._visit(t.upper_bound) | self._visit(t.default)
+    def visit_type_var(self, t: types.TypeVarType) -> None:
+        self._visit(t.values)
+        self._visit(t.upper_bound)
+        self._visit(t.default)
 
-    def visit_type_var_tuple(self, t: types.TypeVarTupleType) -> set[str]:
-        return self._visit(t.upper_bound) | self._visit(t.default)
+    def visit_param_spec(self, t: types.ParamSpecType) -> None:
+        self._visit(t.upper_bound)
+        self._visit(t.default)
 
-    def visit_unpack_type(self, t: types.UnpackType) -> set[str]:
-        return t.type.accept(self)
+    def visit_type_var_tuple(self, t: types.TypeVarTupleType) -> None:
+        self._visit(t.upper_bound)
+        self._visit(t.default)
 
-    def visit_parameters(self, t: types.Parameters) -> set[str]:
-        return self._visit(t.arg_types)
+    def visit_unpack_type(self, t: types.UnpackType) -> None:
+        t.type.accept(self)
 
-    def visit_instance(self, t: types.Instance) -> set[str]:
-        out = self._visit(t.args)
+    def visit_parameters(self, t: types.Parameters) -> None:
+        self._visit(t.arg_types)
+
+    def visit_instance(self, t: types.Instance) -> None:
+        self._visit(t.args)
         if t.type:
             # Uses of a class depend on everything in the MRO,
             # as changes to classes in the MRO can add types to methods,
             # change property types, change the MRO itself, etc.
             for s in t.type.mro:
-                out.update(split_module_names(s.module_name))
+                self._visit_module_name(s.module_name)
             if t.type.metaclass_type is not None:
-                out.update(split_module_names(t.type.metaclass_type.type.module_name))
-        return out
+                self._visit_module_name(t.type.metaclass_type.type.module_name)
 
-    def visit_callable_type(self, t: types.CallableType) -> set[str]:
-        out = self._visit(t.arg_types) | self._visit(t.ret_type)
+    def visit_callable_type(self, t: types.CallableType) -> None:
+        self._visit(t.arg_types)
+        self._visit(t.ret_type)
         if t.definition is not None:
-            out.update(extract_module_names(t.definition.fullname))
-        return out
+            fullname = t.definition.fullname
+            if fullname not in self.seen_fullnames:
+                self.modules.update(extract_module_names(t.definition.fullname))
+                self.seen_fullnames.add(fullname)
 
-    def visit_overloaded(self, t: types.Overloaded) -> set[str]:
-        return self._visit(t.items) | self._visit(t.fallback)
+    def visit_overloaded(self, t: types.Overloaded) -> None:
+        self._visit(t.items)
+        self._visit(t.fallback)
 
-    def visit_tuple_type(self, t: types.TupleType) -> set[str]:
-        return self._visit(t.items) | self._visit(t.partial_fallback)
+    def visit_tuple_type(self, t: types.TupleType) -> None:
+        self._visit(t.items)
+        self._visit(t.partial_fallback)
 
-    def visit_typeddict_type(self, t: types.TypedDictType) -> set[str]:
-        return self._visit(t.items.values()) | self._visit(t.fallback)
+    def visit_typeddict_type(self, t: types.TypedDictType) -> None:
+        self._visit(t.items.values())
+        self._visit(t.fallback)
 
-    def visit_literal_type(self, t: types.LiteralType) -> set[str]:
-        return self._visit(t.fallback)
+    def visit_literal_type(self, t: types.LiteralType) -> None:
+        self._visit(t.fallback)
 
-    def visit_union_type(self, t: types.UnionType) -> set[str]:
-        return self._visit(t.items)
+    def visit_union_type(self, t: types.UnionType) -> None:
+        self._visit(t.items)
 
-    def visit_partial_type(self, t: types.PartialType) -> set[str]:
-        return set()
+    def visit_partial_type(self, t: types.PartialType) -> None:
+        pass
 
-    def visit_type_type(self, t: types.TypeType) -> set[str]:
-        return self._visit(t.item)
+    def visit_type_type(self, t: types.TypeType) -> None:
+        self._visit(t.item)
 
-    def visit_type_alias_type(self, t: types.TypeAliasType) -> set[str]:
-        return self._visit(types.get_proper_type(t))
+    def visit_type_alias_type(self, t: types.TypeAliasType) -> None:
+        self._visit(types.get_proper_type(t))
diff --git a/mypy/infer.py b/mypy/infer.py
index fbec3d7c4278..cdc43797d3b1 100644
--- a/mypy/infer.py
+++ b/mypy/infer.py
@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import NamedTuple, Sequence
+from collections.abc import Sequence
+from typing import NamedTuple
 
 from mypy.constraints import (
     SUBTYPE_OF,
@@ -12,7 +13,7 @@
 )
 from mypy.nodes import ArgKind
 from mypy.solve import solve_constraints
-from mypy.types import CallableType, Instance, Type, TypeVarId
+from mypy.types import CallableType, Instance, Type, TypeVarLikeType
 
 
 class ArgumentInferContext(NamedTuple):
@@ -33,10 +34,12 @@ def infer_function_type_arguments(
     callee_type: CallableType,
     arg_types: Sequence[Type | None],
     arg_kinds: list[ArgKind],
+    arg_names: Sequence[str | None] | None,
     formal_to_actual: list[list[int]],
     context: ArgumentInferContext,
     strict: bool = True,
-) -> list[Type | None]:
+    allow_polymorphic: bool = False,
+) -> tuple[list[Type | None], list[TypeVarLikeType]]:
     """Infer the type arguments of a generic function.
 
     Return an array of lower bound types for the type variables -1 (at
@@ -52,18 +55,22 @@ def infer_function_type_arguments(
     """
     # Infer constraints.
     constraints = infer_constraints_for_callable(
-        callee_type, arg_types, arg_kinds, formal_to_actual, context
+        callee_type, arg_types, arg_kinds, arg_names, formal_to_actual, context
     )
 
     # Solve constraints.
-    type_vars = callee_type.type_var_ids()
-    return solve_constraints(type_vars, constraints, strict)
+    type_vars = callee_type.variables
+    return solve_constraints(type_vars, constraints, strict, allow_polymorphic)
 
 
 def infer_type_arguments(
-    type_var_ids: list[TypeVarId], template: Type, actual: Type, is_supertype: bool = False
+    type_vars: Sequence[TypeVarLikeType],
+    template: Type,
+    actual: Type,
+    is_supertype: bool = False,
+    skip_unsatisfied: bool = False,
 ) -> list[Type | None]:
     # Like infer_function_type_arguments, but only match a single type
     # against a generic type.
     constraints = infer_constraints(template, actual, SUPERTYPE_OF if is_supertype else SUBTYPE_OF)
-    return solve_constraints(type_var_ids, constraints)
+    return solve_constraints(type_vars, constraints, skip_unsatisfied=skip_unsatisfied)[0]
diff --git a/mypy/inspections.py b/mypy/inspections.py
index cb695a80eef2..ac48fac56fa4 100644
--- a/mypy/inspections.py
+++ b/mypy/inspections.py
@@ -6,7 +6,6 @@
 from typing import Callable
 
 from mypy.build import State
-from mypy.find_sources import InvalidSourceList, SourceFinder
 from mypy.messages import format_type
 from mypy.modulefinder import PYTHON_EXTENSIONS
 from mypy.nodes import (
@@ -206,9 +205,6 @@ def __init__(
         force_reload: bool = False,
     ) -> None:
         self.fg_manager = fg_manager
-        self.finder = SourceFinder(
-            self.fg_manager.manager.fscache, self.fg_manager.manager.options
-        )
         self.verbosity = verbosity
         self.limit = limit
         self.include_span = include_span
@@ -219,13 +215,6 @@ def __init__(
         # Module for which inspection was requested.
         self.module: State | None = None
 
-    def parse_location(self, location: str) -> tuple[str, list[int]]:
-        if location.count(":") not in [2, 4]:
-            raise ValueError("Format should be file:line:column[:end_line:end_column]")
-        parts = location.split(":")
-        module, *rest = parts
-        return module, [int(p) for p in rest]
-
     def reload_module(self, state: State) -> None:
         """Reload given module while temporary exporting types."""
         old = self.fg_manager.manager.options.export_types
@@ -346,7 +335,7 @@ def expr_attrs(self, expression: Expression) -> tuple[str, bool]:
             node = expression.node
             names = sorted(node.names)
             if "__builtins__" in names:
-                # This is just to make tests stable. No one will really need ths name.
+                # This is just to make tests stable. No one will really need this name.
                 names.remove("__builtins__")
             mod_dict = {f'"<{node.fullname}>"': [f'"{name}"' for name in names]}
         else:
@@ -480,8 +469,7 @@ def missing_type(self, expression: Expression) -> str:
 
     def missing_node(self, expression: Expression) -> str:
         return (
-            f'Cannot find definition for "{type(expression).__name__}"'
-            f" at {expr_span(expression)}"
+            f'Cannot find definition for "{type(expression).__name__}" at {expr_span(expression)}'
         )
 
     def add_prefixes(self, result: str, expression: Expression) -> str:
@@ -561,16 +549,14 @@ def find_module(self, file: str) -> tuple[State | None, dict[str, object]]:
         if not any(file.endswith(ext) for ext in PYTHON_EXTENSIONS):
             return None, {"error": "Source file is not a Python file"}
 
-        try:
-            module, _ = self.finder.crawl_up(os.path.normpath(file))
-        except InvalidSourceList:
-            return None, {"error": "Invalid source file name: " + file}
-
-        state = self.fg_manager.graph.get(module)
+        # We are using a bit slower but robust way to find a module by path,
+        # to be sure that namespace packages are handled properly.
+        abs_path = os.path.abspath(file)
+        state = next((s for s in self.fg_manager.graph.values() if s.abspath == abs_path), None)
         self.module = state
         return (
             state,
-            {"out": f"Unknown module: {module}", "err": "", "status": 1} if state is None else {},
+            {"out": f"Unknown module: {file}", "err": "", "status": 1} if state is None else {},
         )
 
     def run_inspection(
@@ -578,10 +564,10 @@ def run_inspection(
     ) -> dict[str, object]:
         """Top-level logic to inspect expression(s) at a location.
 
-        This can be re-used by various simple inspections.
+        This can be reused by various simple inspections.
         """
         try:
-            file, pos = self.parse_location(location)
+            file, pos = parse_location(location)
         except ValueError as err:
             return {"error": str(err)}
 
@@ -623,3 +609,18 @@ def get_definition(self, location: str) -> dict[str, object]:
             result["out"] = f"No name or member expressions at {location}"
             result["status"] = 1
         return result
+
+
+def parse_location(location: str) -> tuple[str, list[int]]:
+    if location.count(":") < 2:
+        raise ValueError("Format should be file:line:column[:end_line:end_column]")
+    parts = location.rsplit(":", maxsplit=2)
+    start, *rest = parts
+    # Note: we must allow drive prefix like `C:` on Windows.
+    if start.count(":") < 2:
+        return start, [int(p) for p in rest]
+    parts = start.rsplit(":", maxsplit=2)
+    start, *start_rest = parts
+    if start.count(":") < 2:
+        return start, [int(p) for p in start_rest + rest]
+    raise ValueError("Format should be file:line:column[:end_line:end_column]")
diff --git a/mypy/ipc.py b/mypy/ipc.py
index 21ef61918de5..b2046a47ab15 100644
--- a/mypy/ipc.py
+++ b/mypy/ipc.py
@@ -7,19 +7,18 @@
 from __future__ import annotations
 
 import base64
+import codecs
 import os
 import shutil
 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
-    import ctypes
-
     import _winapi
+    import ctypes
 
     _IPCHandle = int
 
@@ -41,6 +40,10 @@ class IPCBase:
 
     This contains logic shared between the client and server, such as reading
     and writing.
+    We want to be able to send multiple "messages" over a single connection and
+    to be able to separate the messages. We do this by encoding the messages
+    in an alphabet that does not contain spaces, then adding a space for
+    separation. The last framed message is also followed by a space.
     """
 
     connection: _IPCHandle
@@ -48,12 +51,30 @@ class IPCBase:
     def __init__(self, name: str, timeout: float | None) -> None:
         self.name = name
         self.timeout = timeout
+        self.buffer = bytearray()
 
-    def read(self, size: int = 100000) -> bytes:
-        """Read bytes from an IPC connection until its empty."""
-        bdata = bytearray()
+    def frame_from_buffer(self) -> bytearray | None:
+        """Return a full frame from the bytes we have in the buffer."""
+        space_pos = self.buffer.find(b" ")
+        if space_pos == -1:
+            return None
+        # We have a full frame
+        bdata = self.buffer[:space_pos]
+        self.buffer = self.buffer[space_pos + 1 :]
+        return bdata
+
+    def read(self, size: int = 100000) -> str:
+        """Read bytes from an IPC connection until we have a full frame."""
+        bdata: bytearray | None = bytearray()
         if sys.platform == "win32":
             while True:
+                # Check if we already have a message in the buffer before
+                # receiving any more data from the socket.
+                bdata = self.frame_from_buffer()
+                if bdata is not None:
+                    break
+
+                # Receive more data into the buffer.
                 ov, err = _winapi.ReadFile(self.connection, size, overlapped=True)
                 try:
                     if err == _winapi.ERROR_IO_PENDING:
@@ -67,7 +88,10 @@ def read(self, size: int = 100000) -> bytes:
                 _, err = ov.GetOverlappedResult(True)
                 more = ov.getbuffer()
                 if more:
-                    bdata.extend(more)
+                    self.buffer.extend(more)
+                    bdata = self.frame_from_buffer()
+                    if bdata is not None:
+                        break
                 if err == 0:
                     # we are done!
                     break
@@ -78,17 +102,34 @@ def read(self, size: int = 100000) -> bytes:
                     raise IPCException("ReadFile operation aborted.")
         else:
             while True:
+                # Check if we already have a message in the buffer before
+                # receiving any more data from the socket.
+                bdata = self.frame_from_buffer()
+                if bdata is not None:
+                    break
+
+                # Receive more data into the buffer.
                 more = self.connection.recv(size)
                 if not more:
+                    # Connection closed
                     break
-                bdata.extend(more)
-        return bytes(bdata)
+                self.buffer.extend(more)
+
+        if not bdata:
+            # Socket was empty and we didn't get any frame.
+            # This should only happen if the socket was closed.
+            return ""
+        return codecs.decode(bdata, "base64").decode("utf8")
+
+    def write(self, data: str) -> None:
+        """Write to an IPC connection."""
+
+        # Frame the data by urlencoding it and separating by space.
+        encoded_data = codecs.encode(data.encode("utf8"), "base64") + b" "
 
-    def write(self, data: bytes) -> None:
-        """Write bytes to an IPC connection."""
         if sys.platform == "win32":
             try:
-                ov, err = _winapi.WriteFile(self.connection, data, overlapped=True)
+                ov, err = _winapi.WriteFile(self.connection, encoded_data, overlapped=True)
                 try:
                     if err == _winapi.ERROR_IO_PENDING:
                         timeout = int(self.timeout * 1000) if self.timeout else _winapi.INFINITE
@@ -102,12 +143,11 @@ def write(self, data: bytes) -> None:
                     raise
                 bytes_written, err = ov.GetOverlappedResult(True)
                 assert err == 0, err
-                assert bytes_written == len(data)
+                assert bytes_written == len(encoded_data)
             except OSError as e:
                 raise IPCException(f"Failed to write with error: {e.winerror}") from e
         else:
-            self.connection.sendall(data)
-            self.connection.shutdown(socket.SHUT_WR)
+            self.connection.sendall(encoded_data)
 
     def close(self) -> None:
         if sys.platform == "win32":
@@ -263,6 +303,10 @@ def cleanup(self) -> None:
     def connection_name(self) -> str:
         if sys.platform == "win32":
             return self.name
+        elif sys.platform == "gnu0":
+            # GNU/Hurd returns empty string from getsockname()
+            # for AF_UNIX sockets
+            return os.path.join(self.sock_directory, self.name)
         else:
             name = self.sock.getsockname()
             assert isinstance(name, str)
diff --git a/mypy/join.py b/mypy/join.py
index 62d256f4440f..ac01d11d11d6 100644
--- a/mypy/join.py
+++ b/mypy/join.py
@@ -2,11 +2,13 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from typing import overload
 
 import mypy.typeops
+from mypy.expandtype import expand_type
 from mypy.maptype import map_instance_to_supertype
-from mypy.nodes import CONTRAVARIANT, COVARIANT, INVARIANT
+from mypy.nodes import CONTRAVARIANT, COVARIANT, INVARIANT, VARIANCE_NOT_READY
 from mypy.state import state
 from mypy.subtypes import (
     SubtypeContext,
@@ -29,7 +31,6 @@
     Parameters,
     ParamSpecType,
     PartialType,
-    PlaceholderType,
     ProperType,
     TupleType,
     Type,
@@ -37,6 +38,8 @@
     TypedDictType,
     TypeOfAny,
     TypeType,
+    TypeVarId,
+    TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
     TypeVisitor,
@@ -44,8 +47,10 @@
     UninhabitedType,
     UnionType,
     UnpackType,
+    find_unpack_in_list,
     get_proper_type,
     get_proper_types,
+    split_with_prefix_and_suffix,
 )
 
 
@@ -68,7 +73,25 @@ def join_instances(self, t: Instance, s: Instance) -> ProperType:
             args: list[Type] = []
             # N.B: We use zip instead of indexing because the lengths might have
             # mismatches during daemon reprocessing.
-            for ta, sa, type_var in zip(t.args, s.args, t.type.defn.type_vars):
+            if t.type.has_type_var_tuple_type:
+                # We handle joins of variadic instances by simply creating correct mapping
+                # for type arguments and compute the individual joins same as for regular
+                # instances. All the heavy lifting is done in the join of tuple types.
+                assert s.type.type_var_tuple_prefix is not None
+                assert s.type.type_var_tuple_suffix is not None
+                prefix = s.type.type_var_tuple_prefix
+                suffix = s.type.type_var_tuple_suffix
+                tvt = s.type.defn.type_vars[prefix]
+                assert isinstance(tvt, TypeVarTupleType)
+                fallback = tvt.tuple_fallback
+                s_prefix, s_middle, s_suffix = split_with_prefix_and_suffix(s.args, prefix, suffix)
+                t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(t.args, prefix, suffix)
+                s_args = s_prefix + (TupleType(list(s_middle), fallback),) + s_suffix
+                t_args = t_prefix + (TupleType(list(t_middle), fallback),) + t_suffix
+            else:
+                t_args = t.args
+                s_args = s.args
+            for ta, sa, type_var in zip(t_args, s_args, t.type.defn.type_vars):
                 ta_proper = get_proper_type(ta)
                 sa_proper = get_proper_type(sa)
                 new_type: Type | None = None
@@ -77,7 +100,7 @@ def join_instances(self, t: Instance, s: Instance) -> ProperType:
                 elif isinstance(sa_proper, AnyType):
                     new_type = AnyType(TypeOfAny.from_another_any, sa_proper)
                 elif isinstance(type_var, TypeVarType):
-                    if type_var.variance == COVARIANT:
+                    if type_var.variance in (COVARIANT, VARIANCE_NOT_READY):
                         new_type = join_types(ta, sa, self)
                         if len(type_var.values) != 0 and new_type not in type_var.values:
                             self.seen_instances.pop()
@@ -88,12 +111,29 @@ def join_instances(self, t: Instance, s: Instance) -> ProperType:
                     # TODO: contravariant case should use meet but pass seen instances as
                     # an argument to keep track of recursive checks.
                     elif type_var.variance in (INVARIANT, CONTRAVARIANT):
-                        if not is_equivalent(ta, sa):
+                        if isinstance(ta_proper, UninhabitedType) and ta_proper.ambiguous:
+                            new_type = sa
+                        elif isinstance(sa_proper, UninhabitedType) and sa_proper.ambiguous:
+                            new_type = ta
+                        elif not is_equivalent(ta, sa):
                             self.seen_instances.pop()
                             return object_from_instance(t)
-                        # If the types are different but equivalent, then an Any is involved
-                        # so using a join in the contravariant case is also OK.
-                        new_type = join_types(ta, sa, self)
+                        else:
+                            # If the types are different but equivalent, then an Any is involved
+                            # so using a join in the contravariant case is also OK.
+                            new_type = join_types(ta, sa, self)
+                elif isinstance(type_var, TypeVarTupleType):
+                    new_type = get_proper_type(join_types(ta, sa, self))
+                    # Put the joined arguments back into instance in the normal form:
+                    #   a) Tuple[X, Y, Z] -> [X, Y, Z]
+                    #   b) tuple[X, ...] -> [*tuple[X, ...]]
+                    if isinstance(new_type, Instance):
+                        assert new_type.type.fullname == "builtins.tuple"
+                        new_type = UnpackType(new_type)
+                    else:
+                        assert isinstance(new_type, TupleType)
+                        args.extend(new_type.items)
+                        continue
                 else:
                     # ParamSpec type variables behave the same, independent of variance
                     if not is_equivalent(ta, sa):
@@ -143,55 +183,6 @@ def join_instances_via_supertype(self, t: Instance, s: Instance) -> ProperType:
         return best
 
 
-def join_simple(declaration: Type | None, s: Type, t: Type) -> ProperType:
-    """Return a simple least upper bound given the declared type.
-
-    This function should be only used by binder, and should not recurse.
-    For all other uses, use `join_types()`.
-    """
-    declaration = get_proper_type(declaration)
-    s = get_proper_type(s)
-    t = get_proper_type(t)
-
-    if (s.can_be_true, s.can_be_false) != (t.can_be_true, t.can_be_false):
-        # if types are restricted in different ways, use the more general versions
-        s = mypy.typeops.true_or_false(s)
-        t = mypy.typeops.true_or_false(t)
-
-    if isinstance(s, AnyType):
-        return s
-
-    if isinstance(s, ErasedType):
-        return t
-
-    if is_proper_subtype(s, t, ignore_promotions=True):
-        return t
-
-    if is_proper_subtype(t, s, ignore_promotions=True):
-        return s
-
-    if isinstance(declaration, UnionType):
-        return mypy.typeops.make_simplified_union([s, t])
-
-    if isinstance(s, NoneType) and not isinstance(t, NoneType):
-        s, t = t, s
-
-    if isinstance(s, UninhabitedType) and not isinstance(t, UninhabitedType):
-        s, t = t, s
-
-    # Meets/joins require callable type normalization.
-    s, t = normalize_callables(s, t)
-
-    if isinstance(s, UnionType) and not isinstance(t, UnionType):
-        s, t = t, s
-
-    value = t.accept(TypeJoinVisitor(s))
-    if declaration is None or is_subtype(value, declaration):
-        return value
-
-    return declaration
-
-
 def trivial_join(s: Type, t: Type) -> Type:
     """Return one of types (expanded) if it is a supertype of other, otherwise top type."""
     if is_subtype(s, t):
@@ -205,13 +196,11 @@ def trivial_join(s: Type, t: Type) -> Type:
 @overload
 def join_types(
     s: ProperType, t: ProperType, instance_joiner: InstanceJoiner | None = None
-) -> ProperType:
-    ...
+) -> ProperType: ...
 
 
 @overload
-def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type:
-    ...
+def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type: ...
 
 
 def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None) -> Type:
@@ -246,14 +235,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)
 
@@ -288,7 +269,7 @@ def visit_none_type(self, t: NoneType) -> ProperType:
         if state.strict_optional:
             if isinstance(self.s, (NoneType, UninhabitedType)):
                 return t
-            elif isinstance(self.s, UnboundType):
+            elif isinstance(self.s, (UnboundType, AnyType)):
                 return AnyType(TypeOfAny.special_form)
             else:
                 return mypy.typeops.make_simplified_union([self.s, t])
@@ -318,14 +299,27 @@ def visit_param_spec(self, t: ParamSpecType) -> ProperType:
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> ProperType:
         if self.s == t:
             return t
+        if isinstance(self.s, Instance) and is_subtype(t.upper_bound, self.s):
+            # TODO: should we do this more generally and for all TypeVarLikeTypes?
+            return self.s
         return self.default(self.s)
 
     def visit_unpack_type(self, t: UnpackType) -> UnpackType:
         raise NotImplementedError
 
     def visit_parameters(self, t: Parameters) -> ProperType:
-        if self.s == t:
-            return t
+        if isinstance(self.s, Parameters):
+            if not is_similar_params(t, self.s):
+                # TODO: it would be prudent to return [*object, **object] instead of Any.
+                return self.default(self.s)
+            from mypy.meet import meet_types
+
+            return t.copy_modified(
+                arg_types=[
+                    meet_types(s_a, t_a) for s_a, t_a in zip(self.s.arg_types, t.arg_types)
+                ],
+                arg_names=combine_arg_names(self.s, t),
+            )
         else:
             return self.default(self.s)
 
@@ -359,6 +353,8 @@ def visit_instance(self, t: Instance) -> ProperType:
             return join_types(t, self.s)
         elif isinstance(self.s, LiteralType):
             return join_types(t, self.s)
+        elif isinstance(self.s, TypeVarTupleType) and is_subtype(self.s.upper_bound, t):
+            return t
         else:
             return self.default(self.s)
 
@@ -443,6 +439,113 @@ def visit_overloaded(self, t: Overloaded) -> ProperType:
                 return join_types(t, call)
         return join_types(t.fallback, s)
 
+    def join_tuples(self, s: TupleType, t: TupleType) -> list[Type] | None:
+        """Join two tuple types while handling variadic entries.
+
+        This is surprisingly tricky, and we don't handle some tricky corner cases.
+        Most of the trickiness comes from the variadic tuple items like *tuple[X, ...]
+        since they can have arbitrary partial overlaps (while *Ts can't be split).
+        """
+        s_unpack_index = find_unpack_in_list(s.items)
+        t_unpack_index = find_unpack_in_list(t.items)
+        if s_unpack_index is None and t_unpack_index is None:
+            if s.length() == t.length():
+                items: list[Type] = []
+                for i in range(t.length()):
+                    items.append(join_types(t.items[i], s.items[i]))
+                return items
+            return None
+        if s_unpack_index is not None and t_unpack_index is not None:
+            # The most complex case: both tuples have an unpack item.
+            s_unpack = s.items[s_unpack_index]
+            assert isinstance(s_unpack, UnpackType)
+            s_unpacked = get_proper_type(s_unpack.type)
+            t_unpack = t.items[t_unpack_index]
+            assert isinstance(t_unpack, UnpackType)
+            t_unpacked = get_proper_type(t_unpack.type)
+            if s.length() == t.length() and s_unpack_index == t_unpack_index:
+                # We can handle a case where arity is perfectly aligned, e.g.
+                # join(Tuple[X1, *tuple[Y1, ...], Z1], Tuple[X2, *tuple[Y2, ...], Z2]).
+                # We can essentially perform the join elementwise.
+                prefix_len = t_unpack_index
+                suffix_len = t.length() - t_unpack_index - 1
+                items = []
+                for si, ti in zip(s.items[:prefix_len], t.items[:prefix_len]):
+                    items.append(join_types(si, ti))
+                joined = join_types(s_unpacked, t_unpacked)
+                if isinstance(joined, TypeVarTupleType):
+                    items.append(UnpackType(joined))
+                elif isinstance(joined, Instance) and joined.type.fullname == "builtins.tuple":
+                    items.append(UnpackType(joined))
+                else:
+                    if isinstance(t_unpacked, Instance):
+                        assert t_unpacked.type.fullname == "builtins.tuple"
+                        tuple_instance = t_unpacked
+                    else:
+                        assert isinstance(t_unpacked, TypeVarTupleType)
+                        tuple_instance = t_unpacked.tuple_fallback
+                    items.append(
+                        UnpackType(
+                            tuple_instance.copy_modified(
+                                args=[object_from_instance(tuple_instance)]
+                            )
+                        )
+                    )
+                if suffix_len:
+                    for si, ti in zip(s.items[-suffix_len:], t.items[-suffix_len:]):
+                        items.append(join_types(si, ti))
+                return items
+            if s.length() == 1 or t.length() == 1:
+                # Another case we can handle is when one of tuple is purely variadic
+                # (i.e. a non-normalized form of tuple[X, ...]), in this case the join
+                # will be again purely variadic.
+                if not (isinstance(s_unpacked, Instance) and isinstance(t_unpacked, Instance)):
+                    return None
+                assert s_unpacked.type.fullname == "builtins.tuple"
+                assert t_unpacked.type.fullname == "builtins.tuple"
+                mid_joined = join_types(s_unpacked.args[0], t_unpacked.args[0])
+                t_other = [a for i, a in enumerate(t.items) if i != t_unpack_index]
+                s_other = [a for i, a in enumerate(s.items) if i != s_unpack_index]
+                other_joined = join_type_list(s_other + t_other)
+                mid_joined = join_types(mid_joined, other_joined)
+                return [UnpackType(s_unpacked.copy_modified(args=[mid_joined]))]
+            # TODO: are there other case we can handle (e.g. both prefix/suffix are shorter)?
+            return None
+        if s_unpack_index is not None:
+            variadic = s
+            unpack_index = s_unpack_index
+            fixed = t
+        else:
+            assert t_unpack_index is not None
+            variadic = t
+            unpack_index = t_unpack_index
+            fixed = s
+        # Case where one tuple has variadic item and the other one doesn't. The join will
+        # be variadic, since fixed tuple is a subtype of variadic, but not vice versa.
+        unpack = variadic.items[unpack_index]
+        assert isinstance(unpack, UnpackType)
+        unpacked = get_proper_type(unpack.type)
+        if not isinstance(unpacked, Instance):
+            return None
+        if fixed.length() < variadic.length() - 1:
+            # There are no non-trivial types that are supertype of both.
+            return None
+        prefix_len = unpack_index
+        suffix_len = variadic.length() - prefix_len - 1
+        prefix, middle, suffix = split_with_prefix_and_suffix(
+            tuple(fixed.items), prefix_len, suffix_len
+        )
+        items = []
+        for fi, vi in zip(prefix, variadic.items[:prefix_len]):
+            items.append(join_types(fi, vi))
+        mid_joined = join_type_list(list(middle))
+        mid_joined = join_types(mid_joined, unpacked.args[0])
+        items.append(UnpackType(unpacked.copy_modified(args=[mid_joined])))
+        if suffix_len:
+            for fi, vi in zip(suffix, variadic.items[-suffix_len:]):
+                items.append(join_types(fi, vi))
+        return items
+
     def visit_tuple_type(self, t: TupleType) -> ProperType:
         # When given two fixed-length tuples:
         # * If they have the same length, join their subtypes item-wise:
@@ -455,19 +558,26 @@ def visit_tuple_type(self, t: TupleType) -> ProperType:
         #   Tuple[int, bool] + Tuple[bool, ...] becomes Tuple[int, ...]
         # * Joining with any Sequence also returns a Sequence:
         #   Tuple[int, bool] + List[bool] becomes Sequence[int]
-        if isinstance(self.s, TupleType) and self.s.length() == t.length():
+        if isinstance(self.s, TupleType):
             if self.instance_joiner is None:
                 self.instance_joiner = InstanceJoiner()
             fallback = self.instance_joiner.join_instances(
                 mypy.typeops.tuple_fallback(self.s), mypy.typeops.tuple_fallback(t)
             )
             assert isinstance(fallback, Instance)
-            if self.s.length() == t.length():
-                items: list[Type] = []
-                for i in range(t.length()):
-                    items.append(join_types(t.items[i], self.s.items[i]))
+            items = self.join_tuples(self.s, t)
+            if items is not None:
+                if len(items) == 1 and isinstance(item := items[0], UnpackType):
+                    if isinstance(unpacked := get_proper_type(item.type), Instance):
+                        # Avoid double-wrapping tuple[*tuple[X, ...]]
+                        return unpacked
                 return TupleType(items, fallback)
             else:
+                # TODO: should this be a default fallback behaviour like for meet?
+                if is_proper_subtype(self.s, t):
+                    return t
+                if is_proper_subtype(t, self.s):
+                    return self.s
                 return fallback
         else:
             return join_types(self.s, mypy.typeops.tuple_fallback(t))
@@ -483,10 +593,13 @@ def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
                 )
             }
             fallback = self.s.create_anonymous_fallback()
+            all_keys = set(items.keys())
             # We need to filter by items.keys() since some required keys present in both t and
             # self.s might be missing from the join if the types are incompatible.
-            required_keys = set(items.keys()) & t.required_keys & self.s.required_keys
-            return TypedDictType(items, required_keys, fallback)
+            required_keys = all_keys & t.required_keys & self.s.required_keys
+            # If one type has a key as readonly, we mark it as readonly for both:
+            readonly_keys = (t.readonly_keys | t.readonly_keys) & all_keys
+            return TypedDictType(items, required_keys, readonly_keys, fallback)
         elif isinstance(self.s, Instance):
             return join_types(self.s, t.fallback)
         else:
@@ -572,12 +685,47 @@ def is_similar_callables(t: CallableType, s: CallableType) -> bool:
     )
 
 
-def join_similar_callables(t: CallableType, s: CallableType) -> CallableType:
-    from mypy.meet import meet_types
+def is_similar_params(t: Parameters, s: Parameters) -> bool:
+    # This matches the logic in is_similar_callables() above.
+    return (
+        len(t.arg_types) == len(s.arg_types)
+        and t.min_args == s.min_args
+        and (t.var_arg() is not None) == (s.var_arg() is not None)
+    )
+
+
+def update_callable_ids(c: CallableType, ids: list[TypeVarId]) -> CallableType:
+    tv_map = {}
+    tvs = []
+    for tv, new_id in zip(c.variables, ids):
+        new_tv = tv.copy_modified(id=new_id)
+        tvs.append(new_tv)
+        tv_map[tv.id] = new_tv
+    return expand_type(c, tv_map).copy_modified(variables=tvs)
+
+
+def match_generic_callables(t: CallableType, s: CallableType) -> tuple[CallableType, CallableType]:
+    # The case where we combine/join/meet similar callables, situation where both are generic
+    # requires special care. A more principled solution may involve unify_generic_callable(),
+    # but it would have two problems:
+    #   * This adds risk of infinite recursion: e.g. join -> unification -> solver -> join
+    #   * Using unification is an incorrect thing for meets, as it "widens" the types
+    # Finally, this effectively falls back to an old behaviour before namespaces were added to
+    # type variables, and it worked relatively well.
+    max_len = max(len(t.variables), len(s.variables))
+    min_len = min(len(t.variables), len(s.variables))
+    if min_len == 0:
+        return t, s
+    new_ids = [TypeVarId.new(meta_level=0) for _ in range(max_len)]
+    # Note: this relies on variables being in order they appear in function definition.
+    return update_callable_ids(t, new_ids), update_callable_ids(s, new_ids)
+
 
+def join_similar_callables(t: CallableType, s: CallableType) -> CallableType:
+    t, s = match_generic_callables(t, s)
     arg_types: list[Type] = []
     for i in range(len(t.arg_types)):
-        arg_types.append(meet_types(t.arg_types[i], s.arg_types[i]))
+        arg_types.append(safe_meet(t.arg_types[i], s.arg_types[i]))
     # TODO in combine_similar_callables also applies here (names and kinds; user metaclasses)
     # The fallback type can be either 'function', 'type', or some user-provided metaclass.
     # The result should always use 'function' as a fallback if either operands are using it.
@@ -594,10 +742,43 @@ def join_similar_callables(t: CallableType, s: CallableType) -> CallableType:
     )
 
 
+def safe_join(t: Type, s: Type) -> Type:
+    # This is a temporary solution to prevent crashes in combine_similar_callables() etc.,
+    # until relevant TODOs on handling arg_kinds will be addressed there.
+    if not isinstance(t, UnpackType) and not isinstance(s, UnpackType):
+        return join_types(t, s)
+    if isinstance(t, UnpackType) and isinstance(s, UnpackType):
+        return UnpackType(join_types(t.type, s.type))
+    return object_or_any_from_type(get_proper_type(t))
+
+
+def safe_meet(t: Type, s: Type) -> Type:
+    # Similar to above but for meet_types().
+    from mypy.meet import meet_types
+
+    if not isinstance(t, UnpackType) and not isinstance(s, UnpackType):
+        return meet_types(t, s)
+    if isinstance(t, UnpackType) and isinstance(s, UnpackType):
+        unpacked = get_proper_type(t.type)
+        if isinstance(unpacked, TypeVarTupleType):
+            fallback_type = unpacked.tuple_fallback.type
+        elif isinstance(unpacked, TupleType):
+            fallback_type = unpacked.partial_fallback.type
+        else:
+            assert isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple"
+            fallback_type = unpacked.type
+        res = meet_types(t.type, s.type)
+        if isinstance(res, UninhabitedType):
+            res = Instance(fallback_type, [res])
+        return UnpackType(res)
+    return UninhabitedType()
+
+
 def combine_similar_callables(t: CallableType, s: CallableType) -> CallableType:
+    t, s = match_generic_callables(t, s)
     arg_types: list[Type] = []
     for i in range(len(t.arg_types)):
-        arg_types.append(join_types(t.arg_types[i], s.arg_types[i]))
+        arg_types.append(safe_join(t.arg_types[i], s.arg_types[i]))
     # TODO kinds and argument names
     # TODO what should happen if one fallback is 'type' and the other is a user-provided metaclass?
     # The fallback type can be either 'function', 'type', or some user-provided metaclass.
@@ -615,7 +796,9 @@ def combine_similar_callables(t: CallableType, s: CallableType) -> CallableType:
     )
 
 
-def combine_arg_names(t: CallableType, s: CallableType) -> list[str | None]:
+def combine_arg_names(
+    t: CallableType | Parameters, s: CallableType | Parameters
+) -> list[str | None]:
     """Produces a list of argument names compatible with both callables.
 
     For example, suppose 't' and 's' have the following signatures:
@@ -662,7 +845,7 @@ def object_or_any_from_type(typ: ProperType) -> ProperType:
         return object_from_instance(typ.partial_fallback)
     elif isinstance(typ, TypeType):
         return object_or_any_from_type(typ.item)
-    elif isinstance(typ, TypeVarType) and isinstance(typ.upper_bound, ProperType):
+    elif isinstance(typ, TypeVarLikeType) and isinstance(typ.upper_bound, ProperType):
         return object_or_any_from_type(typ.upper_bound)
     elif isinstance(typ, UnionType):
         for item in typ.items:
@@ -670,10 +853,12 @@ def object_or_any_from_type(typ: ProperType) -> ProperType:
                 candidate = object_or_any_from_type(item)
                 if isinstance(candidate, Instance):
                     return candidate
+    elif isinstance(typ, UnpackType):
+        object_or_any_from_type(get_proper_type(typ.type))
     return AnyType(TypeOfAny.implementation_artifact)
 
 
-def join_type_list(types: list[Type]) -> Type:
+def join_type_list(types: Sequence[Type]) -> Type:
     if not types:
         # This is a little arbitrary but reasonable. Any empty tuple should be compatible
         # with all variable length tuples, and this makes it possible.
diff --git a/mypy/literals.py b/mypy/literals.py
index 53ba559c56bb..5b0c46f4bee8 100644
--- a/mypy/literals.py
+++ b/mypy/literals.py
@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from collections.abc import Iterable
+from typing import Any, Final, Optional
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.nodes import (
     LITERAL_NO,
@@ -95,7 +96,27 @@
 #   of an index expression, or the operands of an operator expression).
 
 
+Key: _TypeAlias = tuple[Any, ...]
+
+
+def literal_hash(e: Expression) -> Key | None:
+    """Generate a hashable, (mostly) opaque key for expressions supported by the binder.
+
+    These allow using expressions as dictionary keys based on structural/value
+    matching (instead of based on expression identity).
+
+    Return None if the expression type is not supported (it cannot be narrowed).
+
+    See the comment above for more information.
+
+    NOTE: This is not directly related to literal types.
+    """
+    return e.accept(_hasher)
+
+
 def literal(e: Expression) -> int:
+    """Return the literal kind for an expression."""
+
     if isinstance(e, ComparisonExpr):
         return min(literal(o) for o in e.operands)
 
@@ -128,17 +149,10 @@ def literal(e: Expression) -> int:
     return LITERAL_NO
 
 
-Key: _TypeAlias = Tuple[Any, ...]
-
-
 def subkeys(key: Key) -> Iterable[Key]:
     return [elt for elt in key if isinstance(elt, tuple)]
 
 
-def literal_hash(e: Expression) -> Key | None:
-    return e.accept(_hasher)
-
-
 def extract_var_from_literal_hash(key: Key) -> Var | None:
     """If key refers to a Var node, return it.
 
diff --git a/mypy/lookup.py b/mypy/lookup.py
index 8fc8cf8be3c2..640481ff703c 100644
--- a/mypy/lookup.py
+++ b/mypy/lookup.py
@@ -22,9 +22,11 @@ def lookup_fully_qualified(
     This function should *not* be used to find a module. Those should be looked
     in the modules dictionary.
     """
-    head = name
+    # 1. Exclude the names of ad hoc instance intersections from step 2.
+    i = name.find("<subclass ")
+    head = name if i == -1 else name[:i]
     rest = []
-    # 1. Find a module tree in modules dictionary.
+    # 2. Find a module tree in modules dictionary.
     while True:
         if "." not in head:
             if raise_on_missing:
@@ -36,12 +38,14 @@ def lookup_fully_qualified(
         if mod is not None:
             break
     names = mod.names
-    # 2. Find the symbol in the module tree.
+    # 3. Find the symbol in the module tree.
     if not rest:
         # Looks like a module, don't use this to avoid confusions.
         if raise_on_missing:
             assert rest, f"Cannot find {name}, got a module symbol"
         return None
+    if i != -1:
+        rest[0] += name[i:]
     while True:
         key = rest.pop()
         if key not in names:
diff --git a/mypy/main.py b/mypy/main.py
index 81a0a045745b..6ebf32ded6e1 100644
--- a/mypy/main.py
+++ b/mypy/main.py
@@ -7,29 +7,48 @@
 import subprocess
 import sys
 import time
+from collections import defaultdict
+from collections.abc import Sequence
 from gettext import gettext
-from typing import IO, Any, NoReturn, Sequence, TextIO
-from typing_extensions import Final
+from io import TextIOWrapper
+from typing import IO, TYPE_CHECKING, Any, Final, NoReturn, TextIO
 
 from mypy import build, defaults, state, util
-from mypy.config_parser import get_config_module_names, parse_config_file, parse_version
-from mypy.errorcodes import error_codes
+from mypy.config_parser import (
+    get_config_module_names,
+    parse_config_file,
+    parse_version,
+    validate_package_allow_list,
+)
+from mypy.error_formatter import OUTPUT_CHOICES
 from mypy.errors import CompileError
 from mypy.find_sources import InvalidSourceList, create_source_list
 from mypy.fscache import FileSystemCache
-from mypy.modulefinder import BuildSource, FindModuleCache, SearchPaths, get_search_dirs, mypy_path
+from mypy.modulefinder import (
+    BuildSource,
+    FindModuleCache,
+    ModuleNotFoundReason,
+    SearchPaths,
+    get_search_dirs,
+    mypy_path,
+)
 from mypy.options import INCOMPLETE_FEATURES, BuildType, Options
 from mypy.split_namespace import SplitNamespace
 from mypy.version import __version__
 
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+
+
 orig_stat: Final = os.stat
 MEM_PROFILE: Final = False  # If True, dump memory profile
+RECURSION_LIMIT: Final = 2**14
 
 
 def stat_proxy(path: str) -> os.stat_result:
     try:
         st = orig_stat(path)
-    except os.error as err:
+    except OSError as err:
         print(f"stat({path!r}) -> {err}")
         raise
     else:
@@ -58,16 +77,29 @@ def main(
     util.check_python_version("mypy")
     t0 = time.time()
     # To log stat() calls: os.stat = stat_proxy
-    sys.setrecursionlimit(2**14)
+    sys.setrecursionlimit(RECURSION_LIMIT)
     if args is None:
         args = sys.argv[1:]
 
+    # Write an escape sequence instead of raising an exception on encoding errors.
+    if isinstance(stdout, TextIOWrapper) and stdout.errors == "strict":
+        stdout.reconfigure(errors="backslashreplace")
+
     fscache = FileSystemCache()
     sources, options = process_options(args, stdout=stdout, stderr=stderr, fscache=fscache)
     if clean_exit:
         options.fast_exit = False
 
-    formatter = util.FancyFormatter(stdout, stderr, options.hide_error_codes)
+    formatter = util.FancyFormatter(
+        stdout, stderr, options.hide_error_codes, hide_success=bool(options.output)
+    )
+
+    if options.allow_redefinition_new and not options.local_partial_types:
+        fail(
+            "error: --local-partial-types must be enabled if using --allow-redefinition-new",
+            stderr,
+            options,
+        )
 
     if options.install_types and (stdout is not sys.stdout or stderr is not sys.stderr):
         # Since --install-types performs user input, we want regular stdout and stderr.
@@ -140,7 +172,7 @@ def main(
         sys.exit(code)
 
     # HACK: keep res alive so that mypyc won't free it before the hard_exit
-    list([res])
+    list([res])  # noqa: C410
 
 
 def run_build(
@@ -151,14 +183,19 @@ def run_build(
     stdout: TextIO,
     stderr: TextIO,
 ) -> tuple[build.BuildResult | None, list[str], bool]:
-    formatter = util.FancyFormatter(stdout, stderr, options.hide_error_codes)
+    formatter = util.FancyFormatter(
+        stdout, stderr, options.hide_error_codes, hide_success=bool(options.output)
+    )
 
     messages = []
+    messages_by_file = defaultdict(list)
 
-    def flush_errors(new_messages: list[str], serious: bool) -> None:
+    def flush_errors(filename: str | None, new_messages: list[str], serious: bool) -> None:
         if options.pretty:
             new_messages = formatter.fit_in_terminal(new_messages)
         messages.extend(new_messages)
+        if new_messages:
+            messages_by_file[filename].extend(new_messages)
         if options.non_interactive:
             # Collect messages and possibly show them later.
             return
@@ -183,8 +220,7 @@ def flush_errors(new_messages: list[str], serious: bool) -> None:
         and not options.non_interactive
     ):
         print(
-            "Warning: unused section(s) in %s: %s"
-            % (
+            "Warning: unused section(s) in {}: {}".format(
                 options.config_file,
                 get_config_module_names(
                     options.config_file,
@@ -197,7 +233,7 @@ def flush_errors(new_messages: list[str], serious: bool) -> None:
             ),
             file=stderr,
         )
-    maybe_write_junit_xml(time.time() - t0, serious, messages, options)
+    maybe_write_junit_xml(time.time() - t0, serious, messages, messages_by_file, options)
     return res, messages, blockers
 
 
@@ -213,8 +249,8 @@ def show_messages(
 
 # Make the help output a little less jarring.
 class AugmentedHelpFormatter(argparse.RawDescriptionHelpFormatter):
-    def __init__(self, prog: str) -> None:
-        super().__init__(prog=prog, max_help_position=28)
+    def __init__(self, prog: str, **kwargs: Any) -> None:
+        super().__init__(prog=prog, max_help_position=28, **kwargs)
 
     def _fill_text(self, text: str, width: int, indent: str) -> str:
         if "\n" in text:
@@ -335,14 +371,13 @@ def infer_python_executable(options: Options, special_opts: argparse.Namespace)
 
 
 class CapturableArgumentParser(argparse.ArgumentParser):
-
     """Override ArgumentParser methods that use sys.stdout/sys.stderr directly.
 
     This is needed because hijacking sys.std* is not thread-safe,
     yet output must be captured to properly support mypy.api.run.
     """
 
-    def __init__(self, *args: Any, **kwargs: Any):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         self.stdout = kwargs.pop("stdout", sys.stdout)
         self.stderr = kwargs.pop("stderr", sys.stderr)
         super().__init__(*args, **kwargs)
@@ -350,17 +385,17 @@ def __init__(self, *args: Any, **kwargs: Any):
     # =====================
     # Help-printing methods
     # =====================
-    def print_usage(self, file: IO[str] | None = None) -> None:
+    def print_usage(self, file: SupportsWrite[str] | None = None) -> None:
         if file is None:
             file = self.stdout
         self._print_message(self.format_usage(), file)
 
-    def print_help(self, file: IO[str] | None = None) -> None:
+    def print_help(self, file: SupportsWrite[str] | None = None) -> None:
         if file is None:
             file = self.stdout
         self._print_message(self.format_help(), file)
 
-    def _print_message(self, message: str, file: IO[str] | None = None) -> None:
+    def _print_message(self, message: str, file: SupportsWrite[str] | None = None) -> None:
         if message:
             if file is None:
                 file = self.stderr
@@ -389,7 +424,6 @@ def error(self, message: str) -> NoReturn:
 
 
 class CapturableVersionAction(argparse.Action):
-
     """Supplement CapturableArgumentParser to handle --version.
 
     This is nearly identical to argparse._VersionAction except,
@@ -408,7 +442,7 @@ def __init__(
         default: str = argparse.SUPPRESS,
         help: str = "show program's version number and exit",
         stdout: IO[str] | None = None,
-    ):
+    ) -> None:
         super().__init__(
             option_strings=option_strings, dest=dest, default=default, nargs=0, help=help
         )
@@ -457,6 +491,8 @@ def process_options(
         stdout=stdout,
         stderr=stderr,
     )
+    if sys.version_info >= (3, 14):
+        parser.color = True  # Set as init arg in 3.14
 
     strict_flag_names: list[str] = []
     strict_flag_assignments: list[tuple[str, bool]] = []
@@ -499,8 +535,27 @@ def add_invertible_flag(
     # their `dest` prefixed with `special-opts:`, which will cause them to be
     # parsed into the separate special_opts namespace object.
 
-    # Note: we have a style guide for formatting the mypy --help text. See
-    # https://github.com/python/mypy/wiki/Documentation-Conventions
+    # Our style guide for formatting the output of running `mypy --help`:
+    # Flags:
+    # 1.  The flag help text should start with a capital letter but never end with a period.
+    # 2.  Keep the flag help text brief -- ideally just a single sentence.
+    # 3.  All flags must be a part of a group, unless the flag is deprecated or suppressed.
+    # 4.  Avoid adding new flags to the "miscellaneous" groups -- instead add them to an
+    #     existing group or, if applicable, create a new group. Feel free to move existing
+    #     flags to a new group: just be sure to also update the documentation to match.
+    #
+    # Groups:
+    # 1.  The group title and description should start with a capital letter.
+    # 2.  The first sentence of a group description should be written in the bare infinitive.
+    #     Tip: try substituting the group title and description into the following sentence:
+    #     > {group_title}: these flags will {group_description}
+    #     Feel free to add subsequent sentences that add additional details.
+    # 3.  If you cannot think of a meaningful description for a new group, omit it entirely.
+    #     (E.g. see the "miscellaneous" sections).
+    # 4.  The group description should end with a period (unless the last line is a link). If you
+    #     do end the group description with a link, omit the 'http://' prefix. (Some links are too
+    #     long and will break up into multiple lines if we include that prefix, so for consistency
+    #     we omit the prefix on all links.)
 
     general_group = parser.add_argument_group(title="Optional arguments")
     general_group.add_argument(
@@ -520,6 +575,14 @@ def add_invertible_flag(
         stdout=stdout,
     )
 
+    general_group.add_argument(
+        "-O",
+        "--output",
+        metavar="FORMAT",
+        help="Set a custom output format",
+        choices=OUTPUT_CHOICES,
+    )
+
     config_group = parser.add_argument_group(
         title="Config file",
         description="Use a config file instead of command line arguments. "
@@ -528,15 +591,16 @@ def add_invertible_flag(
     )
     config_group.add_argument(
         "--config-file",
-        help="Configuration file, must have a [mypy] section "
-        "(defaults to {})".format(", ".join(defaults.CONFIG_FILES)),
+        help=(
+            f"Configuration file, must have a [mypy] section "
+            f"(defaults to {', '.join(defaults.CONFIG_NAMES + defaults.SHARED_CONFIG_NAMES)})"
+        ),
     )
     add_invertible_flag(
         "--warn-unused-configs",
         default=False,
         strict_flag=True,
-        help="Warn about unused '[mypy-<pattern>]' or '[[tool.mypy.overrides]]' "
-        "config sections",
+        help="Warn about unused '[mypy-<pattern>]' or '[[tool.mypy.overrides]]' config sections",
         group=config_group,
     )
 
@@ -547,7 +611,7 @@ def add_invertible_flag(
         "--no-namespace-packages",
         dest="namespace_packages",
         default=True,
-        help="Support namespace packages (PEP 420, __init__.py-less)",
+        help="Disable support for namespace packages (PEP 420, __init__.py-less)",
         group=imports_group,
     )
     imports_group.add_argument(
@@ -555,6 +619,11 @@ def add_invertible_flag(
         action="store_true",
         help="Silently ignore imports of missing modules",
     )
+    imports_group.add_argument(
+        "--follow-untyped-imports",
+        action="store_true",
+        help="Typecheck modules without stubs or py.typed marker",
+    )
     imports_group.add_argument(
         "--follow-imports",
         choices=["normal", "silent", "skip", "error"],
@@ -565,8 +634,7 @@ def add_invertible_flag(
         "--python-executable",
         action="store",
         metavar="EXECUTABLE",
-        help="Python executable used for finding PEP 561 compliant installed"
-        " packages and stubs",
+        help="Python executable used for finding PEP 561 compliant installed packages and stubs",
         dest="special-opts:python_executable",
     )
     imports_group.add_argument(
@@ -595,20 +663,11 @@ def add_invertible_flag(
         help="Type check code assuming it will be running on Python x.y",
         dest="special-opts:python_version",
     )
-    platform_group.add_argument(
-        "-2",
-        "--py2",
-        dest="special-opts:python_version",
-        action="store_const",
-        const=defaults.PYTHON2_VERSION,
-        help="Use Python 2 mode (same as --python-version 2.7)",
-    )
     platform_group.add_argument(
         "--platform",
         action="store",
         metavar="PLATFORM",
-        help="Type check special-cased code for the given OS platform "
-        "(defaults to sys.platform)",
+        help="Type check special-cased code for the given OS platform (defaults to sys.platform)",
     )
     platform_group.add_argument(
         "--always-true",
@@ -629,12 +688,6 @@ def add_invertible_flag(
         title="Disallow dynamic typing",
         description="Disallow the use of the dynamic 'Any' type under certain conditions.",
     )
-    disallow_any_group.add_argument(
-        "--disallow-any-unimported",
-        default=False,
-        action="store_true",
-        help="Disallow Any types resulting from unfollowed imports",
-    )
     disallow_any_group.add_argument(
         "--disallow-any-expr",
         default=False,
@@ -645,8 +698,7 @@ def add_invertible_flag(
         "--disallow-any-decorated",
         default=False,
         action="store_true",
-        help="Disallow functions that have Any in their signature "
-        "after decorator transformation",
+        help="Disallow functions that have Any in their signature after decorator transformation",
     )
     disallow_any_group.add_argument(
         "--disallow-any-explicit",
@@ -661,6 +713,12 @@ def add_invertible_flag(
         help="Disallow usage of generic types that do not specify explicit type parameters",
         group=disallow_any_group,
     )
+    add_invertible_flag(
+        "--disallow-any-unimported",
+        default=False,
+        help="Disallow Any types resulting from unfollowed imports",
+        group=disallow_any_group,
+    )
     add_invertible_flag(
         "--disallow-subclassing-any",
         default=False,
@@ -684,6 +742,14 @@ def add_invertible_flag(
         " from functions with type annotations",
         group=untyped_group,
     )
+    untyped_group.add_argument(
+        "--untyped-calls-exclude",
+        metavar="MODULE",
+        action="append",
+        default=[],
+        help="Disable --disallow-untyped-calls for functions/methods coming"
+        " from specific package, module, or class",
+    )
     add_invertible_flag(
         "--disallow-untyped-defs",
         default=False,
@@ -782,6 +848,21 @@ def add_invertible_flag(
         help="Warn about statements or expressions inferred to be unreachable",
         group=lint_group,
     )
+    add_invertible_flag(
+        "--report-deprecated-as-note",
+        default=False,
+        strict_flag=False,
+        help="Report importing or using deprecated features as notes instead of errors",
+        group=lint_group,
+    )
+    lint_group.add_argument(
+        "--deprecated-calls-exclude",
+        metavar="MODULE",
+        action="append",
+        default=[],
+        help="Disable deprecated warnings for functions/methods coming"
+        " from specific package, module, or class",
+    )
 
     # Note: this group is intentionally added here even though we don't add
     # --strict to this group near the end.
@@ -804,7 +885,15 @@ def add_invertible_flag(
         "--allow-redefinition",
         default=False,
         strict_flag=False,
-        help="Allow unconditional variable redefinition with a new type",
+        help="Allow restricted, unconditional variable redefinition with a new type",
+        group=strictness_group,
+    )
+
+    add_invertible_flag(
+        "--allow-redefinition-new",
+        default=False,
+        strict_flag=False,
+        help=argparse.SUPPRESS,  # This is still very experimental
         group=strictness_group,
     )
 
@@ -826,10 +915,20 @@ def add_invertible_flag(
     )
 
     add_invertible_flag(
-        "--strict-concatenate",
+        "--strict-bytes",
         default=False,
         strict_flag=True,
-        help="Make arguments prepended via Concatenate be truly positional-only",
+        help="Disable treating bytearray and memoryview as subtypes of bytes",
+        group=strictness_group,
+    )
+
+    add_invertible_flag(
+        "--extra-checks",
+        default=False,
+        strict_flag=True,
+        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,
     )
 
@@ -885,6 +984,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,
@@ -984,18 +1089,18 @@ def add_invertible_flag(
         help="Use a custom typing module",
     )
     internals_group.add_argument(
-        "--disable-recursive-aliases",
+        "--old-type-inference",
         action="store_true",
-        help="Disable experimental support for recursive type aliases",
+        help="Disable new experimental type inference algorithm",
     )
     # Deprecated reverse variant of the above.
     internals_group.add_argument(
-        "--enable-recursive-aliases", action="store_true", help=argparse.SUPPRESS
+        "--new-type-inference", action="store_true", help=argparse.SUPPRESS
     )
     parser.add_argument(
         "--enable-incomplete-feature",
         action="append",
-        metavar="FEATURE",
+        metavar="{" + ",".join(sorted(INCOMPLETE_FEATURES)) + "}",
         help="Enable support of incomplete/experimental features for early preview",
     )
     internals_group.add_argument(
@@ -1040,9 +1145,25 @@ def add_invertible_flag(
                 dest=f"special-opts:{report_type}_report",
             )
 
+    # Undocumented mypyc feature: generate annotated HTML source file
+    report_group.add_argument(
+        "-a", dest="mypyc_annotation_file", type=str, default=None, help=argparse.SUPPRESS
+    )
+    # Hidden mypyc feature: do not write any C files (keep existing ones and assume they exist).
+    # This can be useful when debugging mypyc bugs.
+    report_group.add_argument(
+        "--skip-c-gen", dest="mypyc_skip_c_generation", action="store_true", help=argparse.SUPPRESS
+    )
+
     other_group = parser.add_argument_group(title="Miscellaneous")
     other_group.add_argument("--quickstart-file", help=argparse.SUPPRESS)
     other_group.add_argument("--junit-xml", help="Write junit.xml to the given file")
+    imports_group.add_argument(
+        "--junit-format",
+        choices=["global", "per_file"],
+        default="global",
+        help="If --junit-xml is set, specifies format. global: single test with all errors; per_file: one test entry per file with failures",
+    )
     other_group.add_argument(
         "--find-occurrences",
         metavar="CLASS.MEMBER",
@@ -1114,9 +1235,11 @@ def add_invertible_flag(
     parser.add_argument("--dump-graph", action="store_true", help=argparse.SUPPRESS)
     # --semantic-analysis-only does exactly that.
     parser.add_argument("--semantic-analysis-only", action="store_true", help=argparse.SUPPRESS)
+    # Some tests use this to tell mypy that we are running a test.
+    parser.add_argument("--test-env", action="store_true", help=argparse.SUPPRESS)
     # --local-partial-types disallows partial types spanning module top level and a function
     # (implicitly defined in fine-grained incremental mode)
-    parser.add_argument("--local-partial-types", action="store_true", help=argparse.SUPPRESS)
+    add_invertible_flag("--local-partial-types", default=False, help=argparse.SUPPRESS)
     # --logical-deps adds some more dependencies that are not semantically needed, but
     # may be helpful to determine relative importance of classes and functions for overall
     # type precision in a code base. It also _removes_ some deps, so this flag should be never
@@ -1140,16 +1263,15 @@ def add_invertible_flag(
     # --debug-serialize will run tree.serialize() even if cache generation is disabled.
     # Useful for mypy_primer to detect serialize errors earlier.
     parser.add_argument("--debug-serialize", action="store_true", help=argparse.SUPPRESS)
-    # This one is deprecated, but we will keep it for few releases.
-    parser.add_argument(
-        "--enable-incomplete-features", action="store_true", help=argparse.SUPPRESS
-    )
+
     parser.add_argument(
         "--disable-bytearray-promotion", action="store_true", help=argparse.SUPPRESS
     )
     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(
@@ -1177,6 +1299,15 @@ def add_invertible_flag(
             "May be specified more than once, eg. --exclude a --exclude b"
         ),
     )
+    add_invertible_flag(
+        "--exclude-gitignore",
+        default=False,
+        help=(
+            "Use .gitignore file(s) to exclude files from checking "
+            "(in addition to any explicit --exclude if present)"
+        ),
+        group=code_group,
+    )
     code_group.add_argument(
         "-m",
         "--module",
@@ -1221,8 +1352,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)
 
@@ -1298,32 +1432,11 @@ def set_strict_flags() -> None:
             % ", ".join(sorted(overlap))
         )
 
-    # Process `--enable-error-code` and `--disable-error-code` flags
-    disabled_codes = set(options.disable_error_code)
-    enabled_codes = set(options.enable_error_code)
-
-    valid_error_codes = set(error_codes.keys())
-
-    invalid_codes = (enabled_codes | disabled_codes) - valid_error_codes
-    if invalid_codes:
-        parser.error(f"Invalid error code(s): {', '.join(sorted(invalid_codes))}")
+    validate_package_allow_list(options.untyped_calls_exclude)
+    validate_package_allow_list(options.deprecated_calls_exclude)
 
-    options.disabled_error_codes |= {error_codes[code] for code in disabled_codes}
-    options.enabled_error_codes |= {error_codes[code] for code in enabled_codes}
-
-    # Enabling an error code always overrides disabling
-    options.disabled_error_codes -= options.enabled_error_codes
-
-    # Validate incomplete features.
-    for feature in options.enable_incomplete_feature:
-        if feature not in INCOMPLETE_FEATURES:
-            parser.error(f"Unknown incomplete feature: {feature}")
-    if options.enable_incomplete_features:
-        print(
-            "Warning: --enable-incomplete-features is deprecated, use"
-            " --enable-incomplete-feature=FEATURE instead"
-        )
-        options.enable_incomplete_feature = list(INCOMPLETE_FEATURES)
+    options.process_error_codes(error_callback=parser.error)
+    options.process_incomplete_features(error_callback=parser.error, warning_callback=print)
 
     # Compute absolute path for custom typeshed (if present).
     if options.custom_typeshed_dir is not None:
@@ -1331,12 +1444,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
 
     # Set reports.
     for flag, val in vars(special_opts).items():
@@ -1356,6 +1469,9 @@ def set_strict_flags() -> None:
 
         process_cache_map(parser, special_opts, options)
 
+    # Process --strict-bytes
+    options.process_strict_bytes()
+
     # An explicitly specified cache_fine_grained implies local_partial_types
     # (because otherwise the cache is not compatible with dmypy)
     if options.cache_fine_grained:
@@ -1369,12 +1485,15 @@ def set_strict_flags() -> None:
     if options.logical_deps:
         options.cache_fine_grained = True
 
-    if options.enable_recursive_aliases:
+    if options.new_type_inference:
         print(
-            "Warning: --enable-recursive-aliases is deprecated;"
-            " recursive types are enabled by default"
+            "Warning: --new-type-inference flag is deprecated;"
+            " new type inference algorithm is already 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:
         options.build_type = BuildType.MODULE
@@ -1390,7 +1509,15 @@ def set_strict_flags() -> None:
                 fail(f"Package name '{p}' cannot have a slash in it.", stderr, options)
             p_targets = cache.find_modules_recursive(p)
             if not p_targets:
-                fail(f"Can't find package '{p}'", stderr, options)
+                reason = cache.find_module(p)
+                if reason is ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS:
+                    fail(
+                        f"Package '{p}' cannot be type checked due to missing py.typed marker. See https://mypy.readthedocs.io/en/stable/installed_packages.html for more details",
+                        stderr,
+                        options,
+                    )
+                else:
+                    fail(f"Can't find package '{p}'", stderr, options)
             targets.extend(p_targets)
         for m in special_opts.modules:
             targets.append(BuildSource(None, m, None))
@@ -1441,7 +1568,7 @@ def process_package_roots(
                 root = ""
         package_root.append(root)
     options.package_root = package_root
-    # Pass the package root on the the filesystem cache.
+    # Pass the package root on the filesystem cache.
     fscache.set_package_root(package_root)
 
 
@@ -1469,18 +1596,37 @@ def process_cache_map(
         options.cache_map[source] = (meta_file, data_file)
 
 
-def maybe_write_junit_xml(td: float, serious: bool, messages: list[str], options: Options) -> None:
+def maybe_write_junit_xml(
+    td: float,
+    serious: bool,
+    all_messages: list[str],
+    messages_by_file: dict[str | None, list[str]],
+    options: Options,
+) -> None:
     if options.junit_xml:
         py_version = f"{options.python_version[0]}_{options.python_version[1]}"
-        util.write_junit_xml(
-            td, serious, messages, options.junit_xml, py_version, options.platform
-        )
+        if options.junit_format == "global":
+            util.write_junit_xml(
+                td,
+                serious,
+                {None: all_messages} if all_messages else {},
+                options.junit_xml,
+                py_version,
+                options.platform,
+            )
+        else:
+            # per_file
+            util.write_junit_xml(
+                td, serious, messages_by_file, options.junit_xml, py_version, options.platform
+            )
 
 
 def fail(msg: str, stderr: TextIO, options: Options) -> NoReturn:
     """Fail with a serious error."""
     stderr.write(f"{msg}\n")
-    maybe_write_junit_xml(0.0, serious=True, messages=[msg], options=options)
+    maybe_write_junit_xml(
+        0.0, serious=True, all_messages=[msg], messages_by_file={None: [msg]}, options=options
+    )
     sys.exit(2)
 
 
@@ -1492,8 +1638,9 @@ def read_types_packages_to_install(cache_dir: str, after_run: bool) -> list[str]
                 + "(and no cache from previous mypy run)\n"
             )
         else:
-            sys.stderr.write("error: --install-types failed (no mypy cache directory)\n")
-        sys.exit(2)
+            sys.stderr.write(
+                "error: --install-types failed (an error blocked analysis of which types to install)\n"
+            )
     fnam = build.missing_stubs_file(cache_dir)
     if not os.path.isfile(fnam):
         # No missing stubs.
diff --git a/mypy/maptype.py b/mypy/maptype.py
index cae904469fed..59ecb2bc9993 100644
--- a/mypy/maptype.py
+++ b/mypy/maptype.py
@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from mypy.expandtype import expand_type
+from mypy.expandtype import expand_type_by_instance
 from mypy.nodes import TypeInfo
-from mypy.types import AnyType, Instance, TupleType, Type, TypeOfAny, TypeVarId, has_type_vars
+from mypy.types import AnyType, Instance, TupleType, TypeOfAny, has_type_vars
 
 
 def map_instance_to_supertype(instance: Instance, superclass: TypeInfo) -> Instance:
@@ -25,13 +25,15 @@ def map_instance_to_supertype(instance: Instance, superclass: TypeInfo) -> Insta
             if not alias._is_recursive:
                 # Unfortunately we can't support this for generic recursive tuples.
                 # If we skip this special casing we will fall back to tuple[Any, ...].
-                env = instance_to_type_environment(instance)
-                tuple_type = expand_type(instance.type.tuple_type, env)
+                tuple_type = expand_type_by_instance(instance.type.tuple_type, instance)
                 if isinstance(tuple_type, TupleType):
                     # Make the import here to avoid cyclic imports.
                     import mypy.typeops
 
                     return mypy.typeops.tuple_fallback(tuple_type)
+                elif isinstance(tuple_type, Instance):
+                    # This can happen after normalizing variadic tuples.
+                    return tuple_type
 
     if not superclass.type_vars:
         # Fast path: `superclass` has no type variables to map to.
@@ -91,8 +93,7 @@ def map_instance_to_direct_supertypes(instance: Instance, supertype: TypeInfo) -
 
     for b in typ.bases:
         if b.type == supertype:
-            env = instance_to_type_environment(instance)
-            t = expand_type(b, env)
+            t = expand_type_by_instance(b, instance)
             assert isinstance(t, Instance)
             result.append(t)
 
@@ -103,16 +104,3 @@ def map_instance_to_direct_supertypes(instance: Instance, supertype: TypeInfo) -
         # type arguments implicitly.
         any_type = AnyType(TypeOfAny.unannotated)
         return [Instance(supertype, [any_type] * len(supertype.type_vars))]
-
-
-def instance_to_type_environment(instance: Instance) -> dict[TypeVarId, Type]:
-    """Given an Instance, produce the resulting type environment for type
-    variables bound by the Instance's class definition.
-
-    An Instance is a type application of a class (a TypeInfo) to its
-    required number of type arguments.  So this environment consists
-    of the class's type variables mapped to the Instance's actual
-    arguments.  The type variables are mapped by their `id`.
-
-    """
-    return {binder.id: arg for binder, arg in zip(instance.type.defn.type_vars, instance.args)}
diff --git a/mypy/meet.py b/mypy/meet.py
index 29c4d3663503..add0785f5e71 100644
--- a/mypy/meet.py
+++ b/mypy/meet.py
@@ -7,6 +7,8 @@
 from mypy.maptype import map_instance_to_supertype
 from mypy.state import state
 from mypy.subtypes import (
+    are_parameters_compatible,
+    find_member,
     is_callable_compatible,
     is_equivalent,
     is_proper_subtype,
@@ -16,6 +18,7 @@
 from mypy.typeops import is_recursive_pair, make_simplified_union, tuple_fallback
 from mypy.types import (
     MYPYC_NATIVE_INT_NAMES,
+    TUPLE_LIKE_INSTANCE_NAMES,
     AnyType,
     CallableType,
     DeletedType,
@@ -44,8 +47,11 @@
     UninhabitedType,
     UnionType,
     UnpackType,
+    find_unpack_in_list,
     get_proper_type,
     get_proper_types,
+    is_named_instance,
+    split_with_prefix_and_suffix,
 )
 
 # TODO Describe this module.
@@ -137,7 +143,12 @@ def narrow_declared_type(declared: Type, narrowed: Type) -> Type:
             ]
         )
     if is_enum_overlapping_union(declared, narrowed):
-        return original_narrowed
+        # Quick check before reaching `is_overlapping_types`. If it's enum/literal overlap,
+        # avoid full expansion and make it faster.
+        assert isinstance(narrowed, UnionType)
+        return make_simplified_union(
+            [narrow_declared_type(declared, x) for x in narrowed.relevant_items()]
+        )
     elif not is_overlapping_types(declared, narrowed, prohibit_none_typevar_overlap=True):
         if state.strict_optional:
             return UninhabitedType()
@@ -218,6 +229,12 @@ def get_possible_variants(typ: Type) -> list[Type]:
         else:
             return [typ.upper_bound]
     elif isinstance(typ, ParamSpecType):
+        # Extract 'object' from the final mro item
+        upper_bound = get_proper_type(typ.upper_bound)
+        if isinstance(upper_bound, Instance):
+            return [Instance(upper_bound.type.mro[-1], [])]
+        return [AnyType(TypeOfAny.implementation_artifact)]
+    elif isinstance(typ, TypeVarTupleType):
         return [typ.upper_bound]
     elif isinstance(typ, UnionType):
         return list(typ.items)
@@ -236,8 +253,8 @@ def is_enum_overlapping_union(x: ProperType, y: ProperType) -> bool:
         and x.type.is_enum
         and isinstance(y, UnionType)
         and any(
-            isinstance(p, LiteralType) and x.type == p.fallback.type
-            for p in (get_proper_type(z) for z in y.relevant_items())
+            isinstance(p := get_proper_type(z), LiteralType) and x.type == p.fallback.type
+            for z in y.relevant_items()
         )
     )
 
@@ -251,18 +268,26 @@ def is_literal_in_union(x: ProperType, y: ProperType) -> bool:
     )
 
 
+def is_object(t: ProperType) -> bool:
+    return isinstance(t, Instance) and t.type.fullname == "builtins.object"
+
+
 def is_overlapping_types(
     left: Type,
     right: Type,
     ignore_promotions: bool = False,
     prohibit_none_typevar_overlap: bool = False,
-    ignore_uninhabited: bool = False,
+    overlap_for_overloads: bool = False,
+    seen_types: set[tuple[Type, Type]] | None = None,
 ) -> bool:
     """Can a value of type 'left' also be of type 'right' or vice-versa?
 
     If 'ignore_promotions' is True, we ignore promotions while checking for overlaps.
     If 'prohibit_none_typevar_overlap' is True, we disallow None from overlapping with
     TypeVars (in both strict-optional and non-strict-optional mode).
+    If 'overlap_for_overloads' is True, we check for overlaps more strictly (to avoid false
+    positives), for example: None only overlaps with explicitly optional types, Any
+    doesn't overlap with anything except object, we don't ignore positional argument names.
     """
     if isinstance(left, TypeGuardedType) or isinstance(  # type: ignore[misc]
         right, TypeGuardedType
@@ -270,18 +295,27 @@ def is_overlapping_types(
         # A type guard forces the new type even if it doesn't overlap the old.
         return True
 
+    if seen_types is None:
+        seen_types = set()
+    if (left, right) in seen_types:
+        return True
+    if isinstance(left, TypeAliasType) and isinstance(right, TypeAliasType):
+        seen_types.add((left, right))
+
     left, right = get_proper_types((left, right))
 
     def _is_overlapping_types(left: Type, right: Type) -> bool:
         """Encode the kind of overlapping check to perform.
 
-        This function mostly exists so we don't have to repeat keyword arguments everywhere."""
+        This function mostly exists, so we don't have to repeat keyword arguments everywhere.
+        """
         return is_overlapping_types(
             left,
             right,
             ignore_promotions=ignore_promotions,
             prohibit_none_typevar_overlap=prohibit_none_typevar_overlap,
-            ignore_uninhabited=ignore_uninhabited,
+            overlap_for_overloads=overlap_for_overloads,
+            seen_types=seen_types.copy(),
         )
 
     # We should never encounter this type.
@@ -309,7 +343,7 @@ def _is_overlapping_types(left: Type, right: Type) -> bool:
 
     # 'Any' may or may not be overlapping with the other type
     if isinstance(left, AnyType) or isinstance(right, AnyType):
-        return True
+        return not overlap_for_overloads or is_object(left) or is_object(right)
 
     # We check for complete overlaps next as a general-purpose failsafe.
     # If this check fails, we start checking to see if there exists a
@@ -329,11 +363,25 @@ def _is_overlapping_types(left: Type, right: Type) -> bool:
     ):
         return True
 
-    if is_proper_subtype(
-        left, right, ignore_promotions=ignore_promotions, ignore_uninhabited=ignore_uninhabited
-    ) or is_proper_subtype(
-        right, left, ignore_promotions=ignore_promotions, ignore_uninhabited=ignore_uninhabited
-    ):
+    def is_none_object_overlap(t1: Type, t2: Type) -> bool:
+        t1, t2 = get_proper_types((t1, t2))
+        return (
+            isinstance(t1, NoneType)
+            and isinstance(t2, Instance)
+            and t2.type.fullname == "builtins.object"
+        )
+
+    if overlap_for_overloads:
+        if is_none_object_overlap(left, right) or is_none_object_overlap(right, left):
+            return False
+
+    def _is_subtype(left: Type, right: Type) -> bool:
+        if overlap_for_overloads:
+            return is_proper_subtype(left, right, ignore_promotions=ignore_promotions)
+        else:
+            return is_subtype(left, right, ignore_promotions=ignore_promotions)
+
+    if _is_subtype(left, right) or _is_subtype(right, left):
         return True
 
     # See the docstring for 'get_possible_variants' for more info on what the
@@ -342,21 +390,6 @@ def _is_overlapping_types(left: Type, right: Type) -> bool:
     left_possible = get_possible_variants(left)
     right_possible = get_possible_variants(right)
 
-    # First handle special cases relating to PEP 612:
-    # - comparing a `Parameters` to a `Parameters`
-    # - comparing a `Parameters` to a `ParamSpecType`
-    # - comparing a `ParamSpecType` to a `ParamSpecType`
-    #
-    # These should all always be considered overlapping equality checks.
-    # These need to be done before we move on to other TypeVarLike comparisons.
-    if isinstance(left, (Parameters, ParamSpecType)) and isinstance(
-        right, (Parameters, ParamSpecType)
-    ):
-        return True
-    # A `Parameters` does not overlap with anything else, however
-    if isinstance(left, Parameters) or isinstance(right, Parameters):
-        return False
-
     # Now move on to checking multi-variant types like Unions. We also perform
     # the same logic if either type happens to be a TypeVar/ParamSpec/TypeVarTuple.
     #
@@ -406,7 +439,7 @@ def is_none_typevarlike_overlap(t1: Type, t2: Type) -> bool:
     # into their 'Instance' fallbacks.
 
     if isinstance(left, TypedDictType) and isinstance(right, TypedDictType):
-        return are_typed_dicts_overlapping(left, right, ignore_promotions=ignore_promotions)
+        return are_typed_dicts_overlapping(left, right, _is_overlapping_types)
     elif typed_dict_mapping_pair(left, right):
         # Overlaps between TypedDicts and Mappings require dedicated logic.
         return typed_dict_mapping_overlap(left, right, overlapping=_is_overlapping_types)
@@ -416,7 +449,7 @@ def is_none_typevarlike_overlap(t1: Type, t2: Type) -> bool:
         right = right.fallback
 
     if is_tuple(left) and is_tuple(right):
-        return are_tuples_overlapping(left, right, ignore_promotions=ignore_promotions)
+        return are_tuples_overlapping(left, right, _is_overlapping_types)
     elif isinstance(left, TupleType):
         left = tuple_fallback(left)
     elif isinstance(right, TupleType):
@@ -453,17 +486,44 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
     if isinstance(left, TypeType) or isinstance(right, TypeType):
         return _type_object_overlap(left, right) or _type_object_overlap(right, left)
 
+    if isinstance(left, Parameters) and isinstance(right, Parameters):
+        return are_parameters_compatible(
+            left,
+            right,
+            is_compat=_is_overlapping_types,
+            is_proper_subtype=False,
+            ignore_pos_arg_names=not overlap_for_overloads,
+            allow_partial_overlap=True,
+        )
+    # A `Parameters` does not overlap with anything else, however
+    if isinstance(left, Parameters) or isinstance(right, Parameters):
+        return False
+
     if isinstance(left, CallableType) and isinstance(right, CallableType):
         return is_callable_compatible(
             left,
             right,
             is_compat=_is_overlapping_types,
-            ignore_pos_arg_names=True,
+            is_proper_subtype=False,
+            ignore_pos_arg_names=not overlap_for_overloads,
             allow_partial_overlap=True,
         )
-    elif isinstance(left, CallableType):
+
+    call = None
+    other = None
+    if isinstance(left, CallableType) and isinstance(right, Instance):
+        call = find_member("__call__", right, right, is_operator=True)
+        other = left
+    if isinstance(right, CallableType) and isinstance(left, Instance):
+        call = find_member("__call__", left, left, is_operator=True)
+        other = right
+    if isinstance(get_proper_type(call), FunctionLike):
+        assert call is not None and other is not None
+        return _is_overlapping_types(call, other)
+
+    if isinstance(left, CallableType):
         left = left.fallback
-    elif isinstance(right, CallableType):
+    if isinstance(right, CallableType):
         right = right.fallback
 
     if isinstance(left, LiteralType) and isinstance(right, LiteralType):
@@ -484,11 +544,7 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
     if isinstance(left, Instance) and isinstance(right, Instance):
         # First we need to handle promotions and structural compatibility for instances
         # that came as fallbacks, so simply call is_subtype() to avoid code duplication.
-        if is_subtype(
-            left, right, ignore_promotions=ignore_promotions, ignore_uninhabited=ignore_uninhabited
-        ) or is_subtype(
-            right, left, ignore_promotions=ignore_promotions, ignore_uninhabited=ignore_uninhabited
-        ):
+        if _is_subtype(left, right) or _is_subtype(right, left):
             return True
 
         if right.type.fullname == "builtins.int" and left.type.fullname in MYPYC_NATIVE_INT_NAMES:
@@ -502,7 +558,27 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
         else:
             return False
 
-        if len(left.args) == len(right.args):
+        if right.type.has_type_var_tuple_type:
+            # Similar to subtyping, we delegate the heavy lifting to the tuple overlap.
+            assert right.type.type_var_tuple_prefix is not None
+            assert right.type.type_var_tuple_suffix is not None
+            prefix = right.type.type_var_tuple_prefix
+            suffix = right.type.type_var_tuple_suffix
+            tvt = right.type.defn.type_vars[prefix]
+            assert isinstance(tvt, TypeVarTupleType)
+            fallback = tvt.tuple_fallback
+            left_prefix, left_middle, left_suffix = split_with_prefix_and_suffix(
+                left.args, prefix, suffix
+            )
+            right_prefix, right_middle, right_suffix = split_with_prefix_and_suffix(
+                right.args, prefix, suffix
+            )
+            left_args = left_prefix + (TupleType(list(left_middle), fallback),) + left_suffix
+            right_args = right_prefix + (TupleType(list(right_middle), fallback),) + right_suffix
+        else:
+            left_args = left.args
+            right_args = right.args
+        if len(left_args) == len(right_args):
             # Note: we don't really care about variance here, since the overlapping check
             # is symmetric and since we want to return 'True' even for partial overlaps.
             #
@@ -519,7 +595,7 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
             # to contain only instances of B at runtime.
             if all(
                 _is_overlapping_types(left_arg, right_arg)
-                for left_arg, right_arg in zip(left.args, right.args)
+                for left_arg, right_arg in zip(left_args, right_args)
             ):
                 return True
 
@@ -548,32 +624,21 @@ def is_overlapping_erased_types(
 
 
 def are_typed_dicts_overlapping(
-    left: TypedDictType,
-    right: TypedDictType,
-    *,
-    ignore_promotions: bool = False,
-    prohibit_none_typevar_overlap: bool = False,
+    left: TypedDictType, right: TypedDictType, is_overlapping: Callable[[Type, Type], bool]
 ) -> bool:
     """Returns 'true' if left and right are overlapping TypeDictTypes."""
     # All required keys in left are present and overlapping with something in right
     for key in left.required_keys:
         if key not in right.items:
             return False
-        if not is_overlapping_types(
-            left.items[key],
-            right.items[key],
-            ignore_promotions=ignore_promotions,
-            prohibit_none_typevar_overlap=prohibit_none_typevar_overlap,
-        ):
+        if not is_overlapping(left.items[key], right.items[key]):
             return False
 
     # Repeat check in the other direction
     for key in right.required_keys:
         if key not in left.items:
             return False
-        if not is_overlapping_types(
-            left.items[key], right.items[key], ignore_promotions=ignore_promotions
-        ):
+        if not is_overlapping(left.items[key], right.items[key]):
             return False
 
     # The presence of any additional optional keys does not affect whether the two
@@ -583,11 +648,7 @@ def are_typed_dicts_overlapping(
 
 
 def are_tuples_overlapping(
-    left: Type,
-    right: Type,
-    *,
-    ignore_promotions: bool = False,
-    prohibit_none_typevar_overlap: bool = False,
+    left: Type, right: Type, is_overlapping: Callable[[Type, Type], bool]
 ) -> bool:
     """Returns true if left and right are overlapping tuples."""
     left, right = get_proper_types((left, right))
@@ -595,17 +656,52 @@ def are_tuples_overlapping(
     right = adjust_tuple(right, left) or right
     assert isinstance(left, TupleType), f"Type {left} is not a tuple"
     assert isinstance(right, TupleType), f"Type {right} is not a tuple"
+
+    # This algorithm works well if only one tuple is variadic, if both are
+    # variadic we may get rare false negatives for overlapping prefix/suffix.
+    # Also, this ignores empty unpack case, but it is probably consistent with
+    # how we handle e.g. empty lists in overload overlaps.
+    # TODO: write a more robust algorithm for cases where both types are variadic.
+    left_unpack = find_unpack_in_list(left.items)
+    right_unpack = find_unpack_in_list(right.items)
+    if left_unpack is not None:
+        left = expand_tuple_if_possible(left, len(right.items))
+    if right_unpack is not None:
+        right = expand_tuple_if_possible(right, len(left.items))
+
     if len(left.items) != len(right.items):
         return False
-    return all(
-        is_overlapping_types(
-            l,
-            r,
-            ignore_promotions=ignore_promotions,
-            prohibit_none_typevar_overlap=prohibit_none_typevar_overlap,
-        )
-        for l, r in zip(left.items, right.items)
-    )
+    if not all(is_overlapping(l, r) for l, r in zip(left.items, right.items)):
+        return False
+
+    # Check that the tuples aren't from e.g. different NamedTuples.
+    if is_named_instance(right.partial_fallback, "builtins.tuple") or is_named_instance(
+        left.partial_fallback, "builtins.tuple"
+    ):
+        return True
+    else:
+        return is_overlapping(left.partial_fallback, right.partial_fallback)
+
+
+def expand_tuple_if_possible(tup: TupleType, target: int) -> TupleType:
+    if len(tup.items) > target + 1:
+        return tup
+    extra = target + 1 - len(tup.items)
+    new_items = []
+    for it in tup.items:
+        if not isinstance(it, UnpackType):
+            new_items.append(it)
+            continue
+        unpacked = get_proper_type(it.type)
+        if isinstance(unpacked, TypeVarTupleType):
+            instance = unpacked.tuple_fallback
+        else:
+            # Nested non-variadic tuples should be normalized at this point.
+            assert isinstance(unpacked, Instance)
+            instance = unpacked
+        assert instance.type.fullname == "builtins.tuple"
+        new_items.extend([instance.args[0]] * extra)
+    return tup.copy_modified(items=new_items)
 
 
 def adjust_tuple(left: ProperType, r: ProperType) -> TupleType | None:
@@ -630,7 +726,7 @@ def __init__(self, s: ProperType) -> None:
     def visit_unbound_type(self, t: UnboundType) -> ProperType:
         if isinstance(self.s, NoneType):
             if state.strict_optional:
-                return AnyType(TypeOfAny.special_form)
+                return UninhabitedType()
             else:
                 return self.s
         elif isinstance(self.s, UninhabitedType):
@@ -692,8 +788,8 @@ def visit_param_spec(self, t: ParamSpecType) -> ProperType:
             return self.default(self.s)
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> ProperType:
-        if self.s == t:
-            return self.s
+        if isinstance(self.s, TypeVarTupleType) and self.s.id == t.id:
+            return self.s if self.s.min_len > t.min_len else t
         else:
             return self.default(self.s)
 
@@ -701,12 +797,13 @@ def visit_unpack_type(self, t: UnpackType) -> ProperType:
         raise NotImplementedError
 
     def visit_parameters(self, t: Parameters) -> ProperType:
-        # TODO: is this the right variance?
-        if isinstance(self.s, (Parameters, CallableType)):
+        if isinstance(self.s, Parameters):
             if len(t.arg_types) != len(self.s.arg_types):
                 return self.default(self.s)
+            from mypy.join import join_types
+
             return t.copy_modified(
-                arg_types=[meet_types(s_a, t_a) for s_a, t_a in zip(self.s.arg_types, t.arg_types)]
+                arg_types=[join_types(s_a, t_a) for s_a, t_a in zip(self.s.arg_types, t.arg_types)]
             )
         else:
             return self.default(self.s)
@@ -720,8 +817,41 @@ def visit_instance(self, t: Instance) -> ProperType:
                     args: list[Type] = []
                     # N.B: We use zip instead of indexing because the lengths might have
                     # mismatches during daemon reprocessing.
-                    for ta, sia in zip(t.args, self.s.args):
-                        args.append(self.meet(ta, sia))
+                    if t.type.has_type_var_tuple_type:
+                        # We handle meet of variadic instances by simply creating correct mapping
+                        # for type arguments and compute the individual meets same as for regular
+                        # instances. All the heavy lifting is done in the meet of tuple types.
+                        s = self.s
+                        assert s.type.type_var_tuple_prefix is not None
+                        assert s.type.type_var_tuple_suffix is not None
+                        prefix = s.type.type_var_tuple_prefix
+                        suffix = s.type.type_var_tuple_suffix
+                        tvt = s.type.defn.type_vars[prefix]
+                        assert isinstance(tvt, TypeVarTupleType)
+                        fallback = tvt.tuple_fallback
+                        s_prefix, s_middle, s_suffix = split_with_prefix_and_suffix(
+                            s.args, prefix, suffix
+                        )
+                        t_prefix, t_middle, t_suffix = split_with_prefix_and_suffix(
+                            t.args, prefix, suffix
+                        )
+                        s_args = s_prefix + (TupleType(list(s_middle), fallback),) + s_suffix
+                        t_args = t_prefix + (TupleType(list(t_middle), fallback),) + t_suffix
+                    else:
+                        t_args = t.args
+                        s_args = self.s.args
+                    for ta, sa, tv in zip(t_args, s_args, t.type.defn.type_vars):
+                        meet = self.meet(ta, sa)
+                        if isinstance(tv, TypeVarTupleType):
+                            # Correctly unpack possible outcomes of meets of tuples: it can be
+                            # either another tuple type or Never (normalized as *tuple[Never, ...])
+                            if isinstance(meet, TupleType):
+                                args.extend(meet.items)
+                                continue
+                            else:
+                                assert isinstance(meet, UninhabitedType)
+                                meet = UnpackType(tv.tuple_fallback.copy_modified(args=[meet]))
+                        args.append(meet)
                     return Instance(t.type, args)
                 else:
                     if state.strict_optional:
@@ -810,20 +940,102 @@ def visit_overloaded(self, t: Overloaded) -> ProperType:
                 return meet_types(t, call)
         return meet_types(t.fallback, s)
 
+    def meet_tuples(self, s: TupleType, t: TupleType) -> list[Type] | None:
+        """Meet two tuple types while handling variadic entries.
+
+        This is surprisingly tricky, and we don't handle some tricky corner cases.
+        Most of the trickiness comes from the variadic tuple items like *tuple[X, ...]
+        since they can have arbitrary partial overlaps (while *Ts can't be split). This
+        function is roughly a mirror of join_tuples() w.r.t. to the fact that fixed
+        tuples are subtypes of variadic ones but not vice versa.
+        """
+        s_unpack_index = find_unpack_in_list(s.items)
+        t_unpack_index = find_unpack_in_list(t.items)
+        if s_unpack_index is None and t_unpack_index is None:
+            if s.length() == t.length():
+                items: list[Type] = []
+                for i in range(t.length()):
+                    items.append(self.meet(t.items[i], s.items[i]))
+                return items
+            return None
+        if s_unpack_index is not None and t_unpack_index is not None:
+            # The only simple case we can handle if both tuples are variadic
+            # is when their structure fully matches. Other cases are tricky because
+            # a variadic item is effectively a union of tuples of all length, thus
+            # potentially causing overlap between a suffix in `s` and a prefix
+            # in `t` (see how this is handled in is_subtype() for details).
+            # TODO: handle more cases (like when both prefix/suffix are shorter in s or t).
+            if s.length() == t.length() and s_unpack_index == t_unpack_index:
+                unpack_index = s_unpack_index
+                s_unpack = s.items[unpack_index]
+                assert isinstance(s_unpack, UnpackType)
+                s_unpacked = get_proper_type(s_unpack.type)
+                t_unpack = t.items[unpack_index]
+                assert isinstance(t_unpack, UnpackType)
+                t_unpacked = get_proper_type(t_unpack.type)
+                if not (isinstance(s_unpacked, Instance) and isinstance(t_unpacked, Instance)):
+                    return None
+                meet = self.meet(s_unpacked, t_unpacked)
+                if not isinstance(meet, Instance):
+                    return None
+                m_prefix: list[Type] = []
+                for si, ti in zip(s.items[:unpack_index], t.items[:unpack_index]):
+                    m_prefix.append(meet_types(si, ti))
+                m_suffix: list[Type] = []
+                for si, ti in zip(s.items[unpack_index + 1 :], t.items[unpack_index + 1 :]):
+                    m_suffix.append(meet_types(si, ti))
+                return m_prefix + [UnpackType(meet)] + m_suffix
+            return None
+        if s_unpack_index is not None:
+            variadic = s
+            unpack_index = s_unpack_index
+            fixed = t
+        else:
+            assert t_unpack_index is not None
+            variadic = t
+            unpack_index = t_unpack_index
+            fixed = s
+        # If one tuple is variadic one, and the other one is fixed, the meet will be fixed.
+        unpack = variadic.items[unpack_index]
+        assert isinstance(unpack, UnpackType)
+        unpacked = get_proper_type(unpack.type)
+        if not isinstance(unpacked, Instance):
+            return None
+        if fixed.length() < variadic.length() - 1:
+            return None
+        prefix_len = unpack_index
+        suffix_len = variadic.length() - prefix_len - 1
+        prefix, middle, suffix = split_with_prefix_and_suffix(
+            tuple(fixed.items), prefix_len, suffix_len
+        )
+        items = []
+        for fi, vi in zip(prefix, variadic.items[:prefix_len]):
+            items.append(self.meet(fi, vi))
+        for mi in middle:
+            items.append(self.meet(mi, unpacked.args[0]))
+        if suffix_len:
+            for fi, vi in zip(suffix, variadic.items[-suffix_len:]):
+                items.append(self.meet(fi, vi))
+        return items
+
     def visit_tuple_type(self, t: TupleType) -> ProperType:
-        if isinstance(self.s, TupleType) and self.s.length() == t.length():
-            items: list[Type] = []
-            for i in range(t.length()):
-                items.append(self.meet(t.items[i], self.s.items[i]))
+        if isinstance(self.s, TupleType):
+            items = self.meet_tuples(self.s, t)
+            if items is None:
+                return self.default(self.s)
             # TODO: What if the fallbacks are different?
             return TupleType(items, tuple_fallback(t))
         elif isinstance(self.s, Instance):
             # meet(Tuple[t1, t2, <...>], Tuple[s, ...]) == Tuple[meet(t1, s), meet(t2, s), <...>].
-            if self.s.type.fullname == "builtins.tuple" and self.s.args:
+            if self.s.type.fullname in TUPLE_LIKE_INSTANCE_NAMES and self.s.args:
                 return t.copy_modified(items=[meet_types(it, self.s.args[0]) for it in t.items])
             elif is_proper_subtype(t, self.s):
                 # A named tuple that inherits from a normal class
                 return t
+            elif self.s.type.has_type_var_tuple_type and is_subtype(t, self.s):
+                # This is a bit ad-hoc but more principled handling is tricky, and this
+                # special case is important for type narrowing in binder to work.
+                return t
         return self.default(self.s)
 
     def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
@@ -844,7 +1056,8 @@ def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
             items = dict(item_list)
             fallback = self.s.create_anonymous_fallback()
             required_keys = t.required_keys | self.s.required_keys
-            return TypedDictType(items, required_keys, fallback)
+            readonly_keys = t.readonly_keys | self.s.readonly_keys
+            return TypedDictType(items, required_keys, readonly_keys, fallback)
         elif isinstance(self.s, Instance) and is_subtype(t, self.s):
             return t
         else:
@@ -892,11 +1105,12 @@ def default(self, typ: Type) -> ProperType:
 
 
 def meet_similar_callables(t: CallableType, s: CallableType) -> CallableType:
-    from mypy.join import join_types
+    from mypy.join import match_generic_callables, safe_join
 
+    t, s = match_generic_callables(t, s)
     arg_types: list[Type] = []
     for i in range(len(t.arg_types)):
-        arg_types.append(join_types(t.arg_types[i], s.arg_types[i]))
+        arg_types.append(safe_join(t.arg_types[i], s.arg_types[i]))
     # TODO in combine_similar_callables also applies here (names and kinds)
     # The fallback type can be either 'function' or 'type'. The result should have 'function' as
     # fallback only if both operands have it as 'function'.
@@ -965,13 +1179,16 @@ def typed_dict_mapping_overlap(
       - TypedDict(x=str, y=str, total=False) doesn't overlap with Dict[str, int]
       - TypedDict(x=int, y=str, total=False) overlaps with Dict[str, str]
 
+    * A TypedDict with at least one ReadOnly[] key does not overlap
+      with Dict or MutableMapping, because they assume mutable data.
+
     As usual empty, dictionaries lie in a gray area. In general, List[str] and List[str]
     are considered non-overlapping despite empty list belongs to both. However, List[int]
-    and List[<nothing>] are considered overlapping.
+    and List[Never] are considered overlapping.
 
     So here we follow the same logic: a TypedDict with no required keys is considered
     non-overlapping with Mapping[str, <some type>], but is considered overlapping with
-    Mapping[<nothing>, <nothing>]. This way we avoid false positives for overloads, and also
+    Mapping[Never, Never]. This way we avoid false positives for overloads, and also
     avoid false positives for comparisons like SomeTypedDict == {} under --strict-equality.
     """
     left, right = get_proper_types((left, right))
@@ -985,6 +1202,12 @@ def typed_dict_mapping_overlap(
         assert isinstance(right, TypedDictType)
         typed, other = right, left
 
+    mutable_mapping = next(
+        (base for base in other.type.mro if base.fullname == "typing.MutableMapping"), None
+    )
+    if mutable_mapping is not None and typed.readonly_keys:
+        return False
+
     mapping = next(base for base in other.type.mro if base.fullname == "typing.Mapping")
     other = map_instance_to_supertype(other, mapping)
     key_type, value_type = get_proper_types(other.args)
diff --git a/mypy/memprofile.py b/mypy/memprofile.py
index 48c0cb5ce022..4bab4ecb262e 100644
--- a/mypy/memprofile.py
+++ b/mypy/memprofile.py
@@ -9,7 +9,8 @@
 import gc
 import sys
 from collections import defaultdict
-from typing import Dict, Iterable, cast
+from collections.abc import Iterable
+from typing import cast
 
 from mypy.nodes import FakeInfo, Node
 from mypy.types import Type
@@ -108,7 +109,7 @@ def visit(o: object) -> None:
             # Processing these would cause a crash.
             continue
         if type(obj) in (dict, defaultdict):
-            for key, val in cast(Dict[object, object], obj).items():
+            for key, val in cast(dict[object, object], obj).items():
                 visit(key)
                 visit(val)
         if type(obj) in (list, tuple, set):
diff --git a/mypy/message_registry.py b/mypy/message_registry.py
index c5164d48fd13..0c7464246990 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
 
@@ -53,7 +52,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
     '"return" with value in async generator is not allowed'
 )
 INVALID_RETURN_TYPE_FOR_GENERATOR: Final = ErrorMessage(
-    'The return type of a generator function should be "Generator"' " or one of its supertypes"
+    'The return type of a generator function should be "Generator" or one of its supertypes'
 )
 INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR: Final = ErrorMessage(
     'The return type of an async generator function should be "AsyncGenerator" or one of its '
@@ -64,6 +63,9 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 INCOMPATIBLE_TYPES_IN_ASSIGNMENT: Final = ErrorMessage(
     "Incompatible types in assignment", code=codes.ASSIGNMENT
 )
+COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE: Final = ErrorMessage(
+    "Covariant override of a mutable attribute", code=codes.MUTABLE_OVERRIDE
+)
 INCOMPATIBLE_TYPES_IN_AWAIT: Final = ErrorMessage('Incompatible types in "await"')
 INCOMPATIBLE_REDEFINITION: Final = ErrorMessage("Incompatible redefinition")
 INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AENTER: Final = (
@@ -84,6 +86,10 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 INCOMPATIBLE_TYPES_IN_CAPTURE: Final = ErrorMessage("Incompatible types in capture pattern")
 MUST_HAVE_NONE_RETURN_TYPE: Final = ErrorMessage('The return type of "{}" must be None')
 TUPLE_INDEX_OUT_OF_RANGE: Final = ErrorMessage("Tuple index out of range")
+AMBIGUOUS_SLICE_OF_VARIADIC_TUPLE: Final = ErrorMessage("Ambiguous slice of a variadic tuple")
+TOO_MANY_TARGETS_FOR_VARIADIC_UNPACK: Final = ErrorMessage(
+    "Too many assignment targets for variadic unpack"
+)
 INVALID_SLICE_INDEX: Final = ErrorMessage("Slice index must be an integer, SupportsIndex or None")
 CANNOT_INFER_LAMBDA_TYPE: Final = ErrorMessage("Cannot infer type of lambda")
 CANNOT_ACCESS_INIT: Final = (
@@ -132,6 +138,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 TYPEDDICT_KEY_MUST_BE_STRING_LITERAL: Final = ErrorMessage(
     "Expected TypedDict key to be string literal"
 )
+TYPEDDICT_OVERRIDE_MERGE: Final = 'Overwriting TypedDict field "{}" while merging'
 MALFORMED_ASSERT: Final = ErrorMessage("Assertion is always true, perhaps remove parentheses?")
 DUPLICATE_TYPE_SIGNATURES: Final = ErrorMessage("Function has duplicate type signatures")
 DESCRIPTOR_SET_NOT_CALLABLE: Final = ErrorMessage("{}.__set__ is not callable")
@@ -172,7 +179,12 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 IMPLICIT_GENERIC_ANY_BUILTIN: Final = (
     'Implicit generic "Any". Use "{}" and specify generic parameters'
 )
-INVALID_UNPACK = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
+INVALID_UNPACK: Final = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
+INVALID_UNPACK_POSITION: Final = "Unpack is only valid in a variadic position"
+INVALID_PARAM_SPEC_LOCATION: Final = "Invalid location for ParamSpec {}"
+INVALID_PARAM_SPEC_LOCATION_NOTE: Final = (
+    'You can use ParamSpec as the first argument to Callable, e.g., "Callable[{}, int]"'
+)
 
 # TypeVar
 INCOMPATIBLE_TYPEVAR_VALUE: Final = 'Value of type variable "{}" of {} cannot be {}'
@@ -184,8 +196,10 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 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 "
-    "one argument containing the same TypeVar"
+    "A function returning TypeVar should receive at least one argument containing the same TypeVar"
+)
+TYPE_PARAMETERS_SHOULD_BE_DECLARED: Final = (
+    "All type parameters should be declared ({} not declared)"
 )
 
 # Super
@@ -202,10 +216,10 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 )
 TARGET_CLASS_HAS_NO_BASE_CLASS: Final = ErrorMessage("Target class has no base class")
 SUPER_OUTSIDE_OF_METHOD_NOT_SUPPORTED: Final = ErrorMessage(
-    "super() outside of a method is not supported"
+    '"super()" outside of a method is not supported'
 )
 SUPER_ENCLOSING_POSITIONAL_ARGS_REQUIRED: Final = ErrorMessage(
-    "super() requires one or more positional arguments in enclosing function"
+    '"super()" requires one or two positional arguments in enclosing function'
 )
 
 # Self-type
@@ -227,7 +241,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 CANNOT_MAKE_DELETABLE_FINAL: Final = ErrorMessage("Deletable attribute cannot be final")
 
 # Enum
-ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDEN: Final = ErrorMessage(
+ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDDEN: Final = ErrorMessage(
     'Assigned "__members__" will be overridden by "Enum" internally'
 )
 
@@ -255,7 +269,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 
 CONTIGUOUS_ITERABLE_EXPECTED: Final = ErrorMessage("Contiguous iterable with same type expected")
 ITERABLE_TYPE_EXPECTED: Final = ErrorMessage("Invalid type '{}' for *expr (iterable expected)")
-TYPE_GUARD_POS_ARG_REQUIRED: Final = ErrorMessage("Type guard requires positional argument")
+TYPE_GUARD_POS_ARG_REQUIRED: Final = ErrorMessage("Type {} requires positional argument")
 
 # Match Statement
 MISSING_MATCH_ARGS: Final = 'Class "{}" doesn\'t define "__match_args__"'
@@ -277,6 +291,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(
@@ -316,3 +331,37 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 ARG_NAME_EXPECTED_STRING_LITERAL: Final = ErrorMessage(
     "Expected string literal for argument name, got {}", codes.SYNTAX
 )
+NARROWED_TYPE_NOT_SUBTYPE: Final = ErrorMessage(
+    "Narrowed type {} is not a subtype of input type {}", codes.NARROWED_TYPE_NOT_SUBTYPE
+)
+TYPE_VAR_TOO_FEW_CONSTRAINED_TYPES: Final = ErrorMessage(
+    "Type variable must have at least two constrained types", codes.MISC
+)
+
+TYPE_VAR_YIELD_EXPRESSION_IN_BOUND: Final = ErrorMessage(
+    "Yield expression cannot be used as a type variable bound", codes.SYNTAX
+)
+
+TYPE_VAR_NAMED_EXPRESSION_IN_BOUND: Final = ErrorMessage(
+    "Named expression cannot be used as a type variable bound", codes.SYNTAX
+)
+
+TYPE_VAR_AWAIT_EXPRESSION_IN_BOUND: Final = ErrorMessage(
+    "Await expression cannot be used as a type variable bound", codes.SYNTAX
+)
+
+TYPE_VAR_GENERIC_CONSTRAINT_TYPE: Final = ErrorMessage(
+    "TypeVar constraint type cannot be parametrized by type variables", codes.MISC
+)
+
+TYPE_ALIAS_WITH_YIELD_EXPRESSION: Final = ErrorMessage(
+    "Yield expression cannot be used within a type alias", codes.SYNTAX
+)
+
+TYPE_ALIAS_WITH_NAMED_EXPRESSION: Final = ErrorMessage(
+    "Named expression cannot be used within a type alias", codes.SYNTAX
+)
+
+TYPE_ALIAS_WITH_AWAIT_EXPRESSION: Final = ErrorMessage(
+    "Await expression cannot be used within a type alias", codes.SYNTAX
+)
diff --git a/mypy/messages.py b/mypy/messages.py
index a732d612123c..2e07d7f63498 100644
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -14,10 +14,10 @@
 import difflib
 import itertools
 import re
+from collections.abc import Collection, Iterable, Iterator, Sequence
 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, Final, cast
 
 import mypy.typeops
 from mypy import errorcodes as codes, message_registry
@@ -56,6 +56,7 @@
 from mypy.subtypes import (
     IS_CLASS_OR_STATIC,
     IS_CLASSVAR,
+    IS_EXPLICIT_SETTER,
     IS_SETTABLE,
     IS_VAR,
     find_member,
@@ -84,12 +85,14 @@
     TypeOfAny,
     TypeStrVisitor,
     TypeType,
+    TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
     UnboundType,
     UninhabitedType,
     UnionType,
     UnpackType,
+    flatten_nested_unions,
     get_proper_type,
     get_proper_types,
 )
@@ -145,6 +148,9 @@
     "numbers.Integral",
 }
 
+MAX_TUPLE_ITEMS = 10
+MAX_UNION_ITEMS = 10
+
 
 class MessageBuilder:
     """Helper class for reporting type checker error messages with parameters.
@@ -181,9 +187,13 @@ def filter_errors(
         *,
         filter_errors: bool | Callable[[str, ErrorInfo], bool] = True,
         save_filtered_errors: bool = False,
+        filter_deprecated: bool = False,
     ) -> ErrorWatcher:
         return ErrorWatcher(
-            self.errors, filter_errors=filter_errors, save_filtered_errors=save_filtered_errors
+            self.errors,
+            filter_errors=filter_errors,
+            save_filtered_errors=save_filtered_errors,
+            filter_deprecated=filter_deprecated,
         )
 
     def add_errors(self, errors: list[ErrorInfo]) -> None:
@@ -205,7 +215,7 @@ def are_type_names_disabled(self) -> bool:
     def prefer_simple_messages(self) -> bool:
         """Should we generate simple/fast error messages?
 
-        If errors aren't shown to the user, we don't want to waste cyles producing
+        If errors aren't shown to the user, we don't want to waste cycles producing
         complex error messages.
         """
         return self.errors.prefer_simple_messages()
@@ -235,9 +245,11 @@ 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)
+                return range(ctx.line, ctx.line + 1)
             elif not isinstance(ctx, Expression):
                 return [ctx.line]
             else:
@@ -354,7 +366,7 @@ def has_no_attr(
         member: str,
         context: Context,
         module_symbol_table: SymbolTable | None = None,
-    ) -> Type:
+    ) -> ErrorCode | None:
         """Report a missing or non-accessible member.
 
         original_type is the top-level type on which the error occurred.
@@ -369,60 +381,67 @@ def has_no_attr(
         directly available on original_type
 
         If member corresponds to an operator, use the corresponding operator
-        name in the messages. Return type Any.
+        name in the messages. Return the error code that was produced, if any.
         """
         original_type = get_proper_type(original_type)
         typ = get_proper_type(typ)
 
         if isinstance(original_type, Instance) and original_type.type.has_readable_member(member):
             self.fail(f'Member "{member}" is not assignable', context)
+            return None
         elif member == "__contains__":
             self.fail(
                 f"Unsupported right operand type for in ({format_type(original_type, self.options)})",
                 context,
                 code=codes.OPERATOR,
             )
+            return codes.OPERATOR
         elif member in op_methods.values():
             # Access to a binary operator member (e.g. _add). This case does
             # not handle indexing operations.
             for op, method in op_methods.items():
                 if method == member:
                     self.unsupported_left_operand(op, original_type, context)
-                    break
+                    return codes.OPERATOR
         elif member == "__neg__":
             self.fail(
                 f"Unsupported operand type for unary - ({format_type(original_type, self.options)})",
                 context,
                 code=codes.OPERATOR,
             )
+            return codes.OPERATOR
         elif member == "__pos__":
             self.fail(
                 f"Unsupported operand type for unary + ({format_type(original_type, self.options)})",
                 context,
                 code=codes.OPERATOR,
             )
+            return codes.OPERATOR
         elif member == "__invert__":
             self.fail(
                 f"Unsupported operand type for ~ ({format_type(original_type, self.options)})",
                 context,
                 code=codes.OPERATOR,
             )
+            return codes.OPERATOR
         elif member == "__getitem__":
             # Indexed get.
             # TODO: Fix this consistently in format_type
-            if isinstance(original_type, CallableType) and original_type.is_type_obj():
+            if isinstance(original_type, FunctionLike) and original_type.is_type_obj():
                 self.fail(
                     "The type {} is not generic and not indexable".format(
                         format_type(original_type, self.options)
                     ),
                     context,
                 )
+                return None
             else:
                 self.fail(
                     f"Value of type {format_type(original_type, self.options)} is not indexable",
                     context,
                     code=codes.INDEX,
                 )
+                return codes.INDEX
         elif member == "__setitem__":
             # Indexed set.
             self.fail(
@@ -432,6 +451,7 @@ def has_no_attr(
                 context,
                 code=codes.INDEX,
             )
+            return codes.INDEX
         elif member == "__call__":
             if isinstance(original_type, Instance) and (
                 original_type.type.fullname == "builtins.function"
@@ -439,12 +459,14 @@ def has_no_attr(
                 # "'function' not callable" is a confusing error message.
                 # Explain that the problem is that the type of the function is not known.
                 self.fail("Cannot call function of unknown type", context, code=codes.OPERATOR)
+                return codes.OPERATOR
             else:
                 self.fail(
                     message_registry.NOT_CALLABLE.format(format_type(original_type, self.options)),
                     context,
                     code=codes.OPERATOR,
                 )
+                return codes.OPERATOR
         else:
             # The non-special case: a missing ordinary attribute.
             extra = ""
@@ -500,6 +522,7 @@ def has_no_attr(
                         context,
                         code=codes.ATTR_DEFINED,
                     )
+                return codes.ATTR_DEFINED
             elif isinstance(original_type, UnionType):
                 # The checker passes "object" in lieu of "None" for attribute
                 # checks, so we manually convert it back.
@@ -517,6 +540,7 @@ def has_no_attr(
                     context,
                     code=codes.UNION_ATTR,
                 )
+                return codes.UNION_ATTR
             elif isinstance(original_type, TypeVarType):
                 bound = get_proper_type(original_type.upper_bound)
                 if isinstance(bound, UnionType):
@@ -530,6 +554,7 @@ def has_no_attr(
                         context,
                         code=codes.UNION_ATTR,
                     )
+                    return codes.UNION_ATTR
             else:
                 self.fail(
                     '{} has no attribute "{}"{}'.format(
@@ -538,7 +563,8 @@ def has_no_attr(
                     context,
                     code=codes.ATTR_DEFINED,
                 )
-        return AnyType(TypeOfAny.from_error)
+                return codes.ATTR_DEFINED
+        return None
 
     def unsupported_operand_types(
         self,
@@ -655,8 +681,7 @@ def incompatible_argument(
                         arg_type, callee.arg_types[n - 1], options=self.options
                     )
                     info = (
-                        f" (expression has type {arg_type_str}, "
-                        f"target has type {callee_type_str})"
+                        f" (expression has type {arg_type_str}, target has type {callee_type_str})"
                     )
                     error_msg = (
                         message_registry.INCOMPATIBLE_TYPES_IN_ASSIGNMENT.with_additional_msg(info)
@@ -851,7 +876,10 @@ def incompatible_argument_note(
             )
             if call:
                 self.note_call(original_caller_type, call, context, code=code)
-
+        if isinstance(callee_type, Instance) and callee_type.type.is_protocol:
+            call = find_member("__call__", callee_type, callee_type, is_operator=True)
+            if call:
+                self.note_call(callee_type, call, context, code=code)
         self.maybe_note_concatenate_pos_args(original_caller_type, callee_type, context, code)
 
     def maybe_note_concatenate_pos_args(
@@ -906,6 +934,17 @@ def invalid_index_type(
             code=code,
         )
 
+    def readonly_keys_mutated(self, keys: set[str], context: Context) -> None:
+        if len(keys) == 1:
+            suffix = "is"
+        else:
+            suffix = "are"
+        self.fail(
+            "ReadOnly {} TypedDict {} mutated".format(format_key_list(sorted(keys)), suffix),
+            code=codes.TYPEDDICT_READONLY_MUTATED,
+            context=context,
+        )
+
     def too_few_arguments(
         self, callee: CallableType, context: Context, argument_names: Sequence[str | None] | None
     ) -> None:
@@ -921,7 +960,7 @@ def too_few_arguments(
                 msg = "Missing positional arguments"
             callee_name = callable_name(callee)
             if callee_name is not None and diff and all(d is not None for d in diff):
-                args = '", "'.join(cast(List[str], diff))
+                args = '", "'.join(cast(list[str], diff))
                 msg += f' "{args}" in call to {callee_name}'
             else:
                 msg = "Too few arguments" + for_function(callee)
@@ -976,10 +1015,17 @@ def maybe_note_about_special_args(self, callee: CallableType, context: Context)
                 context,
             )
 
+    def unexpected_keyword_argument_for_function(
+        self, for_func: str, name: str, context: Context, *, matches: list[str] | None = None
+    ) -> None:
+        msg = f'Unexpected keyword argument "{name}"' + for_func
+        if matches:
+            msg += f"; did you mean {pretty_seq(matches, 'or')}?"
+        self.fail(msg, context, code=codes.CALL_ARG)
+
     def unexpected_keyword_argument(
         self, callee: CallableType, name: str, arg_type: Type, context: Context
     ) -> None:
-        msg = f'Unexpected keyword argument "{name}"' + for_function(callee)
         # Suggest intended keyword, look for type match else fallback on any match.
         matching_type_args = []
         not_matching_type_args = []
@@ -993,9 +1039,9 @@ def unexpected_keyword_argument(
         matches = best_matches(name, matching_type_args, n=3)
         if not matches:
             matches = best_matches(name, not_matching_type_args, n=3)
-        if matches:
-            msg += f"; did you mean {pretty_seq(matches, 'or')}?"
-        self.fail(msg, context, code=codes.CALL_ARG)
+        self.unexpected_keyword_argument_for_function(
+            for_function(callee), name, context, matches=matches
+        )
         module = find_defining_module(self.modules, callee)
         if module:
             assert callee.definition is not None
@@ -1020,18 +1066,11 @@ def duplicate_argument_value(self, callee: CallableType, index: int, context: Co
 
     def does_not_return_value(self, callee_type: Type | None, context: Context) -> None:
         """Report an error about use of an unusable type."""
-        name: str | None = None
         callee_type = get_proper_type(callee_type)
-        if isinstance(callee_type, FunctionLike):
-            name = callable_name(callee_type)
-        if name is not None:
-            self.fail(
-                f"{capitalize(name)} does not return a value",
-                context,
-                code=codes.FUNC_RETURNS_VALUE,
-            )
-        else:
-            self.fail("Function does not return a value", context, code=codes.FUNC_RETURNS_VALUE)
+        callee_name = callable_name(callee_type) if isinstance(callee_type, FunctionLike) else None
+        name = callee_name or "Function"
+        message = f"{name} does not return a value (it only ever returns None)"
+        self.fail(message, context, code=codes.FUNC_RETURNS_VALUE)
 
     def deleted_as_rvalue(self, typ: DeletedType, context: Context) -> None:
         """Report an error about using an deleted type as an rvalue."""
@@ -1113,8 +1152,8 @@ def unpacking_strings_disallowed(self, context: Context) -> None:
     def type_not_iterable(self, type: Type, context: Context) -> None:
         self.fail(f"{format_type(type, self.options)} object is not iterable", context)
 
-    def possible_missing_await(self, context: Context) -> None:
-        self.note('Maybe you forgot to use "await"?', context)
+    def possible_missing_await(self, context: Context, code: ErrorCode | None) -> None:
+        self.note('Maybe you forgot to use "await"?', context, code=code)
 
     def incompatible_operator_assignment(self, op: str, context: Context) -> None:
         self.fail(f"Result type of {op} incompatible in assignment", context)
@@ -1130,6 +1169,20 @@ def overload_signature_incompatible_with_supertype(
         note_template = 'Overload variants must be defined in the same order as they are in "{}"'
         self.note(note_template.format(supertype), context, code=codes.OVERRIDE)
 
+    def incompatible_setter_override(
+        self, defn: Context, typ: Type, original_type: Type, base: TypeInfo
+    ) -> None:
+        self.fail("Incompatible override of a setter type", defn, code=codes.OVERRIDE)
+        base_str, override_str = format_type_distinctly(original_type, typ, options=self.options)
+        self.note(
+            f' (base class "{base.name}" defined the type as {base_str},',
+            defn,
+            code=codes.OVERRIDE,
+        )
+        self.note(f" override has type {override_str})", defn, code=codes.OVERRIDE)
+        if is_subtype(typ, original_type):
+            self.note(" Setter types should behave contravariantly", defn, code=codes.OVERRIDE)
+
     def signature_incompatible_with_supertype(
         self,
         name: str,
@@ -1253,18 +1306,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)
@@ -1306,6 +1362,22 @@ def return_type_incompatible_with_supertype(
             code=codes.OVERRIDE,
         )
 
+        original = get_proper_type(original)
+        override = get_proper_type(override)
+        if (
+            isinstance(original, Instance)
+            and isinstance(override, Instance)
+            and override.type.fullname == "typing.AsyncIterator"
+            and original.type.fullname == "typing.Coroutine"
+            and len(original.args) == 3
+            and original.args[2] == override
+        ):
+            self.note(f'Consider declaring "{name}" in {target} without "async"', context)
+            self.note(
+                "See https://mypy.readthedocs.io/en/stable/more_types.html#asynchronous-iterators",
+                context,
+            )
+
     def override_target(self, name: str, name_in_super: str, supertype: str) -> str:
         target = f'supertype "{supertype}"'
         if name_in_super != name:
@@ -1313,18 +1385,21 @@ def override_target(self, name: str, name_in_super: str, supertype: str) -> str:
         return target
 
     def incompatible_type_application(
-        self, expected_arg_count: int, actual_arg_count: int, context: Context
+        self, min_arg_count: int, max_arg_count: int, actual_arg_count: int, context: Context
     ) -> None:
-        if expected_arg_count == 0:
+        if max_arg_count == 0:
             self.fail("Type application targets a non-generic function or class", context)
-        elif actual_arg_count > expected_arg_count:
-            self.fail(
-                f"Type application has too many types ({expected_arg_count} expected)", context
-            )
+            return
+
+        if min_arg_count == max_arg_count:
+            s = f"{max_arg_count} expected"
         else:
-            self.fail(
-                f"Type application has too few types ({expected_arg_count} expected)", context
-            )
+            s = f"expected between {min_arg_count} and {max_arg_count}"
+
+        if actual_arg_count > max_arg_count:
+            self.fail(f"Type application has too many types ({s})", context)
+        else:
+            self.fail(f"Type application has too few types ({s})", context)
 
     def could_not_infer_type_arguments(
         self, callee_type: CallableType, n: int, context: Context
@@ -1342,7 +1417,7 @@ def could_not_infer_type_arguments(
             self.fail("Cannot infer function type argument", context)
 
     def invalid_var_arg(self, typ: Type, context: Context) -> None:
-        self.fail("List or tuple expected as variadic arguments", context)
+        self.fail("Expected iterable as variadic argument", context)
 
     def invalid_keyword_var_arg(self, typ: Type, is_mapping: bool, context: Context) -> None:
         typ = get_proper_type(typ)
@@ -1380,8 +1455,7 @@ def first_argument_for_super_must_be_type(self, actual: Type, context: Context)
 
     def unsafe_super(self, method: str, cls: str, ctx: Context) -> None:
         self.fail(
-            'Call to abstract method "{}" of "{}" with trivial body'
-            " via super() is unsafe".format(method, cls),
+            f'Call to abstract method "{method}" of "{cls}" with trivial body via super() is unsafe',
             ctx,
             code=codes.SAFE_SUPER,
         )
@@ -1441,20 +1515,19 @@ def cannot_determine_type_in_base(self, name: str, base: str, context: Context)
         self.fail(f'Cannot determine type of "{name}" in base class "{base}"', context)
 
     def no_formal_self(self, name: str, item: CallableType, context: Context) -> None:
+        type = format_type(item, self.options)
         self.fail(
-            'Attribute function "%s" with type %s does not accept self argument'
-            % (name, format_type(item, self.options)),
-            context,
+            f'Attribute function "{name}" with type {type} does not accept self argument', context
         )
 
     def incompatible_self_argument(
         self, name: str, arg: Type, sig: CallableType, is_classmethod: bool, context: Context
     ) -> None:
         kind = "class attribute function" if is_classmethod else "attribute function"
+        arg_type = format_type(arg, self.options)
+        sig_type = format_type(sig, self.options)
         self.fail(
-            'Invalid self argument %s to %s "%s" with type %s'
-            % (format_type(arg, self.options), kind, name, format_type(sig, self.options)),
-            context,
+            f'Invalid self argument {arg_type} to {kind} "{name}" with type {sig_type}', context
         )
 
     def incompatible_conditional_function_def(
@@ -1474,8 +1547,8 @@ def cannot_instantiate_abstract_class(
     ) -> None:
         attrs = format_string_list([f'"{a}"' for a in abstract_attributes])
         self.fail(
-            'Cannot instantiate abstract class "%s" with abstract '
-            "attribute%s %s" % (class_name, plural_s(abstract_attributes), attrs),
+            f'Cannot instantiate abstract class "{class_name}" with abstract '
+            f"attribute{plural_s(abstract_attributes)} {attrs}",
             context,
             code=codes.ABSTRACT,
         )
@@ -1521,13 +1594,25 @@ def no_overridable_method(self, name: str, context: Context) -> None:
             context,
         )
 
+    def explicit_override_decorator_missing(
+        self, name: str, base_name: str, context: Context
+    ) -> None:
+        self.fail(
+            f'Method "{name}" is not using @override '
+            f'but is overriding a method in class "{base_name}"',
+            context,
+            code=codes.EXPLICIT_OVERRIDE_REQUIRED,
+        )
+
     def final_cant_override_writable(self, name: str, ctx: Context) -> None:
         self.fail(f'Cannot override writable attribute "{name}" with a final one', ctx)
 
     def cant_override_final(self, name: str, base_name: str, ctx: Context) -> None:
         self.fail(
-            'Cannot override final attribute "{}"'
-            ' (previously declared in base class "{}")'.format(name, base_name),
+            (
+                f'Cannot override final attribute "{name}" '
+                f'(previously declared in base class "{base_name}")'
+            ),
             ctx,
         )
 
@@ -1577,12 +1662,21 @@ def overload_inconsistently_applies_decorator(self, decorator: str, context: Con
             context,
         )
 
-    def overloaded_signatures_overlap(self, index1: int, index2: int, context: Context) -> None:
+    def overloaded_signatures_overlap(
+        self, index1: int, index2: int, flip_note: bool, context: Context
+    ) -> None:
         self.fail(
             "Overloaded function signatures {} and {} overlap with "
             "incompatible return types".format(index1, index2),
             context,
+            code=codes.OVERLOAD_OVERLAP,
         )
+        if flip_note:
+            self.note(
+                "Flipping the order of overloads will fix this error",
+                context,
+                code=codes.OVERLOAD_OVERLAP,
+            )
 
     def overloaded_signature_will_never_match(
         self, index1: int, index2: int, context: Context
@@ -1593,6 +1687,7 @@ def overloaded_signature_will_never_match(
                 index1=index1, index2=index2
             ),
             context,
+            code=codes.OVERLOAD_CANNOT_MATCH,
         )
 
     def overloaded_signatures_typevar_specific(self, index: int, context: Context) -> None:
@@ -1604,15 +1699,16 @@ def overloaded_signatures_typevar_specific(self, index: int, context: Context) -
 
     def overloaded_signatures_arg_specific(self, index: int, context: Context) -> None:
         self.fail(
-            "Overloaded function implementation does not accept all possible arguments "
-            "of signature {}".format(index),
+            (
+                f"Overloaded function implementation does not accept all possible arguments "
+                f"of signature {index}"
+            ),
             context,
         )
 
     def overloaded_signatures_ret_specific(self, index: int, context: Context) -> None:
         self.fail(
-            "Overloaded function implementation cannot produce return type "
-            "of signature {}".format(index),
+            f"Overloaded function implementation cannot produce return type of signature {index}",
             context,
         )
 
@@ -1635,8 +1731,7 @@ def operator_method_signatures_overlap(
         context: Context,
     ) -> None:
         self.fail(
-            'Signatures of "{}" of "{}" and "{}" of {} '
-            "are unsafely overlapping".format(
+            'Signatures of "{}" of "{}" and "{}" of {} are unsafely overlapping'.format(
                 reverse_method,
                 reverse_class.name,
                 forward_method,
@@ -1714,7 +1809,6 @@ def need_annotation_for_var(
         self, node: SymbolNode, context: Context, python_version: tuple[int, int] | None = None
     ) -> None:
         hint = ""
-        has_variable_annotations = not python_version or python_version >= (3, 6)
         pep604_supported = not python_version or python_version >= (3, 10)
         # type to recommend the user adds
         recommended_type = None
@@ -1733,26 +1827,38 @@ def need_annotation_for_var(
                 alias = alias.split(".")[-1]
                 if alias == "Dict":
                     type_dec = f"{type_dec}, {type_dec}"
+                if self.options.use_lowercase_names():
+                    alias = alias.lower()
                 recommended_type = f"{alias}[{type_dec}]"
         if recommended_type is not None:
-            if has_variable_annotations:
-                hint = f' (hint: "{node.name}: {recommended_type} = ...")'
-            else:
-                hint = f' (hint: "{node.name} = ...  # type: {recommended_type}")'
-
-        if has_variable_annotations:
-            needed = "annotation"
-        else:
-            needed = "comment"
+            hint = f' (hint: "{node.name}: {recommended_type} = ...")'
 
         self.fail(
-            f'Need type {needed} for "{unmangle(node.name)}"{hint}',
+            f'Need type annotation for "{unmangle(node.name)}"{hint}',
             context,
             code=codes.VAR_ANNOTATED,
         )
 
     def explicit_any(self, ctx: Context) -> None:
-        self.fail('Explicit "Any" is not allowed', ctx)
+        self.fail('Explicit "Any" is not allowed', ctx, code=codes.EXPLICIT_ANY)
+
+    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,
@@ -1886,7 +1992,7 @@ def incorrect__exit__return(self, context: Context) -> None:
             code=codes.EXIT_RETURN,
         )
         self.note(
-            'Use "typing_extensions.Literal[False]" as the return type or change it to "None"',
+            'Use "typing.Literal[False]" as the return type or change it to "None"',
             context,
             code=codes.EXIT_RETURN,
         )
@@ -1914,8 +2020,7 @@ def bad_proto_variance(
         self, actual: int, tvar_name: str, expected: int, context: Context
     ) -> None:
         msg = capitalize(
-            '{} type variable "{}" used in protocol where'
-            " {} one is expected".format(
+            '{} type variable "{}" used in protocol where {} one is expected'.format(
                 variance_string(actual), tvar_name, variance_string(expected)
             )
         )
@@ -1998,11 +2103,20 @@ def redundant_expr(self, description: str, truthiness: bool, context: Context) -
     def impossible_intersection(
         self, formatted_base_class_list: str, reason: str, context: Context
     ) -> None:
-        template = "Subclass of {} cannot exist: would have {}"
+        template = "Subclass of {} cannot exist: {}"
         self.fail(
             template.format(formatted_base_class_list, reason), context, code=codes.UNREACHABLE
         )
 
+    def tvar_without_default_type(
+        self, tvar_name: str, last_tvar_name_with_default: str, context: Context
+    ) -> None:
+        self.fail(
+            f'"{tvar_name}" cannot appear after "{last_tvar_name_with_default}" '
+            "in type parameter list because it has no default type",
+            context,
+        )
+
     def report_protocol_problems(
         self,
         subtype: Instance | TupleType | TypedDictType | TypeType | CallableType,
@@ -2029,7 +2143,7 @@ def report_protocol_problems(
         if supertype.type.fullname in exclusions.get(type(subtype), []):
             return
         if any(isinstance(tp, UninhabitedType) for tp in get_proper_types(supertype.args)):
-            # We don't want to add notes for failed inference (e.g. Iterable[<nothing>]).
+            # We don't want to add notes for failed inference (e.g. Iterable[Never]).
             # This will be only confusing a user even more.
             return
 
@@ -2037,12 +2151,8 @@ def report_protocol_problems(
         is_module = False
         skip = []
         if isinstance(subtype, TupleType):
-            if not isinstance(subtype.partial_fallback, Instance):
-                return
             subtype = subtype.partial_fallback
         elif isinstance(subtype, TypedDictType):
-            if not isinstance(subtype.fallback, Instance):
-                return
             subtype = subtype.fallback
         elif isinstance(subtype, TypeType):
             if not isinstance(subtype.item, Instance):
@@ -2093,30 +2203,47 @@ def report_protocol_problems(
             return
 
         # Report member type conflicts
-        conflict_types = get_conflict_protocol_types(subtype, supertype, class_obj=class_obj)
+        conflict_types = get_conflict_protocol_types(
+            subtype, supertype, class_obj=class_obj, options=self.options
+        )
         if conflict_types and (
-            not is_subtype(subtype, erase_type(supertype))
+            not is_subtype(subtype, erase_type(supertype), options=self.options)
             or not subtype.type.defn.type_vars
             or not supertype.type.defn.type_vars
+            # Always show detailed message for ParamSpec
+            or subtype.type.has_param_spec_type
+            or supertype.type.has_param_spec_type
         ):
             type_name = format_type(subtype, self.options, module_names=True)
             self.note(f"Following member(s) of {type_name} have conflicts:", context, code=code)
-            for name, got, exp in conflict_types[:MAX_ITEMS]:
+            for name, got, exp, is_lvalue in conflict_types[:MAX_ITEMS]:
                 exp = get_proper_type(exp)
                 got = get_proper_type(got)
+                setter_suffix = " setter type" if is_lvalue else ""
                 if not isinstance(exp, (CallableType, Overloaded)) or not isinstance(
                     got, (CallableType, Overloaded)
                 ):
                     self.note(
-                        "{}: expected {}, got {}".format(
-                            name, *format_type_distinctly(exp, got, options=self.options)
+                        "{}: expected{} {}, got {}".format(
+                            name,
+                            setter_suffix,
+                            *format_type_distinctly(exp, got, options=self.options),
                         ),
                         context,
                         offset=OFFSET,
                         code=code,
                     )
+                    if is_lvalue and is_subtype(got, exp, options=self.options):
+                        self.note(
+                            "Setter types should behave contravariantly",
+                            context,
+                            offset=OFFSET,
+                            code=code,
+                        )
                 else:
-                    self.note("Expected:", context, offset=OFFSET, code=code)
+                    self.note(
+                        "Expected{}:".format(setter_suffix), context, offset=OFFSET, code=code
+                    )
                     if isinstance(exp, CallableType):
                         self.note(
                             pretty_callable(exp, self.options, skip_self=class_obj or is_module),
@@ -2149,15 +2276,17 @@ def report_protocol_problems(
         for name, subflags, superflags in conflict_flags[:MAX_ITEMS]:
             if not class_obj and IS_CLASSVAR in subflags and IS_CLASSVAR not in superflags:
                 self.note(
-                    "Protocol member {}.{} expected instance variable,"
-                    " got class variable".format(supertype.type.name, name),
+                    "Protocol member {}.{} expected instance variable, got class variable".format(
+                        supertype.type.name, name
+                    ),
                     context,
                     code=code,
                 )
             if not class_obj and IS_CLASSVAR in superflags and IS_CLASSVAR not in subflags:
                 self.note(
-                    "Protocol member {}.{} expected class variable,"
-                    " got instance variable".format(supertype.type.name, name),
+                    "Protocol member {}.{} expected class variable, got instance variable".format(
+                        supertype.type.name, name
+                    ),
                     context,
                     code=code,
                 )
@@ -2257,7 +2386,7 @@ def try_report_long_tuple_assignment_error(
         """
         if isinstance(subtype, TupleType):
             if (
-                len(subtype.items) > 10
+                len(subtype.items) > MAX_TUPLE_ITEMS
                 and isinstance(supertype, Instance)
                 and supertype.type.fullname == "builtins.tuple"
             ):
@@ -2266,7 +2395,7 @@ def try_report_long_tuple_assignment_error(
                 self.generate_incompatible_tuple_error(lhs_types, subtype.items, context, msg)
                 return True
             elif isinstance(supertype, TupleType) and (
-                len(subtype.items) > 10 or len(supertype.items) > 10
+                len(subtype.items) > MAX_TUPLE_ITEMS or len(supertype.items) > MAX_TUPLE_ITEMS
             ):
                 if len(subtype.items) != len(supertype.items):
                     if supertype_label is not None and subtype_label is not None:
@@ -2289,7 +2418,7 @@ def try_report_long_tuple_assignment_error(
     def format_long_tuple_type(self, typ: TupleType) -> str:
         """Format very long tuple type using an ellipsis notation"""
         item_cnt = len(typ.items)
-        if item_cnt > 10:
+        if item_cnt > MAX_TUPLE_ITEMS:
             return "{}[{}, {}, ... <{} more items>]".format(
                 "tuple" if self.options.use_lowercase_names() else "Tuple",
                 format_type_bare(typ.items[0], self.options),
@@ -2310,7 +2439,7 @@ def generate_incompatible_tuple_error(
         error_cnt = 0
         notes: list[str] = []
         for i, (lhs_t, rhs_t) in enumerate(zip(lhs_types, rhs_types)):
-            if not is_subtype(lhs_t, rhs_t):
+            if not is_subtype(rhs_t, lhs_t):
                 if error_cnt < 3:
                     notes.append(
                         "Expression tuple item {} has type {}; {} expected; ".format(
@@ -2349,12 +2478,20 @@ def annotation_in_unchecked_function(self, context: Context) -> None:
             code=codes.ANNOTATION_UNCHECKED,
         )
 
+    def type_parameters_should_be_declared(self, undeclared: list[str], context: Context) -> None:
+        names = ", ".join('"' + n + '"' for n in undeclared)
+        self.fail(
+            message_registry.TYPE_PARAMETERS_SHOULD_BE_DECLARED.format(names),
+            context,
+            code=codes.VALID_TYPE,
+        )
+
 
 def quote_type_string(type_string: str) -> str:
     """Quotes a type representation for use in messages."""
     no_quote_regex = r"^<(tuple|union): \d+ items>$"
     if (
-        type_string in ["Module", "overloaded function", "<nothing>", "<deleted>"]
+        type_string in ["Module", "overloaded function", "<deleted>"]
         or type_string.startswith("Module ")
         or re.match(no_quote_regex, type_string) is not None
         or type_string.endswith("?")
@@ -2408,11 +2545,21 @@ def format(typ: Type) -> str:
     def format_list(types: Sequence[Type]) -> str:
         return ", ".join(format(typ) for typ in types)
 
-    def format_union(types: Sequence[Type]) -> str:
+    def format_union_items(types: Sequence[Type]) -> list[str]:
         formatted = [format(typ) for typ in types if format(typ) != "None"]
+        if len(formatted) > MAX_UNION_ITEMS and verbosity == 0:
+            more = len(formatted) - MAX_UNION_ITEMS // 2
+            formatted = formatted[: MAX_UNION_ITEMS // 2]
+        else:
+            more = 0
+        if more:
+            formatted.append(f"<{more} more items>")
         if any(format(typ) == "None" for typ in types):
             formatted.append("None")
-        return " | ".join(formatted)
+        return formatted
+
+    def format_union(types: Sequence[Type]) -> str:
+        return " | ".join(format_union_items(types))
 
     def format_literal_value(typ: LiteralType) -> str:
         if typ.is_enum_literal():
@@ -2422,14 +2569,16 @@ def format_literal_value(typ: LiteralType) -> str:
             return typ.value_repr()
 
     if isinstance(typ, TypeAliasType) and typ.is_recursive:
-        # TODO: find balance here, str(typ) doesn't support custom verbosity, and may be
-        # too verbose for user messages, OTOH it nicely shows structure of recursive types.
-        if verbosity < 2:
-            type_str = typ.alias.name if typ.alias else "<alias (unfixed)>"
+        if typ.alias is None:
+            type_str = "<alias (unfixed)>"
+        else:
+            if verbosity >= 2 or (fullnames and typ.alias.fullname in fullnames):
+                type_str = typ.alias.fullname
+            else:
+                type_str = typ.alias.name
             if typ.args:
                 type_str += f"[{format_list(typ.args)}]"
-            return type_str
-        return str(typ)
+        return type_str
 
     # TODO: always mention type alias names in errors.
     typ = get_proper_type(typ)
@@ -2437,7 +2586,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:
@@ -2454,6 +2603,8 @@ def format_literal_value(typ: LiteralType) -> str:
         else:
             base_str = itype.type.name
         if not itype.args:
+            if itype.type.has_type_var_tuple_type and len(itype.type.type_vars) == 1:
+                return base_str + "[()]"
             # No type arguments, just return the type name
             return base_str
         elif itype.type.fullname == "builtins.tuple":
@@ -2463,12 +2614,20 @@ def format_literal_value(typ: LiteralType) -> str:
             # There are type arguments. Convert the arguments to strings.
             return f"{base_str}[{format_list(itype.args)}]"
     elif isinstance(typ, UnpackType):
+        if options.use_star_unpack():
+            return f"*{format(typ.type)}"
         return f"Unpack[{format(typ.type)}]"
     elif isinstance(typ, TypeVarType):
         # This is similar to non-generic instance types.
+        fullname = scoped_type_var_name(typ)
+        if verbosity >= 2 or (fullnames and fullname in fullnames):
+            return fullname
         return typ.name
     elif isinstance(typ, TypeVarTupleType):
         # This is similar to non-generic instance types.
+        fullname = scoped_type_var_name(typ)
+        if verbosity >= 2 or (fullnames and fullname in fullnames):
+            return fullname
         return typ.name
     elif isinstance(typ, ParamSpecType):
         # Concatenate[..., P]
@@ -2479,15 +2638,17 @@ def format_literal_value(typ: LiteralType) -> str:
 
             return f"[{args}, **{typ.name_with_suffix()}]"
         else:
+            # TODO: better disambiguate ParamSpec name clashes.
             return typ.name_with_suffix()
     elif isinstance(typ, TupleType):
         # Prefer the name of the fallback class (if not tuple), as it's more informative.
         if typ.partial_fallback.type.fullname != "builtins.tuple":
             return format(typ.partial_fallback)
+        type_items = format_list(typ.items) or "()"
         if options.use_lowercase_names():
-            s = f"tuple[{format_list(typ.items)}]"
+            s = f"tuple[{type_items}]"
         else:
-            s = f"Tuple[{format_list(typ.items)}]"
+            s = f"Tuple[{type_items}]"
         return s
     elif isinstance(typ, TypedDictType):
         # If the TypedDictType is named, return the name
@@ -2495,13 +2656,19 @@ def format_literal_value(typ: LiteralType) -> str:
             return format(typ.fallback)
         items = []
         for item_name, item_type in typ.items.items():
-            modifier = "" if item_name in typ.required_keys else "?"
+            modifier = ""
+            if item_name not in typ.required_keys:
+                modifier += "?"
+            if item_name in typ.readonly_keys:
+                modifier += "="
             items.append(f"{item_name!r}{modifier}: {format(item_type)}")
-        s = f"TypedDict({{{', '.join(items)}}})"
-        return s
+        return f"TypedDict({{{', '.join(items)}}})"
     elif isinstance(typ, LiteralType):
         return f"Literal[{format_literal_value(typ)}]"
     elif isinstance(typ, UnionType):
+        typ = get_proper_type(ignore_last_known_values(typ))
+        if not isinstance(typ, UnionType):
+            return format(typ)
         literal_items, union_items = separate_union_literals(typ)
 
         # Coalesce multiple Literal[] members. This also changes output order.
@@ -2521,7 +2688,7 @@ def format_literal_value(typ: LiteralType) -> str:
                 return (
                     f"{literal_str} | {format_union(union_items)}"
                     if options.use_or_syntax()
-                    else f"Union[{format_list(union_items)}, {literal_str}]"
+                    else f"Union[{', '.join(format_union_items(union_items))}, {literal_str}]"
                 )
             else:
                 return literal_str
@@ -2542,7 +2709,7 @@ def format_literal_value(typ: LiteralType) -> str:
                 s = (
                     format_union(typ.items)
                     if options.use_or_syntax()
-                    else f"Union[{format_list(typ.items)}]"
+                    else f"Union[{', '.join(format_union_items(typ.items))}]"
                 )
             return s
     elif isinstance(typ, NoneType):
@@ -2552,10 +2719,7 @@ def format_literal_value(typ: LiteralType) -> str:
     elif isinstance(typ, DeletedType):
         return "<deleted>"
     elif isinstance(typ, UninhabitedType):
-        if typ.is_noreturn:
-            return "NoReturn"
-        else:
-            return "<nothing>"
+        return "Never"
     elif isinstance(typ, TypeType):
         type_name = "type" if options.use_lowercase_names() else "Type"
         return f"{type_name}[{format(typ.item)}]"
@@ -2564,10 +2728,12 @@ def format_literal_value(typ: LiteralType) -> str:
         if func.is_type_obj():
             # The type of a type object type can be derived from the
             # return type (this always works).
-            return format(TypeType.make_normalized(erase_type(func.items[0].ret_type)))
+            return format(TypeType.make_normalized(func.items[0].ret_type))
         elif isinstance(func, CallableType):
             if func.type_guard is not None:
                 return_type = f"TypeGuard[{format(func.type_guard)}]"
+            elif func.type_is is not None:
+                return_type = f"TypeIs[{format(func.type_is)}]"
             else:
                 return_type = format(func.ret_type)
             if func.is_ellipsis_args:
@@ -2596,29 +2762,51 @@ def format_literal_value(typ: LiteralType) -> str:
         return "object"
 
 
-def collect_all_instances(t: Type) -> list[Instance]:
-    """Return all instances that `t` contains (including `t`).
+def collect_all_named_types(t: Type) -> list[Type]:
+    """Return all instances/aliases/type variables that `t` contains (including `t`).
 
     This is similar to collect_all_inner_types from typeanal but only
     returns instances and will recurse into fallbacks.
     """
-    visitor = CollectAllInstancesQuery()
+    visitor = CollectAllNamedTypesQuery()
     t.accept(visitor)
-    return visitor.instances
+    return visitor.types
 
 
-class CollectAllInstancesQuery(TypeTraverserVisitor):
+class CollectAllNamedTypesQuery(TypeTraverserVisitor):
     def __init__(self) -> None:
-        self.instances: list[Instance] = []
+        self.types: list[Type] = []
 
     def visit_instance(self, t: Instance) -> None:
-        self.instances.append(t)
+        self.types.append(t)
         super().visit_instance(t)
 
     def visit_type_alias_type(self, t: TypeAliasType) -> None:
         if t.alias and not t.is_recursive:
-            t.alias.target.accept(self)
-        super().visit_type_alias_type(t)
+            get_proper_type(t).accept(self)
+        else:
+            self.types.append(t)
+            super().visit_type_alias_type(t)
+
+    def visit_type_var(self, t: TypeVarType) -> None:
+        self.types.append(t)
+        super().visit_type_var(t)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
+        self.types.append(t)
+        super().visit_type_var_tuple(t)
+
+    def visit_param_spec(self, t: ParamSpecType) -> None:
+        self.types.append(t)
+        super().visit_param_spec(t)
+
+
+def scoped_type_var_name(t: TypeVarLikeType) -> str:
+    if not t.id.namespace:
+        return t.name
+    # TODO: support rare cases when both TypeVar name and namespace suffix coincide.
+    *_, suffix = t.id.namespace.split(".")
+    return f"{t.name}@{suffix}"
 
 
 def find_type_overlaps(*types: Type) -> set[str]:
@@ -2629,8 +2817,14 @@ def find_type_overlaps(*types: Type) -> set[str]:
     """
     d: dict[str, set[str]] = {}
     for type in types:
-        for inst in collect_all_instances(type):
-            d.setdefault(inst.type.name, set()).add(inst.type.fullname)
+        for t in collect_all_named_types(type):
+            if isinstance(t, ProperType) and isinstance(t, Instance):
+                d.setdefault(t.type.name, set()).add(t.type.fullname)
+            elif isinstance(t, TypeAliasType) and t.alias:
+                d.setdefault(t.alias.name, set()).add(t.alias.fullname)
+            else:
+                assert isinstance(t, TypeVarLikeType)
+                d.setdefault(t.name, set()).add(scoped_type_var_name(t))
     for shortname in d.keys():
         if f"typing.{shortname}" in TYPES_FOR_UNIMPORTED_HINTS:
             d[shortname].add(f"typing.{shortname}")
@@ -2648,7 +2842,7 @@ def format_type(
     """
     Convert a type to a relatively short string suitable for error messages.
 
-    `verbosity` is a coarse grained control on the verbosity of the type
+    `verbosity` is a coarse-grained control on the verbosity of the type
 
     This function returns a string appropriate for unmodified use in error
     messages; this means that it will be quoted in most cases.  If
@@ -2664,7 +2858,7 @@ def format_type_bare(
     """
     Convert a type to a relatively short string suitable for error messages.
 
-    `verbosity` is a coarse grained control on the verbosity of the type
+    `verbosity` is a coarse-grained control on the verbosity of the type
     `fullnames` specifies a set of names that should be printed in full
 
     This function will return an unquoted string.  If a caller doesn't need to
@@ -2688,7 +2882,29 @@ def format_type_distinctly(*types: Type, options: Options, bare: bool = False) -
     quoting them (such as prepending * or **) should use this.
     """
     overlapping = find_type_overlaps(*types)
-    for verbosity in range(2):
+
+    def format_single(arg: Type) -> str:
+        return format_type_inner(arg, verbosity=0, options=options, fullnames=overlapping)
+
+    min_verbosity = 0
+    # Prevent emitting weird errors like:
+    # ... has incompatible type "Callable[[int], Child]"; expected "Callable[[int], Parent]"
+    if len(types) == 2:
+        left, right = types
+        left = get_proper_type(left)
+        right = get_proper_type(right)
+        # If the right type has named arguments, they may be the reason for incompatibility.
+        # This excludes cases when right is Callable[[Something], None] without named args,
+        # because that's usually the right thing to do.
+        if (
+            isinstance(left, CallableType)
+            and isinstance(right, CallableType)
+            and any(right.arg_names)
+            and is_subtype(left, right, ignore_pos_arg_names=True)
+        ):
+            min_verbosity = 1
+
+    for verbosity in range(min_verbosity, 2):
         strs = [
             format_type_inner(type, verbosity=verbosity, options=options, fullnames=overlapping)
             for type in types
@@ -2756,7 +2972,11 @@ def [T <: int] f(self, x: int, y: T) -> None
             slash = True
 
     # If we got a "special arg" (i.e: self, cls, etc...), prepend it to the arg list
-    if isinstance(tp.definition, FuncDef) and hasattr(tp.definition, "arguments"):
+    if (
+        isinstance(tp.definition, FuncDef)
+        and hasattr(tp.definition, "arguments")
+        and not tp.from_concatenate
+    ):
         definition_arg_names = [arg.variable.name for arg in tp.definition.arguments]
         if (
             len(definition_arg_names) > len(tp.arg_names)
@@ -2780,6 +3000,8 @@ def [T <: int] f(self, x: int, y: T) -> None
     s += " -> "
     if tp.type_guard is not None:
         s += f"TypeGuard[{format_type_bare(tp.type_guard, options)}]"
+    elif tp.type_is is not None:
+        s += f"TypeIs[{format_type_bare(tp.type_is, options)}]"
     else:
         s += format_type_bare(tp.ret_type, options)
 
@@ -2788,14 +3010,14 @@ def [T <: int] f(self, x: int, y: T) -> None
         for tvar in tp.variables:
             if isinstance(tvar, TypeVarType):
                 upper_bound = get_proper_type(tvar.upper_bound)
-                if (
+                if not (
                     isinstance(upper_bound, Instance)
-                    and upper_bound.type.fullname != "builtins.object"
+                    and upper_bound.type.fullname == "builtins.object"
                 ):
-                    tvars.append(f"{tvar.name} <: {format_type_bare(upper_bound, options)}")
+                    tvars.append(f"{tvar.name}: {format_type_bare(upper_bound, options)}")
                 elif tvar.values:
                     tvars.append(
-                        "{} in ({})".format(
+                        "{}: ({})".format(
                             tvar.name,
                             ", ".join([format_type_bare(tp, options) for tp in tvar.values]),
                         )
@@ -2833,13 +3055,13 @@ def get_missing_protocol_members(left: Instance, right: Instance, skip: list[str
 
 
 def get_conflict_protocol_types(
-    left: Instance, right: Instance, class_obj: bool = False
-) -> list[tuple[str, Type, Type]]:
+    left: Instance, right: Instance, class_obj: bool = False, options: Options | None = None
+) -> list[tuple[str, Type, Type, bool]]:
     """Find members that are defined in 'left' but have incompatible types.
-    Return them as a list of ('member', 'got', 'expected').
+    Return them as a list of ('member', 'got', 'expected', 'is_lvalue').
     """
     assert right.type.is_protocol
-    conflicts: list[tuple[str, Type, Type]] = []
+    conflicts: list[tuple[str, Type, Type, bool]] = []
     for member in right.type.protocol_members:
         if member in ("__init__", "__new__"):
             continue
@@ -2848,11 +3070,30 @@ def get_conflict_protocol_types(
         subtype = mypy.typeops.get_protocol_member(left, member, class_obj)
         if not subtype:
             continue
-        is_compat = is_subtype(subtype, supertype, ignore_pos_arg_names=True)
-        if IS_SETTABLE in get_member_flags(member, right):
-            is_compat = is_compat and is_subtype(supertype, subtype)
+        is_compat = is_subtype(subtype, supertype, ignore_pos_arg_names=True, options=options)
         if not is_compat:
-            conflicts.append((member, subtype, supertype))
+            conflicts.append((member, subtype, supertype, False))
+        superflags = get_member_flags(member, right)
+        if IS_SETTABLE not in superflags:
+            continue
+        different_setter = False
+        if IS_EXPLICIT_SETTER in superflags:
+            set_supertype = find_member(member, right, left, is_lvalue=True)
+            if set_supertype and not is_same_type(set_supertype, supertype):
+                different_setter = True
+            supertype = set_supertype
+        if IS_EXPLICIT_SETTER in get_member_flags(member, left):
+            set_subtype = mypy.typeops.get_protocol_member(left, member, class_obj, is_lvalue=True)
+            if set_subtype and not is_same_type(set_subtype, subtype):
+                different_setter = True
+            subtype = set_subtype
+        if not is_compat and not different_setter:
+            # We already have this conflict listed, avoid duplicates.
+            continue
+        assert supertype is not None and subtype is not None
+        is_compat = is_subtype(supertype, subtype, options=options)
+        if not is_compat:
+            conflicts.append((member, subtype, supertype, different_setter))
     return conflicts
 
 
@@ -2950,12 +3191,15 @@ def for_function(callee: CallableType) -> str:
     return ""
 
 
-def wrong_type_arg_count(n: int, act: str, name: str) -> str:
-    s = f"{n} type arguments"
-    if n == 0:
-        s = "no type arguments"
-    elif n == 1:
-        s = "1 type argument"
+def wrong_type_arg_count(low: int, high: int, act: str, name: str) -> str:
+    if low == high:
+        s = f"{low} type arguments"
+        if low == 0:
+            s = "no type arguments"
+        elif low == 1:
+            s = "1 type argument"
+    else:
+        s = f"between {low} and {high} type arguments"
     if act == "0":
         act = "none"
     return f'"{name}" expects {s}, but {act} given'
@@ -2989,8 +3233,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]
@@ -3021,7 +3266,7 @@ def append_invariance_notes(
         and expected_type.type.fullname == "builtins.list"
         and is_subtype(arg_type.args[0], expected_type.args[0])
     ):
-        invariant_type = "List"
+        invariant_type = "list"
         covariant_suggestion = 'Consider using "Sequence" instead, which is covariant'
     elif (
         arg_type.type.fullname == "builtins.dict"
@@ -3029,9 +3274,9 @@ def append_invariance_notes(
         and is_same_type(arg_type.args[0], expected_type.args[0])
         and is_subtype(arg_type.args[1], expected_type.args[1])
     ):
-        invariant_type = "Dict"
+        invariant_type = "dict"
         covariant_suggestion = (
-            'Consider using "Mapping" instead, ' "which is covariant in the value type"
+            'Consider using "Mapping" instead, which is covariant in the value type'
         )
     if invariant_type and covariant_suggestion:
         notes.append(
@@ -3042,6 +3287,23 @@ def append_invariance_notes(
     return notes
 
 
+def append_union_note(
+    notes: list[str], arg_type: UnionType, expected_type: UnionType, options: Options
+) -> list[str]:
+    """Point to specific union item(s) that may cause failure in subtype check."""
+    non_matching = []
+    items = flatten_nested_unions(arg_type.items)
+    if len(items) < MAX_UNION_ITEMS:
+        return notes
+    for item in items:
+        if not is_subtype(item, expected_type):
+            non_matching.append(item)
+    if non_matching:
+        types = ", ".join([format_type(typ, options) for typ in non_matching])
+        notes.append(f"Item{plural_s(non_matching)} in the first union not in the second: {types}")
+    return notes
+
+
 def append_numbers_notes(
     notes: list[str], arg_type: Instance, expected_type: Instance
 ) -> list[str]:
@@ -3095,3 +3357,23 @@ def format_key_list(keys: list[str], *, short: bool = False) -> str:
         return f"{td}key {formatted_keys[0]}"
     else:
         return f"{td}keys ({', '.join(formatted_keys)})"
+
+
+def ignore_last_known_values(t: UnionType) -> Type:
+    """This will avoid types like str | str in error messages.
+
+    last_known_values are kept during union simplification, but may cause
+    weird formatting for e.g. tuples of literals.
+    """
+    union_items: list[Type] = []
+    seen_instances = set()
+    for item in t.items:
+        if isinstance(item, ProperType) and isinstance(item, Instance):
+            erased = item.copy_modified(last_known_value=None)
+            if erased in seen_instances:
+                continue
+            seen_instances.add(erased)
+            union_items.append(erased)
+        else:
+            union_items.append(item)
+    return UnionType.make_union(union_items, t.line, t.column)
diff --git a/mypy/metastore.py b/mypy/metastore.py
index 16cbd5adc9c8..442c7dc77461 100644
--- a/mypy/metastore.py
+++ b/mypy/metastore.py
@@ -14,7 +14,8 @@
 import os
 import time
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Iterable
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     # We avoid importing sqlite3 unless we are using it so we can mostly work
@@ -27,20 +28,20 @@ class MetadataStore:
 
     @abstractmethod
     def getmtime(self, name: str) -> float:
-        """Read the mtime of a metadata entry..
+        """Read the mtime of a metadata entry.
 
         Raises FileNotFound if the entry does not exist.
         """
 
     @abstractmethod
-    def read(self, name: str) -> str:
+    def read(self, name: str) -> bytes:
         """Read the contents of a metadata entry.
 
         Raises FileNotFound if the entry does not exist.
         """
 
     @abstractmethod
-    def write(self, name: str, data: str, mtime: float | None = None) -> bool:
+    def write(self, name: str, data: bytes, mtime: float | None = None) -> bool:
         """Write a metadata entry.
 
         If mtime is specified, set it as the mtime of the entry. Otherwise,
@@ -63,8 +64,7 @@ def commit(self) -> None:
         """
 
     @abstractmethod
-    def list_all(self) -> Iterable[str]:
-        ...
+    def list_all(self) -> Iterable[str]: ...
 
 
 def random_string() -> str:
@@ -87,16 +87,16 @@ def getmtime(self, name: str) -> float:
 
         return int(os.path.getmtime(os.path.join(self.cache_dir_prefix, name)))
 
-    def read(self, name: str) -> str:
+    def read(self, name: str) -> bytes:
         assert os.path.normpath(name) != os.path.abspath(name), "Don't use absolute paths!"
 
         if not self.cache_dir_prefix:
             raise FileNotFoundError()
 
-        with open(os.path.join(self.cache_dir_prefix, name)) as f:
+        with open(os.path.join(self.cache_dir_prefix, name), "rb") as f:
             return f.read()
 
-    def write(self, name: str, data: str, mtime: float | None = None) -> bool:
+    def write(self, name: str, data: bytes, mtime: float | None = None) -> bool:
         assert os.path.normpath(name) != os.path.abspath(name), "Don't use absolute paths!"
 
         if not self.cache_dir_prefix:
@@ -106,13 +106,13 @@ def write(self, name: str, data: str, mtime: float | None = None) -> bool:
         tmp_filename = path + "." + random_string()
         try:
             os.makedirs(os.path.dirname(path), exist_ok=True)
-            with open(tmp_filename, "w") as f:
+            with open(tmp_filename, "wb") as f:
                 f.write(data)
             os.replace(tmp_filename, path)
             if mtime is not None:
                 os.utime(path, times=(mtime, mtime))
 
-        except os.error:
+        except OSError:
             return False
         return True
 
@@ -132,19 +132,17 @@ def list_all(self) -> Iterable[str]:
         for dir, _, files in os.walk(self.cache_dir_prefix):
             dir = os.path.relpath(dir, self.cache_dir_prefix)
             for file in files:
-                yield os.path.join(dir, file)
+                yield os.path.normpath(os.path.join(dir, file))
 
 
 SCHEMA = """
-CREATE TABLE IF NOT EXISTS files (
+CREATE TABLE IF NOT EXISTS files2 (
     path TEXT UNIQUE NOT NULL,
     mtime REAL,
-    data TEXT
+    data BLOB
 );
-CREATE INDEX IF NOT EXISTS path_idx on files(path);
+CREATE INDEX IF NOT EXISTS path_idx on files2(path);
 """
-# No migrations yet
-MIGRATIONS: list[str] = []
 
 
 def connect_db(db_file: str) -> sqlite3.Connection:
@@ -152,11 +150,6 @@ def connect_db(db_file: str) -> sqlite3.Connection:
 
     db = sqlite3.dbapi2.connect(db_file)
     db.executescript(SCHEMA)
-    for migr in MIGRATIONS:
-        try:
-            db.executescript(migr)
-        except sqlite3.OperationalError:
-            pass
     return db
 
 
@@ -177,7 +170,7 @@ def _query(self, name: str, field: str) -> Any:
         if not self.db:
             raise FileNotFoundError()
 
-        cur = self.db.execute(f"SELECT {field} FROM files WHERE path = ?", (name,))
+        cur = self.db.execute(f"SELECT {field} FROM files2 WHERE path = ?", (name,))
         results = cur.fetchall()
         if not results:
             raise FileNotFoundError()
@@ -189,12 +182,12 @@ def getmtime(self, name: str) -> float:
         assert isinstance(mtime, float)
         return mtime
 
-    def read(self, name: str) -> str:
+    def read(self, name: str) -> bytes:
         data = self._query(name, "data")
-        assert isinstance(data, str)
+        assert isinstance(data, bytes)
         return data
 
-    def write(self, name: str, data: str, mtime: float | None = None) -> bool:
+    def write(self, name: str, data: bytes, mtime: float | None = None) -> bool:
         import sqlite3
 
         if not self.db:
@@ -203,7 +196,7 @@ def write(self, name: str, data: str, mtime: float | None = None) -> bool:
             if mtime is None:
                 mtime = time.time()
             self.db.execute(
-                "INSERT OR REPLACE INTO files(path, mtime, data) VALUES(?, ?, ?)",
+                "INSERT OR REPLACE INTO files2(path, mtime, data) VALUES(?, ?, ?)",
                 (name, mtime, data),
             )
         except sqlite3.OperationalError:
@@ -214,7 +207,7 @@ def remove(self, name: str) -> None:
         if not self.db:
             raise FileNotFoundError()
 
-        self.db.execute("DELETE FROM files WHERE path = ?", (name,))
+        self.db.execute("DELETE FROM files2 WHERE path = ?", (name,))
 
     def commit(self) -> None:
         if self.db:
@@ -222,5 +215,5 @@ def commit(self) -> None:
 
     def list_all(self) -> Iterable[str]:
         if self.db:
-            for row in self.db.execute("SELECT path FROM files"):
+            for row in self.db.execute("SELECT path FROM files2"):
                 yield row[0]
diff --git a/mypy/mixedtraverser.py b/mypy/mixedtraverser.py
index 771f87fc6bd6..324e8a87c1bd 100644
--- a/mypy/mixedtraverser.py
+++ b/mypy/mixedtraverser.py
@@ -10,7 +10,9 @@
     NamedTupleExpr,
     NewTypeExpr,
     PromoteExpr,
+    TypeAlias,
     TypeAliasExpr,
+    TypeAliasStmt,
     TypeApplication,
     TypedDictExpr,
     TypeVarExpr,
@@ -30,14 +32,14 @@ def __init__(self) -> None:
 
     # Symbol nodes
 
-    def visit_var(self, var: Var) -> None:
+    def visit_var(self, var: Var, /) -> None:
         self.visit_optional_type(var.type)
 
-    def visit_func(self, o: FuncItem) -> None:
+    def visit_func(self, o: FuncItem, /) -> None:
         super().visit_func(o)
         self.visit_optional_type(o.type)
 
-    def visit_class_def(self, o: ClassDef) -> None:
+    def visit_class_def(self, o: ClassDef, /) -> None:
         # TODO: Should we visit generated methods/variables as well, either here or in
         #       TraverserVisitor?
         super().visit_class_def(o)
@@ -46,67 +48,76 @@ def visit_class_def(self, o: ClassDef) -> None:
             for base in info.bases:
                 base.accept(self)
 
-    def visit_type_alias_expr(self, o: TypeAliasExpr) -> None:
+    def visit_type_alias_expr(self, o: TypeAliasExpr, /) -> None:
         super().visit_type_alias_expr(o)
-        self.in_type_alias_expr = True
-        o.type.accept(self)
-        self.in_type_alias_expr = False
+        o.node.accept(self)
 
-    def visit_type_var_expr(self, o: TypeVarExpr) -> None:
+    def visit_type_var_expr(self, o: TypeVarExpr, /) -> None:
         super().visit_type_var_expr(o)
         o.upper_bound.accept(self)
         for value in o.values:
             value.accept(self)
 
-    def visit_typeddict_expr(self, o: TypedDictExpr) -> None:
+    def visit_typeddict_expr(self, o: TypedDictExpr, /) -> None:
         super().visit_typeddict_expr(o)
         self.visit_optional_type(o.info.typeddict_type)
 
-    def visit_namedtuple_expr(self, o: NamedTupleExpr) -> None:
+    def visit_namedtuple_expr(self, o: NamedTupleExpr, /) -> None:
         super().visit_namedtuple_expr(o)
         assert o.info.tuple_type
         o.info.tuple_type.accept(self)
 
-    def visit__promote_expr(self, o: PromoteExpr) -> None:
+    def visit__promote_expr(self, o: PromoteExpr, /) -> None:
         super().visit__promote_expr(o)
         o.type.accept(self)
 
-    def visit_newtype_expr(self, o: NewTypeExpr) -> None:
+    def visit_newtype_expr(self, o: NewTypeExpr, /) -> None:
         super().visit_newtype_expr(o)
         self.visit_optional_type(o.old_type)
 
     # Statements
 
-    def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
+    def visit_assignment_stmt(self, o: AssignmentStmt, /) -> None:
         super().visit_assignment_stmt(o)
         self.visit_optional_type(o.type)
 
-    def visit_for_stmt(self, o: ForStmt) -> None:
+    def visit_type_alias_stmt(self, o: TypeAliasStmt, /) -> None:
+        super().visit_type_alias_stmt(o)
+        if o.alias_node is not None:
+            o.alias_node.accept(self)
+
+    def visit_type_alias(self, o: TypeAlias, /) -> None:
+        super().visit_type_alias(o)
+        self.in_type_alias_expr = True
+        o.target.accept(self)
+        self.in_type_alias_expr = False
+
+    def visit_for_stmt(self, o: ForStmt, /) -> None:
         super().visit_for_stmt(o)
         self.visit_optional_type(o.index_type)
 
-    def visit_with_stmt(self, o: WithStmt) -> None:
+    def visit_with_stmt(self, o: WithStmt, /) -> None:
         super().visit_with_stmt(o)
         for typ in o.analyzed_types:
             typ.accept(self)
 
     # Expressions
 
-    def visit_cast_expr(self, o: CastExpr) -> None:
+    def visit_cast_expr(self, o: CastExpr, /) -> None:
         super().visit_cast_expr(o)
         o.type.accept(self)
 
-    def visit_assert_type_expr(self, o: AssertTypeExpr) -> None:
+    def visit_assert_type_expr(self, o: AssertTypeExpr, /) -> None:
         super().visit_assert_type_expr(o)
         o.type.accept(self)
 
-    def visit_type_application(self, o: TypeApplication) -> None:
+    def visit_type_application(self, o: TypeApplication, /) -> None:
         super().visit_type_application(o)
         for t in o.types:
             t.accept(self)
 
     # Helpers
 
-    def visit_optional_type(self, t: Type | None) -> None:
+    def visit_optional_type(self, t: Type | None, /) -> None:
         if t:
             t.accept(self)
diff --git a/mypy/modulefinder.py b/mypy/modulefinder.py
index e0406bffcc7b..3040276dea6d 100644
--- a/mypy/modulefinder.py
+++ b/mypy/modulefinder.py
@@ -13,38 +13,54 @@
 import subprocess
 import sys
 from enum import Enum, unique
+from typing import Final, Optional, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
-from mypy.errors import CompileError
-
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    import tomli as tomllib
-
-from typing import Dict, List, NamedTuple, Optional, Tuple, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from pathspec import PathSpec
+from pathspec.patterns.gitwildmatch import GitWildMatchPatternError
 
 from mypy import pyinfo
+from mypy.errors import CompileError
 from mypy.fscache import FileSystemCache
 from mypy.nodes import MypyFile
 from mypy.options import Options
-from mypy.stubinfo import approved_stub_package_exists
+from mypy.stubinfo import stub_distribution_name
+from mypy.util import os_path_join
 
 
 # Paths to be searched in find_module().
-class SearchPaths(NamedTuple):
-    python_path: tuple[str, ...]  # where user code is found
-    mypy_path: tuple[str, ...]  # from $MYPYPATH or config variable
-    package_path: tuple[str, ...]  # from get_site_packages_dirs()
-    typeshed_path: tuple[str, ...]  # paths in typeshed
+class SearchPaths:
+    def __init__(
+        self,
+        python_path: tuple[str, ...],
+        mypy_path: tuple[str, ...],
+        package_path: tuple[str, ...],
+        typeshed_path: tuple[str, ...],
+    ) -> None:
+        # where user code is found
+        self.python_path = tuple(map(os.path.abspath, python_path))
+        # from $MYPYPATH or config variable
+        self.mypy_path = tuple(map(os.path.abspath, mypy_path))
+        # from get_site_packages_dirs()
+        self.package_path = tuple(map(os.path.abspath, package_path))
+        # paths in typeshed
+        self.typeshed_path = tuple(map(os.path.abspath, typeshed_path))
+
+    def asdict(self) -> dict[str, tuple[str, ...]]:
+        return {
+            "python_path": self.python_path,
+            "mypy_path": self.mypy_path,
+            "package_path": self.package_path,
+            "typeshed_path": self.typeshed_path,
+        }
 
 
 # Package dirs are a two-tuple of path to search and whether to verify the module
-OnePackageDir = Tuple[str, bool]
-PackageDirs = List[OnePackageDir]
+OnePackageDir = tuple[str, bool]
+PackageDirs = list[OnePackageDir]
 
 # Minimum and maximum Python versions for modules in stdlib as (major, minor)
-StdlibVersions: _TypeAlias = Dict[str, Tuple[Tuple[int, int], Optional[Tuple[int, int]]]]
+StdlibVersions: _TypeAlias = dict[str, tuple[tuple[int, int], Optional[tuple[int, int]]]]
 
 PYTHON_EXTENSIONS: Final = [".pyi", ".py"]
 
@@ -79,8 +95,7 @@ def error_message_templates(self, daemon: bool) -> tuple[str, list[str]]:
         elif self is ModuleNotFoundReason.WRONG_WORKING_DIRECTORY:
             msg = 'Cannot find implementation or library stub for module named "{module}"'
             notes = [
-                "You may be running mypy in a subpackage, "
-                "mypy should be run on the package root"
+                "You may be running mypy in a subpackage, mypy should be run on the package root"
             ]
         elif self is ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS:
             msg = (
@@ -212,7 +227,7 @@ def find_module_via_source_set(self, id: str) -> ModuleSearchResult | None:
             d = os.path.dirname(p)
             for _ in range(id.count(".")):
                 if not any(
-                    self.fscache.isfile(os.path.join(d, "__init__" + x)) for x in PYTHON_EXTENSIONS
+                    self.fscache.isfile(os_path_join(d, "__init__" + x)) for x in PYTHON_EXTENSIONS
                 ):
                     return None
                 d = os.path.dirname(d)
@@ -246,17 +261,17 @@ def find_module_via_source_set(self, id: str) -> ModuleSearchResult | None:
         return None
 
     def find_lib_path_dirs(self, id: str, lib_path: tuple[str, ...]) -> PackageDirs:
-        """Find which elements of a lib_path have the directory a module needs to exist.
-
-        This is run for the python_path, mypy_path, and typeshed_path search paths.
-        """
+        """Find which elements of a lib_path have the directory a module needs to exist."""
         components = id.split(".")
         dir_chain = os.sep.join(components[:-1])  # e.g., 'foo/bar'
 
         dirs = []
         for pathitem in self.get_toplevel_possibilities(lib_path, components[0]):
             # e.g., '/usr/lib/python3.4/foo/bar'
-            dir = os.path.normpath(os.path.join(pathitem, dir_chain))
+            if dir_chain:
+                dir = os_path_join(pathitem, dir_chain)
+            else:
+                dir = pathitem
             if self.fscache.isdir(dir):
                 dirs.append((dir, True))
         return dirs
@@ -305,13 +320,21 @@ def find_module(self, id: str, *, fast_path: bool = False) -> ModuleSearchResult
                 use_typeshed = self._typeshed_has_version(id)
             elif top_level in self.stdlib_py_versions:
                 use_typeshed = self._typeshed_has_version(top_level)
-            self.results[id] = self._find_module(id, use_typeshed)
-            if (
-                not (fast_path or (self.options is not None and self.options.fast_module_lookup))
-                and self.results[id] is ModuleNotFoundReason.NOT_FOUND
-                and self._can_find_module_in_parent_dir(id)
-            ):
-                self.results[id] = ModuleNotFoundReason.WRONG_WORKING_DIRECTORY
+            result, should_cache = self._find_module(id, use_typeshed)
+            if should_cache:
+                if (
+                    not (
+                        fast_path or (self.options is not None and self.options.fast_module_lookup)
+                    )
+                    and result is ModuleNotFoundReason.NOT_FOUND
+                    and self._can_find_module_in_parent_dir(id)
+                ):
+                    self.results[id] = ModuleNotFoundReason.WRONG_WORKING_DIRECTORY
+                else:
+                    self.results[id] = result
+                return self.results[id]
+            else:
+                return result
         return self.results[id]
 
     def _typeshed_has_version(self, module: str) -> bool:
@@ -322,13 +345,14 @@ def _typeshed_has_version(self, module: str) -> bool:
         return version >= min_version and (max_version is None or version <= max_version)
 
     def _find_module_non_stub_helper(
-        self, components: list[str], pkg_dir: str
+        self, id: str, pkg_dir: str
     ) -> OnePackageDir | ModuleNotFoundReason:
         plausible_match = False
         dir_path = pkg_dir
+        components = id.split(".")
         for index, component in enumerate(components):
-            dir_path = os.path.join(dir_path, component)
-            if self.fscache.isfile(os.path.join(dir_path, "py.typed")):
+            dir_path = os_path_join(dir_path, component)
+            if self.fscache.isfile(os_path_join(dir_path, "py.typed")):
                 return os.path.join(pkg_dir, *components[:-1]), index == 0
             elif not plausible_match and (
                 self.fscache.isdir(dir_path) or self.fscache.isfile(dir_path + ".py")
@@ -337,15 +361,11 @@ def _find_module_non_stub_helper(
             # If this is not a directory then we can't traverse further into it
             if not self.fscache.isdir(dir_path):
                 break
-        if approved_stub_package_exists(components[0]):
-            if len(components) == 1 or (
-                self.find_module(components[0])
-                is ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED
-            ):
-                return ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED
-        if approved_stub_package_exists(".".join(components[:2])):
-            return ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED
         if plausible_match:
+            if self.options:
+                module_specific_options = self.options.clone_for_module(id)
+                if module_specific_options.follow_untyped_imports:
+                    return os.path.join(pkg_dir, *components[:-1]), False
             return ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS
         else:
             return ModuleNotFoundReason.NOT_FOUND
@@ -372,11 +392,16 @@ def _can_find_module_in_parent_dir(self, id: str) -> bool:
         while any(is_init_file(file) for file in os.listdir(working_dir)):
             working_dir = os.path.dirname(working_dir)
             parent_search.search_paths = SearchPaths((working_dir,), (), (), ())
-            if not isinstance(parent_search._find_module(id, False), ModuleNotFoundReason):
+            if not isinstance(parent_search._find_module(id, False)[0], ModuleNotFoundReason):
                 return True
         return False
 
-    def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
+    def _find_module(self, id: str, use_typeshed: bool) -> tuple[ModuleSearchResult, bool]:
+        """Try to find a module in all available sources.
+
+        Returns:
+            ``(result, can_be_cached)`` pair.
+        """
         fscache = self.fscache
 
         # Fast path for any modules in the current source set.
@@ -412,7 +437,7 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
             else None
         )
         if p:
-            return p
+            return p, True
 
         # If we're looking for a module like 'foo.bar.baz', it's likely that most of the
         # many elements of lib_path don't even have a subdirectory 'foo/bar'.  Discover
@@ -426,13 +451,22 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
         third_party_inline_dirs: PackageDirs = []
         third_party_stubs_dirs: PackageDirs = []
         found_possible_third_party_missing_type_hints = False
-        need_installed_stubs = False
         # Third-party stub/typed packages
+        candidate_package_dirs = {
+            package_dir[0]
+            for component in (components[0], components[0] + "-stubs")
+            for package_dir in self.find_lib_path_dirs(component, self.search_paths.package_path)
+        }
+        # Caching FOUND_WITHOUT_TYPE_HINTS is not always safe. That causes issues with
+        # typed subpackages in namespace packages.
+        can_cache_any_result = True
         for pkg_dir in self.search_paths.package_path:
+            if pkg_dir not in candidate_package_dirs:
+                continue
             stub_name = components[0] + "-stubs"
-            stub_dir = os.path.join(pkg_dir, stub_name)
-            if fscache.isdir(stub_dir) and self._is_compatible_stub_package(stub_dir):
-                stub_typed_file = os.path.join(stub_dir, "py.typed")
+            stub_dir = os_path_join(pkg_dir, stub_name)
+            if fscache.isdir(stub_dir):
+                stub_typed_file = os_path_join(stub_dir, "py.typed")
                 stub_components = [stub_name] + components[1:]
                 path = os.path.join(pkg_dir, *stub_components[:-1])
                 if fscache.isdir(path):
@@ -442,7 +476,7 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
                         # Partial here means that mypy should look at the runtime
                         # package if installed.
                         if fscache.read(stub_typed_file).decode().strip() == "partial":
-                            runtime_path = os.path.join(pkg_dir, dir_chain)
+                            runtime_path = os_path_join(pkg_dir, dir_chain)
                             third_party_inline_dirs.append((runtime_path, True))
                             # if the package is partial, we don't verify the module, as
                             # the partial stub package may not have a __init__.pyi
@@ -453,15 +487,15 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
                             third_party_stubs_dirs.append((path, True))
                     else:
                         third_party_stubs_dirs.append((path, True))
-            non_stub_match = self._find_module_non_stub_helper(components, pkg_dir)
+            non_stub_match = self._find_module_non_stub_helper(id, pkg_dir)
             if isinstance(non_stub_match, ModuleNotFoundReason):
                 if non_stub_match is ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS:
                     found_possible_third_party_missing_type_hints = True
-                elif non_stub_match is ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED:
-                    need_installed_stubs = True
+                    can_cache_any_result = False
             else:
                 third_party_inline_dirs.append(non_stub_match)
                 self._update_ns_ancestors(components, non_stub_match)
+
         if self.options and self.options.use_builtins_fixtures:
             # Everything should be in fixtures.
             third_party_inline_dirs.clear()
@@ -489,21 +523,24 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
             dir_prefix = base_dir
             for _ in range(len(components) - 1):
                 dir_prefix = os.path.dirname(dir_prefix)
+
+            # Stubs-only packages always take precedence over py.typed packages
+            path_stubs = f"{base_path}-stubs{sepinit}.pyi"
+            if fscache.isfile_case(path_stubs, dir_prefix):
+                if verify and not verify_module(fscache, id, path_stubs, dir_prefix):
+                    near_misses.append((path_stubs, dir_prefix))
+                else:
+                    return path_stubs, True
+
             # Prefer package over module, i.e. baz/__init__.py* over baz.py*.
             for extension in PYTHON_EXTENSIONS:
                 path = base_path + sepinit + extension
-                path_stubs = base_path + "-stubs" + sepinit + extension
                 if fscache.isfile_case(path, dir_prefix):
                     has_init = True
                     if verify and not verify_module(fscache, id, path, dir_prefix):
                         near_misses.append((path, dir_prefix))
                         continue
-                    return path
-                elif fscache.isfile_case(path_stubs, dir_prefix):
-                    if verify and not verify_module(fscache, id, path_stubs, dir_prefix):
-                        near_misses.append((path_stubs, dir_prefix))
-                        continue
-                    return path_stubs
+                    return path, True
 
             # In namespace mode, register a potential namespace package
             if self.options and self.options.namespace_packages:
@@ -521,7 +558,7 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
                     if verify and not verify_module(fscache, id, path, dir_prefix):
                         near_misses.append((path, dir_prefix))
                         continue
-                    return path
+                    return path, True
 
         # In namespace mode, re-check those entries that had 'verify'.
         # Assume search path entries xxx, yyy and zzz, and we're
@@ -550,7 +587,7 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
                 for path, dir_prefix in near_misses
             ]
             index = levels.index(max(levels))
-            return near_misses[index][0]
+            return near_misses[index][0], True
 
         # Finally, we may be asked to produce an ancestor for an
         # installed package with a py.typed marker that is a
@@ -558,30 +595,30 @@ def _find_module(self, id: str, use_typeshed: bool) -> ModuleSearchResult:
         # if we would otherwise return "not found".
         ancestor = self.ns_ancestors.get(id)
         if ancestor is not None:
-            return ancestor
-
-        if need_installed_stubs:
-            return ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED
-        elif found_possible_third_party_missing_type_hints:
-            return ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS
-        else:
-            return ModuleNotFoundReason.NOT_FOUND
-
-    def _is_compatible_stub_package(self, stub_dir: str) -> bool:
-        """Does a stub package support the target Python version?
+            return ancestor, True
+
+        approved_dist_name = stub_distribution_name(id)
+        if approved_dist_name:
+            if len(components) == 1:
+                return ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED, True
+            # If we're a missing submodule of an already installed approved stubs, we don't want to
+            # error with APPROVED_STUBS_NOT_INSTALLED, but rather want to return NOT_FOUND.
+            for i in range(1, len(components)):
+                parent_id = ".".join(components[:i])
+                if stub_distribution_name(parent_id) == approved_dist_name:
+                    break
+            else:
+                return ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED, True
+            if self.find_module(parent_id) is ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED:
+                return ModuleNotFoundReason.APPROVED_STUBS_NOT_INSTALLED, True
+            return ModuleNotFoundReason.NOT_FOUND, True
 
-        Stub packages may contain a metadata file which specifies
-        whether the stubs are compatible with Python 2 and 3.
-        """
-        metadata_fnam = os.path.join(stub_dir, "METADATA.toml")
-        if not os.path.isfile(metadata_fnam):
-            return True
-        with open(metadata_fnam, "rb") as f:
-            metadata = tomllib.load(f)
-        return bool(metadata.get("python3", True))
+        if found_possible_third_party_missing_type_hints:
+            return ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS, can_cache_any_result
+        return ModuleNotFoundReason.NOT_FOUND, True
 
     def find_modules_recursive(self, module: str) -> list[BuildSource]:
-        module_path = self.find_module(module)
+        module_path = self.find_module(module, fast_path=True)
         if isinstance(module_path, ModuleNotFoundReason):
             return []
         sources = [BuildSource(module_path, module, None)]
@@ -605,18 +642,24 @@ def find_modules_recursive(self, module: str) -> list[BuildSource]:
             # Skip certain names altogether
             if name in ("__pycache__", "site-packages", "node_modules") or name.startswith("."):
                 continue
-            subpath = os.path.join(package_path, name)
+            subpath = os_path_join(package_path, name)
 
             if self.options and matches_exclude(
                 subpath, self.options.exclude, self.fscache, self.options.verbosity >= 2
             ):
                 continue
+            if (
+                self.options
+                and self.options.exclude_gitignore
+                and matches_gitignore(subpath, self.fscache, self.options.verbosity >= 2)
+            ):
+                continue
 
             if self.fscache.isdir(subpath):
                 # Only recurse into packages
                 if (self.options and self.options.namespace_packages) or (
-                    self.fscache.isfile(os.path.join(subpath, "__init__.py"))
-                    or self.fscache.isfile(os.path.join(subpath, "__init__.pyi"))
+                    self.fscache.isfile(os_path_join(subpath, "__init__.py"))
+                    or self.fscache.isfile(os_path_join(subpath, "__init__.pyi"))
                 ):
                     seen.add(name)
                     sources.extend(self.find_modules_recursive(module + "." + name))
@@ -650,6 +693,42 @@ def matches_exclude(
     return False
 
 
+def matches_gitignore(subpath: str, fscache: FileSystemCache, verbose: bool) -> bool:
+    dir, _ = os.path.split(subpath)
+    for gi_path, gi_spec in find_gitignores(dir):
+        relative_path = os.path.relpath(subpath, gi_path)
+        if fscache.isdir(relative_path):
+            relative_path = relative_path + "/"
+        if gi_spec.match_file(relative_path):
+            if verbose:
+                print(
+                    f"TRACE: Excluding {relative_path} (matches .gitignore) in {gi_path}",
+                    file=sys.stderr,
+                )
+            return True
+    return False
+
+
+@functools.lru_cache
+def find_gitignores(dir: str) -> list[tuple[str, PathSpec]]:
+    parent_dir = os.path.dirname(dir)
+    if parent_dir == dir:
+        parent_gitignores = []
+    else:
+        parent_gitignores = find_gitignores(parent_dir)
+
+    gitignore = os.path.join(dir, ".gitignore")
+    if os.path.isfile(gitignore):
+        with open(gitignore) as f:
+            lines = f.readlines()
+        try:
+            return parent_gitignores + [(dir, PathSpec.from_lines("gitwildmatch", lines))]
+        except GitWildMatchPatternError:
+            print(f"error: could not parse {gitignore}", file=sys.stderr)
+            return parent_gitignores
+    return parent_gitignores
+
+
 def is_init_file(path: str) -> bool:
     return os.path.basename(path) in ("__init__.py", "__init__.pyi")
 
@@ -661,7 +740,7 @@ def verify_module(fscache: FileSystemCache, id: str, path: str, prefix: str) ->
     for i in range(id.count(".")):
         path = os.path.dirname(path)
         if not any(
-            fscache.isfile_case(os.path.join(path, f"__init__{extension}"), prefix)
+            fscache.isfile_case(os_path_join(path, f"__init__{extension}"), prefix)
             for extension in PYTHON_EXTENSIONS
         ):
             return False
@@ -676,7 +755,7 @@ def highest_init_level(fscache: FileSystemCache, id: str, path: str, prefix: str
     for i in range(id.count(".")):
         path = os.path.dirname(path)
         if any(
-            fscache.isfile_case(os.path.join(path, f"__init__{extension}"), prefix)
+            fscache.isfile_case(os_path_join(path, f"__init__{extension}"), prefix)
             for extension in PYTHON_EXTENSIONS
         ):
             level = i + 1
@@ -693,10 +772,13 @@ def mypy_path() -> list[str]:
 def default_lib_path(
     data_dir: str, pyversion: tuple[int, int], custom_typeshed_dir: str | None
 ) -> list[str]:
-    """Return default standard library search paths."""
+    """Return default standard library search paths. Guaranteed to be normalised."""
+
+    data_dir = os.path.abspath(data_dir)
     path: list[str] = []
 
     if custom_typeshed_dir:
+        custom_typeshed_dir = os.path.abspath(custom_typeshed_dir)
         typeshed_dir = os.path.join(custom_typeshed_dir, "stdlib")
         mypy_extensions_dir = os.path.join(custom_typeshed_dir, "stubs", "mypy-extensions")
         versions_file = os.path.join(typeshed_dir, "VERSIONS")
@@ -734,9 +816,9 @@ def default_lib_path(
     return path
 
 
-@functools.lru_cache(maxsize=None)
+@functools.cache
 def get_search_dirs(python_executable: str | None) -> tuple[list[str], list[str]]:
-    """Find package directories for given python.
+    """Find package directories for given python. Guaranteed to return absolute paths.
 
     This runs a subprocess call, which generates a list of the directories in sys.path.
     To avoid repeatedly calling a subprocess (which can be slow!) we
@@ -765,6 +847,7 @@ def get_search_dirs(python_executable: str | None) -> tuple[list[str], list[str]
             print(err.stdout)
             raise
         except OSError as err:
+            assert err.errno is not None
             reason = os.strerror(err.errno)
             raise CompileError(
                 [f"mypy: Invalid python executable '{python_executable}': {reason}"]
@@ -798,6 +881,7 @@ def compute_search_paths(
         root_dir = os.getenv("MYPY_TEST_PREFIX", None)
         if not root_dir:
             root_dir = os.path.dirname(os.path.dirname(__file__))
+        root_dir = os.path.abspath(root_dir)
         lib_path.appendleft(os.path.join(root_dir, "test-data", "unit", "lib-stub"))
     # alt_lib_path is used by some tests to bypass the normal lib_path mechanics.
     # If we don't have one, grab directories of source files.
@@ -867,11 +951,11 @@ def load_stdlib_py_versions(custom_typeshed_dir: str | None) -> StdlibVersions:
 
     None means there is no maximum version.
     """
-    typeshed_dir = custom_typeshed_dir or os.path.join(os.path.dirname(__file__), "typeshed")
-    stdlib_dir = os.path.join(typeshed_dir, "stdlib")
+    typeshed_dir = custom_typeshed_dir or os_path_join(os.path.dirname(__file__), "typeshed")
+    stdlib_dir = os_path_join(typeshed_dir, "stdlib")
     result = {}
 
-    versions_path = os.path.join(stdlib_dir, "VERSIONS")
+    versions_path = os_path_join(stdlib_dir, "VERSIONS")
     assert os.path.isfile(versions_path), (custom_typeshed_dir, versions_path, __file__)
     with open(versions_path) as f:
         for line in f:
@@ -895,6 +979,6 @@ def parse_version(version: str) -> tuple[int, int]:
 
 def typeshed_py_version(options: Options) -> tuple[int, int]:
     """Return Python version used for checking whether module supports typeshed."""
-    # Typeshed no longer covers Python 3.x versions before 3.7, so 3.7 is
+    # Typeshed no longer covers Python 3.x versions before 3.8, so 3.8 is
     # the earliest we can support.
-    return max(options.python_version, (3, 7))
+    return max(options.python_version, (3, 8))
diff --git a/mypy/moduleinspect.py b/mypy/moduleinspect.py
index b383fc9dc145..35db2132f66c 100644
--- a/mypy/moduleinspect.py
+++ b/mypy/moduleinspect.py
@@ -8,7 +8,7 @@
 import pkgutil
 import queue
 import sys
-from multiprocessing import Process, Queue
+from multiprocessing import Queue, get_context
 from types import ModuleType
 
 
@@ -39,6 +39,10 @@ def is_c_module(module: ModuleType) -> bool:
     return os.path.splitext(module.__dict__["__file__"])[-1] in [".so", ".pyd", ".dll"]
 
 
+def is_pyc_only(file: str | None) -> bool:
+    return bool(file and file.endswith(".pyc") and not os.path.exists(file[:-1]))
+
+
 class InspectError(Exception):
     pass
 
@@ -119,9 +123,13 @@ def __init__(self) -> None:
         self._start()
 
     def _start(self) -> None:
-        self.tasks: Queue[str] = Queue()
-        self.results: Queue[ModuleProperties | str] = Queue()
-        self.proc = Process(target=worker, args=(self.tasks, self.results, sys.path))
+        if sys.platform == "linux":
+            ctx = get_context("forkserver")
+        else:
+            ctx = get_context("spawn")
+        self.tasks: Queue[str] = ctx.Queue()
+        self.results: Queue[ModuleProperties | str] = ctx.Queue()
+        self.proc = ctx.Process(target=worker, args=(self.tasks, self.results, sys.path))
         self.proc.start()
         self.counter = 0  # Number of successful roundtrips
 
diff --git a/mypy/nodes.py b/mypy/nodes.py
index 8457e39b6aa1..2fb459142066 100644
--- a/mypy/nodes.py
+++ b/mypy/nodes.py
@@ -5,28 +5,16 @@
 import os
 from abc import abstractmethod
 from collections import defaultdict
+from collections.abc import Iterator, Sequence
 from enum import Enum, unique
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TypeVar,
-    Union,
-    cast,
-)
-from typing_extensions import Final, TypeAlias as _TypeAlias, TypeGuard
+from typing import TYPE_CHECKING, Any, Callable, Final, Optional, TypeVar, Union, cast
+from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
 
 from mypy_extensions import trait
 
 import mypy.strconv
 from mypy.options import Options
-from mypy.util import short_type
+from mypy.util import is_sunder, is_typeshed_file, short_type
 from mypy.visitor import ExpressionVisitor, NodeVisitor, StatementVisitor
 
 if TYPE_CHECKING:
@@ -80,7 +68,7 @@ def set_line(
 
 T = TypeVar("T")
 
-JsonDict: _TypeAlias = Dict[str, Any]
+JsonDict: _TypeAlias = dict[str, Any]
 
 
 # Symbol table node kinds
@@ -101,9 +89,14 @@ def set_line(
 REVEAL_TYPE: Final = 0
 REVEAL_LOCALS: Final = 1
 
-LITERAL_YES: Final = 2
-LITERAL_TYPE: Final = 1
-LITERAL_NO: Final = 0
+# Kinds of 'literal' expressions.
+#
+# Use the function mypy.literals.literal to calculate these.
+#
+# TODO: Can we make these less confusing?
+LITERAL_YES: Final = 2  # Value of expression known statically
+LITERAL_TYPE: Final = 1  # Type of expression can be narrowed (e.g. variable reference)
+LITERAL_NO: Final = 0  # None of the above
 
 node_kinds: Final = {LDEF: "Ldef", GDEF: "Gdef", MDEF: "Mdef", UNBOUND_IMPORTED: "UnboundImported"}
 inverse_node_kinds: Final = {_kind: _name for _name, _kind in node_kinds.items()}
@@ -116,6 +109,7 @@ def set_line(
     "__file__": "__builtins__.str",
     "__package__": "__builtins__.str",
     "__annotations__": None,  # dict[str, Any] bounded in add_implicit_module_attrs()
+    "__spec__": None,  # importlib.machinery.ModuleSpec bounded in add_implicit_module_attrs()
 }
 
 
@@ -137,18 +131,7 @@ def set_line(
 
 # This keeps track of the oldest supported Python version where the corresponding
 # alias source is available.
-type_aliases_source_versions: Final = {
-    "typing.List": (2, 7),
-    "typing.Dict": (2, 7),
-    "typing.Set": (2, 7),
-    "typing.FrozenSet": (2, 7),
-    "typing.ChainMap": (3, 3),
-    "typing.Counter": (2, 7),
-    "typing.DefaultDict": (2, 7),
-    "typing.Deque": (2, 7),
-    "typing.OrderedDict": (3, 7),
-    "typing.LiteralString": (3, 11),
-}
+type_aliases_source_versions: Final = {"typing.LiteralString": (3, 11)}
 
 # This keeps track of aliases in `typing_extensions`, which we treat specially.
 typing_extensions_aliases: Final = {
@@ -184,6 +167,8 @@ def get_nongen_builtins(python_version: tuple[int, int]) -> dict[str, str]:
     "typing_extensions.runtime_checkable",
 )
 
+LAMBDA_NAME: Final = "<lambda>"
+
 
 class Node(Context):
     """Common base class for all non-type parse tree nodes."""
@@ -191,18 +176,15 @@ class Node(Context):
     __slots__ = ()
 
     def __str__(self) -> str:
-        ans = self.accept(mypy.strconv.StrConv(options=Options()))
-        if ans is None:
-            return repr(self)
-        return ans
+        return self.accept(mypy.strconv.StrConv(options=Options()))
 
     def str_with_options(self, options: Options) -> str:
-        ans = self.accept(mypy.strconv.StrConv(options=options))
-        assert ans
-        return ans
+        a = self.accept(mypy.strconv.StrConv(options=options))
+        assert a
+        return a
 
     def accept(self, visitor: NodeVisitor[T]) -> T:
-        raise RuntimeError("Not implemented")
+        raise RuntimeError("Not implemented", type(self))
 
 
 @trait
@@ -212,7 +194,7 @@ class Statement(Node):
     __slots__ = ()
 
     def accept(self, visitor: StatementVisitor[T]) -> T:
-        raise RuntimeError("Not implemented")
+        raise RuntimeError("Not implemented", type(self))
 
 
 @trait
@@ -222,7 +204,7 @@ class Expression(Node):
     __slots__ = ()
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        raise RuntimeError("Not implemented")
+        raise RuntimeError("Not implemented", type(self))
 
 
 class FakeExpression(Expression):
@@ -272,7 +254,7 @@ def deserialize(cls, data: JsonDict) -> SymbolNode:
 
 
 # Items: fullname, related symbol table node, surrounding type (if any)
-Definition: _TypeAlias = Tuple[str, "SymbolTableNode", Optional["TypeInfo"]]
+Definition: _TypeAlias = tuple[str, "SymbolTableNode", Optional["TypeInfo"]]
 
 
 class MypyFile(SymbolNode):
@@ -287,12 +269,13 @@ class MypyFile(SymbolNode):
         "names",
         "imports",
         "ignored_lines",
-        "unreachable_lines",
+        "skipped_lines",
         "is_stub",
         "is_cache_skeleton",
         "is_partial_stub_package",
         "plugin_deps",
         "future_import_flags",
+        "_is_typeshed_file",
     )
 
     __match_args__ = ("name", "path", "defs")
@@ -314,8 +297,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?
@@ -328,6 +312,7 @@ class MypyFile(SymbolNode):
     plugin_deps: dict[str, set[str]]
     # Future imports defined in this file. Populated during semantic analysis.
     future_import_flags: set[str]
+    _is_typeshed_file: bool | None
 
     def __init__(
         self,
@@ -348,13 +333,14 @@ 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
         self.is_cache_skeleton = False
         self.is_partial_stub_package = False
         self.future_import_flags = set()
+        self._is_typeshed_file = None
 
     def local_definitions(self) -> Iterator[Definition]:
         """Return all definitions within the module (including nested).
@@ -380,6 +366,12 @@ def is_package_init_file(self) -> bool:
     def is_future_flag_set(self, flag: str) -> bool:
         return flag in self.future_import_flags
 
+    def is_typeshed_file(self, options: Options) -> bool:
+        # Cache result since this is called a lot
+        if self._is_typeshed_file is None:
+            self._is_typeshed_file = is_typeshed_file(options.abs_custom_typeshed_dir, self.path)
+        return self._is_typeshed_file
+
     def serialize(self) -> JsonDict:
         return {
             ".class": "MypyFile",
@@ -510,9 +502,10 @@ 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"
+        "is_type_check_only",  # Uses "@type_check_only"
         "_fullname",
     )
 
@@ -524,13 +517,13 @@ def __init__(self) -> None:
         # Original, not semantically analyzed type (used for reprocessing)
         self.unanalyzed_type: mypy.types.ProperType | None = None
         # If method, reference to TypeInfo
-        # TODO: Type should be Optional[TypeInfo]
         self.info = FUNC_NO_INFO
         self.is_property = False
         self.is_class = False
         self.is_static = False
         self.is_final = False
         self.is_explicit_override = False
+        self.is_type_check_only = False
         # Name with module prefix
         self._fullname = ""
 
@@ -557,21 +550,23 @@ class OverloadedFuncDef(FuncBase, SymbolNode, Statement):
     Overloaded variants must be consecutive in the source file.
     """
 
-    __slots__ = ("items", "unanalyzed_items", "impl")
+    __slots__ = ("items", "unanalyzed_items", "impl", "deprecated", "_is_trivial_self")
 
     items: list[OverloadPart]
     unanalyzed_items: list[OverloadPart]
     impl: OverloadPart | None
+    deprecated: str | None
 
     def __init__(self, items: list[OverloadPart]) -> None:
         super().__init__()
         self.items = items
         self.unanalyzed_items = items.copy()
         self.impl = None
+        self.deprecated = None
+        self._is_trivial_self: bool | None = None
         if items:
             # TODO: figure out how to reliably set end position (we don't know the impl here).
             self.set_line(items[0].line, items[0].column)
-        self.is_final = False
 
     @property
     def name(self) -> str:
@@ -582,6 +577,27 @@ def name(self) -> str:
             assert self.impl is not None
             return self.impl.name
 
+    @property
+    def is_trivial_self(self) -> bool:
+        """Check we can use bind_self() fast path for this overload.
+
+        This will return False if at least one overload:
+          * Has an explicit self annotation, or Self in signature.
+          * Has a non-trivial decorator.
+        """
+        if self._is_trivial_self is not None:
+            return self._is_trivial_self
+        for item in self.items:
+            if isinstance(item, FuncDef):
+                if not item.is_trivial_self:
+                    self._is_trivial_self = False
+                    return False
+            elif item.decorators or not item.func.is_trivial_self:
+                self._is_trivial_self = False
+                return False
+        self._is_trivial_self = True
+        return True
+
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_overloaded_func_def(self)
 
@@ -593,6 +609,7 @@ def serialize(self) -> JsonDict:
             "fullname": self._fullname,
             "impl": None if self.impl is None else self.impl.serialize(),
             "flags": get_flags(self, FUNCBASE_FLAGS),
+            "deprecated": self.deprecated,
         }
 
     @classmethod
@@ -612,9 +629,13 @@ def deserialize(cls, data: JsonDict) -> OverloadedFuncDef:
             res.type = typ
         res._fullname = data["fullname"]
         set_flags(res, data["flags"])
+        res.deprecated = data["deprecated"]
         # NOTE: res.info will be set in the fixup phase.
         return res
 
+    def is_dynamic(self) -> bool:
+        return all(item.is_dynamic() for item in self.items)
+
 
 class Argument(Node):
     """A single argument in a FuncItem."""
@@ -653,6 +674,30 @@ def set_line(
         self.variable.set_line(self.line, self.column, self.end_line, self.end_column)
 
 
+# These specify the kind of a TypeParam
+TYPE_VAR_KIND: Final = 0
+PARAM_SPEC_KIND: Final = 1
+TYPE_VAR_TUPLE_KIND: Final = 2
+
+
+class TypeParam:
+    __slots__ = ("name", "kind", "upper_bound", "values", "default")
+
+    def __init__(
+        self,
+        name: str,
+        kind: int,
+        upper_bound: mypy.types.Type | None,
+        values: list[mypy.types.Type],
+        default: mypy.types.Type | None,
+    ) -> None:
+        self.name = name
+        self.kind = kind
+        self.upper_bound = upper_bound
+        self.values = values
+        self.default = default
+
+
 FUNCITEM_FLAGS: Final = FUNCBASE_FLAGS + [
     "is_overload",
     "is_generator",
@@ -672,6 +717,7 @@ class FuncItem(FuncBase):
         "min_args",  # Minimum number of arguments
         "max_pos",  # Maximum number of positional arguments, -1 if no explicit
         # limit (*args not included)
+        "type_args",  # New-style type parameters (PEP 695)
         "body",  # Body of the function
         "is_overload",  # Is this an overload variant of function with more than
         # one overload variant?
@@ -689,12 +735,14 @@ def __init__(
         arguments: list[Argument] | None = None,
         body: Block | None = None,
         typ: mypy.types.FunctionLike | None = None,
+        type_args: list[TypeParam] | None = None,
     ) -> None:
         super().__init__()
         self.arguments = arguments or []
         self.arg_names = [None if arg.pos_only else arg.variable.name for arg in self.arguments]
         self.arg_kinds: list[ArgKind] = [arg.kind for arg in self.arguments]
         self.max_pos: int = self.arg_kinds.count(ARG_POS) + self.arg_kinds.count(ARG_OPT)
+        self.type_args: list[TypeParam] | None = type_args
         self.body: Block = body or Block([])
         self.type = typ
         self.unanalyzed_type = typ
@@ -721,6 +769,7 @@ def is_dynamic(self) -> bool:
     "is_decorated",
     "is_conditional",
     "is_trivial_body",
+    "is_trivial_self",
     "is_mypy_only",
 ]
 
@@ -744,11 +793,13 @@ class FuncDef(FuncItem, SymbolNode, Statement):
         "is_conditional",
         "abstract_status",
         "original_def",
-        "deco_line",
         "is_trivial_body",
+        "is_trivial_self",
         "is_mypy_only",
-        # Present only when a function is decorated with @typing.datasclass_transform or similar
+        # Present only when a function is decorated with @typing.dataclass_transform or similar
         "dataclass_transform_spec",
+        "docstring",
+        "deprecated",
     )
 
     __match_args__ = ("name", "arguments", "type", "body")
@@ -760,8 +811,9 @@ def __init__(
         arguments: list[Argument] | None = None,
         body: Block | None = None,
         typ: mypy.types.FunctionLike | None = None,
+        type_args: list[TypeParam] | None = None,
     ) -> None:
-        super().__init__(arguments, body, typ)
+        super().__init__(arguments, body, typ, type_args)
         self._name = name
         self.is_decorated = False
         self.is_conditional = False  # Defined conditionally (within block)?
@@ -769,14 +821,17 @@ def __init__(
         # Is this an abstract method with trivial body?
         # Such methods can't be called via super().
         self.is_trivial_body = False
-        self.is_final = False
         # Original conditional definition
         self.original_def: None | FuncDef | Var | Decorator = None
-        # Used for error reporting (to keep backward compatibility with pre-3.8)
-        self.deco_line: int | None = None
         # Definitions that appear in if TYPE_CHECKING are marked with this flag.
         self.is_mypy_only = False
         self.dataclass_transform_spec: DataclassTransformSpec | None = None
+        self.docstring: str | None = None
+        self.deprecated: str | None = None
+        # This is used to simplify bind_self() logic in trivial cases (which are
+        # the majority). In cases where self is not annotated and there are no Self
+        # in the signature we can simply drop the first argument.
+        self.is_trivial_self = False
 
     @property
     def name(self) -> str:
@@ -807,6 +862,7 @@ def serialize(self) -> JsonDict:
                 if self.dataclass_transform_spec is None
                 else self.dataclass_transform_spec.serialize()
             ),
+            "deprecated": self.deprecated,
         }
 
     @classmethod
@@ -834,6 +890,7 @@ def deserialize(cls, data: JsonDict) -> FuncDef:
             if data["dataclass_transform_spec"] is not None
             else None
         )
+        ret.deprecated = data["deprecated"]
         # Leave these uninitialized so that future uses will trigger an error
         del ret.arguments
         del ret.max_pos
@@ -843,7 +900,9 @@ def deserialize(cls, data: JsonDict) -> FuncDef:
 
 # All types that are both SymbolNodes and FuncBases. See the FuncBase
 # docstring for the rationale.
-SYMBOL_FUNCBASE_TYPES = (OverloadedFuncDef, FuncDef)
+# See https://github.com/python/mypy/pull/13607#issuecomment-1236357236
+# TODO: we want to remove this at some point and just use `FuncBase` ideally.
+SYMBOL_FUNCBASE_TYPES: Final = (OverloadedFuncDef, FuncDef)
 
 
 class Decorator(SymbolNode, Statement):
@@ -910,6 +969,9 @@ def deserialize(cls, data: JsonDict) -> Decorator:
         dec.is_overload = data["is_overload"]
         return dec
 
+    def is_dynamic(self) -> bool:
+        return self.func.is_dynamic()
+
 
 VAR_FLAGS: Final = [
     "is_self",
@@ -923,6 +985,7 @@ def deserialize(cls, data: JsonDict) -> Decorator:
     "is_classvar",
     "is_abstract_var",
     "is_final",
+    "is_index_var",
     "final_unset_in_class",
     "final_set_in_init",
     "explicit_self_type",
@@ -946,6 +1009,7 @@ class Var(SymbolNode):
         "_fullname",
         "info",
         "type",
+        "setter_type",
         "final_value",
         "is_self",
         "is_cls",
@@ -959,6 +1023,7 @@ class Var(SymbolNode):
         "is_classvar",
         "is_abstract_var",
         "is_final",
+        "is_index_var",
         "final_unset_in_class",
         "final_set_in_init",
         "is_suppressed_import",
@@ -979,6 +1044,8 @@ def __init__(self, name: str, type: mypy.types.Type | None = None) -> None:
         # TODO: Should be Optional[TypeInfo]
         self.info = VAR_NO_INFO
         self.type: mypy.types.Type | None = type  # Declared or inferred type, or None
+        # The setter type for settable properties.
+        self.setter_type: mypy.types.CallableType | None = None
         # Is this the first argument to an ordinary method (usually "self")?
         self.is_self = False
         # Is this the first argument to a classmethod (typically "cls")?
@@ -993,6 +1060,7 @@ def __init__(self, name: str, type: mypy.types.Type | None = None) -> None:
         self.is_settable_property = False
         self.is_classvar = False
         self.is_abstract_var = False
+        self.is_index_var = False
         # Set to true when this variable refers to a module we were unable to
         # parse for some reason (eg a silenced module)
         self.is_suppressed_import = False
@@ -1001,7 +1069,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
@@ -1032,6 +1100,10 @@ def name(self) -> str:
     def fullname(self) -> str:
         return self._fullname
 
+    def __repr__(self) -> str:
+        name = self.fullname or self.name
+        return f"<Var {name!r} at {hex(id(self))}>"
+
     def accept(self, visitor: NodeVisitor[T]) -> T:
         return visitor.visit_var(self)
 
@@ -1043,6 +1115,7 @@ def serialize(self) -> JsonDict:
             "name": self._name,
             "fullname": self._fullname,
             "type": None if self.type is None else self.type.serialize(),
+            "setter_type": None if self.setter_type is None else self.setter_type.serialize(),
             "flags": get_flags(self, VAR_FLAGS),
         }
         if self.final_value is not None:
@@ -1054,7 +1127,18 @@ def deserialize(cls, data: JsonDict) -> Var:
         assert data[".class"] == "Var"
         name = data["name"]
         type = None if data["type"] is None else mypy.types.deserialize_type(data["type"])
+        setter_type = (
+            None
+            if data["setter_type"] is None
+            else mypy.types.deserialize_type(data["setter_type"])
+        )
         v = Var(name, type)
+        assert (
+            setter_type is None
+            or isinstance(setter_type, mypy.types.ProperType)
+            and isinstance(setter_type, mypy.types.CallableType)
+        )
+        v.setter_type = setter_type
         v.is_ready = False  # Override True default set in __init__
         v._fullname = data["fullname"]
         set_flags(v, data["flags"])
@@ -1069,6 +1153,7 @@ class ClassDef(Statement):
         "name",
         "_fullname",
         "defs",
+        "type_args",
         "type_vars",
         "base_type_exprs",
         "removed_base_type_exprs",
@@ -1078,7 +1163,7 @@ class ClassDef(Statement):
         "keywords",
         "analyzed",
         "has_incompatible_baseclass",
-        "deco_line",
+        "docstring",
         "removed_statements",
     )
 
@@ -1087,6 +1172,9 @@ class ClassDef(Statement):
     name: str  # Name of the class without module prefix
     _fullname: str  # Fully qualified name of the class
     defs: Block
+    # New-style type parameters (PEP 695), unanalyzed
+    type_args: list[TypeParam] | None
+    # Semantically analyzed type parameters (all syntax variants)
     type_vars: list[mypy.types.TypeVarLikeType]
     # Base class expressions (not semantically analyzed -- can be arbitrary expressions)
     base_type_exprs: list[Expression]
@@ -1109,12 +1197,14 @@ def __init__(
         base_type_exprs: list[Expression] | None = None,
         metaclass: Expression | None = None,
         keywords: list[tuple[str, Expression]] | None = None,
+        type_args: list[TypeParam] | None = None,
     ) -> None:
         super().__init__()
         self.name = name
         self._fullname = ""
         self.defs = defs
         self.type_vars = type_vars or []
+        self.type_args = type_args
         self.base_type_exprs = base_type_exprs or []
         self.removed_base_type_exprs = []
         self.info = CLASSDEF_NO_INFO
@@ -1123,8 +1213,7 @@ def __init__(
         self.keywords = dict(keywords) if keywords else {}
         self.analyzed = None
         self.has_incompatible_baseclass = False
-        # Used for error reporting (to keep backwad compatibility with pre-3.8)
-        self.deco_line: int | None = None
+        self.docstring: str | None = None
         self.removed_statements = []
 
     @property
@@ -1152,7 +1241,7 @@ def serialize(self) -> JsonDict:
         }
 
     @classmethod
-    def deserialize(self, data: JsonDict) -> ClassDef:
+    def deserialize(cls, data: JsonDict) -> ClassDef:
         assert data[".class"] == "ClassDef"
         res = ClassDef(
             data["name"],
@@ -1206,7 +1295,7 @@ class Block(Statement):
 
     __match_args__ = ("body", "is_unreachable")
 
-    def __init__(self, body: list[Statement]) -> None:
+    def __init__(self, body: list[Statement], *, is_unreachable: bool = False) -> None:
         super().__init__()
         self.body = body
         # True if we can determine that this block is not executed during semantic
@@ -1214,7 +1303,7 @@ def __init__(self, body: list[Statement]) -> None:
         # something like "if PY3:" when using Python 2. However, some code is
         # only considered unreachable during type checking and this is not true
         # in those cases.
-        self.is_unreachable = False
+        self.is_unreachable = is_unreachable
 
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_block(self)
@@ -1577,11 +1666,12 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
 
 
 class MatchStmt(Statement):
-    __slots__ = ("subject", "patterns", "guards", "bodies")
+    __slots__ = ("subject", "subject_dummy", "patterns", "guards", "bodies")
 
     __match_args__ = ("subject", "patterns", "guards", "bodies")
 
     subject: Expression
+    subject_dummy: NameExpr | None
     patterns: list[Pattern]
     guards: list[Expression | None]
     bodies: list[Block]
@@ -1596,6 +1686,7 @@ def __init__(
         super().__init__()
         assert len(patterns) == len(guards) == len(bodies)
         self.subject = subject
+        self.subject_dummy = None
         self.patterns = patterns
         self.guards = guards
         self.bodies = bodies
@@ -1604,6 +1695,29 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_match_stmt(self)
 
 
+class TypeAliasStmt(Statement):
+    __slots__ = ("name", "type_args", "value", "invalid_recursive_alias", "alias_node")
+
+    __match_args__ = ("name", "type_args", "value")
+
+    name: NameExpr
+    type_args: list[TypeParam]
+    value: LambdaExpr  # Return value will get translated into a type
+    invalid_recursive_alias: bool
+    alias_node: TypeAlias | None
+
+    def __init__(self, name: NameExpr, type_args: list[TypeParam], value: LambdaExpr) -> None:
+        super().__init__()
+        self.name = name
+        self.type_args = type_args
+        self.value = value
+        self.invalid_recursive_alias = False
+        self.alias_node = None
+
+    def accept(self, visitor: StatementVisitor[T]) -> T:
+        return visitor.visit_type_alias_stmt(self)
+
+
 # Expressions
 
 
@@ -1647,7 +1761,7 @@ def accept(self, visitor: ExpressionVisitor[T]) -> T:
         return visitor.visit_str_expr(self)
 
 
-def is_StrExpr_list(seq: list[Expression]) -> TypeGuard[list[StrExpr]]:
+def is_StrExpr_list(seq: list[Expression]) -> TypeGuard[list[StrExpr]]:  # noqa: N802
     return all(isinstance(item, StrExpr) for item in seq)
 
 
@@ -1752,6 +1866,7 @@ class RefExpr(Expression):
         "is_inferred_def",
         "is_alias_rvalue",
         "type_guard",
+        "type_is",
     )
 
     def __init__(self) -> None:
@@ -1773,6 +1888,8 @@ def __init__(self) -> None:
         self.is_alias_rvalue = False
         # Cache type guard from callable_type.type_guard
         self.type_guard: mypy.types.Type | None = None
+        # And same for TypeIs
+        self.type_is: mypy.types.Type | None = None
 
     @property
     def fullname(self) -> str:
@@ -1989,7 +2106,7 @@ class AssignmentExpr(Expression):
 
     __match_args__ = ("target", "value")
 
-    def __init__(self, target: Expression, value: Expression) -> None:
+    def __init__(self, target: NameExpr, value: Expression) -> None:
         super().__init__()
         self.target = target
         self.value = value
@@ -2143,21 +2260,26 @@ def accept(self, visitor: ExpressionVisitor[T]) -> T:
 class RevealExpr(Expression):
     """Reveal type expression reveal_type(expr) or reveal_locals() expression."""
 
-    __slots__ = ("expr", "kind", "local_nodes")
+    __slots__ = ("expr", "kind", "local_nodes", "is_imported")
 
-    __match_args__ = ("expr", "kind", "local_nodes")
+    __match_args__ = ("expr", "kind", "local_nodes", "is_imported")
 
     expr: Expression | None
     kind: int
     local_nodes: list[Var] | None
 
     def __init__(
-        self, kind: int, expr: Expression | None = None, local_nodes: list[Var] | None = None
+        self,
+        kind: int,
+        expr: Expression | None = None,
+        local_nodes: list[Var] | None = None,
+        is_imported: bool = False,
     ) -> None:
         super().__init__()
         self.expr = expr
         self.kind = kind
         self.local_nodes = local_nodes
+        self.is_imported = is_imported
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
         return visitor.visit_reveal_expr(self)
@@ -2191,7 +2313,7 @@ class LambdaExpr(FuncItem, Expression):
 
     @property
     def name(self) -> str:
-        return "<lambda>"
+        return LAMBDA_NAME
 
     def expr(self) -> Expression:
         """Return the expression (the body) of the lambda."""
@@ -2431,6 +2553,7 @@ def accept(self, visitor: ExpressionVisitor[T]) -> T:
 INVARIANT: Final = 0
 COVARIANT: Final = 1
 CONTRAVARIANT: Final = 2
+VARIANCE_NOT_READY: Final = 3  # Variance hasn't been inferred (using Python 3.12 syntax)
 
 
 class TypeVarLikeExpr(SymbolNode, Expression):
@@ -2439,7 +2562,7 @@ class TypeVarLikeExpr(SymbolNode, Expression):
     Note that they are constructed by the semantic analyzer.
     """
 
-    __slots__ = ("_name", "_fullname", "upper_bound", "default", "variance")
+    __slots__ = ("_name", "_fullname", "upper_bound", "default", "variance", "is_new_style")
 
     _name: str
     _fullname: str
@@ -2462,13 +2585,16 @@ def __init__(
         upper_bound: mypy.types.Type,
         default: mypy.types.Type,
         variance: int = INVARIANT,
+        is_new_style: bool = False,
+        line: int = -1,
     ) -> None:
-        super().__init__()
+        super().__init__(line=line)
         self._name = name
         self._fullname = fullname
         self.upper_bound = upper_bound
         self.default = default
         self.variance = variance
+        self.is_new_style = is_new_style
 
     @property
     def name(self) -> str:
@@ -2479,6 +2605,11 @@ def fullname(self) -> str:
         return self._fullname
 
 
+# All types that are both SymbolNodes and Expressions.
+# Use when common children of them are needed.
+SYMBOL_NODE_EXPRESSION_TYPES: Final = (TypeVarLikeExpr,)
+
+
 class TypeVarExpr(TypeVarLikeExpr):
     """Type variable expression TypeVar(...).
 
@@ -2493,7 +2624,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.
@@ -2507,8 +2638,10 @@ def __init__(
         upper_bound: mypy.types.Type,
         default: mypy.types.Type,
         variance: int = INVARIANT,
+        is_new_style: bool = False,
+        line: int = -1,
     ) -> None:
-        super().__init__(name, fullname, upper_bound, default, variance)
+        super().__init__(name, fullname, upper_bound, default, variance, is_new_style, line=line)
         self.values = values
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
@@ -2541,7 +2674,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 +2708,7 @@ class TypeVarTupleExpr(TypeVarLikeExpr):
 
     tuple_fallback: mypy.types.Instance
 
-    __match_args__ = ("name", "upper_bound")
+    __match_args__ = ("name", "upper_bound", "default")
 
     def __init__(
         self,
@@ -2585,8 +2718,10 @@ def __init__(
         tuple_fallback: mypy.types.Instance,
         default: mypy.types.Type,
         variance: int = INVARIANT,
+        is_new_style: bool = False,
+        line: int = -1,
     ) -> None:
-        super().__init__(name, fullname, upper_bound, default, variance)
+        super().__init__(name, fullname, upper_bound, default, variance, is_new_style, line=line)
         self.tuple_fallback = tuple_fallback
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
@@ -2619,27 +2754,14 @@ def deserialize(cls, data: JsonDict) -> TypeVarTupleExpr:
 class TypeAliasExpr(Expression):
     """Type alias expression (rvalue)."""
 
-    __slots__ = ("type", "tvars", "no_args", "node")
+    __slots__ = ("node",)
 
-    __match_args__ = ("type", "tvars", "no_args", "node")
+    __match_args__ = ("node",)
 
-    # The target type.
-    type: mypy.types.Type
-    # Names of type variables used to define the alias
-    tvars: list[str]
-    # Whether this alias was defined in bare form. Used to distinguish
-    # between
-    #     A = List
-    # and
-    #     A = List[Any]
-    no_args: bool
     node: TypeAlias
 
     def __init__(self, node: TypeAlias) -> None:
         super().__init__()
-        self.type = node.target
-        self.tvars = [v.name for v in node.alias_tvars]
-        self.no_args = node.no_args
         self.node = node
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
@@ -2801,6 +2923,29 @@ 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
+    }
+)
+
+# Attributes that can optionally be defined in the body of a subclass of
+# enum.Enum but are removed from the class __dict__ by EnumMeta.
+EXCLUDED_ENUM_ATTRIBUTES: Final = frozenset({"_ignore_", "_order_", "__order__"})
+
+
 class TypeInfo(SymbolNode):
     """The type structure of a single class.
 
@@ -2854,6 +2999,8 @@ class is generic then it will be a type constructor of higher kind.
         "type_var_tuple_suffix",
         "self_type",
         "dataclass_transform_spec",
+        "is_type_check_only",
+        "deprecated",
     )
 
     _fullname: str  # Fully qualified name
@@ -3004,6 +3151,12 @@ class is generic then it will be a type constructor of higher kind.
     # Added if the corresponding class is directly decorated with `typing.dataclass_transform`
     dataclass_transform_spec: DataclassTransformSpec | None
 
+    # Is set to `True` when class is decorated with `@typing.type_check_only`
+    is_type_check_only: bool
+
+    # The type's deprecation message (in case it is deprecated)
+    deprecated: str | None
+
     FLAGS: Final = [
         "is_abstract",
         "is_enum",
@@ -3060,6 +3213,8 @@ def __init__(self, names: SymbolTable, defn: ClassDef, module_name: str) -> None
         self.metadata = {}
         self.self_type = None
         self.dataclass_transform_spec = None
+        self.is_type_check_only = False
+        self.deprecated = None
 
     def add_type_vars(self) -> None:
         self.has_type_var_tuple_type = False
@@ -3073,9 +3228,6 @@ def add_type_vars(self) -> None:
                     self.type_var_tuple_prefix = i
                     self.type_var_tuple_suffix = len(self.defn.type_vars) - i - 1
                 self.type_vars.append(vd.name)
-        assert not (
-            self.has_param_spec_type and self.has_type_var_tuple_type
-        ), "Mixing type var tuples and param specs not supported yet"
 
     @property
     def name(self) -> str:
@@ -3115,8 +3267,62 @@ 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))
+        return sorted(members)
+
+    @property
+    def enum_members(self) -> list[str]:
+        # TODO: cache the results?
+        members = []
+        for name, sym in self.names.items():
+            # Case 1:
+            #
+            # class MyEnum(Enum):
+            #     @member
+            #     def some(self): ...
+            if isinstance(sym.node, Decorator):
+                if any(
+                    dec.fullname == "enum.member"
+                    for dec in sym.node.decorators
+                    if isinstance(dec, RefExpr)
+                ):
+                    members.append(name)
+                    continue
+            # Case 2:
+            #
+            # class MyEnum(Enum):
+            #     x = 1
+            #
+            # Case 3:
+            #
+            # class MyEnum(Enum):
+            #     class Other: ...
+            elif isinstance(sym.node, (Var, TypeInfo)):
+                if (
+                    # TODO: properly support ignored names from `_ignore_`
+                    name in EXCLUDED_ENUM_ATTRIBUTES
+                    or is_sunder(name)
+                    or name.startswith("__")  # dunder and private
+                ):
+                    continue  # name is excluded
+
+                if isinstance(sym.node, Var):
+                    if not sym.node.has_explicit_value:
+                        continue  # unannotated value not a member
+
+                    typ = mypy.types.get_proper_type(sym.node.type)
+                    if (
+                        isinstance(typ, mypy.types.FunctionLike) and not typ.is_type_obj()
+                    ) or (  # explicit `@member` is required
+                        isinstance(typ, mypy.types.Instance)
+                        and typ.type.fullname == "enum.nonmember"
+                    ):
+                        continue  # name is not a member
+
+                members.append(name)
+        return members
 
     def __getitem__(self, name: str) -> SymbolTableNode:
         n = self.get(name)
@@ -3141,7 +3347,7 @@ def get_method(self, name: str) -> FuncBase | Decorator | None:
         for cls in self.mro:
             if name in cls.names:
                 node = cls.names[name].node
-                if isinstance(node, FuncBase):
+                if isinstance(node, SYMBOL_FUNCBASE_TYPES):
                     return node
                 elif isinstance(node, Decorator):  # Two `if`s make `mypyc` happy
                     return node
@@ -3266,16 +3472,16 @@ def serialize(self) -> JsonDict:
             "declared_metaclass": (
                 None if self.declared_metaclass is None else self.declared_metaclass.serialize()
             ),
-            "metaclass_type": None
-            if self.metaclass_type is None
-            else self.metaclass_type.serialize(),
+            "metaclass_type": (
+                None if self.metaclass_type is None else self.metaclass_type.serialize()
+            ),
             "tuple_type": None if self.tuple_type is None else self.tuple_type.serialize(),
-            "typeddict_type": None
-            if self.typeddict_type is None
-            else self.typeddict_type.serialize(),
+            "typeddict_type": (
+                None if self.typeddict_type is None else self.typeddict_type.serialize()
+            ),
             "flags": get_flags(self, TypeInfo.FLAGS),
             "metadata": self.metadata,
-            "slots": list(sorted(self.slots)) if self.slots is not None else None,
+            "slots": sorted(self.slots) if self.slots is not None else None,
             "deletable_attributes": self.deletable_attributes,
             "self_type": self.self_type.serialize() if self.self_type is not None else None,
             "dataclass_transform_spec": (
@@ -3283,6 +3489,7 @@ def serialize(self) -> JsonDict:
                 if self.dataclass_transform_spec is not None
                 else None
             ),
+            "deprecated": self.deprecated,
         }
         return data
 
@@ -3350,6 +3557,7 @@ def deserialize(cls, data: JsonDict) -> TypeInfo:
             ti.dataclass_transform_spec = DataclassTransformSpec.deserialize(
                 data["dataclass_transform_spec"]
             )
+        ti.deprecated = data.get("deprecated")
         return ti
 
 
@@ -3389,6 +3597,7 @@ def __getattribute__(self, attr: str) -> type:
 VAR_NO_INFO: Final[TypeInfo] = FakeInfo("Var is lacking info")
 CLASSDEF_NO_INFO: Final[TypeInfo] = FakeInfo("ClassDef is lacking info")
 FUNC_NO_INFO: Final[TypeInfo] = FakeInfo("FuncBase for non-methods lack info")
+MISSING_FALLBACK: Final = FakeInfo("fallback can't be filled out until semanal")
 
 
 class TypeAlias(SymbolNode):
@@ -3462,7 +3671,7 @@ def f(x: B[T]) -> T: ...  # without T, Any would be used here
     type will be initially an instance type with wrong number of type arguments.
     Such instances are all fixed either during or after main semantic analysis passes.
     We therefore store the difference between `List` and `List[Any]` rvalues (targets)
-    using the `no_args` flag. See also TypeAliasExpr.no_args.
+    using the `no_args` flag.
 
     Meaning of other fields:
 
@@ -3489,6 +3698,7 @@ def f(x: B[T]) -> T: ...  # without T, Any would be used here
         "_is_recursive",
         "eager",
         "tvar_tuple_index",
+        "python_3_12_type_alias",
     )
 
     __match_args__ = ("name", "target", "alias_tvars", "no_args")
@@ -3504,6 +3714,7 @@ def __init__(
         no_args: bool = False,
         normalized: bool = False,
         eager: bool = False,
+        python_3_12_type_alias: bool = False,
     ) -> None:
         self._fullname = fullname
         self.target = target
@@ -3516,6 +3727,7 @@ def __init__(
         # it is the cached value.
         self._is_recursive: bool | None = None
         self.eager = eager
+        self.python_3_12_type_alias = python_3_12_type_alias
         self.tvar_tuple_index = None
         for i, t in enumerate(alias_tvars):
             if isinstance(t, mypy.types.TypeVarTupleType):
@@ -3532,7 +3744,12 @@ def from_tuple_type(cls, info: TypeInfo) -> TypeAlias:
         assert info.tuple_type
         # TODO: is it possible to refactor this to set the correct type vars here?
         return TypeAlias(
-            info.tuple_type.copy_modified(fallback=mypy.types.Instance(info, info.defn.type_vars)),
+            info.tuple_type.copy_modified(
+                # Create an Instance similar to fill_typevars().
+                fallback=mypy.types.Instance(
+                    info, mypy.types.type_vars_as_args(info.defn.type_vars)
+                )
+            ),
             info.fullname,
             info.line,
             info.column,
@@ -3549,7 +3766,10 @@ def from_typeddict_type(cls, info: TypeInfo) -> TypeAlias:
         # TODO: is it possible to refactor this to set the correct type vars here?
         return TypeAlias(
             info.typeddict_type.copy_modified(
-                fallback=mypy.types.Instance(info, info.defn.type_vars)
+                # Create an Instance similar to fill_typevars().
+                fallback=mypy.types.Instance(
+                    info, mypy.types.type_vars_as_args(info.defn.type_vars)
+                )
             ),
             info.fullname,
             info.line,
@@ -3578,6 +3798,7 @@ def serialize(self) -> JsonDict:
             "normalized": self.normalized,
             "line": self.line,
             "column": self.column,
+            "python_3_12_type_alias": self.python_3_12_type_alias,
         }
         return data
 
@@ -3595,14 +3816,16 @@ def deserialize(cls, data: JsonDict) -> TypeAlias:
         normalized = data["normalized"]
         line = data["line"]
         column = data["column"]
+        python_3_12_type_alias = data["python_3_12_type_alias"]
         return cls(
             target,
             fullname,
             line,
             column,
-            alias_tvars=cast(List[mypy.types.TypeVarLikeType], alias_tvars),
+            alias_tvars=cast(list[mypy.types.TypeVarLikeType], alias_tvars),
             no_args=no_args,
             normalized=normalized,
+            python_3_12_type_alias=python_3_12_type_alias,
         )
 
 
@@ -3802,6 +4025,8 @@ def __str__(self) -> str:
         # Include declared type of variables and functions.
         if self.type is not None:
             s += f" : {self.type}"
+        if self.cross_ref:
+            s += f" cross_ref:{self.cross_ref}"
         return s
 
     def serialize(self, prefix: str, name: str) -> JsonDict:
@@ -3862,7 +4087,7 @@ def deserialize(cls, data: JsonDict) -> SymbolTableNode:
         return stnode
 
 
-class SymbolTable(Dict[str, SymbolTableNode]):
+class SymbolTable(dict[str, SymbolTableNode]):
     """Static representation of a namespace dictionary.
 
     This is used for module, class and function namespaces.
@@ -3881,7 +4106,8 @@ def __str__(self) -> str:
                 ):
                     a.append("  " + str(key) + " : " + str(value))
             else:
-                a.append("  <invalid item>")
+                # Used in debugging:
+                a.append("  <invalid item>")  # type: ignore[unreachable]
         a = sorted(a)
         a.insert(0, "SymbolTable(")
         a[-1] += ")"
@@ -3935,7 +4161,7 @@ def __init__(
         # frozen_default was added to CPythonin https://github.com/python/cpython/pull/99958 citing
         # positive discussion in typing-sig
         frozen_default: bool | None = None,
-    ):
+    ) -> None:
         self.eq_default = eq_default if eq_default is not None else True
         self.order_default = order_default if order_default is not None else False
         self.kw_only_default = kw_only_default if kw_only_default is not None else False
@@ -3982,7 +4208,7 @@ def get_member_expr_fullname(expr: MemberExpr) -> str | None:
         initial = expr.expr.name
     elif isinstance(expr.expr, MemberExpr):
         initial = get_member_expr_fullname(expr.expr)
-    else:
+    if initial is None:
         return None
     return f"{initial}.{expr.name}"
 
diff --git a/mypy/operators.py b/mypy/operators.py
index 2b383ef199bb..d1f050b58fae 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 = {
@@ -101,3 +101,26 @@
 reverse_op_method_set: Final = set(reverse_op_methods.values())
 
 unary_op_methods: Final = {"-": "__neg__", "+": "__pos__", "~": "__invert__"}
+
+int_op_to_method: Final = {
+    "==": int.__eq__,
+    "is": int.__eq__,
+    "<": int.__lt__,
+    "<=": int.__le__,
+    "!=": int.__ne__,
+    "is not": int.__ne__,
+    ">": int.__gt__,
+    ">=": int.__ge__,
+}
+
+flip_ops: Final = {"<": ">", "<=": ">=", ">": "<", ">=": "<="}
+neg_ops: Final = {
+    "==": "!=",
+    "!=": "==",
+    "is": "is not",
+    "is not": "is",
+    "<": ">=",
+    "<=": ">",
+    ">": "<=",
+    ">=": "<",
+}
diff --git a/mypy/options.py b/mypy/options.py
index 45591597ba69..52afd27211ed 100644
--- a/mypy/options.py
+++ b/mypy/options.py
@@ -4,8 +4,9 @@
 import re
 import sys
 import sysconfig
-from typing import Any, Callable, Dict, Mapping, Pattern
-from typing_extensions import Final
+from collections.abc import Mapping
+from re import Pattern
+from typing import Any, Callable, Final
 
 from mypy import defaults
 from mypy.errorcodes import ErrorCode, error_codes
@@ -21,6 +22,7 @@ class BuildType:
 PER_MODULE_OPTIONS: Final = {
     # Please keep this list sorted
     "allow_redefinition",
+    "allow_redefinition_new",
     "allow_untyped_globals",
     "always_false",
     "always_true",
@@ -40,8 +42,10 @@ class BuildType:
     "disallow_untyped_defs",
     "enable_error_code",
     "enabled_error_codes",
+    "extra_checks",
     "follow_imports_for_stubs",
     "follow_imports",
+    "follow_untyped_imports",
     "ignore_errors",
     "ignore_missing_imports",
     "implicit_optional",
@@ -62,16 +66,22 @@ class BuildType:
     | {
         "platform",
         "bazel",
+        "old_type_inference",
         "plugins",
         "disable_bytearray_promotion",
         "disable_memoryview_promotion",
+        "strict_bytes",
     }
 ) - {"debug_cache"}
 
-# Features that are currently incomplete/experimental
+# Features that are currently (or were recently) incomplete/experimental
 TYPE_VAR_TUPLE: Final = "TypeVarTuple"
 UNPACK: Final = "Unpack"
-INCOMPLETE_FEATURES: Final = frozenset((TYPE_VAR_TUPLE, UNPACK))
+PRECISE_TUPLE_TYPES: Final = "PreciseTupleTypes"
+NEW_GENERIC_SYNTAX: Final = "NewGenericSyntax"
+INLINE_TYPEDDICT: Final = "InlineTypedDict"
+INCOMPLETE_FEATURES: Final = frozenset((PRECISE_TUPLE_TYPES, INLINE_TYPEDDICT))
+COMPLETE_FEATURES: Final = frozenset((TYPE_VAR_TUPLE, UNPACK, NEW_GENERIC_SYNTAX))
 
 
 class Options:
@@ -108,6 +118,8 @@ def __init__(self) -> None:
         self.ignore_missing_imports = False
         # Is ignore_missing_imports set in a per-module section
         self.ignore_missing_imports_per_module = False
+        # Typecheck modules without stubs or py.typed marker
+        self.follow_untyped_imports = False
         self.follow_imports = "normal"  # normal|silent|skip|error
         # Whether to respect the follow_imports setting even for stub files.
         # Intended to be used for disabling specific stubs.
@@ -125,6 +137,7 @@ def __init__(self) -> None:
         self.explicit_package_bases = False
         # File names, directory names or subpaths to avoid checking
         self.exclude: list[str] = []
+        self.exclude_gitignore: bool = False
 
         # disallow_any options
         self.disallow_any_generics = False
@@ -136,6 +149,10 @@ def __init__(self) -> None:
         # Disallow calling untyped functions from typed ones
         self.disallow_untyped_calls = False
 
+        # Always allow untyped calls for function coming from modules/packages
+        # in this list (each item effectively acts as a prefix match)
+        self.untyped_calls_exclude: list[str] = []
+
         # Disallow defining untyped (or incompletely typed) functions
         self.disallow_untyped_defs = False
 
@@ -164,6 +181,13 @@ def __init__(self) -> None:
         # declared with a precise type
         self.warn_return_any = False
 
+        # Report importing or using deprecated features as errors instead of notes.
+        self.report_deprecated_as_note = False
+
+        # Allow deprecated calls from function coming from modules/packages
+        # in this list (each item effectively acts as a prefix match)
+        self.deprecated_calls_exclude: list[str] = []
+
         # Warn about unused '# type: ignore' comments
         self.warn_unused_ignores = False
 
@@ -196,13 +220,23 @@ def __init__(self) -> None:
         # and the same nesting level as the initialization
         self.allow_redefinition = False
 
+        # Allow flexible variable redefinition with an arbitrary type, in different
+        # blocks and and at different nesting levels
+        self.allow_redefinition_new = False
+
         # Prohibit equality, identity, and container checks for non-overlapping types.
         # 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.
+        # Disable treating bytearray and memoryview as subtypes of bytes
+        self.strict_bytes = False
+
+        # 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
@@ -245,6 +279,8 @@ def __init__(self) -> None:
         # Write junit.xml to given file
         self.junit_xml: str | None = None
 
+        self.junit_format: str = "global"  # global|per_file
+
         # Caching and incremental checking options
         self.incremental = True
         self.cache_dir = defaults.CACHE_DIR
@@ -276,6 +312,12 @@ def __init__(self) -> None:
         # mypy. (Like mypyc.)
         self.preserve_asts = False
 
+        # If True, function and class docstrings will be extracted and retained.
+        # This isn't exposed as a command line option
+        # because it is intended for software integrating with
+        # mypy. (Like stubgen.)
+        self.include_docstrings = False
+
         # Paths of user plugins
         self.plugins: list[str] = []
 
@@ -292,7 +334,6 @@ def __init__(self) -> None:
         self.dump_type_stats = False
         self.dump_inference_stats = False
         self.dump_build_stats = False
-        self.enable_incomplete_features = False  # deprecated
         self.enable_incomplete_feature: list[str] = []
         self.timing_stats: str | None = None
         self.line_checking_stats: str | None = None
@@ -304,11 +345,16 @@ def __init__(self) -> None:
         # Use stub builtins fixtures to speed up tests
         self.use_builtins_fixtures = False
 
+        # This should only be set when running certain mypy tests.
+        # Use this sparingly to avoid tests diverging from non-test behavior.
+        self.test_env = False
+
         # -- experimental options --
         self.shadow_file: list[list[str]] | None = 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
@@ -344,20 +390,28 @@ 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
-        # Disable recursive type aliases (currently experimental)
-        self.disable_recursive_aliases = False
+        # Disable new experimental type inference algorithm.
+        self.old_type_inference = False
         # Deprecated reverse version of the above, do not use.
-        self.enable_recursive_aliases = False
+        self.new_type_inference = False
         # Export line-level, limited, fine-grained dependency information in cache data
         # (undocumented feature).
         self.export_ref_info = False
 
         self.disable_bytearray_promotion = False
         self.disable_memoryview_promotion = False
-
         self.force_uppercase_builtins = False
         self.force_union_syntax = False
 
+        # Sets custom output format
+        self.output: str | None = None
+
+        # Output html file for mypyc -a
+        self.mypyc_annotation_file: str | None = None
+        # Skip writing C output files, but perform all other steps of a build (allows
+        # preserving manual tweaks to generated C file)
+        self.mypyc_skip_c_generation = False
+
     def use_lowercase_names(self) -> bool:
         if self.python_version >= (3, 9):
             return not self.force_uppercase_builtins
@@ -368,17 +422,15 @@ def use_or_syntax(self) -> bool:
             return not self.force_union_syntax
         return False
 
-    # To avoid breaking plugin compatibility, keep providing new_semantic_analyzer
-    @property
-    def new_semantic_analyzer(self) -> bool:
-        return True
+    def use_star_unpack(self) -> bool:
+        return self.python_version >= (3, 11)
 
-    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__", ()))
         for k in get_class_descriptors(Options):
-            if hasattr(self, k) and k != "new_semantic_analyzer":
+            if hasattr(self, k):
                 d[k] = getattr(self, k)
         # Remove private attributes from snapshot
         d = {k: v for k, v in d.items() if not k.startswith("_")}
@@ -387,7 +439,45 @@ def snapshot(self) -> object:
     def __repr__(self) -> str:
         return f"Options({pprint.pformat(self.snapshot())})"
 
+    def process_error_codes(self, *, error_callback: Callable[[str], Any]) -> None:
+        # Process `--enable-error-code` and `--disable-error-code` flags
+        disabled_codes = set(self.disable_error_code)
+        enabled_codes = set(self.enable_error_code)
+
+        valid_error_codes = set(error_codes.keys())
+
+        invalid_codes = (enabled_codes | disabled_codes) - valid_error_codes
+        if invalid_codes:
+            error_callback(f"Invalid error code(s): {', '.join(sorted(invalid_codes))}")
+
+        self.disabled_error_codes |= {error_codes[code] for code in disabled_codes}
+        self.enabled_error_codes |= {error_codes[code] for code in enabled_codes}
+
+        # Enabling an error code always overrides disabling
+        self.disabled_error_codes -= self.enabled_error_codes
+
+    def process_incomplete_features(
+        self, *, error_callback: Callable[[str], Any], warning_callback: Callable[[str], Any]
+    ) -> None:
+        # Validate incomplete features.
+        for feature in self.enable_incomplete_feature:
+            if feature not in INCOMPLETE_FEATURES | COMPLETE_FEATURES:
+                error_callback(f"Unknown incomplete feature: {feature}")
+            if feature in COMPLETE_FEATURES:
+                warning_callback(f"Warning: {feature} is already enabled by default")
+
+    def process_strict_bytes(self) -> None:
+        # Sync `--strict-bytes` and `--disable-{bytearray,memoryview}-promotion`
+        if self.strict_bytes:
+            # backwards compatibility
+            self.disable_bytearray_promotion = True
+            self.disable_memoryview_promotion = True
+        elif self.disable_bytearray_promotion and self.disable_memoryview_promotion:
+            # forwards compatibility
+            self.strict_bytes = True
+
     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 +503,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 = {}
 
@@ -510,7 +611,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/parse.py b/mypy/parse.py
index 8bf9983967ba..ee61760c0ac0 100644
--- a/mypy/parse.py
+++ b/mypy/parse.py
@@ -6,7 +6,12 @@
 
 
 def parse(
-    source: str | bytes, fnam: str, module: str | None, errors: Errors | None, options: Options
+    source: str | bytes,
+    fnam: str,
+    module: str | None,
+    errors: Errors,
+    options: Options,
+    raise_on_error: bool = False,
 ) -> MypyFile:
     """Parse a source file, without doing any semantic analysis.
 
@@ -19,4 +24,7 @@ def parse(
         source = options.transform_source(source)
     import mypy.fastparse
 
-    return mypy.fastparse.parse(source, fnam=fnam, module=module, errors=errors, options=options)
+    tree = mypy.fastparse.parse(source, fnam=fnam, module=module, errors=errors, options=options)
+    if raise_on_error and errors.is_errors():
+        errors.raise_error()
+    return tree
diff --git a/mypy/partially_defined.py b/mypy/partially_defined.py
index 47cbd671f168..38154cf697e1 100644
--- a/mypy/partially_defined.py
+++ b/mypy/partially_defined.py
@@ -36,6 +36,7 @@
     SymbolTable,
     TryStmt,
     TupleExpr,
+    TypeAliasStmt,
     WhileStmt,
     WithStmt,
     implicit_module_attrs,
@@ -44,7 +45,7 @@
 from mypy.patterns import AsPattern, StarredPattern
 from mypy.reachability import ALWAYS_TRUE, infer_pattern_value
 from mypy.traverser import ExtendedTraverserVisitor
-from mypy.types import Type, UninhabitedType
+from mypy.types import Type, UninhabitedType, get_proper_type
 
 
 class BranchState:
@@ -506,7 +507,8 @@ def visit_break_stmt(self, o: BreakStmt) -> None:
         self.tracker.skip_branch()
 
     def visit_expression_stmt(self, o: ExpressionStmt) -> None:
-        if isinstance(self.type_map.get(o.expr, None), UninhabitedType):
+        typ = self.type_map.get(o.expr)
+        if typ is None or isinstance(get_proper_type(typ), UninhabitedType):
             self.tracker.skip_branch()
         super().visit_expression_stmt(o)
 
@@ -673,3 +675,7 @@ def visit_import_from(self, o: ImportFrom) -> None:
                 name = mod
             self.tracker.record_definition(name)
         super().visit_import_from(o)
+
+    def visit_type_alias_stmt(self, o: TypeAliasStmt) -> None:
+        # Type alias target may contain forward references
+        self.tracker.record_definition(o.name.name)
diff --git a/mypy/patterns.py b/mypy/patterns.py
index 32c27d2a5b3c..a01bf6acc876 100644
--- a/mypy/patterns.py
+++ b/mypy/patterns.py
@@ -19,7 +19,7 @@ class Pattern(Node):
     __slots__ = ()
 
     def accept(self, visitor: PatternVisitor[T]) -> T:
-        raise RuntimeError("Not implemented")
+        raise RuntimeError("Not implemented", type(self))
 
 
 class AsPattern(Pattern):
@@ -60,7 +60,7 @@ class ValuePattern(Pattern):
 
     expr: Expression
 
-    def __init__(self, expr: Expression):
+    def __init__(self, expr: Expression) -> None:
         super().__init__()
         self.expr = expr
 
@@ -72,7 +72,7 @@ class SingletonPattern(Pattern):
     # This can be exactly True, False or None
     value: bool | None
 
-    def __init__(self, value: bool | None):
+    def __init__(self, value: bool | None) -> None:
         super().__init__()
         self.value = value
 
@@ -85,7 +85,7 @@ class SequencePattern(Pattern):
 
     patterns: list[Pattern]
 
-    def __init__(self, patterns: list[Pattern]):
+    def __init__(self, patterns: list[Pattern]) -> None:
         super().__init__()
         self.patterns = patterns
 
@@ -98,7 +98,7 @@ class StarredPattern(Pattern):
     # a name.
     capture: NameExpr | None
 
-    def __init__(self, capture: NameExpr | None):
+    def __init__(self, capture: NameExpr | None) -> None:
         super().__init__()
         self.capture = capture
 
@@ -111,7 +111,9 @@ class MappingPattern(Pattern):
     values: list[Pattern]
     rest: NameExpr | None
 
-    def __init__(self, keys: list[Expression], values: list[Pattern], rest: NameExpr | None):
+    def __init__(
+        self, keys: list[Expression], values: list[Pattern], rest: NameExpr | None
+    ) -> None:
         super().__init__()
         assert len(keys) == len(values)
         self.keys = keys
@@ -136,7 +138,7 @@ def __init__(
         positionals: list[Pattern],
         keyword_keys: list[str],
         keyword_values: list[Pattern],
-    ):
+    ) -> None:
         super().__init__()
         assert len(keyword_keys) == len(keyword_values)
         self.class_ref = class_ref
diff --git a/mypy/plugin.py b/mypy/plugin.py
index cf124b45d04f..39841d5b907a 100644
--- a/mypy/plugin.py
+++ b/mypy/plugin.py
@@ -114,9 +114,6 @@ class C: pass
 Note that a forward reference in a function signature won't trigger another
 pass, since all functions are processed only after the top level has been fully
 analyzed.
-
-You can use `api.options.new_semantic_analyzer` to check whether the new
-semantic analyzer is enabled (it's always true in mypy 0.730 and later).
 """
 
 from __future__ import annotations
@@ -173,12 +170,12 @@ def fail(self, msg: str, ctx: Context, *, code: ErrorCode | None = None) -> None
         raise NotImplementedError
 
     @abstractmethod
-    def named_type(self, name: str, args: list[Type]) -> Instance:
+    def named_type(self, fullname: str, args: list[Type], /) -> Instance:
         """Construct an instance of a builtin type with given name."""
         raise NotImplementedError
 
     @abstractmethod
-    def analyze_type(self, typ: Type) -> Type:
+    def analyze_type(self, typ: Type, /) -> Type:
         """Analyze an unbound type using the default mypy logic."""
         raise NotImplementedError
 
@@ -240,14 +237,19 @@ def type_context(self) -> list[Type | None]:
 
     @abstractmethod
     def fail(
-        self, msg: str | ErrorMessage, ctx: Context, *, code: ErrorCode | None = None
+        self, msg: str | ErrorMessage, ctx: Context, /, *, code: ErrorCode | None = None
     ) -> None:
         """Emit an error message at given location."""
         raise NotImplementedError
 
     @abstractmethod
     def named_generic_type(self, name: str, args: list[Type]) -> Instance:
-        """Construct an instance of a builtin type with given type arguments."""
+        """Construct an instance of a generic 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
 
 
@@ -317,13 +319,13 @@ def fail(
     @abstractmethod
     def anal_type(
         self,
-        t: Type,
+        typ: Type,
+        /,
         *,
         tvar_scope: TypeVarLikeScope | None = None,
         allow_tuple_literal: bool = False,
         allow_unbound_tvars: bool = False,
         report_invalid_types: bool = True,
-        third_pass: bool = False,
     ) -> Type | None:
         """Analyze an unbound type.
 
@@ -339,7 +341,7 @@ def class_type(self, self_type: Type) -> Type:
         raise NotImplementedError
 
     @abstractmethod
-    def lookup_fully_qualified(self, name: str) -> SymbolTableNode:
+    def lookup_fully_qualified(self, fullname: str, /) -> SymbolTableNode:
         """Lookup a symbol by its fully qualified name.
 
         Raise an error if not found.
@@ -347,7 +349,7 @@ def lookup_fully_qualified(self, name: str) -> SymbolTableNode:
         raise NotImplementedError
 
     @abstractmethod
-    def lookup_fully_qualified_or_none(self, name: str) -> SymbolTableNode | None:
+    def lookup_fully_qualified_or_none(self, fullname: str, /) -> SymbolTableNode | None:
         """Lookup a symbol by its fully qualified name.
 
         Return None if not found.
@@ -383,12 +385,12 @@ def add_plugin_dependency(self, trigger: str, target: str | None = None) -> None
         raise NotImplementedError
 
     @abstractmethod
-    def add_symbol_table_node(self, name: str, stnode: SymbolTableNode) -> Any:
+    def add_symbol_table_node(self, name: str, symbol: SymbolTableNode) -> Any:
         """Add node to global symbol table (or to nearest class if there is one)."""
         raise NotImplementedError
 
     @abstractmethod
-    def qualified_name(self, n: str) -> str:
+    def qualified_name(self, name: str) -> str:
         """Make qualified name using current module and enclosing class (if any)."""
         raise NotImplementedError
 
@@ -491,6 +493,7 @@ class MethodContext(NamedTuple):
 class AttributeContext(NamedTuple):
     type: ProperType  # Type of object with attribute
     default_attr_type: Type  # Original attribute type
+    is_lvalue: bool  # Whether the attribute is the target of an assignment
     context: Context  # Relevant location context (e.g. for error messages)
     api: CheckerPluginInterface
 
diff --git a/mypy/plugins/attrs.py b/mypy/plugins/attrs.py
index afd9423d6820..b7b3821576ea 100644
--- a/mypy/plugins/attrs.py
+++ b/mypy/plugins/attrs.py
@@ -3,13 +3,12 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterable, Mapping
 from functools import reduce
-from typing import Iterable, List, Mapping, cast
-from typing_extensions import Final, Literal
+from typing import Final, Literal, cast
 
 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
@@ -52,11 +51,17 @@
     _get_bool_argument,
     _get_decorator_bool_argument,
     add_attribute_to_class,
-    add_method,
+    add_method_to_class,
     deserialize_and_fixup_type,
 )
 from mypy.server.trigger import make_wildcard_trigger
-from mypy.typeops import get_type_vars, make_simplified_union, map_type_from_supertype
+from mypy.state import state
+from mypy.typeops import (
+    get_type_vars,
+    make_simplified_union,
+    map_type_from_supertype,
+    type_object_type,
+)
 from mypy.types import (
     AnyType,
     CallableType,
@@ -70,6 +75,7 @@
     Type,
     TypeOfAny,
     TypeType,
+    TypeVarId,
     TypeVarType,
     UninhabitedType,
     UnionType,
@@ -106,6 +112,7 @@ class Attribute:
     def __init__(
         self,
         name: str,
+        alias: str | None,
         info: TypeInfo,
         has_default: bool,
         init: bool,
@@ -115,6 +122,7 @@ def __init__(
         init_type: Type | None,
     ) -> None:
         self.name = name
+        self.alias = alias
         self.info = info
         self.has_default = has_default
         self.init = init
@@ -172,19 +180,23 @@ def argument(self, ctx: mypy.plugin.ClassDefContext) -> Argument:
             arg_kind = ARG_OPT if self.has_default else ARG_POS
 
         # Attrs removes leading underscores when creating the __init__ arguments.
-        return Argument(Var(self.name.lstrip("_"), init_type), init_type, None, arg_kind)
+        name = self.alias or self.name.lstrip("_")
+        return Argument(Var(name, init_type), init_type, None, arg_kind)
 
     def serialize(self) -> JsonDict:
         """Serialize this object so it can be saved and restored."""
         return {
             "name": self.name,
+            "alias": self.alias,
             "has_default": self.has_default,
             "init": self.init,
             "kw_only": self.kw_only,
             "has_converter": self.converter is not None,
-            "converter_init_type": self.converter.init_type.serialize()
-            if self.converter and self.converter.init_type
-            else None,
+            "converter_init_type": (
+                self.converter.init_type.serialize()
+                if self.converter and self.converter.init_type
+                else None
+            ),
             "context_line": self.context.line,
             "context_column": self.context.column,
             "init_type": self.init_type.serialize() if self.init_type else None,
@@ -206,6 +218,7 @@ def deserialize(
 
         return Attribute(
             data["name"],
+            data["alias"],
             info,
             data["has_default"],
             data["init"],
@@ -295,6 +308,7 @@ def attr_class_maker_callback(
     ctx: mypy.plugin.ClassDefContext,
     auto_attribs_default: bool | None = False,
     frozen_default: bool = False,
+    slots_default: bool = False,
 ) -> bool:
     """Add necessary dunder methods to classes decorated with attr.s.
 
@@ -305,17 +319,33 @@ def attr_class_maker_callback(
     it will add an __init__ or all the compare methods.
     For frozen=True it will turn the attrs into properties.
 
+    Hashability will be set according to https://www.attrs.org/en/stable/hashing.html.
+
     See https://www.attrs.org/en/stable/how-does-it-work.html for information on how attrs works.
 
-    If this returns False, some required metadata was not ready yet and we need another
+    If this returns False, some required metadata was not ready yet, and we need another
     pass.
     """
+    with state.strict_optional_set(ctx.api.options.strict_optional):
+        # This hook is called during semantic analysis, but it uses a bunch of
+        # type-checking ops, so it needs the strict optional set properly.
+        return attr_class_maker_callback_impl(
+            ctx, auto_attribs_default, frozen_default, slots_default
+        )
+
+
+def attr_class_maker_callback_impl(
+    ctx: mypy.plugin.ClassDefContext,
+    auto_attribs_default: bool | None,
+    frozen_default: bool,
+    slots_default: bool,
+) -> bool:
     info = ctx.cls.info
 
     init = _get_decorator_bool_argument(ctx, "init", True)
     frozen = _get_frozen(ctx, frozen_default)
     order = _determine_eq_order(ctx)
-    slots = _get_decorator_bool_argument(ctx, "slots", False)
+    slots = _get_decorator_bool_argument(ctx, "slots", slots_default)
 
     auto_attribs = _get_decorator_optional_bool_argument(ctx, "auto_attribs", auto_attribs_default)
     kw_only = _get_decorator_bool_argument(ctx, "kw_only", False)
@@ -354,10 +384,30 @@ def attr_class_maker_callback(
     adder = MethodAdder(ctx)
     # If  __init__ is not being generated, attrs still generates it as __attrs_init__ instead.
     _add_init(ctx, attributes, adder, "__init__" if init else ATTRS_INIT_NAME)
+
     if order:
         _add_order(ctx, adder)
     if frozen:
         _make_frozen(ctx, attributes)
+        # Frozen classes are hashable by default, even if inheriting from non-frozen ones.
+        hashable: bool | None = _get_decorator_bool_argument(
+            ctx, "hash", True
+        ) and _get_decorator_bool_argument(ctx, "unsafe_hash", True)
+    else:
+        hashable = _get_decorator_optional_bool_argument(ctx, "unsafe_hash")
+        if hashable is None:  # unspecified
+            hashable = _get_decorator_optional_bool_argument(ctx, "hash")
+
+    eq = _get_decorator_optional_bool_argument(ctx, "eq")
+    has_own_hash = "__hash__" in ctx.cls.info.names
+
+    if has_own_hash or (hashable is None and eq is False):
+        pass  # Do nothing.
+    elif hashable:
+        # We copy the `__hash__` signature from `object` to make them hashable.
+        ctx.cls.info.names["__hash__"] = ctx.cls.info.mro[-1].names["__hash__"]
+    else:
+        _remove_hashability(ctx)
 
     return True
 
@@ -498,6 +548,7 @@ def _attributes_from_assignment(
     or if auto_attribs is enabled also like this:
         x: type
         x: type = default_value
+        x: type = attr.ib(...)
     """
     for lvalue in stmt.lvalues:
         lvalues, rvalues = _parse_assignments(lvalue, stmt)
@@ -564,7 +615,7 @@ def _attribute_from_auto_attrib(
     has_rhs = not isinstance(rvalue, TempNode)
     sym = ctx.cls.info.names.get(name)
     init_type = sym.type if sym else None
-    return Attribute(name, ctx.cls.info, has_rhs, True, kw_only, None, stmt, init_type)
+    return Attribute(name, None, ctx.cls.info, has_rhs, True, kw_only, None, stmt, init_type)
 
 
 def _attribute_from_attrib_maker(
@@ -628,9 +679,20 @@ def _attribute_from_attrib_maker(
         converter = convert
     converter_info = _parse_converter(ctx, converter)
 
+    # Custom alias might be defined:
+    alias = None
+    alias_expr = _get_argument(rvalue, "alias")
+    if alias_expr:
+        alias = ctx.api.parse_str_literal(alias_expr)
+        if alias is None:
+            ctx.api.fail(
+                '"alias" argument to attrs field must be a string literal',
+                rvalue,
+                code=LITERAL_REQ,
+            )
     name = unmangle(lhs.name)
     return Attribute(
-        name, ctx.cls.info, attr_has_default, init, kw_only, converter_info, stmt, init_type
+        name, alias, ctx.cls.info, attr_has_default, init, kw_only, converter_info, stmt, init_type
     )
 
 
@@ -669,8 +731,6 @@ def _parse_converter(
         ):
             converter_type = converter_expr.node.type
         elif isinstance(converter_expr.node, TypeInfo):
-            from mypy.checkmember import type_object_type  # To avoid import cycle.
-
             converter_type = type_object_type(converter_expr.node, ctx.api.named_type)
     elif (
         isinstance(converter_expr, IndexExpr)
@@ -679,8 +739,6 @@ def _parse_converter(
         and isinstance(converter_expr.base.node, TypeInfo)
     ):
         # The converter is a generic type.
-        from mypy.checkmember import type_object_type  # To avoid import cycle.
-
         converter_type = type_object_type(converter_expr.base.node, ctx.api.named_type)
         if isinstance(converter_type, CallableType):
             converter_type = apply_generic_arguments(
@@ -749,7 +807,7 @@ def _parse_assignments(
     rvalues: list[Expression] = []
     if isinstance(lvalue, (TupleExpr, ListExpr)):
         if all(isinstance(item, NameExpr) for item in lvalue.items):
-            lvalues = cast(List[NameExpr], lvalue.items)
+            lvalues = cast(list[NameExpr], lvalue.items)
         if isinstance(stmt.rvalue, (TupleExpr, ListExpr)):
             rvalues = stmt.rvalue.items
     elif isinstance(lvalue, NameExpr):
@@ -766,25 +824,25 @@ def _add_order(ctx: mypy.plugin.ClassDefContext, adder: MethodAdder) -> None:
     #    AT = TypeVar('AT')
     #    def __lt__(self: AT, other: AT) -> bool
     # This way comparisons with subclasses will work correctly.
+    fullname = f"{ctx.cls.info.fullname}.{SELF_TVAR_NAME}"
     tvd = TypeVarType(
         SELF_TVAR_NAME,
-        ctx.cls.info.fullname + "." + SELF_TVAR_NAME,
-        id=-1,
+        fullname,
+        # Namespace is patched per-method below.
+        id=TypeVarId(-1, namespace=""),
         values=[],
         upper_bound=object_type,
         default=AnyType(TypeOfAny.from_omitted_generics),
     )
     self_tvar_expr = TypeVarExpr(
-        SELF_TVAR_NAME,
-        ctx.cls.info.fullname + "." + SELF_TVAR_NAME,
-        [],
-        object_type,
-        AnyType(TypeOfAny.from_omitted_generics),
+        SELF_TVAR_NAME, fullname, [], object_type, AnyType(TypeOfAny.from_omitted_generics)
     )
     ctx.cls.info.names[SELF_TVAR_NAME] = SymbolTableNode(MDEF, self_tvar_expr)
 
-    args = [Argument(Var("other", tvd), tvd, None, ARG_POS)]
     for method in ["__lt__", "__le__", "__gt__", "__ge__"]:
+        namespace = f"{ctx.cls.info.fullname}.{method}"
+        tvd = tvd.copy_modified(id=TypeVarId(tvd.id.raw_id, namespace=namespace))
+        args = [Argument(Var("other", tvd), tvd, None, ARG_POS)]
         adder.add_method(method, args, bool_type, self_type=tvd, tvd=tvd)
 
 
@@ -803,7 +861,7 @@ def _make_frozen(ctx: mypy.plugin.ClassDefContext, attributes: list[Attribute])
         else:
             # This variable belongs to a super class so create new Var so we
             # can modify it.
-            var = Var(attribute.name, ctx.cls.info[attribute.name].type)
+            var = Var(attribute.name, attribute.init_type)
             var.info = ctx.cls.info
             var._fullname = f"{ctx.cls.info.fullname}.{var.name}"
             ctx.cls.info.names[var.name] = SymbolTableNode(MDEF, var)
@@ -893,9 +951,21 @@ def _add_attrs_magic_attribute(
 
 
 def _add_slots(ctx: mypy.plugin.ClassDefContext, attributes: list[Attribute]) -> None:
+    if any(p.slots is None for p in ctx.cls.info.mro[1:-1]):
+        # At least one type in mro (excluding `self` and `object`)
+        # does not have concrete `__slots__` defined. Ignoring.
+        return
+
     # Unlike `@dataclasses.dataclass`, `__slots__` is rewritten here.
     ctx.cls.info.slots = {attr.name for attr in attributes}
 
+    # Also, inject `__slots__` attribute to class namespace:
+    slots_type = TupleType(
+        [ctx.api.named_type("builtins.str") for _ in attributes],
+        fallback=ctx.api.named_type("builtins.tuple"),
+    )
+    add_attribute_to_class(api=ctx.api, cls=ctx.cls, name="__slots__", typ=slots_type)
+
 
 def _add_match_args(ctx: mypy.plugin.ClassDefContext, attributes: list[Attribute]) -> None:
     if (
@@ -914,6 +984,13 @@ def _add_match_args(ctx: mypy.plugin.ClassDefContext, attributes: list[Attribute
         add_attribute_to_class(api=ctx.api, cls=ctx.cls, name="__match_args__", typ=match_args)
 
 
+def _remove_hashability(ctx: mypy.plugin.ClassDefContext) -> None:
+    """Remove hashability from a class."""
+    add_attribute_to_class(
+        ctx.api, ctx.cls, "__hash__", NoneType(), is_classvar=True, overwrite_existing=True
+    )
+
+
 class MethodAdder:
     """Helper to add methods to a TypeInfo.
 
@@ -940,7 +1017,9 @@ def add_method(
         tvd: If the method is generic these should be the type variables.
         """
         self_type = self_type if self_type is not None else self.self_type
-        add_method(self.ctx, method_name, args, ret_type, self_type, tvd)
+        add_method_to_class(
+            self.ctx.api, self.ctx.cls, method_name, args, ret_type, self_type, tvd
+        )
 
 
 def _get_attrs_init_type(typ: Instance) -> CallableType | None:
@@ -1009,7 +1088,7 @@ def _get_expanded_attr_types(
             return None
         init_func = expand_type_by_instance(init_func, typ)
         # [1:] to skip the self argument of AttrClass.__init__
-        field_names = cast(List[str], init_func.arg_names[1:])
+        field_names = cast(list[str], init_func.arg_names[1:])
         field_types = init_func.arg_types[1:]
         return [dict(zip(field_names, field_types))]
     else:
@@ -1027,9 +1106,11 @@ def _meet_fields(types: list[Mapping[str, Type]]) -> Mapping[str, Type]:
             field_to_types[name].append(typ)
 
     return {
-        name: get_proper_type(reduce(meet_types, f_types))
-        if len(f_types) == len(types)
-        else UninhabitedType()
+        name: (
+            get_proper_type(reduce(meet_types, f_types))
+            if len(f_types) == len(types)
+            else UninhabitedType()
+        )
         for name, f_types in field_to_types.items()
     }
 
@@ -1048,13 +1129,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 +1149,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 +1169,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()
@@ -1109,9 +1180,4 @@ def fields_function_sig_callback(ctx: mypy.plugin.FunctionSigContext) -> Callabl
         assert ret_type is not None
         return ctx.default_signature.copy_modified(arg_types=arg_types, ret_type=ret_type)
 
-    ctx.api.fail(
-        f'Argument 1 to "fields" has incompatible type "{format_type_bare(proper_type, ctx.api.options)}"; expected an attrs class',
-        ctx.context,
-    )
-
     return ctx.default_signature
diff --git a/mypy/plugins/common.py b/mypy/plugins/common.py
index f803387cde8b..ac00171a037c 100644
--- a/mypy/plugins/common.py
+++ b/mypy/plugins/common.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import NamedTuple
+
 from mypy.argmap import map_actuals_to_formals
 from mypy.fixup import TypeFixer
 from mypy.nodes import (
@@ -16,9 +18,11 @@
     JsonDict,
     NameExpr,
     Node,
+    OverloadedFuncDef,
     PassStmt,
     RefExpr,
     SymbolTableNode,
+    TypeInfo,
     Var,
 )
 from mypy.plugin import CheckerPluginInterface, ClassDefContext, SemanticAnalyzerPluginInterface
@@ -28,9 +32,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,
@@ -45,7 +47,7 @@
     deserialize_type,
     get_proper_type,
 )
-from mypy.types_utils import is_optional
+from mypy.types_utils import is_overlapping_none
 from mypy.typevars import fill_typevars
 from mypy.util import get_unique_redefinition_name
 
@@ -143,7 +145,7 @@ def find_shallow_matching_overload_item(overload: Overloaded, call: CallExpr) ->
                         break
                 elif (
                     arg_none
-                    and not is_optional(arg_type)
+                    and not is_overlapping_none(arg_type)
                     and not (
                         isinstance(arg_type, Instance)
                         and arg_type.type.fullname == "builtins.object"
@@ -152,7 +154,7 @@ def find_shallow_matching_overload_item(overload: Overloaded, call: CallExpr) ->
                 ):
                     ok = False
                     break
-                elif isinstance(arg_type, LiteralType) and type(arg_type.value) is bool:
+                elif isinstance(arg_type, LiteralType) and isinstance(arg_type.value, bool):
                     if not any(parse_bool(arg) == arg_type.value for arg in args):
                         ok = False
                         break
@@ -162,7 +164,7 @@ def find_shallow_matching_overload_item(overload: Overloaded, call: CallExpr) ->
 
 
 def _get_callee_type(call: CallExpr) -> CallableType | None:
-    """Return the type of the callee, regardless of its syntatic form."""
+    """Return the type of the callee, regardless of its syntactic form."""
 
     callee_node: Node | None = call.callee
 
@@ -211,24 +213,98 @@ def add_method(
     )
 
 
+class MethodSpec(NamedTuple):
+    """Represents a method signature to be added, except for `name`."""
+
+    args: list[Argument]
+    return_type: Type
+    self_type: Type | None = None
+    tvar_defs: list[TypeVarType] | None = None
+
+
 def add_method_to_class(
     api: SemanticAnalyzerPluginInterface | CheckerPluginInterface,
     cls: ClassDef,
     name: str,
+    # MethodSpec items kept for backward compatibility:
     args: list[Argument],
     return_type: Type,
     self_type: Type | None = None,
-    tvar_def: TypeVarType | None = None,
+    tvar_def: list[TypeVarType] | TypeVarType | None = None,
     is_classmethod: bool = False,
     is_staticmethod: bool = False,
-) -> None:
+) -> FuncDef | Decorator:
     """Adds a new method to a class definition."""
+    _prepare_class_namespace(cls, name)
+
+    if tvar_def is not None and not isinstance(tvar_def, list):
+        tvar_def = [tvar_def]
+
+    func, sym = _add_method_by_spec(
+        api,
+        cls.info,
+        name,
+        MethodSpec(args=args, return_type=return_type, self_type=self_type, tvar_defs=tvar_def),
+        is_classmethod=is_classmethod,
+        is_staticmethod=is_staticmethod,
+    )
+    cls.info.names[name] = sym
+    cls.info.defn.defs.body.append(func)
+    return func
 
-    assert not (
-        is_classmethod is True and is_staticmethod is True
-    ), "Can't add a new method that's both staticmethod and classmethod."
 
+def add_overloaded_method_to_class(
+    api: SemanticAnalyzerPluginInterface | CheckerPluginInterface,
+    cls: ClassDef,
+    name: str,
+    items: list[MethodSpec],
+    is_classmethod: bool = False,
+    is_staticmethod: bool = False,
+) -> OverloadedFuncDef:
+    """Adds a new overloaded method to a class definition."""
+    assert len(items) >= 2, "Overloads must contain at least two cases"
+
+    # Save old definition, if it exists.
+    _prepare_class_namespace(cls, name)
+
+    # Create function bodies for each passed method spec.
+    funcs: list[Decorator | FuncDef] = []
+    for item in items:
+        func, _sym = _add_method_by_spec(
+            api,
+            cls.info,
+            name=name,
+            spec=item,
+            is_classmethod=is_classmethod,
+            is_staticmethod=is_staticmethod,
+        )
+        if isinstance(func, FuncDef):
+            var = Var(func.name, func.type)
+            var.set_line(func.line)
+            func.is_decorated = True
+
+            deco = Decorator(func, [], var)
+        else:
+            deco = func
+        deco.is_overload = True
+        funcs.append(deco)
+
+    # Create the final OverloadedFuncDef node:
+    overload_def = OverloadedFuncDef(funcs)
+    overload_def.info = cls.info
+    overload_def.is_class = is_classmethod
+    overload_def.is_static = is_staticmethod
+    sym = SymbolTableNode(MDEF, overload_def)
+    sym.plugin_generated = True
+
+    cls.info.names[name] = sym
+    cls.info.defn.defs.body.append(overload_def)
+    return overload_def
+
+
+def _prepare_class_namespace(cls: ClassDef, name: str) -> None:
     info = cls.info
+    assert info
 
     # First remove any previously generated methods with the same name
     # to avoid clashes and problems in the semantic analyzer.
@@ -237,6 +313,29 @@ def add_method_to_class(
         if sym.plugin_generated and isinstance(sym.node, FuncDef):
             cls.defs.body.remove(sym.node)
 
+    # NOTE: we would like the plugin generated node to dominate, but we still
+    # need to keep any existing definitions so they get semantically analyzed.
+    if name in info.names:
+        # Get a nice unique name instead.
+        r_name = get_unique_redefinition_name(name, info.names)
+        info.names[r_name] = info.names[name]
+
+
+def _add_method_by_spec(
+    api: SemanticAnalyzerPluginInterface | CheckerPluginInterface,
+    info: TypeInfo,
+    name: str,
+    spec: MethodSpec,
+    *,
+    is_classmethod: bool,
+    is_staticmethod: bool,
+) -> tuple[FuncDef | Decorator, SymbolTableNode]:
+    args, return_type, self_type, tvar_defs = spec
+
+    assert not (
+        is_classmethod is True and is_staticmethod is True
+    ), "Can't add a new method that's both staticmethod and classmethod."
+
     if isinstance(api, SemanticAnalyzerPluginInterface):
         function_type = api.named_type("builtins.function")
     else:
@@ -260,8 +359,8 @@ def add_method_to_class(
         arg_kinds.append(arg.kind)
 
     signature = CallableType(arg_types, arg_kinds, arg_names, return_type, function_type)
-    if tvar_def:
-        signature.variables = [tvar_def]
+    if tvar_defs:
+        signature.variables = tvar_defs
 
     func = FuncDef(name, args, Block([PassStmt()]))
     func.info = info
@@ -271,13 +370,6 @@ def add_method_to_class(
     func._fullname = info.fullname + "." + name
     func.line = info.line
 
-    # NOTE: we would like the plugin generated node to dominate, but we still
-    # need to keep any existing definitions so they get semantically analyzed.
-    if name in info.names:
-        # Get a nice unique name instead.
-        r_name = get_unique_redefinition_name(name, info.names)
-        info.names[r_name] = info.names[name]
-
     # Add decorator for is_staticmethod. It's unnecessary for is_classmethod.
     if is_staticmethod:
         func.is_decorated = True
@@ -288,12 +380,12 @@ def add_method_to_class(
         dec = Decorator(func, [], v)
         dec.line = info.line
         sym = SymbolTableNode(MDEF, dec)
-    else:
-        sym = SymbolTableNode(MDEF, func)
-    sym.plugin_generated = True
-    info.names[name] = sym
+        sym.plugin_generated = True
+        return dec, sym
 
-    info.defn.defs.body.append(func)
+    sym = SymbolTableNode(MDEF, func)
+    sym.plugin_generated = True
+    return func, sym
 
 
 def add_attribute_to_class(
@@ -306,7 +398,8 @@ def add_attribute_to_class(
     override_allow_incompatible: bool = False,
     fullname: str | None = None,
     is_classvar: bool = False,
-) -> None:
+    overwrite_existing: bool = False,
+) -> Var:
     """
     Adds a new attribute to a class definition.
     This currently only generates the symbol table entry and no corresponding AssignmentStatement
@@ -315,7 +408,7 @@ def add_attribute_to_class(
 
     # NOTE: we would like the plugin generated node to dominate, but we still
     # need to keep any existing definitions so they get semantically analyzed.
-    if name in info.names:
+    if name in info.names and not overwrite_existing:
         # Get a nice unique name instead.
         r_name = get_unique_redefinition_name(name, info.names)
         info.names[r_name] = info.names[name]
@@ -337,6 +430,7 @@ def add_attribute_to_class(
     info.names[name] = SymbolTableNode(
         MDEF, node, plugin_generated=True, no_serialize=no_serialize
     )
+    return node
 
 
 def deserialize_and_fixup_type(data: str | JsonDict, api: SemanticAnalyzerPluginInterface) -> Type:
diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
index 2fd903f2f8b9..2b4982a36bb6 100644
--- a/mypy/plugins/dataclasses.py
+++ b/mypy/plugins/dataclasses.py
@@ -2,11 +2,13 @@
 
 from __future__ import annotations
 
-from typing import Iterator, Optional
-from typing_extensions import Final
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, Final, Literal
 
 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,
@@ -22,8 +24,11 @@
     ClassDef,
     Context,
     DataclassTransformSpec,
+    Decorator,
+    EllipsisExpr,
     Expression,
     FuncDef,
+    FuncItem,
     IfStmt,
     JsonDict,
     NameExpr,
@@ -38,7 +43,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,
@@ -53,29 +58,41 @@
 from mypy.types import (
     AnyType,
     CallableType,
+    FunctionLike,
     Instance,
     LiteralType,
     NoneType,
+    ProperType,
     TupleType,
     Type,
     TypeOfAny,
+    TypeVarId,
     TypeVarType,
+    UninhabitedType,
+    UnionType,
     get_proper_type,
 )
 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"}
+# Default field specifiers for dataclasses
+DATACLASS_FIELD_SPECIFIERS: Final = ("dataclasses.Field", "dataclasses.field")
 
 
 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"),
+    field_specifiers=DATACLASS_FIELD_SPECIFIERS,
 )
+_INTERNAL_REPLACE_SYM_NAME: Final = "__mypy-replace"
+_INTERNAL_POST_INIT_SYM_NAME: Final = "__mypy-post_init"
 
 
 class DataclassAttribute:
@@ -92,6 +109,7 @@ def __init__(
         info: TypeInfo,
         kw_only: bool,
         is_neither_frozen_nor_nonfrozen: bool,
+        api: SemanticAnalyzerPluginInterface,
     ) -> None:
         self.name = name
         self.alias = alias
@@ -104,29 +122,52 @@ 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
-        if self.kw_only and self.has_default:
-            arg_kind = ARG_NAMED_OPT
-        elif self.kw_only and not self.has_default:
-            arg_kind = ARG_NAMED
-        elif not self.kw_only and self.has_default:
-            arg_kind = ARG_OPT
+    def to_argument(
+        self, current_info: TypeInfo, *, of: Literal["__init__", "replace", "__post_init__"]
+    ) -> Argument:
+        if of == "__init__":
+            arg_kind = ARG_POS
+            if self.kw_only and self.has_default:
+                arg_kind = ARG_NAMED_OPT
+            elif self.kw_only and not self.has_default:
+                arg_kind = ARG_NAMED
+            elif not self.kw_only and self.has_default:
+                arg_kind = ARG_OPT
+        elif of == "replace":
+            arg_kind = ARG_NAMED if self.is_init_var and not self.has_default else ARG_NAMED_OPT
+        elif of == "__post_init__":
+            # 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_kind = ARG_POS
         return Argument(
             variable=self.to_var(current_info),
             type_annotation=self.expand_type(current_info),
-            initializer=None,
+            initializer=EllipsisExpr() if self.has_default else None,  # Only used by stubgen
             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,
+            # In general, it is not safe to call `expand_type()` during semantic analysis,
             # 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:
@@ -152,16 +193,15 @@ 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)
+        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:
@@ -220,12 +260,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, of="__init__")
+                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.
@@ -235,11 +274,17 @@ def transform(self) -> bool:
                     if arg.kind == ARG_POS:
                         arg.kind = ARG_OPT
 
-                nameless_var = Var("")
+                existing_args_names = {arg.variable.name for arg in args}
+                gen_args_name = "generated_args"
+                while gen_args_name in existing_args_names:
+                    gen_args_name += "_"
+                gen_kwargs_name = "generated_kwargs"
+                while gen_kwargs_name in existing_args_names:
+                    gen_kwargs_name += "_"
                 args = [
-                    Argument(nameless_var, AnyType(TypeOfAny.explicit), None, ARG_STAR),
+                    Argument(Var(gen_args_name), AnyType(TypeOfAny.explicit), None, ARG_STAR),
                     *args,
-                    Argument(nameless_var, AnyType(TypeOfAny.explicit), None, ARG_STAR2),
+                    Argument(Var(gen_kwargs_name), AnyType(TypeOfAny.explicit), None, ARG_STAR2),
                 ]
 
             add_method_to_class(
@@ -273,8 +318,8 @@ def transform(self) -> bool:
                 obj_type = self._api.named_type("builtins.object")
                 order_tvar_def = TypeVarType(
                     SELF_TVAR_NAME,
-                    info.fullname + "." + SELF_TVAR_NAME,
-                    id=-1,
+                    f"{info.fullname}.{SELF_TVAR_NAME}",
+                    id=TypeVarId(-1, namespace=f"{info.fullname}.{method_name}"),
                     values=[],
                     upper_bound=obj_type,
                     default=AnyType(TypeOfAny.from_omitted_generics),
@@ -314,12 +359,12 @@ def transform(self) -> bool:
 
         if decorator_arguments["frozen"]:
             if any(not parent["frozen"] for parent in parent_decorator_arguments):
-                self._api.fail("Cannot inherit frozen dataclass from a non-frozen one", info)
+                self._api.fail("Frozen dataclass cannot inherit from a non-frozen dataclass", info)
             self._propertize_callables(attributes, settable=False)
             self._freeze(attributes)
         else:
             if any(parent["frozen"] for parent in parent_decorator_arguments):
-                self._api.fail("Cannot inherit non-frozen dataclass from a frozen one", info)
+                self._api.fail("Non-frozen dataclass cannot inherit from a frozen dataclass", info)
             self._propertize_callables(attributes)
 
         if decorator_arguments["slots"]:
@@ -332,17 +377,24 @@ def transform(self) -> bool:
             and (
                 "__match_args__" not in info.names or info.names["__match_args__"].plugin_generated
             )
-            and attributes
             and py_version >= (3, 10)
         ):
             str_type = self._api.named_type("builtins.str")
             literals: list[Type] = [
-                LiteralType(attr.name, str_type) for attr in attributes if attr.is_in_init
+                LiteralType(attr.name, str_type)
+                for attr in attributes
+                if attr.is_in_init and not attr.kw_only
             ]
             match_args_type = TupleType(literals, self._api.named_type("builtins.tuple"))
             add_attribute_to_class(self._api, self._cls, "__match_args__", match_args_type)
 
         self._add_dataclass_fields_magic_attribute()
+        self._add_internal_replace_method(attributes)
+        if self._api.options.python_version >= (3, 13):
+            self._add_dunder_replace(attributes)
+
+        if "__post_init__" in info.names:
+            self._add_internal_post_init_method(attributes)
 
         info.metadata["dataclass"] = {
             "attributes": [attr.serialize() for attr in attributes],
@@ -351,6 +403,49 @@ def transform(self) -> bool:
 
         return True
 
+    def _add_dunder_replace(self, attributes: list[DataclassAttribute]) -> None:
+        """Add a `__replace__` method to the class, which is used to replace attributes in the `copy` module."""
+        args = [
+            attr.to_argument(self._cls.info, of="replace")
+            for attr in attributes
+            if attr.is_in_init
+        ]
+        type_vars = [tv for tv in self._cls.type_vars]
+        add_method_to_class(
+            self._api,
+            self._cls,
+            "__replace__",
+            args=args,
+            return_type=Instance(self._cls.info, type_vars),
+        )
+
+    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.
+        """
+        add_method_to_class(
+            self._api,
+            self._cls,
+            _INTERNAL_REPLACE_SYM_NAME,
+            args=[attr.to_argument(self._cls.info, of="replace") for attr in attributes],
+            return_type=NoneType(),
+            is_staticmethod=True,
+        )
+
+    def _add_internal_post_init_method(self, attributes: list[DataclassAttribute]) -> None:
+        add_method_to_class(
+            self._api,
+            self._cls,
+            _INTERNAL_POST_INIT_SYM_NAME,
+            args=[
+                attr.to_argument(self._cls.info, of="__post_init__")
+                for attr in attributes
+                if attr.is_init_var
+            ],
+            return_type=NoneType(),
+        )
+
     def add_slots(
         self, info: TypeInfo, attributes: list[DataclassAttribute], *, correct_version: bool
     ) -> None:
@@ -358,8 +453,7 @@ def add_slots(
             # This means that version is lower than `3.10`,
             # it is just a non-existent argument for `dataclass` function.
             self._api.fail(
-                'Keyword argument "slots" for "dataclass" '
-                "is only valid in Python 3.10 and higher",
+                'Keyword argument "slots" for "dataclass" is only valid in Python 3.10 and higher',
                 self._reason,
             )
             return
@@ -380,8 +474,20 @@ def add_slots(
             )
             return
 
+        if any(p.slots is None for p in info.mro[1:-1]):
+            # At least one type in mro (excluding `self` and `object`)
+            # does not have concrete `__slots__` defined. Ignoring.
+            return
+
         info.slots = generated_slots
 
+        # Now, insert `.__slots__` attribute to class namespace:
+        slots_type = TupleType(
+            [self._api.named_type("builtins.str") for _ in generated_slots],
+            self._api.named_type("builtins.tuple"),
+        )
+        add_attribute_to_class(self._api, self._cls, "__slots__", slots_type)
+
     def reset_init_only_vars(self, info: TypeInfo, attributes: list[DataclassAttribute]) -> None:
         """Remove init-only vars from the class and reset init var declarations."""
         for attr in attributes:
@@ -459,8 +565,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)
@@ -502,6 +607,10 @@ def collect_attributes(self) -> list[DataclassAttribute] | None:
                 # but the only alternative would be to modify the SymbolTable,
                 # and it's a little hairy to do that in a plugin.
                 continue
+            if isinstance(node, Decorator):
+                # This might be a property / field name clash.
+                # We will issue an error later.
+                continue
 
             assert isinstance(node, Var)
 
@@ -591,7 +700,8 @@ def collect_attributes(self) -> list[DataclassAttribute] | None:
                     )
 
             current_attr_names.add(lhs.name)
-            init_type = self._infer_dataclass_attr_init_type(sym, lhs.name, stmt)
+            with state.strict_optional_set(self._api.options.strict_optional):
+                init_type = self._infer_dataclass_attr_init_type(sym, lhs.name, stmt)
             found_attrs[lhs.name] = DataclassAttribute(
                 name=lhs.name,
                 alias=alias,
@@ -606,6 +716,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())
@@ -650,7 +761,7 @@ def _freeze(self, attributes: list[DataclassAttribute]) -> None:
         for attr in attributes:
             # Classes that directly specify a dataclass_transform metaclass must be neither frozen
             # non non-frozen per PEP681. Though it is surprising, this means that attributes from
-            # such a class must be writable even if the rest of the class heirarchy is frozen. This
+            # such a class must be writable even if the rest of the class hierarchy is frozen. This
             # matches the behavior of Pyright (the reference implementation).
             if attr.is_neither_frozen_nor_nonfrozen:
                 continue
@@ -659,6 +770,8 @@ def _freeze(self, attributes: list[DataclassAttribute]) -> None:
             if sym_node is not None:
                 var = sym_node.node
                 if isinstance(var, Var):
+                    if var.is_final:
+                        continue  # do not turn `Final` attrs to `@property`
                     var.is_property = True
             else:
                 var = attr.to_var(info)
@@ -854,6 +967,9 @@ def dataclass_tag_callback(ctx: ClassDefContext) -> None:
 
 def dataclass_class_maker_callback(ctx: ClassDefContext) -> bool:
     """Hooks into the class typechecking process to add support for dataclasses."""
+    if any(i.is_named_tuple for i in ctx.cls.info.mro):
+        ctx.api.fail("A NamedTuple cannot be a dataclass", ctx=ctx.cls.info)
+        return True
     transformer = DataclassTransformer(
         ctx.cls, ctx.reason, _get_transform_spec(ctx.reason), ctx.api
     )
@@ -893,3 +1009,129 @@ 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 _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, 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:
+            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:
+        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}",
+    )
+
+
+def is_processed_dataclass(info: TypeInfo) -> bool:
+    return bool(info) and "dataclass" in info.metadata
+
+
+def check_post_init(api: TypeChecker, defn: FuncItem, info: TypeInfo) -> None:
+    if defn.type is None:
+        return
+    assert isinstance(defn.type, FunctionLike)
+
+    ideal_sig_method = info.get_method(_INTERNAL_POST_INIT_SYM_NAME)
+    assert ideal_sig_method is not None and ideal_sig_method.type is not None
+    ideal_sig = ideal_sig_method.type
+    assert isinstance(ideal_sig, ProperType)  # we set it ourselves
+    assert isinstance(ideal_sig, CallableType)
+    ideal_sig = ideal_sig.copy_modified(name="__post_init__")
+
+    api.check_override(
+        override=defn.type,
+        original=ideal_sig,
+        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/mypy/plugins/default.py b/mypy/plugins/default.py
index 500eef76a9d9..81d2f19dc17b 100644
--- a/mypy/plugins/default.py
+++ b/mypy/plugins/default.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import partial
-from typing import Callable
+from typing import Callable, Final
 
 import mypy.errorcodes as codes
 from mypy import message_registry
@@ -31,7 +31,9 @@
     TypedDictType,
     TypeOfAny,
     TypeVarType,
+    UnionType,
     get_proper_type,
+    get_proper_types,
 )
 
 
@@ -39,24 +41,32 @@ class DefaultPlugin(Plugin):
     """Type checker plugin that is enabled by default."""
 
     def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
-        from mypy.plugins import ctypes, singledispatch
+        from mypy.plugins import ctypes, enums, singledispatch
 
         if fullname == "_ctypes.Array":
             return ctypes.array_constructor_callback
         elif fullname == "functools.singledispatch":
             return singledispatch.create_singledispatch_function_callback
+        elif fullname == "functools.partial":
+            import mypy.plugins.functools
+
+            return mypy.plugins.functools.partial_new_callback
+        elif fullname == "enum.member":
+            return enums.enum_member_callback
 
         return None
 
     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(
@@ -70,12 +80,21 @@ def get_method_signature_hook(
             return typed_dict_setdefault_signature_callback
         elif fullname in {n + ".pop" for n in TPDICT_FB_NAMES}:
             return typed_dict_pop_signature_callback
-        elif fullname in {n + ".update" for n in TPDICT_FB_NAMES}:
-            return typed_dict_update_signature_callback
         elif fullname == "_ctypes.Array.__setitem__":
             return ctypes.array_setitem_callback
         elif fullname == singledispatch.SINGLEDISPATCH_CALLABLE_CALL_METHOD:
             return singledispatch.call_singledispatch_function_callback
+
+        typed_dict_updates = set()
+        for n in TPDICT_FB_NAMES:
+            typed_dict_updates.add(n + ".update")
+            typed_dict_updates.add(n + ".__or__")
+            typed_dict_updates.add(n + ".__ror__")
+            typed_dict_updates.add(n + ".__ior__")
+
+        if fullname in typed_dict_updates:
+            return typed_dict_update_signature_callback
+
         return None
 
     def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None:
@@ -87,6 +106,8 @@ def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | No
             return int_pow_callback
         elif fullname == "builtins.int.__neg__":
             return int_neg_callback
+        elif fullname == "builtins.int.__pos__":
+            return int_pos_callback
         elif fullname in ("builtins.tuple.__mul__", "builtins.tuple.__rmul__"):
             return tuple_mul_callback
         elif fullname in {n + ".setdefault" for n in TPDICT_FB_NAMES}:
@@ -103,6 +124,10 @@ def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | No
             return singledispatch.singledispatch_register_callback
         elif fullname == singledispatch.REGISTER_CALLABLE_CALL_METHOD:
             return singledispatch.call_singledispatch_function_after_register_argument
+        elif fullname == "functools.partial.__call__":
+            import mypy.plugins.functools
+
+            return mypy.plugins.functools.partial_call_callback
         return None
 
     def get_attribute_hook(self, fullname: str) -> Callable[[AttributeContext], Type] | None:
@@ -140,12 +165,13 @@ def get_class_decorator_hook(self, fullname: str) -> Callable[[ClassDefContext],
     def get_class_decorator_hook_2(
         self, fullname: str
     ) -> Callable[[ClassDefContext], bool] | None:
-        from mypy.plugins import attrs, dataclasses, functools
+        import mypy.plugins.functools
+        from mypy.plugins import attrs, dataclasses
 
         if fullname in dataclasses.dataclass_makers:
             return dataclasses.dataclass_class_maker_callback
-        elif fullname in functools.functools_total_ordering_makers:
-            return functools.functools_total_ordering_maker_callback
+        elif fullname in mypy.plugins.functools.functools_total_ordering_makers:
+            return mypy.plugins.functools.functools_total_ordering_maker_callback
         elif fullname in attrs.attr_class_makers:
             return attrs.attr_class_maker_callback
         elif fullname in attrs.attr_dataclass_makers:
@@ -155,7 +181,9 @@ def get_class_decorator_hook_2(
                 attrs.attr_class_maker_callback, auto_attribs_default=None, frozen_default=True
             )
         elif fullname in attrs.attr_define_makers:
-            return partial(attrs.attr_class_maker_callback, auto_attribs_default=None)
+            return partial(
+                attrs.attr_class_maker_callback, auto_attribs_default=None, slots_default=True
+            )
 
         return None
 
@@ -276,11 +304,12 @@ def typed_dict_pop_callback(ctx: MethodContext) -> Type:
         and len(ctx.arg_types) >= 1
         and len(ctx.arg_types[0]) == 1
     ):
-        keys = try_getting_str_literals(ctx.args[0][0], ctx.arg_types[0][0])
+        key_expr = ctx.args[0][0]
+        keys = try_getting_str_literals(key_expr, ctx.arg_types[0][0])
         if keys is None:
             ctx.api.fail(
                 message_registry.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL,
-                ctx.context,
+                key_expr,
                 code=codes.LITERAL_REQ,
             )
             return AnyType(TypeOfAny.from_error)
@@ -288,13 +317,13 @@ def typed_dict_pop_callback(ctx: MethodContext) -> Type:
         value_types = []
         for key in keys:
             if key in ctx.type.required_keys:
-                ctx.api.msg.typeddict_key_cannot_be_deleted(ctx.type, key, ctx.context)
+                ctx.api.msg.typeddict_key_cannot_be_deleted(ctx.type, key, key_expr)
 
             value_type = ctx.type.items.get(key)
             if value_type:
                 value_types.append(value_type)
             else:
-                ctx.api.msg.typeddict_key_not_found(ctx.type, key, ctx.context)
+                ctx.api.msg.typeddict_key_not_found(ctx.type, key, key_expr)
                 return AnyType(TypeOfAny.from_error)
 
         if len(ctx.args[1]) == 0:
@@ -335,23 +364,29 @@ def typed_dict_setdefault_callback(ctx: MethodContext) -> Type:
         and len(ctx.arg_types[0]) == 1
         and len(ctx.arg_types[1]) == 1
     ):
-        keys = try_getting_str_literals(ctx.args[0][0], ctx.arg_types[0][0])
+        key_expr = ctx.args[0][0]
+        keys = try_getting_str_literals(key_expr, ctx.arg_types[0][0])
         if keys is None:
             ctx.api.fail(
                 message_registry.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL,
-                ctx.context,
+                key_expr,
                 code=codes.LITERAL_REQ,
             )
             return AnyType(TypeOfAny.from_error)
 
+        assigned_readonly_keys = ctx.type.readonly_keys & set(keys)
+        if assigned_readonly_keys:
+            ctx.api.msg.readonly_keys_mutated(assigned_readonly_keys, context=key_expr)
+
         default_type = ctx.arg_types[1][0]
+        default_expr = ctx.args[1][0]
 
         value_types = []
         for key in keys:
             value_type = ctx.type.items.get(key)
 
             if value_type is None:
-                ctx.api.msg.typeddict_key_not_found(ctx.type, key, ctx.context)
+                ctx.api.msg.typeddict_key_not_found(ctx.type, key, key_expr)
                 return AnyType(TypeOfAny.from_error)
 
             # The signature_callback above can't always infer the right signature
@@ -360,7 +395,7 @@ def typed_dict_setdefault_callback(ctx: MethodContext) -> Type:
             # default can be assigned to all key-value pairs we're updating.
             if not is_subtype(default_type, value_type):
                 ctx.api.msg.typeddict_setdefault_arguments_inconsistent(
-                    default_type, value_type, ctx.context
+                    default_type, value_type, default_expr
                 )
                 return AnyType(TypeOfAny.from_error)
 
@@ -377,31 +412,74 @@ def typed_dict_delitem_callback(ctx: MethodContext) -> Type:
         and len(ctx.arg_types) == 1
         and len(ctx.arg_types[0]) == 1
     ):
-        keys = try_getting_str_literals(ctx.args[0][0], ctx.arg_types[0][0])
+        key_expr = ctx.args[0][0]
+        keys = try_getting_str_literals(key_expr, ctx.arg_types[0][0])
         if keys is None:
             ctx.api.fail(
                 message_registry.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL,
-                ctx.context,
+                key_expr,
                 code=codes.LITERAL_REQ,
             )
             return AnyType(TypeOfAny.from_error)
 
         for key in keys:
-            if key in ctx.type.required_keys:
-                ctx.api.msg.typeddict_key_cannot_be_deleted(ctx.type, key, ctx.context)
+            if key in ctx.type.required_keys or key in ctx.type.readonly_keys:
+                ctx.api.msg.typeddict_key_cannot_be_deleted(ctx.type, key, key_expr)
             elif key not in ctx.type.items:
-                ctx.api.msg.typeddict_key_not_found(ctx.type, key, ctx.context)
+                ctx.api.msg.typeddict_key_not_found(ctx.type, key, key_expr)
     return ctx.default_return_type
 
 
+_TP_DICT_MUTATING_METHODS: Final = frozenset({"update of TypedDict", "__ior__ of TypedDict"})
+
+
 def typed_dict_update_signature_callback(ctx: MethodSigContext) -> CallableType:
-    """Try to infer a better signature type for TypedDict.update."""
+    """Try to infer a better signature type for methods that update `TypedDict`.
+
+    This includes: `TypedDict.update`, `TypedDict.__or__`, `TypedDict.__ror__`,
+    and `TypedDict.__ior__`.
+    """
     signature = ctx.default_signature
     if isinstance(ctx.type, TypedDictType) and len(signature.arg_types) == 1:
         arg_type = get_proper_type(signature.arg_types[0])
-        assert isinstance(arg_type, TypedDictType)
+        if not isinstance(arg_type, TypedDictType):
+            return signature
         arg_type = arg_type.as_anonymous()
         arg_type = arg_type.copy_modified(required_keys=set())
+        if ctx.args and ctx.args[0]:
+            if signature.name in _TP_DICT_MUTATING_METHODS:
+                # If we want to mutate this object in place, we need to set this flag,
+                # it will trigger an extra check in TypedDict's checker.
+                arg_type.to_be_mutated = True
+            with ctx.api.msg.filter_errors(
+                filter_errors=lambda name, info: info.code != codes.TYPEDDICT_READONLY_MUTATED,
+                save_filtered_errors=True,
+            ):
+                inferred = get_proper_type(
+                    ctx.api.get_expression_type(ctx.args[0][0], type_context=arg_type)
+                )
+            if arg_type.to_be_mutated:
+                arg_type.to_be_mutated = False  # Done!
+            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
 
@@ -426,32 +504,43 @@ def int_pow_callback(ctx: MethodContext) -> Type:
     return ctx.default_return_type
 
 
-def int_neg_callback(ctx: MethodContext) -> Type:
-    """Infer a more precise return type for int.__neg__.
+def int_neg_callback(ctx: MethodContext, multiplier: int = -1) -> Type:
+    """Infer a more precise return type for int.__neg__ and int.__pos__.
 
     This is mainly used to infer the return type as LiteralType
-    if the original underlying object is a LiteralType object
+    if the original underlying object is a LiteralType object.
     """
     if isinstance(ctx.type, Instance) and ctx.type.last_known_value is not None:
         value = ctx.type.last_known_value.value
         fallback = ctx.type.last_known_value.fallback
         if isinstance(value, int):
             if is_literal_type_like(ctx.api.type_context[-1]):
-                return LiteralType(value=-value, fallback=fallback)
+                return LiteralType(value=multiplier * value, fallback=fallback)
             else:
                 return ctx.type.copy_modified(
                     last_known_value=LiteralType(
-                        value=-value, fallback=ctx.type, line=ctx.type.line, column=ctx.type.column
+                        value=multiplier * value,
+                        fallback=fallback,
+                        line=ctx.type.line,
+                        column=ctx.type.column,
                     )
                 )
     elif isinstance(ctx.type, LiteralType):
         value = ctx.type.value
         fallback = ctx.type.fallback
         if isinstance(value, int):
-            return LiteralType(value=-value, fallback=fallback)
+            return LiteralType(value=multiplier * value, fallback=fallback)
     return ctx.default_return_type
 
 
+def int_pos_callback(ctx: MethodContext) -> Type:
+    """Infer a more precise return type for int.__pos__.
+
+    This is identical to __neg__, except the value is not inverted.
+    """
+    return int_neg_callback(ctx, +1)
+
+
 def tuple_mul_callback(ctx: MethodContext) -> Type:
     """Infer a more precise return type for tuple.__mul__ and tuple.__rmul__.
 
@@ -465,7 +554,7 @@ def tuple_mul_callback(ctx: MethodContext) -> Type:
         value = arg_type.last_known_value.value
         if isinstance(value, int):
             return ctx.type.copy_modified(items=ctx.type.items * value)
-    elif isinstance(ctx.type, LiteralType):
+    elif isinstance(arg_type, LiteralType):
         value = arg_type.value
         if isinstance(value, int):
             return ctx.type.copy_modified(items=ctx.type.items * value)
diff --git a/mypy/plugins/enums.py b/mypy/plugins/enums.py
index 1acf42d11ee6..8b7c5df6f51f 100644
--- a/mypy/plugins/enums.py
+++ b/mypy/plugins/enums.py
@@ -10,17 +10,26 @@
 we actually bake some of it directly in to the semantic analysis layer (see
 semanal_enum.py).
 """
+
 from __future__ import annotations
 
-from typing import Iterable, Sequence, TypeVar, cast
-from typing_extensions import Final
+from collections.abc import Iterable, Sequence
+from typing import Final, TypeVar, cast
 
 import mypy.plugin  # To avoid circular imports.
 from mypy.nodes import TypeInfo
 from mypy.semanal_enum import ENUM_BASES
 from mypy.subtypes import is_equivalent
 from mypy.typeops import fixup_partial_type, make_simplified_union
-from mypy.types import CallableType, Instance, LiteralType, ProperType, Type, get_proper_type
+from mypy.types import (
+    CallableType,
+    Instance,
+    LiteralType,
+    ProperType,
+    Type,
+    get_proper_type,
+    is_named_instance,
+)
 
 ENUM_NAME_ACCESS: Final = {f"{prefix}.name" for prefix in ENUM_BASES} | {
     f"{prefix}._name_" for prefix in ENUM_BASES
@@ -79,6 +88,8 @@ def _infer_value_type_with_auto_fallback(
         return None
     proper_type = get_proper_type(fixup_partial_type(proper_type))
     if not (isinstance(proper_type, Instance) and proper_type.type.fullname == "enum.auto"):
+        if is_named_instance(proper_type, "enum.member") and proper_type.args:
+            return proper_type.args[0]
         return proper_type
     assert isinstance(ctx.type, Instance), "An incorrect ctx.type was passed."
     info = ctx.type.type
@@ -118,6 +129,22 @@ def _implements_new(info: TypeInfo) -> bool:
     return type_with_new.fullname not in ("enum.Enum", "enum.IntEnum", "enum.StrEnum")
 
 
+def enum_member_callback(ctx: mypy.plugin.FunctionContext) -> Type:
+    """By default `member(1)` will be inferred as `member[int]`,
+    we want to improve the inference to be `Literal[1]` here."""
+    if ctx.arg_types or ctx.arg_types[0]:
+        arg = get_proper_type(ctx.arg_types[0][0])
+        proper_return = get_proper_type(ctx.default_return_type)
+        if (
+            isinstance(arg, Instance)
+            and arg.last_known_value
+            and isinstance(proper_return, Instance)
+            and len(proper_return.args) == 1
+        ):
+            return proper_return.copy_modified(args=[arg])
+    return ctx.default_return_type
+
+
 def enum_value_callback(ctx: mypy.plugin.AttributeContext) -> Type:
     """This plugin refines the 'value' attribute in enums to refer to
     the original underlying value. For example, suppose we have the
@@ -159,7 +186,7 @@ class SomeEnum:
 
             stnodes = (info.get(name) for name in info.names)
 
-            # Enums _can_ have methods and instance attributes.
+            # Enums _can_ have methods, instance attributes, and `nonmember`s.
             # Omit methods and attributes created by assigning to self.*
             # for our value inference.
             node_types = (
@@ -167,11 +194,12 @@ class SomeEnum:
                 for n in stnodes
                 if n is None or not n.implicit
             )
-            proper_types = list(
+            proper_types = [
                 _infer_value_type_with_auto_fallback(ctx, t)
                 for t in node_types
-                if t is None or not isinstance(t, CallableType)
-            )
+                if t is None
+                or (not isinstance(t, CallableType) and not is_named_instance(t, "enum.nonmember"))
+            ]
             underlying_type = _first(proper_types)
             if underlying_type is None:
                 return ctx.default_attr_type
diff --git a/mypy/plugins/functools.py b/mypy/plugins/functools.py
index eba4d77f2343..25a8c83007ba 100644
--- a/mypy/plugins/functools.py
+++ b/mypy/plugins/functools.py
@@ -1,18 +1,46 @@
 """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.checker
 import mypy.plugin
-from mypy.nodes import ARG_POS, ARG_STAR2, Argument, FuncItem, Var
+import mypy.semanal
+from mypy.argmap import map_actuals_to_formals
+from mypy.nodes import (
+    ARG_POS,
+    ARG_STAR2,
+    SYMBOL_FUNCBASE_TYPES,
+    ArgKind,
+    Argument,
+    CallExpr,
+    NameExpr,
+    Var,
+)
 from mypy.plugins.common import add_method_to_class
-from mypy.types import AnyType, CallableType, Type, TypeOfAny, UnboundType, get_proper_type
+from mypy.typeops import get_all_type_vars
+from mypy.types import (
+    AnyType,
+    CallableType,
+    Instance,
+    Overloaded,
+    ParamSpecFlavor,
+    ParamSpecType,
+    Type,
+    TypeOfAny,
+    TypeVarType,
+    UnboundType,
+    UnionType,
+    get_proper_type,
+)
 
 functools_total_ordering_makers: Final = {"functools.total_ordering"}
 
 _ORDERING_METHODS: Final = {"__lt__", "__le__", "__gt__", "__ge__"}
 
+PARTIAL: Final = "functools.partial"
+
 
 class _MethodInfo(NamedTuple):
     is_static: bool
@@ -89,7 +117,7 @@ def _analyze_class(ctx: mypy.plugin.ClassDefContext) -> dict[str, _MethodInfo |
         for name in _ORDERING_METHODS:
             if name in cls.names and name not in comparison_methods:
                 node = cls.names[name].node
-                if isinstance(node, FuncItem) and isinstance(node.type, CallableType):
+                if isinstance(node, SYMBOL_FUNCBASE_TYPES) and isinstance(node.type, CallableType):
                     comparison_methods[name] = _MethodInfo(node.is_static, node.type)
                     continue
 
@@ -102,3 +130,261 @@ def _analyze_class(ctx: mypy.plugin.ClassDefContext) -> dict[str, _MethodInfo |
                 comparison_methods[name] = None
 
     return comparison_methods
+
+
+def partial_new_callback(ctx: mypy.plugin.FunctionContext) -> Type:
+    """Infer a more precise return type for functools.partial"""
+    if not isinstance(ctx.api, mypy.checker.TypeChecker):  # use internals
+        return ctx.default_return_type
+    if len(ctx.arg_types) != 3:  # fn, *args, **kwargs
+        return ctx.default_return_type
+    if len(ctx.arg_types[0]) != 1:
+        return ctx.default_return_type
+
+    if isinstance(get_proper_type(ctx.arg_types[0][0]), Overloaded):
+        # TODO: handle overloads, just fall back to whatever the non-plugin code does
+        return ctx.default_return_type
+    return handle_partial_with_callee(ctx, callee=ctx.arg_types[0][0])
+
+
+def handle_partial_with_callee(ctx: mypy.plugin.FunctionContext, callee: Type) -> Type:
+    if not isinstance(ctx.api, mypy.checker.TypeChecker):  # use internals
+        return ctx.default_return_type
+
+    if isinstance(callee_proper := get_proper_type(callee), UnionType):
+        return UnionType.make_union(
+            [handle_partial_with_callee(ctx, item) for item in callee_proper.items]
+        )
+
+    fn_type = ctx.api.extract_callable_type(callee, ctx=ctx.default_return_type)
+    if fn_type is None:
+        return ctx.default_return_type
+
+    # We must normalize from the start to have coherent view together with TypeChecker.
+    fn_type = fn_type.with_unpacked_kwargs().with_normalized_var_args()
+
+    last_context = ctx.api.type_context[-1]
+    if not fn_type.is_type_obj():
+        # We wrap the return type to get use of a possible type context provided by caller.
+        # We cannot do this in case of class objects, since otherwise the plugin may get
+        # falsely triggered when evaluating the constructed call itself.
+        ret_type: Type = ctx.api.named_generic_type(PARTIAL, [fn_type.ret_type])
+        wrapped_return = True
+    else:
+        ret_type = fn_type.ret_type
+        # Instead, for class objects we ignore any type context to avoid spurious errors,
+        # since the type context will be partial[X] etc., not X.
+        ctx.api.type_context[-1] = None
+        wrapped_return = False
+
+    # Flatten actual to formal mapping, since this is what check_call() expects.
+    actual_args = []
+    actual_arg_kinds = []
+    actual_arg_names = []
+    actual_types = []
+    seen_args = set()
+    for i, param in enumerate(ctx.args[1:], start=1):
+        for j, a in enumerate(param):
+            if a in seen_args:
+                # Same actual arg can map to multiple formals, but we need to include
+                # each one only once.
+                continue
+            # Here we rely on the fact that expressions are essentially immutable, so
+            # they can be compared by identity.
+            seen_args.add(a)
+            actual_args.append(a)
+            actual_arg_kinds.append(ctx.arg_kinds[i][j])
+            actual_arg_names.append(ctx.arg_names[i][j])
+            actual_types.append(ctx.arg_types[i][j])
+
+    formal_to_actual = map_actuals_to_formals(
+        actual_kinds=actual_arg_kinds,
+        actual_names=actual_arg_names,
+        formal_kinds=fn_type.arg_kinds,
+        formal_names=fn_type.arg_names,
+        actual_arg_type=lambda i: actual_types[i],
+    )
+
+    # We need to remove any type variables that appear only in formals that have
+    # no actuals, to avoid eagerly binding them in check_call() below.
+    can_infer_ids = set()
+    for i, arg_type in enumerate(fn_type.arg_types):
+        if not formal_to_actual[i]:
+            continue
+        can_infer_ids.update({tv.id for tv in get_all_type_vars(arg_type)})
+
+    # special_sig="partial" allows omission of args/kwargs typed with ParamSpec
+    defaulted = fn_type.copy_modified(
+        arg_kinds=[
+            (
+                ArgKind.ARG_OPT
+                if k == ArgKind.ARG_POS
+                else (ArgKind.ARG_NAMED_OPT if k == ArgKind.ARG_NAMED else k)
+            )
+            for k in fn_type.arg_kinds
+        ],
+        ret_type=ret_type,
+        variables=[
+            tv
+            for tv in fn_type.variables
+            # Keep TypeVarTuple/ParamSpec to avoid spurious errors on empty args.
+            if tv.id in can_infer_ids or not isinstance(tv, TypeVarType)
+        ],
+        special_sig="partial",
+    )
+    if defaulted.line < 0:
+        # Make up a line number if we don't have one
+        defaulted.set_line(ctx.default_return_type)
+
+    # Create a valid context for various ad-hoc inspections in check_call().
+    call_expr = CallExpr(
+        callee=ctx.args[0][0],
+        args=actual_args,
+        arg_kinds=actual_arg_kinds,
+        arg_names=actual_arg_names,
+        analyzed=ctx.context.analyzed if isinstance(ctx.context, CallExpr) else None,
+    )
+    call_expr.set_line(ctx.context)
+
+    _, bound = ctx.api.expr_checker.check_call(
+        callee=defaulted,
+        args=actual_args,
+        arg_kinds=actual_arg_kinds,
+        arg_names=actual_arg_names,
+        context=call_expr,
+    )
+    if not wrapped_return:
+        # Restore previously ignored context.
+        ctx.api.type_context[-1] = last_context
+
+    bound = get_proper_type(bound)
+    if not isinstance(bound, CallableType):
+        return ctx.default_return_type
+
+    if wrapped_return:
+        # Reverse the wrapping we did above.
+        ret_type = get_proper_type(bound.ret_type)
+        if not isinstance(ret_type, Instance) or ret_type.type.fullname != PARTIAL:
+            return ctx.default_return_type
+        bound = bound.copy_modified(ret_type=ret_type.args[0])
+
+    partial_kinds = []
+    partial_types = []
+    partial_names = []
+    # We need to fully apply any positional arguments (they cannot be respecified)
+    # However, keyword arguments can be respecified, so just give them a default
+    for i, actuals in enumerate(formal_to_actual):
+        if len(bound.arg_types) == len(fn_type.arg_types):
+            arg_type = bound.arg_types[i]
+            if not mypy.checker.is_valid_inferred_type(arg_type, ctx.api.options):
+                arg_type = fn_type.arg_types[i]  # bit of a hack
+        else:
+            # TODO: I assume that bound and fn_type have the same arguments. It appears this isn't
+            # true when PEP 646 things are happening. See testFunctoolsPartialTypeVarTuple
+            arg_type = fn_type.arg_types[i]
+
+        if not actuals or fn_type.arg_kinds[i] in (ArgKind.ARG_STAR, ArgKind.ARG_STAR2):
+            partial_kinds.append(fn_type.arg_kinds[i])
+            partial_types.append(arg_type)
+            partial_names.append(fn_type.arg_names[i])
+        else:
+            assert actuals
+            if any(actual_arg_kinds[j] in (ArgKind.ARG_POS, ArgKind.ARG_STAR) for j in actuals):
+                # Don't add params for arguments passed positionally
+                continue
+            # Add defaulted params for arguments passed via keyword
+            kind = actual_arg_kinds[actuals[0]]
+            if kind == ArgKind.ARG_NAMED or kind == ArgKind.ARG_STAR2:
+                kind = ArgKind.ARG_NAMED_OPT
+            partial_kinds.append(kind)
+            partial_types.append(arg_type)
+            partial_names.append(fn_type.arg_names[i])
+
+    ret_type = bound.ret_type
+    if not mypy.checker.is_valid_inferred_type(ret_type, ctx.api.options):
+        ret_type = fn_type.ret_type  # same kind of hack as above
+
+    partially_applied = fn_type.copy_modified(
+        arg_types=partial_types,
+        arg_kinds=partial_kinds,
+        arg_names=partial_names,
+        ret_type=ret_type,
+        special_sig="partial",
+    )
+
+    ret = ctx.api.named_generic_type(PARTIAL, [ret_type])
+    ret = ret.copy_with_extra_attr("__mypy_partial", partially_applied)
+    if partially_applied.param_spec():
+        assert ret.extra_attrs is not None  # copy_with_extra_attr above ensures this
+        attrs = ret.extra_attrs.copy()
+        if ArgKind.ARG_STAR in actual_arg_kinds:
+            attrs.immutable.add("__mypy_partial_paramspec_args_bound")
+        if ArgKind.ARG_STAR2 in actual_arg_kinds:
+            attrs.immutable.add("__mypy_partial_paramspec_kwargs_bound")
+        ret.extra_attrs = attrs
+    return ret
+
+
+def partial_call_callback(ctx: mypy.plugin.MethodContext) -> Type:
+    """Infer a more precise return type for functools.partial.__call__."""
+    if (
+        not isinstance(ctx.api, mypy.checker.TypeChecker)  # use internals
+        or not isinstance(ctx.type, Instance)
+        or ctx.type.type.fullname != PARTIAL
+        or not ctx.type.extra_attrs
+        or "__mypy_partial" not in ctx.type.extra_attrs.attrs
+    ):
+        return ctx.default_return_type
+
+    extra_attrs = ctx.type.extra_attrs
+    partial_type = get_proper_type(extra_attrs.attrs["__mypy_partial"])
+    if len(ctx.arg_types) != 2:  # *args, **kwargs
+        return ctx.default_return_type
+
+    # See comments for similar actual to formal code above
+    actual_args = []
+    actual_arg_kinds = []
+    actual_arg_names = []
+    seen_args = set()
+    for i, param in enumerate(ctx.args):
+        for j, a in enumerate(param):
+            if a in seen_args:
+                continue
+            seen_args.add(a)
+            actual_args.append(a)
+            actual_arg_kinds.append(ctx.arg_kinds[i][j])
+            actual_arg_names.append(ctx.arg_names[i][j])
+
+    result, _ = ctx.api.expr_checker.check_call(
+        callee=partial_type,
+        args=actual_args,
+        arg_kinds=actual_arg_kinds,
+        arg_names=actual_arg_names,
+        context=ctx.context,
+    )
+    if not isinstance(partial_type, CallableType) or partial_type.param_spec() is None:
+        return result
+
+    args_bound = "__mypy_partial_paramspec_args_bound" in extra_attrs.immutable
+    kwargs_bound = "__mypy_partial_paramspec_kwargs_bound" in extra_attrs.immutable
+
+    passed_paramspec_parts = [
+        arg.node.type
+        for arg in actual_args
+        if isinstance(arg, NameExpr)
+        and isinstance(arg.node, Var)
+        and isinstance(arg.node.type, ParamSpecType)
+    ]
+    # ensure *args: P.args
+    args_passed = any(part.flavor == ParamSpecFlavor.ARGS for part in passed_paramspec_parts)
+    if not args_bound and not args_passed:
+        ctx.api.expr_checker.msg.too_few_arguments(partial_type, ctx.context, actual_arg_names)
+    elif args_bound and args_passed:
+        ctx.api.expr_checker.msg.too_many_arguments(partial_type, ctx.context)
+
+    # ensure **kwargs: P.kwargs
+    kwargs_passed = any(part.flavor == ParamSpecFlavor.KWARGS for part in passed_paramspec_parts)
+    if not kwargs_bound and not kwargs_passed:
+        ctx.api.expr_checker.msg.too_few_arguments(partial_type, ctx.context, actual_arg_names)
+
+    return result
diff --git a/misc/proper_plugin.py b/mypy/plugins/proper_plugin.py
similarity index 94%
rename from misc/proper_plugin.py
rename to mypy/plugins/proper_plugin.py
index a6e6dc03b625..f51685c80afa 100644
--- a/misc/proper_plugin.py
+++ b/mypy/plugins/proper_plugin.py
@@ -1,3 +1,12 @@
+"""
+This plugin is helpful for mypy development itself.
+By default, it is not enabled for mypy users.
+
+It also can be used by plugin developers as a part of their CI checks.
+
+It finds missing ``get_proper_type()`` call, which can lead to multiple errors.
+"""
+
 from __future__ import annotations
 
 from typing import Callable
@@ -8,7 +17,6 @@
 from mypy.subtypes import is_proper_subtype
 from mypy.types import (
     AnyType,
-    CallableType,
     FunctionLike,
     Instance,
     NoneTyp,
@@ -98,6 +106,7 @@ def is_special_target(right: ProperType) -> bool:
             "mypy.types.ErasedType",
             "mypy.types.DeletedType",
             "mypy.types.RequiredType",
+            "mypy.types.ReadOnlyType",
         ):
             # Special case: these are not valid targets for a type alias and thus safe.
             # TODO: introduce a SyntheticType base to simplify this?
@@ -122,7 +131,7 @@ def is_dangerous_target(typ: ProperType) -> bool:
     """Is this a dangerous target (right argument) for an isinstance() check?"""
     if isinstance(typ, TupleType):
         return any(is_dangerous_target(get_proper_type(t)) for t in typ.items)
-    if isinstance(typ, CallableType) and typ.is_type_obj():
+    if isinstance(typ, FunctionLike) and typ.is_type_obj():
         return typ.type_object().has_base("mypy.types.Type")
     return False
 
diff --git a/mypy/plugins/singledispatch.py b/mypy/plugins/singledispatch.py
index a44493f900b1..be4b405ce610 100644
--- a/mypy/plugins/singledispatch.py
+++ b/mypy/plugins/singledispatch.py
@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from typing import NamedTuple, Sequence, TypeVar, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from collections.abc import Sequence
+from typing import Final, NamedTuple, 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/pyinfo.py b/mypy/pyinfo.py
index 778b0b163ce6..98350f46363c 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.9+ 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.9. This file is run each mypy run, so it should be kept
+as fast as possible.
 """
 import sys
 
@@ -71,6 +71,7 @@ def getsearchdirs() -> tuple[list[str], list[str]]:
 
 
 if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[union-attr]
     if sys.argv[-1] == "getsearchdirs":
         print(repr(getsearchdirs()))
     else:
diff --git a/mypy/reachability.py b/mypy/reachability.py
index 8602fc645e2b..5d170b5071db 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, TypeVar
 
 from mypy.literals import literal
 from mypy.nodes import (
@@ -222,7 +221,7 @@ def consider_sys_platform(expr: Expression, platform: str) -> int:
     Return ALWAYS_TRUE, ALWAYS_FALSE, or TRUTH_VALUE_UNKNOWN.
     """
     # Cases supported:
-    # - sys.platform == 'posix'
+    # - sys.platform == 'linux'
     # - sys.platform != 'win32'
     # - sys.platform.startswith('win')
     if isinstance(expr, ComparisonExpr):
@@ -255,7 +254,7 @@ def consider_sys_platform(expr: Expression, platform: str) -> int:
         return TRUTH_VALUE_UNKNOWN
 
 
-Targ = TypeVar("Targ", int, str, Tuple[int, ...])
+Targ = TypeVar("Targ", int, str, tuple[int, ...])
 
 
 def fixed_comparison(left: Targ, op: str, right: Targ) -> int:
diff --git a/mypy/renaming.py b/mypy/renaming.py
index 2fa3ef168a66..dff76b157acc 100644
--- a/mypy/renaming.py
+++ b/mypy/renaming.py
@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator
-from typing_extensions import Final
+from typing import Final
 
 from mypy.nodes import (
     AssignmentStmt,
@@ -152,7 +152,21 @@ def visit_try_stmt(self, stmt: TryStmt) -> None:
         # type checker which allows them to be always redefined, so no need to
         # do renaming here.
         with self.enter_try():
-            super().visit_try_stmt(stmt)
+            stmt.body.accept(self)
+
+        for var, tp, handler in zip(stmt.vars, stmt.types, stmt.handlers):
+            with self.enter_block():
+                # Handle except variable together with its body
+                if tp is not None:
+                    tp.accept(self)
+                if var is not None:
+                    self.handle_def(var)
+                for s in handler.body:
+                    s.accept(self)
+        if stmt.else_body is not None:
+            stmt.else_body.accept(self)
+        if stmt.finally_body is not None:
+            stmt.finally_body.accept(self)
 
     def visit_with_stmt(self, stmt: WithStmt) -> None:
         for expr in stmt.expr:
@@ -271,7 +285,7 @@ def flush_refs(self) -> None:
         This will be called at the end of a scope.
         """
         is_func = self.scope_kinds[-1] == FUNCTION
-        for name, refs in self.refs[-1].items():
+        for refs in self.refs[-1].values():
             if len(refs) == 1:
                 # Only one definition -- no renaming needed.
                 continue
diff --git a/mypy/report.py b/mypy/report.py
index 81d49baf50da..39cd80ed38bf 100644
--- a/mypy/report.py
+++ b/mypy/report.py
@@ -11,9 +11,10 @@
 import time
 import tokenize
 from abc import ABCMeta, abstractmethod
+from collections.abc import Iterator
 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, Final
+from typing_extensions import TypeAlias as _TypeAlias
 from urllib.request import pathname2url
 
 from mypy import stats
@@ -25,7 +26,7 @@
 from mypy.version import __version__
 
 try:
-    from lxml import etree  # type: ignore[import]
+    from lxml import etree  # type: ignore[import-untyped]
 
     LXML_INSTALLED = True
 except ImportError:
@@ -43,8 +44,8 @@
     ]
 )
 
-ReporterClasses: _TypeAlias = Dict[
-    str, Tuple[Callable[["Reports", str], "AbstractReporter"], bool]
+ReporterClasses: _TypeAlias = dict[
+    str, tuple[Callable[["Reports", str], "AbstractReporter"], bool]
 ]
 
 reporter_classes: Final[ReporterClasses] = {}
@@ -99,7 +100,7 @@ class AbstractReporter(metaclass=ABCMeta):
     def __init__(self, reports: Reports, output_dir: str) -> None:
         self.output_dir = output_dir
         if output_dir != "<memory>":
-            stats.ensure_dir_exists(output_dir)
+            os.makedirs(output_dir, exist_ok=True)
 
     @abstractmethod
     def on_file(
@@ -171,8 +172,12 @@ def on_file(
     ) -> None:
         # Count physical lines.  This assumes the file's encoding is a
         # superset of ASCII (or at least uses \n in its line endings).
-        with open(tree.path, "rb") as f:
-            physical_lines = len(f.readlines())
+        try:
+            with open(tree.path, "rb") as f:
+                physical_lines = len(f.readlines())
+        except IsADirectoryError:
+            # can happen with namespace packages
+            physical_lines = 0
 
         func_counter = FuncCounterVisitor()
         tree.accept(func_counter)
@@ -685,6 +690,8 @@ def on_finish(self) -> None:
             self.root_package.covered_lines, self.root_package.total_lines
         )
         self.root.attrib["branch-rate"] = "0"
+        self.root.attrib["lines-covered"] = str(self.root_package.covered_lines)
+        self.root.attrib["lines-valid"] = str(self.root_package.total_lines)
         sources = etree.SubElement(self.root, "sources")
         source_element = etree.SubElement(sources, "source")
         source_element.text = os.getcwd()
@@ -733,7 +740,7 @@ def on_file(
         if path.startswith(".."):
             return
         out_path = os.path.join(self.output_dir, "xml", path + ".xml")
-        stats.ensure_dir_exists(os.path.dirname(out_path))
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
         last_xml.write(out_path, encoding="utf-8")
 
     def on_finish(self) -> None:
@@ -778,7 +785,7 @@ def on_file(
         if path.startswith(".."):
             return
         out_path = os.path.join(self.output_dir, "html", path + ".html")
-        stats.ensure_dir_exists(os.path.dirname(out_path))
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
         transformed_html = bytes(self.xslt_html(last_xml, ext=self.param_html))
         with open(out_path, "wb") as out_file:
             out_file.write(transformed_html)
diff --git a/mypy/scope.py b/mypy/scope.py
index 021dd9a7d8a5..766048c41180 100644
--- a/mypy/scope.py
+++ b/mypy/scope.py
@@ -5,13 +5,14 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from contextlib import contextmanager, nullcontext
-from typing import Iterator, Optional, Tuple
+from typing import Optional
 from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.nodes import FuncBase, TypeInfo
 
-SavedScope: _TypeAlias = Tuple[str, Optional[TypeInfo], Optional[FuncBase]]
+SavedScope: _TypeAlias = tuple[str, Optional[TypeInfo], Optional[FuncBase]]
 
 
 class Scope:
diff --git a/mypy/semanal.py b/mypy/semanal.py
index c5a6989f4f61..89bb5ab97c2a 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -50,15 +50,17 @@
 
 from __future__ import annotations
 
+from collections.abc import Collection, Iterable, Iterator
 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, Final, TypeVar, cast
+from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
 
 from mypy import errorcodes as codes, message_registry
 from mypy.constant_fold import constant_fold_expr
-from mypy.errorcodes import ErrorCode
+from mypy.errorcodes import PROPERTY_DECORATOR, ErrorCode
 from mypy.errors import Errors, report_internal_error
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
+from mypy.message_registry import ErrorMessage
 from mypy.messages import (
     SUGGESTED_TEST_FIXTURES,
     TYPES_FOR_UNIMPORTED_HINTS,
@@ -70,7 +72,6 @@
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
-    ARG_STAR,
     ARG_STAR2,
     CONTRAVARIANT,
     COVARIANT,
@@ -81,9 +82,14 @@
     LDEF,
     MDEF,
     NOT_ABSTRACT,
+    PARAM_SPEC_KIND,
     REVEAL_LOCALS,
     REVEAL_TYPE,
     RUNTIME_PROTOCOL_DECOS,
+    SYMBOL_FUNCBASE_TYPES,
+    TYPE_VAR_KIND,
+    TYPE_VAR_TUPLE_KIND,
+    VARIANCE_NOT_READY,
     ArgKind,
     AssertStmt,
     AssertTypeExpr,
@@ -92,10 +98,12 @@
     AwaitExpr,
     Block,
     BreakStmt,
+    BytesExpr,
     CallExpr,
     CastExpr,
     ClassDef,
     ComparisonExpr,
+    ComplexExpr,
     ConditionalExpr,
     Context,
     ContinueStmt,
@@ -109,6 +117,7 @@
     Expression,
     ExpressionStmt,
     FakeExpression,
+    FloatExpr,
     ForStmt,
     FuncBase,
     FuncDef,
@@ -121,6 +130,7 @@
     ImportBase,
     ImportFrom,
     IndexExpr,
+    IntExpr,
     LambdaExpr,
     ListComprehension,
     ListExpr,
@@ -159,9 +169,11 @@
     TupleExpr,
     TypeAlias,
     TypeAliasExpr,
+    TypeAliasStmt,
     TypeApplication,
     TypedDictExpr,
     TypeInfo,
+    TypeParam,
     TypeVarExpr,
     TypeVarLikeExpr,
     TypeVarTupleExpr,
@@ -179,13 +191,14 @@
     type_aliases_source_versions,
     typing_extensions_aliases,
 )
-from mypy.options import TYPE_VAR_TUPLE, Options
+from mypy.options import Options
 from mypy.patterns import (
     AsPattern,
     ClassPattern,
     MappingPattern,
     OrPattern,
     SequencePattern,
+    SingletonPattern,
     StarredPattern,
     ValuePattern,
 )
@@ -224,25 +237,28 @@
 from mypy.tvar_scope import TypeVarLikeScope
 from mypy.typeanal import (
     SELF_TYPE_NAMES,
+    FindTypeVarVisitor,
     TypeAnalyser,
+    TypeVarDefaultTranslator,
     TypeVarLikeList,
-    TypeVarLikeQuery,
     analyze_type_alias,
     check_for_explicit_any,
     detect_diverging_alias,
     find_self_type,
-    fix_instance_types,
+    fix_instance,
     has_any_from_unimported_type,
     no_subscript_builtin_alias,
-    remove_dups,
     type_constructors,
+    validate_instance,
 )
 from mypy.typeops import function_type, get_type_vars, try_getting_str_literals_from_type
 from mypy.types import (
     ASSERT_TYPE_NAMES,
     DATACLASS_TRANSFORM_NAMES,
+    DEPRECATED_TYPE_NAMES,
     FINAL_DECORATOR_NAMES,
     FINAL_TYPE_NAMES,
+    IMPORTED_REVEAL_TYPE_NAMES,
     NEVER_NAMES,
     OVERLOAD_NAMES,
     OVERRIDE_DECORATOR_NAMES,
@@ -250,7 +266,10 @@
     REVEAL_TYPE_NAMES,
     TPDICT_NAMES,
     TYPE_ALIAS_NAMES,
+    TYPE_CHECK_ONLY_NAMES,
+    TYPE_VAR_LIKE_NAMES,
     TYPED_NAMEDTUPLE_NAMES,
+    UNPACK_TYPE_NAMES,
     AnyType,
     CallableType,
     FunctionLike,
@@ -269,25 +288,23 @@
     TypedDictType,
     TypeOfAny,
     TypeType,
+    TypeVarId,
     TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
     UnboundType,
+    UnionType,
     UnpackType,
     get_proper_type,
     get_proper_types,
+    has_type_vars,
     is_named_instance,
+    remove_dups,
+    type_vars_as_args,
 )
 from mypy.types_utils import is_invalid_recursive_alias, store_argument_type
 from mypy.typevars import fill_typevars
-from mypy.util import (
-    correct_relative_import,
-    is_dunder,
-    is_typeshed_file,
-    module_prefix,
-    unmangle,
-    unnamed_function,
-)
+from mypy.util import correct_relative_import, is_dunder, module_prefix, unmangle, unnamed_function
 from mypy.visitor import NodeVisitor
 
 T = TypeVar("T")
@@ -312,6 +329,14 @@
 CORE_BUILTIN_CLASSES: Final = ["object", "bool", "function"]
 
 
+# Python has several different scope/namespace kinds with subtly different semantics.
+SCOPE_GLOBAL: Final = 0  # Module top level
+SCOPE_CLASS: Final = 1  # Class body
+SCOPE_FUNC: Final = 2  # Function or lambda
+SCOPE_COMPREHENSION: Final = 3  # Comprehension or generator expression
+SCOPE_ANNOTATION: Final = 4  # Annotation scopes for type parameters and aliases (PEP 695)
+
+
 # Used for tracking incomplete references
 Tag: _TypeAlias = int
 
@@ -337,8 +362,8 @@ class SemanticAnalyzer(
     nonlocal_decls: list[set[str]]
     # Local names of function scopes; None for non-function scopes.
     locals: list[SymbolTable | None]
-    # Whether each scope is a comprehension scope.
-    is_comprehension_stack: list[bool]
+    # Type of each scope (SCOPE_*, indexes match locals)
+    scope_stack: list[int]
     # Nested block depths of scopes
     block_depth: list[int]
     # TypeInfo of directly enclosing class (or None)
@@ -375,7 +400,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?
@@ -412,7 +437,7 @@ def __init__(
             errors: Report analysis errors using this instance
         """
         self.locals = [None]
-        self.is_comprehension_stack = [False]
+        self.scope_stack = [SCOPE_GLOBAL]
         # Saved namespaces from previous iteration. Every top-level function/method body is
         # analyzed in several iterations until all names are resolved. We need to save
         # the local namespaces for the top level function and all nested functions between
@@ -428,7 +453,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)
@@ -464,6 +489,15 @@ def __init__(
         # new uses of this, as this may cause leaking `UnboundType`s to type checking.
         self.allow_unbound_tvars = False
 
+        # Used to pass information about current overload index to visit_func_def().
+        self.current_overload_item: int | None = None
+
+        # Used to track whether currently inside an except* block. This helps
+        # to invoke errors when continue/break/return is used inside except* block.
+        self.inside_except_star_block: bool = False
+        # Used to track edge case when return is still inside except* if it enters a loop
+        self.return_stmt_inside_except_star_block: bool = False
+
     # mypyc doesn't properly handle implementing an abstractproperty
     # with a regular attribute so we make them properties
     @property
@@ -491,6 +525,25 @@ def allow_unbound_tvars_set(self) -> Iterator[None]:
         finally:
             self.allow_unbound_tvars = old
 
+    @contextmanager
+    def inside_except_star_block_set(
+        self, value: bool, entering_loop: bool = False
+    ) -> Iterator[None]:
+        old = self.inside_except_star_block
+        self.inside_except_star_block = value
+
+        # Return statement would still be in except* scope if entering loops
+        if not entering_loop:
+            old_return_stmt_flag = self.return_stmt_inside_except_star_block
+            self.return_stmt_inside_except_star_block = value
+
+        try:
+            yield
+        finally:
+            self.inside_except_star_block = old
+            if not entering_loop:
+                self.return_stmt_inside_except_star_block = old_return_stmt_flag
+
     #
     # Preparing module (performed before semantic analysis)
     #
@@ -605,6 +658,13 @@ def refresh_partial(
 
     def refresh_top_level(self, file_node: MypyFile) -> None:
         """Reanalyze a stale module top-level in fine-grained incremental mode."""
+        if self.options.allow_redefinition_new and not self.options.local_partial_types:
+            n = TempNode(AnyType(TypeOfAny.special_form))
+            n.line = 1
+            n.column = 0
+            n.end_line = 1
+            n.end_column = 0
+            self.fail("--local-partial-types must be enabled if using --allow-redefinition-new", n)
         self.recurse_into_functions = False
         self.add_implicit_module_attrs(file_node)
         for d in file_node.defs:
@@ -622,6 +682,7 @@ def add_implicit_module_attrs(self, file_node: MypyFile) -> None:
         str_type: Type | None = self.named_type_or_none("builtins.str")
         if str_type is None:
             str_type = UnboundType("builtins.str")
+        inst: Type | None
         for name, t in implicit_module_attrs.items():
             if name == "__doc__":
                 typ: Type = str_type
@@ -647,6 +708,22 @@ def add_implicit_module_attrs(self, file_node: MypyFile) -> None:
                     self.defer()
                     return
                 typ = inst
+            elif name == "__spec__":
+                if self.options.use_builtins_fixtures:
+                    inst = self.named_type_or_none("builtins.object")
+                else:
+                    inst = self.named_type_or_none("importlib.machinery.ModuleSpec")
+                if inst is None:
+                    if self.final_iteration:
+                        inst = self.named_type_or_none("builtins.object")
+                        assert inst is not None, "Cannot find builtins.object"
+                    else:
+                        self.defer()
+                        return
+                if file_node.name == "__main__":
+                    # https://docs.python.org/3/reference/import.html#main-spec
+                    inst = UnionType.make_union([inst, NoneType()])
+                typ = inst
             else:
                 assert t is not None, f"type should be specified for {name}"
                 typ = UnboundType(t)
@@ -679,7 +756,10 @@ def add_builtin_aliases(self, tree: MypyFile) -> None:
         """
         assert tree.fullname == "typing"
         for alias, target_name in type_aliases.items():
-            if type_aliases_source_versions[alias] > self.options.python_version:
+            if (
+                alias in type_aliases_source_versions
+                and type_aliases_source_versions[alias] > self.options.python_version
+            ):
                 # This alias is not available on this Python version.
                 continue
             name = alias.split(".")[-1]
@@ -718,7 +798,9 @@ def create_alias(self, tree: MypyFile, target_name: str, alias: str, name: str)
                 target = self.named_type_or_none(target_name, [])
                 assert target is not None
                 # Transform List to List[Any], etc.
-                fix_instance_types(target, self.fail, self.note, self.options)
+                fix_instance(
+                    target, self.fail, self.note, disallow_any=False, options=self.options
+                )
                 alias_node = TypeAlias(
                     target,
                     alias,
@@ -769,13 +851,11 @@ def file_context(
         self.cur_mod_id = file_node.fullname
         with scope.module_scope(self.cur_mod_id):
             self._is_stub_file = file_node.path.lower().endswith(".pyi")
-            self._is_typeshed_stub_file = is_typeshed_file(
-                options.abs_custom_typeshed_dir, file_node.path
-            )
+            self._is_typeshed_stub_file = file_node.is_typeshed_file(options)
             self.globals = file_node.names
             self.tvar_scope = TypeVarLikeScope()
 
-            self.named_tuple_analyzer = NamedTupleAnalyzer(options, self)
+            self.named_tuple_analyzer = NamedTupleAnalyzer(options, self, self.msg)
             self.typed_dict_analyzer = TypedDictAnalyzer(options, self, self.msg)
             self.enum_call_analyzer = EnumCallAnalyzer(options, self)
             self.newtype_analyzer = NewTypeAnalyzer(options, self, self.msg)
@@ -785,6 +865,12 @@ def file_context(
             self.num_incomplete_refs = 0
 
             if active_type:
+                enclosing_fullname = active_type.fullname.rsplit(".", 1)[0]
+                if "." in enclosing_fullname:
+                    enclosing_node = self.lookup_fully_qualified_or_none(enclosing_fullname)
+                    if enclosing_node and isinstance(enclosing_node.node, TypeInfo):
+                        self._type = enclosing_node.node
+                self.push_type_args(active_type.defn.type_args, active_type.defn)
                 self.incomplete_type_stack.append(False)
                 scope.enter_class(active_type)
                 self.enter_class(active_type.defn.info)
@@ -798,6 +884,7 @@ def file_context(
                 self.leave_class()
                 self._type = None
                 self.incomplete_type_stack.pop()
+                self.pop_type_args(active_type.defn.type_args)
         del self.options
 
     #
@@ -830,9 +917,19 @@ def visit_func_def(self, defn: FuncDef) -> None:
             return
 
         with self.scope.function_scope(defn):
-            self.analyze_func_def(defn)
+            with self.inside_except_star_block_set(value=False):
+                self.analyze_func_def(defn)
+
+    def function_fullname(self, fullname: str) -> str:
+        if self.current_overload_item is None:
+            return fullname
+        return f"{fullname}#{self.current_overload_item}"
 
     def analyze_func_def(self, defn: FuncDef) -> None:
+        if self.push_type_args(defn.type_args, defn) is None:
+            self.defer(defn)
+            return
+
         self.function_stack.append(defn)
 
         if defn.type:
@@ -854,7 +951,8 @@ def analyze_func_def(self, defn: FuncDef) -> None:
             self.prepare_method_signature(defn, self.type, has_self_type)
 
         # Analyze function signature
-        with self.tvar_scope_frame(self.tvar_scope.method_frame()):
+        fullname = self.function_fullname(defn.fullname)
+        with self.tvar_scope_frame(self.tvar_scope.method_frame(fullname)):
             if defn.type:
                 self.check_classvar_in_signature(defn.type)
                 assert isinstance(defn.type, CallableType)
@@ -862,10 +960,11 @@ def analyze_func_def(self, defn: FuncDef) -> None:
                 # class-level imported names and type variables are in scope.
                 analyzer = self.type_analyzer()
                 tag = self.track_incomplete_refs()
-                result = analyzer.visit_callable_type(defn.type, nested=False)
+                result = analyzer.visit_callable_type(defn.type, nested=False, namespace=fullname)
                 # Don't store not ready types (including placeholders).
                 if self.found_incomplete_ref(tag) or has_placeholder(result):
                     self.defer(defn)
+                    self.pop_type_args(defn.type_args)
                     return
                 assert isinstance(result, ProperType)
                 if isinstance(result, CallableType):
@@ -879,6 +978,13 @@ def analyze_func_def(self, defn: FuncDef) -> None:
                         )
                         # in this case, we just kind of just ... remove the type guard.
                         result = result.copy_modified(type_guard=None)
+                    if result.type_is and ARG_POS not in result.arg_kinds[skip_self:]:
+                        self.fail(
+                            '"TypeIs" functions must have a positional argument',
+                            result,
+                            code=codes.VALID_TYPE,
+                        )
+                        result = result.copy_modified(type_is=None)
 
                     result = self.remove_unpack_kwargs(defn, result)
                     if has_self_type and self.type is not None:
@@ -888,7 +994,6 @@ def analyze_func_def(self, defn: FuncDef) -> None:
                 defn.type = result
                 self.add_type_alias_deps(analyzer.aliases_used)
                 self.check_function_signature(defn)
-                self.check_paramspec_definition(defn)
                 if isinstance(defn, FuncDef):
                     assert isinstance(defn.type, CallableType)
                     defn.type = set_callable_name(defn.type, defn)
@@ -934,6 +1039,8 @@ def analyze_func_def(self, defn: FuncDef) -> None:
                 defn.type = defn.type.copy_modified(ret_type=ret_type)
                 self.wrapped_coro_return_types[defn] = defn.type
 
+        self.pop_type_args(defn.type_args)
+
     def remove_unpack_kwargs(self, defn: FuncDef, typ: CallableType) -> CallableType:
         if not typ.arg_kinds or typ.arg_kinds[-1] is not ArgKind.ARG_STAR2:
             return typ
@@ -942,7 +1049,7 @@ def remove_unpack_kwargs(self, defn: FuncDef, typ: CallableType) -> CallableType
             return typ
         last_type = get_proper_type(last_type.type)
         if not isinstance(last_type, TypedDictType):
-            self.fail("Unpack item in ** argument must be a TypedDict", defn)
+            self.fail("Unpack item in ** argument must be a TypedDict", last_type)
             new_arg_types = typ.arg_types[:-1] + [AnyType(TypeOfAny.from_error)]
             return typ.copy_modified(arg_types=new_arg_types)
         overlap = set(typ.arg_names) & set(last_type.items)
@@ -959,9 +1066,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:
@@ -976,6 +1085,7 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo, has_self_type:
                         assert self.type is not None and self.type.self_type is not None
                         leading_type: Type = self.type.self_type
                     else:
+                        func.is_trivial_self = True
                         leading_type = fill_typevars(info)
                     if func.is_class or func.name == "__new__":
                         leading_type = self.class_type(leading_type)
@@ -1008,7 +1118,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):
@@ -1048,11 +1172,20 @@ def update_function_type_variables(self, fun_type: CallableType, defn: FuncItem)
         if defn is generic. Return True, if the signature contains typing.Self
         type, or False otherwise.
         """
-        with self.tvar_scope_frame(self.tvar_scope.method_frame()):
+        fullname = self.function_fullname(defn.fullname)
+        with self.tvar_scope_frame(self.tvar_scope.method_frame(fullname)):
             a = self.type_analyzer()
             fun_type.variables, has_self_type = a.bind_function_type_variables(fun_type, defn)
             if has_self_type and self.type is not None:
                 self.setup_self_type()
+            if defn.type_args:
+                bound_fullnames = {v.fullname for v in fun_type.variables}
+                declared_fullnames = {self.qualified_name(p.name) for p in defn.type_args}
+                extra = sorted(bound_fullnames - declared_fullnames)
+                if extra:
+                    self.msg.type_parameters_should_be_declared(
+                        [n.split(".")[-1] for n in extra], defn
+                    )
             return has_self_type
 
     def setup_self_type(self) -> None:
@@ -1078,7 +1211,7 @@ def setup_self_type(self) -> None:
         info.self_type = TypeVarType(
             "Self",
             f"{info.fullname}.Self",
-            id=0,
+            id=TypeVarId(0),  # 0 is a special value for self-types.
             values=[],
             upper_bound=fill_typevars(info),
             default=AnyType(TypeOfAny.from_omitted_generics),
@@ -1098,6 +1231,14 @@ def visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         with self.scope.function_scope(defn):
             self.analyze_overloaded_func_def(defn)
 
+    @contextmanager
+    def overload_item_set(self, item: int | None) -> Iterator[None]:
+        self.current_overload_item = item
+        try:
+            yield
+        finally:
+            self.current_overload_item = None
+
     def analyze_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         # OverloadedFuncDef refers to any legitimate situation where you have
         # more than one declaration for the same function in a row.  This occurs
@@ -1110,17 +1251,21 @@ def analyze_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
 
         first_item = defn.items[0]
         first_item.is_overload = True
-        first_item.accept(self)
+        with self.overload_item_set(0):
+            first_item.accept(self)
 
+        bare_setter_type = None
+        is_property = False
         if isinstance(first_item, Decorator) and first_item.func.is_property:
+            is_property = True
             # This is a property.
             first_item.func.is_overload = True
-            self.analyze_property_with_multi_part_definition(defn)
+            bare_setter_type = self.analyze_property_with_multi_part_definition(defn)
             typ = function_type(first_item.func, self.named_type("builtins.function"))
             assert isinstance(typ, CallableType)
             types = [typ]
         else:
-            # This is an a normal overload. Find the item signatures, the
+            # This is a normal overload. Find the item signatures, the
             # implementation (if outside a stub), and any missing @overload
             # decorators.
             types, impl, non_overload_indexes = self.analyze_overload_sigs_and_impl(defn)
@@ -1137,9 +1282,25 @@ def analyze_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             elif not non_overload_indexes:
                 self.handle_missing_overload_implementation(defn)
 
-        if types:
+        if types and not any(
+            # If some overload items are decorated with other decorators, then
+            # the overload type will be determined during type checking.
+            # Note: bare @property is removed in visit_decorator().
+            isinstance(it, Decorator)
+            and len(it.decorators) > (1 if i > 0 or not is_property else 0)
+            for i, it in enumerate(defn.items)
+        ):
+            # TODO: should we enforce decorated overloads consistency somehow?
+            # Some existing code uses both styles:
+            #   * Put decorator only on implementation, use "effective" types in overloads
+            #   * Put decorator everywhere, use "bare" types in overloads.
             defn.type = Overloaded(types)
             defn.type.line = defn.line
+            # In addition, we can set the getter/setter type for valid properties as some
+            # code paths may either use the above type, or var.type etc. of the first item.
+            if isinstance(first_item, Decorator) and bare_setter_type:
+                first_item.var.type = types[0]
+                first_item.var.setter_type = bare_setter_type
 
         if not defn.items:
             # It was not a real overload after all, but function redefinition. We've
@@ -1151,10 +1312,51 @@ def analyze_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             return
 
         # We know this is an overload def. Infer properties and perform some checks.
+        self.process_deprecated_overload(defn)
         self.process_final_in_overload(defn)
         self.process_static_or_class_method_in_overload(defn)
         self.process_overload_impl(defn)
 
+    def process_deprecated_overload(self, defn: OverloadedFuncDef) -> None:
+        if defn.is_property:
+            return
+
+        if isinstance(impl := defn.impl, Decorator) and (
+            (deprecated := impl.func.deprecated) is not None
+        ):
+            defn.deprecated = deprecated
+            for item in defn.items:
+                if isinstance(item, Decorator):
+                    item.func.deprecated = deprecated
+
+        for item in defn.items:
+            deprecation = False
+            if isinstance(item, Decorator):
+                for d in item.decorators:
+                    if deprecation and refers_to_fullname(d, OVERLOAD_NAMES):
+                        self.msg.note("@overload should be placed before @deprecated", d)
+                    elif (deprecated := self.get_deprecated(d)) is not None:
+                        deprecation = True
+                        if isinstance(typ := item.func.type, CallableType):
+                            typestr = f" {typ} "
+                        else:
+                            typestr = " "
+                        item.func.deprecated = (
+                            f"overload{typestr}of function {defn.fullname} is deprecated: "
+                            f"{deprecated}"
+                        )
+
+    @staticmethod
+    def get_deprecated(expression: Expression) -> str | None:
+        if (
+            isinstance(expression, CallExpr)
+            and refers_to_fullname(expression.callee, DEPRECATED_TYPE_NAMES)
+            and (len(args := expression.args) >= 1)
+            and isinstance(deprecated := args[0], StrExpr)
+        ):
+            return deprecated.value
+        return None
+
     def process_overload_impl(self, defn: OverloadedFuncDef) -> None:
         """Set flags for an overload implementation.
 
@@ -1186,7 +1388,8 @@ def analyze_overload_sigs_and_impl(
             if i != 0:
                 # Assume that the first item was already visited
                 item.is_overload = True
-                item.accept(self)
+                with self.overload_item_set(i if i < len(defn.items) - 1 else None):
+                    item.accept(self)
             # TODO: support decorated overloaded functions properly
             if isinstance(item, Decorator):
                 callable = function_type(item.func, self.named_type("builtins.function"))
@@ -1259,8 +1462,15 @@ def handle_missing_overload_implementation(self, defn: OverloadedFuncDef) -> Non
                         item.func.abstract_status = IS_ABSTRACT
                     else:
                         item.abstract_status = IS_ABSTRACT
+            elif all(
+                isinstance(item, Decorator) and item.func.abstract_status == IS_ABSTRACT
+                for item in defn.items
+            ):
+                # Since there is no implementation, it can't be called via super().
+                if defn.items:
+                    assert isinstance(defn.items[0], Decorator)
+                    defn.items[0].func.is_trivial_body = True
             else:
-                # TODO: also allow omitting an implementation for abstract methods in ABCs?
                 self.fail(
                     "An overloaded function outside a stub file must have an implementation",
                     defn,
@@ -1317,37 +1527,60 @@ def process_static_or_class_method_in_overload(self, defn: OverloadedFuncDef) ->
             defn.is_class = class_status[0]
             defn.is_static = static_status[0]
 
-    def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -> None:
+    def analyze_property_with_multi_part_definition(
+        self, defn: OverloadedFuncDef
+    ) -> CallableType | None:
         """Analyze a property defined using multiple methods (e.g., using @x.setter).
 
         Assume that the first method (@property) has already been analyzed.
+        Return bare setter type (without any other decorators applied), this may be used
+        by the caller for performance optimizations.
         """
         defn.is_property = True
         items = defn.items
         first_item = defn.items[0]
         assert isinstance(first_item, Decorator)
         deleted_items = []
+        bare_setter_type = None
         for i, item in enumerate(items[1:]):
             if isinstance(item, Decorator):
-                if len(item.decorators) >= 1:
-                    node = item.decorators[0]
-                    if isinstance(node, MemberExpr):
-                        if node.name == "setter":
+                item.func.accept(self)
+                if item.decorators:
+                    first_node = item.decorators[0]
+                    if isinstance(first_node, MemberExpr):
+                        if first_node.name == "setter":
                             # The first item represents the entire property.
                             first_item.var.is_settable_property = True
                             # Get abstractness from the original definition.
                             item.func.abstract_status = first_item.func.abstract_status
+                            setter_func_type = function_type(
+                                item.func, self.named_type("builtins.function")
+                            )
+                            assert isinstance(setter_func_type, CallableType)
+                            bare_setter_type = setter_func_type
+                        if first_node.name == "deleter":
+                            item.func.abstract_status = first_item.func.abstract_status
+                        for other_node in item.decorators[1:]:
+                            other_node.accept(self)
                     else:
                         self.fail(
                             f"Only supported top decorator is @{first_item.func.name}.setter", item
                         )
-                item.func.accept(self)
             else:
                 self.fail(f'Unexpected definition for property "{first_item.func.name}"', item)
                 deleted_items.append(i + 1)
         for i in reversed(deleted_items):
             del items[i]
 
+        for item in items[1:]:
+            if isinstance(item, Decorator):
+                for d in item.decorators:
+                    if (deprecated := self.get_deprecated(d)) is not None:
+                        item.func.deprecated = (
+                            f"function {item.fullname} is deprecated: {deprecated}"
+                        )
+        return bare_setter_type
+
     def add_function_to_symbol_table(self, func: FuncDef | OverloadedFuncDef) -> None:
         if self.is_class_scope():
             assert self.type is not None
@@ -1356,7 +1589,8 @@ def add_function_to_symbol_table(self, func: FuncDef | OverloadedFuncDef) -> Non
         self.add_symbol(func.name, func, func)
 
     def analyze_arg_initializers(self, defn: FuncItem) -> None:
-        with self.tvar_scope_frame(self.tvar_scope.method_frame()):
+        fullname = self.function_fullname(defn.fullname)
+        with self.tvar_scope_frame(self.tvar_scope.method_frame(fullname)):
             # Analyze default arguments
             for arg in defn.arguments:
                 if arg.initializer:
@@ -1364,7 +1598,8 @@ def analyze_arg_initializers(self, defn: FuncItem) -> None:
 
     def analyze_function_body(self, defn: FuncItem) -> None:
         is_method = self.is_class_scope()
-        with self.tvar_scope_frame(self.tvar_scope.method_frame()):
+        fullname = self.function_fullname(defn.fullname)
+        with self.tvar_scope_frame(self.tvar_scope.method_frame(fullname)):
             # Bind the type variables again to visit the body.
             if defn.type:
                 a = self.type_analyzer()
@@ -1381,7 +1616,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:
@@ -1416,64 +1651,6 @@ def check_function_signature(self, fdef: FuncItem) -> None:
         elif len(sig.arg_types) > len(fdef.arguments):
             self.fail("Type signature has too many arguments", fdef, blocker=True)
 
-    def check_paramspec_definition(self, defn: FuncDef) -> None:
-        func = defn.type
-        assert isinstance(func, CallableType)
-
-        if not any(isinstance(var, ParamSpecType) for var in func.variables):
-            return  # Function does not have param spec variables
-
-        args = func.var_arg()
-        kwargs = func.kw_arg()
-        if args is None and kwargs is None:
-            return  # Looks like this function does not have starred args
-
-        args_defn_type = None
-        kwargs_defn_type = None
-        for arg_def, arg_kind in zip(defn.arguments, defn.arg_kinds):
-            if arg_kind == ARG_STAR:
-                args_defn_type = arg_def.type_annotation
-            elif arg_kind == ARG_STAR2:
-                kwargs_defn_type = arg_def.type_annotation
-
-        # This may happen on invalid `ParamSpec` args / kwargs definition,
-        # type analyzer sets types of arguments to `Any`, but keeps
-        # definition types as `UnboundType` for now.
-        if not (
-            (isinstance(args_defn_type, UnboundType) and args_defn_type.name.endswith(".args"))
-            or (
-                isinstance(kwargs_defn_type, UnboundType)
-                and kwargs_defn_type.name.endswith(".kwargs")
-            )
-        ):
-            # Looks like both `*args` and `**kwargs` are not `ParamSpec`
-            # It might be something else, skipping.
-            return
-
-        args_type = args.typ if args is not None else None
-        kwargs_type = kwargs.typ if kwargs is not None else None
-
-        if (
-            not isinstance(args_type, ParamSpecType)
-            or not isinstance(kwargs_type, ParamSpecType)
-            or args_type.name != kwargs_type.name
-        ):
-            if isinstance(args_defn_type, UnboundType) and args_defn_type.name.endswith(".args"):
-                param_name = args_defn_type.name.split(".")[0]
-            elif isinstance(kwargs_defn_type, UnboundType) and kwargs_defn_type.name.endswith(
-                ".kwargs"
-            ):
-                param_name = kwargs_defn_type.name.split(".")[0]
-            else:
-                # Fallback for cases that probably should not ever happen:
-                param_name = "P"
-
-            self.fail(
-                f'ParamSpec must have "*args" typed as "{param_name}.args" and "**kwargs" typed as "{param_name}.kwargs"',
-                func,
-                code=codes.VALID_TYPE,
-            )
-
     def visit_decorator(self, dec: Decorator) -> None:
         self.statement = dec
         # TODO: better don't modify them at all.
@@ -1518,6 +1695,7 @@ def visit_decorator(self, dec: Decorator) -> None:
                     "abc.abstractproperty",
                     "functools.cached_property",
                     "enum.property",
+                    "types.DynamicClassAttribute",
                 ),
             ):
                 removed.append(i)
@@ -1542,10 +1720,15 @@ def visit_decorator(self, dec: Decorator) -> None:
                     removed.append(i)
                 else:
                     self.fail("@final cannot be used with non-method functions", d)
+            elif refers_to_fullname(d, TYPE_CHECK_ONLY_NAMES):
+                # TODO: support `@overload` funcs.
+                dec.func.is_type_check_only = True
             elif isinstance(d, CallExpr) and refers_to_fullname(
                 d.callee, DATACLASS_TRANSFORM_NAMES
             ):
                 dec.func.dataclass_transform_spec = self.parse_dataclass_transform_spec(d)
+            elif (deprecated := self.get_deprecated(d)) is not None:
+                dec.func.deprecated = f"function {dec.fullname} is deprecated: {deprecated}"
             elif not dec.var.is_property:
                 # We have seen a "non-trivial" decorator before seeing @property, if
                 # we will see a @property later, give an error, as we don't support this.
@@ -1558,7 +1741,9 @@ def visit_decorator(self, dec: Decorator) -> None:
         if not no_type_check and self.recurse_into_functions:
             dec.func.accept(self)
         if could_be_decorated_property and dec.decorators and dec.var.is_property:
-            self.fail("Decorators on top of @property are not supported", dec)
+            self.fail(
+                "Decorators on top of @property are not supported", dec, code=PROPERTY_DECORATOR
+            )
         if (dec.func.is_static or dec.func.is_class) and dec.var.is_property:
             self.fail("Only instance methods can be decorated with @property", dec)
         if dec.func.abstract_status == IS_ABSTRACT and dec.func.is_final:
@@ -1579,9 +1764,132 @@ def visit_class_def(self, defn: ClassDef) -> None:
         self.incomplete_type_stack.append(not defn.info)
         namespace = self.qualified_name(defn.name)
         with self.tvar_scope_frame(self.tvar_scope.class_frame(namespace)):
+            if self.push_type_args(defn.type_args, defn) is None:
+                self.mark_incomplete(defn.name, defn)
+                return
+
             self.analyze_class(defn)
+            self.pop_type_args(defn.type_args)
         self.incomplete_type_stack.pop()
 
+    def push_type_args(
+        self, type_args: list[TypeParam] | None, context: Context
+    ) -> list[tuple[str, TypeVarLikeExpr]] | None:
+        if not type_args:
+            return []
+        self.locals.append(SymbolTable())
+        self.scope_stack.append(SCOPE_ANNOTATION)
+        tvs: list[tuple[str, TypeVarLikeExpr]] = []
+        for p in type_args:
+            tv = self.analyze_type_param(p, context)
+            if tv is None:
+                return None
+            tvs.append((p.name, tv))
+
+        for name, tv in tvs:
+            if self.is_defined_type_param(name):
+                self.fail(f'"{name}" already defined as a type parameter', context)
+            else:
+                self.add_symbol(name, tv, context, no_progress=True, type_param=True)
+
+        return tvs
+
+    def is_defined_type_param(self, name: str) -> bool:
+        for names in self.locals:
+            if names is None:
+                continue
+            if name in names:
+                node = names[name].node
+                if isinstance(node, TypeVarLikeExpr):
+                    return True
+        return False
+
+    def analyze_type_param(
+        self, type_param: TypeParam, context: Context
+    ) -> TypeVarLikeExpr | None:
+        fullname = self.qualified_name(type_param.name)
+        if type_param.upper_bound:
+            upper_bound = self.anal_type(type_param.upper_bound, allow_placeholder=True)
+            # TODO: we should validate the upper bound is valid for a given kind.
+            if upper_bound is None:
+                # This and below copies special-casing for old-style type variables, that
+                # is equally necessary for new-style classes to break a vicious circle.
+                upper_bound = PlaceholderType(None, [], context.line)
+        else:
+            if type_param.kind == TYPE_VAR_TUPLE_KIND:
+                upper_bound = self.named_type("builtins.tuple", [self.object_type()])
+            else:
+                upper_bound = self.object_type()
+        if type_param.default:
+            default = self.anal_type(
+                type_param.default,
+                allow_placeholder=True,
+                allow_unbound_tvars=True,
+                report_invalid_types=False,
+                allow_param_spec_literals=type_param.kind == PARAM_SPEC_KIND,
+                allow_tuple_literal=type_param.kind == PARAM_SPEC_KIND,
+                allow_unpack=type_param.kind == TYPE_VAR_TUPLE_KIND,
+            )
+            if default is None:
+                default = PlaceholderType(None, [], context.line)
+            elif type_param.kind == TYPE_VAR_KIND:
+                default = self.check_typevar_default(default, type_param.default)
+            elif type_param.kind == PARAM_SPEC_KIND:
+                default = self.check_paramspec_default(default, type_param.default)
+            elif type_param.kind == TYPE_VAR_TUPLE_KIND:
+                default = self.check_typevartuple_default(default, type_param.default)
+        else:
+            default = AnyType(TypeOfAny.from_omitted_generics)
+        if type_param.kind == TYPE_VAR_KIND:
+            values: list[Type] = []
+            if type_param.values:
+                for value in type_param.values:
+                    analyzed = self.anal_type(value, allow_placeholder=True)
+                    if analyzed is None:
+                        analyzed = PlaceholderType(None, [], context.line)
+                    if has_type_vars(analyzed):
+                        self.fail(message_registry.TYPE_VAR_GENERIC_CONSTRAINT_TYPE, context)
+                        values.append(AnyType(TypeOfAny.from_error))
+                    else:
+                        values.append(analyzed)
+            return TypeVarExpr(
+                name=type_param.name,
+                fullname=fullname,
+                values=values,
+                upper_bound=upper_bound,
+                default=default,
+                variance=VARIANCE_NOT_READY,
+                is_new_style=True,
+                line=context.line,
+            )
+        elif type_param.kind == PARAM_SPEC_KIND:
+            return ParamSpecExpr(
+                name=type_param.name,
+                fullname=fullname,
+                upper_bound=upper_bound,
+                default=default,
+                is_new_style=True,
+                line=context.line,
+            )
+        else:
+            assert type_param.kind == TYPE_VAR_TUPLE_KIND
+            tuple_fallback = self.named_type("builtins.tuple", [self.object_type()])
+            return TypeVarTupleExpr(
+                name=type_param.name,
+                fullname=fullname,
+                upper_bound=upper_bound,
+                tuple_fallback=tuple_fallback,
+                default=default,
+                is_new_style=True,
+                line=context.line,
+            )
+
+    def pop_type_args(self, type_args: list[TypeParam] | None) -> None:
+        if not type_args:
+            return
+        self.locals.pop()
+        self.scope_stack.pop()
+
     def analyze_class(self, defn: ClassDef) -> None:
         fullname = self.qualified_name(defn.name)
         if not defn.info and not self.is_core_builtin_class(defn):
@@ -1605,6 +1913,8 @@ def analyze_class(self, defn: ClassDef) -> None:
             defn, bases, context=defn
         )
 
+        self.check_type_alias_bases(bases)
+
         for tvd in tvar_defs:
             if isinstance(tvd, TypeVarType) and any(
                 has_placeholder(t) for t in [tvd.upper_bound] + tvd.values
@@ -1662,10 +1972,33 @@ def analyze_class(self, defn: ClassDef) -> None:
             defn.info.is_protocol = is_protocol
             self.recalculate_metaclass(defn, declared_metaclass)
             defn.info.runtime_protocol = False
+
+            if defn.type_args:
+                # PEP 695 type parameters are not in scope in class decorators, so
+                # temporarily disable type parameter namespace.
+                type_params_names = self.locals.pop()
+                self.scope_stack.pop()
             for decorator in defn.decorators:
                 self.analyze_class_decorator(defn, decorator)
+            if defn.type_args:
+                self.locals.append(type_params_names)
+                self.scope_stack.append(SCOPE_ANNOTATION)
+
             self.analyze_class_body_common(defn)
 
+    def check_type_alias_bases(self, bases: list[Expression]) -> None:
+        for base in bases:
+            if isinstance(base, IndexExpr):
+                base = base.base
+            if (
+                isinstance(base, RefExpr)
+                and isinstance(base.node, TypeAlias)
+                and base.node.python_3_12_type_alias
+            ):
+                self.fail(
+                    'Type alias defined using "type" statement not valid as base class', base
+                )
+
     def setup_type_vars(self, defn: ClassDef, tvar_defs: list[TypeVarLikeType]) -> None:
         defn.type_vars = tvar_defs
         defn.info.type_vars = []
@@ -1675,12 +2008,17 @@ def setup_type_vars(self, defn: ClassDef, tvar_defs: list[TypeVarLikeType]) -> N
     def setup_alias_type_vars(self, defn: ClassDef) -> None:
         assert defn.info.special_alias is not None
         defn.info.special_alias.alias_tvars = list(defn.type_vars)
+        # It is a bit unfortunate that we need to inline some logic from TypeAlias constructor,
+        # but it is required, since type variables may change during semantic analyzer passes.
+        for i, t in enumerate(defn.type_vars):
+            if isinstance(t, TypeVarTupleType):
+                defn.info.special_alias.tvar_tuple_index = i
         target = defn.info.special_alias.target
         assert isinstance(target, ProperType)
         if isinstance(target, TypedDictType):
-            target.fallback.args = tuple(defn.type_vars)
+            target.fallback.args = type_vars_as_args(defn.type_vars)
         elif isinstance(target, TupleType):
-            target.partial_fallback.args = tuple(defn.type_vars)
+            target.partial_fallback.args = type_vars_as_args(defn.type_vars)
         else:
             assert False, f"Unexpected special alias type: {type(target)}"
 
@@ -1690,6 +2028,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()
@@ -1706,13 +2046,12 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> bool:
         if is_typeddict:
             for decorator in defn.decorators:
                 decorator.accept(self)
-                if isinstance(decorator, RefExpr):
-                    if decorator.fullname in FINAL_DECORATOR_NAMES and info is not None:
-                        info.is_final = True
+                if info is not None:
+                    self.analyze_class_decorator_common(defn, info, decorator)
             if info is None:
                 self.mark_incomplete(defn.name, defn)
             else:
-                self.prepare_class_def(defn, info)
+                self.prepare_class_def(defn, info, custom_names=True)
             return True
         return False
 
@@ -1742,6 +2081,9 @@ 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)
+                        self.analyze_class_decorator_common(defn, defn.info, deco)
                     with self.named_tuple_analyzer.save_namedtuple_body(info):
                         self.analyze_class_body_common(defn)
             return True
@@ -1806,34 +2148,49 @@ def enter_class(self, info: TypeInfo) -> None:
         # Remember previous active class
         self.type_stack.append(self.type)
         self.locals.append(None)  # Add class scope
-        self.is_comprehension_stack.append(False)
+        self.scope_stack.append(SCOPE_CLASS)
         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.scope_stack.pop()
         self._type = self.type_stack.pop()
         self.missing_names.pop()
 
     def analyze_class_decorator(self, defn: ClassDef, decorator: Expression) -> None:
         decorator.accept(self)
+        self.analyze_class_decorator_common(defn, defn.info, decorator)
         if isinstance(decorator, RefExpr):
             if decorator.fullname in RUNTIME_PROTOCOL_DECOS:
                 if defn.info.is_protocol:
                     defn.info.runtime_protocol = True
                 else:
                     self.fail("@runtime_checkable can only be used with protocol classes", defn)
-            elif decorator.fullname in FINAL_DECORATOR_NAMES:
-                defn.info.is_final = True
         elif isinstance(decorator, CallExpr) and refers_to_fullname(
             decorator.callee, DATACLASS_TRANSFORM_NAMES
         ):
             defn.info.dataclass_transform_spec = self.parse_dataclass_transform_spec(decorator)
 
+    def analyze_class_decorator_common(
+        self, defn: ClassDef, info: TypeInfo, decorator: Expression
+    ) -> None:
+        """Common method for applying class decorators.
+
+        Called on regular classes, typeddicts, and namedtuples.
+        """
+        if refers_to_fullname(decorator, FINAL_DECORATOR_NAMES):
+            info.is_final = True
+        elif refers_to_fullname(decorator, TYPE_CHECK_ONLY_NAMES):
+            info.is_type_check_only = True
+        elif (deprecated := self.get_deprecated(decorator)) is not None:
+            info.deprecated = f"class {defn.fullname} is deprecated: {deprecated}"
+
     def clean_up_bases_and_infer_type_variables(
         self, defn: ClassDef, base_type_exprs: list[Expression], context: Context
     ) -> tuple[list[Expression], list[TypeVarLikeType], bool]:
@@ -1853,6 +2210,13 @@ class Foo(Bar, Generic[T]): ...
         removed: list[int] = []
         declared_tvars: TypeVarLikeList = []
         is_protocol = False
+        if defn.type_args is not None:
+            for p in defn.type_args:
+                node = self.lookup(p.name, context)
+                assert node is not None
+                assert isinstance(node.node, TypeVarLikeExpr)
+                declared_tvars.append((p.name, node.node))
+
         for i, base_expr in enumerate(base_type_exprs):
             if isinstance(base_expr, StarExpr):
                 base_expr.valid = True
@@ -1865,11 +2229,19 @@ class Foo(Bar, Generic[T]): ...
                 continue
             result = self.analyze_class_typevar_declaration(base)
             if result is not None:
-                if declared_tvars:
-                    self.fail("Only single Generic[...] or Protocol[...] can be in bases", context)
-                removed.append(i)
                 tvars = result[0]
                 is_protocol |= result[1]
+                if declared_tvars:
+                    if defn.type_args:
+                        if is_protocol:
+                            self.fail('No arguments expected for "Protocol" base class', context)
+                        else:
+                            self.fail("Generic[...] base class is redundant", context)
+                    else:
+                        self.fail(
+                            "Only single Generic[...] or Protocol[...] can be in bases", context
+                        )
+                removed.append(i)
                 declared_tvars.extend(tvars)
             if isinstance(base, UnboundType):
                 sym = self.lookup_qualified(base.name, base)
@@ -1881,15 +2253,21 @@ class Foo(Bar, Generic[T]): ...
 
         all_tvars = self.get_all_bases_tvars(base_type_exprs, removed)
         if declared_tvars:
-            if len(remove_dups(declared_tvars)) < len(declared_tvars):
+            if len(remove_dups(declared_tvars)) < len(declared_tvars) and not defn.type_args:
                 self.fail("Duplicate type variables in Generic[...] or Protocol[...]", context)
             declared_tvars = remove_dups(declared_tvars)
             if not set(all_tvars).issubset(set(declared_tvars)):
-                self.fail(
-                    "If Generic[...] or Protocol[...] is present"
-                    " it should list all type variables",
-                    context,
-                )
+                if defn.type_args:
+                    undeclared = sorted(set(all_tvars) - set(declared_tvars))
+                    self.msg.type_parameters_should_be_declared(
+                        [tv[0] for tv in undeclared], context
+                    )
+                else:
+                    self.fail(
+                        "If Generic[...] or Protocol[...] is present"
+                        " it should list all type variables",
+                        context,
+                    )
                 # In case of error, Generic tvars will go first
                 declared_tvars = remove_dups(declared_tvars + all_tvars)
         else:
@@ -1900,10 +2278,7 @@ class Foo(Bar, Generic[T]): ...
             # grained incremental mode.
             defn.removed_base_type_exprs.append(defn.base_type_exprs[i])
             del base_type_exprs[i]
-        tvar_defs: list[TypeVarLikeType] = []
-        for name, tvar_expr in declared_tvars:
-            tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
-            tvar_defs.append(tvar_def)
+        tvar_defs = self.tvar_defs_from_tvars(declared_tvars, context)
         return base_type_exprs, tvar_defs, is_protocol
 
     def analyze_class_typevar_declaration(self, base: Type) -> tuple[TypeVarLikeList, bool] | None:
@@ -1945,38 +2320,48 @@ def analyze_class_typevar_declaration(self, base: Type) -> tuple[TypeVarLikeList
         return None
 
     def analyze_unbound_tvar(self, t: Type) -> tuple[str, TypeVarLikeExpr] | None:
-        if not isinstance(t, UnboundType):
-            return None
-        unbound = t
-        sym = self.lookup_qualified(unbound.name, unbound)
+        if isinstance(t, UnpackType) and isinstance(t.type, UnboundType):
+            return self.analyze_unbound_tvar_impl(t.type, is_unpacked=True)
+        if isinstance(t, UnboundType):
+            sym = self.lookup_qualified(t.name, t)
+            if sym and sym.fullname in UNPACK_TYPE_NAMES:
+                inner_t = t.args[0]
+                if isinstance(inner_t, UnboundType):
+                    return self.analyze_unbound_tvar_impl(inner_t, is_unpacked=True)
+                return None
+            return self.analyze_unbound_tvar_impl(t)
+        return None
+
+    def analyze_unbound_tvar_impl(
+        self, t: UnboundType, is_unpacked: bool = False, is_typealias_param: bool = False
+    ) -> tuple[str, TypeVarLikeExpr] | None:
+        assert not is_unpacked or not is_typealias_param, "Mutually exclusive conditions"
+        sym = self.lookup_qualified(t.name, t)
         if sym and isinstance(sym.node, PlaceholderNode):
             self.record_incomplete_ref()
-        if sym and isinstance(sym.node, ParamSpecExpr):
+        if not is_unpacked and sym and isinstance(sym.node, ParamSpecExpr):
             if sym.fullname and not self.tvar_scope.allow_binding(sym.fullname):
                 # It's bound by our type variable scope
                 return None
-            return unbound.name, sym.node
-        if sym and sym.fullname in ("typing.Unpack", "typing_extensions.Unpack"):
-            inner_t = unbound.args[0]
-            if not isinstance(inner_t, UnboundType):
+            return t.name, sym.node
+        if (is_unpacked or is_typealias_param) and sym and isinstance(sym.node, TypeVarTupleExpr):
+            if sym.fullname and not self.tvar_scope.allow_binding(sym.fullname):
+                # It's bound by our type variable scope
                 return None
-            inner_unbound = inner_t
-            inner_sym = self.lookup_qualified(inner_unbound.name, inner_unbound)
-            if inner_sym and isinstance(inner_sym.node, PlaceholderNode):
-                self.record_incomplete_ref()
-            if inner_sym and isinstance(inner_sym.node, TypeVarTupleExpr):
-                if inner_sym.fullname and not self.tvar_scope.allow_binding(inner_sym.fullname):
-                    # It's bound by our type variable scope
-                    return None
-                return inner_unbound.name, inner_sym.node
-        if sym is None or not isinstance(sym.node, TypeVarExpr):
+            return t.name, sym.node
+        if sym is None or not isinstance(sym.node, TypeVarExpr) or is_unpacked:
             return None
         elif sym.fullname and not self.tvar_scope.allow_binding(sym.fullname):
             # It's bound by our type variable scope
             return None
         else:
             assert isinstance(sym.node, TypeVarExpr)
-            return unbound.name, sym.node
+            return t.name, sym.node
+
+    def find_type_var_likes(self, t: Type) -> TypeVarLikeList:
+        visitor = FindTypeVarVisitor(self, self.tvar_scope)
+        t.accept(visitor)
+        return visitor.type_var_likes
 
     def get_all_bases_tvars(
         self, base_type_exprs: list[Expression], removed: list[int]
@@ -1990,10 +2375,30 @@ def get_all_bases_tvars(
                 except TypeTranslationError:
                     # This error will be caught later.
                     continue
-                base_tvars = base.accept(TypeVarLikeQuery(self, self.tvar_scope))
+                base_tvars = self.find_type_var_likes(base)
                 tvars.extend(base_tvars)
         return remove_dups(tvars)
 
+    def tvar_defs_from_tvars(
+        self, tvars: TypeVarLikeList, context: Context
+    ) -> list[TypeVarLikeType]:
+        tvar_defs: list[TypeVarLikeType] = []
+        last_tvar_name_with_default: str | None = None
+        for name, tvar_expr in tvars:
+            tvar_expr.default = tvar_expr.default.accept(
+                TypeVarDefaultTranslator(self, tvar_expr.name, context)
+            )
+            tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
+            if last_tvar_name_with_default is not None and not tvar_def.has_default():
+                self.msg.tvar_without_default_type(
+                    tvar_def.name, last_tvar_name_with_default, context
+                )
+                tvar_def.default = AnyType(TypeOfAny.from_error)
+            elif tvar_def.has_default():
+                last_tvar_name_with_default = tvar_def.name
+            tvar_defs.append(tvar_def)
+        return tvar_defs
+
     def get_and_bind_all_tvars(self, type_exprs: list[Expression]) -> list[TypeVarLikeType]:
         """Return all type variable references in item type expressions.
 
@@ -2008,7 +2413,7 @@ def get_and_bind_all_tvars(self, type_exprs: list[Expression]) -> list[TypeVarLi
             except TypeTranslationError:
                 # This error will be caught later.
                 continue
-            base_tvars = base.accept(TypeVarLikeQuery(self, self.tvar_scope))
+            base_tvars = self.find_type_var_likes(base)
             tvars.extend(base_tvars)
         tvars = remove_dups(tvars)  # Variables are defined in order of textual appearance.
         tvar_defs = []
@@ -2056,8 +2461,9 @@ def prepare_class_def(
                 # Preserve name from previous fine-grained incremental run.
                 global_name = defn.info.name
             defn.fullname = defn.info._fullname
-            if defn.info.is_named_tuple:
-                # Named tuple nested within a class is stored in the class symbol table.
+            if defn.info.is_named_tuple or defn.info.typeddict_type:
+                # Named tuples and Typed dicts nested within a class are stored
+                # in the class symbol table.
                 self.add_symbol_skip_local(global_name, defn.info)
             else:
                 self.globals[global_name] = SymbolTableNode(GDEF, defn.info)
@@ -2107,8 +2513,16 @@ def analyze_base_classes(
             if (
                 isinstance(base_expr, RefExpr)
                 and base_expr.fullname in TYPED_NAMEDTUPLE_NAMES + TPDICT_NAMES
+            ) or (
+                isinstance(base_expr, CallExpr)
+                and isinstance(base_expr.callee, RefExpr)
+                and base_expr.callee.fullname in TPDICT_NAMES
             ):
                 # Ignore magic bases for now.
+                # For example:
+                #  class Foo(TypedDict): ...  # RefExpr
+                #  class Foo(NamedTuple): ...  # RefExpr
+                #  class Foo(TypedDict("Foo", {"a": int})): ...  # CallExpr
                 continue
 
             try:
@@ -2238,8 +2652,7 @@ def calculate_class_mro(
             calculate_mro(defn.info, obj_type)
         except MroError:
             self.fail(
-                "Cannot determine consistent method resolution "
-                'order (MRO) for "%s"' % defn.name,
+                f'Cannot determine consistent method resolution order (MRO) for "{defn.name}"',
                 defn,
             )
             self.set_dummy_mro(defn.info)
@@ -2368,15 +2781,15 @@ def get_declared_metaclass(
                 return None, True, False  # defer later in the caller
 
             # Support type aliases, like `_Meta: TypeAlias = type`
+            metaclass_info: Node | None = sym.node
             if (
                 isinstance(sym.node, TypeAlias)
-                and sym.node.no_args
-                and isinstance(sym.node.target, ProperType)
-                and isinstance(sym.node.target, Instance)
+                and not sym.node.python_3_12_type_alias
+                and not sym.node.alias_tvars
             ):
-                metaclass_info: Node | None = sym.node.target.type
-            else:
-                metaclass_info = sym.node
+                target = get_proper_type(sym.node.target)
+                if isinstance(target, Instance):
+                    metaclass_info = target.type
 
             if not isinstance(metaclass_info, TypeInfo) or metaclass_info.tuple_type is not None:
                 self.fail(f'Invalid metaclass "{metaclass_name}"', metaclass_expr)
@@ -2422,7 +2835,7 @@ def visit_import(self, i: Import) -> None:
             if as_id is not None:
                 base_id = id
                 imported_id = as_id
-                module_public = use_implicit_reexport or id.split(".")[-1] == as_id
+                module_public = use_implicit_reexport or id == as_id
             else:
                 base_id = id.split(".")[0]
                 imported_id = base_id
@@ -2495,12 +2908,7 @@ def visit_import_from(self, imp: ImportFrom) -> None:
                 elif fullname in self.missing_modules:
                     missing_submodule = True
             # If it is still not resolved, check for a module level __getattr__
-            if (
-                module
-                and not node
-                and (module.is_stub or self.options.python_version >= (3, 7))
-                and "__getattr__" in module.names
-            ):
+            if module and not node and "__getattr__" in module.names:
                 # We store the fullname of the original definition so that we can
                 # detect whether two imported names refer to the same thing.
                 fullname = module_id + "." + id
@@ -2711,8 +3119,6 @@ def visit_import_all(self, i: ImportAll) -> None:
             for name, node in m.names.items():
                 fullname = i_id + "." + name
                 self.set_future_import_flags(fullname)
-                if node is None:
-                    continue
                 # if '__all__' exists, all nodes not included have had module_public set to
                 # False, and we can skip checking '_' because it's been explicitly included.
                 if node.module_public and (not name.startswith("_") or "__all__" in m.names):
@@ -2746,8 +3152,8 @@ class C:
             [(j := i) for i in [1, 2, 3]]
         is a syntax error that is not enforced by Python parser, but at later steps.
         """
-        for i, is_comprehension in enumerate(reversed(self.is_comprehension_stack)):
-            if not is_comprehension and i < len(self.locals) - 1:
+        for i, scope_type in enumerate(reversed(self.scope_stack)):
+            if scope_type != SCOPE_COMPREHENSION and i < len(self.locals) - 1:
                 if self.locals[-1 - i] is None:
                     self.fail(
                         "Assignment expression within a comprehension"
@@ -2781,6 +3187,10 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
             with self.allow_unbound_tvars_set():
                 s.rvalue.accept(self)
             self.basic_type_applications = old_basic_type_applications
+        elif self.can_possibly_be_typevarlike_declaration(s):
+            # Allow unbound tvars inside TypeVarLike defaults to be evaluated later
+            with self.allow_unbound_tvars_set():
+                s.rvalue.accept(self)
         else:
             s.rvalue.accept(self)
 
@@ -2803,22 +3213,23 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         if self.check_and_set_up_type_alias(s):
             s.is_alias_def = True
             special_form = True
-        # * type variable definition
-        elif self.process_typevar_declaration(s):
-            special_form = True
-        elif self.process_paramspec_declaration(s):
-            special_form = True
-        elif self.process_typevartuple_declaration(s):
-            special_form = True
-        # * type constructors
-        elif self.analyze_namedtuple_assign(s):
-            special_form = True
-        elif self.analyze_typeddict_assign(s):
-            special_form = True
-        elif self.newtype_analyzer.process_newtype_declaration(s):
-            special_form = True
-        elif self.analyze_enum_assign(s):
-            special_form = True
+        elif isinstance(s.rvalue, CallExpr):
+            # * type variable definition
+            if self.process_typevar_declaration(s):
+                special_form = True
+            elif self.process_paramspec_declaration(s):
+                special_form = True
+            elif self.process_typevartuple_declaration(s):
+                special_form = True
+            # * type constructors
+            elif self.analyze_namedtuple_assign(s):
+                special_form = True
+            elif self.analyze_typeddict_assign(s):
+                special_form = True
+            elif self.newtype_analyzer.process_newtype_declaration(s):
+                special_form = True
+            elif self.analyze_enum_assign(s):
+                special_form = True
 
         if special_form:
             self.record_special_form_lvalue(s)
@@ -2956,6 +3367,16 @@ def can_possibly_be_type_form(self, s: AssignmentStmt) -> bool:
         # Something that looks like Foo = Bar[Baz, ...]
         return True
 
+    def can_possibly_be_typevarlike_declaration(self, s: AssignmentStmt) -> bool:
+        """Check if r.h.s. can be a TypeVarLike declaration."""
+        if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], NameExpr):
+            return False
+        if not isinstance(s.rvalue, CallExpr) or not isinstance(s.rvalue.callee, NameExpr):
+            return False
+        ref = s.rvalue.callee
+        ref.accept(self)
+        return ref.fullname in TYPE_VAR_LIKE_NAMES
+
     def is_type_ref(self, rv: Expression, bare: bool = False) -> bool:
         """Does this expression refer to a type?
 
@@ -3051,8 +3472,9 @@ def record_special_form_lvalue(self, s: AssignmentStmt) -> None:
     def analyze_enum_assign(self, s: AssignmentStmt) -> bool:
         """Check if s defines an Enum."""
         if isinstance(s.rvalue, CallExpr) and isinstance(s.rvalue.analyzed, EnumCallExpr):
-            # Already analyzed enum -- nothing to do here.
-            return True
+            # This is an analyzed enum definition.
+            # It is valid iff it can be stored correctly, failures were already reported.
+            return self._is_single_name_assignment(s)
         return self.enum_call_analyzer.process_enum_call(s, self.is_func_scope())
 
     def analyze_namedtuple_assign(self, s: AssignmentStmt) -> bool:
@@ -3061,10 +3483,18 @@ def analyze_namedtuple_assign(self, s: AssignmentStmt) -> bool:
             if s.rvalue.analyzed.info.tuple_type and not has_placeholder(
                 s.rvalue.analyzed.info.tuple_type
             ):
-                return True  # This is a valid and analyzed named tuple definition, nothing to do here.
+                # This is an analyzed named tuple definition.
+                # It is valid iff it can be stored correctly, failures were already reported.
+                return self._is_single_name_assignment(s)
         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)):
@@ -3073,9 +3503,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(
@@ -3099,8 +3526,9 @@ def analyze_typeddict_assign(self, s: AssignmentStmt) -> bool:
             if s.rvalue.analyzed.info.typeddict_type and not has_placeholder(
                 s.rvalue.analyzed.info.typeddict_type
             ):
-                # This is a valid and analyzed typed dict definition, nothing to do here.
-                return True
+                # This is an analyzed typed dict definition.
+                # It is valid iff it can be stored correctly, failures were already reported.
+                return self._is_single_name_assignment(s)
         if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], (NameExpr, MemberExpr)):
             return False
         lvalue = s.lvalues[0]
@@ -3124,6 +3552,9 @@ def analyze_typeddict_assign(self, s: AssignmentStmt) -> bool:
                 self.setup_alias_type_vars(defn)
             return True
 
+    def _is_single_name_assignment(self, s: AssignmentStmt) -> bool:
+        return len(s.lvalues) == 1 and isinstance(s.lvalues[0], NameExpr)
+
     def analyze_lvalues(self, s: AssignmentStmt) -> None:
         # We cannot use s.type, because analyze_simple_literal_type() will set it.
         explicit = s.unanalyzed_type is not None
@@ -3163,6 +3594,13 @@ def apply_dynamic_class_hook(self, s: AssignmentStmt) -> None:
                 if isinstance(callee_expr, RefExpr) and callee_expr.fullname:
                     method_name = call.callee.name
                     fname = callee_expr.fullname + "." + method_name
+                elif (
+                    isinstance(callee_expr, IndexExpr)
+                    and isinstance(callee_expr.base, RefExpr)
+                    and isinstance(callee_expr.analyzed, TypeApplication)
+                ):
+                    method_name = call.callee.name
+                    fname = callee_expr.base.fullname + "." + method_name
                 elif isinstance(callee_expr, CallExpr):
                     # check if chain call
                     call = callee_expr
@@ -3197,13 +3635,22 @@ def unwrap_final(self, s: AssignmentStmt) -> bool:
         invalid_bare_final = False
         if not s.unanalyzed_type.args:
             s.type = None
-            if isinstance(s.rvalue, TempNode) and s.rvalue.no_rhs:
+            if (
+                isinstance(s.rvalue, TempNode)
+                and s.rvalue.no_rhs
+                # Filter duplicate errors, we already reported this:
+                and not (self.type and self.type.is_named_tuple)
+            ):
                 invalid_bare_final = True
                 self.fail("Type in Final[...] can only be omitted if there is an initializer", s)
         else:
             s.type = s.unanalyzed_type.args[0]
 
-        if s.type is not None and self.is_classvar(s.type):
+        if (
+            s.type is not None
+            and self.options.python_version < (3, 13)
+            and self.is_classvar(s.type)
+        ):
             self.fail("Variable should not be annotated with both ClassVar and Final", s)
             return False
 
@@ -3219,10 +3666,11 @@ 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)
+            if self.is_class_scope():
+                self.msg.protocol_members_cant_be_final(s)
         if (
             isinstance(s.rvalue, TempNode)
             and s.rvalue.no_rhs
@@ -3303,9 +3751,9 @@ def store_final_status(self, s: AssignmentStmt) -> None:
                     cur_node = self.type.names.get(lval.name, None)
                     if cur_node and isinstance(cur_node.node, Var) and cur_node.node.is_final:
                         assert self.function_stack
-                        top_function = self.function_stack[-1]
+                        current_function = self.function_stack[-1]
                         if (
-                            top_function.name == "__init__"
+                            current_function.name == "__init__"
                             and cur_node.node.final_unset_in_class
                             and not cur_node.node.final_set_in_init
                             and not (isinstance(s.rvalue, TempNode) and s.rvalue.no_rhs)
@@ -3387,7 +3835,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):
@@ -3405,8 +3853,14 @@ def analyze_simple_literal_type(self, rvalue: Expression, is_final: bool) -> Typ
         return typ
 
     def analyze_alias(
-        self, name: str, rvalue: Expression, allow_placeholder: bool = False
-    ) -> tuple[Type | None, list[TypeVarLikeType], set[str], list[str]]:
+        self,
+        name: str,
+        rvalue: Expression,
+        allow_placeholder: bool = False,
+        declared_type_vars: TypeVarLikeList | None = None,
+        all_declared_type_params_names: list[str] | None = None,
+        python_3_12_type_alias: bool = False,
+    ) -> tuple[Type | None, list[TypeVarLikeType], set[str], list[str], bool]:
         """Check if 'rvalue' is a valid type allowed for aliasing (e.g. not a type variable).
 
         If yes, return the corresponding type, a list of
@@ -3420,20 +3874,25 @@ def analyze_alias(
         dynamic = bool(self.function_stack and self.function_stack[-1].is_dynamic())
         global_scope = not self.type and not self.function_stack
         try:
-            typ = expr_to_unanalyzed_type(rvalue, self.options, self.is_stub_file)
+            typ = expr_to_unanalyzed_type(
+                rvalue, self.options, self.is_stub_file, lookup_qualified=self.lookup_qualified
+            )
         except TypeTranslationError:
             self.fail(
                 "Invalid type alias: expression is not a valid type", rvalue, code=codes.VALID_TYPE
             )
-            return None, [], set(), []
+            return None, [], set(), [], False
 
-        found_type_vars = typ.accept(TypeVarLikeQuery(self, self.tvar_scope))
+        found_type_vars = self.find_type_var_likes(typ)
         tvar_defs: list[TypeVarLikeType] = []
         namespace = self.qualified_name(name)
+        alias_type_vars = found_type_vars if declared_type_vars is None else declared_type_vars
         with self.tvar_scope_frame(self.tvar_scope.class_frame(namespace)):
-            for name, tvar_expr in found_type_vars:
-                tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
-                tvar_defs.append(tvar_def)
+            tvar_defs = self.tvar_defs_from_tvars(alias_type_vars, typ)
+
+            if python_3_12_type_alias:
+                with self.allow_unbound_tvars_set():
+                    rvalue.accept(self)
 
             analyzed, depends_on = analyze_type_alias(
                 typ,
@@ -3441,11 +3900,14 @@ def analyze_alias(
                 self.tvar_scope,
                 self.plugin,
                 self.options,
+                self.cur_mod_node,
                 self.is_typeshed_stub_file,
                 allow_placeholder=allow_placeholder,
                 in_dynamic_func=dynamic,
                 global_scope=global_scope,
                 allowed_alias_tvars=tvar_defs,
+                alias_type_params_names=all_declared_type_params_names,
+                python_3_12_type_alias=python_3_12_type_alias,
             )
 
         # There can be only one variadic variable at most, the error is reported elsewhere.
@@ -3458,8 +3920,9 @@ def analyze_alias(
                 variadic = True
             new_tvar_defs.append(td)
 
-        qualified_tvars = [node.fullname for _name, node in found_type_vars]
-        return analyzed, new_tvar_defs, depends_on, qualified_tvars
+        qualified_tvars = [node.fullname for _name, node in alias_type_vars]
+        empty_tuple_index = typ.empty_tuple_index if isinstance(typ, UnboundType) else False
+        return analyzed, new_tvar_defs, depends_on, qualified_tvars, empty_tuple_index
 
     def is_pep_613(self, s: AssignmentStmt) -> bool:
         if s.unanalyzed_type is not None and isinstance(s.unanalyzed_type, UnboundType):
@@ -3490,7 +3953,21 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
             # unless using PEP 613 `cls: TypeAlias = A`
             return False
 
-        if isinstance(s.rvalue, CallExpr) and s.rvalue.analyzed:
+        # It can be `A = TypeAliasType('A', ...)` call, in this case,
+        # we just take the second argument and analyze it:
+        type_params: TypeVarLikeList | None
+        all_type_params_names: list[str] | None
+        if self.check_type_alias_type_call(s.rvalue, name=lvalue.name):
+            rvalue = s.rvalue.args[1]
+            pep_695 = True
+            type_params, all_type_params_names = self.analyze_type_alias_type_params(s.rvalue)
+        else:
+            rvalue = s.rvalue
+            pep_695 = False
+            type_params = None
+            all_type_params_names = None
+
+        if isinstance(rvalue, CallExpr) and rvalue.analyzed:
             return False
 
         existing = self.current_symbol_table().get(lvalue.name)
@@ -3516,7 +3993,7 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
             return False
 
         non_global_scope = self.type or self.is_func_scope()
-        if not pep_613 and isinstance(s.rvalue, RefExpr) and non_global_scope:
+        if not pep_613 and not pep_695 and isinstance(rvalue, RefExpr) and non_global_scope:
             # Fourth rule (special case): Non-subscripted right hand side creates a variable
             # at class and function scopes. For example:
             #
@@ -3528,8 +4005,7 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
             # without this rule, this typical use case will require a lot of explicit
             # annotations (see the second rule).
             return False
-        rvalue = s.rvalue
-        if not pep_613 and not self.can_be_type_alias(rvalue):
+        if not pep_613 and not pep_695 and not self.can_be_type_alias(rvalue):
             return False
 
         if existing and not isinstance(existing.node, (PlaceholderNode, TypeAlias)):
@@ -3542,14 +4018,19 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
             alias_tvars: list[TypeVarLikeType] = []
             depends_on: set[str] = set()
             qualified_tvars: list[str] = []
+            empty_tuple_index = False
         else:
             tag = self.track_incomplete_refs()
-            res, alias_tvars, depends_on, qualified_tvars = self.analyze_alias(
-                lvalue.name, rvalue, allow_placeholder=True
+            res, alias_tvars, depends_on, qualified_tvars, empty_tuple_index = self.analyze_alias(
+                lvalue.name,
+                rvalue,
+                allow_placeholder=True,
+                declared_type_vars=type_params,
+                all_declared_type_params_names=all_type_params_names,
             )
             if not res:
                 return False
-            if not self.options.disable_recursive_aliases and not self.is_func_scope():
+            if not self.is_func_scope():
                 # Only marking incomplete for top-level placeholders makes recursive aliases like
                 # `A = Sequence[str | A]` valid here, similar to how we treat base classes in class
                 # definitions, allowing `class str(Sequence[str]): ...`
@@ -3574,11 +4055,25 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
         # When this type alias gets "inlined", the Any is not explicit anymore,
         # so we need to replace it with non-explicit Anys.
         res = make_any_non_explicit(res)
+        if self.options.disallow_any_unimported and has_any_from_unimported_type(res):
+            # Only show error message once, when the type is fully analyzed.
+            if not has_placeholder(res):
+                self.msg.unimported_type_becomes_any("Type alias target", res, s)
+                res = make_any_non_unimported(res)
         # Note: with the new (lazy) type alias representation we only need to set no_args to True
-        # if the expected number of arguments is non-zero, so that aliases like A = List work.
+        # if the expected number of arguments is non-zero, so that aliases like `A = List` work
+        # but not aliases like `A = TypeAliasType("A", List)` as these need explicit type params.
         # However, eagerly expanding aliases like Text = str is a nice performance optimization.
-        no_args = isinstance(res, Instance) and not res.args  # type: ignore[misc]
-        fix_instance_types(res, self.fail, self.note, self.options)
+        no_args = (
+            isinstance(res, ProperType)
+            and isinstance(res, Instance)
+            and not res.args
+            and not empty_tuple_index
+            and not pep_695
+        )
+        if isinstance(res, ProperType) and isinstance(res, Instance):
+            if not validate_instance(res, self.fail, empty_tuple_index):
+                fix_instance(res, self.fail, self.note, disallow_any=False, options=self.options)
         # Aliases defined within functions can't be accessed outside
         # the function, since the symbol table will no longer
         # exist. Work around by expanding them eagerly when used.
@@ -3591,13 +4086,16 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
             alias_tvars=alias_tvars,
             no_args=no_args,
             eager=eager,
+            python_3_12_type_alias=pep_695,
         )
         if isinstance(s.rvalue, (IndexExpr, CallExpr, OpExpr)) and (
             not isinstance(rvalue, OpExpr)
             or (self.options.python_version >= (3, 10) or self.is_stub_file)
         ):
             # Note: CallExpr is for "void = type(None)" and OpExpr is for "X | Y" union syntax.
-            s.rvalue.analyzed = TypeAliasExpr(alias_node)
+            if not isinstance(s.rvalue.analyzed, TypeAliasExpr):
+                # Any existing node will be updated in-place below.
+                s.rvalue.analyzed = TypeAliasExpr(alias_node)
             s.rvalue.analyzed.line = s.line
             # we use the column from resulting target, to get better location for errors
             s.rvalue.analyzed.column = res.column
@@ -3615,6 +4113,8 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
                     existing.node.alias_tvars = alias_tvars
                     existing.node.no_args = no_args
                     updated = True
+                    # Invalidate recursive status cache in case it was previously set.
+                    existing.node._is_recursive = None
             else:
                 # Otherwise just replace existing placeholder with type alias.
                 existing.node = alias_node
@@ -3632,7 +4132,7 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
             alias_node.normalized = rvalue.node.normalized
         current_node = existing.node if existing else alias_node
         assert isinstance(current_node, TypeAlias)
-        self.disable_invalid_recursive_aliases(s, current_node)
+        self.disable_invalid_recursive_aliases(s, current_node, s.rvalue)
         if self.is_class_scope():
             assert self.type is not None
             if self.type.is_protocol:
@@ -3641,13 +4141,115 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
                     self.note("Use variable annotation syntax to define protocol members", s)
         return True
 
+    def check_type_alias_type_call(self, rvalue: Expression, *, name: str) -> TypeGuard[CallExpr]:
+        if not isinstance(rvalue, CallExpr):
+            return False
+
+        names = ["typing_extensions.TypeAliasType"]
+        if self.options.python_version >= (3, 12):
+            names.append("typing.TypeAliasType")
+        if not refers_to_fullname(rvalue.callee, tuple(names)):
+            return False
+        if not self.check_typevarlike_name(rvalue, name, rvalue):
+            return False
+        if rvalue.arg_kinds.count(ARG_POS) != 2:
+            return False
+
+        return True
+
+    def analyze_type_alias_type_params(
+        self, rvalue: CallExpr
+    ) -> tuple[TypeVarLikeList, list[str]]:
+        """Analyze type_params of TypeAliasType.
+
+        Returns declared unbound type variable expressions and a list of all declared type
+        variable names for error reporting.
+        """
+        if "type_params" in rvalue.arg_names:
+            type_params_arg = rvalue.args[rvalue.arg_names.index("type_params")]
+            if not isinstance(type_params_arg, TupleExpr):
+                self.fail(
+                    "Tuple literal expected as the type_params argument to TypeAliasType",
+                    type_params_arg,
+                )
+                return [], []
+            type_params = type_params_arg.items
+        else:
+            return [], []
+
+        declared_tvars: TypeVarLikeList = []
+        all_declared_tvar_names: list[str] = []  # includes bound type variables
+        have_type_var_tuple = False
+        for tp_expr in type_params:
+            if isinstance(tp_expr, StarExpr):
+                tp_expr.valid = False
+            self.analyze_type_expr(tp_expr)
+            try:
+                base = self.expr_to_unanalyzed_type(tp_expr)
+            except TypeTranslationError:
+                continue
+            if not isinstance(base, UnboundType):
+                continue
+
+            tag = self.track_incomplete_refs()
+            tvar = self.analyze_unbound_tvar_impl(base, is_typealias_param=True)
+            if tvar:
+                if isinstance(tvar[1], TypeVarTupleExpr):
+                    if have_type_var_tuple:
+                        self.fail(
+                            "Can only use one TypeVarTuple in type_params argument to TypeAliasType",
+                            base,
+                            code=codes.TYPE_VAR,
+                        )
+                        have_type_var_tuple = True
+                        continue
+                    have_type_var_tuple = True
+            elif not self.found_incomplete_ref(tag):
+                sym = self.lookup_qualified(base.name, base)
+                if sym and isinstance(sym.node, TypeVarLikeExpr):
+                    all_declared_tvar_names.append(sym.node.name)  # Error will be reported later
+                else:
+                    self.fail(
+                        "Free type variable expected in type_params argument to TypeAliasType",
+                        base,
+                        code=codes.TYPE_VAR,
+                    )
+                    if sym and sym.fullname in UNPACK_TYPE_NAMES:
+                        self.note(
+                            "Don't Unpack type variables in type_params", base, code=codes.TYPE_VAR
+                        )
+                continue
+            if tvar in declared_tvars:
+                self.fail(
+                    f'Duplicate type variable "{tvar[0]}" in type_params argument to TypeAliasType',
+                    base,
+                    code=codes.TYPE_VAR,
+                )
+                continue
+            if tvar:
+                all_declared_tvar_names.append(tvar[0])
+                declared_tvars.append(tvar)
+        return declared_tvars, all_declared_tvar_names
+
     def disable_invalid_recursive_aliases(
-        self, s: AssignmentStmt, current_node: TypeAlias
+        self, s: AssignmentStmt | TypeAliasStmt, current_node: TypeAlias, ctx: Context
     ) -> None:
         """Prohibit and fix recursive type aliases that are invalid/unsupported."""
         messages = []
-        if is_invalid_recursive_alias({current_node}, current_node.target):
-            messages.append("Invalid recursive alias: a union item of itself")
+        if (
+            isinstance(current_node.target, TypeAliasType)
+            and current_node.target.alias is current_node
+        ):
+            # We want to have consistent error messages, but not calling name_not_defined(),
+            # since it will do a bunch of unrelated things we don't want here.
+            messages.append(
+                f'Cannot resolve name "{current_node.name}" (possible cyclic definition)'
+            )
+        elif is_invalid_recursive_alias({current_node}, current_node.target):
+            target = (
+                "tuple" if isinstance(get_proper_type(current_node.target), TupleType) else "union"
+            )
+            messages.append(f"Invalid recursive alias: a {target} item of itself")
         if detect_diverging_alias(
             current_node, current_node.target, self.lookup_qualified, self.tvar_scope
         ):
@@ -3656,7 +4258,7 @@ def disable_invalid_recursive_aliases(
             current_node.target = AnyType(TypeOfAny.from_error)
             s.invalid_recursive_alias = True
         for msg in messages:
-            self.fail(msg, s.rvalue)
+            self.fail(msg, ctx)
 
     def analyze_lvalue(
         self,
@@ -3666,6 +4268,7 @@ def analyze_lvalue(
         is_final: bool = False,
         escape_comprehensions: bool = False,
         has_explicit_value: bool = False,
+        is_index_var: bool = False,
     ) -> None:
         """Analyze an lvalue or assignment target.
 
@@ -3676,6 +4279,7 @@ def analyze_lvalue(
             escape_comprehensions: If we are inside a comprehension, set the variable
                 in the enclosing scope instead. This implements
                 https://www.python.org/dev/peps/pep-0572/#scope-of-the-target
+            is_index_var: If lval is the index variable in a for loop
         """
         if escape_comprehensions:
             assert isinstance(lval, NameExpr), "assignment expression target must be NameExpr"
@@ -3686,6 +4290,7 @@ def analyze_lvalue(
                 is_final,
                 escape_comprehensions,
                 has_explicit_value=has_explicit_value,
+                is_index_var=is_index_var,
             )
         elif isinstance(lval, MemberExpr):
             self.analyze_member_lvalue(lval, explicit_type, is_final, has_explicit_value)
@@ -3712,6 +4317,7 @@ def analyze_name_lvalue(
         is_final: bool,
         escape_comprehensions: bool,
         has_explicit_value: bool,
+        is_index_var: bool,
     ) -> None:
         """Analyze an lvalue that targets a name expression.
 
@@ -3733,7 +4339,12 @@ def analyze_name_lvalue(
         existing = names.get(name)
 
         outer = self.is_global_or_nonlocal(name)
-        if kind == MDEF and isinstance(self.type, TypeInfo) and self.type.is_enum:
+        if (
+            kind == MDEF
+            and isinstance(self.type, TypeInfo)
+            and self.type.is_enum
+            and not name.startswith("__")
+        ):
             # Special case: we need to be sure that `Enum` keys are unique.
             if existing is not None and not isinstance(existing.node, PlaceholderNode):
                 self.fail(
@@ -3743,9 +4354,18 @@ def analyze_name_lvalue(
                     lvalue,
                 )
 
+            if explicit_type and has_explicit_value:
+                self.fail("Enum members must be left unannotated", lvalue)
+                self.note(
+                    "See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members",
+                    lvalue,
+                )
+
         if (not existing or isinstance(existing.node, PlaceholderNode)) and not outer:
             # Define new variable.
-            var = self.make_name_lvalue_var(lvalue, kind, not explicit_type, has_explicit_value)
+            var = self.make_name_lvalue_var(
+                lvalue, kind, not explicit_type, has_explicit_value, is_index_var
+            )
             added = self.add_symbol(name, var, lvalue, escape_comprehensions=escape_comprehensions)
             # Only bind expression if we successfully added name to symbol table.
             if added:
@@ -3758,8 +4378,10 @@ def analyze_name_lvalue(
                 else:
                     lvalue.fullname = lvalue.name
                 if self.is_func_scope():
-                    if unmangle(name) == "_":
+                    if unmangle(name) == "_" and not self.options.allow_redefinition_new:
                         # Special case for assignment to local named '_': always infer 'Any'.
+                        # This isn't needed with --allow-redefinition-new, since arbitrary
+                        # types can be assigned to '_' anyway.
                         typ = AnyType(TypeOfAny.special_form)
                         self.store_declared_types(lvalue, typ)
             if is_final and self.is_final_redefinition(kind, name):
@@ -3797,7 +4419,12 @@ def is_alias_for_final_name(self, name: str) -> bool:
             return existing is not None and is_final_node(existing.node)
 
     def make_name_lvalue_var(
-        self, lvalue: NameExpr, kind: int, inferred: bool, has_explicit_value: bool
+        self,
+        lvalue: NameExpr,
+        kind: int,
+        inferred: bool,
+        has_explicit_value: bool,
+        is_index_var: bool,
     ) -> Var:
         """Return a Var node for an lvalue that is a name expression."""
         name = lvalue.name
@@ -3812,10 +4439,11 @@ def make_name_lvalue_var(
         if kind != LDEF:
             v._fullname = self.qualified_name(name)
         else:
-            # fullanme should never stay None
+            # fullname should never stay None
             v._fullname = name
         v.is_ready = False  # Type not inferred yet
         v.has_explicit_value = has_explicit_value
+        v.is_index_var = is_index_var
         return v
 
     def make_name_lvalue_point_to_existing_def(
@@ -4063,6 +4691,40 @@ def process_typevar_declaration(self, s: AssignmentStmt) -> bool:
         self.add_symbol(name, call.analyzed, s)
         return True
 
+    def check_typevar_default(self, default: Type, context: Context) -> Type:
+        typ = get_proper_type(default)
+        if isinstance(typ, AnyType) and typ.is_from_error:
+            self.fail(
+                message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format("TypeVar", "default"), context
+            )
+        return default
+
+    def check_paramspec_default(self, default: Type, context: Context) -> Type:
+        typ = get_proper_type(default)
+        if isinstance(typ, Parameters):
+            for i, arg_type in enumerate(typ.arg_types):
+                arg_ptype = get_proper_type(arg_type)
+                if isinstance(arg_ptype, AnyType) and arg_ptype.is_from_error:
+                    self.fail(f"Argument {i} of ParamSpec default must be a type", context)
+        elif (
+            isinstance(typ, AnyType)
+            and typ.is_from_error
+            or not isinstance(typ, (AnyType, UnboundType))
+        ):
+            self.fail(
+                "The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec",
+                context,
+            )
+            default = AnyType(TypeOfAny.from_error)
+        return default
+
+    def check_typevartuple_default(self, default: Type, context: Context) -> Type:
+        typ = get_proper_type(default)
+        if not isinstance(typ, UnpackType):
+            self.fail("The default argument to TypeVarTuple must be an Unpacked tuple", context)
+            default = AnyType(TypeOfAny.from_error)
+        return default
+
     def check_typevarlike_name(self, call: CallExpr, name: str, context: Context) -> bool:
         """Checks that the name of a TypeVar or ParamSpec matches its variable."""
         name = unmangle(name)
@@ -4073,7 +4735,7 @@ def check_typevarlike_name(self, call: CallExpr, name: str, context: Context) ->
         if len(call.args) < 1:
             self.fail(f"Too few arguments for {typevarlike_type}()", context)
             return False
-        if not isinstance(call.args[0], StrExpr) or not call.arg_kinds[0] == ARG_POS:
+        if not isinstance(call.args[0], StrExpr) or call.arg_kinds[0] != ARG_POS:
             self.fail(f"{typevarlike_type}() expects a string literal as first argument", context)
             return False
         elif call.args[0].value != name:
@@ -4161,7 +4823,7 @@ def process_typevar_parameters(
             self.fail("TypeVar cannot be both covariant and contravariant", context)
             return None
         elif num_values == 1:
-            self.fail("TypeVar cannot have only a single constraint", context)
+            self.fail(message_registry.TYPE_VAR_TOO_FEW_CONSTRAINED_TYPES, context)
             return None
         elif covariant:
             variance = COVARIANT
@@ -4180,6 +4842,7 @@ def get_typevarlike_argument(
         *,
         allow_unbound_tvars: bool = False,
         allow_param_spec_literals: bool = False,
+        allow_unpack: bool = False,
         report_invalid_typevar_arg: bool = True,
     ) -> ProperType | None:
         try:
@@ -4191,6 +4854,7 @@ def get_typevarlike_argument(
                 report_invalid_types=False,
                 allow_unbound_tvars=allow_unbound_tvars,
                 allow_param_spec_literals=allow_param_spec_literals,
+                allow_unpack=allow_unpack,
             )
             if analyzed is None:
                 # Type variables are special: we need to place them in the symbol table
@@ -4268,23 +4932,7 @@ def process_paramspec_declaration(self, s: AssignmentStmt) -> bool:
                     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)
+                default = self.check_paramspec_default(default, param_value)
             else:
                 # ParamSpec is different from a regular TypeVar:
                 # arguments are not semantically valid. But, allowed in runtime.
@@ -4342,20 +4990,13 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
                     s,
                     allow_unbound_tvars=True,
                     report_invalid_typevar_arg=False,
+                    allow_unpack=True,
                 )
                 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)
+                default = self.check_typevartuple_default(default, param_value)
             else:
                 self.fail(f'Unexpected keyword argument "{param_name}" for "TypeVarTuple"', s)
 
-        if not self.incomplete_feature_enabled(TYPE_VAR_TUPLE, s):
-            return False
-
         name = self.extract_typevarlike_name(s, call)
         if name is None:
             return False
@@ -4366,7 +5007,8 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
             typevartuple_var = TypeVarTupleExpr(
                 name,
                 self.qualified_name(name),
-                self.object_type(),
+                # Upper bound for *Ts is *tuple[object, ...], it can never be object.
+                tuple_fallback.copy_modified(),
                 tuple_fallback,
                 default,
                 INVARIANT,
@@ -4420,7 +5062,11 @@ def analyze_value_types(self, items: list[Expression]) -> list[Type]:
                     # soon, even if some value is not ready yet, see process_typevar_parameters()
                     # for an example.
                     analyzed = PlaceholderType(None, [], node.line)
-                result.append(analyzed)
+                if has_type_vars(analyzed):
+                    self.fail(message_registry.TYPE_VAR_GENERIC_CONSTRAINT_TYPE, node)
+                    result.append(AnyType(TypeOfAny.from_error))
+                else:
+                    result.append(analyzed)
             except TypeTranslationError:
                 self.fail("Type expected", node)
                 result.append(AnyType(TypeOfAny.from_error))
@@ -4496,7 +5142,7 @@ def process_module_assignment(
             # with unpacking assignment like `x, y = a, b`. Mypy didn't
             # understand our all(isinstance(...)), so cast them as TupleExpr
             # so mypy knows it is safe to access their .items attribute.
-            seq_lvals = cast(List[TupleExpr], lvals)
+            seq_lvals = cast(list[TupleExpr], lvals)
             # given an assignment like:
             #     (x, y) = (m, n) = (a, b)
             # we now have:
@@ -4666,6 +5312,8 @@ def visit_return_stmt(self, s: ReturnStmt) -> None:
         self.statement = s
         if not self.is_func_scope():
             self.fail('"return" outside function', s)
+        if self.return_stmt_inside_except_star_block:
+            self.fail('"return" not allowed in except* block', s, serious=True)
         if s.expr:
             s.expr.accept(self)
 
@@ -4698,9 +5346,10 @@ 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
-        s.body.accept(self)
-        self.loop_depth -= 1
+        self.loop_depth[-1] += 1
+        with self.inside_except_star_block_set(value=False, entering_loop=True):
+            s.body.accept(self)
+        self.loop_depth[-1] -= 1
         self.visit_block_maybe(s.else_body)
 
     def visit_for_stmt(self, s: ForStmt) -> None:
@@ -4712,7 +5361,7 @@ def visit_for_stmt(self, s: ForStmt) -> None:
         s.expr.accept(self)
 
         # Bind index variables and check if they define new names.
-        self.analyze_lvalue(s.index, explicit_type=s.index_type is not None)
+        self.analyze_lvalue(s.index, explicit_type=s.index_type is not None, is_index_var=True)
         if s.index_type:
             if self.is_classvar(s.index_type):
                 self.fail_invalid_classvar(s.index)
@@ -4722,21 +5371,25 @@ def visit_for_stmt(self, s: ForStmt) -> None:
                 self.store_declared_types(s.index, analyzed)
                 s.index_type = analyzed
 
-        self.loop_depth += 1
-        self.visit_block(s.body)
-        self.loop_depth -= 1
-
+        self.loop_depth[-1] += 1
+        with self.inside_except_star_block_set(value=False, entering_loop=True):
+            self.visit_block(s.body)
+        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)
+        if self.inside_except_star_block:
+            self.fail('"break" not allowed in except* block', s, serious=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)
+        if self.inside_except_star_block:
+            self.fail('"continue" not allowed in except* block', s, serious=True)
 
     def visit_if_stmt(self, s: IfStmt) -> None:
         self.statement = s
@@ -4757,7 +5410,8 @@ def analyze_try_stmt(self, s: TryStmt, visitor: NodeVisitor[None]) -> None:
                 type.accept(visitor)
             if var:
                 self.analyze_lvalue(var)
-            handler.accept(visitor)
+            with self.inside_except_star_block_set(self.inside_except_star_block or s.is_star):
+                handler.accept(visitor)
         if s.else_body:
             s.else_body.accept(visitor)
         if s.finally_body:
@@ -4840,8 +5494,14 @@ def visit_nonlocal_decl(self, d: NonlocalDecl) -> None:
             self.fail("nonlocal declaration not allowed at module level", d)
         else:
             for name in d.names:
-                for table in reversed(self.locals[:-1]):
+                for table, scope_type in zip(
+                    reversed(self.locals[:-1]), reversed(self.scope_stack[:-1])
+                ):
                     if table is not None and name in table:
+                        if scope_type == SCOPE_ANNOTATION:
+                            self.fail(
+                                f'nonlocal binding not allowed for type parameter "{name}"', d
+                            )
                         break
                 else:
                     self.fail(f'No binding for nonlocal "{name}" found', d)
@@ -4868,6 +5528,119 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
                 guard.accept(self)
             self.visit_block(s.bodies[i])
 
+    def visit_type_alias_stmt(self, s: TypeAliasStmt) -> None:
+        if s.invalid_recursive_alias:
+            return
+        self.statement = s
+        type_params = self.push_type_args(s.type_args, s)
+        if type_params is None:
+            self.defer(s)
+            return
+        all_type_params_names = [p.name for p in s.type_args]
+
+        try:
+            existing = self.current_symbol_table().get(s.name.name)
+            if existing and not (
+                isinstance(existing.node, TypeAlias)
+                or (isinstance(existing.node, PlaceholderNode) and existing.node.line == s.line)
+            ):
+                self.already_defined(s.name.name, s, existing, "Name")
+                return
+
+            tag = self.track_incomplete_refs()
+            res, alias_tvars, depends_on, qualified_tvars, empty_tuple_index = self.analyze_alias(
+                s.name.name,
+                s.value.expr(),
+                allow_placeholder=True,
+                declared_type_vars=type_params,
+                all_declared_type_params_names=all_type_params_names,
+                python_3_12_type_alias=True,
+            )
+            if not res:
+                res = AnyType(TypeOfAny.from_error)
+
+            if not self.is_func_scope():
+                # Only marking incomplete for top-level placeholders makes recursive aliases like
+                # `A = Sequence[str | A]` valid here, similar to how we treat base classes in class
+                # definitions, allowing `class str(Sequence[str]): ...`
+                incomplete_target = isinstance(res, ProperType) and isinstance(
+                    res, PlaceholderType
+                )
+            else:
+                incomplete_target = has_placeholder(res)
+
+            if self.found_incomplete_ref(tag) or incomplete_target:
+                # Since we have got here, we know this must be a type alias (incomplete refs
+                # may appear in nested positions), therefore use becomes_typeinfo=True.
+                self.mark_incomplete(s.name.name, s.value, becomes_typeinfo=True)
+                return
+
+            self.add_type_alias_deps(depends_on)
+            # In addition to the aliases used, we add deps on unbound
+            # type variables, since they are erased from target type.
+            self.add_type_alias_deps(qualified_tvars)
+            # The above are only direct deps on other aliases.
+            # For subscripted aliases, type deps from expansion are added in deps.py
+            # (because the type is stored).
+            check_for_explicit_any(
+                res, self.options, self.is_typeshed_stub_file, self.msg, context=s
+            )
+            # When this type alias gets "inlined", the Any is not explicit anymore,
+            # so we need to replace it with non-explicit Anys.
+            res = make_any_non_explicit(res)
+            if self.options.disallow_any_unimported and has_any_from_unimported_type(res):
+                self.msg.unimported_type_becomes_any("Type alias target", res, s)
+                res = make_any_non_unimported(res)
+            eager = self.is_func_scope()
+            if isinstance(res, ProperType) and isinstance(res, Instance):
+                fix_instance(res, self.fail, self.note, disallow_any=False, options=self.options)
+            alias_node = TypeAlias(
+                res,
+                self.qualified_name(s.name.name),
+                s.line,
+                s.column,
+                alias_tvars=alias_tvars,
+                no_args=False,
+                eager=eager,
+                python_3_12_type_alias=True,
+            )
+            s.alias_node = alias_node
+
+            if (
+                existing
+                and isinstance(existing.node, (PlaceholderNode, TypeAlias))
+                and existing.node.line == s.line
+            ):
+                updated = False
+                if isinstance(existing.node, TypeAlias):
+                    if existing.node.target != res:
+                        # Copy expansion to the existing alias, this matches how we update base classes
+                        # for a TypeInfo _in place_ if there are nested placeholders.
+                        existing.node.target = res
+                        existing.node.alias_tvars = alias_tvars
+                        updated = True
+                else:
+                    # Otherwise just replace existing placeholder with type alias.
+                    existing.node = alias_node
+                    updated = True
+
+                if updated:
+                    if self.final_iteration:
+                        self.cannot_resolve_name(s.name.name, "name", s)
+                        return
+                    else:
+                        # We need to defer so that this change can get propagated to base classes.
+                        self.defer(s, force_progress=True)
+            else:
+                self.add_symbol(s.name.name, alias_node, s)
+
+            current_node = existing.node if existing else alias_node
+            assert isinstance(current_node, TypeAlias)
+            self.disable_invalid_recursive_aliases(s, current_node, s.value)
+            s.name.accept(self)
+        finally:
+            self.pop_type_args(s.type_args)
+
     #
     # Expressions
     #
@@ -4879,10 +5652,12 @@ def visit_name_expr(self, expr: NameExpr) -> None:
 
     def bind_name_expr(self, expr: NameExpr, sym: SymbolTableNode) -> None:
         """Bind name expression to a symbol table node."""
-        if isinstance(sym.node, TypeVarExpr) and self.tvar_scope.get_binding(sym):
-            self.fail(
-                '"{}" is a type variable and only valid in type ' "context".format(expr.name), expr
-            )
+        if (
+            isinstance(sym.node, TypeVarExpr)
+            and self.tvar_scope.get_binding(sym)
+            and not self.allow_unbound_tvars
+        ):
+            self.fail(f'"{expr.name}" is a type variable and only valid in type context', expr)
         elif isinstance(sym.node, PlaceholderNode):
             self.process_placeholder(expr.name, "name", expr)
         else:
@@ -4924,14 +5699,14 @@ def visit_dict_expr(self, expr: DictExpr) -> None:
 
     def visit_star_expr(self, expr: StarExpr) -> None:
         if not expr.valid:
-            self.fail("Can use starred expression only as assignment target", expr, blocker=True)
+            self.fail("can't use starred expression here", expr, blocker=True)
         else:
             expr.expr.accept(self)
 
     def visit_yield_from_expr(self, e: YieldFromExpr) -> None:
         if not self.is_func_scope():
             self.fail('"yield from" outside function', e, serious=True, blocker=True)
-        elif self.is_comprehension_stack[-1]:
+        elif self.scope_stack[-1] == SCOPE_COMPREHENSION:
             self.fail(
                 '"yield from" inside comprehension or generator expression',
                 e,
@@ -4984,7 +5759,17 @@ def visit_call_expr(self, expr: CallExpr) -> None:
         elif refers_to_fullname(expr.callee, REVEAL_TYPE_NAMES):
             if not self.check_fixed_args(expr, 1, "reveal_type"):
                 return
-            expr.analyzed = RevealExpr(kind=REVEAL_TYPE, expr=expr.args[0])
+            reveal_imported = False
+            reveal_type_node = self.lookup("reveal_type", expr, suppress_errors=True)
+            if (
+                reveal_type_node
+                and isinstance(reveal_type_node.node, SYMBOL_FUNCBASE_TYPES)
+                and reveal_type_node.fullname in IMPORTED_REVEAL_TYPE_NAMES
+            ):
+                reveal_imported = True
+            expr.analyzed = RevealExpr(
+                kind=REVEAL_TYPE, expr=expr.args[0], is_imported=reveal_imported
+            )
             expr.analyzed.line = expr.line
             expr.analyzed.column = expr.column
             expr.analyzed.accept(self)
@@ -5045,6 +5830,12 @@ def visit_call_expr(self, expr: CallExpr) -> None:
             expr.analyzed = OpExpr("divmod", expr.args[0], expr.args[1])
             expr.analyzed.line = expr.line
             expr.analyzed.accept(self)
+        elif refers_to_fullname(
+            expr.callee, ("typing.TypeAliasType", "typing_extensions.TypeAliasType")
+        ):
+            with self.allow_unbound_tvars_set():
+                for a in expr.args:
+                    a.accept(self)
         else:
             # Normal call expression.
             for a in expr.args:
@@ -5077,14 +5868,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)
             ]
         )
@@ -5252,29 +6043,32 @@ def analyze_type_application_args(self, expr: IndexExpr) -> list[Type] | None:
         else:
             items = [index]
 
-        # whether param spec literals be allowed here
-        # TODO: should this be computed once and passed in?
-        #   or is there a better way to do this?
+        # TODO: this needs a clean-up.
+        # Probably always allow Parameters literals, and validate in semanal_typeargs.py
         base = expr.base
         if isinstance(base, RefExpr) and isinstance(base.node, TypeAlias):
+            allow_unpack = base.node.tvar_tuple_index is not None
             alias = base.node
-            target = get_proper_type(alias.target)
-            if isinstance(target, Instance):
-                has_param_spec = target.type.has_param_spec_type
-                num_args = len(target.type.type_vars)
+            if any(isinstance(t, ParamSpecType) for t in alias.alias_tvars):
+                has_param_spec = True
+                num_args = len(alias.alias_tvars)
             else:
                 has_param_spec = False
                 num_args = -1
-        elif isinstance(base, NameExpr) and isinstance(base.node, TypeInfo):
+        elif isinstance(base, RefExpr) and isinstance(base.node, TypeInfo):
+            allow_unpack = (
+                base.node.has_type_var_tuple_type or base.node.fullname == "builtins.tuple"
+            )
             has_param_spec = base.node.has_param_spec_type
             num_args = len(base.node.type_vars)
         else:
+            allow_unpack = False
             has_param_spec = False
             num_args = -1
 
         for item in items:
             try:
-                typearg = self.expr_to_unanalyzed_type(item)
+                typearg = self.expr_to_unanalyzed_type(item, allow_unpack=True)
             except TypeTranslationError:
                 self.fail("Type expected within [...]", expr)
                 return None
@@ -5286,16 +6080,18 @@ def analyze_type_application_args(self, expr: IndexExpr) -> list[Type] | None:
                 allow_unbound_tvars=self.allow_unbound_tvars,
                 allow_placeholder=True,
                 allow_param_spec_literals=has_param_spec,
+                allow_unpack=allow_unpack,
             )
             if analyzed is None:
                 return None
             types.append(analyzed)
 
+        if allow_unpack:
+            types = self.type_analyzer().check_unpacks_in_list(types)
         if has_param_spec and num_args == 1 and types:
             first_arg = get_proper_type(types[0])
-            if not (
-                len(types) == 1 and isinstance(first_arg, (Parameters, ParamSpecType, AnyType))
-            ):
+            single_any = len(types) == 1 and isinstance(first_arg, AnyType)
+            if not (single_any or any(isinstance(t, (Parameters, ParamSpecType)) for t in types)):
                 types = [Parameters(types, [ARG_POS] * len(types), [None] * len(types))]
 
         return types
@@ -5393,7 +6189,8 @@ def analyze_comp_for_2(self, expr: GeneratorExpr | DictionaryComprehension) -> N
 
     def visit_lambda_expr(self, expr: LambdaExpr) -> None:
         self.analyze_arg_initializers(expr)
-        self.analyze_function_body(expr)
+        with self.inside_except_star_block_set(False, entering_loop=False):
+            self.analyze_function_body(expr)
 
     def visit_conditional_expr(self, expr: ConditionalExpr) -> None:
         expr.if_expr.accept(self)
@@ -5409,7 +6206,7 @@ def visit__promote_expr(self, expr: PromoteExpr) -> None:
     def visit_yield_expr(self, e: YieldExpr) -> None:
         if not self.is_func_scope():
             self.fail('"yield" outside function', e, serious=True, blocker=True)
-        elif self.is_comprehension_stack[-1]:
+        elif self.scope_stack[-1] == SCOPE_COMPREHENSION:
             self.fail(
                 '"yield" inside comprehension or generator expression',
                 e,
@@ -5417,11 +6214,8 @@ def visit_yield_expr(self, e: YieldExpr) -> None:
                 blocker=True,
             )
         elif self.function_stack[-1].is_coroutine:
-            if self.options.python_version < (3, 6):
-                self.fail('"yield" in async function', e, serious=True, blocker=True)
-            else:
-                self.function_stack[-1].is_generator = True
-                self.function_stack[-1].is_async_generator = True
+            self.function_stack[-1].is_generator = True
+            self.function_stack[-1].is_async_generator = True
         else:
             self.function_stack[-1].is_generator = True
         if e.expr:
@@ -5430,11 +6224,16 @@ def visit_yield_expr(self, e: YieldExpr) -> None:
     def visit_await_expr(self, expr: AwaitExpr) -> None:
         if not self.is_func_scope() or not self.function_stack:
             # We check both because is_function_scope() returns True inside comprehensions.
-            # This is not a blocker, because some enviroments (like ipython)
+            # This is not a blocker, because some environments (like ipython)
             # support top level awaits.
             self.fail('"await" outside function', expr, serious=True, code=codes.TOP_LEVEL_AWAIT)
         elif not self.function_stack[-1].is_coroutine:
-            self.fail('"await" outside coroutine ("async def")', expr, serious=True, blocker=True)
+            self.fail(
+                '"await" outside coroutine ("async def")',
+                expr,
+                serious=True,
+                code=codes.AWAIT_NOT_ASYNC,
+            )
         expr.expr.accept(self)
 
     #
@@ -5509,7 +6308,7 @@ def lookup(
             if not suppress_errors:
                 self.name_not_defined(name, ctx)
             return None
-        # 2. Class attributes (if within class definition)
+        # 2a. Class attributes (if within class definition)
         if self.type and not self.is_func_scope() and name in self.type.names:
             node = self.type.names[name]
             if not node.implicit:
@@ -5519,10 +6318,14 @@ def lookup(
                 # Defined through self.x assignment
                 implicit_name = True
                 implicit_node = node
+        # 2b. Class attributes __qualname__ and __module__
+        if self.type and not self.is_func_scope() and name in {"__qualname__", "__module__"}:
+            return SymbolTableNode(MDEF, Var(name, self.str_type()))
         # 3. Local (function) scopes
         for table in reversed(self.locals):
             if table is not None and name in table:
                 return table[name]
+
         # 4. Current file global scope
         if name in self.globals:
             return self.globals[name]
@@ -5568,12 +6371,26 @@ class C:
         if self.statement is None:
             # Assume it's fine -- don't have enough context to check
             return True
-        return (
+        if (
             node is None
             or self.is_textually_before_statement(node)
             or not self.is_defined_in_current_module(node.fullname)
-            or isinstance(node, (TypeInfo, TypeAlias))
-            or (isinstance(node, PlaceholderNode) and node.becomes_typeinfo)
+        ):
+            return True
+        if self.is_type_like(node):
+            # Allow forward references to classes/type aliases (see docstring), but
+            # a forward reference should never shadow an existing regular reference.
+            if node.name not in self.globals:
+                return True
+            global_node = self.globals[node.name]
+            if not self.is_textually_before_class(global_node.node):
+                return True
+            return not self.is_type_like(global_node.node)
+        return False
+
+    def is_type_like(self, node: SymbolNode | None) -> bool:
+        return isinstance(node, (TypeInfo, TypeAlias)) or (
+            isinstance(node, PlaceholderNode) and node.becomes_typeinfo
         )
 
     def is_textually_before_statement(self, node: SymbolNode) -> bool:
@@ -5595,6 +6412,13 @@ def is_textually_before_statement(self, node: SymbolNode) -> bool:
         else:
             return line_diff > 0
 
+    def is_textually_before_class(self, node: SymbolNode | None) -> bool:
+        """Similar to above, but check if a node is defined before current class."""
+        assert self.type is not None
+        if node is None:
+            return False
+        return node.line < self.type.defn.line
+
     def is_overloaded_item(self, node: SymbolNode, statement: Statement) -> bool:
         """Check whether the function belongs to the overloaded variants"""
         if isinstance(node, OverloadedFuncDef) and isinstance(statement, FuncDef):
@@ -5692,9 +6516,7 @@ def get_module_symbol(self, node: MypyFile, name: str) -> SymbolTableNode | None
                 sym = SymbolTableNode(GDEF, self.modules[fullname])
             elif self.is_incomplete_namespace(module):
                 self.record_incomplete_ref()
-            elif "__getattr__" in names and (
-                node.is_stub or self.options.python_version >= (3, 7)
-            ):
+            elif "__getattr__" in names:
                 gvar = self.create_getattr_var(names["__getattr__"], name, fullname)
                 if gvar:
                     sym = SymbolTableNode(GDEF, gvar)
@@ -5769,18 +6591,46 @@ def lookup_fully_qualified_or_none(self, fullname: str) -> SymbolTableNode | Non
         Note that this can't be used for names nested in class namespaces.
         """
         # TODO: unify/clean-up/simplify lookup methods, see #4157.
-        # TODO: support nested classes (but consider performance impact,
-        #       we might keep the module level only lookup for thing like 'builtins.int').
-        assert "." in fullname
         module, name = fullname.rsplit(".", maxsplit=1)
-        if module not in self.modules:
-            return None
-        filenode = self.modules[module]
-        result = filenode.names.get(name)
-        if result is None and self.is_incomplete_namespace(module):
-            # TODO: More explicit handling of incomplete refs?
-            self.record_incomplete_ref()
-        return result
+
+        if module in self.modules:
+            # If the module exists, look up the name in the module.
+            # This is the common case.
+            filenode = self.modules[module]
+            result = filenode.names.get(name)
+            if result is None and self.is_incomplete_namespace(module):
+                # TODO: More explicit handling of incomplete refs?
+                self.record_incomplete_ref()
+            return result
+        else:
+            # Else, try to find the longest prefix of the module name that is in the modules dictionary.
+            splitted_modules = fullname.split(".")
+            names = []
+
+            while splitted_modules and ".".join(splitted_modules) not in self.modules:
+                names.append(splitted_modules.pop())
+
+            if not splitted_modules or not names:
+                # If no module or name is found, return None.
+                return None
+
+            # Reverse the names list to get the correct order of names.
+            names.reverse()
+
+            module = ".".join(splitted_modules)
+            filenode = self.modules[module]
+            result = filenode.names.get(names[0])
+
+            if result is None and self.is_incomplete_namespace(module):
+                # TODO: More explicit handling of incomplete refs?
+                self.record_incomplete_ref()
+
+            for part in names[1:]:
+                if result is not None and isinstance(result.node, TypeInfo):
+                    result = result.node.names.get(part)
+                else:
+                    return None
+            return result
 
     def object_type(self) -> Instance:
         return self.named_type("builtins.object")
@@ -5837,6 +6687,8 @@ def add_symbol(
         module_hidden: bool = False,
         can_defer: bool = True,
         escape_comprehensions: bool = False,
+        no_progress: bool = False,
+        type_param: bool = False,
     ) -> bool:
         """Add symbol to the currently active symbol table.
 
@@ -5858,7 +6710,9 @@ def add_symbol(
         symbol = SymbolTableNode(
             kind, node, module_public=module_public, module_hidden=module_hidden
         )
-        return self.add_symbol_table_node(name, symbol, context, can_defer, escape_comprehensions)
+        return self.add_symbol_table_node(
+            name, symbol, context, can_defer, escape_comprehensions, no_progress, type_param
+        )
 
     def add_symbol_skip_local(self, name: str, node: SymbolNode) -> None:
         """Same as above, but skipping the local namespace.
@@ -5889,6 +6743,8 @@ def add_symbol_table_node(
         context: Context | None = None,
         can_defer: bool = True,
         escape_comprehensions: bool = False,
+        no_progress: bool = False,
+        type_param: bool = False,
     ) -> bool:
         """Add symbol table node to the currently active symbol table.
 
@@ -5908,7 +6764,9 @@ def add_symbol_table_node(
             can_defer: if True, defer current target if adding a placeholder
             context: error context (see above about None value)
         """
-        names = self.current_symbol_table(escape_comprehensions=escape_comprehensions)
+        names = self.current_symbol_table(
+            escape_comprehensions=escape_comprehensions, type_param=type_param
+        )
         existing = names.get(name)
         if isinstance(symbol.node, PlaceholderNode) and can_defer:
             if context is not None:
@@ -5937,7 +6795,8 @@ def add_symbol_table_node(
                     self.name_already_defined(name, context, existing)
         elif name not in self.missing_names[-1] and "*" not in self.missing_names[-1]:
             names[name] = symbol
-            self.progress = True
+            if not no_progress:
+                self.progress = True
             return True
         return False
 
@@ -6206,7 +7065,7 @@ def process_placeholder(
     def cannot_resolve_name(self, name: str | None, kind: str, ctx: Context) -> None:
         name_format = f' "{name}"' if name else ""
         self.fail(f"Cannot resolve {kind}{name_format} (possible cyclic definition)", ctx)
-        if not self.options.disable_recursive_aliases and self.is_func_scope():
+        if self.is_func_scope():
             self.note("Recursive types are not allowed at function scope", ctx)
 
     def qualified_name(self, name: str) -> str:
@@ -6225,28 +7084,33 @@ def enter(
         names = self.saved_locals.setdefault(function, SymbolTable())
         self.locals.append(names)
         is_comprehension = isinstance(function, (GeneratorExpr, DictionaryComprehension))
-        self.is_comprehension_stack.append(is_comprehension)
+        self.scope_stack.append(SCOPE_FUNC if not is_comprehension else SCOPE_COMPREHENSION)
         self.global_decls.append(set())
         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
         finally:
             self.locals.pop()
-            self.is_comprehension_stack.pop()
+            self.scope_stack.pop()
             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:
-        return self.locals[-1] is not None
+        scope_type = self.scope_stack[-1]
+        if scope_type == SCOPE_ANNOTATION:
+            scope_type = self.scope_stack[-2]
+        return scope_type in (SCOPE_FUNC, SCOPE_COMPREHENSION)
 
     def is_nested_within_func_scope(self) -> bool:
         """Are we underneath a function scope, even if we are in a nested class also?"""
-        return any(l is not None for l in self.locals)
+        return any(s in (SCOPE_FUNC, SCOPE_COMPREHENSION) for s in self.scope_stack)
 
     def is_class_scope(self) -> bool:
         return self.type is not None and not self.is_func_scope()
@@ -6263,14 +7127,24 @@ def current_symbol_kind(self) -> int:
             kind = GDEF
         return kind
 
-    def current_symbol_table(self, escape_comprehensions: bool = False) -> SymbolTable:
-        if self.is_func_scope():
-            assert self.locals[-1] is not None
+    def current_symbol_table(
+        self, escape_comprehensions: bool = False, type_param: bool = False
+    ) -> SymbolTable:
+        if type_param and self.scope_stack[-1] == SCOPE_ANNOTATION:
+            n = self.locals[-1]
+            assert n is not None
+            return n
+        elif self.is_func_scope():
+            if self.scope_stack[-1] == SCOPE_ANNOTATION:
+                n = self.locals[-2]
+            else:
+                n = self.locals[-1]
+            assert n is not None
             if escape_comprehensions:
-                assert len(self.locals) == len(self.is_comprehension_stack)
+                assert len(self.locals) == len(self.scope_stack)
                 # Retrieve the symbol table from the enclosing non-comprehension scope.
-                for i, is_comprehension in enumerate(reversed(self.is_comprehension_stack)):
-                    if not is_comprehension:
+                for i, scope_type in enumerate(reversed(self.scope_stack)):
+                    if scope_type != SCOPE_COMPREHENSION:
                         if i == len(self.locals) - 1:  # The last iteration.
                             # The caller of the comprehension is in the global space.
                             names = self.globals
@@ -6284,7 +7158,7 @@ def current_symbol_table(self, escape_comprehensions: bool = False) -> SymbolTab
                 else:
                     assert False, "Should have at least one non-comprehension scope"
             else:
-                names = self.locals[-1]
+                names = n
             assert names is not None
         elif self.type is not None:
             names = self.type.names
@@ -6309,6 +7183,7 @@ def name_not_defined(self, name: str, ctx: Context, namespace: str | None = None
             namespace is None
             and self.type
             and not self.is_func_scope()
+            and self.incomplete_type_stack
             and self.incomplete_type_stack[-1]
             and not self.final_iteration
         ):
@@ -6411,7 +7286,7 @@ def in_checked_function(self) -> bool:
 
     def fail(
         self,
-        msg: str,
+        msg: str | ErrorMessage,
         ctx: Context,
         serious: bool = False,
         *,
@@ -6422,7 +7297,19 @@ def fail(
             return
         # In case it's a bug and we don't really have context
         assert ctx is not None, msg
-        self.errors.report(ctx.line, ctx.column, msg, blocker=blocker, code=code)
+        if isinstance(msg, ErrorMessage):
+            if code is None:
+                code = msg.code
+            msg = msg.value
+        self.errors.report(
+            ctx.line,
+            ctx.column,
+            msg,
+            blocker=blocker,
+            code=code,
+            end_line=ctx.end_line,
+            end_column=ctx.end_column,
+        )
 
     def note(self, msg: str, ctx: Context, code: ErrorCode | None = None) -> None:
         if not self.in_checked_function():
@@ -6453,6 +7340,7 @@ def expr_to_analyzed_type(
         allow_type_any: bool = False,
         allow_unbound_tvars: bool = False,
         allow_param_spec_literals: bool = False,
+        allow_unpack: bool = False,
     ) -> Type | None:
         if isinstance(expr, CallExpr):
             # This is a legacy syntax intended mostly for Python 2, we keep it for
@@ -6483,6 +7371,7 @@ def expr_to_analyzed_type(
             allow_type_any=allow_type_any,
             allow_unbound_tvars=allow_unbound_tvars,
             allow_param_spec_literals=allow_param_spec_literals,
+            allow_unpack=allow_unpack,
         )
 
     def analyze_type_expr(self, expr: Expression) -> None:
@@ -6502,10 +7391,13 @@ def type_analyzer(
         allow_tuple_literal: bool = False,
         allow_unbound_tvars: bool = False,
         allow_placeholder: bool = False,
-        allow_required: bool = False,
+        allow_typed_dict_special_forms: bool = False,
+        allow_final: bool = False,
         allow_param_spec_literals: bool = False,
+        allow_unpack: bool = False,
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
+        prohibit_special_class_field_types: str | None = None,
         allow_type_any: bool = False,
     ) -> TypeAnalyser:
         if tvar_scope is None:
@@ -6515,22 +7407,28 @@ def type_analyzer(
             tvar_scope,
             self.plugin,
             self.options,
+            self.cur_mod_node,
             self.is_typeshed_stub_file,
             allow_unbound_tvars=allow_unbound_tvars,
             allow_tuple_literal=allow_tuple_literal,
             report_invalid_types=report_invalid_types,
             allow_placeholder=allow_placeholder,
-            allow_required=allow_required,
+            allow_typed_dict_special_forms=allow_typed_dict_special_forms,
+            allow_final=allow_final,
             allow_param_spec_literals=allow_param_spec_literals,
+            allow_unpack=allow_unpack,
             prohibit_self_type=prohibit_self_type,
+            prohibit_special_class_field_types=prohibit_special_class_field_types,
             allow_type_any=allow_type_any,
         )
         tpan.in_dynamic_func = bool(self.function_stack and self.function_stack[-1].is_dynamic())
         tpan.global_scope = not self.type and not self.function_stack
         return tpan
 
-    def expr_to_unanalyzed_type(self, node: Expression) -> ProperType:
-        return expr_to_unanalyzed_type(node, self.options, self.is_stub_file)
+    def expr_to_unanalyzed_type(self, node: Expression, allow_unpack: bool = False) -> ProperType:
+        return expr_to_unanalyzed_type(
+            node, self.options, self.is_stub_file, allow_unpack=allow_unpack
+        )
 
     def anal_type(
         self,
@@ -6540,12 +7438,14 @@ def anal_type(
         allow_tuple_literal: bool = False,
         allow_unbound_tvars: bool = False,
         allow_placeholder: bool = False,
-        allow_required: bool = False,
+        allow_typed_dict_special_forms: bool = False,
+        allow_final: bool = False,
         allow_param_spec_literals: bool = False,
+        allow_unpack: bool = False,
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
+        prohibit_special_class_field_types: str | None = None,
         allow_type_any: bool = False,
-        third_pass: bool = False,
     ) -> Type | None:
         """Semantically analyze a type.
 
@@ -6553,8 +7453,6 @@ def anal_type(
             typ: Type to analyze (if already analyzed, this is a no-op)
             allow_placeholder: If True, may return PlaceholderType if
                 encountering an incomplete definition
-            third_pass: Unused; only for compatibility with old semantic
-                analyzer
 
         Return None only if some part of the type couldn't be bound *and* it
         referred to an incomplete namespace or definition. In this case also
@@ -6577,10 +7475,13 @@ def anal_type(
             allow_unbound_tvars=allow_unbound_tvars,
             allow_tuple_literal=allow_tuple_literal,
             allow_placeholder=allow_placeholder,
-            allow_required=allow_required,
+            allow_typed_dict_special_forms=allow_typed_dict_special_forms,
+            allow_final=allow_final,
             allow_param_spec_literals=allow_param_spec_literals,
+            allow_unpack=allow_unpack,
             report_invalid_types=report_invalid_types,
             prohibit_self_type=prohibit_self_type,
+            prohibit_special_class_field_types=prohibit_special_class_field_types,
             allow_type_any=allow_type_any,
         )
         tag = self.track_incomplete_refs()
@@ -6701,16 +7602,44 @@ def parse_dataclass_transform_spec(self, call: CallExpr) -> DataclassTransformSp
     def parse_dataclass_transform_field_specifiers(self, arg: Expression) -> tuple[str, ...]:
         if not isinstance(arg, TupleExpr):
             self.fail('"field_specifiers" argument must be a tuple literal', arg)
-            return tuple()
+            return ()
 
         names = []
         for specifier in arg.items:
             if not isinstance(specifier, RefExpr):
                 self.fail('"field_specifiers" must only contain identifiers', specifier)
-                return tuple()
+                return ()
             names.append(specifier.fullname)
         return tuple(names)
 
+    # leafs
+    def visit_int_expr(self, o: IntExpr, /) -> None:
+        return None
+
+    def visit_str_expr(self, o: StrExpr, /) -> None:
+        return None
+
+    def visit_bytes_expr(self, o: BytesExpr, /) -> None:
+        return None
+
+    def visit_float_expr(self, o: FloatExpr, /) -> None:
+        return None
+
+    def visit_complex_expr(self, o: ComplexExpr, /) -> None:
+        return None
+
+    def visit_ellipsis(self, o: EllipsisExpr, /) -> None:
+        return None
+
+    def visit_temp_node(self, o: TempNode, /) -> None:
+        return None
+
+    def visit_pass_stmt(self, o: PassStmt, /) -> None:
+        return None
+
+    def visit_singleton_pattern(self, o: SingletonPattern, /) -> None:
+        return None
+
 
 def replace_implicit_first_type(sig: FunctionLike, new: Type) -> FunctionLike:
     if isinstance(sig, CallableType):
@@ -6786,6 +7715,21 @@ def visit_type_alias_type(self, t: TypeAliasType) -> Type:
         return t.copy_modified(args=[a.accept(self) for a in t.args])
 
 
+def make_any_non_unimported(t: Type) -> Type:
+    """Replace all Any types that come from unimported types with special form Any."""
+    return t.accept(MakeAnyNonUnimported())
+
+
+class MakeAnyNonUnimported(TrivialSyntheticTypeTranslator):
+    def visit_any(self, t: AnyType) -> Type:
+        if t.type_of_any == TypeOfAny.from_unimported_type:
+            return t.copy_modified(TypeOfAny.special_form, missing_import_name=None)
+        return t
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        return t.copy_modified(args=[a.accept(self) for a in t.args])
+
+
 def apply_semantic_analyzer_patches(patches: list[tuple[int, Callable[[], None]]]) -> None:
     """Call patch callbacks in the right order.
 
diff --git a/mypy/semanal_classprop.py b/mypy/semanal_classprop.py
index 3f5bc9c4c2de..c5ad34122f6c 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 (
@@ -46,6 +46,8 @@ def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: E
     abstract attribute.  Also compute a list of abstract attributes.
     Report error is required ABCMeta metaclass is missing.
     """
+    typ.is_abstract = False
+    typ.abstract_attributes = []
     if typ.typeddict_type:
         return  # TypedDict can't be abstract
     concrete: set[str] = set()
@@ -56,7 +58,6 @@ def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: E
         # Special case: NewTypes are considered as always non-abstract, so they can be used as:
         #     Config = NewType('Config', Mapping[str, str])
         #     default = Config({'cannot': 'modify'})  # OK
-        typ.abstract_attributes = []
         return
     for base in typ.mro:
         for name, symnode in base.names.items():
@@ -121,11 +122,12 @@ def check_protocol_status(info: TypeInfo, errors: Errors) -> None:
     if info.is_protocol:
         for type in info.bases:
             if not type.type.is_protocol and type.type.fullname != "builtins.object":
-
-                def report(message: str, severity: str) -> None:
-                    errors.report(info.line, info.column, message, severity=severity)
-
-                report("All bases of a protocol must be protocols", "error")
+                errors.report(
+                    info.line,
+                    info.column,
+                    "All bases of a protocol must be protocols",
+                    severity="error",
+                )
 
 
 def calculate_class_vars(info: TypeInfo) -> None:
diff --git a/mypy/semanal_enum.py b/mypy/semanal_enum.py
index f8d321ffada9..b1e267b4c781 100644
--- a/mypy/semanal_enum.py
+++ b/mypy/semanal_enum.py
@@ -5,12 +5,12 @@
 
 from __future__ import annotations
 
-from typing import cast
-from typing_extensions import Final
+from typing import Final, cast
 
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
+    EXCLUDED_ENUM_ATTRIBUTES,
     MDEF,
     AssignmentStmt,
     CallExpr,
@@ -31,7 +31,7 @@
 )
 from mypy.options import Options
 from mypy.semanal_shared import SemanticAnalyzerInterface
-from mypy.types import ENUM_REMOVED_PROPS, LiteralType, get_proper_type
+from mypy.types import LiteralType, get_proper_type
 
 # Note: 'enum.EnumMeta' is deliberately excluded from this list. Classes that directly use
 # enum.EnumMeta do not necessarily automatically have the 'name' and 'value' attributes.
@@ -44,7 +44,7 @@
         "value",
         "_name_",
         "_value_",
-        *ENUM_REMOVED_PROPS,
+        *EXCLUDED_ENUM_ATTRIBUTES,
         # Also attributes from `object`:
         "__module__",
         "__annotations__",
@@ -104,19 +104,29 @@ class A(enum.Enum):
         fullname = callee.fullname
         if fullname not in ENUM_BASES:
             return None
-        items, values, ok = self.parse_enum_call_args(call, fullname.split(".")[-1])
+
+        new_class_name, items, values, ok = self.parse_enum_call_args(
+            call, fullname.split(".")[-1]
+        )
         if not ok:
             # Error. Construct dummy return value.
-            info = self.build_enum_call_typeinfo(var_name, [], fullname, node.line)
+            name = var_name
+            if is_func_scope:
+                name += "@" + str(call.line)
+            info = self.build_enum_call_typeinfo(name, [], fullname, node.line)
         else:
+            if new_class_name != var_name:
+                msg = f'String argument 1 "{new_class_name}" to {fullname}(...) does not match variable name "{var_name}"'
+                self.fail(msg, call)
+
             name = cast(StrExpr, call.args[0]).value
             if name != var_name or is_func_scope:
                 # Give it a unique name derived from the line number.
                 name += "@" + str(call.line)
             info = self.build_enum_call_typeinfo(name, items, fullname, call.line)
-            # Store generated TypeInfo under both names, see semanal_namedtuple for more details.
-            if name != var_name or is_func_scope:
-                self.api.add_symbol_skip_local(name, info)
+        # Store generated TypeInfo under both names, see semanal_namedtuple for more details.
+        if name != var_name or is_func_scope:
+            self.api.add_symbol_skip_local(name, info)
         call.analyzed = EnumCallExpr(info, items, values)
         call.analyzed.set_line(call)
         info.line = node.line
@@ -134,19 +144,25 @@ def build_enum_call_typeinfo(
             var = Var(item)
             var.info = info
             var.is_property = True
+            # When an enum is created by its functional form `Enum(name, values)`
+            # - if it is a string it is first split by commas/whitespace
+            # - if it is an iterable of single items each item is assigned a value starting at `start`
+            # - if it is an iterable of (name, value) then the given values will be used
+            # either way, each item should be treated as if it has an explicit value.
+            var.has_explicit_value = True
             var._fullname = f"{info.fullname}.{item}"
             info.names[item] = SymbolTableNode(MDEF, var)
         return info
 
     def parse_enum_call_args(
         self, call: CallExpr, class_name: str
-    ) -> tuple[list[str], list[Expression | None], bool]:
+    ) -> tuple[str, list[str], list[Expression | None], bool]:
         """Parse arguments of an Enum call.
 
         Return a tuple of fields, values, was there an error.
         """
         args = call.args
-        if not all([arg_kind in [ARG_POS, ARG_NAMED] for arg_kind in call.arg_kinds]):
+        if not all(arg_kind in [ARG_POS, ARG_NAMED] for arg_kind in call.arg_kinds):
             return self.fail_enum_call_arg(f"Unexpected arguments to {class_name}()", call)
         if len(args) < 2:
             return self.fail_enum_call_arg(f"Too few arguments for {class_name}()", call)
@@ -170,6 +186,8 @@ def parse_enum_call_args(
             return self.fail_enum_call_arg(
                 f"{class_name}() expects a string literal as the first argument", call
             )
+        new_class_name = value.value
+
         items = []
         values: list[Expression | None] = []
         if isinstance(names, StrExpr):
@@ -237,13 +255,13 @@ def parse_enum_call_args(
         if not values:
             values = [None] * len(items)
         assert len(items) == len(values)
-        return items, values, True
+        return new_class_name, items, values, True
 
     def fail_enum_call_arg(
         self, message: str, context: Context
-    ) -> tuple[list[str], list[Expression | None], bool]:
+    ) -> tuple[str, list[str], list[Expression | None], bool]:
         self.fail(message, context)
-        return [], [], False
+        return "", [], [], False
 
     # Helpers
 
diff --git a/mypy/semanal_main.py b/mypy/semanal_main.py
index 8e8c455dd686..00d795c64e44 100644
--- a/mypy/semanal_main.py
+++ b/mypy/semanal_main.py
@@ -26,9 +26,11 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from contextlib import nullcontext
-from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from itertools import groupby
+from typing import TYPE_CHECKING, Callable, Final, Optional, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.build
 import mypy.state
@@ -59,7 +61,7 @@
     from mypy.build import Graph, State
 
 
-Patches: _TypeAlias = List[Tuple[int, Callable[[], None]]]
+Patches: _TypeAlias = list[tuple[int, Callable[[], None]]]
 
 
 # If we perform this many iterations, raise an exception since we are likely stuck.
@@ -75,7 +77,6 @@
     "abc",
     "collections",
     "collections.abc",
-    "typing_extensions",
 ]
 
 
@@ -180,7 +181,7 @@ def process_top_levels(graph: Graph, scc: list[str], patches: Patches) -> None:
 
     # Reverse order of the scc so the first modules in the original list will be
     # be processed first. This helps with performance.
-    scc = list(reversed(scc))
+    scc = list(reversed(scc))  # noqa: FURB187 intentional copy
 
     # Initialize ASTs and symbol tables.
     for id in scc:
@@ -233,26 +234,66 @@ def process_top_levels(graph: Graph, scc: list[str], patches: Patches) -> None:
         final_iteration = not any_progress
 
 
+def order_by_subclassing(targets: list[FullTargetInfo]) -> Iterator[FullTargetInfo]:
+    """Make sure that superclass methods are always processed before subclass methods.
+
+    This algorithm is not very optimal, but it is simple and should work well for lists
+    that are already almost correctly ordered.
+    """
+
+    # First, group the targets by their TypeInfo (since targets are sorted by line,
+    # we know that each TypeInfo will appear as group key only once).
+    grouped = [(k, list(g)) for k, g in groupby(targets, key=lambda x: x[3])]
+    remaining_infos = {info for info, _ in grouped if info is not None}
+
+    next_group = 0
+    while grouped:
+        if next_group >= len(grouped):
+            # This should never happen, if there is an MRO cycle, it should be reported
+            # and fixed during top-level processing.
+            raise ValueError("Cannot order method targets by MRO")
+        next_info, group = grouped[next_group]
+        if next_info is None:
+            # Trivial case, not methods but functions, process them straight away.
+            yield from group
+            grouped.pop(next_group)
+            continue
+        if any(parent in remaining_infos for parent in next_info.mro[1:]):
+            # We cannot process this method group yet, try a next one.
+            next_group += 1
+            continue
+        yield from group
+        grouped.pop(next_group)
+        remaining_infos.discard(next_info)
+        # Each time after processing a method group we should retry from start,
+        # since there may be some groups that are not blocked on parents anymore.
+        next_group = 0
+
+
 def process_functions(graph: Graph, scc: list[str], patches: Patches) -> None:
     # Process functions.
+    all_targets = []
     for module in scc:
         tree = graph[module].tree
         assert tree is not None
-        analyzer = graph[module].manager.semantic_analyzer
         # In principle, functions can be processed in arbitrary order,
         # but _methods_ must be processed in the order they are defined,
         # because some features (most notably partial types) depend on
         # order of definitions on self.
         #
         # There can be multiple generated methods per line. Use target
-        # name as the second sort key to get a repeatable sort order on
-        # Python 3.5, which doesn't preserve dictionary order.
+        # name as the second sort key to get a repeatable sort order.
         targets = sorted(get_all_leaf_targets(tree), key=lambda x: (x[1].line, x[0]))
-        for target, node, active_type in targets:
-            assert isinstance(node, (FuncDef, OverloadedFuncDef, Decorator))
-            process_top_level_function(
-                analyzer, graph[module], module, target, node, active_type, patches
-            )
+        all_targets.extend(
+            [(module, target, node, active_type) for target, node, active_type in targets]
+        )
+
+    for module, target, node, active_type in order_by_subclassing(all_targets):
+        analyzer = graph[module].manager.semantic_analyzer
+        assert isinstance(node, (FuncDef, OverloadedFuncDef, Decorator))
+        process_top_level_function(
+            analyzer, graph[module], module, target, node, active_type, patches
+        )
 
 
 def process_top_level_function(
@@ -292,6 +333,8 @@ def process_top_level_function(
         deferred, incomplete, progress = semantic_analyze_target(
             target, module, state, node, active_type, final_iteration, patches
         )
+        if not incomplete:
+            state.manager.incomplete_namespaces.discard(module)
         if final_iteration:
             assert not deferred, "Must not defer during final iteration"
         if not progress:
@@ -303,10 +346,15 @@ def process_top_level_function(
     analyzer.saved_locals.clear()
 
 
-TargetInfo: _TypeAlias = Tuple[
+TargetInfo: _TypeAlias = tuple[
     str, Union[MypyFile, FuncDef, OverloadedFuncDef, Decorator], Optional[TypeInfo]
 ]
 
+# Same as above but includes module as first item.
+FullTargetInfo: _TypeAlias = tuple[
+    str, str, Union[MypyFile, FuncDef, OverloadedFuncDef, Decorator], Optional[TypeInfo]
+]
+
 
 def get_all_leaf_targets(file: MypyFile) -> list[TargetInfo]:
     """Return all leaf targets in a symbol table (module-level and methods)."""
@@ -341,6 +389,7 @@ def semantic_analyze_target(
     analyzer.global_decls = [set()]
     analyzer.nonlocal_decls = [set()]
     analyzer.globals = tree.names
+    analyzer.imports = set()
     analyzer.progress = False
     with state.wrap_context(check_blockers=False):
         refresh_node = node
@@ -381,7 +430,8 @@ def check_type_arguments(graph: Graph, scc: list[str], errors: Errors) -> None:
         analyzer = TypeArgumentAnalyzer(
             errors,
             state.options,
-            is_typeshed_file(state.options.abs_custom_typeshed_dir, state.path or ""),
+            state.tree.is_typeshed_file(state.options),
+            state.manager.semantic_analyzer.named_type,
         )
         with state.wrap_context():
             with mypy.state.state.strict_optional_set(state.options.strict_optional):
@@ -400,6 +450,7 @@ def check_type_arguments_in_targets(
         errors,
         state.options,
         is_typeshed_file(state.options.abs_custom_typeshed_dir, state.path or ""),
+        state.manager.semantic_analyzer.named_type,
     )
     with state.wrap_context():
         with mypy.state.state.strict_optional_set(state.options.strict_optional):
diff --git a/mypy/semanal_namedtuple.py b/mypy/semanal_namedtuple.py
index c690d4ec6d20..b67747d16887 100644
--- a/mypy/semanal_namedtuple.py
+++ b/mypy/semanal_namedtuple.py
@@ -5,11 +5,14 @@
 
 from __future__ import annotations
 
+import keyword
+from collections.abc import Container, Iterator, Mapping
 from contextlib import contextmanager
-from typing import Iterator, List, Mapping, cast
-from typing_extensions import Final
+from typing import Final, cast
 
+from mypy.errorcodes import ARG_TYPE, ErrorCode
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
+from mypy.messages import MessageBuilder
 from mypy.nodes import (
     ARG_NAMED_OPT,
     ARG_OPT,
@@ -60,6 +63,7 @@
     Type,
     TypeOfAny,
     TypeType,
+    TypeVarId,
     TypeVarLikeType,
     TypeVarType,
     UnboundType,
@@ -85,16 +89,19 @@
 )
 
 NAMEDTUP_CLASS_ERROR: Final = (
-    "Invalid statement in NamedTuple definition; " 'expected "field_name: field_type [= default]"'
+    'Invalid statement in NamedTuple definition; expected "field_name: field_type [= default]"'
 )
 
 SELF_TVAR_NAME: Final = "_NT"
 
 
 class NamedTupleAnalyzer:
-    def __init__(self, options: Options, api: SemanticAnalyzerInterface) -> None:
+    def __init__(
+        self, options: Options, api: SemanticAnalyzerInterface, msg: MessageBuilder
+    ) -> None:
         self.options = options
         self.api = api
+        self.msg = msg
 
     def analyze_namedtuple_classdef(
         self, defn: ClassDef, is_stub_file: bool, is_func_scope: bool
@@ -143,9 +150,6 @@ def check_namedtuple_classdef(
           * valid statements
         or None, if any of the types are not ready.
         """
-        if self.options.python_version < (3, 6) and not is_stub_file:
-            self.fail("NamedTuple class syntax is only supported in Python 3.6", defn)
-            return [], [], {}, []
         if len(defn.base_type_exprs) > 1:
             self.fail("NamedTuple should be a single base", defn)
         items: list[str] = []
@@ -186,15 +190,15 @@ def check_namedtuple_classdef(
                     # it would be inconsistent with type aliases.
                     analyzed = self.api.anal_type(
                         stmt.type,
-                        allow_placeholder=not self.options.disable_recursive_aliases
-                        and not self.api.is_func_scope(),
+                        allow_placeholder=not self.api.is_func_scope(),
                         prohibit_self_type="NamedTuple item type",
+                        prohibit_special_class_field_types="NamedTuple",
                     )
                     if analyzed is None:
                         # Something is incomplete. We need to defer this named tuple.
                         return None
                     types.append(analyzed)
-                # ...despite possible minor failures that allow further analyzis.
+                # ...despite possible minor failures that allow further analysis.
                 if name.startswith("_"):
                     self.fail(
                         f"NamedTuple field name cannot start with an underscore: {name}", stmt
@@ -209,6 +213,10 @@ def check_namedtuple_classdef(
                         )
                 else:
                     default_items[name] = stmt.rvalue
+        if defn.keywords:
+            for_function = ' for "__init_subclass__" of "NamedTuple"'
+            for key in defn.keywords:
+                self.msg.unexpected_keyword_argument_for_function(for_function, key, defn)
         return items, types, default_items, statements
 
     def check_namedtuple(
@@ -349,6 +357,7 @@ def parse_namedtuple_args(
             self.fail(f'Too few arguments for "{type_name}()"', call)
             return None
         defaults: list[Expression] = []
+        rename = False
         if len(args) > 2:
             # Typed namedtuple doesn't support additional arguments.
             if fullname in TYPED_NAMEDTUPLE_NAMES:
@@ -367,7 +376,16 @@ def parse_namedtuple_args(
                             "{}()".format(type_name),
                             arg,
                         )
-                    break
+                elif arg_name == "rename":
+                    arg = args[i]
+                    if isinstance(arg, NameExpr) and arg.name in ("True", "False"):
+                        rename = arg.name == "True"
+                    else:
+                        self.fail(
+                            f'Boolean literal expected as the "rename" argument to {type_name}()',
+                            arg,
+                            code=ARG_TYPE,
+                        )
         if call.arg_kinds[:2] != [ARG_POS, ARG_POS]:
             self.fail(f'Unexpected arguments to "{type_name}()"', call)
             return None
@@ -414,17 +432,28 @@ def parse_namedtuple_args(
                     return [], [], [], typename, [], False
         if not types:
             types = [AnyType(TypeOfAny.unannotated) for _ in items]
-        underscore = [item for item in items if item.startswith("_")]
-        if underscore:
-            self.fail(
-                f'"{type_name}()" field names cannot start with an underscore: '
-                + ", ".join(underscore),
-                call,
-            )
+        processed_items = []
+        seen_names: set[str] = set()
+        for i, item in enumerate(items):
+            problem = self.check_namedtuple_field_name(item, seen_names)
+            if problem is None:
+                processed_items.append(item)
+                seen_names.add(item)
+            else:
+                if not rename:
+                    self.fail(f'"{type_name}()" {problem}', call)
+                # Even if rename=False, we pretend that it is True.
+                # At runtime namedtuple creation would throw an error;
+                # applying the rename logic means we create a more sensible
+                # namedtuple.
+                new_name = f"_{i}"
+                processed_items.append(new_name)
+                seen_names.add(new_name)
+
         if len(defaults) > len(items):
             self.fail(f'Too many defaults given in call to "{type_name}()"', call)
             defaults = defaults[: len(items)]
-        return items, types, defaults, typename, tvar_defs, True
+        return processed_items, types, defaults, typename, tvar_defs, True
 
     def parse_namedtuple_fields_with_types(
         self, nodes: list[Expression], context: Context
@@ -454,9 +483,9 @@ def parse_namedtuple_fields_with_types(
                 # We never allow recursive types at function scope.
                 analyzed = self.api.anal_type(
                     type,
-                    allow_placeholder=not self.options.disable_recursive_aliases
-                    and not self.api.is_func_scope(),
+                    allow_placeholder=not self.api.is_func_scope(),
                     prohibit_self_type="NamedTuple item type",
+                    prohibit_special_class_field_types="NamedTuple",
                 )
                 # Workaround #4987 and avoid introducing a bogus UnboundType
                 if isinstance(analyzed, UnboundType):
@@ -543,40 +572,46 @@ def add_field(
             add_field(Var("__match_args__", match_args_type), is_initialized_in_class=True)
 
         assert info.tuple_type is not None  # Set by update_tuple_type() above.
-        tvd = TypeVarType(
+        shared_self_type = TypeVarType(
             name=SELF_TVAR_NAME,
-            fullname=info.fullname + "." + SELF_TVAR_NAME,
+            fullname=f"{info.fullname}.{SELF_TVAR_NAME}",
+            # Namespace is patched per-method below.
             id=self.api.tvar_scope.new_unique_func_id(),
             values=[],
             upper_bound=info.tuple_type,
             default=AnyType(TypeOfAny.from_omitted_generics),
         )
-        selftype = tvd
 
         def add_method(
             funcname: str,
-            ret: Type,
+            ret: Type | None,  # None means use (patched) self-type
             args: list[Argument],
             is_classmethod: bool = False,
             is_new: bool = False,
         ) -> None:
+            fullname = f"{info.fullname}.{funcname}"
+            self_type = shared_self_type.copy_modified(
+                id=TypeVarId(shared_self_type.id.raw_id, namespace=fullname)
+            )
+            if ret is None:
+                ret = self_type
             if is_classmethod or is_new:
-                first = [Argument(Var("_cls"), TypeType.make_normalized(selftype), None, ARG_POS)]
+                first = [Argument(Var("_cls"), TypeType.make_normalized(self_type), None, ARG_POS)]
             else:
-                first = [Argument(Var("_self"), selftype, None, ARG_POS)]
+                first = [Argument(Var("_self"), self_type, None, ARG_POS)]
             args = first + args
 
             types = [arg.type_annotation for arg in args]
             items = [arg.variable.name for arg in args]
             arg_kinds = [arg.kind for arg in args]
             assert None not in types
-            signature = CallableType(cast(List[Type], types), arg_kinds, items, ret, function_type)
-            signature.variables = [tvd]
+            signature = CallableType(cast(list[Type], types), arg_kinds, items, ret, function_type)
+            signature.variables = [self_type]
             func = FuncDef(funcname, args, Block([]))
             func.info = info
             func.is_class = is_classmethod
             func.type = set_callable_name(signature, func)
-            func._fullname = info.fullname + "." + funcname
+            func._fullname = fullname
             func.line = line
             if is_classmethod:
                 v = Var(funcname, func.type)
@@ -594,27 +629,28 @@ def add_method(
 
         add_method(
             "_replace",
-            ret=selftype,
+            ret=None,
             args=[Argument(var, var.type, EllipsisExpr(), ARG_NAMED_OPT) for var in vars],
         )
+        if self.options.python_version >= (3, 13):
+            add_method(
+                "__replace__",
+                ret=None,
+                args=[Argument(var, var.type, EllipsisExpr(), ARG_NAMED_OPT) for var in vars],
+            )
 
         def make_init_arg(var: Var) -> Argument:
             default = default_items.get(var.name, None)
             kind = ARG_POS if default is None else ARG_OPT
             return Argument(var, var.type, default, kind)
 
-        add_method("__new__", ret=selftype, args=[make_init_arg(var) for var in vars], is_new=True)
+        add_method("__new__", ret=None, 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,
+            ret=None,
             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(
@@ -669,5 +705,17 @@ def save_namedtuple_body(self, named_tuple_info: TypeInfo) -> Iterator[None]:
 
     # Helpers
 
-    def fail(self, msg: str, ctx: Context) -> None:
-        self.api.fail(msg, ctx)
+    def check_namedtuple_field_name(self, field: str, seen_names: Container[str]) -> str | None:
+        """Return None for valid fields, a string description for invalid ones."""
+        if field in seen_names:
+            return f'has duplicate field name "{field}"'
+        elif not field.isidentifier():
+            return f'field name "{field}" is not a valid identifier'
+        elif field.startswith("_"):
+            return f'field name "{field}" starts with an underscore'
+        elif keyword.iskeyword(field):
+            return f'field name "{field}" is a keyword'
+        return None
+
+    def fail(self, msg: str, ctx: Context, code: ErrorCode | None = None) -> None:
+        self.api.fail(msg, ctx, code=code)
diff --git a/mypy/semanal_newtype.py b/mypy/semanal_newtype.py
index a8380309d310..0c717b5d9a0e 100644
--- a/mypy/semanal_newtype.py
+++ b/mypy/semanal_newtype.py
@@ -147,7 +147,7 @@ def analyze_newtype_declaration(self, s: AssignmentStmt) -> tuple[str | None, Ca
             and isinstance(s.lvalues[0], NameExpr)
             and isinstance(s.rvalue, CallExpr)
             and isinstance(s.rvalue.callee, RefExpr)
-            and s.rvalue.callee.fullname == "typing.NewType"
+            and (s.rvalue.callee.fullname in ("typing.NewType", "typing_extensions.NewType"))
         ):
             name = s.lvalues[0].name
 
@@ -174,7 +174,7 @@ def analyze_newtype_declaration(self, s: AssignmentStmt) -> tuple[str | None, Ca
     def check_newtype_args(
         self, name: str, call: CallExpr, context: Context
     ) -> tuple[Type | None, bool]:
-        """Ananlyze base type in NewType call.
+        """Analyze base type in NewType call.
 
         Return a tuple (type, should defer).
         """
@@ -207,8 +207,7 @@ def check_newtype_args(
             self.api.anal_type(
                 unanalyzed_type,
                 report_invalid_types=False,
-                allow_placeholder=not self.options.disable_recursive_aliases
-                and not self.api.is_func_scope(),
+                allow_placeholder=not self.api.is_func_scope(),
             )
         )
         should_defer = False
diff --git a/mypy/semanal_pass1.py b/mypy/semanal_pass1.py
index 659f33e65ead..aaa01969217a 100644
--- a/mypy/semanal_pass1.py
+++ b/mypy/semanal_pass1.py
@@ -45,10 +45,9 @@ class SemanticAnalyzerPreAnalysis(TraverserVisitor):
 
       import sys
 
-      def do_stuff():
-          # type: () -> None:
-          if sys.python_version < (3,):
-              import xyz  # Only available in Python 2
+      def do_stuff() -> None:
+          if sys.version_info >= (3, 10):
+              import xyz  # Only available in Python 3.10+
               xyz.whatever()
           ...
 
@@ -62,7 +61,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 +73,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 +126,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/semanal_shared.py b/mypy/semanal_shared.py
index d097e1fb08dc..bdd01ef6a6f3 100644
--- a/mypy/semanal_shared.py
+++ b/mypy/semanal_shared.py
@@ -3,12 +3,10 @@
 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, Literal, Protocol, overload
 
 from mypy_extensions import trait
 
-from mypy import join
 from mypy.errorcodes import LITERAL_REQ, ErrorCode
 from mypy.nodes import (
     CallExpr,
@@ -30,6 +28,7 @@
 from mypy.plugin import SemanticAnalyzerPluginInterface
 from mypy.tvar_scope import TypeVarLikeScope
 from mypy.type_visitor import ANY_STRATEGY, BoolTypeQuery
+from mypy.typeops import make_simplified_union
 from mypy.types import (
     TPDICT_FB_NAMES,
     AnyType,
@@ -45,6 +44,8 @@
     TypeOfAny,
     TypeVarId,
     TypeVarLikeType,
+    TypeVarTupleType,
+    UnpackType,
     get_proper_type,
 )
 
@@ -56,7 +57,7 @@
 # Priorities for ordering of patches within the "patch" phase of semantic analysis
 # (after the main pass):
 
-# Fix fallbacks (does joins)
+# Fix fallbacks (does subtype checks).
 PRIORITY_FALLBACKS: Final = 1
 
 
@@ -74,11 +75,11 @@ def lookup_qualified(
         raise NotImplementedError
 
     @abstractmethod
-    def lookup_fully_qualified(self, name: str) -> SymbolTableNode:
+    def lookup_fully_qualified(self, fullname: str, /) -> SymbolTableNode:
         raise NotImplementedError
 
     @abstractmethod
-    def lookup_fully_qualified_or_none(self, name: str) -> SymbolTableNode | None:
+    def lookup_fully_qualified_or_none(self, fullname: str, /) -> SymbolTableNode | None:
         raise NotImplementedError
 
     @abstractmethod
@@ -174,15 +175,17 @@ def accept(self, node: Node) -> None:
     @abstractmethod
     def anal_type(
         self,
-        t: Type,
+        typ: Type,
+        /,
         *,
         tvar_scope: TypeVarLikeScope | None = None,
         allow_tuple_literal: bool = False,
         allow_unbound_tvars: bool = False,
-        allow_required: bool = False,
+        allow_typed_dict_special_forms: bool = False,
         allow_placeholder: bool = False,
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
+        prohibit_special_class_field_types: str | None = None,
     ) -> Type | None:
         raise NotImplementedError
 
@@ -195,11 +198,11 @@ def basic_new_typeinfo(self, name: str, basetype_or_fallback: Instance, line: in
         raise NotImplementedError
 
     @abstractmethod
-    def schedule_patch(self, priority: int, fn: Callable[[], None]) -> None:
+    def schedule_patch(self, priority: int, patch: Callable[[], None]) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def add_symbol_table_node(self, name: str, stnode: SymbolTableNode) -> bool:
+    def add_symbol_table_node(self, name: str, symbol: SymbolTableNode) -> bool:
         """Add node to the current symbol table."""
         raise NotImplementedError
 
@@ -239,7 +242,7 @@ def parse_bool(self, expr: Expression) -> bool | None:
         raise NotImplementedError
 
     @abstractmethod
-    def qualified_name(self, n: str) -> str:
+    def qualified_name(self, name: str) -> str:
         raise NotImplementedError
 
     @property
@@ -286,18 +289,33 @@ def calculate_tuple_fallback(typ: TupleType) -> None:
     """
     fallback = typ.partial_fallback
     assert fallback.type.fullname == "builtins.tuple"
-    fallback.args = (join.join_type_list(list(typ.items)),) + fallback.args[1:]
+    items = []
+    for item in typ.items:
+        # TODO: this duplicates some logic in typeops.tuple_fallback().
+        if isinstance(item, UnpackType):
+            unpacked_type = get_proper_type(item.type)
+            if isinstance(unpacked_type, TypeVarTupleType):
+                unpacked_type = get_proper_type(unpacked_type.upper_bound)
+            if (
+                isinstance(unpacked_type, Instance)
+                and unpacked_type.type.fullname == "builtins.tuple"
+            ):
+                items.append(unpacked_type.args[0])
+            else:
+                raise NotImplementedError
+        else:
+            items.append(item)
+    fallback.args = (make_simplified_union(items),)
 
 
 class _NamedTypeCallback(Protocol):
-    def __call__(self, fully_qualified_name: str, args: list[Type] | None = None) -> Instance:
-        ...
+    def __call__(self, fullname: str, args: list[Type] | None = None) -> Instance: ...
 
 
 def paramspec_args(
     name: str,
     fullname: str,
-    id: TypeVarId | int,
+    id: TypeVarId,
     *,
     named_type_func: _NamedTypeCallback,
     line: int = -1,
@@ -320,7 +338,7 @@ def paramspec_args(
 def paramspec_kwargs(
     name: str,
     fullname: str,
-    id: TypeVarId | int,
+    id: TypeVarId,
     *,
     named_type_func: _NamedTypeCallback,
     line: int = -1,
@@ -434,9 +452,8 @@ def require_bool_literal_argument(
     api: SemanticAnalyzerInterface | SemanticAnalyzerPluginInterface,
     expression: Expression,
     name: str,
-    default: Literal[True] | Literal[False],
-) -> bool:
-    ...
+    default: Literal[True, False],
+) -> bool: ...
 
 
 @overload
@@ -445,8 +462,7 @@ def require_bool_literal_argument(
     expression: Expression,
     name: str,
     default: None = None,
-) -> bool | None:
-    ...
+) -> bool | None: ...
 
 
 def require_bool_literal_argument(
diff --git a/mypy/semanal_typeargs.py b/mypy/semanal_typeargs.py
index e188955dabbb..435abb78ca43 100644
--- a/mypy/semanal_typeargs.py
+++ b/mypy/semanal_typeargs.py
@@ -7,20 +7,21 @@
 
 from __future__ import annotations
 
-from typing import Sequence
+from typing import Callable
 
 from mypy import errorcodes as codes, message_registry
 from mypy.errorcodes import ErrorCode
 from mypy.errors import Errors
+from mypy.message_registry import INVALID_PARAM_SPEC_LOCATION, INVALID_PARAM_SPEC_LOCATION_NOTE
 from mypy.messages import format_type
 from mypy.mixedtraverser import MixedTraverserVisitor
 from mypy.nodes import Block, ClassDef, Context, FakeInfo, FuncItem, MypyFile
 from mypy.options import Options
 from mypy.scope import Scope
 from mypy.subtypes import is_same_type, is_subtype
-from mypy.typeanal import set_any_tvars
 from mypy.types import (
     AnyType,
+    CallableType,
     Instance,
     Parameters,
     ParamSpecType,
@@ -38,14 +39,22 @@
     get_proper_types,
     split_with_prefix_and_suffix,
 )
+from mypy.typevartuples import erased_vars
 
 
 class TypeArgumentAnalyzer(MixedTraverserVisitor):
-    def __init__(self, errors: Errors, options: Options, is_typeshed_file: bool) -> None:
+    def __init__(
+        self,
+        errors: Errors,
+        options: Options,
+        is_typeshed_file: bool,
+        named_type: Callable[[str, list[Type]], Instance],
+    ) -> None:
         super().__init__()
         self.errors = errors
         self.options = options
         self.is_typeshed_file = is_typeshed_file
+        self.named_type = named_type
         self.scope = Scope()
         # Should we also analyze function definitions, or only module top-levels?
         self.recurse_into_functions = True
@@ -80,56 +89,53 @@ def visit_type_alias_type(self, t: TypeAliasType) -> None:
             # types, since errors there have already been reported.
             return
         self.seen_aliases.add(t)
-        # Some recursive aliases may produce spurious args. In principle this is not very
-        # important, as we would simply ignore them when expanding, but it is better to keep
-        # correct aliases. Also, variadic aliases are better to check when fully analyzed,
-        # so we do this here.
         assert t.alias is not None, f"Unfixed type alias {t.type_ref}"
-        args = flatten_nested_tuples(t.args)
-        if t.alias.tvar_tuple_index is not None:
-            correct = len(args) >= len(t.alias.alias_tvars) - 1
-            if any(
-                isinstance(a, UnpackType) and isinstance(get_proper_type(a.type), Instance)
-                for a in args
-            ):
-                correct = True
-        else:
-            correct = len(args) == len(t.alias.alias_tvars)
-        if not correct:
-            if t.alias.tvar_tuple_index is not None:
-                exp_len = f"at least {len(t.alias.alias_tvars) - 1}"
-            else:
-                exp_len = f"{len(t.alias.alias_tvars)}"
-            self.fail(
-                f"Bad number of arguments for type alias, expected: {exp_len}, given: {len(args)}",
-                t,
-                code=codes.TYPE_ARG,
-            )
-            t.args = set_any_tvars(
-                t.alias, t.line, t.column, self.options, from_error=True, fail=self.fail
-            ).args
-        else:
-            t.args = args
-        is_error = self.validate_args(t.alias.name, t.args, t.alias.alias_tvars, t)
+        is_error, is_invalid = self.validate_args(
+            t.alias.name, tuple(t.args), t.alias.alias_tvars, t
+        )
+        if is_invalid:
+            # If there is an arity error (e.g. non-Parameters used for ParamSpec etc.),
+            # then it is safer to erase the arguments completely, to avoid crashes later.
+            # TODO: can we move this logic to typeanal.py?
+            t.args = erased_vars(t.alias.alias_tvars, TypeOfAny.from_error)
         if not is_error:
             # If there was already an error for the alias itself, there is no point in checking
             # the expansion, most likely it will result in the same kind of error.
             get_proper_type(t).accept(self)
 
+    def visit_tuple_type(self, t: TupleType) -> None:
+        t.items = flatten_nested_tuples(t.items)
+        # We could also normalize Tuple[*tuple[X, ...]] -> tuple[X, ...] like in
+        # expand_type() but we can't do this here since it is not a translator visitor,
+        # and we need to return an Instance instead of TupleType.
+        super().visit_tuple_type(t)
+
+    def visit_callable_type(self, t: CallableType) -> None:
+        super().visit_callable_type(t)
+        t.normalize_trivial_unpack()
+
     def visit_instance(self, t: Instance) -> None:
+        super().visit_instance(t)
         # Type argument counts were checked in the main semantic analyzer pass. We assume
         # that the counts are correct here.
         info = t.type
         if isinstance(info, FakeInfo):
             return  # https://github.com/python/mypy/issues/11079
-        self.validate_args(info.name, t.args, info.defn.type_vars, t)
-        super().visit_instance(t)
+        _, is_invalid = self.validate_args(info.name, t.args, info.defn.type_vars, t)
+        if is_invalid:
+            t.args = tuple(erased_vars(info.defn.type_vars, TypeOfAny.from_error))
+        if t.type.fullname == "builtins.tuple" and len(t.args) == 1:
+            # Normalize Tuple[*Tuple[X, ...], ...] -> Tuple[X, ...]
+            arg = t.args[0]
+            if isinstance(arg, UnpackType):
+                unpacked = get_proper_type(arg.type)
+                if isinstance(unpacked, Instance):
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    t.args = unpacked.args
 
     def validate_args(
-        self, name: str, args: Sequence[Type], type_vars: list[TypeVarLikeType], ctx: Context
-    ) -> bool:
-        # TODO: we need to do flatten_nested_tuples and validate arg count for instances
-        # similar to how do we do this for type aliases above, but this may have perf penalty.
+        self, name: str, args: tuple[Type, ...], type_vars: list[TypeVarLikeType], ctx: Context
+    ) -> tuple[bool, bool]:
         if any(isinstance(v, TypeVarTupleType) for v in type_vars):
             prefix = next(i for (i, v) in enumerate(type_vars) if isinstance(v, TypeVarTupleType))
             tvt = type_vars[prefix]
@@ -137,19 +143,33 @@ def validate_args(
             start, middle, end = split_with_prefix_and_suffix(
                 tuple(args), prefix, len(type_vars) - prefix - 1
             )
-            args = list(start) + [TupleType(list(middle), tvt.tuple_fallback)] + list(end)
+            args = start + (TupleType(list(middle), tvt.tuple_fallback),) + end
 
         is_error = False
+        is_invalid = False
         for (i, arg), tvar in zip(enumerate(args), type_vars):
+            context = ctx if arg.line < 0 else arg
             if isinstance(tvar, TypeVarType):
                 if isinstance(arg, ParamSpecType):
-                    # TODO: Better message
-                    is_error = True
-                    self.fail(f'Invalid location for ParamSpec "{arg.name}"', ctx)
+                    is_invalid = True
+                    self.fail(
+                        INVALID_PARAM_SPEC_LOCATION.format(format_type(arg, self.options)),
+                        context,
+                        code=codes.VALID_TYPE,
+                    )
                     self.note(
-                        "You can use ParamSpec as the first argument to Callable, e.g., "
-                        "'Callable[{}, int]'".format(arg.name),
-                        ctx,
+                        INVALID_PARAM_SPEC_LOCATION_NOTE.format(arg.name),
+                        context,
+                        code=codes.VALID_TYPE,
+                    )
+                    continue
+                if isinstance(arg, Parameters):
+                    is_invalid = True
+                    self.fail(
+                        f"Cannot use {format_type(arg, self.options)} for regular type variable,"
+                        " only for ParamSpec",
+                        context,
+                        code=codes.VALID_TYPE,
                     )
                     continue
                 if tvar.values:
@@ -163,15 +183,24 @@ def validate_args(
                             is_error = True
                             self.fail(
                                 message_registry.INVALID_TYPEVAR_AS_TYPEARG.format(arg.name, name),
-                                ctx,
+                                context,
                                 code=codes.TYPE_VAR,
                             )
                             continue
                     else:
                         arg_values = [arg]
-                    if self.check_type_var_values(name, arg_values, tvar.name, tvar.values, ctx):
+                    if self.check_type_var_values(
+                        name, arg_values, tvar.name, tvar.values, context
+                    ):
                         is_error = True
-                if not is_subtype(arg, tvar.upper_bound):
+                # Check against upper bound. Since it's object the vast majority of the time,
+                # add fast path to avoid a potentially slow subtype check.
+                upper_bound = tvar.upper_bound
+                object_upper_bound = (
+                    type(upper_bound) is Instance
+                    and upper_bound.type.fullname == "builtins.object"
+                )
+                if not object_upper_bound and not is_subtype(arg, upper_bound):
                     if self.in_type_alias_expr and isinstance(arg, TypeVarType):
                         # Type aliases are allowed to use unconstrained type variables
                         # error will be checked at substitution point.
@@ -181,42 +210,46 @@ def validate_args(
                         message_registry.INVALID_TYPEVAR_ARG_BOUND.format(
                             format_type(arg, self.options),
                             name,
-                            format_type(tvar.upper_bound, self.options),
+                            format_type(upper_bound, self.options),
                         ),
-                        ctx,
+                        context,
                         code=codes.TYPE_VAR,
                     )
             elif isinstance(tvar, ParamSpecType):
                 if not isinstance(
                     get_proper_type(arg), (ParamSpecType, Parameters, AnyType, UnboundType)
                 ):
+                    is_invalid = True
                     self.fail(
                         "Can only replace ParamSpec with a parameter types list or"
                         f" another ParamSpec, got {format_type(arg, self.options)}",
-                        ctx,
+                        context,
+                        code=codes.VALID_TYPE,
                     )
-        return is_error
+        if is_invalid:
+            is_error = True
+        return is_error, is_invalid
 
     def visit_unpack_type(self, typ: UnpackType) -> None:
+        super().visit_unpack_type(typ)
         proper_type = get_proper_type(typ.type)
         if isinstance(proper_type, TupleType):
             return
         if isinstance(proper_type, TypeVarTupleType):
             return
+        # TODO: this should probably be .has_base("builtins.tuple"), also elsewhere. This is
+        # tricky however, since this needs map_instance_to_supertype() available in many places.
         if isinstance(proper_type, Instance) and proper_type.type.fullname == "builtins.tuple":
             return
-        if (
-            isinstance(proper_type, UnboundType)
-            or isinstance(proper_type, AnyType)
-            and proper_type.type_of_any == TypeOfAny.from_error
-        ):
-            return
-
-        # TODO: Infer something when it can't be unpacked to allow rest of
-        # typechecking to work.
-        self.fail(
-            message_registry.INVALID_UNPACK.format(format_type(proper_type, self.options)), typ
-        )
+        if not isinstance(proper_type, (UnboundType, AnyType)):
+            # Avoid extra errors if there were some errors already. Also interpret plain Any
+            # as tuple[Any, ...] (this is better for the code in type checker).
+            self.fail(
+                message_registry.INVALID_UNPACK.format(format_type(proper_type, self.options)),
+                typ.type,
+                code=codes.VALID_TYPE,
+            )
+        typ.type = self.named_type("builtins.tuple", [AnyType(TypeOfAny.from_error)])
 
     def check_type_var_values(
         self, name: str, actuals: list[Type], arg_name: str, valids: list[Type], context: Context
diff --git a/mypy/semanal_typeddict.py b/mypy/semanal_typeddict.py
index 47a3f558aa13..8bf073d30f71 100644
--- a/mypy/semanal_typeddict.py
+++ b/mypy/semanal_typeddict.py
@@ -2,12 +2,14 @@
 
 from __future__ import annotations
 
-from typing_extensions import Final
+from collections.abc import Collection
+from typing import Final
 
 from mypy import errorcodes as codes, message_registry
 from mypy.errorcodes import ErrorCode
 from mypy.expandtype import expand_type
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
+from mypy.message_registry import TYPEDDICT_OVERRIDE_MERGE
 from mypy.messages import MessageBuilder
 from mypy.nodes import (
     ARG_NAMED,
@@ -28,6 +30,7 @@
     StrExpr,
     TempNode,
     TupleExpr,
+    TypeAlias,
     TypedDictExpr,
     TypeInfo,
 )
@@ -37,19 +40,22 @@
     has_placeholder,
     require_bool_literal_argument,
 )
+from mypy.state import state
 from mypy.typeanal import check_for_explicit_any, has_any_from_unimported_type
 from mypy.types import (
     TPDICT_NAMES,
     AnyType,
+    ReadOnlyType,
     RequiredType,
     Type,
     TypedDictType,
     TypeOfAny,
     TypeVarLikeType,
+    get_proper_type,
 )
 
 TPDICT_CLASS_ERROR: Final = (
-    "Invalid statement in TypedDict definition; " 'expected "field_name: field_type"'
+    'Invalid statement in TypedDict definition; expected "field_name: field_type"'
 )
 
 
@@ -78,6 +84,8 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
         """
         possible = False
         for base_expr in defn.base_type_exprs:
+            if isinstance(base_expr, CallExpr):
+                base_expr = base_expr.callee
             if isinstance(base_expr, IndexExpr):
                 base_expr = base_expr.base
             if isinstance(base_expr, RefExpr):
@@ -92,17 +100,23 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
         existing_info = None
         if isinstance(defn.analyzed, TypedDictExpr):
             existing_info = defn.analyzed.info
+
+        field_types: dict[str, Type] | None
         if (
             len(defn.base_type_exprs) == 1
             and isinstance(defn.base_type_exprs[0], RefExpr)
             and defn.base_type_exprs[0].fullname in TPDICT_NAMES
         ):
             # Building a new TypedDict
-            fields, types, statements, required_keys = self.analyze_typeddict_classdef_fields(defn)
-            if fields is None:
+            field_types, statements, required_keys, readonly_keys = (
+                self.analyze_typeddict_classdef_fields(defn)
+            )
+            if field_types is None:
                 return True, None  # Defer
+            if self.api.is_func_scope() and "@" not in defn.name:
+                defn.name += "@" + str(defn.line)
             info = self.build_typeddict_typeinfo(
-                defn.name, fields, types, required_keys, defn.line, existing_info
+                defn.name, field_types, required_keys, readonly_keys, defn.line, existing_info
             )
             defn.analyzed = TypedDictExpr(info)
             defn.analyzed.line = defn.line
@@ -114,50 +128,50 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
         typeddict_bases: list[Expression] = []
         typeddict_bases_set = set()
         for expr in defn.base_type_exprs:
-            if isinstance(expr, RefExpr) and expr.fullname in TPDICT_NAMES:
+            ok, maybe_type_info, _ = self.check_typeddict(expr, None, False)
+            if ok and maybe_type_info is not None:
+                # expr is a CallExpr
+                info = maybe_type_info
+                typeddict_bases_set.add(info.fullname)
+                typeddict_bases.append(expr)
+            elif isinstance(expr, RefExpr) and expr.fullname in TPDICT_NAMES:
                 if "TypedDict" not in typeddict_bases_set:
                     typeddict_bases_set.add("TypedDict")
                 else:
                     self.fail('Duplicate base class "TypedDict"', defn)
-            elif isinstance(expr, RefExpr) and self.is_typeddict(expr):
-                assert expr.fullname
-                if expr.fullname not in typeddict_bases_set:
-                    typeddict_bases_set.add(expr.fullname)
-                    typeddict_bases.append(expr)
-                else:
-                    assert isinstance(expr.node, TypeInfo)
-                    self.fail(f'Duplicate base class "{expr.node.name}"', defn)
-            elif isinstance(expr, IndexExpr) and self.is_typeddict(expr.base):
-                assert isinstance(expr.base, RefExpr)
-                assert expr.base.fullname
-                if expr.base.fullname not in typeddict_bases_set:
-                    typeddict_bases_set.add(expr.base.fullname)
+            elif (
+                isinstance(expr, RefExpr)
+                and self.is_typeddict(expr)
+                or isinstance(expr, IndexExpr)
+                and self.is_typeddict(expr.base)
+            ):
+                info = self._parse_typeddict_base(expr, defn)
+                if info.fullname not in typeddict_bases_set:
+                    typeddict_bases_set.add(info.fullname)
                     typeddict_bases.append(expr)
                 else:
-                    assert isinstance(expr.base.node, TypeInfo)
-                    self.fail(f'Duplicate base class "{expr.base.node.name}"', defn)
+                    self.fail(f'Duplicate base class "{info.name}"', defn)
             else:
                 self.fail("All bases of a new TypedDict must be TypedDict types", defn)
 
-        keys: list[str] = []
-        types = []
+        field_types = {}
         required_keys = set()
+        readonly_keys = set()
         # Iterate over bases in reverse order so that leftmost base class' keys take precedence
         for base in reversed(typeddict_bases):
-            self.add_keys_and_types_from_base(base, keys, types, required_keys, defn)
-        (
-            new_keys,
-            new_types,
-            new_statements,
-            new_required_keys,
-        ) = self.analyze_typeddict_classdef_fields(defn, keys)
-        if new_keys is None:
+            self.add_keys_and_types_from_base(
+                base, field_types, required_keys, readonly_keys, defn
+            )
+        (new_field_types, new_statements, new_required_keys, new_readonly_keys) = (
+            self.analyze_typeddict_classdef_fields(defn, oldfields=field_types)
+        )
+        if new_field_types is None:
             return True, None  # Defer
-        keys.extend(new_keys)
-        types.extend(new_types)
+        field_types.update(new_field_types)
         required_keys.update(new_required_keys)
+        readonly_keys.update(new_readonly_keys)
         info = self.build_typeddict_typeinfo(
-            defn.name, keys, types, required_keys, defn.line, existing_info
+            defn.name, field_types, required_keys, readonly_keys, defn.line, existing_info
         )
         defn.analyzed = TypedDictExpr(info)
         defn.analyzed.line = defn.line
@@ -168,20 +182,14 @@ def analyze_typeddict_classdef(self, defn: ClassDef) -> tuple[bool, TypeInfo | N
     def add_keys_and_types_from_base(
         self,
         base: Expression,
-        keys: list[str],
-        types: list[Type],
+        field_types: dict[str, Type],
         required_keys: set[str],
+        readonly_keys: set[str],
         ctx: Context,
     ) -> None:
-        if isinstance(base, RefExpr):
-            assert isinstance(base.node, TypeInfo)
-            info = base.node
-            base_args: list[Type] = []
-        else:
-            assert isinstance(base, IndexExpr)
-            assert isinstance(base.base, RefExpr)
-            assert isinstance(base.base.node, TypeInfo)
-            info = base.base.node
+        info = self._parse_typeddict_base(base, ctx)
+        base_args: list[Type] = []
+        if isinstance(base, IndexExpr):
             args = self.analyze_base_args(base, ctx)
             if args is None:
                 return
@@ -201,13 +209,35 @@ def add_keys_and_types_from_base(
                 any_kind = TypeOfAny.from_error
             base_args = [AnyType(any_kind) for _ in tvars]
 
-        valid_items = self.map_items_to_base(valid_items, tvars, base_args)
+        with state.strict_optional_set(self.options.strict_optional):
+            valid_items = self.map_items_to_base(valid_items, tvars, base_args)
         for key in base_items:
-            if key in keys:
-                self.fail(f'Overwriting TypedDict field "{key}" while merging', ctx)
-        keys.extend(valid_items.keys())
-        types.extend(valid_items.values())
+            if key in field_types:
+                self.fail(TYPEDDICT_OVERRIDE_MERGE.format(key), ctx)
+
+        field_types.update(valid_items)
         required_keys.update(base_typed_dict.required_keys)
+        readonly_keys.update(base_typed_dict.readonly_keys)
+
+    def _parse_typeddict_base(self, base: Expression, ctx: Context) -> TypeInfo:
+        if isinstance(base, RefExpr):
+            if isinstance(base.node, TypeInfo):
+                return base.node
+            elif isinstance(base.node, TypeAlias):
+                # Only old TypeAlias / plain assignment, PEP695 `type` stmt
+                # cannot be used as a base class
+                target = get_proper_type(base.node.target)
+                assert isinstance(target, TypedDictType)
+                return target.fallback.type
+            else:
+                assert False
+        elif isinstance(base, IndexExpr):
+            assert isinstance(base.base, RefExpr)
+            return self._parse_typeddict_base(base.base, ctx)
+        else:
+            assert isinstance(base, CallExpr)
+            assert isinstance(base.analyzed, TypedDictExpr)
+            return base.analyzed.info
 
     def analyze_base_args(self, base: IndexExpr, ctx: Context) -> list[Type] | None:
         """Analyze arguments of base type expressions as types.
@@ -229,9 +259,8 @@ def analyze_base_args(self, base: IndexExpr, ctx: Context) -> list[Type] | None:
                 return None
             analyzed = self.api.anal_type(
                 type,
-                allow_required=True,
-                allow_placeholder=not self.options.disable_recursive_aliases
-                and not self.api.is_func_scope(),
+                allow_typed_dict_special_forms=True,
+                allow_placeholder=not self.api.is_func_scope(),
             )
             if analyzed is None:
                 return None
@@ -252,29 +281,41 @@ def map_items_to_base(
             if not tvars:
                 mapped_items[key] = type_in_base
                 continue
+            # TODO: simple zip can't be used for variadic types.
             mapped_items[key] = expand_type(
                 type_in_base, {t.id: a for (t, a) in zip(tvars, base_args)}
             )
         return mapped_items
 
     def analyze_typeddict_classdef_fields(
-        self, defn: ClassDef, oldfields: list[str] | None = None
-    ) -> tuple[list[str] | None, list[Type], list[Statement], set[str]]:
+        self, defn: ClassDef, oldfields: Collection[str] | None = None
+    ) -> tuple[dict[str, Type] | None, list[Statement], set[str], set[str]]:
         """Analyze fields defined in a TypedDict class definition.
 
         This doesn't consider inherited fields (if any). Also consider totality,
         if given.
 
         Return tuple with these items:
-         * List of keys (or None if found an incomplete reference --> deferral)
-         * List of types for each key
+         * Dict of key -> type (or None if found an incomplete reference -> deferral)
          * List of statements from defn.defs.body that are legally allowed to be a
            part of a TypedDict definition
          * Set of required keys
         """
-        fields: list[str] = []
-        types: list[Type] = []
+        fields: dict[str, Type] = {}
+        readonly_keys = set[str]()
+        required_keys = set[str]()
         statements: list[Statement] = []
+
+        total: bool | None = True
+        for key in defn.keywords:
+            if key == "total":
+                total = require_bool_literal_argument(
+                    self.api, defn.keywords["total"], "total", True
+                )
+                continue
+            for_function = ' for "__init_subclass__" of "TypedDict"'
+            self.msg.unexpected_keyword_argument_for_function(for_function, key, defn)
+
         for stmt in defn.defs.body:
             if not isinstance(stmt, AssignmentStmt):
                 # Still allow pass or ... (for empty TypedDict's) and docstrings
@@ -298,41 +339,71 @@ def analyze_typeddict_classdef_fields(
                     self.fail(f'Duplicate TypedDict key "{name}"', stmt)
                     continue
                 # Append stmt, name, and type in this case...
-                fields.append(name)
                 statements.append(stmt)
-                if stmt.type is None:
-                    types.append(AnyType(TypeOfAny.unannotated))
+
+                field_type: Type
+                if stmt.unanalyzed_type is None:
+                    field_type = AnyType(TypeOfAny.unannotated)
                 else:
                     analyzed = self.api.anal_type(
-                        stmt.type,
-                        allow_required=True,
-                        allow_placeholder=not self.options.disable_recursive_aliases
-                        and not self.api.is_func_scope(),
+                        stmt.unanalyzed_type,
+                        allow_typed_dict_special_forms=True,
+                        allow_placeholder=not self.api.is_func_scope(),
                         prohibit_self_type="TypedDict item type",
+                        prohibit_special_class_field_types="TypedDict",
                     )
                     if analyzed is None:
-                        return None, [], [], set()  # Need to defer
-                    types.append(analyzed)
+                        return None, [], set(), set()  # Need to defer
+                    field_type = analyzed
+                    if not has_placeholder(analyzed):
+                        stmt.type = self.extract_meta_info(analyzed, stmt)[0]
+
+                field_type, required, readonly = self.extract_meta_info(field_type)
+                fields[name] = field_type
+
+                if (total or required is True) and required is not False:
+                    required_keys.add(name)
+                if readonly:
+                    readonly_keys.add(name)
+
                 # ...despite possible minor failures that allow further analysis.
                 if stmt.type is None or hasattr(stmt, "new_syntax") and not stmt.new_syntax:
                     self.fail(TPDICT_CLASS_ERROR, stmt)
                 elif not isinstance(stmt.rvalue, TempNode):
                     # x: int assigns rvalue to TempNode(AnyType())
                     self.fail("Right hand side values are not supported in TypedDict", stmt)
-        total: bool | None = True
-        if "total" in defn.keywords:
-            total = require_bool_literal_argument(self.api, defn.keywords["total"], "total", True)
-        required_keys = {
-            field
-            for (field, t) in zip(fields, types)
-            if (total or (isinstance(t, RequiredType) and t.required))
-            and not (isinstance(t, RequiredType) and not t.required)
-        }
-        types = [  # unwrap Required[T] to just T
-            t.item if isinstance(t, RequiredType) else t for t in types
-        ]
-
-        return fields, types, statements, required_keys
+
+        return fields, statements, required_keys, readonly_keys
+
+    def extract_meta_info(
+        self, typ: Type, context: Context | None = None
+    ) -> tuple[Type, bool | None, bool]:
+        """Unwrap all metadata types."""
+        is_required = None  # default, no modification
+        readonly = False  # by default all is mutable
+
+        seen_required = False
+        seen_readonly = False
+        while isinstance(typ, (RequiredType, ReadOnlyType)):
+            if isinstance(typ, RequiredType):
+                if context is not None and seen_required:
+                    self.fail(
+                        '"{}" type cannot be nested'.format(
+                            "Required[]" if typ.required else "NotRequired[]"
+                        ),
+                        context,
+                        code=codes.VALID_TYPE,
+                    )
+                is_required = typ.required
+                seen_required = True
+                typ = typ.item
+            if isinstance(typ, ReadOnlyType):
+                if context is not None and seen_readonly:
+                    self.fail('"ReadOnly[]" type cannot be nested', context, code=codes.VALID_TYPE)
+                readonly = True
+                seen_readonly = True
+                typ = typ.item
+        return typ, is_required, readonly
 
     def check_typeddict(
         self, node: Expression, var_name: str | None, is_func_scope: bool
@@ -365,7 +436,13 @@ def check_typeddict(
         name, items, types, total, tvar_defs, ok = res
         if not ok:
             # Error. Construct dummy return value.
-            info = self.build_typeddict_typeinfo("TypedDict", [], [], set(), call.line, None)
+            if var_name:
+                name = var_name
+                if is_func_scope:
+                    name += "@" + str(call.line)
+            else:
+                name = var_name = "TypedDict@" + str(call.line)
+            info = self.build_typeddict_typeinfo(name, {}, set(), set(), call.line, None)
         else:
             if var_name is not None and name != var_name:
                 self.fail(
@@ -384,19 +461,38 @@ def check_typeddict(
                 if (total or (isinstance(t, RequiredType) and t.required))
                 and not (isinstance(t, RequiredType) and not t.required)
             }
-            types = [  # unwrap Required[T] to just T
-                t.item if isinstance(t, RequiredType) else t for t in types
+            readonly_keys = {
+                field for (field, t) in zip(items, types) if isinstance(t, ReadOnlyType)
+            }
+            types = [  # unwrap Required[T] or ReadOnly[T] to just T
+                t.item if isinstance(t, (RequiredType, ReadOnlyType)) else t for t in types
             ]
+
+            # Perform various validations after unwrapping.
+            for t in types:
+                check_for_explicit_any(
+                    t, self.options, self.api.is_typeshed_stub_file, self.msg, context=call
+                )
+            if self.options.disallow_any_unimported:
+                for t in types:
+                    if has_any_from_unimported_type(t):
+                        self.msg.unimported_type_becomes_any("Type of a TypedDict key", t, call)
+
             existing_info = None
             if isinstance(node.analyzed, TypedDictExpr):
                 existing_info = node.analyzed.info
             info = self.build_typeddict_typeinfo(
-                name, items, types, required_keys, call.line, existing_info
+                name,
+                dict(zip(items, types)),
+                required_keys,
+                readonly_keys,
+                call.line,
+                existing_info,
             )
             info.line = node.line
-            # Store generated TypeInfo under both names, see semanal_namedtuple for more details.
-            if name != var_name or is_func_scope:
-                self.api.add_symbol_skip_local(name, info)
+        # Store generated TypeInfo under both names, see semanal_namedtuple for more details.
+        if name != var_name or is_func_scope:
+            self.api.add_symbol_skip_local(name, info)
         if var_name:
             self.api.add_symbol(var_name, info, node)
         call.analyzed = TypedDictExpr(info)
@@ -439,25 +535,16 @@ def parse_typeddict_args(
                 return "", [], [], True, [], False
         dictexpr = args[1]
         tvar_defs = self.api.get_and_bind_all_tvars([t for k, t in dictexpr.items])
-        res = self.parse_typeddict_fields_with_types(dictexpr.items, call)
+        res = self.parse_typeddict_fields_with_types(dictexpr.items)
         if res is None:
             # One of the types is not ready, defer.
             return None
         items, types, ok = res
-        for t in types:
-            check_for_explicit_any(
-                t, self.options, self.api.is_typeshed_stub_file, self.msg, context=call
-            )
-
-        if self.options.disallow_any_unimported:
-            for t in types:
-                if has_any_from_unimported_type(t):
-                    self.msg.unimported_type_becomes_any("Type of a TypedDict key", t, dictexpr)
         assert total is not None
         return args[0].value, items, types, total, tvar_defs, ok
 
     def parse_typeddict_fields_with_types(
-        self, dict_items: list[tuple[Expression | None, Expression]], context: Context
+        self, dict_items: list[tuple[Expression | None, Expression]]
     ) -> tuple[list[str], list[Type], bool] | None:
         """Parse typed dict items passed as pairs (name expression, type expression).
 
@@ -482,24 +569,14 @@ def parse_typeddict_fields_with_types(
                     field_type_expr, self.options, self.api.is_stub_file
                 )
             except TypeTranslationError:
-                if (
-                    isinstance(field_type_expr, CallExpr)
-                    and isinstance(field_type_expr.callee, RefExpr)
-                    and field_type_expr.callee.fullname in TPDICT_NAMES
-                ):
-                    self.fail_typeddict_arg(
-                        "Inline TypedDict types not supported; use assignment to define TypedDict",
-                        field_type_expr,
-                    )
-                else:
-                    self.fail_typeddict_arg("Invalid field type", field_type_expr)
+                self.fail_typeddict_arg("Use dict literal for nested TypedDict", field_type_expr)
                 return [], [], False
             analyzed = self.api.anal_type(
                 type,
-                allow_required=True,
-                allow_placeholder=not self.options.disable_recursive_aliases
-                and not self.api.is_func_scope(),
+                allow_typed_dict_special_forms=True,
+                allow_placeholder=not self.api.is_func_scope(),
                 prohibit_self_type="TypedDict item type",
+                prohibit_special_class_field_types="TypedDict",
             )
             if analyzed is None:
                 return None
@@ -515,9 +592,9 @@ def fail_typeddict_arg(
     def build_typeddict_typeinfo(
         self,
         name: str,
-        items: list[str],
-        types: list[Type],
+        item_types: dict[str, Type],
         required_keys: set[str],
+        readonly_keys: set[str],
         line: int,
         existing_info: TypeInfo | None,
     ) -> TypeInfo:
@@ -529,7 +606,7 @@ def build_typeddict_typeinfo(
         )
         assert fallback is not None
         info = existing_info or self.api.basic_new_typeinfo(name, fallback, line)
-        typeddict_type = TypedDictType(dict(zip(items, types)), required_keys, fallback)
+        typeddict_type = TypedDictType(item_types, required_keys, readonly_keys, fallback)
         if info.special_alias and has_placeholder(info.special_alias.target):
             self.api.process_placeholder(
                 None, "TypedDict item", info, force_progress=typeddict_type != info.typeddict_type
@@ -540,10 +617,11 @@ def build_typeddict_typeinfo(
     # Helpers
 
     def is_typeddict(self, expr: Expression) -> bool:
-        return (
-            isinstance(expr, RefExpr)
-            and isinstance(expr.node, TypeInfo)
+        return isinstance(expr, RefExpr) and (
+            isinstance(expr.node, TypeInfo)
             and expr.node.typeddict_type is not None
+            or isinstance(expr.node, TypeAlias)
+            and isinstance(get_proper_type(expr.node.target), TypedDictType)
         )
 
     def fail(self, msg: str, ctx: Context, *, code: ErrorCode | None = None) -> None:
diff --git a/mypy/server/astdiff.py b/mypy/server/astdiff.py
index 93f178dca35a..1b0cc218ed16 100644
--- a/mypy/server/astdiff.py
+++ b/mypy/server/astdiff.py
@@ -52,14 +52,15 @@ class level -- these are handled at attribute level (say, 'mod.Cls.method'
 
 from __future__ import annotations
 
-from typing import Sequence, Tuple, Union
+from collections.abc import Sequence
+from typing import Union
 from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.expandtype import expand_type
 from mypy.nodes import (
+    SYMBOL_FUNCBASE_TYPES,
     UNBOUND_IMPORTED,
     Decorator,
-    FuncBase,
     FuncDef,
     FuncItem,
     MypyFile,
@@ -74,6 +75,7 @@ class level -- these are handled at attribute level (say, 'mod.Cls.method'
     Var,
 )
 from mypy.semanal_shared import find_dataclass_transform_spec
+from mypy.state import state
 from mypy.types import (
     AnyType,
     CallableType,
@@ -113,10 +115,10 @@ class level -- these are handled at attribute level (say, 'mod.Cls.method'
 
 # Type snapshots are strict, they must be hashable and ordered (e.g. for Unions).
 Primitive: _TypeAlias = Union[str, float, int, bool]  # float is for Literal[3.14] support.
-SnapshotItem: _TypeAlias = Tuple[Union[Primitive, "SnapshotItem"], ...]
+SnapshotItem: _TypeAlias = tuple[Union[Primitive, "SnapshotItem"], ...]
 
 # Symbol snapshots can be more lenient.
-SymbolSnapshot: _TypeAlias = Tuple[object, ...]
+SymbolSnapshot: _TypeAlias = tuple[object, ...]
 
 
 def compare_symbol_table_snapshots(
@@ -218,7 +220,9 @@ def snapshot_symbol_table(name_prefix: str, table: SymbolTable) -> dict[str, Sym
             assert symbol.kind != UNBOUND_IMPORTED
             if node and get_prefix(node.fullname) != name_prefix:
                 # This is a cross-reference to a node defined in another module.
-                result[name] = ("CrossRef", common)
+                # Include the node kind (FuncDef, Decorator, TypeInfo, ...), so that we will
+                # reprocess when a *new* node is created instead of merging an existing one.
+                result[name] = ("CrossRef", common, type(node).__name__)
             else:
                 result[name] = snapshot_definition(node, common)
     return result
@@ -230,17 +234,22 @@ def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> Symb
     The representation is nested tuples and dicts. Only externally
     visible attributes are included.
     """
-    if isinstance(node, FuncBase):
+    if isinstance(node, SYMBOL_FUNCBASE_TYPES):
         # TODO: info
         if node.type:
-            signature = snapshot_type(node.type)
+            signature: tuple[object, ...] = snapshot_type(node.type)
         else:
             signature = snapshot_untyped_signature(node)
         impl: FuncDef | None = None
         if isinstance(node, FuncDef):
             impl = node
-        elif isinstance(node, OverloadedFuncDef) and node.impl:
+        elif node.impl:
             impl = node.impl.func if isinstance(node.impl, Decorator) else node.impl
+        setter_type = None
+        if isinstance(node, OverloadedFuncDef) and node.items:
+            first_item = node.items[0]
+            if isinstance(first_item, Decorator) and first_item.func.is_property:
+                setter_type = snapshot_optional_type(first_item.var.setter_type)
         is_trivial_body = impl.is_trivial_body if impl else False
         dataclass_transform_spec = find_dataclass_transform_spec(node)
         return (
@@ -253,6 +262,8 @@ def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> Symb
             signature,
             is_trivial_body,
             dataclass_transform_spec.serialize() if dataclass_transform_spec is not None else None,
+            node.deprecated if isinstance(node, FuncDef) else None,
+            setter_type,  # multi-part properties are stored as OverloadedFuncDef
         )
     elif isinstance(node, Var):
         return ("Var", common, snapshot_optional_type(node.type), node.is_final)
@@ -299,6 +310,7 @@ def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> Symb
             [snapshot_type(base) for base in node.bases],
             [snapshot_type(p) for p in node._promote],
             dataclass_transform_spec.serialize() if dataclass_transform_spec is not None else None,
+            node.deprecated,
         )
         prefix = node.fullname
         symbol_table = snapshot_symbol_table(prefix, node.names)
@@ -377,11 +389,20 @@ def visit_deleted_type(self, typ: DeletedType) -> SnapshotItem:
         return snapshot_simple_type(typ)
 
     def visit_instance(self, typ: Instance) -> SnapshotItem:
+        extra_attrs: SnapshotItem
+        if typ.extra_attrs:
+            extra_attrs = (
+                tuple(sorted((k, v.accept(self)) for k, v in typ.extra_attrs.attrs.items())),
+                tuple(typ.extra_attrs.immutable),
+            )
+        else:
+            extra_attrs = ()
         return (
             "Instance",
             encode_optional_str(typ.type.fullname),
             snapshot_types(typ.args),
             ("None",) if typ.last_known_value is None else snapshot_type(typ.last_known_value),
+            extra_attrs,
         )
 
     def visit_type_var(self, typ: TypeVarType) -> SnapshotItem:
@@ -456,7 +477,8 @@ def normalize_callable_variables(self, typ: CallableType) -> CallableType:
                 tv = v.copy_modified(id=tid)
             tvs.append(tv)
             tvmap[v.id] = tv
-        return expand_type(typ, tvmap).copy_modified(variables=tvs)
+        with state.strict_optional_set(True):
+            return expand_type(typ, tvmap).copy_modified(variables=tvs)
 
     def visit_tuple_type(self, typ: TupleType) -> SnapshotItem:
         return ("TupleType", snapshot_types(typ.items))
@@ -464,7 +486,8 @@ def visit_tuple_type(self, typ: TupleType) -> SnapshotItem:
     def visit_typeddict_type(self, typ: TypedDictType) -> SnapshotItem:
         items = tuple((key, snapshot_type(item_type)) for key, item_type in typ.items.items())
         required = tuple(sorted(typ.required_keys))
-        return ("TypedDictType", items, required)
+        readonly = tuple(sorted(typ.readonly_keys))
+        return ("TypedDictType", items, required, readonly)
 
     def visit_literal_type(self, typ: LiteralType) -> SnapshotItem:
         return ("LiteralType", snapshot_type(typ.fallback), typ.value)
diff --git a/mypy/server/astmerge.py b/mypy/server/astmerge.py
index 5e3759227c7b..8cd574628bb8 100644
--- a/mypy/server/astmerge.py
+++ b/mypy/server/astmerge.py
@@ -51,6 +51,7 @@
 
 from mypy.nodes import (
     MDEF,
+    SYMBOL_NODE_EXPRESSION_TYPES,
     AssertTypeExpr,
     AssignmentStmt,
     Block,
@@ -73,7 +74,6 @@
     SymbolNode,
     SymbolTable,
     TypeAlias,
-    TypeAliasExpr,
     TypedDictExpr,
     TypeInfo,
     Var,
@@ -161,7 +161,7 @@ def replacement_map_from_symbol_table(
         ):
             new_node = new[name]
             if (
-                type(new_node.node) == type(node.node)  # noqa: E721
+                type(new_node.node) == type(node.node)
                 and new_node.node
                 and node.node
                 and new_node.node.fullname == node.node.fullname
@@ -302,7 +302,7 @@ def visit_super_expr(self, node: SuperExpr) -> None:
 
     def visit_call_expr(self, node: CallExpr) -> None:
         super().visit_call_expr(node)
-        if isinstance(node.analyzed, SymbolNode):
+        if isinstance(node.analyzed, SYMBOL_NODE_EXPRESSION_TYPES):
             node.analyzed = self.fixup(node.analyzed)
 
     def visit_newtype_expr(self, node: NewTypeExpr) -> None:
@@ -326,15 +326,12 @@ def visit_enum_call_expr(self, node: EnumCallExpr) -> None:
         self.process_synthetic_type_info(node.info)
         super().visit_enum_call_expr(node)
 
-    def visit_type_alias_expr(self, node: TypeAliasExpr) -> None:
-        self.fixup_type(node.type)
-        super().visit_type_alias_expr(node)
-
     # Others
 
     def visit_var(self, node: Var) -> None:
         node.info = self.fixup(node.info)
         self.fixup_type(node.type)
+        self.fixup_type(node.setter_type)
         super().visit_var(node)
 
     def visit_type_alias(self, node: TypeAlias) -> None:
@@ -399,7 +396,7 @@ def process_synthetic_type_info(self, info: TypeInfo) -> None:
         # have bodies in the AST so we need to iterate over their symbol
         # tables separately, unlike normal classes.
         self.process_type_info(info)
-        for name, node in info.names.items():
+        for node in info.names.values():
             if node.node:
                 node.node.accept(self)
 
@@ -467,13 +464,13 @@ def visit_overloaded(self, t: Overloaded) -> None:
 
     def visit_erased_type(self, t: ErasedType) -> None:
         # This type should exist only temporarily during type inference
-        raise RuntimeError
+        raise RuntimeError("Cannot handle erased type")
 
     def visit_deleted_type(self, typ: DeletedType) -> None:
         pass
 
     def visit_partial_type(self, typ: PartialType) -> None:
-        raise RuntimeError
+        raise RuntimeError("Cannot handle partial type")
 
     def visit_tuple_type(self, typ: TupleType) -> None:
         for item in typ.items:
@@ -554,7 +551,7 @@ def fixup(self, node: SN) -> SN:
 def replace_nodes_in_symbol_table(
     symbols: SymbolTable, replacements: dict[SymbolNode, SymbolNode]
 ) -> None:
-    for name, node in symbols.items():
+    for node in symbols.values():
         if node.node:
             if node.node in replacements:
                 new = replacements[node.node]
diff --git a/mypy/server/aststrip.py b/mypy/server/aststrip.py
index 05af6a3d53a1..a70dfc30deb5 100644
--- a/mypy/server/aststrip.py
+++ b/mypy/server/aststrip.py
@@ -33,8 +33,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from contextlib import contextmanager, nullcontext
-from typing import Dict, Iterator, Tuple
 from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.nodes import (
@@ -68,7 +68,7 @@
 from mypy.types import CallableType
 from mypy.typestate import type_state
 
-SavedAttributes: _TypeAlias = Dict[Tuple[ClassDef, str], SymbolTableNode]
+SavedAttributes: _TypeAlias = dict[tuple[ClassDef, str], SymbolTableNode]
 
 
 def strip_target(
diff --git a/mypy/server/deps.py b/mypy/server/deps.py
index ed85b74f2206..b994a214f67a 100644
--- a/mypy/server/deps.py
+++ b/mypy/server/deps.py
@@ -56,7 +56,7 @@ class 'mod.Cls'. This can also refer to an attribute inherited from a
 * 'mod.Cls' represents each method in class 'mod.Cls' + the top-level of the
   module 'mod'. (To simplify the implementation, there is no location that only
   includes the body of a class without the entire surrounding module top level.)
-* Trigger '<...>' as a location is an indirect way of referring to to all
+* Trigger '<...>' as a location is an indirect way of referring to all
   locations triggered by the trigger. These indirect locations keep the
   dependency map smaller and easier to manage.
 
@@ -82,12 +82,12 @@ class 'mod.Cls'. This can also refer to an attribute inherited from a
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import List
 
 from mypy.nodes import (
     GDEF,
     LDEF,
     MDEF,
+    SYMBOL_FUNCBASE_TYPES,
     AssertTypeExpr,
     AssignmentStmt,
     AwaitExpr,
@@ -472,7 +472,7 @@ def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
                 self.add_dependency(make_trigger(class_name + ".__init__"))
                 self.add_dependency(make_trigger(class_name + ".__new__"))
             if isinstance(rvalue, IndexExpr) and isinstance(rvalue.analyzed, TypeAliasExpr):
-                self.add_type_dependencies(rvalue.analyzed.type)
+                self.add_type_dependencies(rvalue.analyzed.node.target)
             elif typ:
                 self.add_type_dependencies(typ)
         else:
@@ -502,7 +502,7 @@ def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
                 if isinstance(rvalue.callee.node, TypeInfo):
                     # use actual __init__ as a dependency source
                     init = rvalue.callee.node.get("__init__")
-                    if init and isinstance(init.node, FuncBase):
+                    if init and isinstance(init.node, SYMBOL_FUNCBASE_TYPES):
                         fname = init.node.fullname
                 else:
                     fname = rvalue.callee.fullname
@@ -947,7 +947,7 @@ def get_type_triggers(
     return typ.accept(TypeTriggersVisitor(use_logical_deps, seen_aliases))
 
 
-class TypeTriggersVisitor(TypeVisitor[List[str]]):
+class TypeTriggersVisitor(TypeVisitor[list[str]]):
     def __init__(
         self, use_logical_deps: bool, seen_aliases: set[TypeAliasType] | None = None
     ) -> None:
diff --git a/mypy/server/mergecheck.py b/mypy/server/mergecheck.py
index ef6f5b86c8f3..11e00213d05a 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
@@ -26,10 +26,11 @@ def check_consistency(o: object) -> None:
             continue
 
         fn = sym.fullname
-        # Skip None names, since they are ambiguous.
+        # Skip None and empty names, since they are ambiguous.
         # TODO: Everything should have a proper full name?
-        if fn is None:
+        if not fn:
             continue
+
         # Skip stuff that should be expected to have duplicate names
         if isinstance(sym, (Var, Decorator)):
             continue
@@ -37,7 +38,7 @@ def check_consistency(o: object) -> None:
             continue
 
         if fn not in m:
-            m[sym.fullname] = sym
+            m[fn] = sym
             continue
 
         # We have trouble and need to decide what to do about it.
diff --git a/mypy/server/objgraph.py b/mypy/server/objgraph.py
index 89a086b8a0ab..e5096d5befa3 100644
--- a/mypy/server/objgraph.py
+++ b/mypy/server/objgraph.py
@@ -4,9 +4,8 @@
 
 import types
 import weakref
-from collections.abc import Iterable
-from typing import Iterator, Mapping
-from typing_extensions import Final
+from collections.abc import Iterable, Iterator, Mapping
+from typing import Final
 
 method_descriptor_type: Final = type(object.__dir__)
 method_wrapper_type: Final = type(object().__ne__)
@@ -46,7 +45,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 +69,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/server/trigger.py b/mypy/server/trigger.py
index 5f2115739d38..97b5f89cd3ba 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 7b439eb0ab9f..9891e2417b94 100644
--- a/mypy/server/update.py
+++ b/mypy/server/update.py
@@ -118,8 +118,9 @@
 import re
 import sys
 import time
-from typing import Callable, NamedTuple, Sequence, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from collections.abc import Sequence
+from typing import Callable, Final, NamedTuple, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.build import (
     DEBUG_FINE_GRAINED,
@@ -146,11 +147,7 @@
     TypeInfo,
 )
 from mypy.options import Options
-from mypy.semanal_main import (
-    core_modules,
-    semantic_analysis_for_scc,
-    semantic_analysis_for_targets,
-)
+from mypy.semanal_main import semantic_analysis_for_scc, semantic_analysis_for_targets
 from mypy.server.astdiff import (
     SymbolSnapshot,
     compare_symbol_table_snapshots,
@@ -162,11 +159,12 @@
 from mypy.server.target import trigger_to_target
 from mypy.server.trigger import WILDCARD_TAG, make_trigger
 from mypy.typestate import type_state
-from mypy.util import module_prefix, split_target
+from mypy.util import is_stdlib_file, module_prefix, split_target
 
 MAX_ITER: Final = 1000
 
-SENSITIVE_INTERNAL_MODULES = tuple(core_modules) + ("mypy_extensions", "typing_extensions")
+# These are modules beyond stdlib that have some special meaning for mypy.
+SENSITIVE_INTERNAL_MODULES = ("mypy_extensions", "typing_extensions")
 
 
 class FineGrainedBuildManager:
@@ -406,7 +404,10 @@ def update_module(
         # builtins and friends could potentially get triggered because
         # of protocol stuff, but nothing good could possibly come from
         # actually updating them.
-        if module in SENSITIVE_INTERNAL_MODULES:
+        if (
+            is_stdlib_file(self.manager.options.abs_custom_typeshed_dir, path)
+            or module in SENSITIVE_INTERNAL_MODULES
+        ):
             return [], (module, path), None
 
         manager = self.manager
@@ -986,7 +987,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:
@@ -1059,8 +1060,7 @@ def find_symbol_tables_recursive(prefix: str, symbols: SymbolTable) -> dict[str,
 
     Returns a dictionary from full name to corresponding symbol table.
     """
-    result = {}
-    result[prefix] = symbols
+    result = {prefix: symbols}
     for name, node in symbols.items():
         if isinstance(node.node, TypeInfo) and node.node.fullname.startswith(prefix + "."):
             more = find_symbol_tables_recursive(prefix + "." + name, node.node.names)
diff --git a/mypy/sharedparse.py b/mypy/sharedparse.py
index 6f864ccce816..ef2e4f720664 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/solve.py b/mypy/solve.py
index b8304d29c1ce..57988790a727 100644
--- a/mypy/solve.py
+++ b/mypy/solve.py
@@ -3,92 +3,579 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterable, Sequence
+from typing_extensions import TypeAlias as _TypeAlias
 
-from mypy.constraints import SUPERTYPE_OF, Constraint
+from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, infer_constraints, 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.meet import meet_type_list, meet_types
 from mypy.subtypes import is_subtype
+from mypy.typeops import get_all_type_vars
 from mypy.types import (
     AnyType,
+    Instance,
+    NoneType,
+    ParamSpecType,
     ProperType,
+    TupleType,
     Type,
     TypeOfAny,
     TypeVarId,
+    TypeVarLikeType,
+    TypeVarTupleType,
+    TypeVarType,
     UninhabitedType,
     UnionType,
+    UnpackType,
     get_proper_type,
 )
 from mypy.typestate import type_state
 
+Bounds: _TypeAlias = "dict[TypeVarId, set[Type]]"
+Graph: _TypeAlias = "set[tuple[TypeVarId, TypeVarId]]"
+Solutions: _TypeAlias = "dict[TypeVarId, Type | None]"
+
 
 def solve_constraints(
-    vars: list[TypeVarId], constraints: list[Constraint], strict: bool = True
-) -> list[Type | None]:
+    original_vars: Sequence[TypeVarLikeType],
+    constraints: list[Constraint],
+    strict: bool = True,
+    allow_polymorphic: bool = False,
+    skip_unsatisfied: bool = False,
+) -> tuple[list[Type | None], list[TypeVarLikeType]]:
     """Solve type constraints.
 
-    Return the best type(s) for type variables; each type can be None if the value of the variable
-    could not be solved.
+    Return the best type(s) for type variables; each type can be None if the value of
+    the variable could not be solved.
 
     If a variable has no constraints, if strict=True then arbitrarily
-    pick NoneType as the value of the type variable.  If strict=False,
-    pick AnyType.
+    pick UninhabitedType as the value of the type variable. If strict=False, pick AnyType.
+    If allow_polymorphic=True, then use the full algorithm that can potentially return
+    free type variables in solutions (these require special care when applying). Otherwise,
+    use a simplified algorithm that just solves each type variable individually if possible.
+
+    The skip_unsatisfied flag matches the same one in applytype.apply_generic_arguments().
     """
+    vars = [tv.id for tv in original_vars]
+    if not vars:
+        return [], []
+
+    originals = {tv.id: tv for tv in original_vars}
+    extra_vars: list[TypeVarId] = []
+    # Get additional type variables from generic actuals.
+    for c in constraints:
+        extra_vars.extend([v.id for v in c.extra_tvars if v.id not in vars + extra_vars])
+        originals.update({v.id: v for v in c.extra_tvars if v.id not in originals})
+
+    if allow_polymorphic:
+        # Constraints inferred from unions require special handling in polymorphic inference.
+        constraints = skip_reverse_union_constraints(constraints)
+
     # 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 + extra_vars}
     for con in constraints:
-        cmap[con.type_var].append(con)
+        if con.type_var in vars + extra_vars:
+            cmap[con.type_var].append(con)
 
-    res: list[Type | None] = []
+    if allow_polymorphic:
+        if constraints:
+            solutions, free_vars = solve_with_dependent(
+                vars + extra_vars, constraints, vars, originals
+            )
+        else:
+            solutions = {}
+            free_vars = []
+    else:
+        solutions = {}
+        free_vars = []
+        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]
+            solution = solve_one(lowers, uppers)
+
+            # Do not leak type variables in non-polymorphic solutions.
+            if solution is None or not get_vars(
+                solution, [tv for tv in extra_vars if tv not in vars]
+            ):
+                solutions[tv] = solution
 
-    # Solve each type variable separately.
-    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)
+    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:
-                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))
+                candidate = AnyType(TypeOfAny.special_form)
+            res.append(candidate)
+
+    if not free_vars and not skip_unsatisfied:
+        # Most of the validation for solutions is done in applytype.py, but here we can
+        # quickly test solutions w.r.t. to upper bounds, and use the latter (if possible),
+        # if solutions are actually not valid (due to poor inference context).
+        res = pre_validate_solutions(res, original_vars, constraints)
+
+    return res, free_vars
+
+
+def solve_with_dependent(
+    vars: list[TypeVarId],
+    constraints: list[Constraint],
+    original_vars: list[TypeVarId],
+    originals: dict[TypeVarId, TypeVarLikeType],
+) -> tuple[Solutions, list[TypeVarLikeType]]:
+    """Solve set of constraints that may depend on each other, like T <: List[S].
+
+    The whole algorithm consists of five steps:
+      * Propagate via linear constraints and use secondary constraints to get transitive closure
+      * Find dependencies between type variables, group them in SCCs, and sort topologically
+      * Check that 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 leaves, updating bounds after each step.
+    """
+    graph, lowers, uppers = transitive_closure(vars, constraints)
+
+    dmap = compute_dependencies(vars, graph, lowers, uppers)
+    sccs = list(strongly_connected_components(set(vars), dmap))
+    if not all(check_linear(scc, lowers, uppers) for scc in sccs):
+        return {}, []
+    raw_batches = list(topsort(prepare_sccs(sccs, dmap)))
+
+    free_vars = []
+    free_solutions = {}
+    for scc in raw_batches[0]:
+        # If there are no bounds on this 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(not lowers[tv] and not uppers[tv] for tv in scc):
+            best_free = choose_free([originals[tv] for tv in scc], original_vars)
+            if best_free:
+                # TODO: failing to choose may cause leaking type variables,
+                # we need to fail gracefully instead.
+                free_vars.append(best_free.id)
+                free_solutions[best_free.id] = best_free
+
+    # Update lowers/uppers with free vars, so these can now be used
+    # as valid solutions.
+    for l, u in graph:
+        if l in free_vars:
+            lowers[u].add(free_solutions[l])
+        if u in free_vars:
+            uppers[l].add(free_solutions[u])
+
+    # 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:
+        res = solve_iteratively(flat_batch, graph, lowers, uppers)
+        solutions.update(res)
+    return solutions, [free_solutions[tv] for tv in free_vars]
+
+
+def solve_iteratively(
+    batch: list[TypeVarId], graph: Graph, lowers: Bounds, uppers: Bounds
+) -> Solutions:
+    """Solve transitive closure sequentially, updating upper/lower bounds after each step.
+
+    Transitive closure is represented as a linear graph plus lower/upper bounds for each
+    type variable, see transitive_closure() docstring for details.
+
+    We solve for type variables that appear in `batch`. If a bound is not constant (i.e. it
+    looks like T :> F[S, ...]), we substitute solutions found so far in the target F[S, ...]
+    after solving the batch.
+
+    Importantly, after solving each variable in a batch, we move it from linear graph to
+    upper/lower bounds, this way we can guarantee consistency of solutions (see comment below
+    for an example when this is important).
+    """
+    solutions = {}
+    s_batch = set(batch)
+    while s_batch:
+        for tv in sorted(s_batch, key=lambda x: x.raw_id):
+            if lowers[tv] or 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])
+        solutions[solvable_tv] = result
+        if result is None:
+            # TODO: support backtracking lower/upper bound choices and order within SCCs.
+            # (will require switching this function from iterative to recursive).
             continue
-        elif bottom is None:
-            if top:
-                candidate = top
+
+        # Update the (transitive) bounds from graph if there is a solution.
+        # This is needed to guarantee solutions will never contradict the initial
+        # constraints. For example, consider {T <: S, T <: A, S :> B} with A :> B.
+        # If we would not update the uppers/lowers from graph, we would infer T = A, S = B
+        # which is not correct.
+        for l, u in graph.copy():
+            if l == u:
+                continue
+            if l == solvable_tv:
+                lowers[u].add(result)
+                graph.remove((l, u))
+            if u == solvable_tv:
+                uppers[l].add(result)
+                graph.remove((l, u))
+
+    # We can update uppers/lowers only once after solving the whole SCC,
+    # since uppers/lowers can't depend on type variables in the SCC
+    # (and we would reject such SCC as non-linear and therefore not solvable).
+    subs = {tv: s for (tv, s) in solutions.items() if s is not None}
+    for tv in lowers:
+        lowers[tv] = {expand_type(lt, subs) for lt in lowers[tv]}
+    for tv in uppers:
+        uppers[tv] = {expand_type(ut, subs) for ut in uppers[tv]}
+    return solutions
+
+
+def solve_one(lowers: Iterable[Type], uppers: Iterable[Type]) -> 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
+
+    # Filter out previous results of failed inference, they will only spoil the current pass...
+    new_uppers = []
+    for u in uppers:
+        pu = get_proper_type(u)
+        if not isinstance(pu, UninhabitedType) or not pu.ambiguous:
+            new_uppers.append(u)
+    uppers = new_uppers
+
+    # ...unless this is the only information we have, then we just pass it on.
+    if not uppers and not lowers:
+        candidate = UninhabitedType()
+        candidate.ambiguous = True
+        return candidate
+
+    # 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:
+        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:
+                bottom = join_types(bottom, target)
+
+    for target in uppers:
+        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 choose_free(
+    scc: list[TypeVarLikeType], original_vars: list[TypeVarId]
+) -> TypeVarLikeType | None:
+    """Choose the best solution for an SCC containing only type variables.
+
+    This is needed to preserve e.g. the upper bound in a situation like this:
+        def dec(f: Callable[[T], S]) -> Callable[[T], S]: ...
+
+        @dec
+        def test(x: U) -> U: ...
+
+    where U <: A.
+    """
+
+    if len(scc) == 1:
+        # Fast path, choice is trivial.
+        return scc[0]
+
+    common_upper_bound = meet_type_list([t.upper_bound for t in scc])
+    common_upper_bound_p = get_proper_type(common_upper_bound)
+    # We include None for when strict-optional is disabled.
+    if isinstance(common_upper_bound_p, (UninhabitedType, NoneType)):
+        # This will cause to infer Never, which is better than a free TypeVar
+        # that has an upper bound Never.
+        return None
+
+    values: list[Type] = []
+    for tv in scc:
+        if isinstance(tv, TypeVarType) and tv.values:
+            if values:
+                # It is too tricky to support multiple TypeVars with values
+                # within the same SCC.
+                return None
+            values = tv.values.copy()
+
+    if values and not is_trivial_bound(common_upper_bound_p):
+        # If there are both values and upper bound present, we give up,
+        # since type variables having both are not supported.
+        return None
+
+    # For convenience with current type application machinery, we use a stable
+    # choice that prefers the original type variables (not polymorphic ones) in SCC.
+    best = min(scc, key=lambda x: (x.id not in original_vars, x.id.raw_id))
+    if isinstance(best, TypeVarType):
+        return best.copy_modified(values=values, upper_bound=common_upper_bound)
+    if is_trivial_bound(common_upper_bound_p, allow_tuple=True):
+        # TODO: support more cases for ParamSpecs/TypeVarTuples
+        return best
+    return None
+
+
+def is_trivial_bound(tp: ProperType, allow_tuple: bool = False) -> bool:
+    if isinstance(tp, Instance) and tp.type.fullname == "builtins.tuple":
+        return allow_tuple and is_trivial_bound(get_proper_type(tp.args[0]))
+    return isinstance(tp, Instance) and tp.type.fullname == "builtins.object"
+
+
+def find_linear(c: Constraint) -> tuple[bool, TypeVarId | None]:
+    """Find out if this constraint represent a linear relationship, return target id if yes."""
+    if isinstance(c.origin_type_var, TypeVarType):
+        if isinstance(c.target, TypeVarType):
+            return True, c.target.id
+    if isinstance(c.origin_type_var, ParamSpecType):
+        if isinstance(c.target, ParamSpecType) and not c.target.prefix.arg_types:
+            return True, c.target.id
+    if isinstance(c.origin_type_var, TypeVarTupleType):
+        target = get_proper_type(c.target)
+        if isinstance(target, TupleType) and len(target.items) == 1:
+            item = target.items[0]
+            if isinstance(item, UnpackType) and isinstance(item.type, TypeVarTupleType):
+                return True, item.type.id
+    return False, None
+
+
+def transitive_closure(
+    tvars: list[TypeVarId], constraints: list[Constraint]
+) -> tuple[Graph, Bounds, Bounds]:
+    """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.
+
+    The transitive closure is represented by:
+      * A set of lower and upper bounds for each type variable, where only constant and
+        non-linear terms are included in the bounds.
+      * A graph of linear constraints between type variables (represented as a set of pairs)
+    Such separation simplifies reasoning, and allows an efficient and simple incremental
+    transitive closure algorithm that we use here.
+
+    For example if we have initial constraints [T <: S, S <: U, U <: int], the transitive
+    closure is given by:
+      * {} <: T <: {int}
+      * {} <: S <: {int}
+      * {} <: U <: {int}
+      * {T <: S, S <: U, T <: U}
+    """
+    uppers: Bounds = defaultdict(set)
+    lowers: Bounds = defaultdict(set)
+    graph: Graph = {(tv, tv) for tv in tvars}
+
+    remaining = set(constraints)
+    while remaining:
+        c = remaining.pop()
+        # Note that ParamSpec constraint P <: Q may be considered linear only if Q has no prefix,
+        # for cases like P <: Concatenate[T, Q] we should consider this non-linear and put {P} and
+        # {T, Q} into separate SCCs. Similarly, Ts <: Tuple[*Us] considered linear, while
+        # Ts <: Tuple[*Us, U] is non-linear.
+        is_linear, target_id = find_linear(c)
+        if is_linear and target_id in tvars:
+            assert target_id is not None
+            if c.op == SUBTYPE_OF:
+                lower, upper = c.type_var, 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
+                lower, upper = target_id, c.type_var
+            if (lower, upper) in graph:
+                continue
+            graph |= {
+                (l, u) for l in tvars for u in tvars if (l, lower) in graph and (upper, u) in graph
+            }
+            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]
+            for lt in lowers[lower]:
+                for ut in uppers[upper]:
+                    add_secondary_constraints(remaining, lt, ut)
+        elif c.op == SUBTYPE_OF:
+            if c.target in uppers[c.type_var]:
+                continue
+            for l in tvars:
+                if (l, c.type_var) in graph:
+                    uppers[l].add(c.target)
+            for lt in lowers[c.type_var]:
+                add_secondary_constraints(remaining, lt, c.target)
         else:
-            candidate = None
-        res.append(candidate)
+            assert c.op == SUPERTYPE_OF
+            if c.target in lowers[c.type_var]:
+                continue
+            for u in tvars:
+                if (c.type_var, u) in graph:
+                    lowers[u].add(c.target)
+            for ut in uppers[c.type_var]:
+                add_secondary_constraints(remaining, c.target, ut)
+    return graph, lowers, uppers
+
+
+def add_secondary_constraints(cs: set[Constraint], lower: Type, upper: Type) -> None:
+    """Add secondary constraints inferred between lower and upper (in place)."""
+    if isinstance(get_proper_type(upper), UnionType) and isinstance(
+        get_proper_type(lower), UnionType
+    ):
+        # When both types are unions, this can lead to inferring spurious constraints,
+        # for example Union[T, int] <: S <: Union[T, int] may infer T <: int.
+        # To avoid this, just skip them for now.
+        return
+    # TODO: what if secondary constraints result in inference against polymorphic actual?
+    cs.update(set(infer_constraints(lower, upper, SUBTYPE_OF)))
+    cs.update(set(infer_constraints(upper, lower, SUPERTYPE_OF)))
 
+
+def compute_dependencies(
+    tvars: list[TypeVarId], graph: Graph, lowers: Bounds, uppers: Bounds
+) -> 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 = {}
+    for tv in tvars:
+        deps = set()
+        for lt in lowers[tv]:
+            deps |= get_vars(lt, tvars)
+        for ut in uppers[tv]:
+            deps |= get_vars(ut, tvars)
+        for other in tvars:
+            if other == tv:
+                continue
+            if (tv, other) in graph or (other, tv) in graph:
+                deps.add(other)
+        res[tv] = list(deps)
     return res
+
+
+def check_linear(scc: set[TypeVarId], lowers: Bounds, uppers: Bounds) -> 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(lt, list(scc)) for lt in lowers[tv]):
+            return False
+        if any(get_vars(ut, list(scc)) for ut in uppers[tv]):
+            return False
+    return True
+
+
+def skip_reverse_union_constraints(cs: list[Constraint]) -> list[Constraint]:
+    """Avoid ambiguities for constraints inferred from unions during polymorphic inference.
+
+    Polymorphic inference implicitly relies on assumption that a reverse of a linear constraint
+    is a linear constraint. This is however not true in presence of union types, for example
+    T :> Union[S, int] vs S <: T. Trying to solve such constraints would be detected ambiguous
+    as (T, S) form a non-linear SCC. However, simply removing the linear part results in a valid
+    solution T = Union[S, int], S = <free>. A similar scenario is when we get T <: Union[T, int],
+    such constraints carry no information, and will equally confuse linearity check.
+
+    TODO: a cleaner solution may be to avoid inferring such constraints in first place, but
+    this would require passing around a flag through all infer_constraints() calls.
+    """
+    reverse_union_cs = set()
+    for c in cs:
+        p_target = get_proper_type(c.target)
+        if isinstance(p_target, UnionType):
+            for item in p_target.items:
+                if isinstance(item, TypeVarType):
+                    if item == c.origin_type_var and c.op == SUBTYPE_OF:
+                        reverse_union_cs.add(c)
+                        continue
+                    # These two forms are semantically identical, but are different from
+                    # the point of view of Constraint.__eq__().
+                    reverse_union_cs.add(Constraint(item, neg_op(c.op), c.origin_type_var))
+                    reverse_union_cs.add(Constraint(c.origin_type_var, c.op, item))
+    return [c for c in cs if c not in reverse_union_cs]
+
+
+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_all_type_vars(target)} & set(vars)
+
+
+def pre_validate_solutions(
+    solutions: list[Type | None],
+    original_vars: Sequence[TypeVarLikeType],
+    constraints: list[Constraint],
+) -> list[Type | None]:
+    """Check is each solution satisfies the upper bound of the corresponding type variable.
+
+    If it doesn't satisfy the bound, check if bound itself satisfies all constraints, and
+    if yes, use it instead as a fallback solution.
+    """
+    new_solutions: list[Type | None] = []
+    for t, s in zip(original_vars, solutions):
+        if is_callable_protocol(t.upper_bound):
+            # This is really ad-hoc, but a proper fix would be much more complex,
+            # and otherwise this may cause crash in a relatively common scenario.
+            new_solutions.append(s)
+            continue
+        if s is not None and not is_subtype(s, t.upper_bound):
+            bound_satisfies_all = True
+            for c in constraints:
+                if c.op == SUBTYPE_OF and not is_subtype(t.upper_bound, c.target):
+                    bound_satisfies_all = False
+                    break
+                if c.op == SUPERTYPE_OF and not is_subtype(c.target, t.upper_bound):
+                    bound_satisfies_all = False
+                    break
+            if bound_satisfies_all:
+                new_solutions.append(t.upper_bound)
+                continue
+        new_solutions.append(s)
+    return new_solutions
+
+
+def is_callable_protocol(t: Type) -> bool:
+    proper_t = get_proper_type(t)
+    if isinstance(proper_t, Instance) and proper_t.type.is_protocol:
+        return "__call__" in proper_t.type.protocol_members
+    return False
diff --git a/mypy/state.py b/mypy/state.py
index 2e44a936f819..a3055bf6b208 100644
--- a/mypy/state.py
+++ b/mypy/state.py
@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator
-from typing_extensions import Final
+from typing import Final
 
 # These are global mutable state. Don't add anything here unless there's a very
 # good reason.
@@ -25,5 +25,5 @@ def strict_optional_set(self, value: bool) -> Iterator[None]:
             self.strict_optional = saved
 
 
-state: Final = StrictOptionalState(strict_optional=False)
+state: Final = StrictOptionalState(strict_optional=True)
 find_occurrences: tuple[str, str] | None = None
diff --git a/mypy/stats.py b/mypy/stats.py
index 5f4b9d4d201f..6bad400ce5d5 100644
--- a/mypy/stats.py
+++ b/mypy/stats.py
@@ -4,9 +4,9 @@
 
 import os
 from collections import Counter
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator
-from typing_extensions import Final
+from typing import Final
 
 from mypy import nodes
 from mypy.argmap import map_formals_to_actuals
@@ -204,7 +204,11 @@ def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
             # Type variable definition -- not a real assignment.
             return
         if o.type:
+            # If there is an explicit type, don't visit the l.h.s. as an expression
+            # to avoid double-counting and mishandling special forms.
             self.type(o.type)
+            o.rvalue.accept(self)
+            return
         elif self.inferred and not self.all_nodes:
             # if self.all_nodes is set, lvalues will be visited later
             for lvalue in o.lvalues:
@@ -478,11 +482,6 @@ def is_complex(t: Type) -> bool:
     return is_generic(t) or isinstance(t, (FunctionLike, TupleType, TypeVarType))
 
 
-def ensure_dir_exists(dir: str) -> None:
-    if not os.path.exists(dir):
-        os.makedirs(dir)
-
-
 def is_special_form_any(t: AnyType) -> bool:
     return get_original_any(t).type_of_any == TypeOfAny.special_form
 
diff --git a/mypy/strconv.py b/mypy/strconv.py
index c428addd43aa..3e9d37586f72 100644
--- a/mypy/strconv.py
+++ b/mypy/strconv.py
@@ -4,7 +4,8 @@
 
 import os
 import re
-from typing import TYPE_CHECKING, Any, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
 
 import mypy.nodes
 from mypy.options import Options
@@ -86,6 +87,9 @@ def func_helper(self, o: mypy.nodes.FuncItem) -> list[object]:
             elif kind == mypy.nodes.ARG_STAR2:
                 extra.append(("DictVarArg", [arg.variable]))
         a: list[Any] = []
+        if o.type_args:
+            for p in o.type_args:
+                a.append(self.type_param(p))
         if args:
             a.append(("Args", args))
         if o.type:
@@ -109,7 +113,7 @@ def visit_mypy_file(self, o: mypy.nodes.MypyFile) -> str:
         if o.path != "main":
             # Insert path. Normalize directory separators to / to unify test
             # case# output in all platforms.
-            a.insert(0, o.path.replace(os.sep, "/"))
+            a.insert(0, o.path.replace(os.getcwd() + os.sep, "").replace(os.sep, "/"))
         if o.ignored_lines:
             a.append("IgnoredLines(%s)" % ", ".join(str(line) for line in sorted(o.ignored_lines)))
         return self.dump(a, o)
@@ -187,6 +191,9 @@ def visit_class_def(self, o: mypy.nodes.ClassDef) -> str:
             a.insert(1, ("TupleType", [o.info.tuple_type]))
         if o.info and o.info.fallback_to_any:
             a.insert(1, "FallbackToAny")
+        if o.type_args:
+            for p in reversed(o.type_args):
+                a.insert(1, self.type_param(p))
         return self.dump(a, o)
 
     def visit_var(self, o: mypy.nodes.Var) -> str:
@@ -323,6 +330,30 @@ def visit_match_stmt(self, o: mypy.nodes.MatchStmt) -> str:
             a.append(("Body", o.bodies[i].body))
         return self.dump(a, o)
 
+    def visit_type_alias_stmt(self, o: mypy.nodes.TypeAliasStmt) -> str:
+        a: list[Any] = [o.name]
+        for p in o.type_args:
+            a.append(self.type_param(p))
+        a.append(o.value)
+        return self.dump(a, o)
+
+    def type_param(self, p: mypy.nodes.TypeParam) -> list[Any]:
+        a: list[Any] = []
+        if p.kind == mypy.nodes.PARAM_SPEC_KIND:
+            prefix = "**"
+        elif p.kind == mypy.nodes.TYPE_VAR_TUPLE_KIND:
+            prefix = "*"
+        else:
+            prefix = ""
+        a.append(prefix + p.name)
+        if p.upper_bound:
+            a.append(p.upper_bound)
+        if p.values:
+            a.append(("Values", p.values))
+        if p.default:
+            a.append(("Default", [p.default]))
+        return [("TypeParam", a)]
+
     # Expressions
 
     # Simple expressions
@@ -511,7 +542,7 @@ def visit_type_var_tuple_expr(self, o: mypy.nodes.TypeVarTupleExpr) -> str:
         return self.dump(a, o)
 
     def visit_type_alias_expr(self, o: mypy.nodes.TypeAliasExpr) -> str:
-        return f"TypeAliasExpr({self.stringify_type(o.type)})"
+        return f"TypeAliasExpr({self.stringify_type(o.node.target)})"
 
     def visit_namedtuple_expr(self, o: mypy.nodes.NamedTupleExpr) -> str:
         return f"NamedTupleExpr:{o.line}({o.info.name}, {self.stringify_type(o.info.tuple_type) if o.info.tuple_type is not None else None})"
diff --git a/mypy/stubdoc.py b/mypy/stubdoc.py
index 7c8751bbd6ed..617c5ecda408 100644
--- a/mypy/stubdoc.py
+++ b/mypy/stubdoc.py
@@ -8,16 +8,20 @@
 
 import contextlib
 import io
+import keyword
 import re
 import tokenize
-from typing import Any, MutableMapping, MutableSequence, NamedTuple, Sequence, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from collections.abc import MutableMapping, MutableSequence, Sequence
+from typing import Any, Final, NamedTuple
+from typing_extensions import TypeAlias as _TypeAlias
+
+import mypy.util
 
 # Type alias for signatures strings in format ('func_name', '(arg, opt_arg=False)').
-Sig: _TypeAlias = Tuple[str, str]
+Sig: _TypeAlias = tuple[str, str]
 
 
-_TYPE_RE: Final = re.compile(r"^[a-zA-Z_][\w\[\], ]*(\.[a-zA-Z_][\w\[\], ]*)*$")
+_TYPE_RE: Final = re.compile(r"^[a-zA-Z_][\w\[\], .\"\'|]*(\.[a-zA-Z_][\w\[\], ]*)*$")
 _ARG_NAME_RE: Final = re.compile(r"\**[A-Za-z_][A-Za-z0-9_]*$")
 
 
@@ -33,13 +37,25 @@ def is_valid_type(s: str) -> bool:
 class ArgSig:
     """Signature info for a single argument."""
 
-    def __init__(self, name: str, type: str | None = None, default: bool = False):
+    def __init__(
+        self,
+        name: str,
+        type: str | None = None,
+        *,
+        default: bool = False,
+        default_value: str = "...",
+    ) -> None:
         self.name = name
-        if type and not is_valid_type(type):
-            raise ValueError("Invalid type: " + type)
         self.type = type
         # Does this argument have a default value?
         self.default = default
+        self.default_value = default_value
+
+    def is_star_arg(self) -> bool:
+        return self.name.startswith("*") and not self.name.startswith("**")
+
+    def is_star_kwarg(self) -> bool:
+        return self.name.startswith("**")
 
     def __repr__(self) -> str:
         return "ArgSig(name={}, type={}, default={})".format(
@@ -52,6 +68,7 @@ def __eq__(self, other: Any) -> bool:
                 self.name == other.name
                 and self.type == other.type
                 and self.default == other.default
+                and self.default_value == other.default_value
             )
         return False
 
@@ -59,7 +76,79 @@ def __eq__(self, other: Any) -> bool:
 class FunctionSig(NamedTuple):
     name: str
     args: list[ArgSig]
-    ret_type: str
+    ret_type: str | None
+    type_args: str = ""  # TODO implement in stubgenc and remove the default
+
+    def is_special_method(self) -> bool:
+        return bool(
+            self.name.startswith("__")
+            and self.name.endswith("__")
+            and self.args
+            and self.args[0].name in ("self", "cls")
+        )
+
+    def has_catchall_args(self) -> bool:
+        """Return if this signature has catchall args: (*args, **kwargs)"""
+        if self.args and self.args[0].name in ("self", "cls"):
+            args = self.args[1:]
+        else:
+            args = self.args
+        return (
+            len(args) == 2
+            and all(a.type in (None, "object", "Any", "typing.Any") for a in args)
+            and args[0].is_star_arg()
+            and args[1].is_star_kwarg()
+        )
+
+    def is_catchall_signature(self) -> bool:
+        """Return if this signature is the catchall identity: (*args, **kwargs) -> Any"""
+        return self.has_catchall_args() and self.ret_type in (None, "Any", "typing.Any")
+
+    def format_sig(
+        self,
+        indent: str = "",
+        is_async: bool = False,
+        any_val: str | None = None,
+        docstring: str | None = None,
+    ) -> str:
+        args: list[str] = []
+        for arg in self.args:
+            arg_def = arg.name
+
+            if arg_def in keyword.kwlist:
+                arg_def = "_" + arg_def
+
+            if (
+                arg.type is None
+                and any_val is not None
+                and arg.name not in ("self", "cls")
+                and not arg.name.startswith("*")
+            ):
+                arg_type: str | None = any_val
+            else:
+                arg_type = arg.type
+            if arg_type:
+                arg_def += ": " + arg_type
+                if arg.default:
+                    arg_def += f" = {arg.default_value}"
+
+            elif arg.default:
+                arg_def += f"={arg.default_value}"
+
+            args.append(arg_def)
+
+        retfield = ""
+        ret_type = self.ret_type if self.ret_type else any_val
+        if ret_type is not None:
+            retfield = " -> " + ret_type
+
+        prefix = "async " if is_async else ""
+        sig = f"{indent}{prefix}def {self.name}{self.type_args}({', '.join(args)}){retfield}:"
+        if docstring:
+            suffix = f"\n{indent}    {mypy.util.quote_docstring(docstring)}"
+        else:
+            suffix = " ..."
+        return f"{sig}{suffix}"
 
 
 # States of the docstring parser.
@@ -86,6 +175,8 @@ def __init__(self, function_name: str) -> None:
         self.ret_type = "Any"
         self.found = False
         self.args: list[ArgSig] = []
+        self.pos_only: int | None = None
+        self.keyword_only: int | None = None
         # Valid signatures found so far.
         self.signatures: list[FunctionSig] = []
 
@@ -163,34 +254,69 @@ def add_token(self, token: tokenize.TokenInfo) -> None:
                 self.arg_type = self.accumulator
                 self.state.pop()
             elif self.state[-1] == STATE_ARGUMENT_LIST:
-                self.arg_name = self.accumulator
-                if not (
-                    token.string == ")" and self.accumulator.strip() == ""
-                ) and not _ARG_NAME_RE.match(self.arg_name):
-                    # Invalid argument name.
-                    self.reset()
-                    return
+                if self.accumulator == "*":
+                    if self.keyword_only is not None:
+                        # Error condition: cannot have * twice
+                        self.reset()
+                        return
+                    self.keyword_only = len(self.args)
+                    self.accumulator = ""
+                else:
+                    if self.accumulator.startswith("*"):
+                        self.keyword_only = len(self.args) + 1
+                    self.arg_name = self.accumulator
+                    if not (
+                        token.string == ")" and self.accumulator.strip() == ""
+                    ) and not _ARG_NAME_RE.match(self.arg_name):
+                        # Invalid argument name.
+                        self.reset()
+                        return
 
             if token.string == ")":
+                if (
+                    self.state[-1] == STATE_ARGUMENT_LIST
+                    and self.keyword_only is not None
+                    and self.keyword_only == len(self.args)
+                    and not self.arg_name
+                ):
+                    # Error condition: * must be followed by arguments
+                    self.reset()
+                    return
                 self.state.pop()
 
             # arg_name is empty when there are no args. e.g. func()
             if self.arg_name:
-                try:
+                if self.arg_type and not is_valid_type(self.arg_type):
+                    # wrong type, use Any
+                    self.args.append(
+                        ArgSig(name=self.arg_name, type=None, default=bool(self.arg_default))
+                    )
+                else:
                     self.args.append(
                         ArgSig(
                             name=self.arg_name, type=self.arg_type, default=bool(self.arg_default)
                         )
                     )
-                except ValueError:
-                    # wrong type, use Any
-                    self.args.append(
-                        ArgSig(name=self.arg_name, type=None, default=bool(self.arg_default))
-                    )
             self.arg_name = ""
             self.arg_type = None
             self.arg_default = None
             self.accumulator = ""
+        elif (
+            token.type == tokenize.OP
+            and token.string == "/"
+            and self.state[-1] == STATE_ARGUMENT_LIST
+        ):
+            if token.string == "/":
+                if self.pos_only is not None or self.keyword_only is not None or not self.args:
+                    # Error cases:
+                    # - / shows up more than once
+                    # - / shows up after *
+                    # - / shows up before any arguments
+                    self.reset()
+                    return
+                self.pos_only = len(self.args)
+                self.state.append(STATE_ARGUMENT_TYPE)
+                self.accumulator = ""
 
         elif token.type == tokenize.OP and token.string == "->" and self.state[-1] == STATE_INIT:
             self.accumulator = ""
@@ -236,11 +362,11 @@ def args_kwargs(signature: FunctionSig) -> bool:
             return has_arg("*args", signature) and has_arg("**kwargs", signature)
 
         # Move functions with (*args, **kwargs) in their signature to last place.
-        return list(sorted(self.signatures, key=lambda x: 1 if args_kwargs(x) else 0))
+        return sorted(self.signatures, key=lambda x: 1 if args_kwargs(x) else 0)
 
 
 def infer_sig_from_docstring(docstr: str | None, name: str) -> list[FunctionSig] | None:
-    """Convert function signature to list of TypedFunctionSig
+    """Convert function signature to list of FunctionSig
 
     Look for function signatures of function in docstring. Signature is a string of
     the format <function_name>(<signature>) -> <return type> or perhaps without
@@ -254,7 +380,7 @@ def infer_sig_from_docstring(docstr: str | None, name: str) -> list[FunctionSig]
         * docstr: docstring
         * name: name of function for which signatures are to be found
     """
-    if not docstr:
+    if not (isinstance(docstr, str) and docstr):
         return None
 
     state = DocStringParser(name)
@@ -294,7 +420,8 @@ def infer_ret_type_sig_from_docstring(docstr: str, name: str) -> str | None:
 
 def infer_ret_type_sig_from_anon_docstring(docstr: str) -> str | None:
     """Convert signature in form of "(self: TestClass, arg0) -> int" to their return type."""
-    return infer_ret_type_sig_from_docstring("stub" + docstr.strip(), "stub")
+    lines = ["stub" + line.strip() for line in docstr.splitlines() if line.strip().startswith("(")]
+    return infer_ret_type_sig_from_docstring("".join(lines), "stub")
 
 
 def parse_signature(sig: str) -> tuple[str, list[str], list[str]] | None:
diff --git a/mypy/stubgen.py b/mypy/stubgen.py
index ba71456af4a4..3173bfdf9f5c 100755
--- a/mypy/stubgen.py
+++ b/mypy/stubgen.py
@@ -7,7 +7,7 @@
   - or use mypy's mechanisms, if importing is prohibited
 * (optionally) semantically analysing the sources using mypy (as a single set)
 * emitting the stubs text:
-  - for Python modules: from ASTs using StubGenerator
+  - for Python modules: from ASTs using ASTStubGenerator
   - for C modules using runtime introspection and (optionally) Sphinx docs
 
 During first and third steps some problematic files can be skipped, but any
@@ -22,7 +22,7 @@
   => Generate out/urllib/parse.pyi.
 
   $ stubgen -p urllib
-  => Generate stubs for whole urlib package (recursively).
+  => Generate stubs for whole urllib package (recursively).
 
 For C modules, you can get more precise function signatures by parsing .rst (Sphinx)
 documentation for extra information. For this, use the --doc-dir option:
@@ -42,21 +42,20 @@
 from __future__ import annotations
 
 import argparse
-import glob
 import keyword
 import os
 import os.path
 import sys
 import traceback
-from collections import defaultdict
-from typing import Iterable, Mapping
-from typing_extensions import Final
+from collections.abc import Iterable, Iterator
+from typing import Final
 
 import mypy.build
 import mypy.mixedtraverser
 import mypy.parse
 import mypy.traverser
 import mypy.util
+import mypy.version
 from mypy.build import build
 from mypy.errors import CompileError, Errors
 from mypy.find_sources import InvalidSourceList, create_source_list
@@ -67,7 +66,7 @@
     SearchPaths,
     default_lib_path,
 )
-from mypy.moduleinspect import ModuleInspect
+from mypy.moduleinspect import ModuleInspect, is_pyc_only
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
@@ -81,10 +80,12 @@
     CallExpr,
     ClassDef,
     ComparisonExpr,
+    ComplexExpr,
     Decorator,
     DictExpr,
     EllipsisExpr,
     Expression,
+    ExpressionStmt,
     FloatExpr,
     FuncBase,
     FuncDef,
@@ -94,34 +95,42 @@
     ImportFrom,
     IndexExpr,
     IntExpr,
+    LambdaExpr,
     ListExpr,
     MemberExpr,
     MypyFile,
     NameExpr,
     OpExpr,
     OverloadedFuncDef,
+    SetExpr,
+    StarExpr,
     Statement,
     StrExpr,
+    TempNode,
     TupleExpr,
+    TypeAliasStmt,
     TypeInfo,
     UnaryExpr,
     Var,
 )
 from mypy.options import Options as MypyOptions
-from mypy.stubdoc import Sig, find_unique_signatures, parse_all_signatures
-from mypy.stubgenc import (
-    DocstringSignatureGenerator,
-    ExternalSignatureGenerator,
-    FallbackSignatureGenerator,
-    SignatureGenerator,
-    generate_stub_for_c_module,
-)
+from mypy.plugins.dataclasses import DATACLASS_FIELD_SPECIFIERS
+from mypy.semanal_shared import find_dataclass_transform_spec
+from mypy.sharedparse import MAGIC_METHODS_POS_ARGS_ONLY
+from mypy.stubdoc import ArgSig, FunctionSig
+from mypy.stubgenc import InspectionStubGenerator, generate_stub_for_c_module
 from mypy.stubutil import (
+    TYPING_BUILTIN_REPLACEMENTS,
+    BaseStubGenerator,
     CantImport,
+    ClassInfo,
+    FunctionContext,
     common_dir_prefix,
     fail_missing,
     find_module_path_and_all_py3,
     generate_guarded,
+    infer_method_arg_types,
+    infer_method_ret_type,
     remove_misplaced_type_comments,
     report_missing,
     walk_packages,
@@ -133,25 +142,21 @@
     has_yield_from_expression,
 )
 from mypy.types import (
+    DATACLASS_TRANSFORM_NAMES,
     OVERLOAD_NAMES,
     TPDICT_NAMES,
+    TYPE_VAR_LIKE_NAMES,
     TYPED_NAMEDTUPLE_NAMES,
     AnyType,
     CallableType,
     Instance,
-    NoneType,
     TupleType,
     Type,
-    TypeList,
-    TypeStrVisitor,
     UnboundType,
-    UnionType,
     get_proper_type,
 )
 from mypy.visitor import NodeVisitor
 
-TYPING_MODULE_NAMES: Final = ("typing", "typing_extensions")
-
 # Common ways of naming package containing vendored modules.
 VENDOR_PACKAGES: Final = ["packages", "vendor", "vendored", "_vendor", "_vendored_packages"]
 
@@ -164,32 +169,6 @@
     "/_vendored_packages/",
 ]
 
-# Special-cased names that are implicitly exported from the stub (from m import y as y).
-EXTRA_EXPORTED: Final = {
-    "pyasn1_modules.rfc2437.univ",
-    "pyasn1_modules.rfc2459.char",
-    "pyasn1_modules.rfc2459.univ",
-}
-
-# These names should be omitted from generated stubs.
-IGNORED_DUNDERS: Final = {
-    "__all__",
-    "__author__",
-    "__version__",
-    "__about__",
-    "__copyright__",
-    "__email__",
-    "__license__",
-    "__summary__",
-    "__title__",
-    "__uri__",
-    "__str__",
-    "__repr__",
-    "__getstate__",
-    "__setstate__",
-    "__slots__",
-}
-
 # These methods are expected to always return a non-trivial value.
 METHODS_WITH_RETURN_VALUE: Final = {
     "__ne__",
@@ -202,22 +181,6 @@
     "__iter__",
 }
 
-# These magic methods always return the same type.
-KNOWN_MAGIC_METHODS_RETURN_TYPES: Final = {
-    "__len__": "int",
-    "__length_hint__": "int",
-    "__init__": "None",
-    "__del__": "None",
-    "__bool__": "bool",
-    "__bytes__": "bytes",
-    "__format__": "str",
-    "__contains__": "bool",
-    "__complex__": "complex",
-    "__int__": "int",
-    "__float__": "float",
-    "__index__": "int",
-}
-
 
 class Options:
     """Represents stubgen options.
@@ -229,6 +192,7 @@ def __init__(
         self,
         pyversion: tuple[int, int],
         no_import: bool,
+        inspect: bool,
         doc_dir: str,
         search_path: list[str],
         interpreter: str,
@@ -242,10 +206,12 @@ def __init__(
         verbose: bool,
         quiet: bool,
         export_less: bool,
+        include_docstrings: bool,
     ) -> None:
         # See parse_options for descriptions of the flags.
         self.pyversion = pyversion
         self.no_import = no_import
+        self.inspect = inspect
         self.doc_dir = doc_dir
         self.search_path = search_path
         self.interpreter = interpreter
@@ -260,6 +226,7 @@ def __init__(
         self.verbose = verbose
         self.quiet = quiet
         self.export_less = export_less
+        self.include_docstrings = include_docstrings
 
 
 class StubSource:
@@ -276,6 +243,9 @@ def __init__(
         self.runtime_all = runtime_all
         self.ast: MypyFile | None = None
 
+    def __repr__(self) -> str:
+        return f"StubSource({self.source})"
+
     @property
     def module(self) -> str:
         return self.source.module
@@ -300,71 +270,13 @@ def path(self) -> str | None:
 ERROR_MARKER: Final = "<ERROR>"
 
 
-class AnnotationPrinter(TypeStrVisitor):
-    """Visitor used to print existing annotations in a file.
-
-    The main difference from TypeStrVisitor is a better treatment of
-    unbound types.
-
-    Notes:
-    * This visitor doesn't add imports necessary for annotations, this is done separately
-      by ImportTracker.
-    * It can print all kinds of types, but the generated strings may not be valid (notably
-      callable types) since it prints the same string that reveal_type() does.
-    * For Instance types it prints the fully qualified names.
-    """
-
-    # TODO: Generate valid string representation for callable types.
-    # TODO: Use short names for Instances.
-    def __init__(self, stubgen: StubGenerator) -> None:
-        super().__init__(options=mypy.options.Options())
-        self.stubgen = stubgen
-
-    def visit_any(self, t: AnyType) -> str:
-        s = super().visit_any(t)
-        self.stubgen.import_tracker.require_name(s)
-        return s
-
-    def visit_unbound_type(self, t: UnboundType) -> str:
-        s = t.name
-        self.stubgen.import_tracker.require_name(s)
-        if t.args:
-            s += f"[{self.args_str(t.args)}]"
-        return s
-
-    def visit_none_type(self, t: NoneType) -> str:
-        return "None"
-
-    def visit_type_list(self, t: TypeList) -> str:
-        return f"[{self.list_str(t.items)}]"
-
-    def visit_union_type(self, t: UnionType) -> str:
-        return " | ".join([item.accept(self) for item in t.items])
-
-    def args_str(self, args: Iterable[Type]) -> str:
-        """Convert an array of arguments to strings and join the results with commas.
-
-        The main difference from list_str is the preservation of quotes for string
-        arguments
-        """
-        types = ["builtins.bytes", "builtins.str"]
-        res = []
-        for arg in args:
-            arg_str = arg.accept(self)
-            if isinstance(arg, UnboundType) and arg.original_str_fallback in types:
-                res.append(f"'{arg_str}'")
-            else:
-                res.append(arg_str)
-        return ", ".join(res)
-
-
 class AliasPrinter(NodeVisitor[str]):
     """Visitor used to collect type aliases _and_ type variable definitions.
 
     Visit r.h.s of the definition to get the string representation of type alias.
     """
 
-    def __init__(self, stubgen: StubGenerator) -> None:
+    def __init__(self, stubgen: ASTStubGenerator) -> None:
         self.stubgen = stubgen
         super().__init__()
 
@@ -386,33 +298,59 @@ def visit_call_expr(self, node: CallExpr) -> str:
                 raise ValueError(f"Unknown argument kind {kind} in call")
         return f"{callee}({', '.join(args)})"
 
+    def _visit_ref_expr(self, node: NameExpr | MemberExpr) -> str:
+        fullname = self.stubgen.get_fullname(node)
+        if fullname in TYPING_BUILTIN_REPLACEMENTS:
+            return self.stubgen.add_name(TYPING_BUILTIN_REPLACEMENTS[fullname], require=False)
+        qualname = get_qualified_name(node)
+        self.stubgen.import_tracker.require_name(qualname)
+        return qualname
+
     def visit_name_expr(self, node: NameExpr) -> str:
-        self.stubgen.import_tracker.require_name(node.name)
-        return node.name
+        return self._visit_ref_expr(node)
 
     def visit_member_expr(self, o: MemberExpr) -> str:
-        node: Expression = o
-        trailer = ""
-        while isinstance(node, MemberExpr):
-            trailer = "." + node.name + trailer
-            node = node.expr
-        if not isinstance(node, NameExpr):
-            return ERROR_MARKER
-        self.stubgen.import_tracker.require_name(node.name)
-        return node.name + trailer
+        return self._visit_ref_expr(o)
 
-    def visit_str_expr(self, node: StrExpr) -> str:
+    def _visit_literal_node(
+        self, node: StrExpr | BytesExpr | IntExpr | FloatExpr | ComplexExpr
+    ) -> str:
         return repr(node.value)
 
+    def visit_str_expr(self, node: StrExpr) -> str:
+        return self._visit_literal_node(node)
+
+    def visit_bytes_expr(self, node: BytesExpr) -> str:
+        return f"b{self._visit_literal_node(node)}"
+
+    def visit_int_expr(self, node: IntExpr) -> str:
+        return self._visit_literal_node(node)
+
+    def visit_float_expr(self, node: FloatExpr) -> str:
+        return self._visit_literal_node(node)
+
+    def visit_complex_expr(self, node: ComplexExpr) -> str:
+        return self._visit_literal_node(node)
+
     def visit_index_expr(self, node: IndexExpr) -> str:
+        base_fullname = self.stubgen.get_fullname(node.base)
+        if base_fullname == "typing.Union":
+            if isinstance(node.index, TupleExpr):
+                return " | ".join([item.accept(self) for item in node.index.items])
+            return node.index.accept(self)
+        if base_fullname == "typing.Optional":
+            if isinstance(node.index, TupleExpr):
+                return self.stubgen.add_name("_typeshed.Incomplete")
+            return f"{node.index.accept(self)} | None"
         base = node.base.accept(self)
         index = node.index.accept(self)
         if len(index) > 2 and index.startswith("(") and index.endswith(")"):
-            index = index[1:-1]
+            index = index[1:-1].rstrip(",")
         return f"{base}[{index}]"
 
     def visit_tuple_expr(self, node: TupleExpr) -> str:
-        return f"({', '.join(n.accept(self) for n in node.items)})"
+        suffix = "," if len(node.items) == 1 else ""
+        return f"({', '.join(n.accept(self) for n in node.items)}{suffix})"
 
     def visit_list_expr(self, node: ListExpr) -> str:
         return f"[{', '.join(n.accept(self) for n in node.items)}]"
@@ -431,118 +369,12 @@ def visit_ellipsis(self, node: EllipsisExpr) -> str:
     def visit_op_expr(self, o: OpExpr) -> str:
         return f"{o.left.accept(self)} {o.op} {o.right.accept(self)}"
 
+    def visit_star_expr(self, o: StarExpr) -> str:
+        return f"*{o.expr.accept(self)}"
 
-class ImportTracker:
-    """Record necessary imports during stub generation."""
-
-    def __init__(self) -> None:
-        # module_for['foo'] has the module name where 'foo' was imported from, or None if
-        # 'foo' is a module imported directly; examples
-        #     'from pkg.m import f as foo' ==> module_for['foo'] == 'pkg.m'
-        #     'from m import f' ==> module_for['f'] == 'm'
-        #     'import m' ==> module_for['m'] == None
-        #     'import pkg.m' ==> module_for['pkg.m'] == None
-        #                    ==> module_for['pkg'] == None
-        self.module_for: dict[str, str | None] = {}
-
-        # direct_imports['foo'] is the module path used when the name 'foo' was added to the
-        # namespace.
-        #   import foo.bar.baz  ==> direct_imports['foo'] == 'foo.bar.baz'
-        #                       ==> direct_imports['foo.bar'] == 'foo.bar.baz'
-        #                       ==> direct_imports['foo.bar.baz'] == 'foo.bar.baz'
-        self.direct_imports: dict[str, str] = {}
-
-        # reverse_alias['foo'] is the name that 'foo' had originally when imported with an
-        # alias; examples
-        #     'import numpy as np' ==> reverse_alias['np'] == 'numpy'
-        #     'import foo.bar as bar' ==> reverse_alias['bar'] == 'foo.bar'
-        #     'from decimal import Decimal as D' ==> reverse_alias['D'] == 'Decimal'
-        self.reverse_alias: dict[str, str] = {}
-
-        # required_names is the set of names that are actually used in a type annotation
-        self.required_names: set[str] = set()
-
-        # Names that should be reexported if they come from another module
-        self.reexports: set[str] = set()
-
-    def add_import_from(self, module: str, names: list[tuple[str, str | None]]) -> None:
-        for name, alias in names:
-            if alias:
-                # 'from {module} import {name} as {alias}'
-                self.module_for[alias] = module
-                self.reverse_alias[alias] = name
-            else:
-                # 'from {module} import {name}'
-                self.module_for[name] = module
-                self.reverse_alias.pop(name, None)
-            self.direct_imports.pop(alias or name, None)
-
-    def add_import(self, module: str, alias: str | None = None) -> None:
-        if alias:
-            # 'import {module} as {alias}'
-            self.module_for[alias] = None
-            self.reverse_alias[alias] = module
-        else:
-            # 'import {module}'
-            name = module
-            # add module and its parent packages
-            while name:
-                self.module_for[name] = None
-                self.direct_imports[name] = module
-                self.reverse_alias.pop(name, None)
-                name = name.rpartition(".")[0]
-
-    def require_name(self, name: str) -> None:
-        self.required_names.add(name.split(".")[0])
-
-    def reexport(self, name: str) -> None:
-        """Mark a given non qualified name as needed in __all__.
-
-        This means that in case it comes from a module, it should be
-        imported with an alias even is the alias is the same as the name.
-        """
-        self.require_name(name)
-        self.reexports.add(name)
-
-    def import_lines(self) -> list[str]:
-        """The list of required import lines (as strings with python code)."""
-        result = []
-
-        # To summarize multiple names imported from a same module, we collect those
-        # in the `module_map` dictionary, mapping a module path to the list of names that should
-        # be imported from it. the names can also be alias in the form 'original as alias'
-        module_map: Mapping[str, list[str]] = defaultdict(list)
-
-        for name in sorted(self.required_names):
-            # If we haven't seen this name in an import statement, ignore it
-            if name not in self.module_for:
-                continue
-
-            m = self.module_for[name]
-            if m is not None:
-                # This name was found in a from ... import ...
-                # Collect the name in the module_map
-                if name in self.reverse_alias:
-                    name = f"{self.reverse_alias[name]} as {name}"
-                elif name in self.reexports:
-                    name = f"{name} as {name}"
-                module_map[m].append(name)
-            else:
-                # This name was found in an import ...
-                # We can already generate the import line
-                if name in self.reverse_alias:
-                    source = self.reverse_alias[name]
-                    result.append(f"import {source} as {name}\n")
-                elif name in self.reexports:
-                    assert "." not in name  # Because reexports only has nonqualified names
-                    result.append(f"import {name} as {name}\n")
-                else:
-                    result.append(f"import {self.direct_imports[name]}\n")
-
-        # Now generate all the from ... import ... lines collected in module_map
-        for module, names in sorted(module_map.items()):
-            result.append(f"from {module} import {', '.join(sorted(names))}\n")
-        return result
+    def visit_lambda_expr(self, o: LambdaExpr) -> str:
+        # TODO: Required for among other things dataclass.field default_factory
+        return self.stubgen.add_name("_typeshed.Incomplete")
 
 
 def find_defined_names(file: MypyFile) -> set[str]:
@@ -551,11 +383,17 @@ def find_defined_names(file: MypyFile) -> set[str]:
     return finder.names
 
 
+def get_assigned_names(lvalues: Iterable[Expression]) -> Iterator[str]:
+    for lvalue in lvalues:
+        if isinstance(lvalue, NameExpr):
+            yield lvalue.name
+        elif isinstance(lvalue, TupleExpr):
+            yield from get_assigned_names(lvalue.items)
+
+
 class DefinitionFinder(mypy.traverser.TraverserVisitor):
     """Find names of things defined at the top level of a module."""
 
-    # TODO: Assignment statements etc.
-
     def __init__(self) -> None:
         # Short names of things defined at the top level.
         self.names: set[str] = set()
@@ -568,6 +406,13 @@ def visit_func_def(self, o: FuncDef) -> None:
         # Don't recurse, as we only keep track of top-level definitions.
         self.names.add(o.name)
 
+    def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
+        for name in get_assigned_names(o.lvalues):
+            self.names.add(name)
+
+    def visit_type_alias_stmt(self, o: TypeAliasStmt) -> None:
+        self.names.add(o.name.name)
+
 
 def find_referenced_names(file: MypyFile) -> set[str]:
     finder = ReferenceFinder()
@@ -575,6 +420,10 @@ def find_referenced_names(file: MypyFile) -> set[str]:
     return finder.refs
 
 
+def is_none_expr(expr: Expression) -> bool:
+    return isinstance(expr, NameExpr) and expr.name == "None"
+
+
 class ReferenceFinder(mypy.mixedtraverser.MixedTraverserVisitor):
     """Find all name references (both local and global)."""
 
@@ -592,7 +441,7 @@ def visit_name_expr(self, e: NameExpr) -> None:
         self.refs.add(e.name)
 
     def visit_instance(self, t: Instance) -> None:
-        self.add_ref(t.type.fullname)
+        self.add_ref(t.type.name)
         super().visit_instance(t)
 
     def visit_unbound_type(self, t: UnboundType) -> None:
@@ -611,73 +460,49 @@ def visit_callable_type(self, t: CallableType) -> None:
         t.ret_type.accept(self)
 
     def add_ref(self, fullname: str) -> None:
-        self.refs.add(fullname.split(".")[-1])
+        self.refs.add(fullname)
+        while "." in fullname:
+            fullname = fullname.rsplit(".", 1)[0]
+            self.refs.add(fullname)
 
 
-class StubGenerator(mypy.traverser.TraverserVisitor):
+class ASTStubGenerator(BaseStubGenerator, mypy.traverser.TraverserVisitor):
     """Generate stub text from a mypy AST."""
 
     def __init__(
         self,
-        _all_: list[str] | None,
+        _all_: list[str] | None = None,
         include_private: bool = False,
         analyzed: bool = False,
         export_less: bool = False,
+        include_docstrings: bool = False,
     ) -> None:
-        # Best known value of __all__.
-        self._all_ = _all_
-        self._output: list[str] = []
+        super().__init__(_all_, include_private, export_less, include_docstrings)
         self._decorators: list[str] = []
-        self._import_lines: list[str] = []
-        # Current indent level (indent is hardcoded to 4 spaces).
-        self._indent = ""
         # Stack of defined variables (per scope).
         self._vars: list[list[str]] = [[]]
         # What was generated previously in the stub file.
         self._state = EMPTY
-        self._toplevel_names: list[str] = []
-        self._include_private = include_private
-        self.import_tracker = ImportTracker()
+        self._class_stack: list[ClassDef] = []
         # Was the tree semantically analysed before?
         self.analyzed = analyzed
-        # Disable implicit exports of package-internal imports?
-        self.export_less = export_less
-        # Add imports that could be implicitly generated
-        self.import_tracker.add_import_from("typing", [("NamedTuple", None)])
-        # Names in __all__ are required
-        for name in _all_ or ():
-            if name not in IGNORED_DUNDERS:
-                self.import_tracker.reexport(name)
-        self.defined_names: set[str] = set()
         # Short names of methods defined in the body of the current class
         self.method_names: set[str] = set()
+        self.processing_enum = False
+        self.processing_dataclass = False
+        self.dataclass_field_specifier: tuple[str, ...] = ()
+
+    @property
+    def _current_class(self) -> ClassDef | None:
+        return self._class_stack[-1] if self._class_stack else None
 
     def visit_mypy_file(self, o: MypyFile) -> None:
-        self.module = o.fullname  # Current module being processed
+        self.module_name = o.fullname  # Current module being processed
         self.path = o.path
-        self.defined_names = find_defined_names(o)
+        self.set_defined_names(find_defined_names(o))
         self.referenced_names = find_referenced_names(o)
-        known_imports = {
-            "_typeshed": ["Incomplete"],
-            "typing": ["Any", "TypeVar", "NamedTuple"],
-            "collections.abc": ["Generator"],
-            "typing_extensions": ["TypedDict"],
-        }
-        for pkg, imports in known_imports.items():
-            for t in imports:
-                if t not in self.defined_names:
-                    alias = None
-                else:
-                    alias = "_" + t
-                self.import_tracker.add_import_from(pkg, [(t, alias)])
         super().visit_mypy_file(o)
-        undefined_names = [name for name in self._all_ or [] if name not in self._toplevel_names]
-        if undefined_names:
-            if self._state != EMPTY:
-                self.add("\n")
-            self.add("# Names in __all__ with no definition:\n")
-            for name in sorted(undefined_names):
-                self.add(f"#   {name}\n")
+        self.check_undefined_names()
 
     def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
         """@property with setters and getters, @overload chain and some others."""
@@ -699,32 +524,18 @@ def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
                 # skip the overload implementation and clear the decorator we just processed
                 self.clear_decorators()
 
-    def visit_func_def(self, o: FuncDef) -> None:
-        if (
-            self.is_private_name(o.name, o.fullname)
-            or self.is_not_in_all(o.name)
-            or (self.is_recorded_name(o.name) and not o.is_overload)
-        ):
-            self.clear_decorators()
-            return
-        if not self._indent and self._state not in (EMPTY, FUNC) and not o.is_awaitable_coroutine:
-            self.add("\n")
-        if not self.is_top_level():
-            self_inits = find_self_initializers(o)
-            for init, value in self_inits:
-                if init in self.method_names:
-                    # Can't have both an attribute and a method/property with the same name.
-                    continue
-                init_code = self.get_init(init, value)
-                if init_code:
-                    self.add(init_code)
-        # dump decorators, just before "def ..."
-        for s in self._decorators:
-            self.add(s)
-        self.clear_decorators()
-        self.add(f"{self._indent}{'async ' if o.is_coroutine else ''}def {o.name}(")
-        self.record_name(o.name)
-        args: list[str] = []
+    def get_default_function_sig(self, func_def: FuncDef, ctx: FunctionContext) -> FunctionSig:
+        args = self._get_func_args(func_def, ctx)
+        retname = self._get_func_return(func_def, ctx)
+        type_args = self.format_type_args(func_def)
+        return FunctionSig(func_def.name, args, retname, type_args)
+
+    def _get_func_args(self, o: FuncDef, ctx: FunctionContext) -> list[ArgSig]:
+        args: list[ArgSig] = []
+
+        # Ignore pos-only status of magic methods whose args names are elided by mypy at parse
+        actually_pos_only_args = o.name not in MAGIC_METHODS_POS_ARGS_ONLY
+        pos_only_marker_position = 0  # Where to insert "/", if any
         for i, arg_ in enumerate(o.arguments):
             var = arg_.variable
             kind = arg_.kind
@@ -738,80 +549,155 @@ def visit_func_def(self, o: FuncDef) -> None:
             # name their 0th argument other than self/cls
             is_self_arg = i == 0 and name == "self"
             is_cls_arg = i == 0 and name == "cls"
-            annotation = ""
+            typename: str | None = None
             if annotated_type and not is_self_arg and not is_cls_arg:
                 # Luckily, an argument explicitly annotated with "Any" has
                 # type "UnboundType" and will not match.
                 if not isinstance(get_proper_type(annotated_type), AnyType):
-                    annotation = f": {self.print_annotation(annotated_type)}"
+                    typename = self.print_annotation(annotated_type)
+
+            if actually_pos_only_args and arg_.pos_only:
+                pos_only_marker_position += 1
 
-            if kind.is_named() and not any(arg.startswith("*") for arg in args):
-                args.append("*")
+            if kind.is_named() and not any(arg.name.startswith("*") for arg in args):
+                args.append(ArgSig("*"))
 
+            default = "..."
             if arg_.initializer:
-                if not annotation:
+                if not typename:
                     typename = self.get_str_type_of_node(arg_.initializer, True, False)
-                    if typename == "":
-                        annotation = "=..."
-                    else:
-                        annotation = f": {typename} = ..."
-                else:
-                    annotation += " = ..."
-                arg = name + annotation
+                potential_default, valid = self.get_str_default_of_node(arg_.initializer)
+                if valid and len(potential_default) <= 200:
+                    default = potential_default
             elif kind == ARG_STAR:
-                arg = f"*{name}{annotation}"
+                name = f"*{name}"
             elif kind == ARG_STAR2:
-                arg = f"**{name}{annotation}"
-            else:
-                arg = name + annotation
-            args.append(arg)
-        retname = None
+                name = f"**{name}"
+
+            args.append(
+                ArgSig(name, typename, default=bool(arg_.initializer), default_value=default)
+            )
+        if pos_only_marker_position:
+            args.insert(pos_only_marker_position, ArgSig("/"))
+
+        if ctx.class_info is not None and all(
+            arg.type is None and arg.default is False for arg in args
+        ):
+            new_args = infer_method_arg_types(
+                ctx.name, ctx.class_info.self_var, [arg.name for arg in args]
+            )
+            if new_args is not None:
+                args = new_args
+
+        return args
+
+    def _get_func_return(self, o: FuncDef, ctx: FunctionContext) -> str | None:
         if o.name != "__init__" and isinstance(o.unanalyzed_type, CallableType):
             if isinstance(get_proper_type(o.unanalyzed_type.ret_type), AnyType):
                 # Luckily, a return type explicitly annotated with "Any" has
                 # type "UnboundType" and will enter the else branch.
-                retname = None  # implicit Any
+                return None  # implicit Any
             else:
-                retname = self.print_annotation(o.unanalyzed_type.ret_type)
-        elif o.abstract_status == IS_ABSTRACT or o.name in METHODS_WITH_RETURN_VALUE:
+                return self.print_annotation(o.unanalyzed_type.ret_type)
+        if o.abstract_status == IS_ABSTRACT or o.name in METHODS_WITH_RETURN_VALUE:
             # Always assume abstract methods return Any unless explicitly annotated. Also
             # some dunder methods should not have a None return type.
-            retname = None  # implicit Any
-        elif o.name in KNOWN_MAGIC_METHODS_RETURN_TYPES:
-            retname = KNOWN_MAGIC_METHODS_RETURN_TYPES[o.name]
-        elif has_yield_expression(o) or has_yield_from_expression(o):
-            self.add_typing_import("Generator")
+            return None  # implicit Any
+        retname = infer_method_ret_type(o.name)
+        if retname is not None:
+            return retname
+        if has_yield_expression(o) or has_yield_from_expression(o):
+            generator_name = self.add_name("collections.abc.Generator")
             yield_name = "None"
-            send_name = "None"
-            return_name = "None"
+            send_name: str | None = None
+            return_name: str | None = None
             if has_yield_from_expression(o):
-                self.add_typing_import("Incomplete")
-                yield_name = send_name = self.typing_name("Incomplete")
+                yield_name = send_name = self.add_name("_typeshed.Incomplete")
             else:
                 for expr, in_assignment in all_yield_expressions(o):
-                    if expr.expr is not None and not self.is_none_expr(expr.expr):
-                        self.add_typing_import("Incomplete")
-                        yield_name = self.typing_name("Incomplete")
+                    if expr.expr is not None and not is_none_expr(expr.expr):
+                        yield_name = self.add_name("_typeshed.Incomplete")
                     if in_assignment:
-                        self.add_typing_import("Incomplete")
-                        send_name = self.typing_name("Incomplete")
+                        send_name = self.add_name("_typeshed.Incomplete")
             if has_return_statement(o):
-                self.add_typing_import("Incomplete")
-                return_name = self.typing_name("Incomplete")
-            generator_name = self.typing_name("Generator")
-            retname = f"{generator_name}[{yield_name}, {send_name}, {return_name}]"
-        elif not has_return_statement(o) and o.abstract_status == NOT_ABSTRACT:
-            retname = "None"
-        retfield = ""
-        if retname is not None:
-            retfield = " -> " + retname
+                return_name = self.add_name("_typeshed.Incomplete")
+            if return_name is not None:
+                if send_name is None:
+                    send_name = "None"
+                return f"{generator_name}[{yield_name}, {send_name}, {return_name}]"
+            elif send_name is not None:
+                return f"{generator_name}[{yield_name}, {send_name}]"
+            else:
+                return f"{generator_name}[{yield_name}]"
+        if not has_return_statement(o) and o.abstract_status == NOT_ABSTRACT:
+            return "None"
+        return None
 
-        self.add(", ".join(args))
-        self.add(f"){retfield}: ...\n")
-        self._state = FUNC
+    def _get_func_docstring(self, node: FuncDef) -> str | None:
+        if not node.body.body:
+            return None
+        expr = node.body.body[0]
+        if isinstance(expr, ExpressionStmt) and isinstance(expr.expr, StrExpr):
+            return expr.expr.value
+        return None
 
-    def is_none_expr(self, expr: Expression) -> bool:
-        return isinstance(expr, NameExpr) and expr.name == "None"
+    def visit_func_def(self, o: FuncDef) -> None:
+        is_dataclass_generated = (
+            self.analyzed and self.processing_dataclass and o.info.names[o.name].plugin_generated
+        )
+        if is_dataclass_generated:
+            # Skip methods generated by the @dataclass decorator
+            return
+        if (
+            self.is_private_name(o.name, o.fullname)
+            or self.is_not_in_all(o.name)
+            or (self.is_recorded_name(o.name) and not o.is_overload)
+        ):
+            self.clear_decorators()
+            return
+        if self.is_top_level() and self._state not in (EMPTY, FUNC):
+            self.add("\n")
+        if not self.is_top_level():
+            self_inits = find_self_initializers(o)
+            for init, value, annotation in self_inits:
+                if init in self.method_names:
+                    # Can't have both an attribute and a method/property with the same name.
+                    continue
+                init_code = self.get_init(init, value, annotation)
+                if init_code:
+                    self.add(init_code)
+
+        if self._class_stack:
+            if len(o.arguments):
+                self_var = o.arguments[0].variable.name
+            else:
+                self_var = "self"
+            class_info: ClassInfo | None = None
+            for class_def in self._class_stack:
+                class_info = ClassInfo(class_def.name, self_var, parent=class_info)
+        else:
+            class_info = None
+
+        ctx = FunctionContext(
+            module_name=self.module_name,
+            name=o.name,
+            docstring=self._get_func_docstring(o),
+            is_abstract=o.abstract_status != NOT_ABSTRACT,
+            class_info=class_info,
+        )
+
+        self.record_name(o.name)
+
+        default_sig = self.get_default_function_sig(o, ctx)
+        sigs = self.get_signatures(default_sig, self.sig_generators, ctx)
+
+        for output in self.format_func_def(
+            sigs, is_coroutine=o.is_coroutine, decorators=self._decorators, docstring=ctx.docstring
+        ):
+            self.add(output + "\n")
+
+        self.clear_decorators()
+        self._state = FUNC
 
     def visit_decorator(self, o: Decorator) -> None:
         if self.is_private_name(o.func.name, o.func.fullname):
@@ -824,11 +710,15 @@ def process_decorator(self, o: Decorator) -> None:
 
         Only preserve certain special decorators such as @abstractmethod.
         """
+        o.func.is_overload = False
         for decorator in o.original_decorators:
-            if not isinstance(decorator, (NameExpr, MemberExpr)):
+            d = decorator
+            if isinstance(d, CallExpr):
+                d = d.callee
+            if not isinstance(d, (NameExpr, MemberExpr)):
                 continue
-            qualname = get_qualified_name(decorator)
-            fullname = self.get_fullname(decorator)
+            qualname = get_qualified_name(d)
+            fullname = self.get_fullname(d)
             if fullname in (
                 "builtins.property",
                 "builtins.staticmethod",
@@ -861,11 +751,17 @@ def process_decorator(self, o: Decorator) -> None:
             elif fullname in OVERLOAD_NAMES:
                 self.add_decorator(qualname, require_name=True)
                 o.func.is_overload = True
-            elif qualname.endswith(".setter"):
+            elif qualname.endswith((".setter", ".deleter")):
                 self.add_decorator(qualname, require_name=False)
+            elif fullname in DATACLASS_TRANSFORM_NAMES:
+                p = AliasPrinter(self)
+                self._decorators.append(f"@{decorator.accept(p)}")
+            elif isinstance(decorator, (NameExpr, MemberExpr)):
+                p = AliasPrinter(self)
+                self._decorators.append(f"@{decorator.accept(p)}")
 
     def get_fullname(self, expr: Expression) -> str:
-        """Return the full name resolving imports and import aliases."""
+        """Return the expression's full name."""
         if (
             self.analyzed
             and isinstance(expr, (NameExpr, MemberExpr))
@@ -874,29 +770,25 @@ def get_fullname(self, expr: Expression) -> str:
         ):
             return expr.fullname
         name = get_qualified_name(expr)
-        if "." not in name:
-            real_module = self.import_tracker.module_for.get(name)
-            real_short = self.import_tracker.reverse_alias.get(name, name)
-            if real_module is None and real_short not in self.defined_names:
-                real_module = "builtins"  # not imported and not defined, must be a builtin
-        else:
-            name_module, real_short = name.split(".", 1)
-            real_module = self.import_tracker.reverse_alias.get(name_module, name_module)
-        resolved_name = real_short if real_module is None else f"{real_module}.{real_short}"
-        return resolved_name
+        return self.resolve_name(name)
 
     def visit_class_def(self, o: ClassDef) -> None:
+        self._class_stack.append(o)
         self.method_names = find_method_names(o.defs.body)
         sep: int | None = None
-        if not self._indent and self._state != EMPTY:
+        if self.is_top_level() and self._state != EMPTY:
             sep = len(self._output)
             self.add("\n")
-        self.add(f"{self._indent}class {o.name}")
+        decorators = self.get_class_decorators(o)
+        for d in decorators:
+            self.add(f"{self._indent}@{d}\n")
         self.record_name(o.name)
         base_types = self.get_base_types(o)
         if base_types:
             for base in base_types:
                 self.import_tracker.require_name(base)
+        if self.analyzed and o.info.is_enum:
+            self.processing_enum = True
         if isinstance(o.metaclass, (NameExpr, MemberExpr)):
             meta = o.metaclass.accept(AliasPrinter(self))
             base_types.append("metaclass=" + meta)
@@ -904,24 +796,35 @@ def visit_class_def(self, o: ClassDef) -> None:
             base_types.append("metaclass=abc.ABCMeta")
             self.import_tracker.add_import("abc")
             self.import_tracker.require_name("abc")
-        if base_types:
-            self.add(f"({', '.join(base_types)})")
-        self.add(":\n")
+        bases = f"({', '.join(base_types)})" if base_types else ""
+        type_args = self.format_type_args(o)
+        self.add(f"{self._indent}class {o.name}{type_args}{bases}:\n")
+        self.indent()
+        if self._include_docstrings and o.docstring:
+            docstring = mypy.util.quote_docstring(o.docstring)
+            self.add(f"{self._indent}{docstring}\n")
         n = len(self._output)
-        self._indent += "    "
         self._vars.append([])
+        if self.analyzed and (spec := find_dataclass_transform_spec(o)):
+            self.processing_dataclass = True
+            self.dataclass_field_specifier = spec.field_specifiers
         super().visit_class_def(o)
-        self._indent = self._indent[:-4]
+        self.dedent()
         self._vars.pop()
         self._vars[-1].append(o.name)
         if len(self._output) == n:
             if self._state == EMPTY_CLASS and sep is not None:
                 self._output[sep] = ""
-            self._output[-1] = self._output[-1][:-1] + " ...\n"
+            if not (self._include_docstrings and o.docstring):
+                self._output[-1] = self._output[-1][:-1] + " ...\n"
             self._state = EMPTY_CLASS
         else:
             self._state = CLASS
         self.method_names = set()
+        self.processing_dataclass = False
+        self.dataclass_field_specifier = ()
+        self._class_stack.pop(-1)
+        self.processing_enum = False
 
     def get_base_types(self, cdef: ClassDef) -> list[str]:
         """Get list of base classes for a class."""
@@ -947,27 +850,55 @@ def get_base_types(self, cdef: ClassDef) -> list[str]:
                     nt_fields = self._get_namedtuple_fields(base)
                     assert isinstance(base.args[0], StrExpr)
                     typename = base.args[0].value
-                    if nt_fields is not None:
-                        fields_str = ", ".join(f"({f!r}, {t})" for f, t in nt_fields)
-                        namedtuple_name = self.typing_name("NamedTuple")
-                        base_types.append(f"{namedtuple_name}({typename!r}, [{fields_str}])")
-                        self.add_typing_import("NamedTuple")
-                    else:
+                    if nt_fields is None:
                         # Invalid namedtuple() call, cannot determine fields
-                        base_types.append(self.typing_name("Incomplete"))
+                        base_types.append(self.add_name("_typeshed.Incomplete"))
+                        continue
+                    fields_str = ", ".join(f"({f!r}, {t})" for f, t in nt_fields)
+                    namedtuple_name = self.add_name("typing.NamedTuple")
+                    base_types.append(f"{namedtuple_name}({typename!r}, [{fields_str}])")
                 elif self.is_typed_namedtuple(base):
                     base_types.append(base.accept(p))
                 else:
                     # At this point, we don't know what the base class is, so we
                     # just use Incomplete as the base class.
-                    base_types.append(self.typing_name("Incomplete"))
-                    self.add_typing_import("Incomplete")
+                    base_types.append(self.add_name("_typeshed.Incomplete"))
         for name, value in cdef.keywords.items():
             if name == "metaclass":
                 continue  # handled separately
-            base_types.append(f"{name}={value.accept(p)}")
+            processed_value = value.accept(p) or "..."  # at least, don't crash
+            base_types.append(f"{name}={processed_value}")
         return base_types
 
+    def get_class_decorators(self, cdef: ClassDef) -> list[str]:
+        decorators: list[str] = []
+        p = AliasPrinter(self)
+        for d in cdef.decorators:
+            if self.is_dataclass(d):
+                decorators.append(d.accept(p))
+                self.import_tracker.require_name(get_qualified_name(d))
+                self.processing_dataclass = True
+            if self.is_dataclass_transform(d):
+                decorators.append(d.accept(p))
+                self.import_tracker.require_name(get_qualified_name(d))
+        return decorators
+
+    def is_dataclass(self, expr: Expression) -> bool:
+        if isinstance(expr, CallExpr):
+            expr = expr.callee
+        return self.get_fullname(expr) == "dataclasses.dataclass"
+
+    def is_dataclass_transform(self, expr: Expression) -> bool:
+        if isinstance(expr, CallExpr):
+            expr = expr.callee
+        if self.get_fullname(expr) in DATACLASS_TRANSFORM_NAMES:
+            return True
+        if (spec := find_dataclass_transform_spec(expr)) is not None:
+            self.processing_dataclass = True
+            self.dataclass_field_specifier = spec.field_specifiers
+            return True
+        return False
+
     def visit_block(self, o: Block) -> None:
         # Unreachable statements may be partially uninitialized and that may
         # cause trouble.
@@ -989,13 +920,20 @@ def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
                     continue
             if (
                 isinstance(lvalue, NameExpr)
-                and not self.is_private_name(lvalue.name)
-                # it is never an alias with explicit annotation
-                and not o.unanalyzed_type
                 and self.is_alias_expression(o.rvalue)
+                and not self.is_private_name(lvalue.name)
             ):
-                self.process_typealias(lvalue, o.rvalue)
-                continue
+                is_explicit_type_alias = (
+                    o.unanalyzed_type and getattr(o.type, "name", None) == "TypeAlias"
+                )
+                if is_explicit_type_alias:
+                    self.process_typealias(lvalue, o.rvalue, is_explicit_type_alias=True)
+                    continue
+
+                if not o.unanalyzed_type:
+                    self.process_typealias(lvalue, o.rvalue)
+                    continue
+
             if isinstance(lvalue, (TupleExpr, ListExpr)):
                 items = lvalue.items
                 if isinstance(o.unanalyzed_type, TupleType):  # type: ignore[misc]
@@ -1012,7 +950,7 @@ def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
                     init = self.get_init(item.name, o.rvalue, annotation)
                     if init:
                         found = True
-                        if not sep and not self._indent and self._state not in (EMPTY, VAR):
+                        if not sep and self.is_top_level() and self._state not in (EMPTY, VAR):
                             init = "\n" + init
                             sep = True
                         self.add(init)
@@ -1042,9 +980,11 @@ def _get_namedtuple_fields(self, call: CallExpr) -> list[tuple[str, str]] | None
             else:
                 return None  # Invalid namedtuple fields type
             if field_names:
-                self.add_typing_import("Incomplete")
-            incomplete = self.typing_name("Incomplete")
-            return [(field_name, incomplete) for field_name in field_names]
+                incomplete = self.add_name("_typeshed.Incomplete")
+                return [(field_name, incomplete) for field_name in field_names]
+            else:
+                return []
+
         elif self.is_typed_namedtuple(call):
             fields_arg = call.args[1]
             if not isinstance(fields_arg, (ListExpr, TupleExpr)):
@@ -1074,8 +1014,7 @@ def process_namedtuple(self, lvalue: NameExpr, rvalue: CallExpr) -> None:
         if fields is None:
             self.annotate_as_incomplete(lvalue)
             return
-        self.add_typing_import("NamedTuple")
-        bases = self.typing_name("NamedTuple")
+        bases = self.add_name("typing.NamedTuple")
         # TODO: Add support for generic NamedTuples. Requires `Generic` as base class.
         class_def = f"{self._indent}class {lvalue.name}({bases}):"
         if len(fields) == 0:
@@ -1125,14 +1064,13 @@ def process_typeddict(self, lvalue: NameExpr, rvalue: CallExpr) -> None:
                     total = arg
                 else:
                     items.append((arg_name, arg))
-        self.add_typing_import("TypedDict")
         p = AliasPrinter(self)
         if any(not key.isidentifier() or keyword.iskeyword(key) for key, _ in items):
             # Keep the call syntax if there are non-identifier or reserved keyword keys.
             self.add(f"{self._indent}{lvalue.name} = {rvalue.accept(p)}\n")
             self._state = VAR
         else:
-            bases = self.typing_name("TypedDict")
+            bases = self.add_name("typing_extensions.TypedDict")
             # TODO: Add support for generic TypedDicts. Requires `Generic` as base class.
             if total is not None:
                 bases += f", total={total.accept(p)}"
@@ -1149,8 +1087,8 @@ def process_typeddict(self, lvalue: NameExpr, rvalue: CallExpr) -> None:
                 self._state = CLASS
 
     def annotate_as_incomplete(self, lvalue: NameExpr) -> None:
-        self.add_typing_import("Incomplete")
-        self.add(f"{self._indent}{lvalue.name}: {self.typing_name('Incomplete')}\n")
+        incomplete = self.add_name("_typeshed.Incomplete")
+        self.add(f"{self._indent}{lvalue.name}: {incomplete}\n")
         self._state = VAR
 
     def is_alias_expression(self, expr: Expression, top_level: bool = True) -> bool:
@@ -1159,11 +1097,8 @@ def is_alias_expression(self, expr: Expression, top_level: bool = True) -> bool:
         Used to know if assignments look like type aliases, function alias,
         or module alias.
         """
-        # Assignment of TypeVar(...) are passed through
-        if isinstance(expr, CallExpr) and self.get_fullname(expr.callee) in (
-            "typing.TypeVar",
-            "typing_extensions.TypeVar",
-        ):
+        # Assignment of TypeVar(...)  and other typevar-likes are passed through
+        if isinstance(expr, CallExpr) and self.get_fullname(expr.callee) in TYPE_VAR_LIKE_NAMES:
             return True
         elif isinstance(expr, EllipsisExpr):
             return not top_level
@@ -1181,10 +1116,15 @@ def is_alias_expression(self, expr: Expression, top_level: bool = True) -> bool:
                 and isinstance(expr.node, (FuncDef, Decorator, MypyFile))
                 or isinstance(expr.node, TypeInfo)
             ) and not self.is_private_member(expr.node.fullname)
-        elif (
-            isinstance(expr, IndexExpr)
-            and isinstance(expr.base, NameExpr)
-            and not self.is_private_name(expr.base.name)
+        elif isinstance(expr, IndexExpr) and (
+            (isinstance(expr.base, NameExpr) and not self.is_private_name(expr.base.name))
+            or (  # Also some known aliases that could be member expression
+                isinstance(expr.base, MemberExpr)
+                and not self.is_private_member(get_qualified_name(expr.base))
+                and self.get_fullname(expr.base).startswith(
+                    ("builtins.", "typing.", "typing_extensions.", "collections.abc.")
+                )
+            )
         ):
             if isinstance(expr.index, TupleExpr):
                 indices = expr.index.items
@@ -1199,15 +1139,35 @@ def is_alias_expression(self, expr: Expression, top_level: bool = True) -> bool:
                 else:
                     return False
             return all(self.is_alias_expression(i, top_level=False) for i in indices)
+        elif isinstance(expr, OpExpr) and expr.op == "|":
+            return self.is_alias_expression(
+                expr.left, top_level=False
+            ) and self.is_alias_expression(expr.right, top_level=False)
         else:
             return False
 
-    def process_typealias(self, lvalue: NameExpr, rvalue: Expression) -> None:
+    def process_typealias(
+        self, lvalue: NameExpr, rvalue: Expression, is_explicit_type_alias: bool = False
+    ) -> None:
         p = AliasPrinter(self)
-        self.add(f"{self._indent}{lvalue.name} = {rvalue.accept(p)}\n")
+        if is_explicit_type_alias:
+            self.import_tracker.require_name("TypeAlias")
+            self.add(f"{self._indent}{lvalue.name}: TypeAlias = {rvalue.accept(p)}\n")
+        else:
+            self.add(f"{self._indent}{lvalue.name} = {rvalue.accept(p)}\n")
         self.record_name(lvalue.name)
         self._vars[-1].append(lvalue.name)
 
+    def visit_type_alias_stmt(self, o: TypeAliasStmt) -> None:
+        """Type aliases defined with the `type` keyword (PEP 695)."""
+        p = AliasPrinter(self)
+        name = o.name.name
+        rvalue = o.value.expr()
+        type_args = self.format_type_args(o)
+        self.add(f"{self._indent}type {name}{type_args} = {rvalue.accept(p)}\n")
+        self.record_name(name)
+        self._vars[-1].append(name)
+
     def visit_if_stmt(self, o: IfStmt) -> None:
         # Ignore if __name__ == '__main__'.
         expr = o.expr[0]
@@ -1228,9 +1188,9 @@ def visit_import_from(self, o: ImportFrom) -> None:
         exported_names: set[str] = set()
         import_names = []
         module, relative = translate_module_name(o.id, o.relative)
-        if self.module:
+        if self.module_name:
             full_module, ok = mypy.util.correct_relative_import(
-                self.module, relative, module, self.path.endswith(".__init__.py")
+                self.module_name, relative, module, self.path.endswith(".__init__.py")
             )
             if not ok:
                 full_module = module
@@ -1243,35 +1203,7 @@ def visit_import_from(self, o: ImportFrom) -> None:
                 # Vendored six -- translate into plain 'import six'.
                 self.visit_import(Import([("six", None)]))
                 continue
-            exported = False
-            if as_name is None and self.module and (self.module + "." + name) in EXTRA_EXPORTED:
-                # Special case certain names that should be exported, against our general rules.
-                exported = True
-            is_private = self.is_private_name(name, full_module + "." + name)
-            if (
-                as_name is None
-                and name not in self.referenced_names
-                and (not self._all_ or name in IGNORED_DUNDERS)
-                and not is_private
-                and module not in ("abc", "asyncio") + TYPING_MODULE_NAMES
-            ):
-                # An imported name that is never referenced in the module is assumed to be
-                # exported, unless there is an explicit __all__. Note that we need to special
-                # case 'abc' since some references are deleted during semantic analysis.
-                exported = True
-            top_level = full_module.split(".")[0]
-            if (
-                as_name is None
-                and not self.export_less
-                and (not self._all_ or name in IGNORED_DUNDERS)
-                and self.module
-                and not is_private
-                and top_level in (self.module.split(".")[0], "_" + self.module.split(".")[0])
-            ):
-                # Export imports from the same package, since we can't reliably tell whether they
-                # are part of the public API.
-                exported = True
-            if exported:
+            if self.should_reexport(name, full_module, as_name is not None):
                 self.import_tracker.reexport(name)
                 as_name = name
             import_names.append((name, as_name))
@@ -1285,7 +1217,7 @@ def visit_import_from(self, o: ImportFrom) -> None:
             names = [
                 name
                 for name, alias in o.names
-                if name in self._all_ and alias is None and name not in IGNORED_DUNDERS
+                if name in self._all_ and alias is None and name not in self.IGNORED_DUNDERS
             ]
             exported_names.update(names)
 
@@ -1319,73 +1251,56 @@ def get_init(
                 isinstance(annotation, UnboundType)
                 and not annotation.args
                 and annotation.name == "Final"
-                and self.import_tracker.module_for.get("Final") in TYPING_MODULE_NAMES
+                and self.import_tracker.module_for.get("Final") in self.TYPING_MODULE_NAMES
             ):
                 # Final without type argument is invalid in stubs.
                 final_arg = self.get_str_type_of_node(rvalue)
                 typename += f"[{final_arg}]"
+        elif self.processing_enum:
+            initializer, _ = self.get_str_default_of_node(rvalue)
+            return f"{self._indent}{lvalue} = {initializer}\n"
+        elif self.processing_dataclass:
+            # attribute without annotation is not a dataclass field, don't add annotation.
+            return f"{self._indent}{lvalue} = ...\n"
         else:
             typename = self.get_str_type_of_node(rvalue)
-        return f"{self._indent}{lvalue}: {typename}\n"
+        initializer = self.get_assign_initializer(rvalue)
+        return f"{self._indent}{lvalue}: {typename}{initializer}\n"
 
-    def add(self, string: str) -> None:
-        """Add text to generated stub."""
-        self._output.append(string)
+    def get_assign_initializer(self, rvalue: Expression) -> str:
+        """Does this rvalue need some special initializer value?"""
+        if not self._current_class:
+            return ""
+        # Current rules
+        # 1. Return `...` if we are dealing with `NamedTuple` or `dataclass` field and
+        #    it has an existing default value
+        if (
+            self._current_class.info
+            and self._current_class.info.is_named_tuple
+            and not isinstance(rvalue, TempNode)
+        ):
+            return " = ..."
+        if self.processing_dataclass:
+            if isinstance(rvalue, CallExpr):
+                fullname = self.get_fullname(rvalue.callee)
+                if fullname in (self.dataclass_field_specifier or DATACLASS_FIELD_SPECIFIERS):
+                    p = AliasPrinter(self)
+                    return f" = {rvalue.accept(p)}"
+            if not (isinstance(rvalue, TempNode) and rvalue.no_rhs):
+                return " = ..."
+        # TODO: support other possible cases, where initializer is important
+
+        # By default, no initializer is required:
+        return ""
 
     def add_decorator(self, name: str, require_name: bool = False) -> None:
         if require_name:
             self.import_tracker.require_name(name)
-        if not self._indent and self._state not in (EMPTY, FUNC):
-            self._decorators.append("\n")
-        self._decorators.append(f"{self._indent}@{name}\n")
+        self._decorators.append(f"@{name}")
 
     def clear_decorators(self) -> None:
         self._decorators.clear()
 
-    def typing_name(self, name: str) -> str:
-        if name in self.defined_names:
-            # Avoid name clash between name from typing and a name defined in stub.
-            return "_" + name
-        else:
-            return name
-
-    def add_typing_import(self, name: str) -> None:
-        """Add a name to be imported for typing, unless it's imported already.
-
-        The import will be internal to the stub.
-        """
-        name = self.typing_name(name)
-        self.import_tracker.require_name(name)
-
-    def add_import_line(self, line: str) -> None:
-        """Add a line of text to the import section, unless it's already there."""
-        if line not in self._import_lines:
-            self._import_lines.append(line)
-
-    def output(self) -> str:
-        """Return the text for the stub."""
-        imports = ""
-        if self._import_lines:
-            imports += "".join(self._import_lines)
-        imports += "".join(self.import_tracker.import_lines())
-        if imports and self._output:
-            imports += "\n"
-        return imports + "".join(self._output)
-
-    def is_not_in_all(self, name: str) -> bool:
-        if self.is_private_name(name):
-            return False
-        if self._all_:
-            return self.is_top_level() and name not in self._all_
-        return False
-
-    def is_private_name(self, name: str, fullname: str | None = None) -> bool:
-        if self._include_private:
-            return False
-        if fullname in EXTRA_EXPORTED:
-            return False
-        return name.startswith("_") and (not name.endswith("__") or name in IGNORED_DUNDERS)
-
     def is_private_member(self, fullname: str) -> bool:
         parts = fullname.split(".")
         return any(self.is_private_name(part) for part in parts)
@@ -1393,6 +1308,8 @@ def is_private_member(self, fullname: str) -> bool:
     def get_str_type_of_node(
         self, rvalue: Expression, can_infer_optional: bool = False, can_be_any: bool = True
     ) -> str:
+        rvalue = self.maybe_unwrap_unary_expr(rvalue)
+
         if isinstance(rvalue, IntExpr):
             return "int"
         if isinstance(rvalue, StrExpr):
@@ -1401,38 +1318,134 @@ def get_str_type_of_node(
             return "bytes"
         if isinstance(rvalue, FloatExpr):
             return "float"
-        if isinstance(rvalue, UnaryExpr) and isinstance(rvalue.expr, IntExpr):
-            return "int"
+        if isinstance(rvalue, ComplexExpr):  # 1j
+            return "complex"
+        if isinstance(rvalue, OpExpr) and rvalue.op in ("-", "+"):  # -1j + 1
+            if isinstance(self.maybe_unwrap_unary_expr(rvalue.left), ComplexExpr) or isinstance(
+                self.maybe_unwrap_unary_expr(rvalue.right), ComplexExpr
+            ):
+                return "complex"
         if isinstance(rvalue, NameExpr) and rvalue.name in ("True", "False"):
             return "bool"
         if can_infer_optional and isinstance(rvalue, NameExpr) and rvalue.name == "None":
-            self.add_typing_import("Incomplete")
-            return f"{self.typing_name('Incomplete')} | None"
+            return f"{self.add_name('_typeshed.Incomplete')} | None"
         if can_be_any:
-            self.add_typing_import("Incomplete")
-            return self.typing_name("Incomplete")
+            return self.add_name("_typeshed.Incomplete")
         else:
             return ""
 
-    def print_annotation(self, t: Type) -> str:
-        printer = AnnotationPrinter(self)
-        return t.accept(printer)
-
-    def is_top_level(self) -> bool:
-        """Are we processing the top level of a file?"""
-        return self._indent == ""
+    def maybe_unwrap_unary_expr(self, expr: Expression) -> Expression:
+        """Unwrap (possibly nested) unary expressions.
 
-    def record_name(self, name: str) -> None:
-        """Mark a name as defined.
-
-        This only does anything if at the top level of a module.
+        But, some unary expressions can change the type of expression.
+        While we want to preserve it. For example, `~True` is `int`.
+        So, we only allow a subset of unary expressions to be unwrapped.
+        """
+        if not isinstance(expr, UnaryExpr):
+            return expr
+
+        # First, try to unwrap `[+-]+ (int|float|complex)` expr:
+        math_ops = ("+", "-")
+        if expr.op in math_ops:
+            while isinstance(expr, UnaryExpr):
+                if expr.op not in math_ops or not isinstance(
+                    expr.expr, (IntExpr, FloatExpr, ComplexExpr, UnaryExpr)
+                ):
+                    break
+                expr = expr.expr
+            return expr
+
+        # Next, try `not bool` expr:
+        if expr.op == "not":
+            while isinstance(expr, UnaryExpr):
+                if expr.op != "not" or not isinstance(expr.expr, (NameExpr, UnaryExpr)):
+                    break
+                if isinstance(expr.expr, NameExpr) and expr.expr.name not in ("True", "False"):
+                    break
+                expr = expr.expr
+            return expr
+
+        # This is some other unary expr, we cannot do anything with it (yet?).
+        return expr
+
+    def get_str_default_of_node(self, rvalue: Expression) -> tuple[str, bool]:
+        """Get a string representation of the default value of a node.
+
+        Returns a 2-tuple of the default and whether or not it is valid.
         """
-        if self.is_top_level():
-            self._toplevel_names.append(name)
+        if isinstance(rvalue, NameExpr):
+            if rvalue.name in ("None", "True", "False"):
+                return rvalue.name, True
+        elif isinstance(rvalue, (IntExpr, FloatExpr)):
+            return f"{rvalue.value}", True
+        elif isinstance(rvalue, UnaryExpr):
+            if isinstance(rvalue.expr, (IntExpr, FloatExpr)):
+                return f"{rvalue.op}{rvalue.expr.value}", True
+        elif isinstance(rvalue, StrExpr):
+            return repr(rvalue.value), True
+        elif isinstance(rvalue, BytesExpr):
+            return "b" + repr(rvalue.value).replace("\\\\", "\\"), True
+        elif isinstance(rvalue, TupleExpr):
+            items_defaults = []
+            for e in rvalue.items:
+                e_default, valid = self.get_str_default_of_node(e)
+                if not valid:
+                    break
+                items_defaults.append(e_default)
+            else:
+                closing = ",)" if len(items_defaults) == 1 else ")"
+                default = "(" + ", ".join(items_defaults) + closing
+                return default, True
+        elif isinstance(rvalue, ListExpr):
+            items_defaults = []
+            for e in rvalue.items:
+                e_default, valid = self.get_str_default_of_node(e)
+                if not valid:
+                    break
+                items_defaults.append(e_default)
+            else:
+                default = "[" + ", ".join(items_defaults) + "]"
+                return default, True
+        elif isinstance(rvalue, SetExpr):
+            items_defaults = []
+            for e in rvalue.items:
+                e_default, valid = self.get_str_default_of_node(e)
+                if not valid:
+                    break
+                items_defaults.append(e_default)
+            else:
+                if items_defaults:
+                    default = "{" + ", ".join(items_defaults) + "}"
+                    return default, True
+        elif isinstance(rvalue, DictExpr):
+            items_defaults = []
+            for k, v in rvalue.items:
+                if k is None:
+                    break
+                k_default, k_valid = self.get_str_default_of_node(k)
+                v_default, v_valid = self.get_str_default_of_node(v)
+                if not (k_valid and v_valid):
+                    break
+                items_defaults.append(f"{k_default}: {v_default}")
+            else:
+                default = "{" + ", ".join(items_defaults) + "}"
+                return default, True
+        return "...", False
 
-    def is_recorded_name(self, name: str) -> bool:
-        """Has this name been recorded previously?"""
-        return self.is_top_level() and name in self._toplevel_names
+    def should_reexport(self, name: str, full_module: str, name_is_alias: bool) -> bool:
+        is_private = self.is_private_name(name, full_module + "." + name)
+        if (
+            not name_is_alias
+            and name not in self.referenced_names
+            and (not self._all_ or name in self.IGNORED_DUNDERS)
+            and not is_private
+            and full_module not in ("abc", "asyncio") + self.TYPING_MODULE_NAMES
+        ):
+            # An imported name that is never referenced in the module is assumed to be
+            # exported, unless there is an explicit __all__. Note that we need to special
+            # case 'abc' since some references are deleted during semantic analysis.
+            return True
+        return super().should_reexport(name, full_module, name_is_alias)
 
 
 def find_method_names(defs: list[Statement]) -> set[str]:
@@ -1451,7 +1464,7 @@ def find_method_names(defs: list[Statement]) -> set[str]:
 
 class SelfTraverser(mypy.traverser.TraverserVisitor):
     def __init__(self) -> None:
-        self.results: list[tuple[str, Expression]] = []
+        self.results: list[tuple[str, Expression, Type | None]] = []
 
     def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
         lvalue = o.lvalues[0]
@@ -1460,10 +1473,10 @@ def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
             and isinstance(lvalue.expr, NameExpr)
             and lvalue.expr.name == "self"
         ):
-            self.results.append((lvalue.name, o.rvalue))
+            self.results.append((lvalue.name, o.rvalue, o.unanalyzed_type))
 
 
-def find_self_initializers(fdef: FuncBase) -> list[tuple[str, Expression]]:
+def find_self_initializers(fdef: FuncBase) -> list[tuple[str, Expression, Type | None]]:
     """Find attribute initializers in a method.
 
     Return a list of pairs (attribute name, r.h.s. expression).
@@ -1488,22 +1501,31 @@ def remove_blacklisted_modules(modules: list[StubSource]) -> list[StubSource]:
     ]
 
 
+def split_pyc_from_py(modules: list[StubSource]) -> tuple[list[StubSource], list[StubSource]]:
+    py_modules = []
+    pyc_modules = []
+    for mod in modules:
+        if is_pyc_only(mod.path):
+            pyc_modules.append(mod)
+        else:
+            py_modules.append(mod)
+    return pyc_modules, py_modules
+
+
 def is_blacklisted_path(path: str) -> bool:
     return any(substr in (normalize_path_separators(path) + "\n") for substr in BLACKLIST)
 
 
 def normalize_path_separators(path: str) -> str:
-    if sys.platform == "win32":
-        return path.replace("\\", "/")
-    return path
+    return path.replace("\\", "/") if sys.platform == "win32" else path
 
 
 def collect_build_targets(
     options: Options, mypy_opts: MypyOptions
-) -> tuple[list[StubSource], list[StubSource]]:
+) -> tuple[list[StubSource], list[StubSource], list[StubSource]]:
     """Collect files for which we need to generate stubs.
 
-    Return list of Python modules and C modules.
+    Return list of py modules, pyc modules, and C modules.
     """
     if options.packages or options.modules:
         if options.no_import:
@@ -1526,8 +1548,8 @@ def collect_build_targets(
         c_modules = []
 
     py_modules = remove_blacklisted_modules(py_modules)
-
-    return py_modules, c_modules
+    pyc_mod, py_mod = split_pyc_from_py(py_modules)
+    return py_mod, pyc_mod, c_modules
 
 
 def find_module_paths_using_imports(
@@ -1551,7 +1573,7 @@ def find_module_paths_using_imports(
             except CantImport as e:
                 tb = traceback.format_exc()
                 if verbose:
-                    sys.stdout.write(tb)
+                    sys.stderr.write(tb)
                 if not quiet:
                     report_missing(mod, e.message, tb)
                 continue
@@ -1648,6 +1670,7 @@ def mypy_options(stubgen_options: Options) -> MypyOptions:
     options.show_traceback = True
     options.transform_source = remove_misplaced_type_comments
     options.preserve_asts = True
+    options.include_docstrings = stubgen_options.include_docstrings
 
     # Override cache_dir if provided in the environment
     environ_cache_dir = os.getenv("MYPY_CACHE_DIR", "")
@@ -1705,91 +1728,90 @@ def generate_asts_for_modules(
             mod.runtime_all = res.manager.semantic_analyzer.export_map[mod.module]
 
 
-def generate_stub_from_ast(
+def generate_stub_for_py_module(
     mod: StubSource,
     target: str,
+    *,
     parse_only: bool = False,
+    inspect: bool = False,
     include_private: bool = False,
     export_less: bool = False,
+    include_docstrings: bool = False,
+    doc_dir: str = "",
+    all_modules: list[str],
 ) -> None:
     """Use analysed (or just parsed) AST to generate type stub for single file.
 
     If directory for target doesn't exist it will created. Existing stub
     will be overwritten.
     """
-    gen = StubGenerator(
-        mod.runtime_all,
-        include_private=include_private,
-        analyzed=not parse_only,
-        export_less=export_less,
-    )
-    assert mod.ast is not None, "This function must be used only with analyzed modules"
-    mod.ast.accept(gen)
+    if inspect:
+        ngen = InspectionStubGenerator(
+            module_name=mod.module,
+            known_modules=all_modules,
+            _all_=mod.runtime_all,
+            doc_dir=doc_dir,
+            include_private=include_private,
+            export_less=export_less,
+            include_docstrings=include_docstrings,
+        )
+        ngen.generate_module()
+        output = ngen.output()
+
+    else:
+        gen = ASTStubGenerator(
+            mod.runtime_all,
+            include_private=include_private,
+            analyzed=not parse_only,
+            export_less=export_less,
+            include_docstrings=include_docstrings,
+        )
+        assert mod.ast is not None, "This function must be used only with analyzed modules"
+        mod.ast.accept(gen)
+        output = gen.output()
 
     # Write output to file.
     subdir = os.path.dirname(target)
     if subdir and not os.path.isdir(subdir):
         os.makedirs(subdir)
-    with open(target, "w") as file:
-        file.write("".join(gen.output()))
-
-
-def get_sig_generators(options: Options) -> list[SignatureGenerator]:
-    sig_generators: list[SignatureGenerator] = [
-        DocstringSignatureGenerator(),
-        FallbackSignatureGenerator(),
-    ]
-    if options.doc_dir:
-        # Collect info from docs (if given). Always check these first.
-        sigs, class_sigs = collect_docs_signatures(options.doc_dir)
-        sig_generators.insert(0, ExternalSignatureGenerator(sigs, class_sigs))
-    return sig_generators
-
-
-def collect_docs_signatures(doc_dir: str) -> tuple[dict[str, str], dict[str, str]]:
-    """Gather all function and class signatures in the docs.
-
-    Return a tuple (function signatures, class signatures).
-    Currently only used for C modules.
-    """
-    all_sigs: list[Sig] = []
-    all_class_sigs: list[Sig] = []
-    for path in glob.glob(f"{doc_dir}/*.rst"):
-        with open(path) as f:
-            loc_sigs, loc_class_sigs = parse_all_signatures(f.readlines())
-        all_sigs += loc_sigs
-        all_class_sigs += loc_class_sigs
-    sigs = dict(find_unique_signatures(all_sigs))
-    class_sigs = dict(find_unique_signatures(all_class_sigs))
-    return sigs, class_sigs
+    with open(target, "w", encoding="utf-8") as file:
+        file.write(output)
 
 
 def generate_stubs(options: Options) -> None:
     """Main entry point for the program."""
     mypy_opts = mypy_options(options)
-    py_modules, c_modules = collect_build_targets(options, mypy_opts)
-    sig_generators = get_sig_generators(options)
+    py_modules, pyc_modules, c_modules = collect_build_targets(options, mypy_opts)
+    all_modules = py_modules + pyc_modules + c_modules
+    all_module_names = sorted(m.module for m in all_modules)
     # Use parsed sources to generate stubs for Python modules.
     generate_asts_for_modules(py_modules, options.parse_only, mypy_opts, options.verbose)
     files = []
-    for mod in py_modules:
+    for mod in py_modules + pyc_modules:
         assert mod.path is not None, "Not found module was not skipped"
         target = mod.module.replace(".", "/")
-        if os.path.basename(mod.path) == "__init__.py":
+        if os.path.basename(mod.path) in ["__init__.py", "__init__.pyc"]:
             target += "/__init__.pyi"
         else:
             target += ".pyi"
         target = os.path.join(options.output_dir, target)
         files.append(target)
         with generate_guarded(mod.module, target, options.ignore_errors, options.verbose):
-            generate_stub_from_ast(
-                mod, target, options.parse_only, options.include_private, options.export_less
+            generate_stub_for_py_module(
+                mod,
+                target,
+                parse_only=options.parse_only,
+                inspect=options.inspect or mod in pyc_modules,
+                include_private=options.include_private,
+                export_less=options.export_less,
+                include_docstrings=options.include_docstrings,
+                doc_dir=options.doc_dir,
+                all_modules=all_module_names,
             )
 
     # Separately analyse C modules using different logic.
-    all_modules = sorted(m.module for m in (py_modules + c_modules))
     for mod in c_modules:
-        if any(py_mod.module.startswith(mod.module + ".") for py_mod in py_modules + c_modules):
+        if any(py_mod.module.startswith(mod.module + ".") for py_mod in all_modules):
             target = mod.module.replace(".", "/") + "/__init__.pyi"
         else:
             target = mod.module.replace(".", "/") + ".pyi"
@@ -1797,9 +1819,15 @@ def generate_stubs(options: Options) -> None:
         files.append(target)
         with generate_guarded(mod.module, target, options.ignore_errors, options.verbose):
             generate_stub_for_c_module(
-                mod.module, target, known_modules=all_modules, sig_generators=sig_generators
+                mod.module,
+                target,
+                known_modules=all_module_names,
+                doc_dir=options.doc_dir,
+                include_private=options.include_private,
+                export_less=options.export_less,
+                include_docstrings=options.include_docstrings,
             )
-    num_modules = len(py_modules) + len(c_modules)
+    num_modules = len(all_modules)
     if not options.quiet and num_modules > 0:
         print("Processed %d modules" % num_modules)
         if len(files) == 1:
@@ -1820,7 +1848,11 @@ def generate_stubs(options: Options) -> None:
 
 
 def parse_options(args: list[str]) -> Options:
-    parser = argparse.ArgumentParser(prog="stubgen", usage=HEADER, description=DESCRIPTION)
+    parser = argparse.ArgumentParser(
+        prog="stubgen", usage=HEADER, description=DESCRIPTION, fromfile_prefix_chars="@"
+    )
+    if sys.version_info >= (3, 14):
+        parser.color = True  # Set as init arg in 3.14
 
     parser.add_argument(
         "--ignore-errors",
@@ -1835,10 +1867,21 @@ def parse_options(args: list[str]) -> Options:
         "respect __all__)",
     )
     parser.add_argument(
+        "--no-analysis",
         "--parse-only",
+        dest="parse_only",
         action="store_true",
         help="don't perform semantic analysis of sources, just parse them "
-        "(only applies to Python modules, might affect quality of stubs)",
+        "(only applies to Python modules, might affect quality of stubs. "
+        "Not compatible with --inspect-mode)",
+    )
+    parser.add_argument(
+        "--inspect-mode",
+        dest="inspect",
+        action="store_true",
+        help="import and inspect modules instead of parsing source code."
+        "This is the default behavior for c modules and pyc-only packages, but "
+        "it is also useful for pure python modules with dynamically generated members.",
     )
     parser.add_argument(
         "--include-private",
@@ -1851,6 +1894,11 @@ def parse_options(args: list[str]) -> Options:
         action="store_true",
         help="don't implicitly export all names imported from other modules in the same package",
     )
+    parser.add_argument(
+        "--include-docstrings",
+        action="store_true",
+        help="include existing docstrings with the stubs",
+    )
     parser.add_argument("-v", "--verbose", action="store_true", help="show more verbose messages")
     parser.add_argument("-q", "--quiet", action="store_true", help="show fewer messages")
     parser.add_argument(
@@ -1900,6 +1948,9 @@ def parse_options(args: list[str]) -> Options:
         dest="files",
         help="generate stubs for given files or directories",
     )
+    parser.add_argument(
+        "--version", action="version", version="%(prog)s " + mypy.version.__version__
+    )
 
     ns = parser.parse_args(args)
 
@@ -1910,14 +1961,16 @@ def parse_options(args: list[str]) -> Options:
         parser.error("May only specify one of: modules/packages or files.")
     if ns.quiet and ns.verbose:
         parser.error("Cannot specify both quiet and verbose messages")
+    if ns.inspect and ns.parse_only:
+        parser.error("Cannot specify both --parse-only/--no-analysis and --inspect-mode")
 
     # Create the output folder if it doesn't already exist.
-    if not os.path.exists(ns.output_dir):
-        os.makedirs(ns.output_dir)
+    os.makedirs(ns.output_dir, exist_ok=True)
 
     return Options(
         pyversion=pyversion,
         no_import=ns.no_import,
+        inspect=ns.inspect,
         doc_dir=ns.doc_dir,
         search_path=ns.search_path.split(":"),
         interpreter=ns.interpreter,
@@ -1931,6 +1984,7 @@ def parse_options(args: list[str]) -> Options:
         verbose=ns.verbose,
         quiet=ns.quiet,
         export_less=ns.export_less,
+        include_docstrings=ns.include_docstrings,
     )
 
 
diff --git a/mypy/stubgenc.py b/mypy/stubgenc.py
index 4fc9f8c6fdfa..b675079dd8dd 100755
--- a/mypy/stubgenc.py
+++ b/mypy/stubgenc.py
@@ -6,72 +6,44 @@
 
 from __future__ import annotations
 
+import enum
+import glob
 import importlib
 import inspect
+import keyword
 import os.path
-import re
-from abc import abstractmethod
-from types import ModuleType
-from typing import Any, Iterable, Mapping
-from typing_extensions import Final
+from collections.abc import Mapping
+from types import FunctionType, ModuleType
+from typing import Any, Callable
 
+from mypy.fastparse import parse_type_comment
 from mypy.moduleinspect import is_c_module
 from mypy.stubdoc import (
     ArgSig,
     FunctionSig,
+    Sig,
+    find_unique_signatures,
     infer_arg_sig_from_anon_docstring,
     infer_prop_type_from_docstring,
     infer_ret_type_sig_from_anon_docstring,
     infer_ret_type_sig_from_docstring,
     infer_sig_from_docstring,
+    parse_all_signatures,
 )
-
-# Members of the typing module to consider for importing by default.
-_DEFAULT_TYPING_IMPORTS: Final = (
-    "Any",
-    "Callable",
-    "ClassVar",
-    "Dict",
-    "Iterable",
-    "Iterator",
-    "List",
-    "Optional",
-    "Tuple",
-    "Union",
+from mypy.stubutil import (
+    BaseStubGenerator,
+    ClassInfo,
+    FunctionContext,
+    SignatureGenerator,
+    infer_method_arg_types,
+    infer_method_ret_type,
 )
 
 
-class SignatureGenerator:
-    """Abstract base class for extracting a list of FunctionSigs for each function."""
-
-    def remove_self_type(
-        self, inferred: list[FunctionSig] | None, self_var: str
-    ) -> list[FunctionSig] | None:
-        """Remove type annotation from self/cls argument"""
-        if inferred:
-            for signature in inferred:
-                if signature.args:
-                    if signature.args[0].name == self_var:
-                        signature.args[0].type = None
-        return inferred
-
-    @abstractmethod
-    def get_function_sig(
-        self, func: object, module_name: str, name: str
-    ) -> list[FunctionSig] | None:
-        pass
-
-    @abstractmethod
-    def get_method_sig(
-        self, cls: type, func: object, module_name: str, class_name: str, name: str, self_var: str
-    ) -> list[FunctionSig] | None:
-        pass
-
-
 class ExternalSignatureGenerator(SignatureGenerator):
     def __init__(
         self, func_sigs: dict[str, str] | None = None, class_sigs: dict[str, str] | None = None
-    ):
+    ) -> None:
         """
         Takes a mapping of function/method names to signatures and class name to
         class signatures (usually corresponds to __init__).
@@ -79,97 +51,107 @@ class signatures (usually corresponds to __init__).
         self.func_sigs = func_sigs or {}
         self.class_sigs = class_sigs or {}
 
-    def get_function_sig(
-        self, func: object, module_name: str, name: str
-    ) -> list[FunctionSig] | None:
-        if name in self.func_sigs:
-            return [
-                FunctionSig(
-                    name=name,
-                    args=infer_arg_sig_from_anon_docstring(self.func_sigs[name]),
-                    ret_type="Any",
-                )
-            ]
-        else:
-            return None
+    @classmethod
+    def from_doc_dir(cls, doc_dir: str) -> ExternalSignatureGenerator:
+        """Instantiate from a directory of .rst files."""
+        all_sigs: list[Sig] = []
+        all_class_sigs: list[Sig] = []
+        for path in glob.glob(f"{doc_dir}/*.rst"):
+            with open(path) as f:
+                loc_sigs, loc_class_sigs = parse_all_signatures(f.readlines())
+            all_sigs += loc_sigs
+            all_class_sigs += loc_class_sigs
+        sigs = dict(find_unique_signatures(all_sigs))
+        class_sigs = dict(find_unique_signatures(all_class_sigs))
+        return ExternalSignatureGenerator(sigs, class_sigs)
 
-    def get_method_sig(
-        self, cls: type, func: object, module_name: str, class_name: str, name: str, self_var: str
+    def get_function_sig(
+        self, default_sig: FunctionSig, ctx: FunctionContext
     ) -> list[FunctionSig] | None:
+        # method:
         if (
-            name in ("__new__", "__init__")
-            and name not in self.func_sigs
-            and class_name in self.class_sigs
+            ctx.class_info
+            and ctx.name in ("__new__", "__init__")
+            and ctx.name not in self.func_sigs
+            and ctx.class_info.name in self.class_sigs
         ):
             return [
                 FunctionSig(
-                    name=name,
-                    args=infer_arg_sig_from_anon_docstring(self.class_sigs[class_name]),
-                    ret_type=infer_method_ret_type(name),
+                    name=ctx.name,
+                    args=infer_arg_sig_from_anon_docstring(self.class_sigs[ctx.class_info.name]),
+                    ret_type=infer_method_ret_type(ctx.name),
                 )
             ]
-        inferred = self.get_function_sig(func, module_name, name)
-        return self.remove_self_type(inferred, self_var)
+
+        # function:
+        if ctx.name not in self.func_sigs:
+            return None
+
+        inferred = [
+            FunctionSig(
+                name=ctx.name,
+                args=infer_arg_sig_from_anon_docstring(self.func_sigs[ctx.name]),
+                ret_type=None,
+            )
+        ]
+        if ctx.class_info:
+            return self.remove_self_type(inferred, ctx.class_info.self_var)
+        else:
+            return inferred
+
+    def get_property_type(self, default_type: str | None, ctx: FunctionContext) -> str | None:
+        return None
 
 
 class DocstringSignatureGenerator(SignatureGenerator):
     def get_function_sig(
-        self, func: object, module_name: str, name: str
+        self, default_sig: FunctionSig, ctx: FunctionContext
     ) -> list[FunctionSig] | None:
-        docstr = getattr(func, "__doc__", None)
-        inferred = infer_sig_from_docstring(docstr, name)
+        inferred = infer_sig_from_docstring(ctx.docstring, ctx.name)
         if inferred:
-            assert docstr is not None
-            if is_pybind11_overloaded_function_docstring(docstr, name):
+            assert ctx.docstring is not None
+            if is_pybind11_overloaded_function_docstring(ctx.docstring, ctx.name):
                 # Remove pybind11 umbrella (*args, **kwargs) for overloaded functions
                 del inferred[-1]
-        return inferred
 
-    def get_method_sig(
-        self,
-        cls: type,
-        func: object,
-        module_name: str,
-        class_name: str,
-        func_name: str,
-        self_var: str,
-    ) -> list[FunctionSig] | None:
-        inferred = self.get_function_sig(func, module_name, func_name)
-        if not inferred and func_name == "__init__":
-            # look for class-level constructor signatures of the form <class_name>(<signature>)
-            inferred = self.get_function_sig(cls, module_name, class_name)
-        return self.remove_self_type(inferred, self_var)
+        if ctx.class_info:
+            if not inferred and ctx.name == "__init__":
+                # look for class-level constructor signatures of the form <class_name>(<signature>)
+                inferred = infer_sig_from_docstring(ctx.class_info.docstring, ctx.class_info.name)
+                if inferred:
+                    inferred = [sig._replace(name="__init__") for sig in inferred]
+            return self.remove_self_type(inferred, ctx.class_info.self_var)
+        else:
+            return inferred
 
+    def get_property_type(self, default_type: str | None, ctx: FunctionContext) -> str | None:
+        """Infer property type from docstring or docstring signature."""
+        if ctx.docstring is not None:
+            inferred = infer_ret_type_sig_from_anon_docstring(ctx.docstring)
+            if inferred:
+                return inferred
+            inferred = infer_ret_type_sig_from_docstring(ctx.docstring, ctx.name)
+            if inferred:
+                return inferred
+            inferred = infer_prop_type_from_docstring(ctx.docstring)
+            return inferred
+        else:
+            return None
 
-class FallbackSignatureGenerator(SignatureGenerator):
-    def get_function_sig(
-        self, func: object, module_name: str, name: str
-    ) -> list[FunctionSig] | None:
-        return [
-            FunctionSig(
-                name=name,
-                args=infer_arg_sig_from_anon_docstring("(*args, **kwargs)"),
-                ret_type="Any",
-            )
-        ]
 
-    def get_method_sig(
-        self, cls: type, func: object, module_name: str, class_name: str, name: str, self_var: str
-    ) -> list[FunctionSig] | None:
-        return [
-            FunctionSig(
-                name=name,
-                args=infer_method_args(name, self_var),
-                ret_type=infer_method_ret_type(name),
-            )
-        ]
+def is_pybind11_overloaded_function_docstring(docstring: str, name: str) -> bool:
+    return docstring.startswith(f"{name}(*args, **kwargs)\nOverloaded function.\n\n")
 
 
 def generate_stub_for_c_module(
     module_name: str,
     target: str,
     known_modules: list[str],
-    sig_generators: Iterable[SignatureGenerator],
+    doc_dir: str = "",
+    *,
+    include_private: bool = False,
+    export_less: bool = False,
+    include_docstrings: bool = False,
 ) -> None:
     """Generate stub for C module.
 
@@ -183,439 +165,749 @@ def generate_stub_for_c_module(
     If directory for target doesn't exist it will be created. Existing stub
     will be overwritten.
     """
-    module = importlib.import_module(module_name)
-    assert is_c_module(module), f"{module_name} is not a C module"
     subdir = os.path.dirname(target)
     if subdir and not os.path.isdir(subdir):
         os.makedirs(subdir)
-    imports: list[str] = []
-    functions: list[str] = []
-    done = set()
-    items = sorted(get_members(module), key=lambda x: x[0])
-    for name, obj in items:
-        if is_c_function(obj):
-            generate_c_function_stub(
-                module,
-                name,
-                obj,
-                output=functions,
-                known_modules=known_modules,
-                imports=imports,
-                sig_generators=sig_generators,
-            )
-            done.add(name)
-    types: list[str] = []
-    for name, obj in items:
-        if name.startswith("__") and name.endswith("__"):
-            continue
-        if is_c_type(obj):
-            generate_c_type_stub(
-                module,
-                name,
-                obj,
-                output=types,
-                known_modules=known_modules,
-                imports=imports,
-                sig_generators=sig_generators,
-            )
-            done.add(name)
-    variables = []
-    for name, obj in items:
-        if name.startswith("__") and name.endswith("__"):
-            continue
-        if name not in done and not inspect.ismodule(obj):
-            type_str = strip_or_import(
-                get_type_fullname(type(obj)), module, known_modules, imports
-            )
-            variables.append(f"{name}: {type_str}")
-    output = sorted(set(imports))
-    for line in variables:
-        output.append(line)
-    for line in types:
-        if line.startswith("class") and output and output[-1]:
-            output.append("")
-        output.append(line)
-    if output and functions:
-        output.append("")
-    for line in functions:
-        output.append(line)
-    output = add_typing_import(output)
-    with open(target, "w") as file:
-        for line in output:
-            file.write(f"{line}\n")
-
-
-def add_typing_import(output: list[str]) -> list[str]:
-    """Add typing imports for collections/types that occur in the generated stub."""
-    names = []
-    for name in _DEFAULT_TYPING_IMPORTS:
-        if any(re.search(r"\b%s\b" % name, line) for line in output):
-            names.append(name)
-    if names:
-        return [f"from typing import {', '.join(names)}", ""] + output
-    else:
-        return output.copy()
-
-
-def get_members(obj: object) -> list[tuple[str, Any]]:
-    obj_dict: Mapping[str, Any] = getattr(obj, "__dict__")  # noqa: B009
-    results = []
-    for name in obj_dict:
-        if is_skipped_attribute(name):
-            continue
-        # Try to get the value via getattr
-        try:
-            value = getattr(obj, name)
-        except AttributeError:
-            continue
-        else:
-            results.append((name, value))
-    return results
 
+    gen = InspectionStubGenerator(
+        module_name,
+        known_modules,
+        doc_dir,
+        include_private=include_private,
+        export_less=export_less,
+        include_docstrings=include_docstrings,
+    )
+    gen.generate_module()
+    output = gen.output()
 
-def is_c_function(obj: object) -> bool:
-    return inspect.isbuiltin(obj) or type(obj) is type(ord)
+    with open(target, "w", encoding="utf-8") as file:
+        file.write(output)
 
 
-def is_c_method(obj: object) -> bool:
-    return inspect.ismethoddescriptor(obj) or type(obj) in (
-        type(str.index),
-        type(str.__add__),
-        type(str.__new__),
-    )
+class CFunctionStub:
+    """
+    Class that mimics a C function in order to provide parseable docstrings.
+    """
 
+    def __init__(self, name: str, doc: str, is_abstract: bool = False) -> None:
+        self.__name__ = name
+        self.__doc__ = doc
+        self.__abstractmethod__ = is_abstract
 
-def is_c_classmethod(obj: object) -> bool:
-    return inspect.isbuiltin(obj) or type(obj).__name__ in (
-        "classmethod",
-        "classmethod_descriptor",
-    )
+    @classmethod
+    def _from_sig(cls, sig: FunctionSig, is_abstract: bool = False) -> CFunctionStub:
+        return CFunctionStub(sig.name, sig.format_sig()[:-4], is_abstract)
 
+    @classmethod
+    def _from_sigs(cls, sigs: list[FunctionSig], is_abstract: bool = False) -> CFunctionStub:
+        return CFunctionStub(
+            sigs[0].name, "\n".join(sig.format_sig()[:-4] for sig in sigs), is_abstract
+        )
 
-def is_c_property(obj: object) -> bool:
-    return inspect.isdatadescriptor(obj) or hasattr(obj, "fget")
+    def __get__(self) -> None:  # noqa: PLE0302
+        """
+        This exists to make this object look like a method descriptor and thus
+        return true for CStubGenerator.ismethod()
+        """
+        pass
 
 
-def is_c_property_readonly(prop: Any) -> bool:
-    return hasattr(prop, "fset") and prop.fset is None
+_Missing = enum.Enum("_Missing", "VALUE")
 
 
-def is_c_type(obj: object) -> bool:
-    return inspect.isclass(obj) or type(obj) is type(int)
+class InspectionStubGenerator(BaseStubGenerator):
+    """Stub generator that does not parse code.
 
+    Generation is performed by inspecting the module's contents, and thus works
+    for highly dynamic modules, pyc files, and C modules (via the CStubGenerator
+    subclass).
+    """
 
-def is_pybind11_overloaded_function_docstring(docstr: str, name: str) -> bool:
-    return docstr.startswith(f"{name}(*args, **kwargs)\n" + "Overloaded function.\n\n")
+    def __init__(
+        self,
+        module_name: str,
+        known_modules: list[str],
+        doc_dir: str = "",
+        _all_: list[str] | None = None,
+        include_private: bool = False,
+        export_less: bool = False,
+        include_docstrings: bool = False,
+        module: ModuleType | None = None,
+    ) -> None:
+        self.doc_dir = doc_dir
+        if module is None:
+            self.module = importlib.import_module(module_name)
+        else:
+            self.module = module
+        self.is_c_module = is_c_module(self.module)
+        self.known_modules = known_modules
+        self.resort_members = self.is_c_module
+        super().__init__(_all_, include_private, export_less, include_docstrings)
+        self.module_name = module_name
+        if self.is_c_module:
+            # Add additional implicit imports.
+            # C-extensions are given more latitude since they do not import the typing module.
+            self.known_imports.update(
+                {
+                    "typing": [
+                        "Any",
+                        "Callable",
+                        "ClassVar",
+                        "Dict",
+                        "Iterable",
+                        "Iterator",
+                        "List",
+                        "Literal",
+                        "NamedTuple",
+                        "Optional",
+                        "Tuple",
+                        "Union",
+                    ]
+                }
+            )
 
+    def get_default_function_sig(self, func: object, ctx: FunctionContext) -> FunctionSig:
+        argspec = None
+        if not self.is_c_module:
+            # Get the full argument specification of the function
+            try:
+                argspec = inspect.getfullargspec(func)
+            except TypeError:
+                # some callables cannot be inspected, e.g. functools.partial
+                pass
+        if argspec is None:
+            if ctx.class_info is not None:
+                # method:
+                return FunctionSig(
+                    name=ctx.name,
+                    args=infer_c_method_args(ctx.name, ctx.class_info.self_var),
+                    ret_type=infer_method_ret_type(ctx.name),
+                )
+            else:
+                # function:
+                return FunctionSig(
+                    name=ctx.name,
+                    args=[ArgSig(name="*args"), ArgSig(name="**kwargs")],
+                    ret_type=None,
+                )
 
-def generate_c_function_stub(
-    module: ModuleType,
-    name: str,
-    obj: object,
-    *,
-    known_modules: list[str],
-    sig_generators: Iterable[SignatureGenerator],
-    output: list[str],
-    imports: list[str],
-    self_var: str | None = None,
-    cls: type | None = None,
-    class_name: str | None = None,
-) -> None:
-    """Generate stub for a single function or method.
+        # Extract the function arguments, defaults, and varargs
+        args = argspec.args
+        defaults = argspec.defaults
+        varargs = argspec.varargs
+        kwargs = argspec.varkw
+        annotations = argspec.annotations
+        kwonlyargs = argspec.kwonlyargs
+        kwonlydefaults = argspec.kwonlydefaults
+
+        def get_annotation(key: str) -> str | None:
+            if key not in annotations:
+                return None
+            argtype = annotations[key]
+            if argtype is None:
+                return "None"
+            if not isinstance(argtype, str):
+                return self.get_type_fullname(argtype)
+            return argtype
+
+        arglist: list[ArgSig] = []
+
+        # Add the arguments to the signature
+        def add_args(
+            args: list[str], get_default_value: Callable[[int, str], object | _Missing]
+        ) -> None:
+            for i, arg in enumerate(args):
+                # Check if the argument has a default value
+                default_value = get_default_value(i, arg)
+                if default_value is not _Missing.VALUE:
+                    if arg in annotations:
+                        argtype = annotations[arg]
+                    else:
+                        argtype = self.get_type_annotation(default_value)
+                        if argtype == "None":
+                            # None is not a useful annotation, but we can infer that the arg
+                            # is optional
+                            incomplete = self.add_name("_typeshed.Incomplete")
+                            argtype = f"{incomplete} | None"
+
+                    arglist.append(ArgSig(arg, argtype, default=True))
+                else:
+                    arglist.append(ArgSig(arg, get_annotation(arg), default=False))
+
+        def get_pos_default(i: int, _arg: str) -> Any | _Missing:
+            if defaults and i >= len(args) - len(defaults):
+                return defaults[i - (len(args) - len(defaults))]
+            else:
+                return _Missing.VALUE
 
-    The result (always a single line) will be appended to 'output'.
-    If necessary, any required names will be added to 'imports'.
-    The 'class_name' is used to find signature of __init__ or __new__ in
-    'class_sigs'.
-    """
-    inferred: list[FunctionSig] | None = None
-    if class_name:
-        # method:
-        assert cls is not None, "cls should be provided for methods"
-        assert self_var is not None, "self_var should be provided for methods"
-        for sig_gen in sig_generators:
-            inferred = sig_gen.get_method_sig(
-                cls, obj, module.__name__, class_name, name, self_var
-            )
-            if inferred:
-                # add self/cls var, if not present
-                for sig in inferred:
-                    if not sig.args or sig.args[0].name not in ("self", "cls"):
-                        sig.args.insert(0, ArgSig(name=self_var))
-                break
-    else:
-        # function:
-        for sig_gen in sig_generators:
-            inferred = sig_gen.get_function_sig(obj, module.__name__, name)
-            if inferred:
-                break
+        add_args(args, get_pos_default)
 
-    if not inferred:
-        raise ValueError(
-            "No signature was found. This should never happen "
-            "if FallbackSignatureGenerator is provided"
-        )
+        # Add *args if present
+        if varargs:
+            arglist.append(ArgSig(f"*{varargs}", get_annotation(varargs)))
+        # if we have keyword only args, then we need to add "*"
+        elif kwonlyargs:
+            arglist.append(ArgSig("*"))
 
-    is_overloaded = len(inferred) > 1 if inferred else False
-    if is_overloaded:
-        imports.append("from typing import overload")
-    if inferred:
-        for signature in inferred:
-            args: list[str] = []
-            for arg in signature.args:
-                arg_def = arg.name
-                if arg_def == "None":
-                    arg_def = "_none"  # None is not a valid argument name
-
-                if arg.type:
-                    arg_def += ": " + strip_or_import(arg.type, module, known_modules, imports)
-
-                if arg.default:
-                    arg_def += " = ..."
-
-                args.append(arg_def)
-
-            if is_overloaded:
-                output.append("@overload")
-            # a sig generator indicates @classmethod by specifying the cls arg
-            if class_name and signature.args and signature.args[0].name == "cls":
-                output.append("@classmethod")
-            output.append(
-                "def {function}({args}) -> {ret}: ...".format(
-                    function=name,
-                    args=", ".join(args),
-                    ret=strip_or_import(signature.ret_type, module, known_modules, imports),
-                )
+        def get_kw_default(_i: int, arg: str) -> Any | _Missing:
+            if kwonlydefaults and arg in kwonlydefaults:
+                return kwonlydefaults[arg]
+            else:
+                return _Missing.VALUE
+
+        add_args(kwonlyargs, get_kw_default)
+
+        # Add **kwargs if present
+        if kwargs:
+            arglist.append(ArgSig(f"**{kwargs}", get_annotation(kwargs)))
+
+        # add types for known special methods
+        if ctx.class_info is not None and all(
+            arg.type is None and arg.default is False for arg in arglist
+        ):
+            new_args = infer_method_arg_types(
+                ctx.name, ctx.class_info.self_var, [arg.name for arg in arglist if arg.name]
             )
+            if new_args is not None:
+                arglist = new_args
+
+        ret_type = get_annotation("return") or infer_method_ret_type(ctx.name)
+        return FunctionSig(ctx.name, arglist, ret_type)
 
+    def get_sig_generators(self) -> list[SignatureGenerator]:
+        if not self.is_c_module:
+            return []
+        else:
+            sig_generators: list[SignatureGenerator] = [DocstringSignatureGenerator()]
+            if self.doc_dir:
+                # Collect info from docs (if given). Always check these first.
+                sig_generators.insert(0, ExternalSignatureGenerator.from_doc_dir(self.doc_dir))
+            return sig_generators
 
-def strip_or_import(
-    typ: str, module: ModuleType, known_modules: list[str], imports: list[str]
-) -> str:
-    """Strips unnecessary module names from typ.
+    def strip_or_import(self, type_name: str) -> str:
+        """Strips unnecessary module names from typ.
 
-    If typ represents a type that is inside module or is a type coming from builtins, remove
-    module declaration from it. Return stripped name of the type.
+        If typ represents a type that is inside module or is a type coming from builtins, remove
+        module declaration from it. Return stripped name of the type.
 
-    Arguments:
-        typ: name of the type
-        module: in which this type is used
-        known_modules: other modules being processed
-        imports: list of import statements (may be modified during the call)
-    """
-    local_modules = ["builtins"]
-    if module:
-        local_modules.append(module.__name__)
-
-    stripped_type = typ
-    if any(c in typ for c in "[,"):
-        for subtyp in re.split(r"[\[,\]]", typ):
-            stripped_subtyp = strip_or_import(subtyp.strip(), module, known_modules, imports)
-            if stripped_subtyp != subtyp:
-                stripped_type = re.sub(
-                    r"(^|[\[, ]+)" + re.escape(subtyp) + r"($|[\], ]+)",
-                    r"\1" + stripped_subtyp + r"\2",
-                    stripped_type,
-                )
-    elif "." in typ:
-        for module_name in local_modules + list(reversed(known_modules)):
-            if typ.startswith(module_name + "."):
-                if module_name in local_modules:
-                    stripped_type = typ[len(module_name) + 1 :]
-                arg_module = module_name
-                break
+        Arguments:
+            typ: name of the type
+        """
+        local_modules = ["builtins", self.module_name]
+        parsed_type = parse_type_comment(type_name, 0, 0, None)[1]
+        assert parsed_type is not None, type_name
+        return self.print_annotation(parsed_type, self.known_modules, local_modules)
+
+    def get_obj_module(self, obj: object) -> str | None:
+        """Return module name of the object."""
+        return getattr(obj, "__module__", None)
+
+    def is_defined_in_module(self, obj: object) -> bool:
+        """Check if object is considered defined in the current module."""
+        module = self.get_obj_module(obj)
+        return module is None or module == self.module_name
+
+    def generate_module(self) -> None:
+        all_items = self.get_members(self.module)
+        if self.resort_members:
+            all_items = sorted(all_items, key=lambda x: x[0])
+        items = []
+        for name, obj in all_items:
+            if inspect.ismodule(obj) and obj.__name__ in self.known_modules:
+                module_name = obj.__name__
+                if module_name.startswith(self.module_name + "."):
+                    # from {.rel_name} import {mod_name} as {name}
+                    pkg_name, mod_name = module_name.rsplit(".", 1)
+                    rel_module = pkg_name[len(self.module_name) :] or "."
+                    self.import_tracker.add_import_from(rel_module, [(mod_name, name)])
+                    self.import_tracker.reexport(name)
+                else:
+                    # import {module_name} as {name}
+                    self.import_tracker.add_import(module_name, name)
+                    self.import_tracker.reexport(name)
+            elif self.is_defined_in_module(obj) and not inspect.ismodule(obj):
+                # process this below
+                items.append((name, obj))
+            else:
+                # from {obj_module} import {obj_name}
+                obj_module_name = self.get_obj_module(obj)
+                if obj_module_name:
+                    self.import_tracker.add_import_from(obj_module_name, [(name, None)])
+                    if self.should_reexport(name, obj_module_name, name_is_alias=False):
+                        self.import_tracker.reexport(name)
+
+        self.set_defined_names({name for name, obj in all_items if not inspect.ismodule(obj)})
+
+        if self.resort_members:
+            functions: list[str] = []
+            types: list[str] = []
+            variables: list[str] = []
         else:
-            arg_module = typ[: typ.rindex(".")]
-        if arg_module not in local_modules:
-            imports.append(f"import {arg_module}")
-    if stripped_type == "NoneType":
-        stripped_type = "None"
-    return stripped_type
-
-
-def is_static_property(obj: object) -> bool:
-    return type(obj).__name__ == "pybind11_static_property"
-
-
-def generate_c_property_stub(
-    name: str,
-    obj: object,
-    static_properties: list[str],
-    rw_properties: list[str],
-    ro_properties: list[str],
-    readonly: bool,
-    module: ModuleType | None = None,
-    known_modules: list[str] | None = None,
-    imports: list[str] | None = None,
-) -> None:
-    """Generate property stub using introspection of 'obj'.
+            output: list[str] = []
+            functions = types = variables = output
+
+        for name, obj in items:
+            if self.is_function(obj):
+                self.generate_function_stub(name, obj, output=functions)
+            elif inspect.isclass(obj):
+                self.generate_class_stub(name, obj, output=types)
+            else:
+                self.generate_variable_stub(name, obj, output=variables)
+
+        self._output = []
+
+        if self.resort_members:
+            for line in variables:
+                self._output.append(line + "\n")
+            for line in types:
+                if line.startswith("class") and self._output and self._output[-1]:
+                    self._output.append("\n")
+                self._output.append(line + "\n")
+            if self._output and functions:
+                self._output.append("\n")
+            for line in functions:
+                self._output.append(line + "\n")
+        else:
+            for i, line in enumerate(output):
+                if (
+                    self._output
+                    and line.startswith("class")
+                    and (
+                        not self._output[-1].startswith("class")
+                        or (len(output) > i + 1 and output[i + 1].startswith("    "))
+                    )
+                ) or (
+                    self._output
+                    and self._output[-1].startswith("def")
+                    and not line.startswith("def")
+                ):
+                    self._output.append("\n")
+                self._output.append(line + "\n")
+        self.check_undefined_names()
+
+    def is_skipped_attribute(self, attr: str) -> bool:
+        return (
+            attr
+            in (
+                "__class__",
+                "__getattribute__",
+                "__str__",
+                "__repr__",
+                "__doc__",
+                "__dict__",
+                "__module__",
+                "__weakref__",
+                "__annotations__",
+                "__firstlineno__",
+                "__static_attributes__",
+                "__annotate__",
+            )
+            or attr in self.IGNORED_DUNDERS
+            or is_pybind_skipped_attribute(attr)  # For pickling
+            or keyword.iskeyword(attr)
+        )
 
-    Try to infer type from docstring, append resulting lines to 'output'.
-    """
+    def get_members(self, obj: object) -> list[tuple[str, Any]]:
+        obj_dict: Mapping[str, Any] = getattr(obj, "__dict__")  # noqa: B009
+        results = []
+        for name in obj_dict:
+            if self.is_skipped_attribute(name):
+                continue
+            # Try to get the value via getattr
+            try:
+                value = getattr(obj, name)
+            except AttributeError:
+                continue
+            else:
+                results.append((name, value))
+        return results
 
-    def infer_prop_type(docstr: str | None) -> str | None:
-        """Infer property type from docstring or docstring signature."""
-        if docstr is not None:
-            inferred = infer_ret_type_sig_from_anon_docstring(docstr)
-            if not inferred:
-                inferred = infer_ret_type_sig_from_docstring(docstr, name)
-            if not inferred:
-                inferred = infer_prop_type_from_docstring(docstr)
-            return inferred
+    def get_type_annotation(self, obj: object) -> str:
+        """
+        Given an instance, return a string representation of its type that is valid
+        to use as a type annotation.
+        """
+        if obj is None or obj is type(None):
+            return "None"
+        elif inspect.isclass(obj):
+            return f"type[{self.get_type_fullname(obj)}]"
+        elif isinstance(obj, FunctionType):
+            return self.add_name("typing.Callable")
+        elif isinstance(obj, ModuleType):
+            return self.add_name("types.ModuleType", require=False)
         else:
-            return None
+            return self.get_type_fullname(type(obj))
+
+    def is_function(self, obj: object) -> bool:
+        if self.is_c_module:
+            return inspect.isbuiltin(obj)
+        else:
+            return inspect.isfunction(obj)
+
+    def is_method(self, class_info: ClassInfo, name: str, obj: object) -> bool:
+        if self.is_c_module:
+            return inspect.ismethoddescriptor(obj) or type(obj) in (
+                type(str.index),
+                type(str.__add__),
+                type(str.__new__),
+            )
+        else:
+            # this is valid because it is only called on members of a class
+            return inspect.isfunction(obj)
+
+    def is_classmethod(self, class_info: ClassInfo, name: str, obj: object) -> bool:
+        if self.is_c_module:
+            return inspect.isbuiltin(obj) or type(obj).__name__ in (
+                "classmethod",
+                "classmethod_descriptor",
+            )
+        else:
+            return inspect.ismethod(obj)
+
+    def is_staticmethod(self, class_info: ClassInfo | None, name: str, obj: object) -> bool:
+        if class_info is None:
+            return False
+        elif self.is_c_module:
+            raw_lookup: Mapping[str, Any] = getattr(class_info.cls, "__dict__")  # noqa: B009
+            raw_value = raw_lookup.get(name, obj)
+            return isinstance(raw_value, staticmethod)
+        else:
+            return isinstance(inspect.getattr_static(class_info.cls, name), staticmethod)
+
+    @staticmethod
+    def is_abstract_method(obj: object) -> bool:
+        return getattr(obj, "__abstractmethod__", False)
+
+    @staticmethod
+    def is_property(class_info: ClassInfo, name: str, obj: object) -> bool:
+        return inspect.isdatadescriptor(obj) or hasattr(obj, "fget")
+
+    @staticmethod
+    def is_property_readonly(prop: Any) -> bool:
+        return hasattr(prop, "fset") and prop.fset is None
 
-    inferred = infer_prop_type(getattr(obj, "__doc__", None))
-    if not inferred:
-        fget = getattr(obj, "fget", None)
-        inferred = infer_prop_type(getattr(fget, "__doc__", None))
-    if not inferred:
-        inferred = "Any"
-
-    if module is not None and imports is not None and known_modules is not None:
-        inferred = strip_or_import(inferred, module, known_modules, imports)
-
-    if is_static_property(obj):
-        trailing_comment = "  # read-only" if readonly else ""
-        static_properties.append(f"{name}: ClassVar[{inferred}] = ...{trailing_comment}")
-    else:  # regular property
-        if readonly:
-            ro_properties.append("@property")
-            ro_properties.append(f"def {name}(self) -> {inferred}: ...")
+    def is_static_property(self, obj: object) -> bool:
+        """For c-modules, whether the property behaves like an attribute"""
+        if self.is_c_module:
+            # StaticProperty is from boost-python
+            return type(obj).__name__ in ("pybind11_static_property", "StaticProperty")
         else:
-            rw_properties.append(f"{name}: {inferred}")
+            return False
+
+    def process_inferred_sigs(self, inferred: list[FunctionSig]) -> None:
+        for i, sig in enumerate(inferred):
+            for arg in sig.args:
+                if arg.type is not None:
+                    arg.type = self.strip_or_import(arg.type)
+            if sig.ret_type is not None:
+                inferred[i] = sig._replace(ret_type=self.strip_or_import(sig.ret_type))
+
+    def generate_function_stub(
+        self, name: str, obj: object, *, output: list[str], class_info: ClassInfo | None = None
+    ) -> None:
+        """Generate stub for a single function or method.
+
+        The result (always a single line) will be appended to 'output'.
+        If necessary, any required names will be added to 'imports'.
+        The 'class_name' is used to find signature of __init__ or __new__ in
+        'class_sigs'.
+        """
+        docstring: Any = getattr(obj, "__doc__", None)
+        if not isinstance(docstring, str):
+            docstring = None
+
+        ctx = FunctionContext(
+            self.module_name,
+            name,
+            docstring=docstring,
+            is_abstract=self.is_abstract_method(obj),
+            class_info=class_info,
+        )
+        if self.is_private_name(name, ctx.fullname) or self.is_not_in_all(name):
+            return
 
+        self.record_name(ctx.name)
+        default_sig = self.get_default_function_sig(obj, ctx)
+        inferred = self.get_signatures(default_sig, self.sig_generators, ctx)
+        self.process_inferred_sigs(inferred)
 
-def generate_c_type_stub(
-    module: ModuleType,
-    class_name: str,
-    obj: type,
-    output: list[str],
-    known_modules: list[str],
-    imports: list[str],
-    sig_generators: Iterable[SignatureGenerator],
-) -> None:
-    """Generate stub for a single class using runtime introspection.
+        decorators = []
+        if len(inferred) > 1:
+            decorators.append("@{}".format(self.add_name("typing.overload")))
 
-    The result lines will be appended to 'output'. If necessary, any
-    required names will be added to 'imports'.
-    """
-    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)
-    methods: list[str] = []
-    types: list[str] = []
-    static_properties: list[str] = []
-    rw_properties: list[str] = []
-    ro_properties: list[str] = []
-    attrs: list[tuple[str, Any]] = []
-    for attr, value in items:
-        # use unevaluated descriptors when dealing with property inspection
-        raw_value = raw_lookup.get(attr, value)
-        if is_c_method(value) or is_c_classmethod(value):
-            if attr == "__new__":
-                # TODO: We should support __new__.
-                if "__init__" in names:
-                    # Avoid duplicate functions if both are present.
-                    # But is there any case where .__new__() has a
-                    # better signature than __init__() ?
-                    continue
-                attr = "__init__"
-            if is_c_classmethod(value):
-                self_var = "cls"
+        if ctx.is_abstract:
+            decorators.append("@{}".format(self.add_name("abc.abstractmethod")))
+
+        if class_info is not None:
+            if self.is_staticmethod(class_info, name, obj):
+                decorators.append("@staticmethod")
             else:
-                self_var = "self"
-            generate_c_function_stub(
-                module,
-                attr,
-                value,
-                output=methods,
-                known_modules=known_modules,
-                imports=imports,
-                self_var=self_var,
-                cls=obj,
-                class_name=class_name,
-                sig_generators=sig_generators,
-            )
-        elif is_c_property(raw_value):
-            generate_c_property_stub(
-                attr,
-                raw_value,
-                static_properties,
-                rw_properties,
-                ro_properties,
-                is_c_property_readonly(raw_value),
-                module=module,
-                known_modules=known_modules,
-                imports=imports,
-            )
-        elif is_c_type(value):
-            generate_c_type_stub(
-                module,
-                attr,
-                value,
-                types,
-                imports=imports,
-                known_modules=known_modules,
-                sig_generators=sig_generators,
+                for sig in inferred:
+                    if not sig.args or sig.args[0].name not in ("self", "cls"):
+                        sig.args.insert(0, ArgSig(name=class_info.self_var))
+                # a sig generator indicates @classmethod by specifying the cls arg.
+                if inferred[0].args and inferred[0].args[0].name == "cls":
+                    decorators.append("@classmethod")
+
+        if docstring:
+            docstring = self._indent_docstring(docstring)
+        output.extend(self.format_func_def(inferred, decorators=decorators, docstring=docstring))
+        self._fix_iter(ctx, inferred, output)
+
+    def _indent_docstring(self, docstring: str) -> str:
+        """Fix indentation of docstring extracted from pybind11 or other binding generators."""
+        lines = docstring.splitlines(keepends=True)
+        indent = self._indent + "    "
+        if len(lines) > 1:
+            if not all(line.startswith(indent) or not line.strip() for line in lines):
+                # if the docstring is not indented, then indent all but the first line
+                for i, line in enumerate(lines[1:]):
+                    if line.strip():
+                        lines[i + 1] = indent + line
+        # if there's a trailing newline, add a final line to visually indent the quoted docstring
+        if lines[-1].endswith("\n"):
+            if len(lines) > 1:
+                lines.append(indent)
+            else:
+                lines[-1] = lines[-1][:-1]
+        return "".join(lines)
+
+    def _fix_iter(
+        self, ctx: FunctionContext, inferred: list[FunctionSig], output: list[str]
+    ) -> None:
+        """Ensure that objects which implement old-style iteration via __getitem__
+        are considered iterable.
+        """
+        if (
+            ctx.class_info
+            and ctx.class_info.cls is not None
+            and ctx.name == "__getitem__"
+            and "__iter__" not in ctx.class_info.cls.__dict__
+        ):
+            item_type: str | None = None
+            for sig in inferred:
+                if sig.args and sig.args[-1].type == "int":
+                    item_type = sig.ret_type
+                    break
+            if item_type is None:
+                return
+            obj = CFunctionStub(
+                "__iter__", f"def __iter__(self) -> typing.Iterator[{item_type}]\n"
             )
+            self.generate_function_stub("__iter__", obj, output=output, class_info=ctx.class_info)
+
+    def generate_property_stub(
+        self,
+        name: str,
+        raw_obj: object,
+        obj: object,
+        static_properties: list[str],
+        rw_properties: list[str],
+        ro_properties: list[str],
+        class_info: ClassInfo | None = None,
+    ) -> None:
+        """Generate property stub using introspection of 'obj'.
+
+        Try to infer type from docstring, append resulting lines to 'output'.
+
+        raw_obj : object before evaluation of descriptor (if any)
+        obj : object after evaluation of descriptor
+        """
+
+        docstring = getattr(raw_obj, "__doc__", None)
+        fget = getattr(raw_obj, "fget", None)
+        if fget:
+            alt_docstr = getattr(fget, "__doc__", None)
+            if alt_docstr and docstring:
+                docstring += "\n" + alt_docstr
+            elif alt_docstr:
+                docstring = alt_docstr
+
+        ctx = FunctionContext(
+            self.module_name, name, docstring=docstring, is_abstract=False, class_info=class_info
+        )
+
+        if self.is_private_name(name, ctx.fullname) or self.is_not_in_all(name):
+            return
+
+        self.record_name(ctx.name)
+        static = self.is_static_property(raw_obj)
+        readonly = self.is_property_readonly(raw_obj)
+        if static:
+            ret_type: str | None = self.strip_or_import(self.get_type_annotation(obj))
         else:
-            attrs.append((attr, value))
+            default_sig = self.get_default_function_sig(raw_obj, ctx)
+            ret_type = default_sig.ret_type
+
+        inferred_type = self.get_property_type(ret_type, self.sig_generators, ctx)
+        if inferred_type is not None:
+            inferred_type = self.strip_or_import(inferred_type)
 
-    for attr, value in attrs:
-        static_properties.append(
-            "{}: ClassVar[{}] = ...".format(
-                attr,
-                strip_or_import(get_type_fullname(type(value)), module, known_modules, imports),
+        if static:
+            classvar = self.add_name("typing.ClassVar")
+            trailing_comment = "  # read-only" if readonly else ""
+            if inferred_type is None:
+                inferred_type = self.add_name("_typeshed.Incomplete")
+
+            static_properties.append(
+                f"{self._indent}{name}: {classvar}[{inferred_type}] = ...{trailing_comment}"
             )
+        else:  # regular property
+            if readonly:
+                ro_properties.append(f"{self._indent}@property")
+                sig = FunctionSig(name, [ArgSig("self")], inferred_type)
+                ro_properties.append(sig.format_sig(indent=self._indent))
+            else:
+                if inferred_type is None:
+                    inferred_type = self.add_name("_typeshed.Incomplete")
+
+                rw_properties.append(f"{self._indent}{name}: {inferred_type}")
+
+    def get_type_fullname(self, typ: type) -> str:
+        """Given a type, return a string representation"""
+        if typ is Any:
+            return "Any"
+        typename = getattr(typ, "__qualname__", typ.__name__)
+        module_name = self.get_obj_module(typ)
+        if module_name is None:
+            # This should not normally happen, but some types may resist our
+            # introspection attempts too hard. See
+            # https://github.com/python/mypy/issues/19031
+            return "_typeshed.Incomplete"
+        if module_name != "builtins":
+            typename = f"{module_name}.{typename}"
+        return typename
+
+    def get_base_types(self, obj: type) -> list[str]:
+        all_bases = type.mro(obj)
+        if all_bases[-1] is object:
+            # TODO: Is this always object?
+            del all_bases[-1]
+        # remove pybind11_object. All classes generated by pybind11 have pybind11_object in their MRO,
+        # which only overrides a few functions in object type
+        if all_bases and all_bases[-1].__name__ == "pybind11_object":
+            del all_bases[-1]
+        # remove the class itself
+        all_bases = all_bases[1:]
+        # Remove base classes of other bases as redundant.
+        bases: list[type] = []
+        for base in all_bases:
+            if not any(issubclass(b, base) for b in bases):
+                bases.append(base)
+        return [self.strip_or_import(self.get_type_fullname(base)) for base in bases]
+
+    def generate_class_stub(
+        self, class_name: str, cls: type, output: list[str], parent_class: ClassInfo | None = None
+    ) -> None:
+        """Generate stub for a single class using runtime introspection.
+
+        The result lines will be appended to 'output'. If necessary, any
+        required names will be added to 'imports'.
+        """
+        raw_lookup: Mapping[str, Any] = getattr(cls, "__dict__")  # noqa: B009
+        items = self.get_members(cls)
+        if self.resort_members:
+            items = sorted(items, key=lambda x: method_name_sort_key(x[0]))
+        names = {x[0] for x in items}
+        methods: list[str] = []
+        types: list[str] = []
+        static_properties: list[str] = []
+        rw_properties: list[str] = []
+        ro_properties: list[str] = []
+        attrs: list[tuple[str, Any]] = []
+
+        self.record_name(class_name)
+        self.indent()
+
+        class_info = ClassInfo(
+            class_name, "", getattr(cls, "__doc__", None), cls, parent=parent_class
         )
-    all_bases = type.mro(obj)
-    if all_bases[-1] is object:
-        # TODO: Is this always object?
-        del all_bases[-1]
-    # remove pybind11_object. All classes generated by pybind11 have pybind11_object in their MRO,
-    # which only overrides a few functions in object type
-    if all_bases and all_bases[-1].__name__ == "pybind11_object":
-        del all_bases[-1]
-    # remove the class itself
-    all_bases = all_bases[1:]
-    # Remove base classes of other bases as redundant.
-    bases: list[type] = []
-    for base in all_bases:
-        if not any(issubclass(b, base) for b in bases):
-            bases.append(base)
-    if bases:
-        bases_str = "(%s)" % ", ".join(
-            strip_or_import(get_type_fullname(base), module, known_modules, imports)
-            for base in bases
-        )
-    else:
-        bases_str = ""
-    if types or static_properties or rw_properties or methods or ro_properties:
-        output.append(f"class {class_name}{bases_str}:")
-        for line in types:
-            if (
-                output
-                and output[-1]
-                and not output[-1].startswith("class")
-                and line.startswith("class")
+
+        for attr, value in items:
+            # use unevaluated descriptors when dealing with property inspection
+            raw_value = raw_lookup.get(attr, value)
+            if self.is_method(class_info, attr, value) or self.is_classmethod(
+                class_info, attr, value
             ):
-                output.append("")
-            output.append("    " + line)
-        for line in static_properties:
-            output.append(f"    {line}")
-        for line in rw_properties:
-            output.append(f"    {line}")
-        for line in methods:
-            output.append(f"    {line}")
-        for line in ro_properties:
-            output.append(f"    {line}")
-    else:
-        output.append(f"class {class_name}{bases_str}: ...")
+                if attr == "__new__":
+                    # TODO: We should support __new__.
+                    if "__init__" in names:
+                        # Avoid duplicate functions if both are present.
+                        # But is there any case where .__new__() has a
+                        # better signature than __init__() ?
+                        continue
+                    attr = "__init__"
+                # FIXME: make this nicer
+                if self.is_staticmethod(class_info, attr, value):
+                    class_info.self_var = ""
+                elif self.is_classmethod(class_info, attr, value):
+                    class_info.self_var = "cls"
+                else:
+                    class_info.self_var = "self"
+                self.generate_function_stub(attr, value, output=methods, class_info=class_info)
+            elif self.is_property(class_info, attr, raw_value):
+                self.generate_property_stub(
+                    attr,
+                    raw_value,
+                    value,
+                    static_properties,
+                    rw_properties,
+                    ro_properties,
+                    class_info,
+                )
+            elif inspect.isclass(value) and self.is_defined_in_module(value):
+                self.generate_class_stub(attr, value, types, parent_class=class_info)
+            else:
+                attrs.append((attr, value))
 
+        for attr, value in attrs:
+            if attr == "__hash__" and value is None:
+                # special case for __hash__
+                continue
+            prop_type_name = self.strip_or_import(self.get_type_annotation(value))
+            classvar = self.add_name("typing.ClassVar")
+            static_properties.append(f"{self._indent}{attr}: {classvar}[{prop_type_name}] = ...")
 
-def get_type_fullname(typ: type) -> str:
-    return f"{typ.__module__}.{getattr(typ, '__qualname__', typ.__name__)}"
+        self.dedent()
+
+        bases = self.get_base_types(cls)
+        if bases:
+            bases_str = "(%s)" % ", ".join(bases)
+        else:
+            bases_str = ""
+        if types or static_properties or rw_properties or methods or ro_properties:
+            output.append(f"{self._indent}class {class_name}{bases_str}:")
+            for line in types:
+                if (
+                    output
+                    and output[-1]
+                    and not output[-1].strip().startswith("class")
+                    and line.strip().startswith("class")
+                ):
+                    output.append("")
+                output.append(line)
+            for line in static_properties:
+                output.append(line)
+            for line in rw_properties:
+                output.append(line)
+            for line in methods:
+                output.append(line)
+            for line in ro_properties:
+                output.append(line)
+        else:
+            output.append(f"{self._indent}class {class_name}{bases_str}: ...")
+
+    def generate_variable_stub(self, name: str, obj: object, output: list[str]) -> None:
+        """Generate stub for a single variable using runtime introspection.
+
+        The result lines will be appended to 'output'. If necessary, any
+        required names will be added to 'imports'.
+        """
+        if self.is_private_name(name, f"{self.module_name}.{name}") or self.is_not_in_all(name):
+            return
+        self.record_name(name)
+        type_str = self.strip_or_import(self.get_type_annotation(obj))
+        output.append(f"{name}: {type_str}")
 
 
 def method_name_sort_key(name: str) -> tuple[int, str]:
@@ -634,22 +926,9 @@ def is_pybind_skipped_attribute(attr: str) -> bool:
     return attr.startswith("__pybind11_module_local_")
 
 
-def is_skipped_attribute(attr: str) -> bool:
-    return attr in (
-        "__class__",
-        "__getattribute__",
-        "__str__",
-        "__repr__",
-        "__doc__",
-        "__dict__",
-        "__module__",
-        "__weakref__",
-    ) or is_pybind_skipped_attribute(  # For pickling
-        attr
-    )
-
-
-def infer_method_args(name: str, self_var: str | None = None) -> list[ArgSig]:
+def infer_c_method_args(
+    name: str, self_var: str = "self", arg_names: list[str] | None = None
+) -> list[ArgSig]:
     args: list[ArgSig] | None = None
     if name.startswith("__") and name.endswith("__"):
         name = name[2:-2]
@@ -689,13 +968,9 @@ def infer_method_args(name: str, self_var: str | None = None) -> list[ArgSig]:
             args = []
         elif name == "setstate":
             args = [ArgSig(name="state")]
+        elif name in ("eq", "ne", "lt", "le", "gt", "ge"):
+            args = [ArgSig(name="other", type="object")]
         elif name in (
-            "eq",
-            "ne",
-            "lt",
-            "le",
-            "gt",
-            "ge",
             "add",
             "radd",
             "sub",
@@ -747,22 +1022,15 @@ def infer_method_args(name: str, self_var: str | None = None) -> list[ArgSig]:
         elif name == "reduce_ex":
             args = [ArgSig(name="protocol")]
         elif name == "exit":
-            args = [ArgSig(name="type"), ArgSig(name="value"), ArgSig(name="traceback")]
+            args = [
+                ArgSig(name="type", type="type[BaseException] | None"),
+                ArgSig(name="value", type="BaseException | None"),
+                ArgSig(name="traceback", type="types.TracebackType | None"),
+            ]
+    if args is None:
+        args = infer_method_arg_types(name, self_var, arg_names)
+    else:
+        args = [ArgSig(name=self_var)] + args
     if args is None:
         args = [ArgSig(name="*args"), ArgSig(name="**kwargs")]
-    return [ArgSig(name=self_var or "self")] + args
-
-
-def infer_method_ret_type(name: str) -> str:
-    if name.startswith("__") and name.endswith("__"):
-        name = name[2:-2]
-        if name in ("float", "bool", "bytes", "int"):
-            return name
-        # Note: __eq__ and co may return arbitrary types, but bool is good enough for stubgen.
-        elif name in ("eq", "ne", "lt", "le", "gt", "ge", "contains"):
-            return "bool"
-        elif name in ("len", "hash", "sizeof", "trunc", "floor", "ceil"):
-            return "int"
-        elif name in ("init", "setitem"):
-            return "None"
-    return "Any"
+    return args
diff --git a/mypy/stubinfo.py b/mypy/stubinfo.py
index e6e549ad280f..33064c9d3067 100644
--- a/mypy/stubinfo.py
+++ b/mypy/stubinfo.py
@@ -1,66 +1,64 @@
 from __future__ import annotations
 
 
-def is_legacy_bundled_package(prefix: str) -> bool:
-    return prefix in legacy_bundled_packages
+def is_module_from_legacy_bundled_package(module: str) -> bool:
+    top_level = module.split(".", 1)[0]
+    return top_level in legacy_bundled_packages
 
 
-def approved_stub_package_exists(prefix: str) -> bool:
-    return is_legacy_bundled_package(prefix) or prefix in non_bundled_packages
+def stub_distribution_name(module: str) -> str | None:
+    top_level = module.split(".", 1)[0]
 
+    dist = legacy_bundled_packages.get(top_level)
+    if dist:
+        return dist
+    dist = non_bundled_packages_flat.get(top_level)
+    if dist:
+        return dist
 
-def stub_package_name(prefix: str) -> str:
-    return legacy_bundled_packages.get(prefix) or non_bundled_packages[prefix]
+    if top_level in non_bundled_packages_namespace:
+        namespace = non_bundled_packages_namespace[top_level]
+        components = module.split(".")
+        for i in range(len(components), 0, -1):
+            module = ".".join(components[:i])
+            dist = namespace.get(module)
+            if dist:
+                return dist
+
+    return None
 
 
 # Stubs for these third-party packages used to be shipped with mypy.
 #
 # Map package name to PyPI stub distribution name.
-#
-# Package name can have one or two components ('a' or 'a.b').
-legacy_bundled_packages = {
+legacy_bundled_packages: dict[str, str] = {
     "aiofiles": "types-aiofiles",
     "bleach": "types-bleach",
-    "boto": "types-boto",
     "cachetools": "types-cachetools",
     "click_spinner": "types-click-spinner",
-    "contextvars": "types-contextvars",
     "croniter": "types-croniter",
-    "dataclasses": "types-dataclasses",
     "dateparser": "types-dateparser",
-    "datetimerange": "types-DateTimeRange",
     "dateutil": "types-python-dateutil",
     "decorator": "types-decorator",
     "deprecated": "types-Deprecated",
     "docutils": "types-docutils",
     "first": "types-first",
-    "geoip2": "types-geoip2",
-    "gflags": "types-python-gflags",
-    "google.protobuf": "types-protobuf",
     "markdown": "types-Markdown",
-    "maxminddb": "types-maxminddb",
     "mock": "types-mock",
     "OpenSSL": "types-pyOpenSSL",
     "paramiko": "types-paramiko",
-    "pkg_resources": "types-setuptools",
     "polib": "types-polib",
     "pycurl": "types-pycurl",
     "pymysql": "types-PyMySQL",
     "pyrfc3339": "types-pyRFC3339",
-    "python2": "types-six",
     "pytz": "types-pytz",
-    "pyVmomi": "types-pyvmomi",
-    "redis": "types-redis",
     "requests": "types-requests",
     "retry": "types-retry",
     "simplejson": "types-simplejson",
     "singledispatch": "types-singledispatch",
     "six": "types-six",
-    "slugify": "types-python-slugify",
     "tabulate": "types-tabulate",
     "toml": "types-toml",
-    "typed_ast": "types-typed-ast",
-    "tzlocal": "types-tzlocal",
     "ujson": "types-ujson",
     "waitress": "types-waitress",
     "yaml": "types-PyYAML",
@@ -71,114 +69,233 @@ def stub_package_name(prefix: str) -> str:
 # include packages that have a release that includes PEP 561 type
 # information.
 #
-# Package name can have one or two components ('a' or 'a.b').
-#
 # Note that these packages are omitted for now:
 #   pika:       typeshed's stubs are on PyPI as types-pika-ts.
 #               types-pika already exists on PyPI, and is more complete in many ways,
 #               but is a non-typeshed stubs package.
-non_bundled_packages = {
-    "MySQLdb": "types-mysqlclient",
-    "PIL": "types-Pillow",
-    "PyInstaller": "types-pyinstaller",
-    "Xlib": "types-python-xlib",
-    "annoy": "types-annoy",
-    "appdirs": "types-appdirs",
+non_bundled_packages_flat: dict[str, str] = {
+    "_cffi_backend": "types-cffi",
+    "_win32typing": "types-pywin32",
+    "antlr4": "types-antlr4-python3-runtime",
+    "assertpy": "types-assertpy",
+    "atheris": "types-atheris",
+    "authlib": "types-Authlib",
     "aws_xray_sdk": "types-aws-xray-sdk",
-    "babel": "types-babel",
-    "backports.ssl_match_hostname": "types-backports.ssl_match_hostname",
+    "boltons": "types-boltons",
     "braintree": "types-braintree",
     "bs4": "types-beautifulsoup4",
     "bugbear": "types-flake8-bugbear",
     "caldav": "types-caldav",
+    "capturer": "types-capturer",
     "cffi": "types-cffi",
     "chevron": "types-chevron",
+    "click_default_group": "types-click-default-group",
+    "click_log": "types-click-log",
+    "click_web": "types-click-web",
     "colorama": "types-colorama",
+    "commctrl": "types-pywin32",
     "commonmark": "types-commonmark",
     "consolemenu": "types-console-menu",
+    "corus": "types-corus",  # codespell:ignore corus
+    "cronlog": "types-python-crontab",
     "crontab": "types-python-crontab",
-    "d3dshot": "types-D3DShot",
-    "dj_database_url": "types-dj-database-url",
+    "crontabs": "types-python-crontab",
+    "datemath": "types-python-datemath",
+    "dateparser_data": "types-dateparser",
+    "dde": "types-pywin32",
+    "defusedxml": "types-defusedxml",
+    "docker": "types-docker",
     "dockerfile_parse": "types-dockerfile-parse",
-    "docopt": "types-docopt",
     "editdistance": "types-editdistance",
     "entrypoints": "types-entrypoints",
+    "exifread": "types-ExifRead",
+    "fanstatic": "types-fanstatic",
     "farmhash": "types-pyfarmhash",
-    "flake8_2020": "types-flake8-2020",
     "flake8_builtins": "types-flake8-builtins",
     "flake8_docstrings": "types-flake8-docstrings",
-    "flake8_plugin_utils": "types-flake8-plugin-utils",
     "flake8_rst_docstrings": "types-flake8-rst-docstrings",
     "flake8_simplify": "types-flake8-simplify",
     "flake8_typing_imports": "types-flake8-typing-imports",
+    "flake8": "types-flake8",
     "flask_cors": "types-Flask-Cors",
     "flask_migrate": "types-Flask-Migrate",
-    "flask_sqlalchemy": "types-Flask-SQLAlchemy",
+    "flask_socketio": "types-Flask-SocketIO",
     "fpdf": "types-fpdf2",
     "gdb": "types-gdb",
-    "google.cloud": "types-google-cloud-ndb",
+    "gevent": "types-gevent",
+    "greenlet": "types-greenlet",
     "hdbcli": "types-hdbcli",
     "html5lib": "types-html5lib",
     "httplib2": "types-httplib2",
     "humanfriendly": "types-humanfriendly",
-    "invoke": "types-invoke",
+    "hvac": "types-hvac",
+    "ibm_db": "types-ibm-db",
+    "icalendar": "types-icalendar",
+    "import_export": "types-django-import-export",
+    "influxdb_client": "types-influxdb-client",
+    "inifile": "types-inifile",
+    "isapi": "types-pywin32",
     "jack": "types-JACK-Client",
+    "jenkins": "types-python-jenkins",
+    "Jetson": "types-Jetson.GPIO",
+    "jks": "types-pyjks",
     "jmespath": "types-jmespath",
     "jose": "types-python-jose",
     "jsonschema": "types-jsonschema",
+    "jwcrypto": "types-jwcrypto",
     "keyboard": "types-keyboard",
     "ldap3": "types-ldap3",
+    "lupa": "types-lupa",
+    "lzstring": "types-lzstring",
+    "m3u8": "types-m3u8",
+    "mmapfile": "types-pywin32",
+    "mmsystem": "types-pywin32",
+    "mypy_extensions": "types-mypy-extensions",
+    "MySQLdb": "types-mysqlclient",
+    "nanoid": "types-nanoid",
+    "nanoleafapi": "types-nanoleafapi",
+    "netaddr": "types-netaddr",
+    "netifaces": "types-netifaces",
+    "networkx": "types-networkx",
     "nmap": "types-python-nmap",
+    "ntsecuritycon": "types-pywin32",
     "oauthlib": "types-oauthlib",
+    "objgraph": "types-objgraph",
+    "odbc": "types-pywin32",
+    "olefile": "types-olefile",
     "openpyxl": "types-openpyxl",
     "opentracing": "types-opentracing",
-    "paho.mqtt": "types-paho-mqtt",
     "parsimonious": "types-parsimonious",
     "passlib": "types-passlib",
     "passpy": "types-passpy",
     "peewee": "types-peewee",
     "pep8ext_naming": "types-pep8-naming",
-    "playsound": "types-playsound",
+    "perfmon": "types-pywin32",
+    "pexpect": "types-pexpect",
+    "playhouse": "types-peewee",
+    "portpicker": "types-portpicker",
     "psutil": "types-psutil",
     "psycopg2": "types-psycopg2",
+    "pyasn1": "types-pyasn1",
     "pyaudio": "types-pyaudio",
     "pyautogui": "types-PyAutoGUI",
     "pycocotools": "types-pycocotools",
     "pyflakes": "types-pyflakes",
+    "pygit2": "types-pygit2",
     "pygments": "types-Pygments",
     "pyi_splash": "types-pyinstaller",
+    "PyInstaller": "types-pyinstaller",
     "pynput": "types-pynput",
-    "pythoncom": "types-pywin32",
-    "pythonwin": "types-pywin32",
     "pyscreeze": "types-PyScreeze",
     "pysftp": "types-pysftp",
     "pytest_lazyfixture": "types-pytest-lazy-fixture",
+    "python_http_client": "types-python-http-client",
+    "pythoncom": "types-pywin32",
+    "pythonwin": "types-pywin32",
     "pywintypes": "types-pywin32",
+    "qrbill": "types-qrbill",
+    "qrcode": "types-qrcode",
     "regex": "types-regex",
+    "regutil": "types-pywin32",
+    "reportlab": "types-reportlab",
+    "requests_oauthlib": "types-requests-oauthlib",
+    "RPi": "types-RPi.GPIO",
+    "s2clientprotocol": "types-s2clientprotocol",
+    "sass": "types-libsass",
+    "sassutils": "types-libsass",
+    "seaborn": "types-seaborn",
     "send2trash": "types-Send2Trash",
+    "serial": "types-pyserial",
+    "servicemanager": "types-pywin32",
+    "setuptools": "types-setuptools",
+    "shapely": "types-shapely",
     "slumber": "types-slumber",
-    "stdlib_list": "types-stdlib-list",
-    "stripe": "types-stripe",
+    "sspicon": "types-pywin32",
+    "str2bool": "types-str2bool",
+    "tensorflow": "types-tensorflow",
+    "tgcrypto": "types-TgCrypto",
+    "timer": "types-pywin32",
     "toposort": "types-toposort",
     "tqdm": "types-tqdm",
-    "tree_sitter": "types-tree-sitter",
+    "translationstring": "types-translationstring",
     "tree_sitter_languages": "types-tree-sitter-languages",
     "ttkthemes": "types-ttkthemes",
-    "urllib3": "types-urllib3",
+    "unidiff": "types-unidiff",
+    "untangle": "types-untangle",
+    "usersettings": "types-usersettings",
+    "uwsgi": "types-uWSGI",
+    "uwsgidecorators": "types-uWSGI",
     "vobject": "types-vobject",
+    "webob": "types-WebOb",
     "whatthepatch": "types-whatthepatch",
+    "win2kras": "types-pywin32",
     "win32": "types-pywin32",
     "win32api": "types-pywin32",
-    "win32con": "types-pywin32",
+    "win32clipboard": "types-pywin32",
     "win32com": "types-pywin32",
     "win32comext": "types-pywin32",
+    "win32con": "types-pywin32",
+    "win32console": "types-pywin32",
+    "win32cred": "types-pywin32",
+    "win32crypt": "types-pywin32",
+    "win32cryptcon": "types-pywin32",
+    "win32event": "types-pywin32",
+    "win32evtlog": "types-pywin32",
+    "win32evtlogutil": "types-pywin32",
+    "win32file": "types-pywin32",
+    "win32gui_struct": "types-pywin32",
     "win32gui": "types-pywin32",
+    "win32help": "types-pywin32",
+    "win32inet": "types-pywin32",
+    "win32inetcon": "types-pywin32",
+    "win32job": "types-pywin32",
+    "win32lz": "types-pywin32",
+    "win32net": "types-pywin32",
+    "win32netcon": "types-pywin32",
+    "win32pdh": "types-pywin32",
+    "win32pdhquery": "types-pywin32",
+    "win32pipe": "types-pywin32",
+    "win32print": "types-pywin32",
+    "win32process": "types-pywin32",
+    "win32profile": "types-pywin32",
+    "win32ras": "types-pywin32",
+    "win32security": "types-pywin32",
+    "win32service": "types-pywin32",
+    "win32serviceutil": "types-pywin32",
+    "win32timezone": "types-pywin32",
+    "win32trace": "types-pywin32",
+    "win32transaction": "types-pywin32",
+    "win32ts": "types-pywin32",
+    "win32ui": "types-pywin32",
+    "win32uiole": "types-pywin32",
+    "win32verstamp": "types-pywin32",
+    "win32wnet": "types-pywin32",
+    "winerror": "types-pywin32",
+    "winioctlcon": "types-pywin32",
+    "winnt": "types-pywin32",
+    "winperf": "types-pywin32",
+    "winxpgui": "types-pywin32",
+    "winxptheme": "types-pywin32",
+    "workalendar": "types-workalendar",
+    "wtforms": "types-WTForms",
+    "wurlitzer": "types-wurlitzer",
+    "xdg": "types-pyxdg",
+    "xdgenvpy": "types-xdgenvpy",
+    "Xlib": "types-python-xlib",
     "xmltodict": "types-xmltodict",
-    "xxhash": "types-xxhash",
+    "zstd": "types-zstd",
     "zxcvbn": "types-zxcvbn",
     # Stub packages that are not from typeshed
     # Since these can be installed automatically via --install-types, we have a high trust bar
     # for additions here
     "pandas": "pandas-stubs",  # https://github.com/pandas-dev/pandas-stubs
     "lxml": "lxml-stubs",  # https://github.com/lxml/lxml-stubs
+    "scipy": "scipy-stubs",  # https://github.com/scipy/scipy-stubs
+}
+
+
+non_bundled_packages_namespace: dict[str, dict[str, str]] = {
+    "backports": {"backports.ssl_match_hostname": "types-backports.ssl_match_hostname"},
+    "google": {"google.cloud.ndb": "types-google-cloud-ndb", "google.protobuf": "types-protobuf"},
+    "paho": {"paho.mqtt": "types-paho-mqtt"},
 }
diff --git a/mypy/stubtest.py b/mypy/stubtest.py
index 4e038cfd75d1..f9e6f7d337be 100644
--- a/mypy/stubtest.py
+++ b/mypy/stubtest.py
@@ -10,7 +10,9 @@
 import collections.abc
 import copy
 import enum
+import functools
 import importlib
+import importlib.machinery
 import inspect
 import os
 import pkgutil
@@ -22,10 +24,12 @@
 import typing
 import typing_extensions
 import warnings
+from collections import defaultdict
+from collections.abc import Iterator, Set as AbstractSet
 from contextlib import redirect_stderr, redirect_stdout
 from functools import singledispatch
 from pathlib import Path
-from typing import Any, Generic, Iterator, TypeVar, Union
+from typing import Any, Final, Generic, TypeVar, Union
 from typing_extensions import get_origin, is_typeddict
 
 import mypy.build
@@ -48,12 +52,23 @@ def __repr__(self) -> str:
         return "MISSING"
 
 
-MISSING: typing_extensions.Final = Missing()
+MISSING: Final = Missing()
 
 T = TypeVar("T")
 MaybeMissing: typing_extensions.TypeAlias = Union[T, Missing]
 
-_formatter: typing_extensions.Final = FancyFormatter(sys.stdout, sys.stderr, False)
+
+class Unrepresentable:
+    """Marker object for unrepresentable parameter defaults."""
+
+    def __repr__(self) -> str:
+        return "<unrepresentable>"
+
+
+UNREPRESENTABLE: Final = Unrepresentable()
+
+
+_formatter: Final = FancyFormatter(sys.stdout, sys.stderr, False)
 
 
 def _style(message: str, **kwargs: Any) -> str:
@@ -100,7 +115,17 @@ def __init__(
         self.stub_object = stub_object
         self.runtime_object = runtime_object
         self.stub_desc = stub_desc or str(getattr(stub_object, "type", stub_object))
-        self.runtime_desc = runtime_desc or _truncate(repr(runtime_object), 100)
+
+        if runtime_desc is None:
+            runtime_sig = safe_inspect_signature(runtime_object)
+            if runtime_sig is None:
+                self.runtime_desc = _truncate(repr(runtime_object), 100)
+            else:
+                runtime_is_async = inspect.iscoroutinefunction(runtime_object)
+                description = describe_runtime_callable(runtime_sig, is_async=runtime_is_async)
+                self.runtime_desc = _truncate(description, 100)
+        else:
+            self.runtime_desc = runtime_desc
 
     def is_missing_stub(self) -> bool:
         """Whether or not the error is for something missing from the stub."""
@@ -109,7 +134,7 @@ def is_missing_stub(self) -> bool:
     def is_positional_only_related(self) -> bool:
         """Whether or not the error is for something being (or not being) positional-only."""
         # TODO: This is hacky, use error codes or something more resilient
-        return "leading double underscore" in self.message
+        return "should be positional" in self.message
 
     def get_description(self, concise: bool = False) -> str:
         """Returns a description of the error.
@@ -209,7 +234,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():
@@ -275,44 +305,30 @@ def _verify_exported_names(
         # desirable in at least the `names_in_runtime_not_stub` case
         stub_object=MISSING,
         runtime_object=MISSING,
-        stub_desc=(
-            f"Names exported in the stub but not at runtime: " f"{names_in_stub_not_runtime}"
-        ),
+        stub_desc=(f"Names exported in the stub but not at runtime: {names_in_stub_not_runtime}"),
         runtime_desc=(
-            f"Names exported at runtime but not in the stub: " f"{names_in_runtime_not_stub}"
+            f"Names exported at runtime but not in the stub: {names_in_runtime_not_stub}"
         ),
     )
 
 
-def _get_imported_symbol_names(runtime: types.ModuleType) -> frozenset[str] | None:
-    """Retrieve the names in the global namespace which are known to be imported.
-
-    1). Use inspect to retrieve the source code of the module
-    2). Use symtable to parse the source and retrieve names that are known to be imported
-        from other modules.
-
-    If either of the above steps fails, return `None`.
+@functools.lru_cache
+def _module_symbol_table(runtime: types.ModuleType) -> symtable.SymbolTable | None:
+    """Retrieve the symbol table for the module (or None on failure).
 
-    Note that if a set of names is returned,
-    it won't include names imported via `from foo import *` imports.
+    1) Use inspect to retrieve the source code of the module
+    2) Use symtable to parse the source (and use what symtable knows for its purposes)
     """
     try:
         source = inspect.getsource(runtime)
     except (OSError, TypeError, SyntaxError):
         return None
 
-    if not source.strip():
-        # The source code for the module was an empty file,
-        # no point in parsing it with symtable
-        return frozenset()
-
     try:
-        module_symtable = symtable.symtable(source, runtime.__name__, "exec")
+        return symtable.symtable(source, runtime.__name__, "exec")
     except SyntaxError:
         return None
 
-    return frozenset(sym.get_name() for sym in module_symtable.get_symbols() if sym.is_imported())
-
 
 @verify.register(nodes.MypyFile)
 def verify_mypyfile(
@@ -322,7 +338,8 @@ def verify_mypyfile(
         yield Error(object_path, "is not present at runtime", stub, runtime)
         return
     if not isinstance(runtime, types.ModuleType):
-        yield Error(object_path, "is not a module", stub, runtime)
+        # Can possibly happen:
+        yield Error(object_path, "is not a module", stub, runtime)  # type: ignore[unreachable]
         return
 
     runtime_all_as_set: set[str] | None
@@ -333,6 +350,8 @@ def verify_mypyfile(
             # Only verify the contents of the stub's __all__
             # if the stub actually defines __all__
             yield from _verify_exported_names(object_path, stub, runtime_all_as_set)
+        else:
+            yield Error(object_path + ["__all__"], "is not present in stub", MISSING, runtime)
     else:
         runtime_all_as_set = None
 
@@ -343,25 +362,37 @@ def verify_mypyfile(
         if not o.module_hidden and (not is_probably_private(m) or hasattr(runtime, m))
     }
 
-    imported_symbols = _get_imported_symbol_names(runtime)
-
     def _belongs_to_runtime(r: types.ModuleType, attr: str) -> bool:
         """Heuristics to determine whether a name originates from another module."""
         obj = getattr(r, attr)
         if isinstance(obj, types.ModuleType):
             return False
-        if callable(obj):
-            # It's highly likely to be a class or a function if it's callable,
-            # so the __module__ attribute will give a good indication of which module it comes from
+
+        symbol_table = _module_symbol_table(r)
+        if symbol_table is not None:
             try:
-                obj_mod = obj.__module__
-            except Exception:
+                symbol = symbol_table.lookup(attr)
+            except KeyError:
                 pass
             else:
-                if isinstance(obj_mod, str):
-                    return bool(obj_mod == r.__name__)
-        if imported_symbols is not None:
-            return attr not in imported_symbols
+                if symbol.is_imported():
+                    # symtable says we got this from another module
+                    return False
+                # But we can't just return True here, because symtable doesn't know about symbols
+                # that come from `from module import *`
+                if symbol.is_assigned():
+                    # symtable knows we assigned this symbol in the module
+                    return True
+
+        # The __module__ attribute is unreliable for anything except functions and classes,
+        # but it's our best guess at this point
+        try:
+            obj_mod = obj.__module__
+        except Exception:
+            pass
+        else:
+            if isinstance(obj_mod, str):
+                return bool(obj_mod == r.__name__)
         return True
 
     runtime_public_contents = (
@@ -477,11 +508,25 @@ def _verify_metaclass(
 def verify_typeinfo(
     stub: nodes.TypeInfo, runtime: MaybeMissing[type[Any]], object_path: list[str]
 ) -> Iterator[Error]:
+    if stub.is_type_check_only:
+        # This type only exists in stubs, we only check that the runtime part
+        # is missing. Other checks are not required.
+        if not isinstance(runtime, Missing):
+            yield Error(
+                object_path,
+                'is marked as "@type_check_only", but also exists at runtime',
+                stub,
+                runtime,
+                stub_desc=repr(stub),
+            )
+        return
+
     if isinstance(runtime, Missing):
         yield Error(object_path, "is not present at runtime", stub, runtime, stub_desc=repr(stub))
         return
     if not isinstance(runtime, type):
-        yield Error(object_path, "is not a type", stub, runtime, stub_desc=repr(stub))
+        # Yes, some runtime objects can be not types, no way to tell mypy about that.
+        yield Error(object_path, "is not a type", stub, runtime, stub_desc=repr(stub))  # type: ignore[unreachable]
         return
 
     yield from _verify_final(stub, runtime, object_path)
@@ -491,7 +536,11 @@ def verify_typeinfo(
     )
 
     # Check everything already defined on the stub class itself (i.e. not inherited)
-    to_check = set(stub.names)
+    #
+    # Filter out non-identifier names, as these are (hopefully always?) whacky/fictional things
+    # (like __mypy-replace or __mypy-post_init, etc.) that don't exist at runtime,
+    # and exist purely for internal mypy reasons
+    to_check = {name for name in stub.names if name.isidentifier()}
     # Check all public things on the runtime class
     to_check.update(
         m for m in vars(runtime) if not is_probably_private(m) and m not in IGNORABLE_CLASS_DUNDERS
@@ -522,6 +571,27 @@ def verify_typeinfo(
             # Catch all exceptions in case the runtime raises an unexpected exception
             # from __getattr__ or similar.
             continue
+
+        # If it came from the metaclass, consider the runtime_attr to be MISSING
+        # for a more accurate message
+        if (
+            runtime_attr is not MISSING
+            and type(runtime) is not runtime
+            and getattr(runtime_attr, "__objclass__", None) is type(runtime)
+        ):
+            runtime_attr = MISSING
+
+        # __setattr__ and __delattr__ on object are a special case,
+        # so if we only have these methods inherited from there, pretend that
+        # we don't have them. See python/typeshed#7385.
+        if (
+            entry in ("__setattr__", "__delattr__")
+            and runtime_attr is not MISSING
+            and runtime is not object
+            and getattr(runtime_attr, "__objclass__", None) is object
+        ):
+            runtime_attr = MISSING
+
         # Do not error for an object missing from the stub
         # If the runtime object is a types.WrapperDescriptorType object
         # and has a non-special dunder name.
@@ -584,10 +654,14 @@ def _verify_arg_name(
     if is_dunder(function_name, exclude_special=True):
         return
 
-    def strip_prefix(s: str, prefix: str) -> str:
-        return s[len(prefix) :] if s.startswith(prefix) else s
+    if (
+        stub_arg.variable.name == runtime_arg.name
+        or stub_arg.variable.name.removeprefix("__") == runtime_arg.name
+    ):
+        return
 
-    if strip_prefix(stub_arg.variable.name, "__") == runtime_arg.name:
+    nonspecific_names = {"object", "args"}
+    if runtime_arg.name in nonspecific_names:
         return
 
     def names_approx_match(a: str, b: str) -> bool:
@@ -613,7 +687,7 @@ def _verify_arg_default_value(
     stub_arg: nodes.Argument, runtime_arg: inspect.Parameter
 ) -> Iterator[str]:
     """Checks whether argument default values are compatible."""
-    if runtime_arg.default != inspect.Parameter.empty:
+    if runtime_arg.default is not inspect.Parameter.empty:
         if stub_arg.kind.is_required():
             yield (
                 f'runtime argument "{runtime_arg.name}" '
@@ -632,7 +706,7 @@ def _verify_arg_default_value(
                 runtime_type is not None
                 and stub_type is not None
                 # Avoid false positives for marker objects
-                and type(runtime_arg.default) != object
+                and type(runtime_arg.default) is not object
                 # And ellipsis
                 and runtime_arg.default is not ...
                 and not is_subtype_helper(runtime_type, stub_type)
@@ -647,18 +721,27 @@ def _verify_arg_default_value(
                 if (
                     stub_default is not UNKNOWN
                     and stub_default is not ...
-                    and (
-                        stub_default != runtime_arg.default
-                        # We want the types to match exactly, e.g. in case the stub has
-                        # True and the runtime has 1 (or vice versa).
-                        or type(stub_default) is not type(runtime_arg.default)  # noqa: E721
-                    )
+                    and runtime_arg.default is not UNREPRESENTABLE
                 ):
-                    yield (
-                        f'runtime argument "{runtime_arg.name}" '
-                        f"has a default value of {runtime_arg.default!r}, "
-                        f"which is different from stub argument default {stub_default!r}"
-                    )
+                    defaults_match = True
+                    # We want the types to match exactly, e.g. in case the stub has
+                    # True and the runtime has 1 (or vice versa).
+                    if type(stub_default) is not type(runtime_arg.default):
+                        defaults_match = False
+                    else:
+                        try:
+                            defaults_match = bool(stub_default == runtime_arg.default)
+                        except Exception:
+                            # Exception can be raised in bool dunder method (e.g. numpy arrays)
+                            # At this point, consider the default to be different, it is probably
+                            # too complex to put in a stub anyway.
+                            defaults_match = False
+                    if not defaults_match:
+                        yield (
+                            f'runtime argument "{runtime_arg.name}" '
+                            f"has a default value of {runtime_arg.default!r}, "
+                            f"which is different from stub argument default {stub_default!r}"
+                        )
     else:
         if stub_arg.kind.is_optional():
             yield (
@@ -668,7 +751,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":
@@ -700,7 +783,7 @@ def get_type(arg: Any) -> str | None:
 
         def has_default(arg: Any) -> bool:
             if isinstance(arg, inspect.Parameter):
-                return bool(arg.default != inspect.Parameter.empty)
+                return arg.default is not inspect.Parameter.empty
             if isinstance(arg, nodes.Argument):
                 return arg.kind.is_optional()
             raise AssertionError
@@ -775,14 +858,17 @@ def from_overloadedfuncdef(stub: nodes.OverloadedFuncDef) -> Signature[nodes.Arg
 
         all_args: dict[str, list[tuple[nodes.Argument, int]]] = {}
         for func in map(_resolve_funcitem_from_decorator, stub.items):
-            assert func is not None
+            assert func is not None, "Failed to resolve decorated overload"
             args = maybe_strip_cls(stub.name, func.arguments)
             for index, arg in enumerate(args):
                 # For positional-only args, we allow overloads to have different names for the same
                 # argument. To accomplish this, we just make up a fake index-based name.
                 name = (
                     f"__{index}"
-                    if arg.variable.name.startswith("__") or assume_positional_only
+                    if arg.variable.name.startswith("__")
+                    or arg.pos_only
+                    or assume_positional_only
+                    or arg.variable.name.strip("_") == "self"
                     else arg.variable.name
                 )
                 all_args.setdefault(name, []).append((arg, index))
@@ -826,6 +912,7 @@ def get_kind(arg_name: str) -> nodes.ArgKind:
                 type_annotation=None,
                 initializer=None,
                 kind=get_kind(arg_name),
+                pos_only=all(arg.pos_only for arg, _ in all_args[arg_name]),
             )
             if arg.kind.is_positional():
                 sig.pos.append(arg)
@@ -851,21 +938,23 @@ def _verify_signature(
             runtime_arg.kind == inspect.Parameter.POSITIONAL_ONLY
             and not stub_arg.pos_only
             and not stub_arg.variable.name.startswith("__")
-            and not stub_arg.variable.name.strip("_") == "self"
+            and stub_arg.variable.name.strip("_") != "self"
             and not is_dunder(function_name, exclude_special=True)  # noisy for dunder methods
         ):
             yield (
                 f'stub argument "{stub_arg.variable.name}" should be positional-only '
-                f'(rename with a leading double underscore, i.e. "__{runtime_arg.name}")'
+                f'(add "/", e.g. "{runtime_arg.name}, /")'
             )
         if (
             runtime_arg.kind != inspect.Parameter.POSITIONAL_ONLY
             and (stub_arg.pos_only or stub_arg.variable.name.startswith("__"))
+            and not runtime_arg.name.startswith("__")
+            and stub_arg.variable.name.strip("_") != "self"
             and not is_dunder(function_name, exclude_special=True)  # noisy for dunder methods
         ):
             yield (
                 f'stub argument "{stub_arg.variable.name}" should be positional or keyword '
-                "(remove leading double underscore)"
+                '(remove "/")'
             )
 
     # Check unmatched positional args
@@ -879,7 +968,10 @@ def _verify_signature(
                 # If the variable is in runtime.kwonly, it's just mislabelled as not a
                 # keyword-only argument
                 if stub_arg.variable.name not in runtime.kwonly:
-                    yield f'runtime does not have argument "{stub_arg.variable.name}"'
+                    msg = f'runtime does not have argument "{stub_arg.variable.name}"'
+                    if runtime.varkw is not None:
+                        msg += ". Maybe you forgot to make it keyword-only in the stub?"
+                    yield msg
                 else:
                     yield f'stub argument "{stub_arg.variable.name}" is not keyword-only'
             if stub.varpos is not None:
@@ -887,7 +979,8 @@ def _verify_signature(
     elif len(stub.pos) < len(runtime.pos):
         for runtime_arg in runtime.pos[len(stub.pos) :]:
             if runtime_arg.name not in stub.kwonly:
-                yield f'stub does not have argument "{runtime_arg.name}"'
+                if not _is_private_parameter(runtime_arg):
+                    yield f'stub does not have argument "{runtime_arg.name}"'
             else:
                 yield f'runtime argument "{runtime_arg.name}" is not keyword-only'
 
@@ -927,7 +1020,8 @@ def _verify_signature(
             ):
                 yield f'stub argument "{arg}" is not keyword-only'
         else:
-            yield f'stub does not have argument "{arg}"'
+            if not _is_private_parameter(runtime.kwonly[arg]):
+                yield f'stub does not have argument "{arg}"'
 
     # Checks involving **kwargs
     if stub.varkw is None and runtime.varkw is not None:
@@ -942,6 +1036,14 @@ def _verify_signature(
         yield f'runtime does not have **kwargs argument "{stub.varkw.variable.name}"'
 
 
+def _is_private_parameter(arg: inspect.Parameter) -> bool:
+    return (
+        arg.name.startswith("_")
+        and not arg.name.startswith("__")
+        and arg.default is not inspect.Parameter.empty
+    )
+
+
 @verify.register(nodes.FuncItem)
 def verify_funcitem(
     stub: nodes.FuncItem, runtime: MaybeMissing[Any], object_path: list[str]
@@ -973,7 +1075,7 @@ def verify_funcitem(
     if signature:
         stub_sig = Signature.from_funcitem(stub)
         runtime_sig = Signature.from_inspect_signature(signature)
-        runtime_sig_desc = f'{"async " if runtime_is_coroutine else ""}def {signature}'
+        runtime_sig_desc = describe_runtime_callable(signature, is_async=runtime_is_coroutine)
         stub_desc = str(stub_sig)
     else:
         runtime_sig_desc, stub_desc = None, None
@@ -1005,9 +1107,11 @@ def verify_funcitem(
 
 
 @verify.register(Missing)
-def verify_none(
+def verify_missing(
     stub: Missing, runtime: MaybeMissing[Any], object_path: list[str]
 ) -> Iterator[Error]:
+    if runtime is MISSING:
+        return
     yield Error(object_path, "is not present in stub", stub, runtime)
 
 
@@ -1041,6 +1145,13 @@ def verify_var(
             runtime_type = get_mypy_type_of_runtime_value(runtime.value)
             if runtime_type is not None and is_subtype_helper(runtime_type, stub.type):
                 should_error = False
+            # We always allow setting the stub value to ...
+            proper_type = mypy.types.get_proper_type(stub.type)
+            if (
+                isinstance(proper_type, mypy.types.Instance)
+                and proper_type.type.fullname == "builtins.ellipsis"
+            ):
+                should_error = False
 
         if should_error:
             yield Error(
@@ -1052,6 +1163,7 @@ def verify_var(
 def verify_overloadedfuncdef(
     stub: nodes.OverloadedFuncDef, runtime: MaybeMissing[Any], object_path: list[str]
 ) -> Iterator[Error]:
+    # TODO: support `@type_check_only` decorator
     if isinstance(runtime, Missing):
         yield Error(object_path, "is not present at runtime", stub, runtime)
         return
@@ -1144,11 +1256,30 @@ def verify_paramspecexpr(
         return
 
 
+def _is_django_cached_property(runtime: Any) -> bool:  # pragma: no cover
+    # This is a special case for
+    # https://docs.djangoproject.com/en/5.2/ref/utils/#django.utils.functional.cached_property
+    # This is needed in `django-stubs` project:
+    # https://github.com/typeddjango/django-stubs
+    if type(runtime).__name__ != "cached_property":
+        return False
+    try:
+        return bool(runtime.func)
+    except Exception:
+        return False
+
+
 def _verify_readonly_property(stub: nodes.Decorator, runtime: Any) -> Iterator[str]:
     assert stub.func.is_property
     if isinstance(runtime, property):
         yield from _verify_final_method(stub.func, runtime.fget, MISSING)
         return
+    if isinstance(runtime, functools.cached_property):
+        yield from _verify_final_method(stub.func, runtime.func, MISSING)
+        return
+    if _is_django_cached_property(runtime):
+        yield from _verify_final_method(stub.func, runtime.func, MISSING)
+        return
     if inspect.isdatadescriptor(runtime):
         # It's enough like a property...
         return
@@ -1201,6 +1332,12 @@ def _resolve_funcitem_from_decorator(dec: nodes.OverloadPart) -> nodes.FuncItem
     def apply_decorator_to_funcitem(
         decorator: nodes.Expression, func: nodes.FuncItem
     ) -> nodes.FuncItem | None:
+        if (
+            isinstance(decorator, nodes.CallExpr)
+            and isinstance(decorator.callee, nodes.RefExpr)
+            and decorator.callee.fullname in mypy.types.DEPRECATED_TYPE_NAMES
+        ):
+            return func
         if not isinstance(decorator, nodes.RefExpr):
             return None
         if not decorator.fullname:
@@ -1209,6 +1346,8 @@ def apply_decorator_to_funcitem(
         if (
             decorator.fullname in ("builtins.staticmethod", "abc.abstractmethod")
             or decorator.fullname in mypy.types.OVERLOAD_NAMES
+            or decorator.fullname in mypy.types.OVERRIDE_DECORATOR_NAMES
+            or decorator.fullname in mypy.types.FINAL_DECORATOR_NAMES
         ):
             return func
         if decorator.fullname == "builtins.classmethod":
@@ -1239,6 +1378,19 @@ def apply_decorator_to_funcitem(
 def verify_decorator(
     stub: nodes.Decorator, runtime: MaybeMissing[Any], object_path: list[str]
 ) -> Iterator[Error]:
+    if stub.func.is_type_check_only:
+        # This function only exists in stubs, we only check that the runtime part
+        # is missing. Other checks are not required.
+        if not isinstance(runtime, Missing):
+            yield Error(
+                object_path,
+                'is marked as "@type_check_only", but also exists at runtime',
+                stub,
+                runtime,
+                stub_desc=repr(stub),
+            )
+        return
+
     if isinstance(runtime, Missing):
         yield Error(object_path, "is not present at runtime", stub, runtime)
         return
@@ -1331,7 +1483,7 @@ def verify_typealias(
 # ====================
 
 
-IGNORED_MODULE_DUNDERS: typing_extensions.Final = frozenset(
+IGNORED_MODULE_DUNDERS: Final = frozenset(
     {
         "__file__",
         "__doc__",
@@ -1342,6 +1494,7 @@ def verify_typealias(
         "__loader__",
         "__spec__",
         "__annotations__",
+        "__annotate__",
         "__path__",  # mypy adds __path__ to packages, but C packages don't have it
         "__getattr__",  # resulting behaviour might be typed explicitly
         # Created by `warnings.warn`, does not make much sense to have in stubs:
@@ -1353,18 +1506,23 @@ def verify_typealias(
     }
 )
 
-IGNORABLE_CLASS_DUNDERS: typing_extensions.Final = frozenset(
+IGNORABLE_CLASS_DUNDERS: Final = frozenset(
     {
         # Special attributes
         "__dict__",
         "__annotations__",
+        "__annotate__",
+        "__annotations_cache__",
+        "__annotate_func__",
         "__text_signature__",
         "__weakref__",
-        "__del__",  # Only ever called when an object is being deleted, who cares?
         "__hash__",
         "__getattr__",  # resulting behaviour might be typed explicitly
         "__setattr__",  # defining this on a class can cause worse type checking
         "__vectorcalloffset__",  # undocumented implementation detail of the vectorcall protocol
+        "__firstlineno__",
+        "__static_attributes__",
+        "__classdictcell__",
         # isinstance/issubclass hooks that type-checkers don't usually care about
         "__instancecheck__",
         "__subclasshook__",
@@ -1383,6 +1541,7 @@ def verify_typealias(
         "__getinitargs__",
         "__reduce_ex__",
         "__reduce__",
+        "__slotnames__",  # Cached names of slots added by `copyreg` module.
         # ctypes weirdness
         "__ctype_be__",
         "__ctype_le__",
@@ -1396,6 +1555,7 @@ def verify_typealias(
         # Added to all protocol classes on 3.12+ (or if using typing_extensions.Protocol)
         "__protocol_attrs__",
         "__callable_proto_members_only__",
+        "__non_callable_proto_members__",
         # typing implementation details, consider removing some of these:
         "__parameters__",
         "__origin__",
@@ -1414,9 +1574,17 @@ def is_probably_private(name: str) -> bool:
 
 def is_probably_a_function(runtime: Any) -> bool:
     return (
-        isinstance(runtime, (types.FunctionType, types.BuiltinFunctionType))
-        or isinstance(runtime, (types.MethodType, types.BuiltinMethodType))
+        isinstance(
+            runtime,
+            (
+                types.FunctionType,
+                types.BuiltinFunctionType,
+                types.MethodType,
+                types.BuiltinMethodType,
+            ),
+        )
         or (inspect.ismethoddescriptor(runtime) and callable(runtime))
+        or (isinstance(runtime, types.MethodWrapperType) and callable(runtime))
     )
 
 
@@ -1426,7 +1594,29 @@ def is_read_only_property(runtime: object) -> bool:
 
 def safe_inspect_signature(runtime: Any) -> inspect.Signature | None:
     try:
-        return inspect.signature(runtime)
+        try:
+            return inspect.signature(runtime)
+        except ValueError:
+            if (
+                hasattr(runtime, "__text_signature__")
+                and "<unrepresentable>" in runtime.__text_signature__
+            ):
+                # Try to fix up the signature. Workaround for
+                # https://github.com/python/cpython/issues/87233
+                sig = runtime.__text_signature__.replace("<unrepresentable>", "...")
+                sig = inspect._signature_fromstr(inspect.Signature, runtime, sig)  # type: ignore[attr-defined]
+                assert isinstance(sig, inspect.Signature)
+                new_params = [
+                    (
+                        parameter.replace(default=UNREPRESENTABLE)
+                        if parameter.default is ...
+                        else parameter
+                    )
+                    for parameter in sig.parameters.values()
+                ]
+                return sig.replace(parameters=new_params)
+            else:
+                raise
     except Exception:
         # inspect.signature throws ValueError all the time
         # catch RuntimeError because of https://bugs.python.org/issue39504
@@ -1435,6 +1625,10 @@ def safe_inspect_signature(runtime: Any) -> inspect.Signature | None:
         return None
 
 
+def describe_runtime_callable(signature: inspect.Signature, *, is_async: bool) -> str:
+    return f'{"async " if is_async else ""}def {signature}'
+
+
 def is_subtype_helper(left: mypy.types.Type, right: mypy.types.Type) -> bool:
     """Checks whether ``left`` is a subtype of ``right``."""
     left = mypy.types.get_proper_type(left)
@@ -1492,13 +1686,13 @@ def anytype() -> mypy.types.AnyType:
                 arg_names.append(
                     None if arg.kind == inspect.Parameter.POSITIONAL_ONLY else arg.name
                 )
-                has_default = arg.default == inspect.Parameter.empty
+                no_default = arg.default is inspect.Parameter.empty
                 if arg.kind == inspect.Parameter.POSITIONAL_ONLY:
-                    arg_kinds.append(nodes.ARG_POS if has_default else nodes.ARG_OPT)
+                    arg_kinds.append(nodes.ARG_POS if no_default else nodes.ARG_OPT)
                 elif arg.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
-                    arg_kinds.append(nodes.ARG_POS if has_default else nodes.ARG_OPT)
+                    arg_kinds.append(nodes.ARG_POS if no_default else nodes.ARG_OPT)
                 elif arg.kind == inspect.Parameter.KEYWORD_ONLY:
-                    arg_kinds.append(nodes.ARG_NAMED if has_default else nodes.ARG_NAMED_OPT)
+                    arg_kinds.append(nodes.ARG_NAMED if no_default else nodes.ARG_NAMED_OPT)
                 elif arg.kind == inspect.Parameter.VAR_POSITIONAL:
                     arg_kinds.append(nodes.ARG_STAR)
                 elif arg.kind == inspect.Parameter.VAR_KEYWORD:
@@ -1542,10 +1736,10 @@ def anytype() -> mypy.types.AnyType:
     fallback = mypy.types.Instance(type_info, [anytype() for _ in type_info.type_vars])
 
     value: bool | int | str
-    if isinstance(runtime, bytes):
-        value = bytes_to_human_readable_repr(runtime)
-    elif isinstance(runtime, enum.Enum):
+    if isinstance(runtime, enum.Enum) and isinstance(runtime.name, str):
         value = runtime.name
+    elif isinstance(runtime, bytes):
+        value = bytes_to_human_readable_repr(runtime)
     elif isinstance(runtime, (bool, int, str)):
         value = runtime
     else:
@@ -1630,7 +1824,7 @@ def get_stub(module: str) -> nodes.MypyFile | None:
 
 def get_typeshed_stdlib_modules(
     custom_typeshed_dir: str | None, version_info: tuple[int, int] | None = None
-) -> list[str]:
+) -> set[str]:
     """Returns a list of stdlib modules in typeshed (for current Python version)."""
     stdlib_py_versions = mypy.modulefinder.load_stdlib_py_versions(custom_typeshed_dir)
     if version_info is None:
@@ -1652,14 +1846,91 @@ def exists_in_version(module: str) -> bool:
         typeshed_dir = Path(mypy.build.default_data_dir()) / "typeshed"
     stdlib_dir = typeshed_dir / "stdlib"
 
-    modules = []
+    modules: set[str] = set()
     for path in stdlib_dir.rglob("*.pyi"):
         if path.stem == "__init__":
             path = path.parent
         module = ".".join(path.relative_to(stdlib_dir).parts[:-1] + (path.stem,))
         if exists_in_version(module):
-            modules.append(module)
-    return sorted(modules)
+            modules.add(module)
+    return modules
+
+
+def get_importable_stdlib_modules() -> set[str]:
+    """Return all importable stdlib modules at runtime."""
+    all_stdlib_modules: AbstractSet[str]
+    if sys.version_info >= (3, 10):
+        all_stdlib_modules = sys.stdlib_module_names
+    else:
+        all_stdlib_modules = set(sys.builtin_module_names)
+        modules_by_finder: defaultdict[importlib.machinery.FileFinder, set[str]] = defaultdict(set)
+        for m in pkgutil.iter_modules():
+            if isinstance(m.module_finder, importlib.machinery.FileFinder):
+                modules_by_finder[m.module_finder].add(m.name)
+        for finder, module_group in modules_by_finder.items():
+            if (
+                "site-packages" not in Path(finder.path).parts
+                # if "_queue" is present, it's most likely the module finder
+                # for stdlib extension modules;
+                # if "queue" is present, it's most likely the module finder
+                # for pure-Python stdlib modules.
+                # In either case, we'll want to add all the modules that the finder has to offer us.
+                # This is a bit hacky, but seems to work well in a cross-platform way.
+                and {"_queue", "queue"} & module_group
+            ):
+                all_stdlib_modules.update(module_group)
+
+    importable_stdlib_modules: set[str] = set()
+    for module_name in all_stdlib_modules:
+        if module_name in ANNOYING_STDLIB_MODULES:
+            continue
+
+        try:
+            runtime = silent_import_module(module_name)
+        except ImportError:
+            continue
+        else:
+            importable_stdlib_modules.add(module_name)
+
+        try:
+            # some stdlib modules (e.g. `nt`) don't have __path__ set...
+            runtime_path = runtime.__path__
+            runtime_name = runtime.__name__
+        except AttributeError:
+            continue
+
+        for submodule in pkgutil.walk_packages(runtime_path, runtime_name + "."):
+            submodule_name = submodule.name
+
+            # There are many annoying *.__main__ stdlib modules,
+            # and including stubs for them isn't really that useful anyway:
+            # tkinter.__main__ opens a tkinter windows; unittest.__main__ raises SystemExit; etc.
+            #
+            # The idlelib.* submodules are similarly annoying in opening random tkinter windows,
+            # and we're unlikely to ever add stubs for idlelib in typeshed
+            # (see discussion in https://github.com/python/typeshed/pull/9193)
+            #
+            # test.* modules do weird things like raising exceptions in __del__ methods,
+            # leading to unraisable exceptions being logged to the terminal
+            # as a warning at the end of the stubtest run
+            if submodule_name.endswith(".__main__") or submodule_name.startswith(
+                ("idlelib.", "test.")
+            ):
+                continue
+
+            try:
+                silent_import_module(submodule_name)
+            except KeyboardInterrupt:
+                raise
+            # importing multiprocessing.popen_forkserver on Windows raises AttributeError...
+            # some submodules also appear to raise SystemExit as well on some Python versions
+            # (not sure exactly which)
+            except BaseException:
+                continue
+            else:
+                importable_stdlib_modules.add(submodule_name)
+
+    return importable_stdlib_modules
 
 
 def get_allowlist_entries(allowlist_file: str) -> Iterator[str]:
@@ -1684,10 +1955,16 @@ class _Arguments:
     allowlist: list[str]
     generate_allowlist: bool
     ignore_unused_allowlist: bool
-    mypy_config_file: str
-    custom_typeshed_dir: str
+    mypy_config_file: str | None
+    custom_typeshed_dir: str | None
     check_typeshed: bool
     version: str
+    show_traceback: bool
+    pdb: bool
+
+
+# typeshed added a stub for __main__, but that causes stubtest to check itself
+ANNOYING_STDLIB_MODULES: Final = frozenset({"antigravity", "this", "__main__", "_ios_support"})
 
 
 def test_stubs(args: _Arguments, use_builtins_fixtures: bool = False) -> int:
@@ -1712,10 +1989,9 @@ def test_stubs(args: _Arguments, use_builtins_fixtures: bool = False) -> int:
                 "cannot pass both --check-typeshed and a list of modules",
             )
             return 1
-        modules = get_typeshed_stdlib_modules(args.custom_typeshed_dir)
-        # typeshed added a stub for __main__, but that causes stubtest to check itself
-        annoying_modules = {"antigravity", "this", "__main__"}
-        modules = [m for m in modules if m not in annoying_modules]
+        typeshed_modules = get_typeshed_stdlib_modules(args.custom_typeshed_dir)
+        runtime_modules = get_importable_stdlib_modules()
+        modules = sorted((typeshed_modules | runtime_modules) - ANNOYING_STDLIB_MODULES)
 
     if not modules:
         print(_style("error:", color="red", bold=True), "no modules to check")
@@ -1725,9 +2001,11 @@ def test_stubs(args: _Arguments, use_builtins_fixtures: bool = False) -> int:
     options.incremental = False
     options.custom_typeshed_dir = args.custom_typeshed_dir
     if options.custom_typeshed_dir:
-        options.abs_custom_typeshed_dir = os.path.abspath(args.custom_typeshed_dir)
+        options.abs_custom_typeshed_dir = os.path.abspath(options.custom_typeshed_dir)
     options.config_file = args.mypy_config_file
     options.use_builtins_fixtures = use_builtins_fixtures
+    options.show_traceback = args.show_traceback
+    options.pdb = args.pdb
 
     if options.config_file:
 
@@ -1736,6 +2014,19 @@ def set_strict_flags() -> None:  # not needed yet
 
         parse_config_file(options, set_strict_flags, options.config_file, sys.stdout, sys.stderr)
 
+    def error_callback(msg: str) -> typing.NoReturn:
+        print(_style("error:", color="red", bold=True), msg)
+        sys.exit(1)
+
+    def warning_callback(msg: str) -> None:
+        print(_style("warning:", color="yellow", bold=True), msg)
+
+    options.process_error_codes(error_callback=error_callback)
+    options.process_incomplete_features(
+        error_callback=error_callback, warning_callback=warning_callback
+    )
+    options.process_strict_bytes()
+
     try:
         modules = build_stubs(modules, options, find_submodules=not args.check_typeshed)
     except StubtestFailure as stubtest_failure:
@@ -1815,6 +2106,8 @@ def parse_options(args: list[str]) -> _Arguments:
     parser = argparse.ArgumentParser(
         description="Compares stubs to objects introspected from the runtime."
     )
+    if sys.version_info >= (3, 14):
+        parser.color = True  # Set as init arg in 3.14
     parser.add_argument("modules", nargs="*", help="Modules to test")
     parser.add_argument(
         "--concise",
@@ -1869,6 +2162,10 @@ def parse_options(args: list[str]) -> _Arguments:
     parser.add_argument(
         "--version", action="version", version="%(prog)s " + mypy.version.__version__
     )
+    parser.add_argument("--pdb", action="store_true", help="Invoke pdb on fatal error")
+    parser.add_argument(
+        "--show-traceback", "--tb", action="store_true", help="Show traceback on fatal error"
+    )
 
     return parser.parse_args(args, namespace=_Arguments())
 
diff --git a/mypy/stubutil.py b/mypy/stubutil.py
index e15766b66cb3..fecd9b29d57d 100644
--- a/mypy/stubutil.py
+++ b/mypy/stubutil.py
@@ -5,19 +5,57 @@
 import os.path
 import re
 import sys
+import traceback
+from abc import abstractmethod
+from collections import defaultdict
+from collections.abc import Iterable, Iterator, Mapping
 from contextlib import contextmanager
-from typing import Iterator
-from typing_extensions import overload
+from typing import Final, overload
 
+from mypy_extensions import mypyc_attr
+
+import mypy.options
 from mypy.modulefinder import ModuleNotFoundReason
 from mypy.moduleinspect import InspectError, ModuleInspect
+from mypy.nodes import PARAM_SPEC_KIND, TYPE_VAR_TUPLE_KIND, ClassDef, FuncDef, TypeAliasStmt
+from mypy.stubdoc import ArgSig, FunctionSig
+from mypy.types import (
+    AnyType,
+    NoneType,
+    Type,
+    TypeList,
+    TypeStrVisitor,
+    UnboundType,
+    UnionType,
+    UnpackType,
+)
 
 # Modules that may fail when imported, or that may have side effects (fully qualified).
 NOT_IMPORTABLE_MODULES = ()
 
+# Typing constructs to be replaced by their builtin equivalents.
+TYPING_BUILTIN_REPLACEMENTS: Final = {
+    # From typing
+    "typing.Text": "builtins.str",
+    "typing.Tuple": "builtins.tuple",
+    "typing.List": "builtins.list",
+    "typing.Dict": "builtins.dict",
+    "typing.Set": "builtins.set",
+    "typing.FrozenSet": "builtins.frozenset",
+    "typing.Type": "builtins.type",
+    # From typing_extensions
+    "typing_extensions.Text": "builtins.str",
+    "typing_extensions.Tuple": "builtins.tuple",
+    "typing_extensions.List": "builtins.list",
+    "typing_extensions.Dict": "builtins.dict",
+    "typing_extensions.Set": "builtins.set",
+    "typing_extensions.FrozenSet": "builtins.frozenset",
+    "typing_extensions.Type": "builtins.type",
+}
+
 
 class CantImport(Exception):
-    def __init__(self, module: str, message: str):
+    def __init__(self, module: str, message: str) -> None:
         self.module = module
         self.message = message
 
@@ -42,6 +80,9 @@ def walk_packages(
         try:
             prop = inspect.get_package_properties(package_name)
         except InspectError:
+            if verbose:
+                tb = traceback.format_exc()
+                sys.stderr.write(tb)
             report_missing(package_name)
             continue
         yield prop.name
@@ -70,8 +111,9 @@ def find_module_path_and_all_py3(
 ) -> tuple[str | None, list[str] | None] | None:
     """Find module and determine __all__ for a Python 3 module.
 
-    Return None if the module is a C module. Return (module_path, __all__) if
-    it is a Python module. Raise CantImport if import failed.
+    Return None if the module is a C or pyc-only module.
+    Return (module_path, __all__) if it is a Python module.
+    Raise CantImport if import failed.
     """
     if module in NOT_IMPORTABLE_MODULES:
         raise CantImport(module, "")
@@ -132,13 +174,11 @@ def fail_missing(mod: str, reason: ModuleNotFoundReason) -> None:
 
 
 @overload
-def remove_misplaced_type_comments(source: bytes) -> bytes:
-    ...
+def remove_misplaced_type_comments(source: bytes) -> bytes: ...
 
 
 @overload
-def remove_misplaced_type_comments(source: str) -> str:
-    ...
+def remove_misplaced_type_comments(source: str) -> str: ...
 
 
 def remove_misplaced_type_comments(source: str | bytes) -> str | bytes:
@@ -182,3 +222,673 @@ def common_dir_prefix(paths: list[str]) -> str:
                 cur = path
                 break
     return cur or "."
+
+
+class AnnotationPrinter(TypeStrVisitor):
+    """Visitor used to print existing annotations in a file.
+
+    The main difference from TypeStrVisitor is a better treatment of
+    unbound types.
+
+    Notes:
+    * This visitor doesn't add imports necessary for annotations, this is done separately
+      by ImportTracker.
+    * It can print all kinds of types, but the generated strings may not be valid (notably
+      callable types) since it prints the same string that reveal_type() does.
+    * For Instance types it prints the fully qualified names.
+    """
+
+    # TODO: Generate valid string representation for callable types.
+    # TODO: Use short names for Instances.
+    def __init__(
+        self,
+        stubgen: BaseStubGenerator,
+        known_modules: list[str] | None = None,
+        local_modules: list[str] | None = None,
+    ) -> None:
+        super().__init__(options=mypy.options.Options())
+        self.stubgen = stubgen
+        self.known_modules = known_modules
+        self.local_modules = local_modules or ["builtins"]
+
+    def visit_any(self, t: AnyType) -> str:
+        s = super().visit_any(t)
+        self.stubgen.import_tracker.require_name(s)
+        return s
+
+    def visit_unbound_type(self, t: UnboundType) -> str:
+        s = t.name
+        fullname = self.stubgen.resolve_name(s)
+        if fullname == "typing.Union":
+            return " | ".join([item.accept(self) for item in t.args])
+        if fullname == "typing.Optional":
+            if len(t.args) == 1:
+                return f"{t.args[0].accept(self)} | None"
+            return self.stubgen.add_name("_typeshed.Incomplete")
+        if fullname in TYPING_BUILTIN_REPLACEMENTS:
+            s = self.stubgen.add_name(TYPING_BUILTIN_REPLACEMENTS[fullname], require=True)
+        if self.known_modules is not None and "." in s:
+            # see if this object is from any of the modules that we're currently processing.
+            # reverse sort so that subpackages come before parents: e.g. "foo.bar" before "foo".
+            for module_name in self.local_modules + sorted(self.known_modules, reverse=True):
+                if s.startswith(module_name + "."):
+                    if module_name in self.local_modules:
+                        s = s[len(module_name) + 1 :]
+                    arg_module = module_name
+                    break
+            else:
+                arg_module = s[: s.rindex(".")]
+            if arg_module not in self.local_modules:
+                self.stubgen.import_tracker.add_import(arg_module, require=True)
+        elif s == "NoneType":
+            # when called without analysis all types are unbound, so this won't hit
+            # visit_none_type().
+            s = "None"
+        else:
+            self.stubgen.import_tracker.require_name(s)
+        if t.args:
+            s += f"[{self.args_str(t.args)}]"
+        elif t.empty_tuple_index:
+            s += "[()]"
+        return s
+
+    def visit_none_type(self, t: NoneType) -> str:
+        return "None"
+
+    def visit_type_list(self, t: TypeList) -> str:
+        return f"[{self.list_str(t.items)}]"
+
+    def visit_union_type(self, t: UnionType) -> str:
+        return " | ".join([item.accept(self) for item in t.items])
+
+    def visit_unpack_type(self, t: UnpackType) -> str:
+        if self.options.python_version >= (3, 11):
+            return f"*{t.type.accept(self)}"
+        return super().visit_unpack_type(t)
+
+    def args_str(self, args: Iterable[Type]) -> str:
+        """Convert an array of arguments to strings and join the results with commas.
+
+        The main difference from list_str is the preservation of quotes for string
+        arguments
+        """
+        types = ["builtins.bytes", "builtins.str"]
+        res = []
+        for arg in args:
+            arg_str = arg.accept(self)
+            if isinstance(arg, UnboundType) and arg.original_str_fallback in types:
+                res.append(f"'{arg_str}'")
+            else:
+                res.append(arg_str)
+        return ", ".join(res)
+
+
+class ClassInfo:
+    def __init__(
+        self,
+        name: str,
+        self_var: str,
+        docstring: str | None = None,
+        cls: type | None = None,
+        parent: ClassInfo | None = None,
+    ) -> None:
+        self.name = name
+        self.self_var = self_var
+        self.docstring = docstring
+        self.cls = cls
+        self.parent = parent
+
+
+class FunctionContext:
+    def __init__(
+        self,
+        module_name: str,
+        name: str,
+        docstring: str | None = None,
+        is_abstract: bool = False,
+        class_info: ClassInfo | None = None,
+    ) -> None:
+        self.module_name = module_name
+        self.name = name
+        self.docstring = docstring
+        self.is_abstract = is_abstract
+        self.class_info = class_info
+        self._fullname: str | None = None
+
+    @property
+    def fullname(self) -> str:
+        if self._fullname is None:
+            if self.class_info:
+                parents = []
+                class_info: ClassInfo | None = self.class_info
+                while class_info is not None:
+                    parents.append(class_info.name)
+                    class_info = class_info.parent
+                namespace = ".".join(reversed(parents))
+                self._fullname = f"{self.module_name}.{namespace}.{self.name}"
+            else:
+                self._fullname = f"{self.module_name}.{self.name}"
+        return self._fullname
+
+
+def infer_method_ret_type(name: str) -> str | None:
+    """Infer return types for known special methods"""
+    if name.startswith("__") and name.endswith("__"):
+        name = name[2:-2]
+        if name in ("float", "bool", "bytes", "int", "complex", "str"):
+            return name
+        # Note: __eq__ and co may return arbitrary types, but bool is good enough for stubgen.
+        elif name in ("eq", "ne", "lt", "le", "gt", "ge", "contains"):
+            return "bool"
+        elif name in ("len", "length_hint", "index", "hash", "sizeof", "trunc", "floor", "ceil"):
+            return "int"
+        elif name in ("format", "repr"):
+            return "str"
+        elif name in ("init", "setitem", "del", "delitem"):
+            return "None"
+    return None
+
+
+def infer_method_arg_types(
+    name: str, self_var: str = "self", arg_names: list[str] | None = None
+) -> list[ArgSig] | None:
+    """Infer argument types for known special methods"""
+    args: list[ArgSig] | None = None
+    if name.startswith("__") and name.endswith("__"):
+        if arg_names and len(arg_names) >= 1 and arg_names[0] == "self":
+            arg_names = arg_names[1:]
+
+        name = name[2:-2]
+        if name == "exit":
+            if arg_names is None:
+                arg_names = ["type", "value", "traceback"]
+            if len(arg_names) == 3:
+                arg_types = [
+                    "type[BaseException] | None",
+                    "BaseException | None",
+                    "types.TracebackType | None",
+                ]
+                args = [
+                    ArgSig(name=arg_name, type=arg_type)
+                    for arg_name, arg_type in zip(arg_names, arg_types)
+                ]
+    if args is not None:
+        return [ArgSig(name=self_var)] + args
+    return None
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class SignatureGenerator:
+    """Abstract base class for extracting a list of FunctionSigs for each function."""
+
+    def remove_self_type(
+        self, inferred: list[FunctionSig] | None, self_var: str
+    ) -> list[FunctionSig] | None:
+        """Remove type annotation from self/cls argument"""
+        if inferred:
+            for signature in inferred:
+                if signature.args:
+                    if signature.args[0].name == self_var:
+                        signature.args[0].type = None
+        return inferred
+
+    @abstractmethod
+    def get_function_sig(
+        self, default_sig: FunctionSig, ctx: FunctionContext
+    ) -> list[FunctionSig] | None:
+        """Return a list of signatures for the given function.
+
+        If no signature can be found, return None. If all of the registered SignatureGenerators
+        for the stub generator return None, then the default_sig will be used.
+        """
+        pass
+
+    @abstractmethod
+    def get_property_type(self, default_type: str | None, ctx: FunctionContext) -> str | None:
+        """Return the type of the given property"""
+        pass
+
+
+class ImportTracker:
+    """Record necessary imports during stub generation."""
+
+    def __init__(self) -> None:
+        # module_for['foo'] has the module name where 'foo' was imported from, or None if
+        # 'foo' is a module imported directly;
+        # direct_imports['foo'] is the module path used when the name 'foo' was added to the
+        # namespace.
+        # reverse_alias['foo'] is the name that 'foo' had originally when imported with an
+        # alias; examples
+        #     'from pkg import mod'      ==> module_for['mod'] == 'pkg'
+        #     'from pkg import mod as m' ==> module_for['m'] == 'pkg'
+        #                                ==> reverse_alias['m'] == 'mod'
+        #     'import pkg.mod as m'      ==> module_for['m'] == None
+        #                                ==> reverse_alias['m'] == 'pkg.mod'
+        #     'import pkg.mod'           ==> module_for['pkg'] == None
+        #                                ==> module_for['pkg.mod'] == None
+        #                                ==> direct_imports['pkg'] == 'pkg.mod'
+        #                                ==> direct_imports['pkg.mod'] == 'pkg.mod'
+        self.module_for: dict[str, str | None] = {}
+        self.direct_imports: dict[str, str] = {}
+        self.reverse_alias: dict[str, str] = {}
+
+        # required_names is the set of names that are actually used in a type annotation
+        self.required_names: set[str] = set()
+
+        # Names that should be reexported if they come from another module
+        self.reexports: set[str] = set()
+
+    def add_import_from(
+        self, module: str, names: list[tuple[str, str | None]], require: bool = False
+    ) -> None:
+        for name, alias in names:
+            if alias:
+                # 'from {module} import {name} as {alias}'
+                self.module_for[alias] = module
+                self.reverse_alias[alias] = name
+            else:
+                # 'from {module} import {name}'
+                self.module_for[name] = module
+                self.reverse_alias.pop(name, None)
+            if require:
+                self.require_name(alias or name)
+            self.direct_imports.pop(alias or name, None)
+
+    def add_import(self, module: str, alias: str | None = None, require: bool = False) -> None:
+        if alias:
+            # 'import {module} as {alias}'
+            assert "." not in alias  # invalid syntax
+            self.module_for[alias] = None
+            self.reverse_alias[alias] = module
+            if require:
+                self.required_names.add(alias)
+        else:
+            # 'import {module}'
+            name = module
+            if require:
+                self.required_names.add(name)
+            # add module and its parent packages
+            while name:
+                self.module_for[name] = None
+                self.direct_imports[name] = module
+                self.reverse_alias.pop(name, None)
+                name = name.rpartition(".")[0]
+
+    def require_name(self, name: str) -> None:
+        while name not in self.direct_imports and "." in name:
+            name = name.rsplit(".", 1)[0]
+        self.required_names.add(name)
+
+    def reexport(self, name: str) -> None:
+        """Mark a given non qualified name as needed in __all__.
+
+        This means that in case it comes from a module, it should be
+        imported with an alias even if the alias is the same as the name.
+        """
+        self.require_name(name)
+        self.reexports.add(name)
+
+    def import_lines(self) -> list[str]:
+        """The list of required import lines (as strings with python code).
+
+        In order for a module be included in this output, an identifier must be both
+        'required' via require_name() and 'imported' via add_import_from()
+        or add_import()
+        """
+        result = []
+
+        # To summarize multiple names imported from a same module, we collect those
+        # in the `module_map` dictionary, mapping a module path to the list of names that should
+        # be imported from it. the names can also be alias in the form 'original as alias'
+        module_map: Mapping[str, list[str]] = defaultdict(list)
+
+        for name in sorted(
+            self.required_names,
+            key=lambda n: (self.reverse_alias[n], n) if n in self.reverse_alias else (n, ""),
+        ):
+            # If we haven't seen this name in an import statement, ignore it
+            if name not in self.module_for:
+                continue
+
+            m = self.module_for[name]
+            if m is not None:
+                # This name was found in a from ... import ...
+                # Collect the name in the module_map
+                if name in self.reverse_alias:
+                    name = f"{self.reverse_alias[name]} as {name}"
+                elif name in self.reexports:
+                    name = f"{name} as {name}"
+                module_map[m].append(name)
+            else:
+                # This name was found in an import ...
+                # We can already generate the import line
+                if name in self.reverse_alias:
+                    source = self.reverse_alias[name]
+                    result.append(f"import {source} as {name}\n")
+                elif name in self.reexports:
+                    assert "." not in name  # Because reexports only has nonqualified names
+                    result.append(f"import {name} as {name}\n")
+                else:
+                    result.append(f"import {name}\n")
+
+        # Now generate all the from ... import ... lines collected in module_map
+        for module, names in sorted(module_map.items()):
+            result.append(f"from {module} import {', '.join(sorted(names))}\n")
+        return result
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class BaseStubGenerator:
+    # These names should be omitted from generated stubs.
+    IGNORED_DUNDERS: Final = {
+        "__all__",
+        "__author__",
+        "__about__",
+        "__copyright__",
+        "__email__",
+        "__license__",
+        "__summary__",
+        "__title__",
+        "__uri__",
+        "__str__",
+        "__repr__",
+        "__getstate__",
+        "__setstate__",
+        "__slots__",
+        "__builtins__",
+        "__cached__",
+        "__file__",
+        "__name__",
+        "__package__",
+        "__path__",
+        "__spec__",
+        "__loader__",
+    }
+    TYPING_MODULE_NAMES: Final = ("typing", "typing_extensions")
+    # Special-cased names that are implicitly exported from the stub (from m import y as y).
+    EXTRA_EXPORTED: Final = {
+        "pyasn1_modules.rfc2437.univ",
+        "pyasn1_modules.rfc2459.char",
+        "pyasn1_modules.rfc2459.univ",
+    }
+
+    def __init__(
+        self,
+        _all_: list[str] | None = None,
+        include_private: bool = False,
+        export_less: bool = False,
+        include_docstrings: bool = False,
+    ) -> None:
+        # Best known value of __all__.
+        self._all_ = _all_
+        self._include_private = include_private
+        self._include_docstrings = include_docstrings
+        # Disable implicit exports of package-internal imports?
+        self.export_less = export_less
+        self._import_lines: list[str] = []
+        self._output: list[str] = []
+        # Current indent level (indent is hardcoded to 4 spaces).
+        self._indent = ""
+        self._toplevel_names: list[str] = []
+        self.import_tracker = ImportTracker()
+        # Top-level members
+        self.defined_names: set[str] = set()
+        self.sig_generators = self.get_sig_generators()
+        # populated by visit_mypy_file
+        self.module_name: str = ""
+        # These are "soft" imports for objects which might appear in annotations but not have
+        # a corresponding import statement.
+        self.known_imports = {
+            "_typeshed": ["Incomplete"],
+            "typing": ["Any", "TypeVar", "NamedTuple", "TypedDict"],
+            "collections.abc": ["Generator"],
+            "typing_extensions": ["ParamSpec", "TypeVarTuple"],
+        }
+
+    def get_sig_generators(self) -> list[SignatureGenerator]:
+        return []
+
+    def resolve_name(self, name: str) -> str:
+        """Return the full name resolving imports and import aliases."""
+        if "." not in name:
+            real_module = self.import_tracker.module_for.get(name)
+            real_short = self.import_tracker.reverse_alias.get(name, name)
+            if real_module is None and real_short not in self.defined_names:
+                real_module = "builtins"  # not imported and not defined, must be a builtin
+        else:
+            name_module, real_short = name.split(".", 1)
+            real_module = self.import_tracker.reverse_alias.get(name_module, name_module)
+        resolved_name = real_short if real_module is None else f"{real_module}.{real_short}"
+        return resolved_name
+
+    def add_name(self, fullname: str, require: bool = True) -> str:
+        """Add a name to be imported and return the name reference.
+
+        The import will be internal to the stub (i.e don't reexport).
+        """
+        module, name = fullname.rsplit(".", 1)
+        alias = "_" + name if name in self.defined_names else None
+        while alias in self.defined_names:
+            alias = "_" + alias
+        if module != "builtins" or alias:  # don't import from builtins unless needed
+            self.import_tracker.add_import_from(module, [(name, alias)], require=require)
+        return alias or name
+
+    def add_import_line(self, line: str) -> None:
+        """Add a line of text to the import section, unless it's already there."""
+        if line not in self._import_lines:
+            self._import_lines.append(line)
+
+    def get_imports(self) -> str:
+        """Return the import statements for the stub."""
+        imports = ""
+        if self._import_lines:
+            imports += "".join(self._import_lines)
+        imports += "".join(self.import_tracker.import_lines())
+        return imports
+
+    def output(self) -> str:
+        """Return the text for the stub."""
+        pieces: list[str] = []
+        if imports := self.get_imports():
+            pieces.append(imports)
+        if dunder_all := self.get_dunder_all():
+            pieces.append(dunder_all)
+        if self._output:
+            pieces.append("".join(self._output))
+        return "\n".join(pieces)
+
+    def get_dunder_all(self) -> str:
+        """Return the __all__ list for the stub."""
+        if self._all_:
+            # Note we emit all names in the runtime __all__ here, even if they
+            # don't actually exist. If that happens, the runtime has a bug, and
+            # it's not obvious what the correct behavior should be. We choose
+            # to reflect the runtime __all__ as closely as possible.
+            return f"__all__ = {self._all_!r}\n"
+        return ""
+
+    def add(self, string: str) -> None:
+        """Add text to generated stub."""
+        self._output.append(string)
+
+    def is_top_level(self) -> bool:
+        """Are we processing the top level of a file?"""
+        return self._indent == ""
+
+    def indent(self) -> None:
+        """Add one level of indentation."""
+        self._indent += "    "
+
+    def dedent(self) -> None:
+        """Remove one level of indentation."""
+        self._indent = self._indent[:-4]
+
+    def record_name(self, name: str) -> None:
+        """Mark a name as defined.
+
+        This only does anything if at the top level of a module.
+        """
+        if self.is_top_level():
+            self._toplevel_names.append(name)
+
+    def is_recorded_name(self, name: str) -> bool:
+        """Has this name been recorded previously?"""
+        return self.is_top_level() and name in self._toplevel_names
+
+    def set_defined_names(self, defined_names: set[str]) -> None:
+        self.defined_names = defined_names
+        # Names in __all__ are required
+        for name in self._all_ or ():
+            self.import_tracker.reexport(name)
+
+        for pkg, imports in self.known_imports.items():
+            for t in imports:
+                # require=False means that the import won't be added unless require_name() is called
+                # for the object during generation.
+                self.add_name(f"{pkg}.{t}", require=False)
+
+    def check_undefined_names(self) -> None:
+        undefined_names = [name for name in self._all_ or [] if name not in self._toplevel_names]
+        if undefined_names:
+            if self._output:
+                self.add("\n")
+            self.add("# Names in __all__ with no definition:\n")
+            for name in sorted(undefined_names):
+                self.add(f"#   {name}\n")
+
+    def get_signatures(
+        self,
+        default_signature: FunctionSig,
+        sig_generators: list[SignatureGenerator],
+        func_ctx: FunctionContext,
+    ) -> list[FunctionSig]:
+        for sig_gen in sig_generators:
+            inferred = sig_gen.get_function_sig(default_signature, func_ctx)
+            if inferred:
+                return inferred
+
+        return [default_signature]
+
+    def get_property_type(
+        self,
+        default_type: str | None,
+        sig_generators: list[SignatureGenerator],
+        func_ctx: FunctionContext,
+    ) -> str | None:
+        for sig_gen in sig_generators:
+            inferred = sig_gen.get_property_type(default_type, func_ctx)
+            if inferred:
+                return inferred
+
+        return default_type
+
+    def format_func_def(
+        self,
+        sigs: list[FunctionSig],
+        is_coroutine: bool = False,
+        decorators: list[str] | None = None,
+        docstring: str | None = None,
+    ) -> list[str]:
+        lines: list[str] = []
+        if decorators is None:
+            decorators = []
+
+        for signature in sigs:
+            # dump decorators, just before "def ..."
+            for deco in decorators:
+                lines.append(f"{self._indent}{deco}")
+
+            lines.append(
+                signature.format_sig(
+                    indent=self._indent,
+                    is_async=is_coroutine,
+                    docstring=docstring if self._include_docstrings else None,
+                )
+            )
+        return lines
+
+    def format_type_args(self, o: TypeAliasStmt | FuncDef | ClassDef) -> str:
+        if not o.type_args:
+            return ""
+        p = AnnotationPrinter(self)
+        type_args_list: list[str] = []
+        for type_arg in o.type_args:
+            if type_arg.kind == PARAM_SPEC_KIND:
+                prefix = "**"
+            elif type_arg.kind == TYPE_VAR_TUPLE_KIND:
+                prefix = "*"
+            else:
+                prefix = ""
+            if type_arg.upper_bound:
+                bound_or_values = f": {type_arg.upper_bound.accept(p)}"
+            elif type_arg.values:
+                bound_or_values = f": ({', '.join(v.accept(p) for v in type_arg.values)})"
+            else:
+                bound_or_values = ""
+            if type_arg.default:
+                default = f" = {type_arg.default.accept(p)}"
+            else:
+                default = ""
+            type_args_list.append(f"{prefix}{type_arg.name}{bound_or_values}{default}")
+        return "[" + ", ".join(type_args_list) + "]"
+
+    def print_annotation(
+        self,
+        t: Type,
+        known_modules: list[str] | None = None,
+        local_modules: list[str] | None = None,
+    ) -> str:
+        printer = AnnotationPrinter(self, known_modules, local_modules)
+        return t.accept(printer)
+
+    def is_not_in_all(self, name: str) -> bool:
+        if self.is_private_name(name):
+            return False
+        if self._all_:
+            return self.is_top_level() and name not in self._all_
+        return False
+
+    def is_private_name(self, name: str, fullname: str | None = None) -> bool:
+        if "__mypy-" in name:
+            return True  # Never include mypy generated symbols
+        if self._include_private:
+            return False
+        if fullname in self.EXTRA_EXPORTED:
+            return False
+        if name == "_":
+            return False
+        if not name.startswith("_"):
+            return False
+        if self._all_ and name in self._all_:
+            return False
+        if name.startswith("__") and name.endswith("__"):
+            return name in self.IGNORED_DUNDERS
+        return True
+
+    def should_reexport(self, name: str, full_module: str, name_is_alias: bool) -> bool:
+        if (
+            not name_is_alias
+            and self.module_name
+            and (self.module_name + "." + name) in self.EXTRA_EXPORTED
+        ):
+            # Special case certain names that should be exported, against our general rules.
+            return True
+        if name_is_alias:
+            return False
+        if self.export_less:
+            return False
+        if not self.module_name:
+            return False
+        is_private = self.is_private_name(name, full_module + "." + name)
+        if is_private:
+            return False
+        top_level = full_module.split(".")[0]
+        self_top_level = self.module_name.split(".", 1)[0]
+        if top_level not in (self_top_level, "_" + self_top_level):
+            # Export imports from the same package, since we can't reliably tell whether they
+            # are part of the public API.
+            return False
+        if self._all_:
+            return name in self._all_
+        return True
diff --git a/mypy/subtypes.py b/mypy/subtypes.py
index a3b28a3e24de..84fda7955d75 100644
--- a/mypy/subtypes.py
+++ b/mypy/subtypes.py
@@ -1,14 +1,20 @@
 from __future__ import annotations
 
+from collections.abc import Iterable, Iterator
 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, TypeVar, cast
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.applytype
 import mypy.constraints
 import mypy.typeops
 from mypy.erasetype import erase_type
-from mypy.expandtype import expand_self_type, expand_type_by_instance
+from mypy.expandtype import (
+    expand_self_type,
+    expand_type,
+    expand_type_by_instance,
+    freshen_function_type_vars,
+)
 from mypy.maptype import map_instance_to_supertype
 
 # Circular import; done in the function instead.
@@ -18,6 +24,8 @@
     ARG_STAR2,
     CONTRAVARIANT,
     COVARIANT,
+    INVARIANT,
+    VARIANCE_NOT_READY,
     Decorator,
     FuncBase,
     OverloadedFuncDef,
@@ -58,19 +66,22 @@
     UninhabitedType,
     UnionType,
     UnpackType,
+    find_unpack_in_list,
+    flatten_nested_unions,
     get_proper_type,
     is_named_instance,
+    split_with_prefix_and_suffix,
 )
 from mypy.types_utils import flatten_types
 from mypy.typestate import SubtypeKind, type_state
-from mypy.typevars import fill_typevars_with_any
-from mypy.typevartuples import extract_unpack, fully_split_with_mapped_and_template
+from mypy.typevars import fill_typevars, fill_typevars_with_any
 
 # Flags for detected protocol members
 IS_SETTABLE: Final = 1
 IS_CLASSVAR: Final = 2
 IS_CLASS_OR_STATIC: Final = 3
 IS_VAR: Final = 4
+IS_EXPLICIT_SETTER: Final = 5
 
 TypeParameterChecker: _TypeAlias = Callable[[Type, Type, int, bool, "SubtypeContext"], bool]
 
@@ -84,8 +95,8 @@ def __init__(
         ignore_pos_arg_names: bool = False,
         ignore_declared_variance: bool = False,
         # Supported for both proper and non-proper
+        always_covariant: bool = False,
         ignore_promotions: bool = False,
-        ignore_uninhabited: bool = False,
         # Proper subtype flags
         erase_instances: bool = False,
         keep_erased_types: bool = False,
@@ -94,8 +105,8 @@ def __init__(
         self.ignore_type_params = ignore_type_params
         self.ignore_pos_arg_names = ignore_pos_arg_names
         self.ignore_declared_variance = ignore_declared_variance
+        self.always_covariant = always_covariant
         self.ignore_promotions = ignore_promotions
-        self.ignore_uninhabited = ignore_uninhabited
         self.erase_instances = erase_instances
         self.keep_erased_types = keep_erased_types
         self.options = options
@@ -117,8 +128,8 @@ def is_subtype(
     ignore_type_params: bool = False,
     ignore_pos_arg_names: bool = False,
     ignore_declared_variance: bool = False,
+    always_covariant: bool = False,
     ignore_promotions: bool = False,
-    ignore_uninhabited: bool = False,
     options: Options | None = None,
 ) -> bool:
     """Is 'left' subtype of 'right'?
@@ -137,8 +148,8 @@ def is_subtype(
             ignore_type_params=ignore_type_params,
             ignore_pos_arg_names=ignore_pos_arg_names,
             ignore_declared_variance=ignore_declared_variance,
+            always_covariant=always_covariant,
             ignore_promotions=ignore_promotions,
-            ignore_uninhabited=ignore_uninhabited,
             options=options,
         )
     else:
@@ -147,8 +158,8 @@ def is_subtype(
                 ignore_type_params,
                 ignore_pos_arg_names,
                 ignore_declared_variance,
+                always_covariant,
                 ignore_promotions,
-                ignore_uninhabited,
                 options,
             }
         ), "Don't pass both context and individual flags"
@@ -183,7 +194,6 @@ def is_proper_subtype(
     *,
     subtype_context: SubtypeContext | None = None,
     ignore_promotions: bool = False,
-    ignore_uninhabited: bool = False,
     erase_instances: bool = False,
     keep_erased_types: bool = False,
 ) -> bool:
@@ -199,19 +209,12 @@ def is_proper_subtype(
     if subtype_context is None:
         subtype_context = SubtypeContext(
             ignore_promotions=ignore_promotions,
-            ignore_uninhabited=ignore_uninhabited,
             erase_instances=erase_instances,
             keep_erased_types=keep_erased_types,
         )
     else:
         assert not any(
-            {
-                ignore_promotions,
-                ignore_uninhabited,
-                erase_instances,
-                keep_erased_types,
-                ignore_uninhabited,
-            }
+            {ignore_promotions, erase_instances, keep_erased_types}
         ), "Don't pass both context and individual flags"
     if type_state.is_assumed_proper_subtype(left, right):
         return True
@@ -256,6 +259,18 @@ def is_same_type(
     This means types may have different representation (e.g. an alias, or
     a non-simplified union) but are semantically exchangeable in all contexts.
     """
+    # First, use fast path for some common types. This is performance-critical.
+    if (
+        type(a) is Instance
+        and type(b) is Instance
+        and a.type == b.type
+        and len(a.args) == len(b.args)
+        and a.last_known_value is b.last_known_value
+    ):
+        return all(is_same_type(x, y) for x, y in zip(a.args, b.args))
+    elif isinstance(a, TypeVarType) and isinstance(b, TypeVarType) and a.id == b.id:
+        return True
+
     # Note that using ignore_promotions=True (default) makes types like int and int64
     # considered not the same type (which is the case at runtime).
     # Also Union[bool, int] (if it wasn't simplified before) will be different
@@ -278,7 +293,13 @@ def _is_subtype(
     left = get_proper_type(left)
     right = get_proper_type(right)
 
-    if not proper_subtype and isinstance(right, (AnyType, UnboundType, ErasedType)):
+    # Note: Unpack type should not be a subtype of Any, since it may represent
+    # multiple types. This should always go through the visitor, to check arity.
+    if (
+        not proper_subtype
+        and isinstance(right, (AnyType, UnboundType, ErasedType))
+        and not isinstance(left, UnpackType)
+    ):
         # TODO: should we consider all types proper subtypes of UnboundType and/or
         # ErasedType as we do for non-proper subtyping.
         return True
@@ -307,7 +328,9 @@ def _is_subtype(
             and isinstance(left, Instance)
             and (left.type.is_enum or left.type.fullname == "builtins.bool")
         ):
-            right = UnionType(mypy.typeops.try_contracting_literals_in_union(right.items))
+            right = UnionType(
+                mypy.typeops.try_contracting_literals_in_union(flatten_nested_unions(right.items))
+            )
             if proper_subtype:
                 is_subtype_of_item = any(
                     is_proper_subtype(orig_left, item, subtype_context=subtype_context)
@@ -335,7 +358,16 @@ def _is_subtype(
 def check_type_parameter(
     left: Type, right: Type, variance: int, proper_subtype: bool, subtype_context: SubtypeContext
 ) -> bool:
-    if variance == COVARIANT:
+    # It is safe to consider empty collection literals and similar as covariant, since
+    # such type can't be stored in a variable, see checker.is_valid_inferred_type().
+    if variance == INVARIANT:
+        p_left = get_proper_type(left)
+        if isinstance(p_left, UninhabitedType) and p_left.ambiguous:
+            variance = COVARIANT
+    # If variance hasn't been inferred yet, we are lenient and default to
+    # covariance. This shouldn't happen often, but it's very difficult to
+    # avoid these cases altogether.
+    if variance == COVARIANT or variance == VARIANCE_NOT_READY:
         if proper_subtype:
             return is_proper_subtype(left, right, subtype_context=subtype_context)
         else:
@@ -374,6 +406,7 @@ def build_subtype_kind(subtype_context: SubtypeContext, proper_subtype: bool) ->
             subtype_context.ignore_type_params,
             subtype_context.ignore_pos_arg_names,
             subtype_context.ignore_declared_variance,
+            subtype_context.always_covariant,
             subtype_context.ignore_promotions,
             subtype_context.erase_instances,
             subtype_context.keep_erased_types,
@@ -384,6 +417,9 @@ def _is_subtype(self, left: Type, right: Type) -> bool:
             return is_proper_subtype(left, right, subtype_context=self.subtype_context)
         return is_subtype(left, right, subtype_context=self.subtype_context)
 
+    def _all_subtypes(self, lefts: Iterable[Type], rights: Iterable[Type]) -> bool:
+        return all(self._is_subtype(li, ri) for (li, ri) in zip(lefts, rights))
+
     # visit_x(left) means: is left (which is an instance of X) a subtype of right?
 
     def visit_unbound_type(self, left: UnboundType) -> bool:
@@ -412,11 +448,7 @@ def visit_none_type(self, left: NoneType) -> bool:
             return True
 
     def visit_uninhabited_type(self, left: UninhabitedType) -> bool:
-        # We ignore this for unsafe overload checks, so that and empty list and
-        # a list of int will be considered non-overlapping.
-        if isinstance(self.right, UninhabitedType):
-            return True
-        return not self.subtype_context.ignore_uninhabited
+        return True
 
     def visit_erased_type(self, left: ErasedType) -> bool:
         # This may be encountered during type inference. The result probably doesn't
@@ -437,12 +469,41 @@ def visit_instance(self, left: Instance) -> bool:
         right = self.right
         if isinstance(right, TupleType) and right.partial_fallback.type.is_enum:
             return self._is_subtype(left, mypy.typeops.tuple_fallback(right))
+        if isinstance(right, TupleType):
+            if len(right.items) == 1:
+                # Non-normalized Tuple type (may be left after semantic analysis
+                # because semanal_typearg visitor is not a type translator).
+                item = right.items[0]
+                if isinstance(item, UnpackType):
+                    unpacked = get_proper_type(item.type)
+                    if isinstance(unpacked, Instance):
+                        return self._is_subtype(left, unpacked)
+            if left.type.has_base(right.partial_fallback.type.fullname):
+                if not self.proper_subtype:
+                    # Special cases to consider:
+                    #   * Plain tuple[Any, ...] instance is a subtype of all tuple types.
+                    #   * Foo[*tuple[Any, ...]] (normalized) instance is a subtype of all
+                    #     tuples with fallback to Foo (e.g. for variadic NamedTuples).
+                    mapped = map_instance_to_supertype(left, right.partial_fallback.type)
+                    if is_erased_instance(mapped):
+                        if (
+                            mapped.type.fullname == "builtins.tuple"
+                            or mapped.type.has_type_var_tuple_type
+                        ):
+                            return True
+            return False
+        if isinstance(right, TypeVarTupleType):
+            # tuple[Any, ...] is like Any in the world of tuples (see special case above).
+            if left.type.has_base("builtins.tuple"):
+                mapped = map_instance_to_supertype(left, right.tuple_fallback.type)
+                if isinstance(get_proper_type(mapped.args[0]), AnyType):
+                    return not self.proper_subtype
         if isinstance(right, Instance):
             if type_state.is_cached_subtype_check(self._subtype_kind, left, right):
                 return True
             if type_state.is_cached_negative_subtype_check(self._subtype_kind, left, right):
                 return False
-            if not self.subtype_context.ignore_promotions:
+            if not self.subtype_context.ignore_promotions and not right.type.is_protocol:
                 for base in left.type.mro:
                     if base._promote and any(
                         self._is_subtype(p, self.right) for p in base._promote
@@ -476,120 +537,54 @@ def visit_instance(self, left: Instance) -> bool:
                     t = erased
                 nominal = True
                 if right.type.has_type_var_tuple_type:
-                    assert left.type.type_var_tuple_prefix is not None
-                    assert left.type.type_var_tuple_suffix is not None
+                    # For variadic instances we simply find the correct type argument mappings,
+                    # all the heavy lifting is done by the tuple subtyping.
                     assert right.type.type_var_tuple_prefix is not None
                     assert right.type.type_var_tuple_suffix is not None
-                    split_result = fully_split_with_mapped_and_template(
-                        left.args,
-                        left.type.type_var_tuple_prefix,
-                        left.type.type_var_tuple_suffix,
-                        right.args,
-                        right.type.type_var_tuple_prefix,
-                        right.type.type_var_tuple_suffix,
+                    prefix = right.type.type_var_tuple_prefix
+                    suffix = right.type.type_var_tuple_suffix
+                    tvt = right.type.defn.type_vars[prefix]
+                    assert isinstance(tvt, TypeVarTupleType)
+                    fallback = tvt.tuple_fallback
+                    left_prefix, left_middle, left_suffix = split_with_prefix_and_suffix(
+                        t.args, prefix, suffix
                     )
-                    if split_result is None:
-                        return False
-
-                    (
-                        left_prefix,
-                        left_mprefix,
-                        left_middle,
-                        left_msuffix,
-                        left_suffix,
-                        right_prefix,
-                        right_mprefix,
-                        right_middle,
-                        right_msuffix,
-                        right_suffix,
-                    ) = split_result
-
-                    left_unpacked = extract_unpack(left_middle)
-                    right_unpacked = extract_unpack(right_middle)
-
-                    # Helper for case 2 below so we can treat them the same.
-                    def check_mixed(
-                        unpacked_type: ProperType, compare_to: tuple[Type, ...]
-                    ) -> bool:
-                        if (
-                            isinstance(unpacked_type, Instance)
-                            and unpacked_type.type.fullname == "builtins.tuple"
-                        ):
-                            return all(is_equivalent(l, unpacked_type.args[0]) for l in compare_to)
-                        if isinstance(unpacked_type, TypeVarTupleType):
-                            return False
-                        if isinstance(unpacked_type, AnyType):
-                            return True
-                        if isinstance(unpacked_type, TupleType):
-                            if len(unpacked_type.items) != len(compare_to):
-                                return False
-                            for t1, t2 in zip(unpacked_type.items, compare_to):
-                                if not is_equivalent(t1, t2):
-                                    return False
-                            return True
-                        return False
-
-                    # Case 1: Both are unpacks, in this case we check what is being
-                    # unpacked is the same.
-                    if left_unpacked is not None and right_unpacked is not None:
-                        if not is_equivalent(left_unpacked, right_unpacked):
-                            return False
-
-                    # Case 2: Only one of the types is an unpack. The equivalence
-                    # case is mostly the same but we check some additional
-                    # things when unpacking on the right.
-                    elif left_unpacked is not None and right_unpacked is None:
-                        if not check_mixed(left_unpacked, right_middle):
-                            return False
-                    elif left_unpacked is None and right_unpacked is not None:
-                        if not check_mixed(right_unpacked, left_middle):
-                            return False
-
-                    # Case 3: Neither type is an unpack. In this case we just compare
-                    # the items themselves.
-                    else:
-                        if len(left_middle) != len(right_middle):
-                            return False
-                        for left_t, right_t in zip(left_middle, right_middle):
-                            if not is_equivalent(left_t, right_t):
-                                return False
-
-                    assert len(left_mprefix) == len(right_mprefix)
-                    assert len(left_msuffix) == len(right_msuffix)
-
-                    for left_item, right_item in zip(
-                        left_mprefix + left_msuffix, right_mprefix + right_msuffix
-                    ):
-                        if not is_equivalent(left_item, right_item):
-                            return False
-
-                    left_items = t.args[: right.type.type_var_tuple_prefix]
-                    right_items = right.args[: right.type.type_var_tuple_prefix]
-                    if right.type.type_var_tuple_suffix:
-                        left_items += t.args[-right.type.type_var_tuple_suffix :]
-                        right_items += right.args[-right.type.type_var_tuple_suffix :]
-                    unpack_index = right.type.type_var_tuple_prefix
-                    assert unpack_index is not None
-                    type_params = zip(
-                        left_prefix + left_suffix,
-                        right_prefix + right_suffix,
-                        right.type.defn.type_vars[:unpack_index]
-                        + right.type.defn.type_vars[unpack_index + 1 :],
+                    right_prefix, right_middle, right_suffix = split_with_prefix_and_suffix(
+                        right.args, prefix, suffix
+                    )
+                    left_args = (
+                        left_prefix + (TupleType(list(left_middle), fallback),) + left_suffix
+                    )
+                    right_args = (
+                        right_prefix + (TupleType(list(right_middle), fallback),) + right_suffix
                     )
+                    if not self.proper_subtype and is_erased_instance(t):
+                        return True
+                    if len(left_args) != len(right_args):
+                        return False
+                    type_params = zip(left_args, right_args, right.type.defn.type_vars)
                 else:
                     type_params = zip(t.args, right.args, right.type.defn.type_vars)
                 if not self.subtype_context.ignore_type_params:
+                    tried_infer = False
                     for lefta, righta, tvar in type_params:
                         if isinstance(tvar, TypeVarType):
+                            if tvar.variance == VARIANCE_NOT_READY and not tried_infer:
+                                infer_class_variances(right.type)
+                                tried_infer = True
+                            if (
+                                self.subtype_context.always_covariant
+                                and tvar.variance == INVARIANT
+                            ):
+                                variance = COVARIANT
+                            else:
+                                variance = tvar.variance
                             if not check_type_parameter(
-                                lefta,
-                                righta,
-                                tvar.variance,
-                                self.proper_subtype,
-                                self.subtype_context,
+                                lefta, righta, variance, self.proper_subtype, self.subtype_context
                             ):
                                 nominal = False
                         else:
+                            # TODO: everywhere else ParamSpecs are handled as invariant.
                             if not check_type_parameter(
                                 lefta, righta, COVARIANT, self.proper_subtype, self.subtype_context
                             ):
@@ -600,7 +595,7 @@ def check_mixed(
                     type_state.record_negative_subtype_cache_entry(self._subtype_kind, left, right)
                 return nominal
             if right.type.is_protocol and is_protocol_implementation(
-                left, right, proper_subtype=self.proper_subtype
+                left, right, proper_subtype=self.proper_subtype, options=self.options
             ):
                 return True
             # We record negative cache entry here, and not in the protocol check like we do for
@@ -623,8 +618,8 @@ def check_mixed(
                         return is_named_instance(item, "builtins.object")
         if isinstance(right, LiteralType) and left.last_known_value is not None:
             return self._is_subtype(left.last_known_value, right)
-        if isinstance(right, CallableType):
-            # Special case: Instance can be a subtype of Callable.
+        if isinstance(right, FunctionLike):
+            # Special case: Instance can be a subtype of Callable / Overloaded.
             call = find_member("__call__", left, left, is_operator=True)
             if call:
                 return self._is_subtype(call, right)
@@ -647,7 +642,7 @@ def visit_param_spec(self, left: ParamSpecType) -> bool:
             and right.id == left.id
             and right.flavor == left.flavor
         ):
-            return True
+            return self._is_subtype(left.prefix, right.prefix)
         if isinstance(right, Parameters) and are_trivial_parameters(right):
             return True
         return self._is_subtype(left.upper_bound, self.right)
@@ -655,10 +650,12 @@ def visit_param_spec(self, left: ParamSpecType) -> bool:
     def visit_type_var_tuple(self, left: TypeVarTupleType) -> bool:
         right = self.right
         if isinstance(right, TypeVarTupleType) and right.id == left.id:
-            return True
+            return left.min_len >= right.min_len
         return self._is_subtype(left.upper_bound, self.right)
 
     def visit_unpack_type(self, left: UnpackType) -> bool:
+        # TODO: Ideally we should not need this (since it is not a real type).
+        # Instead callers (upper level types) should handle it when it appears in type list.
         if isinstance(self.right, UnpackType):
             return self._is_subtype(left.type, self.right.type)
         if isinstance(self.right, Instance) and self.right.type.fullname == "builtins.object":
@@ -666,16 +663,17 @@ def visit_unpack_type(self, left: UnpackType) -> bool:
         return False
 
     def visit_parameters(self, left: Parameters) -> bool:
-        if isinstance(self.right, (Parameters, CallableType)):
-            right = self.right
-            if isinstance(right, CallableType):
-                right = right.with_unpacked_kwargs()
+        if isinstance(self.right, Parameters):
             return are_parameters_compatible(
                 left,
-                right,
+                self.right,
                 is_compat=self._is_subtype,
+                # TODO: this should pass the current value, but then couple tests fail.
+                is_proper_subtype=False,
                 ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,
             )
+        elif isinstance(self.right, Instance):
+            return self.right.type.fullname == "builtins.object"
         else:
             return False
 
@@ -685,16 +683,34 @@ def visit_callable_type(self, left: CallableType) -> bool:
             if left.type_guard is not None and right.type_guard is not None:
                 if not self._is_subtype(left.type_guard, right.type_guard):
                     return False
+            elif left.type_is is not None and right.type_is is not None:
+                # For TypeIs we have to check both ways; it is unsafe to pass
+                # a TypeIs[Child] when a TypeIs[Parent] is expected, because
+                # if the narrower returns False, we assume that the narrowed value is
+                # *not* a Parent.
+                if not self._is_subtype(left.type_is, right.type_is) or not self._is_subtype(
+                    right.type_is, left.type_is
+                ):
+                    return False
             elif right.type_guard is not None and left.type_guard is None:
                 # This means that one function has `TypeGuard` and other does not.
                 # They are not compatible. See https://github.com/python/mypy/issues/11307
                 return False
+            elif right.type_is is not None and left.type_is is None:
+                # Similarly, if one function has `TypeIs` and the other does not,
+                # they are not compatible.
+                return False
             return is_callable_compatible(
                 left,
                 right,
                 is_compat=self._is_subtype,
+                is_proper_subtype=self.proper_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 False
+                ),
             )
         elif isinstance(right, Overloaded):
             return all(self._is_subtype(left, item) for item in right.items)
@@ -721,14 +737,6 @@ def visit_callable_type(self, left: CallableType) -> bool:
         elif isinstance(right, TypeType):
             # This is unsound, we don't check the __init__ signature.
             return left.is_type_obj() and self._is_subtype(left.ret_type, right.item)
-        elif isinstance(right, Parameters):
-            # this doesn't check return types.... but is needed for is_equivalent
-            return are_parameters_compatible(
-                left.with_unpacked_kwargs(),
-                right,
-                is_compat=self._is_subtype,
-                ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,
-            )
         else:
             return False
 
@@ -750,59 +758,185 @@ def visit_tuple_type(self, left: TupleType) -> bool:
                     # TODO: We shouldn't need this special case. This is currently needed
                     #       for isinstance(x, tuple), though it's unclear why.
                     return True
-                return all(self._is_subtype(li, iter_type) for li in left.items)
+                for li in left.items:
+                    if isinstance(li, UnpackType):
+                        unpack = get_proper_type(li.type)
+                        if isinstance(unpack, TypeVarTupleType):
+                            unpack = get_proper_type(unpack.upper_bound)
+                        assert (
+                            isinstance(unpack, Instance)
+                            and unpack.type.fullname == "builtins.tuple"
+                        )
+                        li = unpack.args[0]
+                    if not self._is_subtype(li, iter_type):
+                        return False
+                return True
             elif self._is_subtype(left.partial_fallback, right) and self._is_subtype(
                 mypy.typeops.tuple_fallback(left), right
             ):
                 return True
             return False
         elif isinstance(right, TupleType):
+            # If right has a variadic unpack this needs special handling. If there is a TypeVarTuple
+            # unpack, item count must coincide. If the left has variadic unpack but right
+            # doesn't have one, we will fall through to False down the line.
+            if self.variadic_tuple_subtype(left, right):
+                return True
             if len(left.items) != len(right.items):
                 return False
             if any(not self._is_subtype(l, r) for l, r in zip(left.items, right.items)):
                 return False
-            rfallback = mypy.typeops.tuple_fallback(right)
-            if is_named_instance(rfallback, "builtins.tuple"):
+            if is_named_instance(right.partial_fallback, "builtins.tuple"):
                 # No need to verify fallback. This is useful since the calculated fallback
                 # may be inconsistent due to how we calculate joins between unions vs.
                 # non-unions. For example, join(int, str) == object, whereas
                 # join(Union[int, C], Union[str, C]) == Union[int, str, C].
                 return True
-            lfallback = mypy.typeops.tuple_fallback(left)
-            return self._is_subtype(lfallback, rfallback)
+            if is_named_instance(left.partial_fallback, "builtins.tuple"):
+                # Again, no need to verify. At this point we know the right fallback
+                # is a subclass of tuple, so if left is plain tuple, it cannot be a subtype.
+                return False
+            # At this point we know both fallbacks are non-tuple.
+            return self._is_subtype(left.partial_fallback, right.partial_fallback)
         else:
             return False
 
+    def variadic_tuple_subtype(self, left: TupleType, right: TupleType) -> bool:
+        """Check subtyping between two potentially variadic tuples.
+
+        Most non-trivial cases here are due to variadic unpacks like *tuple[X, ...],
+        we handle such unpacks as infinite unions Tuple[()] | Tuple[X] | Tuple[X, X] | ...
+
+        Note: the cases where right is fixed or has *Ts unpack should be handled
+        by the caller.
+        """
+        right_unpack_index = find_unpack_in_list(right.items)
+        if right_unpack_index is None:
+            # This case should be handled by the caller.
+            return False
+        right_unpack = right.items[right_unpack_index]
+        assert isinstance(right_unpack, UnpackType)
+        right_unpacked = get_proper_type(right_unpack.type)
+        if not isinstance(right_unpacked, Instance):
+            # This case should be handled by the caller.
+            return False
+        assert right_unpacked.type.fullname == "builtins.tuple"
+        right_item = right_unpacked.args[0]
+        right_prefix = right_unpack_index
+        right_suffix = len(right.items) - right_prefix - 1
+        left_unpack_index = find_unpack_in_list(left.items)
+        if left_unpack_index is None:
+            # Simple case: left is fixed, simply find correct mapping to the right
+            # (effectively selecting item with matching length from an infinite union).
+            if len(left.items) < right_prefix + right_suffix:
+                return False
+            prefix, middle, suffix = split_with_prefix_and_suffix(
+                tuple(left.items), right_prefix, right_suffix
+            )
+            if not all(
+                self._is_subtype(li, ri) for li, ri in zip(prefix, right.items[:right_prefix])
+            ):
+                return False
+            if right_suffix and not all(
+                self._is_subtype(li, ri) for li, ri in zip(suffix, right.items[-right_suffix:])
+            ):
+                return False
+            return all(self._is_subtype(li, right_item) for li in middle)
+        else:
+            if len(left.items) < len(right.items):
+                # There are some items on the left that will never have a matching length
+                # on the right.
+                return False
+            left_prefix = left_unpack_index
+            left_suffix = len(left.items) - left_prefix - 1
+            left_unpack = left.items[left_unpack_index]
+            assert isinstance(left_unpack, UnpackType)
+            left_unpacked = get_proper_type(left_unpack.type)
+            if not isinstance(left_unpacked, Instance):
+                # *Ts unpack can't be split, except if it is all mapped to Anys or objects.
+                if self.is_top_type(right_item):
+                    right_prefix_types, middle, right_suffix_types = split_with_prefix_and_suffix(
+                        tuple(right.items), left_prefix, left_suffix
+                    )
+                    if not all(
+                        self.is_top_type(ri) or isinstance(ri, UnpackType) for ri in middle
+                    ):
+                        return False
+                    # Also check the tails match as well.
+                    return self._all_subtypes(
+                        left.items[:left_prefix], right_prefix_types
+                    ) and self._all_subtypes(left.items[-left_suffix:], right_suffix_types)
+                return False
+            assert left_unpacked.type.fullname == "builtins.tuple"
+            left_item = left_unpacked.args[0]
+
+            # The most tricky case with two variadic unpacks we handle similar to union
+            # subtyping: *each* item on the left, must be a subtype of *some* item on the right.
+            # For this we first check the "asymptotic case", i.e. that both unpacks a subtypes,
+            # and then check subtyping for all finite overlaps.
+            if not self._is_subtype(left_item, right_item):
+                return False
+            max_overlap = max(0, right_prefix - left_prefix, right_suffix - left_suffix)
+            for overlap in range(max_overlap + 1):
+                repr_items = left.items[:left_prefix] + [left_item] * overlap
+                if left_suffix:
+                    repr_items += left.items[-left_suffix:]
+                left_repr = left.copy_modified(items=repr_items)
+                if not self._is_subtype(left_repr, right):
+                    return False
+            return True
+
+    def is_top_type(self, typ: Type) -> bool:
+        if not self.proper_subtype and isinstance(get_proper_type(typ), AnyType):
+            return True
+        return is_named_instance(typ, "builtins.object")
+
     def visit_typeddict_type(self, left: TypedDictType) -> bool:
         right = self.right
         if isinstance(right, Instance):
             return self._is_subtype(left.fallback, right)
         elif isinstance(right, TypedDictType):
+            if left == right:
+                return True  # Fast path
             if not left.names_are_wider_than(right):
                 return False
             for name, l, r in left.zip(right):
                 # TODO: should we pass on the full subtype_context here and below?
-                if self.proper_subtype:
-                    check = is_same_type(l, r)
+                right_readonly = name in right.readonly_keys
+                if not right_readonly:
+                    if self.proper_subtype:
+                        check = is_same_type(l, r)
+                    else:
+                        check = is_equivalent(
+                            l,
+                            r,
+                            ignore_type_params=self.subtype_context.ignore_type_params,
+                            options=self.options,
+                        )
                 else:
-                    check = is_equivalent(
-                        l,
-                        r,
-                        ignore_type_params=self.subtype_context.ignore_type_params,
-                        options=self.options,
-                    )
+                    # Read-only items behave covariantly
+                    check = self._is_subtype(l, r)
                 if not check:
                     return False
                 # Non-required key is not compatible with a required key since
                 # indexing may fail unexpectedly if a required key is missing.
-                # Required key is not compatible with a non-required key since
-                # the prior doesn't support 'del' but the latter should support
-                # it.
+                # Required key is not compatible with a non-read-only non-required
+                # key since the prior doesn't support 'del' but the latter should
+                # support it.
+                # Required key is compatible with a read-only non-required key.
+                required_differ = (name in left.required_keys) != (name in right.required_keys)
+                if not right_readonly and required_differ:
+                    return False
+                # Readonly fields check:
                 #
-                # NOTE: 'del' support is currently not implemented (#3550). We
-                #       don't want to have to change subtyping after 'del' support
-                #       lands so here we are anticipating that change.
-                if (name in left.required_keys) != (name in right.required_keys):
+                # A = TypedDict('A', {'x': ReadOnly[int]})
+                # B = TypedDict('B', {'x': int})
+                # def reset_x(b: B) -> None:
+                #     b['x'] = 0
+                #
+                # So, `A` cannot be a subtype of `B`, while `B` can be a subtype of `A`,
+                # because you can use `B` everywhere you use `A`, but not the other way around.
+                if name in left.readonly_keys and name not in right.readonly_keys:
                     return False
             # (NOTE: Fallbacks don't matter.)
             return True
@@ -838,7 +972,7 @@ def visit_overloaded(self, left: Overloaded) -> bool:
                 # When it is the same overload, then the types are equal.
                 return True
 
-            # Ensure each overload in the right side (the supertype) is accounted for.
+            # Ensure each overload on the right side (the supertype) is accounted for.
             previous_match_left_index = -1
             matched_overloads = set()
 
@@ -858,12 +992,17 @@ 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 False
+                        )
                         if left_index not in matched_overloads and (
                             is_callable_compatible(
                                 left_item,
                                 right_item,
                                 is_compat=self._is_subtype,
+                                is_proper_subtype=self.proper_subtype,
                                 ignore_return=True,
                                 ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,
                                 strict_concatenate=strict_concat,
@@ -872,6 +1011,7 @@ def visit_overloaded(self, left: Overloaded) -> bool:
                                 right_item,
                                 left_item,
                                 is_compat=self._is_subtype,
+                                is_proper_subtype=self.proper_subtype,
                                 ignore_return=True,
                                 ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,
                                 strict_concatenate=strict_concat,
@@ -951,6 +1091,11 @@ def visit_type_type(self, left: TypeType) -> bool:
         right = self.right
         if isinstance(right, TypeType):
             return self._is_subtype(left.item, right.item)
+        if isinstance(right, Overloaded) and right.is_type_obj():
+            # Same as in other direction: if it's a constructor callable, all
+            # items should belong to the same class' constructor, so it's enough
+            # to check one of them.
+            return self._is_subtype(left, right.items[0])
         if isinstance(right, CallableType):
             if self.proper_subtype and not right.is_type_obj():
                 # We can't accept `Type[X]` as a *proper* subtype of Callable[P, X]
@@ -997,6 +1142,7 @@ def is_protocol_implementation(
     proper_subtype: bool = False,
     class_obj: bool = False,
     skip: list[str] | None = None,
+    options: Options | None = None,
 ) -> bool:
     """Check whether 'left' implements the protocol 'right'.
 
@@ -1040,7 +1186,7 @@ def f(self) -> A: ...
             ignore_names = member != "__call__"  # __call__ can be passed kwargs
             # The third argument below indicates to what self type is bound.
             # We always bind self to the subtype. (Similarly to nominal types).
-            supertype = get_proper_type(find_member(member, right, left))
+            supertype = find_member(member, right, left)
             assert supertype is not None
 
             subtype = mypy.typeops.get_protocol_member(left, member, class_obj)
@@ -1049,33 +1195,39 @@ def f(self) -> A: ...
             # print(member, 'of', right, 'has type', supertype)
             if not subtype:
                 return False
-            if isinstance(subtype, PartialType):
-                subtype = (
-                    NoneType()
-                    if subtype.type is None
-                    else Instance(
-                        subtype.type,
-                        [AnyType(TypeOfAny.unannotated)] * len(subtype.type.type_vars),
-                    )
-                )
             if not proper_subtype:
                 # Nominal check currently ignores arg names
                 # NOTE: If we ever change this, be sure to also change the call to
                 # SubtypeVisitor.build_subtype_kind(...) down below.
-                is_compat = is_subtype(subtype, supertype, ignore_pos_arg_names=ignore_names)
+                is_compat = is_subtype(
+                    subtype, supertype, ignore_pos_arg_names=ignore_names, options=options
+                )
             else:
                 is_compat = is_proper_subtype(subtype, supertype)
             if not is_compat:
                 return False
-            if isinstance(subtype, NoneType) and isinstance(supertype, CallableType):
+            if isinstance(get_proper_type(subtype), NoneType) and isinstance(
+                get_proper_type(supertype), CallableType
+            ):
                 # We want __hash__ = None idiom to work even without --strict-optional
                 return False
             subflags = get_member_flags(member, left, class_obj=class_obj)
             superflags = get_member_flags(member, right)
             if IS_SETTABLE in superflags:
                 # Check opposite direction for settable attributes.
-                if not is_subtype(supertype, subtype):
+                if IS_EXPLICIT_SETTER in superflags:
+                    supertype = find_member(member, right, left, is_lvalue=True)
+                if IS_EXPLICIT_SETTER in subflags:
+                    subtype = mypy.typeops.get_protocol_member(
+                        left, member, class_obj, is_lvalue=True
+                    )
+                # At this point we know attribute is present on subtype, otherwise we
+                # would return False above.
+                assert supertype is not None and subtype is not None
+                if not is_subtype(supertype, subtype, options=options):
                     return False
+            if IS_SETTABLE in superflags and IS_SETTABLE not in subflags:
+                return False
             if not class_obj:
                 if IS_SETTABLE not in superflags:
                     if IS_CLASSVAR in superflags and IS_CLASSVAR not in subflags:
@@ -1089,8 +1241,6 @@ def f(self) -> A: ...
                 if IS_CLASSVAR in superflags:
                     # This can be never matched by a class object.
                     return False
-            if IS_SETTABLE in superflags and IS_SETTABLE not in subflags:
-                return False
             # This rule is copied from nominal check in checker.py
             if IS_CLASS_OR_STATIC in superflags and IS_CLASS_OR_STATIC not in subflags:
                 return False
@@ -1109,7 +1259,13 @@ def f(self) -> A: ...
 
 
 def find_member(
-    name: str, itype: Instance, subtype: Type, is_operator: bool = False, class_obj: bool = False
+    name: str,
+    itype: Instance,
+    subtype: Type,
+    *,
+    is_operator: bool = False,
+    class_obj: bool = False,
+    is_lvalue: bool = False,
 ) -> Type | None:
     """Find the type of member by 'name' in 'itype's TypeInfo.
 
@@ -1127,7 +1283,10 @@ def find_member(
             assert isinstance(method, OverloadedFuncDef)
             dec = method.items[0]
             assert isinstance(dec, Decorator)
-            return find_node_type(dec.var, itype, subtype, class_obj=class_obj)
+            # Pass on is_lvalue flag as this may be a property with different setter type.
+            return find_node_type(
+                dec.var, itype, subtype, class_obj=class_obj, is_lvalue=is_lvalue
+            )
         return find_node_type(method, itype, subtype, class_obj=class_obj)
     else:
         # don't have such method, maybe variable or decorator?
@@ -1192,7 +1351,10 @@ def get_member_flags(name: str, itype: Instance, class_obj: bool = False) -> set
             dec = method.items[0]
             assert isinstance(dec, Decorator)
             if dec.var.is_settable_property or setattr_meth:
-                return {IS_VAR, IS_SETTABLE}
+                flags = {IS_VAR, IS_SETTABLE}
+                if dec.var.setter_type is not None:
+                    flags.add(IS_EXPLICIT_SETTER)
+                return flags
             else:
                 return {IS_VAR}
         return set()  # Just a regular method
@@ -1223,7 +1385,11 @@ def get_member_flags(name: str, itype: Instance, class_obj: bool = False) -> set
 
 
 def find_node_type(
-    node: Var | FuncBase, itype: Instance, subtype: Type, class_obj: bool = False
+    node: Var | FuncBase,
+    itype: Instance,
+    subtype: Type,
+    class_obj: bool = False,
+    is_lvalue: bool = False,
 ) -> Type:
     """Find type of a variable or method 'node' (maybe also a decorated method).
     Apply type arguments from 'itype', and bind 'self' to 'subtype'.
@@ -1235,7 +1401,13 @@ def find_node_type(
             node, fallback=Instance(itype.type.mro[-1], [])
         )
     else:
-        typ = node.type
+        # This part and the one below are simply copies of the logic from checkmember.py.
+        if node.is_settable_property and is_lvalue:
+            typ = node.setter_type
+            if typ is None and node.is_ready:
+                typ = node.type
+        else:
+            typ = node.type
         if typ is not None:
             typ = expand_self_type(node, typ, subtype)
     p_typ = get_proper_type(typ)
@@ -1259,7 +1431,15 @@ def find_node_type(
             )
         if node.is_property and not class_obj:
             assert isinstance(signature, CallableType)
-            typ = signature.ret_type
+            if (
+                isinstance(node, Var)
+                and node.is_settable_property
+                and is_lvalue
+                and node.setter_type is not None
+            ):
+                typ = signature.arg_types[0]
+            else:
+                typ = signature.ret_type
         else:
             typ = signature
     itype = map_instance_to_supertype(itype, node.info)
@@ -1287,6 +1467,7 @@ def is_callable_compatible(
     right: CallableType,
     *,
     is_compat: Callable[[Type, Type], bool],
+    is_proper_subtype: bool,
     is_compat_return: Callable[[Type, Type], bool] | None = None,
     ignore_return: bool = False,
     ignore_pos_arg_names: bool = False,
@@ -1313,7 +1494,7 @@ def is_callable_compatible(
         configurable.
 
         For example, when checking the validity of overloads, it's useful to see if
-        the first overload alternative has more precise arguments then the second.
+        the first overload alternative has more precise arguments than the second.
         We would want to check the arguments covariantly in that case.
 
         Note! The following two function calls are NOT equivalent:
@@ -1383,8 +1564,8 @@ def g(x: int) -> int: ...
         whether or not we check the args covariantly.
     """
     # Normalize both types before comparing them.
-    left = left.with_unpacked_kwargs()
-    right = right.with_unpacked_kwargs()
+    left = left.with_unpacked_kwargs().with_normalized_var_args()
+    right = right.with_unpacked_kwargs().with_normalized_var_args()
 
     if is_compat_return is None:
         is_compat_return = is_compat
@@ -1414,17 +1595,6 @@ def g(x: int) -> int: ...
             return False
         left = unified
 
-    # If we allow partial overlaps, we don't need to leave R generic:
-    # if we can find even just a single typevar assignment which
-    # would make these callables compatible, we should return True.
-
-    # So, we repeat the above checks in the opposite direction. This also
-    # lets us preserve the 'symmetry' property of allow_partial_overlap.
-    if allow_partial_overlap and right.variables:
-        unified = unify_generic_callable(right, left, ignore_return=ignore_return)
-        if unified is not None:
-            right = unified
-
     # Check return types.
     if not ignore_return and not is_compat_return(left.ret_type, right.ret_type):
         return False
@@ -1441,8 +1611,8 @@ def g(x: int) -> int: ...
         left,
         right,
         is_compat=is_compat,
+        is_proper_subtype=is_proper_subtype,
         ignore_pos_arg_names=ignore_pos_arg_names,
-        check_args_covariantly=check_args_covariantly,
         allow_partial_overlap=allow_partial_overlap,
         strict_concatenate_check=strict_concatenate_check,
     )
@@ -1460,18 +1630,30 @@ def are_trivial_parameters(param: Parameters | NormalizedCallableType) -> bool:
     )
 
 
+def is_trivial_suffix(param: Parameters | NormalizedCallableType) -> bool:
+    param_star = param.var_arg()
+    param_star2 = param.kw_arg()
+    return (
+        param.arg_kinds[-2:] == [ARG_STAR, ARG_STAR2]
+        and param_star is not None
+        and isinstance(get_proper_type(param_star.typ), AnyType)
+        and param_star2 is not None
+        and isinstance(get_proper_type(param_star2.typ), AnyType)
+    )
+
+
 def are_parameters_compatible(
     left: Parameters | NormalizedCallableType,
     right: Parameters | NormalizedCallableType,
     *,
     is_compat: Callable[[Type, Type], bool],
+    is_proper_subtype: bool,
     ignore_pos_arg_names: bool = False,
-    check_args_covariantly: bool = False,
     allow_partial_overlap: bool = False,
-    strict_concatenate_check: bool = True,
+    strict_concatenate_check: bool = False,
 ) -> bool:
     """Helper function for is_callable_compatible, used for Parameter compatibility"""
-    if right.is_ellipsis_args:
+    if right.is_ellipsis_args and not is_proper_subtype:
         return True
 
     left_star = left.var_arg()
@@ -1480,8 +1662,22 @@ def are_parameters_compatible(
     right_star2 = right.kw_arg()
 
     # Treat "def _(*a: Any, **kw: Any) -> X" similarly to "Callable[..., X]"
-    if are_trivial_parameters(right):
+    if are_trivial_parameters(right) and not is_proper_subtype:
         return True
+    trivial_suffix = is_trivial_suffix(right) and not is_proper_subtype
+
+    trivial_vararg_suffix = False
+    if (
+        right.arg_kinds[-1:] == [ARG_STAR]
+        and isinstance(get_proper_type(right.arg_types[-1]), AnyType)
+        and not is_proper_subtype
+        and all(k.is_positional(star=True) for k in left.arg_kinds)
+    ):
+        # Similar to how (*Any, **Any) is considered a supertype of all callables, we consider
+        # (*Any) a supertype of all callables with positional arguments. This is needed in
+        # particular because we often refuse to try type inference if actual type is not
+        # a subtype of erased template type.
+        trivial_vararg_suffix = True
 
     # Match up corresponding arguments and check them for compatibility. In
     # every pair (argL, argR) of corresponding arguments from L and R, argL must
@@ -1512,15 +1708,19 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
         if right_arg is None:
             return False
         if left_arg is None:
-            return not allow_partial_overlap
+            return not allow_partial_overlap and not trivial_suffix
         return not is_compat(right_arg.typ, left_arg.typ)
 
-    if _incompatible(left_star, right_star) or _incompatible(left_star2, right_star2):
+    if (
+        _incompatible(left_star, right_star)
+        and not trivial_vararg_suffix
+        or _incompatible(left_star2, right_star2)
+    ):
         return False
 
     # Phase 1b: Check non-star args: for every arg right can accept, left must
     #           also accept. The only exception is if we are allowing partial
-    #           partial overlaps: in that case, we ignore optional args on the right.
+    #           overlaps: in that case, we ignore optional args on the right.
     for right_arg in right.formal_arguments():
         left_arg = mypy.typeops.callable_corresponding_argument(left, right_arg)
         if left_arg is None:
@@ -1528,14 +1728,25 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
                 continue
             return False
         if not are_args_compatible(
-            left_arg, right_arg, ignore_pos_arg_names, allow_partial_overlap, is_compat
+            left_arg,
+            right_arg,
+            is_compat,
+            ignore_pos_arg_names=ignore_pos_arg_names,
+            allow_partial_overlap=allow_partial_overlap,
+            allow_imprecise_kinds=right.imprecise_arg_kinds,
         ):
             return False
 
+    if trivial_suffix:
+        # For trivial right suffix we *only* check that every non-star right argument
+        # has a valid match on the left.
+        return True
+
     # Phase 1c: Check var args. Right has an infinite series of optional positional
     #           arguments. Get all further positional args of left, and make sure
-    #           they're more general then the corresponding member in right.
-    if right_star is not None:
+    #           they're more general than the corresponding member in right.
+    # TODO: handle suffix in UnpackType (i.e. *args: *Tuple[Ts, X, Y]).
+    if right_star is not None and not trivial_vararg_suffix:
         # Synthesize an anonymous formal argument for the right
         right_by_position = right.try_synthesizing_arg_from_vararg(None)
         assert right_by_position is not None
@@ -1552,16 +1763,16 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
             if not are_args_compatible(
                 left_by_position,
                 right_by_position,
-                ignore_pos_arg_names,
-                allow_partial_overlap,
                 is_compat,
+                ignore_pos_arg_names=ignore_pos_arg_names,
+                allow_partial_overlap=allow_partial_overlap,
             ):
                 return False
             i += 1
 
     # Phase 1d: Check kw args. Right has an infinite series of optional named
     #           arguments. Get all further named args of left, and make sure
-    #           they're more general then the corresponding member in right.
+    #           they're more general than the corresponding member in right.
     if right_star2 is not None:
         right_names = {name for name in right.arg_names if name is not None}
         left_only_names = set()
@@ -1587,7 +1798,11 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
                 continue
 
             if not are_args_compatible(
-                left_by_name, right_by_name, ignore_pos_arg_names, allow_partial_overlap, is_compat
+                left_by_name,
+                right_by_name,
+                is_compat,
+                ignore_pos_arg_names=ignore_pos_arg_names,
+                allow_partial_overlap=allow_partial_overlap,
             ):
                 return False
 
@@ -1611,6 +1826,7 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
             and right_by_name != right_by_pos
             and (right_by_pos.required or right_by_name.required)
             and strict_concatenate_check
+            and not right.imprecise_arg_kinds
         ):
             return False
 
@@ -1625,11 +1841,19 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
 def are_args_compatible(
     left: FormalArgument,
     right: FormalArgument,
+    is_compat: Callable[[Type, Type], bool],
+    *,
     ignore_pos_arg_names: bool,
     allow_partial_overlap: bool,
-    is_compat: Callable[[Type, Type], bool],
+    allow_imprecise_kinds: bool = False,
 ) -> bool:
-    def is_different(left_item: object | None, right_item: object | None) -> bool:
+    if left.required and right.required:
+        # If both arguments are required allow_partial_overlap has no effect.
+        allow_partial_overlap = False
+
+    def is_different(
+        left_item: object | None, right_item: object | None, allow_overlap: bool
+    ) -> bool:
         """Checks if the left and right items are different.
 
         If the right item is unspecified (e.g. if the right callable doesn't care
@@ -1639,24 +1863,26 @@ def is_different(left_item: object | None, right_item: object | None) -> bool:
         if the left callable also doesn't care."""
         if right_item is None:
             return False
-        if allow_partial_overlap and left_item is None:
+        if allow_overlap and left_item is None:
             return False
         return left_item != right_item
 
     # If right has a specific name it wants this argument to be, left must
     # have the same.
-    if is_different(left.name, right.name):
+    if is_different(left.name, right.name, allow_partial_overlap):
         # But pay attention to whether we're ignoring positional arg names
         if not ignore_pos_arg_names or right.pos is None:
             return False
 
-    # If right is at a specific position, left must have the same:
-    if is_different(left.pos, right.pos):
+    # If right is at a specific position, left must have the same.
+    # TODO: partial overlap logic is flawed for positions.
+    # We disable it to avoid false positives at a cost of few false negatives.
+    if is_different(left.pos, right.pos, allow_overlap=False) and not allow_imprecise_kinds:
         return False
 
     # If right's argument is optional, left's must also be
     # (unless we're relaxing the checks to allow potential
-    # rather then definite compatibility).
+    # rather than definite compatibility).
     if not allow_partial_overlap and not right.required and left.required:
         return False
 
@@ -1688,25 +1914,35 @@ def unify_generic_callable(
     """
     import mypy.solve
 
+    if set(type.type_var_ids()) & {v.id for v in mypy.typeops.get_all_type_vars(target)}:
+        # Overload overlap check does nasty things like unifying in opposite direction.
+        # This can easily create type variable clashes, so we need to refresh.
+        type = freshen_function_type_vars(type)
+
     if return_constraint_direction is None:
         return_constraint_direction = mypy.constraints.SUBTYPE_OF
 
     constraints: list[mypy.constraints.Constraint] = []
-    for arg_type, target_arg_type in zip(type.arg_types, target.arg_types):
-        c = mypy.constraints.infer_constraints(
-            arg_type, target_arg_type, mypy.constraints.SUPERTYPE_OF
-        )
-        constraints.extend(c)
+    # There is some special logic for inference in callables, so better use them
+    # as wholes instead of picking separate arguments.
+    cs = mypy.constraints.infer_constraints(
+        type.copy_modified(ret_type=UninhabitedType()),
+        target.copy_modified(ret_type=UninhabitedType()),
+        mypy.constraints.SUBTYPE_OF,
+        skip_neg_op=True,
+    )
+    constraints.extend(cs)
     if not ignore_return:
         c = mypy.constraints.infer_constraints(
             type.ret_type, target.ret_type, return_constraint_direction
         )
         constraints.extend(c)
-    type_var_ids = [tvar.id for tvar in type.variables]
-    inferred_vars = mypy.solve.solve_constraints(type_var_ids, constraints)
+    inferred_vars, _ = mypy.solve.solve_constraints(
+        type.variables, constraints, allow_polymorphic=True
+    )
     if None in inferred_vars:
         return None
-    non_none_inferred_vars = cast(List[Type], inferred_vars)
+    non_none_inferred_vars = cast(list[Type], inferred_vars)
     had_errors = False
 
     def report(*args: Any) -> None:
@@ -1765,6 +2001,8 @@ def restrict_subtype_away(t: Type, s: Type) -> Type:
                 if (isinstance(get_proper_type(item), AnyType) or not covers_at_runtime(item, s))
             ]
         return UnionType.make_union(new_items)
+    elif isinstance(p_t, TypeVarType):
+        return p_t.copy_modified(upper_bound=restrict_subtype_away(p_t.upper_bound, s))
     elif covers_at_runtime(t, s):
         return UninhabitedType()
     else:
@@ -1814,3 +2052,137 @@ def is_more_precise(left: Type, right: Type, *, ignore_promotions: bool = False)
     if isinstance(right, AnyType):
         return True
     return is_proper_subtype(left, right, ignore_promotions=ignore_promotions)
+
+
+def all_non_object_members(info: TypeInfo) -> set[str]:
+    members = set(info.names)
+    for base in info.mro[1:-1]:
+        members.update(base.names)
+    return members
+
+
+def infer_variance(info: TypeInfo, i: int) -> bool:
+    """Infer the variance of the ith type variable of a generic class.
+
+    Return True if successful. This can fail if some inferred types aren't ready.
+    """
+    object_type = Instance(info.mro[-1], [])
+
+    for variance in COVARIANT, CONTRAVARIANT, INVARIANT:
+        tv = info.defn.type_vars[i]
+        assert isinstance(tv, TypeVarType)
+        if tv.variance != VARIANCE_NOT_READY:
+            continue
+        tv.variance = variance
+        co = True
+        contra = True
+        tvar = info.defn.type_vars[i]
+        self_type = fill_typevars(info)
+        for member in all_non_object_members(info):
+            # __mypy-replace is an implementation detail of the dataclass plugin
+            if member in ("__init__", "__new__", "__mypy-replace"):
+                continue
+
+            if isinstance(self_type, TupleType):
+                self_type = mypy.typeops.tuple_fallback(self_type)
+            flags = get_member_flags(member, self_type)
+            settable = IS_SETTABLE in flags
+
+            node = info[member].node
+            if isinstance(node, Var):
+                if node.type is None:
+                    tv.variance = VARIANCE_NOT_READY
+                    return False
+                if has_underscore_prefix(member):
+                    # Special case to avoid false positives (and to pass conformance tests)
+                    settable = False
+
+            # TODO: handle settable properties with setter type different from getter.
+            typ = find_member(member, self_type, self_type)
+            if typ:
+                # It's okay for a method in a generic class with a contravariant type
+                # variable to return a generic instance of the class, if it doesn't involve
+                # variance (i.e. values of type variables are propagated). Our normal rules
+                # would disallow this. Replace such return types with 'Any' to allow this.
+                #
+                # This could probably be more lenient (e.g. allow self type be nested, don't
+                # require all type arguments to be identical to self_type), but this will
+                # hopefully cover the vast majority of such cases, including Self.
+                typ = erase_return_self_types(typ, self_type)
+
+                typ2 = expand_type(typ, {tvar.id: object_type})
+                if not is_subtype(typ, typ2):
+                    co = False
+                if not is_subtype(typ2, typ):
+                    contra = False
+                    if settable:
+                        co = False
+
+        # Infer variance from base classes, in case they have explicit variances
+        for base in info.bases:
+            base2 = expand_type(base, {tvar.id: object_type})
+            if not is_subtype(base, base2):
+                co = False
+            if not is_subtype(base2, base):
+                contra = False
+
+        if co:
+            v = COVARIANT
+        elif contra:
+            v = CONTRAVARIANT
+        else:
+            v = INVARIANT
+        if v == variance:
+            break
+        tv.variance = VARIANCE_NOT_READY
+    return True
+
+
+def has_underscore_prefix(name: str) -> bool:
+    return name.startswith("_") and not (name.startswith("__") and name.endswith("__"))
+
+
+def infer_class_variances(info: TypeInfo) -> bool:
+    if not info.defn.type_args:
+        return True
+    tvs = info.defn.type_vars
+    success = True
+    for i, tv in enumerate(tvs):
+        if isinstance(tv, TypeVarType) and tv.variance == VARIANCE_NOT_READY:
+            if not infer_variance(info, i):
+                success = False
+    return success
+
+
+def erase_return_self_types(typ: Type, self_type: Instance) -> Type:
+    """If a typ is function-like and returns self_type, replace return type with Any."""
+    proper_type = get_proper_type(typ)
+    if isinstance(proper_type, CallableType):
+        ret = get_proper_type(proper_type.ret_type)
+        if isinstance(ret, Instance) and ret == self_type:
+            return proper_type.copy_modified(ret_type=AnyType(TypeOfAny.implementation_artifact))
+    elif isinstance(proper_type, Overloaded):
+        return Overloaded(
+            [
+                cast(CallableType, erase_return_self_types(it, self_type))
+                for it in proper_type.items
+            ]
+        )
+    return typ
+
+
+def is_erased_instance(t: Instance) -> bool:
+    """Is this an instance where all args are Any types?"""
+    if not t.args:
+        return False
+    for arg in t.args:
+        if isinstance(arg, UnpackType):
+            unpacked = get_proper_type(arg.type)
+            if not isinstance(unpacked, Instance):
+                return False
+            assert unpacked.type.fullname == "builtins.tuple"
+            if not isinstance(get_proper_type(unpacked.args[0]), AnyType):
+                return False
+        elif not isinstance(get_proper_type(arg), AnyType):
+            return False
+    return True
diff --git a/mypy/suggestions.py b/mypy/suggestions.py
index 8e1225f00a2f..f27ad7cdb637 100644
--- a/mypy/suggestions.py
+++ b/mypy/suggestions.py
@@ -27,9 +27,9 @@
 import itertools
 import json
 import os
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Callable, Iterator, NamedTuple, TypeVar, cast
-from typing_extensions import TypedDict
+from typing import Callable, NamedTuple, TypedDict, TypeVar, cast
 
 from mypy.argmap import map_actuals_to_formals
 from mypy.build import Graph, State
@@ -52,6 +52,7 @@
     SymbolNode,
     SymbolTable,
     TypeInfo,
+    Var,
     reverse_builtin_aliases,
 )
 from mypy.options import Options
@@ -59,7 +60,7 @@
 from mypy.server.update import FineGrainedBuildManager
 from mypy.state import state
 from mypy.traverser import TraverserVisitor
-from mypy.typeops import make_simplified_union
+from mypy.typeops import bind_self, make_simplified_union
 from mypy.types import (
     AnyType,
     CallableType,
@@ -79,7 +80,7 @@
     UnionType,
     get_proper_type,
 )
-from mypy.types_utils import is_optional, remove_optional
+from mypy.types_utils import is_overlapping_none, remove_optional
 from mypy.util import split_target
 
 
@@ -454,7 +455,7 @@ def get_guesses_from_parent(self, node: FuncDef) -> list[CallableType]:
             pnode = parent.names.get(node.name)
             if pnode and isinstance(pnode.node, (FuncDef, Decorator)):
                 typ = get_proper_type(pnode.node.type)
-                # FIXME: Doesn't work right with generic tyeps
+                # FIXME: Doesn't work right with generic types
                 if isinstance(typ, CallableType) and len(typ.arg_types) == len(node.arguments):
                     # Return the first thing we find, since it probably doesn't make sense
                     # to grab things further up in the chain if an earlier parent has it.
@@ -638,15 +639,20 @@ def find_node_by_file_and_line(self, file: str, line: int) -> tuple[str, SymbolN
     def extract_from_decorator(self, node: Decorator) -> FuncDef | None:
         for dec in node.decorators:
             typ = None
-            if isinstance(dec, RefExpr) and isinstance(dec.node, FuncDef):
-                typ = dec.node.type
+            if isinstance(dec, RefExpr) and isinstance(dec.node, (Var, FuncDef)):
+                typ = get_proper_type(dec.node.type)
             elif (
                 isinstance(dec, CallExpr)
                 and isinstance(dec.callee, RefExpr)
-                and isinstance(dec.callee.node, FuncDef)
-                and isinstance(dec.callee.node.type, CallableType)
+                and isinstance(dec.callee.node, (Decorator, FuncDef, Var))
+                and isinstance((call_tp := get_proper_type(dec.callee.node.type)), CallableType)
             ):
-                typ = get_proper_type(dec.callee.node.type.ret_type)
+                typ = get_proper_type(call_tp.ret_type)
+
+            if isinstance(typ, Instance):
+                call_method = typ.type.get_method("__call__")
+                if isinstance(call_method, FuncDef) and isinstance(call_method.type, FunctionLike):
+                    typ = bind_self(call_method.type, None)
 
             if not isinstance(typ, FunctionLike):
                 return None
@@ -752,7 +758,7 @@ def score_type(self, t: Type, arg_pos: bool) -> int:
                 return 20
             if any(has_any_type(x) for x in t.items):
                 return 15
-            if not is_optional(t):
+            if not is_overlapping_none(t):
                 return 10
         if isinstance(t, CallableType) and (has_any_type(t) or is_tricky_callable(t)):
             return 10
@@ -868,7 +874,7 @@ def visit_typeddict_type(self, t: TypedDictType) -> str:
         return t.fallback.accept(self)
 
     def visit_union_type(self, t: UnionType) -> str:
-        if len(t.items) == 2 and is_optional(t):
+        if len(t.items) == 2 and is_overlapping_none(t):
             return f"Optional[{remove_optional(t).accept(self)}]"
         else:
             return super().visit_union_type(t)
diff --git a/mypy/test/config.py b/mypy/test/config.py
index 3806cf3dfa13..2dc4208b1e9d 100644
--- a/mypy/test/config.py
+++ b/mypy/test/config.py
@@ -18,6 +18,9 @@
 # It is also hard-coded in numerous places, so don't change it.
 test_temp_dir = "tmp"
 
+# Mypyc tests may write intermediate files (e.g. generated C) here on failure
+mypyc_output_dir = os.path.join(PREFIX, ".mypyc_test_output")
+
 # The PEP 561 tests do a bunch of pip installs which, even though they operate
 # on distinct temporary virtual environments, run into race conditions on shared
 # file-system state. To make this work reliably in parallel mode, we'll use a
diff --git a/mypy/test/data.py b/mypy/test/data.py
index daf815dbdbdc..5b0ad84c0ba7 100644
--- a/mypy/test/data.py
+++ b/mypy/test/data.py
@@ -10,14 +10,17 @@
 import sys
 import tempfile
 from abc import abstractmethod
+from collections.abc import Iterator
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Iterator, NamedTuple, Pattern, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from re import Pattern
+from typing import Any, Final, NamedTuple, NoReturn, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 import pytest
 
-from mypy.test.config import PREFIX, test_data_prefix, test_temp_dir
+from mypy import defaults
+from mypy.test.config import PREFIX, mypyc_output_dir, test_data_prefix, test_temp_dir
 
 root_dir = os.path.normpath(PREFIX)
 
@@ -64,7 +67,6 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
         join = posixpath.join
 
     out_section_missing = case.suite.required_out_section
-    normalize_output = True
 
     files: list[tuple[str, str]] = []  # path and contents
     output_files: list[tuple[str, str | Pattern[str]]] = []  # output path and contents
@@ -77,11 +79,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 +142,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):
@@ -145,39 +157,34 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
 
             version_check = True
             for arg in args:
-                if arg == "skip-path-normalization":
-                    normalize_output = False
                 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 == ">=":
+                        if version <= defaults.PYTHON3_VERSION:
+                            _item_fail(
+                                f"{arg} always true since minimum runtime version is {defaults.PYTHON3_VERSION}"
+                            )
                         version_check = sys.version_info >= version
                     elif compare_op == "==":
+                        if version < defaults.PYTHON3_VERSION:
+                            _item_fail(
+                                f"{arg} always false since minimum runtime version is {defaults.PYTHON3_VERSION}"
+                            )
                         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:
                 tmp_output = [expand_variables(line) for line in item.data]
-                if os.path.sep == "\\" and normalize_output:
+                if os.path.sep == "\\" and case.normalize_output:
                     tmp_output = [fix_win_path(line) for line in tmp_output]
                 if item.id == "out" or item.id == "out1":
                     output = tmp_output
@@ -189,10 +196,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 +212,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 +223,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)
 
@@ -237,7 +238,6 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
     case.expected_rechecked_modules = rechecked_modules
     case.deleted_paths = deleted_paths
     case.triggered = triggered or []
-    case.normalize_output = normalize_output
     case.expected_fine_grained_targets = targets
     case.test_modules = test_modules
 
@@ -246,7 +246,7 @@ class DataDrivenTestCase(pytest.Item):
     """Holds parsed data-driven test cases, and handles directory setup and teardown."""
 
     # Override parent member type
-    parent: DataSuiteCollector
+    parent: DataFileCollector
 
     input: list[str]
     output: list[str]  # Output for the first pass
@@ -267,7 +267,7 @@ class DataDrivenTestCase(pytest.Item):
 
     # Whether or not we should normalize the output to standardize things like
     # forward vs backward slashes in file paths for Windows vs Linux.
-    normalize_output = True
+    normalize_output: bool
 
     # Extra attributes used by some tests.
     last_line: int
@@ -277,23 +277,27 @@ class DataDrivenTestCase(pytest.Item):
 
     def __init__(
         self,
-        parent: DataSuiteCollector,
+        parent: DataFileCollector,
         suite: DataSuite,
+        *,
         file: str,
         name: str,
         writescache: bool,
         only_when: str,
+        normalize_output: bool,
         platform: str | None,
         skip: bool,
         xfail: bool,
         data: str,
         line: int,
     ) -> None:
+        assert isinstance(parent, DataFileCollector)
         super().__init__(name, parent)
         self.suite = suite
         self.file = file
         self.writescache = writescache
         self.only_when = only_when
+        self.normalize_output = normalize_output
         if (platform == "windows" and sys.platform != "win32") or (
             platform == "posix" and sys.platform == "win32"
         ):
@@ -303,7 +307,7 @@ def __init__(
         self.data = data
         self.line = line
         self.old_cwd: str | None = None
-        self.tmpdir: tempfile.TemporaryDirectory[str] | None = None
+        self.tmpdir: str | None = None
 
     def runtest(self) -> None:
         if self.skip:
@@ -322,19 +326,19 @@ def runtest(self) -> None:
             save_dir: str | None = self.config.getoption("--save-failures-to", None)
             if save_dir:
                 assert self.tmpdir is not None
-                target_dir = os.path.join(save_dir, os.path.basename(self.tmpdir.name))
+                target_dir = os.path.join(save_dir, os.path.basename(self.tmpdir))
                 print(f"Copying data from test {self.name} to {target_dir}")
                 if not os.path.isabs(target_dir):
                     assert self.old_cwd
                     target_dir = os.path.join(self.old_cwd, target_dir)
-                shutil.copytree(self.tmpdir.name, target_dir)
+                shutil.copytree(self.tmpdir, target_dir)
             raise
 
     def setup(self) -> None:
         parse_test_case(case=self)
         self.old_cwd = os.getcwd()
-        self.tmpdir = tempfile.TemporaryDirectory(prefix="mypy-test-")
-        os.chdir(self.tmpdir.name)
+        self.tmpdir = tempfile.mkdtemp(prefix="mypy-test-")
+        os.chdir(self.tmpdir)
         os.mkdir(test_temp_dir)
 
         # Precalculate steps for find_steps()
@@ -367,19 +371,20 @@ 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:
+            shutil.rmtree(self.tmpdir, ignore_errors=True)
         self.old_cwd = None
         self.tmpdir = None
 
     def reportinfo(self) -> tuple[str, int, str]:
         return self.file, self.line, self.name
 
-    def repr_failure(self, excinfo: Any, style: Any | None = None) -> str:
+    def repr_failure(
+        self, excinfo: pytest.ExceptionInfo[BaseException], style: Any | None = None
+    ) -> str:
+        excrepr: object
         if isinstance(excinfo.value, SystemExit):
             # We assume that before doing exit() (which raises SystemExit) we've printed
             # enough context about what happened so that a stack trace is not useful.
@@ -389,7 +394,7 @@ def repr_failure(self, excinfo: Any, style: Any | None = None) -> str:
         elif isinstance(excinfo.value, pytest.fail.Exception) and not excinfo.value.pytrace:
             excrepr = excinfo.exconly()
         else:
-            self.parent._prunetraceback(excinfo)
+            excinfo.traceback = self.parent._traceback_filter(excinfo)
             excrepr = excinfo.getrepr(style="short")
 
         return f"data: {self.file}:{self.line}:\n{excrepr}"
@@ -582,6 +587,13 @@ def fix_cobertura_filename(line: str) -> str:
 ##
 
 
+def pytest_sessionstart(session: Any) -> None:
+    # Clean up directory where mypyc tests write intermediate files on failure
+    # to avoid any confusion between test runs
+    if os.path.isdir(mypyc_output_dir):
+        shutil.rmtree(mypyc_output_dir)
+
+
 # This function name is special to pytest.  See
 # https://docs.pytest.org/en/latest/reference.html#initialization-hooks
 def pytest_addoption(parser: Any) -> None:
@@ -615,6 +627,15 @@ def pytest_addoption(parser: Any) -> None:
     )
 
 
+@pytest.hookimpl(tryfirst=True)
+def pytest_cmdline_main(config: pytest.Config) -> None:
+    if config.getoption("--collectonly"):
+        return
+    # --update-data is not compatible with parallelized tests, disable parallelization
+    if config.getoption("--update-data"):
+        config.option.numprocesses = 0
+
+
 # This function name is special to pytest.  See
 # https://doc.pytest.org/en/latest/how-to/writing_plugins.html#collection-hooks
 def pytest_pycollect_makeitem(collector: Any, name: str, obj: object) -> Any | None:
@@ -628,12 +649,21 @@ def pytest_pycollect_makeitem(collector: Any, name: str, obj: object) -> Any | N
             # Non-None result means this obj is a test case.
             # The collect method of the returned DataSuiteCollector instance will be called later,
             # with self.obj being obj.
-            return DataSuiteCollector.from_parent(  # type: ignore[no-untyped-call]
-                parent=collector, name=name
-            )
+            return DataSuiteCollector.from_parent(parent=collector, name=name)
     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<skip_path_normalization>-skip_path_normalization)?"
+    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 +674,34 @@ 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")),
+            normalize_output=not m.group("skip_path_normalization"),
             data=data,
             line=line_no,
         )
diff --git a/mypy/test/helpers.py b/mypy/test/helpers.py
index 849ccdc376bd..fcec68094e51 100644
--- a/mypy/test/helpers.py
+++ b/mypy/test/helpers.py
@@ -1,13 +1,16 @@
 from __future__ import annotations
 
 import contextlib
+import difflib
 import os
 import pathlib
 import re
 import shutil
 import sys
 import time
-from typing import Any, Callable, Iterable, Iterator, Pattern
+from collections.abc import Iterable, Iterator
+from re import Pattern
+from typing import IO, Any, Callable
 
 # Exporting Suite as alias to TestCase for backwards compatibility
 # TODO: avoid aliasing - import and subclass TestCase directly
@@ -40,73 +43,91 @@ def run_mypy(args: list[str]) -> None:
     if status != 0:
         sys.stdout.write(outval)
         sys.stderr.write(errval)
-        pytest.fail(msg="Sample check failed", pytrace=False)
+        pytest.fail(reason="Sample check failed", pytrace=False)
+
+
+def diff_ranges(
+    left: list[str], right: list[str]
+) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]:
+    seq = difflib.SequenceMatcher(None, left, right)
+    # note last triple is a dummy, so don't need to worry
+    blocks = seq.get_matching_blocks()
+
+    i = 0
+    j = 0
+    left_ranges = []
+    right_ranges = []
+    for block in blocks:
+        # mismatched range
+        left_ranges.append((i, block.a))
+        right_ranges.append((j, block.b))
+
+        i = block.a + block.size
+        j = block.b + block.size
+
+        # matched range
+        left_ranges.append((block.a, i))
+        right_ranges.append((block.b, j))
+    return left_ranges, right_ranges
+
+
+def render_diff_range(
+    ranges: list[tuple[int, int]],
+    content: list[str],
+    *,
+    colour: str | None = None,
+    output: IO[str] = sys.stderr,
+    indent: int = 2,
+) -> None:
+    for i, line_range in enumerate(ranges):
+        is_matching = i % 2 == 1
+        lines = content[line_range[0] : line_range[1]]
+        for j, line in enumerate(lines):
+            if (
+                is_matching
+                # elide the middle of matching blocks
+                and j >= 3
+                and j < len(lines) - 3
+            ):
+                if j == 3:
+                    output.write(" " * indent + "...\n")
+                continue
 
+            if not is_matching and colour:
+                output.write(colour)
 
-def assert_string_arrays_equal(expected: list[str], actual: list[str], msg: str) -> None:
-    """Assert that two string arrays are equal.
+            output.write(" " * indent + line)
+
+            if not is_matching:
+                if colour:
+                    output.write("\033[0m")
+                output.write(" (diff)")
 
-    We consider "can't" and "cannot" equivalent, by replacing the
-    former with the latter before comparing.
+            output.write("\n")
+
+
+def assert_string_arrays_equal(
+    expected: list[str], actual: list[str], msg: str, *, traceback: bool = False
+) -> None:
+    """Assert that two string arrays are equal.
 
     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)
-
+    if expected != actual:
+        expected_ranges, actual_ranges = diff_ranges(expected, actual)
         sys.stderr.write("Expected:\n")
-
-        # If omit some lines at the beginning, indicate it by displaying a line
-        # with '...'.
-        if num_skip_start > 0:
-            sys.stderr.write("  ...\n")
-
-        # Keep track of the first different line.
-        first_diff = -1
-
-        # Display only this many first characters of identical lines.
-        width = 75
-
-        for i in range(num_skip_start, len(expected) - num_skip_end):
-            if i >= len(actual) or expected[i] != actual[i]:
-                if first_diff < 0:
-                    first_diff = i
-                sys.stderr.write(f"  {expected[i]:<45} (diff)")
-            else:
-                e = expected[i]
-                sys.stderr.write("  " + e[:width])
-                if len(e) > width:
-                    sys.stderr.write("...")
-            sys.stderr.write("\n")
-        if num_skip_end > 0:
-            sys.stderr.write("  ...\n")
-
+        red = "\033[31m" if sys.platform != "win32" else None
+        render_diff_range(expected_ranges, expected, colour=red)
         sys.stderr.write("Actual:\n")
-
-        if num_skip_start > 0:
-            sys.stderr.write("  ...\n")
-
-        for j in range(num_skip_start, len(actual) - num_skip_end):
-            if j >= len(expected) or expected[j] != actual[j]:
-                sys.stderr.write(f"  {actual[j]:<45} (diff)")
-            else:
-                a = actual[j]
-                sys.stderr.write("  " + a[:width])
-                if len(a) > width:
-                    sys.stderr.write("...")
-            sys.stderr.write("\n")
-        if not actual:
-            sys.stderr.write("  (empty)\n")
-        if num_skip_end > 0:
-            sys.stderr.write("  ...\n")
+        green = "\033[32m" if sys.platform != "win32" else None
+        render_diff_range(actual_ranges, actual, colour=green)
 
         sys.stderr.write("\n")
-
+        first_diff = next(
+            (i for i, (a, b) in enumerate(zip(expected, actual)) if a != b),
+            max(len(expected), len(actual)),
+        )
         if 0 <= first_diff < len(actual) and (
             len(expected[first_diff]) >= MIN_LINE_LENGTH_FOR_ALIGNMENT
             or len(actual[first_diff]) >= MIN_LINE_LENGTH_FOR_ALIGNMENT
@@ -115,7 +136,11 @@ def assert_string_arrays_equal(expected: list[str], actual: list[str], msg: str)
             # long lines.
             show_align_message(expected[first_diff], actual[first_diff])
 
-        pytest.fail(msg, pytrace=False)
+        sys.stderr.write(
+            "Update the test output using --update-data "
+            "(implies -n0; you can additionally use the -k selector to update only specific tests)\n"
+        )
+        pytest.fail(msg, pytrace=traceback)
 
 
 def assert_module_equivalence(name: str, expected: Iterable[str], actual: Iterable[str]) -> None:
@@ -124,7 +149,7 @@ def assert_module_equivalence(name: str, expected: Iterable[str], actual: Iterab
     assert_string_arrays_equal(
         expected_normalized,
         actual_normalized,
-        ("Actual modules ({}) do not match expected modules ({}) " 'for "[{} ...]"').format(
+        ('Actual modules ({}) do not match expected modules ({}) for "[{} ...]"').format(
             ", ".join(actual_normalized), ", ".join(expected_normalized), name
         ),
     )
@@ -135,7 +160,7 @@ def assert_target_equivalence(name: str, expected: list[str], actual: list[str])
     assert_string_arrays_equal(
         expected,
         actual,
-        ("Actual targets ({}) do not match expected targets ({}) " 'for "[{} ...]"').format(
+        ('Actual targets ({}) do not match expected targets ({}) for "[{} ...]"').format(
             ", ".join(actual), ", ".join(expected), name
         ),
     )
@@ -232,29 +257,10 @@ def local_sys_path_set() -> Iterator[None]:
         sys.path = old_sys_path
 
 
-def num_skipped_prefix_lines(a1: list[str], a2: list[str]) -> int:
-    num_eq = 0
-    while num_eq < min(len(a1), len(a2)) and a1[num_eq] == a2[num_eq]:
-        num_eq += 1
-    return max(0, num_eq - 4)
-
-
-def num_skipped_suffix_lines(a1: list[str], a2: list[str]) -> int:
-    num_eq = 0
-    while num_eq < min(len(a1), len(a2)) and a1[-num_eq - 1] == a2[-num_eq - 1]:
-        num_eq += 1
-    return max(0, num_eq - 4)
-
-
 def testfile_pyversion(path: str) -> tuple[int, int]:
-    if path.endswith("python311.test"):
-        return 3, 11
-    elif path.endswith("python310.test"):
-        return 3, 10
-    elif path.endswith("python39.test"):
-        return 3, 9
-    elif path.endswith("python38.test"):
-        return 3, 8
+    m = re.search(r"python3([0-9]+)\.test$", path)
+    if m:
+        return 3, int(m.group(1))
     else:
         return defaults.PYTHON3_VERSION
 
@@ -345,15 +351,13 @@ def parse_options(
     else:
         flag_list = []
         options = Options()
-        # TODO: Enable strict optional in test cases by default (requires *many* test case changes)
-        options.strict_optional = False
         options.error_summary = False
         options.hide_error_codes = True
         options.force_uppercase_builtins = True
         options.force_union_syntax = True
 
     # Allow custom python version to override testfile_pyversion.
-    if all(flag.split("=")[0] not in ["--python-version", "-2", "--py2"] for flag in flag_list):
+    if all(flag.split("=")[0] != "--python-version" for flag in flag_list):
         options.python_version = testfile_pyversion(testcase.file)
 
     if testcase.config.getoption("--mypy-verbose"):
@@ -409,8 +413,7 @@ def check_test_output_files(
     testcase: DataDrivenTestCase, step: int, strip_prefix: str = ""
 ) -> None:
     for path, expected_content in testcase.output_files:
-        if path.startswith(strip_prefix):
-            path = path[len(strip_prefix) :]
+        path = path.removeprefix(strip_prefix)
         if not os.path.exists(path):
             raise AssertionError(
                 "Expected file {} was not produced by test case{}".format(
diff --git a/test-data/pybind11_mypy_demo/stubgen/pybind11_mypy_demo/__init__.pyi b/mypy/test/meta/__init__.py
similarity index 100%
rename from test-data/pybind11_mypy_demo/stubgen/pybind11_mypy_demo/__init__.pyi
rename to mypy/test/meta/__init__.py
diff --git a/mypy/test/meta/_pytest.py b/mypy/test/meta/_pytest.py
new file mode 100644
index 000000000000..0caa6b8694b7
--- /dev/null
+++ b/mypy/test/meta/_pytest.py
@@ -0,0 +1,72 @@
+import shlex
+import subprocess
+import sys
+import textwrap
+import uuid
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+from mypy.test.config import test_data_prefix
+
+
+@dataclass
+class PytestResult:
+    input: str
+    input_updated: str  # any updates made by --update-data
+    stdout: str
+    stderr: str
+
+
+def dedent_docstring(s: str) -> str:
+    return textwrap.dedent(s).lstrip()
+
+
+def run_pytest_data_suite(
+    data_suite: str,
+    *,
+    data_file_prefix: str = "check",
+    pytest_node_prefix: str = "mypy/test/testcheck.py::TypeCheckSuite",
+    extra_args: Iterable[str],
+    max_attempts: int,
+) -> PytestResult:
+    """
+    Runs a suite of data test cases through pytest until either tests pass
+    or until a maximum number of attempts (needed for incremental tests).
+
+    :param data_suite: the actual "suite" i.e. the contents of a .test file
+    """
+    p_test_data = Path(test_data_prefix)
+    p_root = p_test_data.parent.parent
+    p = p_test_data / f"{data_file_prefix}-meta-{uuid.uuid4()}.test"
+    assert not p.exists()
+    data_suite = dedent_docstring(data_suite)
+    try:
+        p.write_text(data_suite)
+
+        test_nodeid = f"{pytest_node_prefix}::{p.name}"
+        extra_args = [sys.executable, "-m", "pytest", "-n", "0", "-s", *extra_args, test_nodeid]
+        cmd = shlex.join(extra_args)
+        for i in range(max_attempts - 1, -1, -1):
+            print(f">> {cmd}")
+            proc = subprocess.run(extra_args, capture_output=True, check=False, cwd=p_root)
+            if proc.returncode == 0:
+                break
+            prefix = "NESTED PYTEST STDOUT"
+            for line in proc.stdout.decode().splitlines():
+                print(f"{prefix}: {line}")
+                prefix = " " * len(prefix)
+            prefix = "NESTED PYTEST STDERR"
+            for line in proc.stderr.decode().splitlines():
+                print(f"{prefix}: {line}")
+                prefix = " " * len(prefix)
+            print(f"Exit code {proc.returncode} ({i} attempts remaining)")
+
+        return PytestResult(
+            input=data_suite,
+            input_updated=p.read_text(),
+            stdout=proc.stdout.decode(),
+            stderr=proc.stderr.decode(),
+        )
+    finally:
+        p.unlink()
diff --git a/mypy/test/meta/test_diff_helper.py b/mypy/test/meta/test_diff_helper.py
new file mode 100644
index 000000000000..047751fee1d2
--- /dev/null
+++ b/mypy/test/meta/test_diff_helper.py
@@ -0,0 +1,47 @@
+import io
+
+from mypy.test.helpers import Suite, diff_ranges, render_diff_range
+
+
+class DiffHelperSuite(Suite):
+    def test_render_diff_range(self) -> None:
+        expected = ["hello", "world"]
+        actual = ["goodbye", "world"]
+
+        expected_ranges, actual_ranges = diff_ranges(expected, actual)
+
+        output = io.StringIO()
+        render_diff_range(expected_ranges, expected, output=output)
+        assert output.getvalue() == "  hello (diff)\n  world\n"
+        output = io.StringIO()
+        render_diff_range(actual_ranges, actual, output=output)
+        assert output.getvalue() == "  goodbye (diff)\n  world\n"
+
+        expected = ["a", "b", "c", "d", "e", "f", "g", "h", "circle", "i", "j"]
+        actual = ["a", "b", "c", "d", "e", "f", "g", "h", "square", "i", "j"]
+
+        expected_ranges, actual_ranges = diff_ranges(expected, actual)
+
+        output = io.StringIO()
+        render_diff_range(expected_ranges, expected, output=output, indent=0)
+        assert output.getvalue() == "a\nb\nc\n...\nf\ng\nh\ncircle (diff)\ni\nj\n"
+        output = io.StringIO()
+        render_diff_range(actual_ranges, actual, output=output, indent=0)
+        assert output.getvalue() == "a\nb\nc\n...\nf\ng\nh\nsquare (diff)\ni\nj\n"
+
+    def test_diff_ranges(self) -> None:
+        a = ["hello", "world"]
+        b = ["hello", "world"]
+
+        assert diff_ranges(a, b) == (
+            [(0, 0), (0, 2), (2, 2), (2, 2)],
+            [(0, 0), (0, 2), (2, 2), (2, 2)],
+        )
+
+        a = ["hello", "world"]
+        b = ["goodbye", "world"]
+
+        assert diff_ranges(a, b) == (
+            [(0, 1), (1, 2), (2, 2), (2, 2)],
+            [(0, 1), (1, 2), (2, 2), (2, 2)],
+        )
diff --git a/mypy/test/meta/test_parse_data.py b/mypy/test/meta/test_parse_data.py
new file mode 100644
index 000000000000..8c6fc1610e63
--- /dev/null
+++ b/mypy/test/meta/test_parse_data.py
@@ -0,0 +1,73 @@
+"""
+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.
+"""
+
+from mypy.test.helpers import Suite
+from mypy.test.meta._pytest import PytestResult, run_pytest_data_suite
+
+
+def _run_pytest(data_suite: str) -> PytestResult:
+    return run_pytest_data_suite(data_suite, extra_args=[], max_attempts=1)
+
+
+class ParseTestDataSuite(Suite):
+    def test_parse_invalid_case(self) -> None:
+        # Act
+        result = _run_pytest(
+            """
+            [case abc]
+            s: str
+            [case foo-XFAIL]
+            s: str
+            """
+        )
+
+        # Assert
+        assert "Invalid testcase id 'foo-XFAIL'" in result.stdout
+
+    def test_parse_invalid_section(self) -> None:
+        # Act
+        result = _run_pytest(
+            """
+            [case abc]
+            s: str
+            [unknownsection]
+            abc
+            """
+        )
+
+        # Assert
+        expected_lineno = result.input.splitlines().index("[unknownsection]") + 1
+        expected = (
+            f".test:{expected_lineno}: Invalid section header [unknownsection] in case 'abc'"
+        )
+        assert expected in result.stdout
+
+    def test_bad_ge_version_check(self) -> None:
+        # Act
+        actual = _run_pytest(
+            """
+            [case abc]
+            s: str
+            [out version>=3.9]
+            abc
+            """
+        )
+
+        # Assert
+        assert "version>=3.9 always true since minimum runtime version is (3, 9)" in actual.stdout
+
+    def test_bad_eq_version_check(self) -> None:
+        # Act
+        actual = _run_pytest(
+            """
+            [case abc]
+            s: str
+            [out version==3.7]
+            abc
+            """
+        )
+
+        # Assert
+        assert "version==3.7 always false since minimum runtime version is (3, 9)" in actual.stdout
diff --git a/mypy/test/testupdatedata.py b/mypy/test/meta/test_update_data.py
similarity index 72%
rename from mypy/test/testupdatedata.py
rename to mypy/test/meta/test_update_data.py
index 54e9622a5e91..820fd359893e 100644
--- a/mypy/test/testupdatedata.py
+++ b/mypy/test/meta/test_update_data.py
@@ -1,46 +1,26 @@
-import shlex
-import subprocess
-import sys
-import textwrap
-from pathlib import Path
+"""
+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.
+"""
 
-from mypy.test.config import test_data_prefix
 from mypy.test.helpers import Suite
+from mypy.test.meta._pytest import PytestResult, dedent_docstring, run_pytest_data_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_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())
-
-            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, cwd=p_root)
-                if res.returncode == 0:
-                    break
-                print(f"`{cmd}` returned {res.returncode}: {i} attempts remaining")
-
-            return p.read_text()
-        finally:
-            p.unlink()
+def _run_pytest_update_data(data_suite: str) -> PytestResult:
+    """
+    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).
+    """
+    return run_pytest_data_suite(data_suite, extra_args=["--update-data"], max_attempts=3)
+
 
+class UpdateDataSuite(Suite):
     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(
+        result = _run_pytest_update_data(
             """
             [case testCorrect]
             s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
@@ -94,12 +74,12 @@ def test_update_data(self) -> None:
             [file b.py]
             s2: str = 43  # E: baz
             [builtins fixtures/list.pyi]
-            """,
-            max_attempts=3,
+            """
         )
 
         # Assert
-        expected = """
+        expected = dedent_docstring(
+            """
         [case testCorrect]
         s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 
@@ -151,4 +131,5 @@ def test_update_data(self) -> None:
         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()
+        )
+        assert result.input_updated == expected
diff --git a/mypy/test/test_config_parser.py b/mypy/test/test_config_parser.py
new file mode 100644
index 000000000000..597143738f23
--- /dev/null
+++ b/mypy/test/test_config_parser.py
@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import tempfile
+import unittest
+from collections.abc import Iterator
+from pathlib import Path
+
+from mypy.config_parser import _find_config_file
+from mypy.defaults import CONFIG_NAMES, SHARED_CONFIG_NAMES
+
+
+@contextlib.contextmanager
+def chdir(target: Path) -> Iterator[None]:
+    # Replace with contextlib.chdir in Python 3.11
+    dir = os.getcwd()
+    os.chdir(target)
+    try:
+        yield
+    finally:
+        os.chdir(dir)
+
+
+def write_config(path: Path, content: str | None = None) -> None:
+    if path.suffix == ".toml":
+        if content is None:
+            content = "[tool.mypy]\nstrict = true"
+        path.write_text(content)
+    else:
+        if content is None:
+            content = "[mypy]\nstrict = True"
+        path.write_text(content)
+
+
+class FindConfigFileSuite(unittest.TestCase):
+
+    def test_no_config(self) -> None:
+        with tempfile.TemporaryDirectory() as _tmpdir:
+            tmpdir = Path(_tmpdir)
+            (tmpdir / ".git").touch()
+            with chdir(tmpdir):
+                result = _find_config_file()
+                assert result is None
+
+    def test_parent_config_with_and_without_git(self) -> None:
+        for name in CONFIG_NAMES + SHARED_CONFIG_NAMES:
+            with tempfile.TemporaryDirectory() as _tmpdir:
+                tmpdir = Path(_tmpdir)
+
+                config = tmpdir / name
+                write_config(config)
+
+                child = tmpdir / "child"
+                child.mkdir()
+
+                with chdir(child):
+                    result = _find_config_file()
+                    assert result is not None
+                    assert Path(result[2]).resolve() == config.resolve()
+
+                    git = child / ".git"
+                    git.touch()
+
+                    result = _find_config_file()
+                    assert result is None
+
+                    git.unlink()
+                    result = _find_config_file()
+                    assert result is not None
+                    hg = child / ".hg"
+                    hg.touch()
+
+                    result = _find_config_file()
+                    assert result is None
+
+    def test_precedence(self) -> None:
+        with tempfile.TemporaryDirectory() as _tmpdir:
+            tmpdir = Path(_tmpdir)
+
+            pyproject = tmpdir / "pyproject.toml"
+            setup_cfg = tmpdir / "setup.cfg"
+            mypy_ini = tmpdir / "mypy.ini"
+            dot_mypy = tmpdir / ".mypy.ini"
+
+            child = tmpdir / "child"
+            child.mkdir()
+
+            for cwd in [tmpdir, child]:
+                write_config(pyproject)
+                write_config(setup_cfg)
+                write_config(mypy_ini)
+                write_config(dot_mypy)
+
+                with chdir(cwd):
+                    result = _find_config_file()
+                    assert result is not None
+                    assert os.path.basename(result[2]) == "mypy.ini"
+
+                    mypy_ini.unlink()
+                    result = _find_config_file()
+                    assert result is not None
+                    assert os.path.basename(result[2]) == ".mypy.ini"
+
+                    dot_mypy.unlink()
+                    result = _find_config_file()
+                    assert result is not None
+                    assert os.path.basename(result[2]) == "pyproject.toml"
+
+                    pyproject.unlink()
+                    result = _find_config_file()
+                    assert result is not None
+                    assert os.path.basename(result[2]) == "setup.cfg"
+
+    def test_precedence_missing_section(self) -> None:
+        with tempfile.TemporaryDirectory() as _tmpdir:
+            tmpdir = Path(_tmpdir)
+
+            child = tmpdir / "child"
+            child.mkdir()
+
+            parent_mypy = tmpdir / "mypy.ini"
+            child_pyproject = child / "pyproject.toml"
+            write_config(parent_mypy)
+            write_config(child_pyproject, content="")
+
+            with chdir(child):
+                result = _find_config_file()
+                assert result is not None
+                assert Path(result[2]).resolve() == parent_mypy.resolve()
diff --git a/mypy/test/test_find_sources.py b/mypy/test/test_find_sources.py
index 21ba0903a824..321f3405e999 100644
--- a/mypy/test/test_find_sources.py
+++ b/mypy/test/test_find_sources.py
@@ -17,20 +17,20 @@ class FakeFSCache(FileSystemCache):
     def __init__(self, files: set[str]) -> None:
         self.files = {os.path.abspath(f) for f in files}
 
-    def isfile(self, file: str) -> bool:
-        return file in self.files
+    def isfile(self, path: str) -> bool:
+        return path in self.files
 
-    def isdir(self, dir: str) -> bool:
-        if not dir.endswith(os.sep):
-            dir += os.sep
-        return any(f.startswith(dir) for f in self.files)
+    def isdir(self, path: str) -> bool:
+        if not path.endswith(os.sep):
+            path += os.sep
+        return any(f.startswith(path) for f in self.files)
 
-    def listdir(self, dir: str) -> list[str]:
-        if not dir.endswith(os.sep):
-            dir += os.sep
-        return list({f[len(dir) :].split(os.sep)[0] for f in self.files if f.startswith(dir)})
+    def listdir(self, path: str) -> list[str]:
+        if not path.endswith(os.sep):
+            path += os.sep
+        return list({f[len(path) :].split(os.sep)[0] for f in self.files if f.startswith(path)})
 
-    def init_under_package_root(self, file: str) -> bool:
+    def init_under_package_root(self, path: str) -> bool:
         return False
 
 
diff --git a/mypy/test/testargs.py b/mypy/test/testargs.py
index b0cc6b19aa80..7c139902fe90 100644
--- a/mypy/test/testargs.py
+++ b/mypy/test/testargs.py
@@ -4,6 +4,7 @@
 defaults, and that argparse doesn't assign any new members to the Options
 object it creates.
 """
+
 from __future__ import annotations
 
 import argparse
diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index 58c0ee803359..e6415ddff906 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -10,7 +10,6 @@
 from mypy.build import Graph
 from mypy.errors import CompileError
 from mypy.modulefinder import BuildSource, FindModuleCache, SearchPaths
-from mypy.options import TYPE_VAR_TUPLE, UNPACK
 from mypy.test.config import test_data_prefix, test_temp_dir
 from mypy.test.data import DataDrivenTestCase, DataSuite, FileOperation, module_from_path
 from mypy.test.helpers import (
@@ -26,25 +25,26 @@
 from mypy.test.update_data import update_testcase_output
 
 try:
-    import lxml  # type: ignore[import]
+    import lxml  # type: ignore[import-untyped]
 except ImportError:
     lxml = None
 
+
 import pytest
 
 # List of files that contain test case descriptions.
 # 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")
-if sys.version_info < (3, 9):
-    typecheck_files.remove("check-python39.test")
+# Tests that use Python version specific features:
 if sys.version_info < (3, 10):
     typecheck_files.remove("check-python310.test")
 if sys.version_info < (3, 11):
     typecheck_files.remove("check-python311.test")
+if sys.version_info < (3, 12):
+    typecheck_files.remove("check-python312.test")
+if sys.version_info < (3, 13):
+    typecheck_files.remove("check-python313.test")
 
 # Special tests for platforms with case-insensitive filesystems.
 if sys.platform not in ("darwin", "win32"):
@@ -100,9 +100,11 @@ def _filename(_msg: str) -> str:
     def run_case_once(
         self,
         testcase: DataDrivenTestCase,
-        operations: list[FileOperation] = [],
+        operations: list[FileOperation] | None = None,
         incremental_step: int = 0,
     ) -> None:
+        if operations is None:
+            operations = []
         original_program_text = "\n".join(testcase.input)
         module_data = self.parse_module(original_program_text, incremental_step)
 
@@ -125,13 +127,9 @@ def run_case_once(
         # Parse options after moving files (in case mypy.ini is being moved).
         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]
         options.show_traceback = True
 
         # Enable some options automatically based on test file name.
-        if "optional" in testcase.file:
-            options.strict_optional = True
         if "columns" in testcase.file:
             options.show_column_numbers = True
         if "errorcodes" in testcase.file:
diff --git a/mypy/test/testcmdline.py b/mypy/test/testcmdline.py
index 30ecef07a821..9bc02d319964 100644
--- a/mypy/test/testcmdline.py
+++ b/mypy/test/testcmdline.py
@@ -20,7 +20,7 @@
 )
 
 try:
-    import lxml  # type: ignore[import]
+    import lxml  # type: ignore[import-untyped]
 except ImportError:
     lxml = None
 
diff --git a/mypy/test/testconstraints.py b/mypy/test/testconstraints.py
index b46f31327150..277694a328c9 100644
--- a/mypy/test/testconstraints.py
+++ b/mypy/test/testconstraints.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import pytest
-
 from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, infer_constraints
 from mypy.test.helpers import Suite
 from mypy.test.typefixture import TypeFixture
@@ -22,7 +20,6 @@ def test_basic_type_variable(self) -> None:
                 Constraint(type_var=fx.t, op=direction, target=fx.a)
             ]
 
-    @pytest.mark.xfail
     def test_basic_type_var_tuple_subtype(self) -> None:
         fx = self.fx
         assert infer_constraints(
@@ -33,13 +30,18 @@ def test_basic_type_var_tuple_subtype(self) -> None:
 
     def test_basic_type_var_tuple(self) -> None:
         fx = self.fx
-        assert infer_constraints(
-            Instance(fx.gvi, [UnpackType(fx.ts)]), Instance(fx.gvi, [fx.a, fx.b]), SUPERTYPE_OF
-        ) == [
+        assert set(
+            infer_constraints(
+                Instance(fx.gvi, [UnpackType(fx.ts)]), Instance(fx.gvi, [fx.a, fx.b]), SUPERTYPE_OF
+            )
+        ) == {
             Constraint(
                 type_var=fx.ts, op=SUPERTYPE_OF, target=TupleType([fx.a, fx.b], fx.std_tuple)
-            )
-        ]
+            ),
+            Constraint(
+                type_var=fx.ts, op=SUBTYPE_OF, target=TupleType([fx.a, fx.b], fx.std_tuple)
+            ),
+        }
 
     def test_type_var_tuple_with_prefix_and_suffix(self) -> None:
         fx = self.fx
@@ -54,10 +56,13 @@ def test_type_var_tuple_with_prefix_and_suffix(self) -> None:
             Constraint(
                 type_var=fx.ts, op=SUPERTYPE_OF, target=TupleType([fx.b, fx.c], fx.std_tuple)
             ),
+            Constraint(
+                type_var=fx.ts, op=SUBTYPE_OF, target=TupleType([fx.b, fx.c], fx.std_tuple)
+            ),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.d),
         }
 
-    def test_unpack_homogenous_tuple(self) -> None:
+    def test_unpack_homogeneous_tuple(self) -> None:
         fx = self.fx
         assert set(
             infer_constraints(
@@ -67,10 +72,12 @@ def test_unpack_homogenous_tuple(self) -> None:
             )
         ) == {
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.a),
+            Constraint(type_var=fx.t, op=SUBTYPE_OF, target=fx.a),
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.b),
+            Constraint(type_var=fx.t, op=SUBTYPE_OF, target=fx.b),
         }
 
-    def test_unpack_homogenous_tuple_with_prefix_and_suffix(self) -> None:
+    def test_unpack_homogeneous_tuple_with_prefix_and_suffix(self) -> None:
         fx = self.fx
         assert set(
             infer_constraints(
@@ -81,51 +88,26 @@ def test_unpack_homogenous_tuple_with_prefix_and_suffix(self) -> None:
         ) == {
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.a),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.b),
+            Constraint(type_var=fx.s, op=SUBTYPE_OF, target=fx.b),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.c),
+            Constraint(type_var=fx.s, op=SUBTYPE_OF, target=fx.c),
             Constraint(type_var=fx.u, op=SUPERTYPE_OF, target=fx.d),
         }
 
-    def test_unpack_tuple(self) -> None:
-        fx = self.fx
-        assert set(
-            infer_constraints(
-                Instance(
-                    fx.gvi,
-                    [
-                        UnpackType(
-                            TupleType([fx.t, fx.s], fallback=Instance(fx.std_tuplei, [fx.o]))
-                        )
-                    ],
-                ),
-                Instance(fx.gvi, [fx.a, fx.b]),
-                SUPERTYPE_OF,
-            )
-        ) == {
-            Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.a),
-            Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.b),
-        }
-
     def test_unpack_with_prefix_and_suffix(self) -> None:
         fx = self.fx
         assert set(
             infer_constraints(
-                Instance(
-                    fx.gv2i,
-                    [
-                        fx.u,
-                        UnpackType(
-                            TupleType([fx.t, fx.s], fallback=Instance(fx.std_tuplei, [fx.o]))
-                        ),
-                        fx.u,
-                    ],
-                ),
+                Instance(fx.gv2i, [fx.u, fx.t, fx.s, fx.u]),
                 Instance(fx.gv2i, [fx.a, fx.b, fx.c, fx.d]),
                 SUPERTYPE_OF,
             )
         ) == {
             Constraint(type_var=fx.u, op=SUPERTYPE_OF, target=fx.a),
             Constraint(type_var=fx.t, op=SUPERTYPE_OF, target=fx.b),
+            Constraint(type_var=fx.t, op=SUBTYPE_OF, target=fx.b),
             Constraint(type_var=fx.s, op=SUPERTYPE_OF, target=fx.c),
+            Constraint(type_var=fx.s, op=SUBTYPE_OF, target=fx.c),
             Constraint(type_var=fx.u, op=SUPERTYPE_OF, target=fx.d),
         }
 
@@ -133,16 +115,7 @@ def test_unpack_tuple_length_non_match(self) -> None:
         fx = self.fx
         assert set(
             infer_constraints(
-                Instance(
-                    fx.gv2i,
-                    [
-                        fx.u,
-                        UnpackType(
-                            TupleType([fx.t, fx.s], fallback=Instance(fx.std_tuplei, [fx.o]))
-                        ),
-                        fx.u,
-                    ],
-                ),
+                Instance(fx.gv2i, [fx.u, fx.t, fx.s, fx.u]),
                 Instance(fx.gv2i, [fx.a, fx.b, fx.d]),
                 SUPERTYPE_OF,
             )
diff --git a/mypy/test/testdaemon.py b/mypy/test/testdaemon.py
index e3cdf44d89f2..7115e682e60d 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/testdeps.py b/mypy/test/testdeps.py
index f9a059672de8..7c845eab8b57 100644
--- a/mypy/test/testdeps.py
+++ b/mypy/test/testdeps.py
@@ -3,8 +3,11 @@
 from __future__ import annotations
 
 import os
+import sys
 from collections import defaultdict
 
+import pytest
+
 from mypy import build
 from mypy.errors import CompileError
 from mypy.modulefinder import BuildSource
@@ -28,6 +31,8 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
         src = "\n".join(testcase.input)
         dump_all = "# __dump_all__" in src
         options = parse_options(src, testcase, incremental_step=1)
+        if options.python_version > sys.version_info:
+            pytest.skip("Test case requires a newer Python version")
         options.use_builtins_fixtures = True
         options.show_traceback = True
         options.cache_dir = os.devnull
diff --git a/mypy/test/testdiff.py b/mypy/test/testdiff.py
index 5e2e0bc2ca5a..0559b33c33e2 100644
--- a/mypy/test/testdiff.py
+++ b/mypy/test/testdiff.py
@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import os
+import sys
+
+import pytest
 
 from mypy import build
-from mypy.defaults import PYTHON3_VERSION
 from mypy.errors import CompileError
 from mypy.modulefinder import BuildSource
 from mypy.nodes import MypyFile
@@ -24,6 +26,8 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
         files_dict = dict(testcase.files)
         second_src = files_dict["tmp/next.py"]
         options = parse_options(first_src, testcase, 1)
+        if options.python_version > sys.version_info:
+            pytest.skip("Test case requires a newer Python version")
 
         messages1, files1 = self.build(first_src, options)
         messages2, files2 = self.build(second_src, options)
@@ -53,7 +57,6 @@ def build(self, source: str, options: Options) -> tuple[list[str], dict[str, Myp
         options.use_builtins_fixtures = True
         options.show_traceback = True
         options.cache_dir = os.devnull
-        options.python_version = PYTHON3_VERSION
         options.allow_empty_bodies = True
         try:
             result = build.build(
diff --git a/mypy/test/testerrorstream.py b/mypy/test/testerrorstream.py
index 4b98f10fc9ca..a54a3495ddb2 100644
--- a/mypy/test/testerrorstream.py
+++ b/mypy/test/testerrorstream.py
@@ -1,4 +1,5 @@
 """Tests for mypy incremental error output."""
+
 from __future__ import annotations
 
 from mypy import build
@@ -29,7 +30,7 @@ def test_error_stream(testcase: DataDrivenTestCase) -> None:
 
     logged_messages: list[str] = []
 
-    def flush_errors(msgs: list[str], serious: bool) -> None:
+    def flush_errors(filename: str | None, msgs: list[str], serious: bool) -> None:
         if msgs:
             logged_messages.append("==== Errors flushed ====")
             logged_messages.extend(msgs)
diff --git a/mypy/test/testfinegrained.py b/mypy/test/testfinegrained.py
index 5b4c816b5c38..b098c1fb0ad2 100644
--- a/mypy/test/testfinegrained.py
+++ b/mypy/test/testfinegrained.py
@@ -29,7 +29,7 @@
 from mypy.errors import CompileError
 from mypy.find_sources import create_source_list
 from mypy.modulefinder import BuildSource
-from mypy.options import TYPE_VAR_TUPLE, UNPACK, Options
+from mypy.options import Options
 from mypy.server.mergecheck import check_consistency
 from mypy.server.update import sort_messages_preserving_file_order
 from mypy.test.config import test_temp_dir
@@ -70,15 +70,11 @@ 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:
         if self.should_skip(testcase):
             pytest.skip()
-            return
 
         main_src = "\n".join(testcase.input)
         main_path = os.path.join(test_temp_dir, "main")
@@ -86,6 +82,9 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
             f.write(main_src)
 
         options = self.get_options(main_src, testcase, build_cache=False)
+        if options.python_version > sys.version_info:
+            pytest.skip("Test case requires a newer Python version")
+
         build_options = self.get_options(main_src, testcase, build_cache=True)
         server = Server(options, DEFAULT_STATUS_FILE)
 
@@ -101,8 +100,8 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
         if messages:
             a.extend(normalize_messages(messages))
 
-        assert testcase.tmpdir
-        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir.name))
+        assert testcase.tmpdir is not None
+        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir))
         a.extend(self.maybe_inspect(step, server, main_src))
 
         if server.fine_grained_manager:
@@ -153,7 +152,7 @@ def get_options(self, source: str, testcase: DataDrivenTestCase, build_cache: bo
         options.use_fine_grained_cache = self.use_cache and not build_cache
         options.cache_fine_grained = self.use_cache
         options.local_partial_types = True
-        options.enable_incomplete_feature = [TYPE_VAR_TUPLE, UNPACK]
+        options.export_types = "inspect" in testcase.file
         # Treat empty bodies safely for these test cases.
         options.allow_empty_bodies = not testcase.name.endswith("_no_empty")
         if re.search("flags:.*--follow-imports", source) is None:
@@ -168,7 +167,7 @@ def get_options(self, source: str, testcase: DataDrivenTestCase, build_cache: bo
         return options
 
     def run_check(self, server: Server, sources: list[BuildSource]) -> list[str]:
-        response = server.check(sources, export_types=True, is_tty=False, terminal_width=-1)
+        response = server.check(sources, export_types=False, is_tty=False, terminal_width=-1)
         out = response["out"] or response["err"]
         assert isinstance(out, str)
         return out.splitlines()
@@ -248,8 +247,8 @@ def perform_step(
         new_messages = normalize_messages(new_messages)
 
         a = new_messages
-        assert testcase.tmpdir
-        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir.name))
+        assert testcase.tmpdir is not None
+        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir))
         a.extend(self.maybe_inspect(step, server, main_src))
 
         return a, triggered
@@ -321,6 +320,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)
 
@@ -355,7 +355,7 @@ def maybe_inspect(self, step: int, server: Server, src: str) -> list[str]:
             )
             val = res["error"] if "error" in res else res["out"] + res["err"]
             output.extend(val.strip().split("\n"))
-        return normalize_messages(output)
+        return output
 
     def get_suggest(self, program_text: str, incremental_step: int) -> list[tuple[str, str]]:
         step_bit = "1?" if incremental_step == 1 else str(incremental_step)
diff --git a/mypy/test/testformatter.py b/mypy/test/testformatter.py
index f64527e7804a..9f8bb5d82408 100644
--- a/mypy/test/testformatter.py
+++ b/mypy/test/testformatter.py
@@ -52,14 +52,14 @@ def test_trim_source(self) -> None:
 
     def test_split_words(self) -> None:
         assert split_words("Simple message") == ["Simple", "message"]
-        assert split_words('Message with "Some[Long, Types]"' " in it") == [
+        assert split_words('Message with "Some[Long, Types]" in it') == [
             "Message",
             "with",
             '"Some[Long, Types]"',
             "in",
             "it",
         ]
-        assert split_words('Message with "Some[Long, Types]"' " and [error-code]") == [
+        assert split_words('Message with "Some[Long, Types]" and [error-code]') == [
             "Message",
             "with",
             '"Some[Long, Types]"',
diff --git a/mypy/test/testgraph.py b/mypy/test/testgraph.py
index ce7697142ff2..238869f36fdf 100644
--- a/mypy/test/testgraph.py
+++ b/mypy/test/testgraph.py
@@ -3,19 +3,12 @@
 from __future__ import annotations
 
 import sys
-from typing import AbstractSet
+from collections.abc import Set as 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
@@ -57,7 +50,7 @@ def _make_manager(self) -> BuildManager:
             plugin=Plugin(options),
             plugins_snapshot={},
             errors=errors,
-            flush_errors=lambda msgs, serious: None,
+            flush_errors=lambda filename, msgs, serious: None,
             fscache=fscache,
             stdout=sys.stdout,
             stderr=sys.stderr,
diff --git a/mypy/test/testinfer.py b/mypy/test/testinfer.py
index 08926c179623..9c18624e0283 100644
--- a/mypy/test/testinfer.py
+++ b/mypy/test/testinfer.py
@@ -134,7 +134,7 @@ def expand_caller_kinds(
 
 
 def expand_callee_kinds(
-    kinds_and_names: list[ArgKind | tuple[ArgKind, str]]
+    kinds_and_names: list[ArgKind | tuple[ArgKind, str]],
 ) -> tuple[list[ArgKind], list[str | None]]:
     kinds = []
     names: list[str | None] = []
@@ -366,7 +366,7 @@ def test_single_pair(self) -> None:
                 )
 
     def test_empty_pair_list(self) -> None:
-        # This case should never occur in practice -- ComparisionExprs
+        # This case should never occur in practice -- ComparisonExprs
         # always contain at least one comparison. But in case it does...
 
         self.assertEqual(group_comparison_operands([], {}, set()), [])
diff --git a/mypy/test/testipc.py b/mypy/test/testipc.py
index 9034f514bb45..0224035a7b61 100644
--- a/mypy/test/testipc.py
+++ b/mypy/test/testipc.py
@@ -2,7 +2,7 @@
 
 import sys
 import time
-from multiprocessing import Process, Queue
+from multiprocessing import Queue, get_context
 from unittest import TestCase, main
 
 import pytest
@@ -15,41 +15,84 @@
 def server(msg: str, q: Queue[str]) -> None:
     server = IPCServer(CONNECTION_NAME)
     q.put(server.connection_name)
-    data = b""
+    data = ""
     while not data:
         with server:
-            server.write(msg.encode())
+            server.write(msg)
             data = server.read()
     server.cleanup()
 
 
+def server_multi_message_echo(q: Queue[str]) -> None:
+    server = IPCServer(CONNECTION_NAME)
+    q.put(server.connection_name)
+    data = ""
+    with server:
+        while data != "quit":
+            data = server.read()
+            server.write(data)
+    server.cleanup()
+
+
 class IPCTests(TestCase):
+    def setUp(self) -> None:
+        if sys.platform == "linux":
+            # The default "fork" start method is potentially unsafe
+            self.ctx = get_context("forkserver")
+        else:
+            self.ctx = get_context("spawn")
+
     def test_transaction_large(self) -> None:
-        queue: Queue[str] = Queue()
+        queue: Queue[str] = self.ctx.Queue()
         msg = "t" * 200000  # longer than the max read size of 100_000
-        p = Process(target=server, args=(msg, queue), daemon=True)
+        p = self.ctx.Process(target=server, args=(msg, queue), daemon=True)
         p.start()
         connection_name = queue.get()
         with IPCClient(connection_name, timeout=1) as client:
-            assert client.read() == msg.encode()
-            client.write(b"test")
+            assert client.read() == msg
+            client.write("test")
         queue.close()
         queue.join_thread()
         p.join()
 
     def test_connect_twice(self) -> None:
-        queue: Queue[str] = Queue()
+        queue: Queue[str] = self.ctx.Queue()
         msg = "this is a test message"
-        p = Process(target=server, args=(msg, queue), daemon=True)
+        p = self.ctx.Process(target=server, args=(msg, queue), daemon=True)
         p.start()
         connection_name = queue.get()
         with IPCClient(connection_name, timeout=1) as client:
-            assert client.read() == msg.encode()
-            client.write(b"")  # don't let the server hang up yet, we want to connect again.
+            assert client.read() == msg
+            client.write("")  # don't let the server hang up yet, we want to connect again.
 
         with IPCClient(connection_name, timeout=1) as client:
-            assert client.read() == msg.encode()
-            client.write(b"test")
+            assert client.read() == msg
+            client.write("test")
+        queue.close()
+        queue.join_thread()
+        p.join()
+        assert p.exitcode == 0
+
+    def test_multiple_messages(self) -> None:
+        queue: Queue[str] = self.ctx.Queue()
+        p = self.ctx.Process(target=server_multi_message_echo, args=(queue,), daemon=True)
+        p.start()
+        connection_name = queue.get()
+        with IPCClient(connection_name, timeout=1) as client:
+            # "foo bar" with extra accents on letters.
+            # In UTF-8 encoding so we don't confuse editors opening this file.
+            fancy_text = b"f\xcc\xb6o\xcc\xb2\xf0\x9d\x91\x9c \xd0\xb2\xe2\xb7\xa1a\xcc\xb6r\xcc\x93\xcd\x98\xcd\x8c"
+            client.write(fancy_text.decode("utf-8"))
+            assert client.read() == fancy_text.decode("utf-8")
+
+            client.write("Test with spaces")
+            client.write("Test write before reading previous")
+            time.sleep(0)  # yield to the server to force reading of all messages by server.
+            assert client.read() == "Test with spaces"
+            assert client.read() == "Test write before reading previous"
+
+            client.write("quit")
+            assert client.read() == "quit"
         queue.close()
         queue.join_thread()
         p.join()
diff --git a/mypy/test/testmerge.py b/mypy/test/testmerge.py
index 0582c9ed5882..51a4ff39dd9a 100644
--- a/mypy/test/testmerge.py
+++ b/mypy/test/testmerge.py
@@ -13,7 +13,6 @@
     UNBOUND_IMPORTED,
     Expression,
     MypyFile,
-    Node,
     SymbolTable,
     SymbolTableNode,
     TypeInfo,
@@ -172,10 +171,7 @@ def format_symbol_table_node(self, node: SymbolTableNode) -> str:
             if node.kind == UNBOUND_IMPORTED:
                 return "UNBOUND_IMPORTED"
             return "None"
-        if isinstance(node.node, Node):
-            s = f"{str(type(node.node).__name__)}<{self.id_mapper.id(node.node)}>"
-        else:
-            s = f"? ({type(node.node)})"
+        s = f"{str(type(node.node).__name__)}<{self.id_mapper.id(node.node)}>"
         if (
             isinstance(node.node, Var)
             and node.node.type
diff --git a/mypy/test/testmodulefinder.py b/mypy/test/testmodulefinder.py
index 943913d6cadb..d4ee3af041c5 100644
--- a/mypy/test/testmodulefinder.py
+++ b/mypy/test/testmodulefinder.py
@@ -53,12 +53,12 @@ def test__no_namespace_packages__find_a_in_pkg1(self) -> None:
         Find find pkg1/a.py for "a" with namespace_packages False.
         """
         found_module = self.fmc_nons.find_module("a")
-        expected = os.path.join(data_path, "pkg1", "a.py")
+        expected = os.path.abspath(os.path.join(data_path, "pkg1", "a.py"))
         assert_equal(expected, found_module)
 
     def test__no_namespace_packages__find_b_in_pkg2(self) -> None:
         found_module = self.fmc_ns.find_module("b")
-        expected = os.path.join(data_path, "pkg2", "b", "__init__.py")
+        expected = os.path.abspath(os.path.join(data_path, "pkg2", "b", "__init__.py"))
         assert_equal(expected, found_module)
 
     def test__find_nsx_as_namespace_pkg_in_pkg1(self) -> None:
@@ -67,7 +67,7 @@ def test__find_nsx_as_namespace_pkg_in_pkg1(self) -> None:
         the path to the first one found in mypypath.
         """
         found_module = self.fmc_ns.find_module("nsx")
-        expected = os.path.join(data_path, "nsx-pkg1", "nsx")
+        expected = os.path.abspath(os.path.join(data_path, "nsx-pkg1", "nsx"))
         assert_equal(expected, found_module)
 
     def test__find_nsx_a_init_in_pkg1(self) -> None:
@@ -75,7 +75,7 @@ def test__find_nsx_a_init_in_pkg1(self) -> None:
         Find nsx-pkg1/nsx/a/__init__.py for "nsx.a" in namespace mode.
         """
         found_module = self.fmc_ns.find_module("nsx.a")
-        expected = os.path.join(data_path, "nsx-pkg1", "nsx", "a", "__init__.py")
+        expected = os.path.abspath(os.path.join(data_path, "nsx-pkg1", "nsx", "a", "__init__.py"))
         assert_equal(expected, found_module)
 
     def test__find_nsx_b_init_in_pkg2(self) -> None:
@@ -83,7 +83,7 @@ def test__find_nsx_b_init_in_pkg2(self) -> None:
         Find nsx-pkg2/nsx/b/__init__.py for "nsx.b" in namespace mode.
         """
         found_module = self.fmc_ns.find_module("nsx.b")
-        expected = os.path.join(data_path, "nsx-pkg2", "nsx", "b", "__init__.py")
+        expected = os.path.abspath(os.path.join(data_path, "nsx-pkg2", "nsx", "b", "__init__.py"))
         assert_equal(expected, found_module)
 
     def test__find_nsx_c_c_in_pkg3(self) -> None:
@@ -91,7 +91,7 @@ def test__find_nsx_c_c_in_pkg3(self) -> None:
         Find nsx-pkg3/nsx/c/c.py for "nsx.c.c" in namespace mode.
         """
         found_module = self.fmc_ns.find_module("nsx.c.c")
-        expected = os.path.join(data_path, "nsx-pkg3", "nsx", "c", "c.py")
+        expected = os.path.abspath(os.path.join(data_path, "nsx-pkg3", "nsx", "c", "c.py"))
         assert_equal(expected, found_module)
 
     def test__find_nsy_a__init_pyi(self) -> None:
@@ -99,7 +99,7 @@ def test__find_nsy_a__init_pyi(self) -> None:
         Prefer nsy-pkg1/a/__init__.pyi file over __init__.py.
         """
         found_module = self.fmc_ns.find_module("nsy.a")
-        expected = os.path.join(data_path, "nsy-pkg1", "nsy", "a", "__init__.pyi")
+        expected = os.path.abspath(os.path.join(data_path, "nsy-pkg1", "nsy", "a", "__init__.pyi"))
         assert_equal(expected, found_module)
 
     def test__find_nsy_b__init_py(self) -> None:
@@ -109,7 +109,7 @@ def test__find_nsy_b__init_py(self) -> None:
         a package is preferred over a module.
         """
         found_module = self.fmc_ns.find_module("nsy.b")
-        expected = os.path.join(data_path, "nsy-pkg2", "nsy", "b", "__init__.py")
+        expected = os.path.abspath(os.path.join(data_path, "nsy-pkg2", "nsy", "b", "__init__.py"))
         assert_equal(expected, found_module)
 
     def test__find_nsy_c_pyi(self) -> None:
@@ -119,17 +119,17 @@ def test__find_nsy_c_pyi(self) -> None:
         .pyi is preferred over .py.
         """
         found_module = self.fmc_ns.find_module("nsy.c")
-        expected = os.path.join(data_path, "nsy-pkg2", "nsy", "c.pyi")
+        expected = os.path.abspath(os.path.join(data_path, "nsy-pkg2", "nsy", "c.pyi"))
         assert_equal(expected, found_module)
 
     def test__find_a_in_pkg1(self) -> None:
         found_module = self.fmc_ns.find_module("a")
-        expected = os.path.join(data_path, "pkg1", "a.py")
+        expected = os.path.abspath(os.path.join(data_path, "pkg1", "a.py"))
         assert_equal(expected, found_module)
 
     def test__find_b_init_in_pkg2(self) -> None:
         found_module = self.fmc_ns.find_module("b")
-        expected = os.path.join(data_path, "pkg2", "b", "__init__.py")
+        expected = os.path.abspath(os.path.join(data_path, "pkg2", "b", "__init__.py"))
         assert_equal(expected, found_module)
 
     def test__find_d_nowhere(self) -> None:
@@ -165,7 +165,7 @@ def setUp(self) -> None:
         self.fmc_nons = FindModuleCache(self.search_paths, fscache=None, options=options)
 
     def path(self, *parts: str) -> str:
-        return os.path.join(self.package_dir, *parts)
+        return os.path.abspath(os.path.join(self.package_dir, *parts))
 
     def test__packages_with_ns(self) -> None:
         cases = [
@@ -195,6 +195,9 @@ def test__packages_with_ns(self) -> None:
             ("pkg_typed.b", self.path("pkg_typed", "b", "__init__.py")),
             ("pkg_typed.b.c", self.path("pkg_typed", "b", "c.py")),
             ("pkg_typed.a.a_var", ModuleNotFoundReason.NOT_FOUND),
+            # Regular package with py.typed, bundled stubs, and external stubs-only package
+            ("pkg_typed_w_stubs", self.path("pkg_typed_w_stubs-stubs", "__init__.pyi")),
+            ("pkg_typed_w_stubs.spam", self.path("pkg_typed_w_stubs-stubs", "spam.pyi")),
             # Regular package without py.typed
             ("pkg_untyped", ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS),
             ("pkg_untyped.a", ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS),
@@ -214,7 +217,7 @@ def test__packages_with_ns(self) -> None:
             # A regular package with an installed set of stubs
             ("foo.bar", self.path("foo-stubs", "bar.pyi")),
             # A regular, non-site-packages module
-            ("a", os.path.join(data_path, "pkg1", "a.py")),
+            ("a", os.path.abspath(os.path.join(data_path, "pkg1", "a.py"))),
         ]
         for module, expected in cases:
             template = "Find(" + module + ") got {}; expected {}"
@@ -250,6 +253,9 @@ def test__packages_without_ns(self) -> None:
             ("pkg_typed.b", self.path("pkg_typed", "b", "__init__.py")),
             ("pkg_typed.b.c", self.path("pkg_typed", "b", "c.py")),
             ("pkg_typed.a.a_var", ModuleNotFoundReason.NOT_FOUND),
+            # Regular package with py.typed, bundled stubs, and external stubs-only package
+            ("pkg_typed_w_stubs", self.path("pkg_typed_w_stubs-stubs", "__init__.pyi")),
+            ("pkg_typed_w_stubs.spam", self.path("pkg_typed_w_stubs-stubs", "spam.pyi")),
             # Regular package without py.typed
             ("pkg_untyped", ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS),
             ("pkg_untyped.a", ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS),
@@ -269,7 +275,7 @@ def test__packages_without_ns(self) -> None:
             # A regular package with an installed set of stubs
             ("foo.bar", self.path("foo-stubs", "bar.pyi")),
             # A regular, non-site-packages module
-            ("a", os.path.join(data_path, "pkg1", "a.py")),
+            ("a", os.path.abspath(os.path.join(data_path, "pkg1", "a.py"))),
         ]
         for module, expected in cases:
             template = "Find(" + module + ") got {}; expected {}"
diff --git a/mypy/test/testoutput.py b/mypy/test/testoutput.py
new file mode 100644
index 000000000000..41f6881658c8
--- /dev/null
+++ b/mypy/test/testoutput.py
@@ -0,0 +1,58 @@
+"""Test cases for `--output=json`.
+
+These cannot be run by the usual unit test runner because of the backslashes in
+the output, which get normalized to forward slashes by the test suite on Windows.
+"""
+
+from __future__ import annotations
+
+import os
+import os.path
+
+from mypy import api
+from mypy.defaults import PYTHON3_VERSION
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase, DataSuite
+
+
+class OutputJSONsuite(DataSuite):
+    files = ["outputjson.test"]
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        test_output_json(testcase)
+
+
+def test_output_json(testcase: DataDrivenTestCase) -> None:
+    """Runs Mypy in a subprocess, and ensures that `--output=json` works as intended."""
+    mypy_cmdline = ["--output=json"]
+    mypy_cmdline.append(f"--python-version={'.'.join(map(str, PYTHON3_VERSION))}")
+
+    # Write the program to a file.
+    program_path = os.path.join(test_temp_dir, "main")
+    mypy_cmdline.append(program_path)
+    with open(program_path, "w", encoding="utf8") as file:
+        for s in testcase.input:
+            file.write(f"{s}\n")
+
+    output = []
+    # Type check the program.
+    out, err, returncode = api.run(mypy_cmdline)
+    # split lines, remove newlines, and remove directory of test case
+    for line in (out + err).rstrip("\n").splitlines():
+        if line.startswith(test_temp_dir + os.sep):
+            output.append(line[len(test_temp_dir + os.sep) :].rstrip("\r\n"))
+        else:
+            output.append(line.rstrip("\r\n"))
+
+    if returncode > 1:
+        output.append("!!! Mypy crashed !!!")
+
+    # Remove temp file.
+    os.remove(program_path)
+
+    # JSON encodes every `\` character into `\\`, so we need to remove `\\` from windows paths
+    # and `/` from POSIX paths
+    json_os_separator = os.sep.replace("\\", "\\\\")
+    normalized_output = [line.replace(test_temp_dir + json_os_separator, "") for line in output]
+
+    assert normalized_output == testcase.output
diff --git a/mypy/test/testparse.py b/mypy/test/testparse.py
index 0140eb072821..074ccfb379d0 100644
--- a/mypy/test/testparse.py
+++ b/mypy/test/testparse.py
@@ -8,7 +8,7 @@
 
 from mypy import defaults
 from mypy.config_parser import parse_mypy_comments
-from mypy.errors import CompileError
+from mypy.errors import CompileError, Errors
 from mypy.options import Options
 from mypy.parse import parse
 from mypy.test.data import DataDrivenTestCase, DataSuite
@@ -23,6 +23,10 @@ class ParserSuite(DataSuite):
 
     if sys.version_info < (3, 10):
         files.remove("parse-python310.test")
+    if sys.version_info < (3, 12):
+        files.remove("parse-python312.test")
+    if sys.version_info < (3, 13):
+        files.remove("parse-python313.test")
 
     def run_case(self, testcase: DataDrivenTestCase) -> None:
         test_parser(testcase)
@@ -39,6 +43,10 @@ def test_parser(testcase: DataDrivenTestCase) -> None:
 
     if testcase.file.endswith("python310.test"):
         options.python_version = (3, 10)
+    elif testcase.file.endswith("python312.test"):
+        options.python_version = (3, 12)
+    elif testcase.file.endswith("python313.test"):
+        options.python_version = (3, 13)
     else:
         options.python_version = defaults.PYTHON3_VERSION
 
@@ -51,7 +59,12 @@ def test_parser(testcase: DataDrivenTestCase) -> None:
 
     try:
         n = parse(
-            bytes(source, "ascii"), fnam="main", module="__main__", errors=None, options=options
+            bytes(source, "ascii"),
+            fnam="main",
+            module="__main__",
+            errors=Errors(options),
+            options=options,
+            raise_on_error=True,
         )
         a = n.str_with_options(options).split("\n")
     except CompileError as e:
@@ -82,7 +95,12 @@ def test_parse_error(testcase: DataDrivenTestCase) -> None:
             skip()
         # Compile temporary file. The test file contains non-ASCII characters.
         parse(
-            bytes("\n".join(testcase.input), "utf-8"), INPUT_FILE_NAME, "__main__", None, options
+            bytes("\n".join(testcase.input), "utf-8"),
+            INPUT_FILE_NAME,
+            "__main__",
+            errors=Errors(options),
+            options=options,
+            raise_on_error=True,
         )
         raise AssertionError("No errors reported")
     except CompileError as e:
diff --git a/mypy/test/testpep561.py b/mypy/test/testpep561.py
index ed8674e8d5bb..0afb69bc0c99 100644
--- a/mypy/test/testpep561.py
+++ b/mypy/test/testpep561.py
@@ -5,8 +5,8 @@
 import subprocess
 import sys
 import tempfile
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator
 
 import filelock
 
@@ -23,8 +23,8 @@ class PEP561Suite(DataSuite):
     files = ["pep561.test"]
     base_path = "."
 
-    def run_case(self, test_case: DataDrivenTestCase) -> None:
-        test_pep561(test_case)
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        test_pep561(testcase)
 
 
 @contextmanager
@@ -46,23 +46,38 @@ 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)
+    ):
+        # 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, 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}
@@ -85,18 +100,20 @@ def test_pep561(testcase: DataDrivenTestCase) -> None:
     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
+        if editable:
+            # Editable installs with PEP 660 require pip>=21.3
+            upgrade_pip(python_executable)
         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)
@@ -113,7 +130,7 @@ def test_pep561(testcase: DataDrivenTestCase) -> None:
 
         steps = testcase.find_steps()
         if steps != [[]]:
-            steps = [[]] + steps  # type: ignore[assignment]
+            steps = [[]] + steps
 
         for i, operations in enumerate(steps):
             perform_file_operations(operations)
@@ -128,8 +145,11 @@ def test_pep561(testcase: DataDrivenTestCase) -> None:
                     output.append(line[len(test_temp_dir + os.sep) :].rstrip("\r\n"))
                 else:
                     # Normalize paths so that the output is the same on Windows and Linux/macOS.
-                    line = line.replace(test_temp_dir + os.sep, test_temp_dir + "/")
-                    output.append(line.rstrip("\r\n"))
+                    # Yes, this is naive: replace all slashes preceding first colon, if any.
+                    path, *rest = line.split(":", maxsplit=1)
+                    if rest:
+                        path = path.replace(os.sep, "/")
+                    output.append(":".join([path, *rest]).rstrip("\r\n"))
             iter_count = "" if i == 0 else f" on iteration {i + 1}"
             expected = testcase.output if i == 0 else testcase.output2.get(i + 1, [])
 
@@ -156,38 +176,3 @@ def parse_mypy_args(line: str) -> list[str]:
     if not m:
         return []  # No args; mypy will spit out an error.
     return m.group(1).split()
-
-
-def test_mypy_path_is_respected() -> None:
-    assert False
-    packages = "packages"
-    pkg_name = "a"
-    with tempfile.TemporaryDirectory() as temp_dir:
-        old_dir = os.getcwd()
-        os.chdir(temp_dir)
-        try:
-            # Create the pkg for files to go into
-            full_pkg_name = os.path.join(temp_dir, packages, pkg_name)
-            os.makedirs(full_pkg_name)
-
-            # Create the empty __init__ file to declare a package
-            pkg_init_name = os.path.join(temp_dir, packages, pkg_name, "__init__.py")
-            open(pkg_init_name, "w", encoding="utf8").close()
-
-            mypy_config_path = os.path.join(temp_dir, "mypy.ini")
-            with open(mypy_config_path, "w") as mypy_file:
-                mypy_file.write("[mypy]\n")
-                mypy_file.write(f"mypy_path = ./{packages}\n")
-
-            with virtualenv() as venv:
-                venv_dir, python_executable = venv
-
-                cmd_line_args = []
-                if python_executable != sys.executable:
-                    cmd_line_args.append(f"--python-executable={python_executable}")
-                cmd_line_args.extend(["--config-file", mypy_config_path, "--package", pkg_name])
-
-                out, err, returncode = mypy.api.run(cmd_line_args)
-                assert returncode == 0
-        finally:
-            os.chdir(old_dir)
diff --git a/mypy/test/testpythoneval.py b/mypy/test/testpythoneval.py
index 1fd342452102..32c07087292e 100644
--- a/mypy/test/testpythoneval.py
+++ b/mypy/test/testpythoneval.py
@@ -46,15 +46,14 @@ 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",
         "--allow-empty-bodies",
         "--force-uppercase-builtins",
+        "--test-env",  # Speeds up some checks
     ]
     interpreter = python3_path
     mypy_cmdline.append(f"--python-version={'.'.join(map(str, PYTHON3_VERSION))}")
@@ -64,9 +63,9 @@ def test_python_evaluation(testcase: DataDrivenTestCase, cache_dir: str) -> None
         additional_flags = m.group(1).split()
         for flag in additional_flags:
             if flag.startswith("--python-version="):
-                targetted_python_version = flag.split("=")[1]
-                targetted_major, targetted_minor = targetted_python_version.split(".")
-                if (int(targetted_major), int(targetted_minor)) > (
+                targeted_python_version = flag.split("=")[1]
+                targeted_major, targeted_minor = targeted_python_version.split(".")
+                if (int(targeted_major), int(targeted_minor)) > (
                     sys.version_info.major,
                     sys.version_info.minor,
                 ):
diff --git a/mypy/test/testreports.py b/mypy/test/testreports.py
index a422b4bb2a7b..f638756ad819 100644
--- a/mypy/test/testreports.py
+++ b/mypy/test/testreports.py
@@ -1,4 +1,5 @@
 """Test cases for reports generated by mypy."""
+
 from __future__ import annotations
 
 import textwrap
@@ -7,7 +8,7 @@
 from mypy.test.helpers import Suite, assert_equal
 
 try:
-    import lxml  # type: ignore[import]
+    import lxml  # type: ignore[import-untyped]
 except ImportError:
     lxml = None
 
@@ -22,7 +23,7 @@ def test_get_line_rate(self) -> None:
 
     @pytest.mark.skipif(lxml is None, reason="Cannot import lxml. Is it installed?")
     def test_as_xml(self) -> None:
-        import lxml.etree as etree  # type: ignore[import]
+        import lxml.etree as etree  # type: ignore[import-untyped]
 
         cobertura_package = CoberturaPackage("foobar")
         cobertura_package.covered_lines = 21
diff --git a/mypy/test/testsemanal.py b/mypy/test/testsemanal.py
index 3455f41aa20a..a544e1f91829 100644
--- a/mypy/test/testsemanal.py
+++ b/mypy/test/testsemanal.py
@@ -3,14 +3,13 @@
 from __future__ import annotations
 
 import sys
-from typing import Dict
 
 from mypy import build
 from mypy.defaults import PYTHON3_VERSION
 from mypy.errors import CompileError
 from mypy.modulefinder import BuildSource
 from mypy.nodes import TypeInfo
-from mypy.options import TYPE_VAR_TUPLE, UNPACK, Options
+from mypy.options import Options
 from mypy.test.config import test_temp_dir
 from mypy.test.data import DataDrivenTestCase, DataSuite
 from mypy.test.helpers import (
@@ -45,7 +44,6 @@ def get_semanal_options(program_text: str, testcase: DataDrivenTestCase) -> Opti
     options.semantic_analysis_only = True
     options.show_traceback = True
     options.python_version = PYTHON3_VERSION
-    options.enable_incomplete_feature = [TYPE_VAR_TUPLE, UNPACK]
     options.force_uppercase_builtins = True
     return options
 
@@ -200,7 +198,7 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
         )
 
 
-class TypeInfoMap(Dict[str, TypeInfo]):
+class TypeInfoMap(dict[str, TypeInfo]):
     def __str__(self) -> str:
         a: list[str] = ["TypeInfoMap("]
         for x, y in sorted(self.items()):
diff --git a/mypy/test/testsolve.py b/mypy/test/testsolve.py
index d6c585ef4aaa..6566b03ef5e9 100644
--- a/mypy/test/testsolve.py
+++ b/mypy/test/testsolve.py
@@ -3,10 +3,10 @@
 from __future__ import annotations
 
 from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint
-from mypy.solve import solve_constraints
+from mypy.solve import Bounds, Graph, solve_constraints, transitive_closure
 from mypy.test.helpers import Suite, assert_equal
 from mypy.test.typefixture import TypeFixture
-from mypy.types import Type, TypeVarId, TypeVarType
+from mypy.types import Type, TypeVarId, TypeVarLikeType, TypeVarType
 
 
 class SolveSuite(Suite):
@@ -17,125 +17,266 @@ def test_empty_input(self) -> None:
         self.assert_solve([], [], [])
 
     def test_simple_supertype_constraints(self) -> None:
+        self.assert_solve([self.fx.t], [self.supc(self.fx.t, self.fx.a)], [self.fx.a])
         self.assert_solve(
-            [self.fx.t.id], [self.supc(self.fx.t, self.fx.a)], [(self.fx.a, self.fx.o)]
-        )
-        self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.supc(self.fx.t, self.fx.a), self.supc(self.fx.t, self.fx.b)],
-            [(self.fx.a, self.fx.o)],
+            [self.fx.a],
         )
 
     def test_simple_subtype_constraints(self) -> None:
-        self.assert_solve([self.fx.t.id], [self.subc(self.fx.t, self.fx.a)], [self.fx.a])
+        self.assert_solve([self.fx.t], [self.subc(self.fx.t, self.fx.a)], [self.fx.a])
         self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.subc(self.fx.t, self.fx.a), self.subc(self.fx.t, self.fx.b)],
             [self.fx.b],
         )
 
     def test_both_kinds_of_constraints(self) -> None:
         self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.supc(self.fx.t, self.fx.b), self.subc(self.fx.t, self.fx.a)],
-            [(self.fx.b, self.fx.a)],
+            [self.fx.b],
         )
 
     def test_unsatisfiable_constraints(self) -> None:
         # The constraints are impossible to satisfy.
         self.assert_solve(
-            [self.fx.t.id],
-            [self.supc(self.fx.t, self.fx.a), self.subc(self.fx.t, self.fx.b)],
-            [None],
+            [self.fx.t], [self.supc(self.fx.t, self.fx.a), self.subc(self.fx.t, self.fx.b)], [None]
         )
 
     def test_exactly_specified_result(self) -> None:
         self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.supc(self.fx.t, self.fx.b), self.subc(self.fx.t, self.fx.b)],
-            [(self.fx.b, self.fx.b)],
+            [self.fx.b],
         )
 
     def test_multiple_variables(self) -> None:
         self.assert_solve(
-            [self.fx.t.id, self.fx.s.id],
+            [self.fx.t, self.fx.s],
             [
                 self.supc(self.fx.t, self.fx.b),
                 self.supc(self.fx.s, self.fx.c),
                 self.subc(self.fx.t, self.fx.a),
             ],
-            [(self.fx.b, self.fx.a), (self.fx.c, self.fx.o)],
+            [self.fx.b, self.fx.c],
         )
 
     def test_no_constraints_for_var(self) -> None:
-        self.assert_solve([self.fx.t.id], [], [self.fx.uninhabited])
+        self.assert_solve([self.fx.t], [], [self.fx.uninhabited])
+        self.assert_solve([self.fx.t, self.fx.s], [], [self.fx.uninhabited, self.fx.uninhabited])
         self.assert_solve(
-            [self.fx.t.id, self.fx.s.id], [], [self.fx.uninhabited, self.fx.uninhabited]
-        )
-        self.assert_solve(
-            [self.fx.t.id, self.fx.s.id],
+            [self.fx.t, self.fx.s],
             [self.supc(self.fx.s, self.fx.a)],
-            [self.fx.uninhabited, (self.fx.a, self.fx.o)],
+            [self.fx.uninhabited, self.fx.a],
         )
 
     def test_simple_constraints_with_dynamic_type(self) -> None:
+        self.assert_solve([self.fx.t], [self.supc(self.fx.t, self.fx.anyt)], [self.fx.anyt])
         self.assert_solve(
-            [self.fx.t.id], [self.supc(self.fx.t, self.fx.anyt)], [(self.fx.anyt, self.fx.anyt)]
-        )
-        self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.supc(self.fx.t, self.fx.anyt), self.supc(self.fx.t, self.fx.anyt)],
-            [(self.fx.anyt, self.fx.anyt)],
+            [self.fx.anyt],
         )
         self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.supc(self.fx.t, self.fx.anyt), self.supc(self.fx.t, self.fx.a)],
-            [(self.fx.anyt, self.fx.anyt)],
+            [self.fx.anyt],
         )
 
+        self.assert_solve([self.fx.t], [self.subc(self.fx.t, self.fx.anyt)], [self.fx.anyt])
         self.assert_solve(
-            [self.fx.t.id], [self.subc(self.fx.t, self.fx.anyt)], [(self.fx.anyt, self.fx.anyt)]
-        )
-        self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.subc(self.fx.t, self.fx.anyt), self.subc(self.fx.t, self.fx.anyt)],
-            [(self.fx.anyt, self.fx.anyt)],
+            [self.fx.anyt],
         )
-        # self.assert_solve([self.fx.t.id],
+        # self.assert_solve([self.fx.t],
         #                   [self.subc(self.fx.t, self.fx.anyt),
         #                    self.subc(self.fx.t, self.fx.a)],
-        #                   [(self.fx.anyt, self.fx.anyt)])
+        #                   [self.fx.anyt])
         # TODO: figure out what this should be after changes to meet(any, X)
 
     def test_both_normal_and_any_types_in_results(self) -> None:
         # If one of the bounds is any, we promote the other bound to
         # any as well, since otherwise the type range does not make sense.
         self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.supc(self.fx.t, self.fx.a), self.subc(self.fx.t, self.fx.anyt)],
-            [(self.fx.anyt, self.fx.anyt)],
+            [self.fx.anyt],
         )
 
         self.assert_solve(
-            [self.fx.t.id],
+            [self.fx.t],
             [self.supc(self.fx.t, self.fx.anyt), self.subc(self.fx.t, self.fx.a)],
-            [(self.fx.anyt, self.fx.anyt)],
+            [self.fx.anyt],
+        )
+
+    def test_poly_no_constraints(self) -> None:
+        self.assert_solve(
+            [self.fx.t, self.fx.u],
+            [],
+            [self.fx.uninhabited, self.fx.uninhabited],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_trivial_free(self) -> None:
+        self.assert_solve(
+            [self.fx.t, self.fx.u],
+            [self.subc(self.fx.t, self.fx.a)],
+            [self.fx.a, self.fx.u],
+            [self.fx.u],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_free_pair(self) -> None:
+        self.assert_solve(
+            [self.fx.t, self.fx.u],
+            [self.subc(self.fx.t, self.fx.u)],
+            [self.fx.t, self.fx.t],
+            [self.fx.t],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_free_pair_with_bounds(self) -> None:
+        t_prime = self.fx.t.copy_modified(upper_bound=self.fx.b)
+        self.assert_solve(
+            [self.fx.t, self.fx.ub],
+            [self.subc(self.fx.t, self.fx.ub)],
+            [t_prime, t_prime],
+            [t_prime],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_free_pair_with_bounds_uninhabited(self) -> None:
+        self.assert_solve(
+            [self.fx.ub, self.fx.uc],
+            [self.subc(self.fx.ub, self.fx.uc)],
+            [self.fx.uninhabited, self.fx.uninhabited],
+            [],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_bounded_chain(self) -> None:
+        # B <: T <: U <: S <: A
+        self.assert_solve(
+            [self.fx.t, self.fx.u, self.fx.s],
+            [
+                self.supc(self.fx.t, self.fx.b),
+                self.subc(self.fx.t, self.fx.u),
+                self.subc(self.fx.u, self.fx.s),
+                self.subc(self.fx.s, self.fx.a),
+            ],
+            [self.fx.b, self.fx.b, self.fx.b],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_reverse_overlapping_chain(self) -> None:
+        # A :> T <: S :> B
+        self.assert_solve(
+            [self.fx.t, self.fx.s],
+            [
+                self.subc(self.fx.t, self.fx.s),
+                self.subc(self.fx.t, self.fx.a),
+                self.supc(self.fx.s, self.fx.b),
+            ],
+            [self.fx.a, self.fx.a],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_reverse_split_chain(self) -> None:
+        # B :> T <: S :> A
+        self.assert_solve(
+            [self.fx.t, self.fx.s],
+            [
+                self.subc(self.fx.t, self.fx.s),
+                self.subc(self.fx.t, self.fx.b),
+                self.supc(self.fx.s, self.fx.a),
+            ],
+            [self.fx.b, self.fx.a],
+            allow_polymorphic=True,
+        )
+
+    def test_poly_unsolvable_chain(self) -> None:
+        # A <: T <: U <: S <: B
+        self.assert_solve(
+            [self.fx.t, self.fx.u, self.fx.s],
+            [
+                self.supc(self.fx.t, self.fx.a),
+                self.subc(self.fx.t, self.fx.u),
+                self.subc(self.fx.u, self.fx.s),
+                self.subc(self.fx.s, self.fx.b),
+            ],
+            [None, None, None],
+            allow_polymorphic=True,
+        )
+
+    def test_simple_chain_closure(self) -> None:
+        self.assert_transitive_closure(
+            [self.fx.t.id, self.fx.s.id],
+            [
+                self.supc(self.fx.t, self.fx.b),
+                self.subc(self.fx.t, self.fx.s),
+                self.subc(self.fx.s, self.fx.a),
+            ],
+            {(self.fx.t.id, self.fx.s.id)},
+            {self.fx.t.id: {self.fx.b}, self.fx.s.id: {self.fx.b}},
+            {self.fx.t.id: {self.fx.a}, self.fx.s.id: {self.fx.a}},
+        )
+
+    def test_reverse_chain_closure(self) -> None:
+        self.assert_transitive_closure(
+            [self.fx.t.id, self.fx.s.id],
+            [
+                self.subc(self.fx.t, self.fx.s),
+                self.subc(self.fx.t, self.fx.a),
+                self.supc(self.fx.s, self.fx.b),
+            ],
+            {(self.fx.t.id, self.fx.s.id)},
+            {self.fx.t.id: set(), self.fx.s.id: {self.fx.b}},
+            {self.fx.t.id: {self.fx.a}, self.fx.s.id: set()},
+        )
+
+    def test_secondary_constraint_closure(self) -> None:
+        self.assert_transitive_closure(
+            [self.fx.t.id, self.fx.s.id],
+            [self.supc(self.fx.s, self.fx.gt), self.subc(self.fx.s, self.fx.ga)],
+            set(),
+            {self.fx.t.id: set(), self.fx.s.id: {self.fx.gt}},
+            {self.fx.t.id: {self.fx.a}, self.fx.s.id: {self.fx.ga}},
         )
 
     def assert_solve(
+        self,
+        vars: list[TypeVarLikeType],
+        constraints: list[Constraint],
+        results: list[None | Type],
+        free_vars: list[TypeVarLikeType] | None = None,
+        allow_polymorphic: bool = False,
+    ) -> None:
+        if free_vars is None:
+            free_vars = []
+        actual, actual_free = solve_constraints(
+            vars, constraints, allow_polymorphic=allow_polymorphic
+        )
+        assert_equal(actual, results)
+        assert_equal(actual_free, free_vars)
+
+    def assert_transitive_closure(
         self,
         vars: list[TypeVarId],
         constraints: list[Constraint],
-        results: list[None | Type | tuple[Type, Type]],
+        graph: Graph,
+        lowers: Bounds,
+        uppers: Bounds,
     ) -> None:
-        res: list[Type | None] = []
-        for r in results:
-            if isinstance(r, tuple):
-                res.append(r[0])
-            else:
-                res.append(r)
-        actual = solve_constraints(vars, constraints)
-        assert_equal(str(actual), str(res))
+        actual_graph, actual_lowers, actual_uppers = transitive_closure(vars, constraints)
+        # Add trivial elements.
+        for v in vars:
+            graph.add((v, v))
+        assert_equal(actual_graph, graph)
+        assert_equal(dict(actual_lowers), lowers)
+        assert_equal(dict(actual_uppers), uppers)
 
     def supc(self, type_var: TypeVarType, bound: Type) -> Constraint:
         return Constraint(type_var, SUPERTYPE_OF, bound)
diff --git a/mypy/test/teststubgen.py b/mypy/test/teststubgen.py
index b21e06c0896a..43974cf8ec68 100644
--- a/mypy/test/teststubgen.py
+++ b/mypy/test/teststubgen.py
@@ -10,6 +10,8 @@
 from types import ModuleType
 from typing import Any
 
+import pytest
+
 from mypy.errors import CompileError
 from mypy.moduleinspect import InspectError, ModuleInspect
 from mypy.stubdoc import (
@@ -28,21 +30,20 @@
     Options,
     collect_build_targets,
     generate_stubs,
-    get_sig_generators,
     is_blacklisted_path,
     is_non_library_module,
     mypy_options,
     parse_options,
 )
-from mypy.stubgenc import (
-    generate_c_function_stub,
-    generate_c_property_stub,
-    generate_c_type_stub,
-    infer_method_args,
+from mypy.stubgenc import InspectionStubGenerator, infer_c_method_args
+from mypy.stubutil import (
+    ClassInfo,
+    FunctionContext,
+    common_dir_prefix,
     infer_method_ret_type,
-    is_c_property_readonly,
+    remove_misplaced_type_comments,
+    walk_packages,
 )
-from mypy.stubutil import common_dir_prefix, remove_misplaced_type_comments, walk_packages
 from mypy.test.data import DataDrivenTestCase, DataSuite
 from mypy.test.helpers import assert_equal, assert_string_arrays_equal, local_sys_path_set
 
@@ -62,7 +63,8 @@ def test_files_found(self) -> None:
                 os.mkdir(os.path.join("subdir", "pack"))
                 self.make_file("subdir", "pack", "__init__.py")
                 opts = parse_options(["subdir"])
-                py_mods, c_mods = collect_build_targets(opts, mypy_options(opts))
+                py_mods, pyi_mods, c_mods = collect_build_targets(opts, mypy_options(opts))
+                assert_equal(pyi_mods, [])
                 assert_equal(c_mods, [])
                 files = {mod.path for mod in py_mods}
                 assert_equal(
@@ -87,7 +89,8 @@ def test_packages_found(self) -> None:
                 self.make_file("pack", "a.py")
                 self.make_file("pack", "b.py")
                 opts = parse_options(["-p", "pack"])
-                py_mods, c_mods = collect_build_targets(opts, mypy_options(opts))
+                py_mods, pyi_mods, c_mods = collect_build_targets(opts, mypy_options(opts))
+                assert_equal(pyi_mods, [])
                 assert_equal(c_mods, [])
                 files = {os.path.relpath(mod.path or "FAIL") for mod in py_mods}
                 assert_equal(
@@ -111,7 +114,7 @@ def test_module_not_found(self) -> None:
                 os.chdir(tmp)
                 self.make_file(tmp, "mymodule.py", content="import a")
                 opts = parse_options(["-m", "mymodule"])
-                py_mods, c_mods = collect_build_targets(opts, mypy_options(opts))
+                collect_build_targets(opts, mypy_options(opts))
                 assert captured_output.getvalue() == ""
             finally:
                 sys.stdout = sys.__stdout__
@@ -396,6 +399,164 @@ def test_infer_sig_from_docstring_bad_indentation(self) -> None:
             None,
         )
 
+    def test_infer_sig_from_docstring_args_kwargs(self) -> None:
+        assert_equal(
+            infer_sig_from_docstring("func(*args, **kwargs) -> int", "func"),
+            [
+                FunctionSig(
+                    name="func",
+                    args=[ArgSig(name="*args"), ArgSig(name="**kwargs")],
+                    ret_type="int",
+                )
+            ],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(*args) -> int", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="*args")], ret_type="int")],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(**kwargs) -> int", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="**kwargs")], ret_type="int")],
+        )
+
+    @pytest.mark.xfail(
+        raises=AssertionError, reason="Arg and kwarg signature validation not implemented yet"
+    )
+    def test_infer_sig_from_docstring_args_kwargs_errors(self) -> None:
+        # Double args
+        assert_equal(infer_sig_from_docstring("func(*args, *args2) -> int", "func"), [])
+
+        # Double kwargs
+        assert_equal(infer_sig_from_docstring("func(**kw, **kw2) -> int", "func"), [])
+
+        # args after kwargs
+        assert_equal(infer_sig_from_docstring("func(**kwargs, *args) -> int", "func"), [])
+
+    def test_infer_sig_from_docstring_positional_only_arguments(self) -> None:
+        assert_equal(
+            infer_sig_from_docstring("func(self, /) -> str", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="self")], ret_type="str")],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(self, x, /) -> str", "func"),
+            [
+                FunctionSig(
+                    name="func", args=[ArgSig(name="self"), ArgSig(name="x")], ret_type="str"
+                )
+            ],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(x, /, y) -> int", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="x"), ArgSig(name="y")], ret_type="int")],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(x, /, *args) -> str", "func"),
+            [
+                FunctionSig(
+                    name="func", args=[ArgSig(name="x"), ArgSig(name="*args")], ret_type="str"
+                )
+            ],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(x, /, *, kwonly, **kwargs) -> str", "func"),
+            [
+                FunctionSig(
+                    name="func",
+                    args=[ArgSig(name="x"), ArgSig(name="kwonly"), ArgSig(name="**kwargs")],
+                    ret_type="str",
+                )
+            ],
+        )
+
+    def test_infer_sig_from_docstring_keyword_only_arguments(self) -> None:
+        assert_equal(
+            infer_sig_from_docstring("func(*, x) -> str", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="x")], ret_type="str")],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(x, *, y) -> str", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="x"), ArgSig(name="y")], ret_type="str")],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(*, x, y) -> str", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="x"), ArgSig(name="y")], ret_type="str")],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(x, *, kwonly, **kwargs) -> str", "func"),
+            [
+                FunctionSig(
+                    name="func",
+                    args=[ArgSig(name="x"), ArgSig(name="kwonly"), ArgSig("**kwargs")],
+                    ret_type="str",
+                )
+            ],
+        )
+
+    def test_infer_sig_from_docstring_pos_only_and_keyword_only_arguments(self) -> None:
+        assert_equal(
+            infer_sig_from_docstring("func(x, /, *, y) -> str", "func"),
+            [FunctionSig(name="func", args=[ArgSig(name="x"), ArgSig(name="y")], ret_type="str")],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(x,  /, y,  *, z) -> str", "func"),
+            [
+                FunctionSig(
+                    name="func",
+                    args=[ArgSig(name="x"), ArgSig(name="y"), ArgSig(name="z")],
+                    ret_type="str",
+                )
+            ],
+        )
+
+        assert_equal(
+            infer_sig_from_docstring("func(x,  /, y,  *, z, **kwargs) -> str", "func"),
+            [
+                FunctionSig(
+                    name="func",
+                    args=[
+                        ArgSig(name="x"),
+                        ArgSig(name="y"),
+                        ArgSig(name="z"),
+                        ArgSig("**kwargs"),
+                    ],
+                    ret_type="str",
+                )
+            ],
+        )
+
+    def test_infer_sig_from_docstring_pos_only_and_keyword_only_arguments_errors(self) -> None:
+        # / as first argument
+        assert_equal(infer_sig_from_docstring("func(/, x) -> str", "func"), [])
+
+        # * as last argument
+        assert_equal(infer_sig_from_docstring("func(x, *) -> str", "func"), [])
+
+        # / after *
+        assert_equal(infer_sig_from_docstring("func(x, *, /,  y) -> str", "func"), [])
+
+        # Two /
+        assert_equal(infer_sig_from_docstring("func(x, /, /, *,  y) -> str", "func"), [])
+
+        assert_equal(infer_sig_from_docstring("func(x, /, y,  /, *,  z) -> str", "func"), [])
+
+        # Two *
+        assert_equal(infer_sig_from_docstring("func(x, /, *, *,  y) -> str", "func"), [])
+
+        assert_equal(infer_sig_from_docstring("func(x, /, *, y, *,  z) -> str", "func"), [])
+
+        # *args and * are not allowed
+        assert_equal(infer_sig_from_docstring("func(*args, *, kwonly) -> str", "func"), [])
+
     def test_infer_arg_sig_from_anon_docstring(self) -> None:
         assert_equal(
             infer_arg_sig_from_anon_docstring("(*args, **kwargs)"),
@@ -610,6 +771,16 @@ def test_common_dir_prefix_win(self) -> None:
         assert common_dir_prefix([r"foo\bar/x.pyi"]) == r"foo\bar"
         assert common_dir_prefix([r"foo/bar/x.pyi"]) == r"foo\bar"
 
+    def test_function_context_nested_classes(self) -> None:
+        ctx = FunctionContext(
+            module_name="spangle",
+            name="foo",
+            class_info=ClassInfo(
+                name="Nested", self_var="self", parent=ClassInfo(name="Parent", self_var="self")
+            ),
+        )
+        assert ctx.fullname == "spangle.Parent.Nested.foo"
+
 
 class StubgenHelpersSuite(unittest.TestCase):
     def test_is_blacklisted_path(self) -> None:
@@ -677,6 +848,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)
@@ -697,14 +869,20 @@ def run_case_inner(self, testcase: DataDrivenTestCase) -> None:
                 f.write(content)
 
         options = self.parse_flags(source, extra)
+        if sys.version_info < options.pyversion:
+            pytest.skip()
         modules = self.parse_modules(source)
         out_dir = "out"
         try:
             try:
-                if not testcase.name.endswith("_import"):
-                    options.no_import = True
-                if not testcase.name.endswith("_semanal"):
-                    options.parse_only = True
+                if testcase.name.endswith("_inspect"):
+                    options.inspect = True
+                else:
+                    if not testcase.name.endswith("_import"):
+                        options.no_import = True
+                    if not testcase.name.endswith("_semanal"):
+                        options.parse_only = True
+
                 generate_stubs(options)
                 a: list[str] = []
                 for module in modules:
@@ -723,11 +901,22 @@ def run_case_inner(self, testcase: DataDrivenTestCase) -> None:
 
     def parse_flags(self, program_text: str, extra: list[str]) -> Options:
         flags = re.search("# flags: (.*)$", program_text, flags=re.MULTILINE)
+        pyversion = None
         if flags:
             flag_list = flags.group(1).split()
+            for i, flag in enumerate(flag_list):
+                if flag.startswith("--python-version="):
+                    pyversion = flag.split("=", 1)[1]
+                    del flag_list[i]
+                    break
         else:
             flag_list = []
         options = parse_options(flag_list + extra)
+        if pyversion:
+            # A hack to allow testing old python versions with new language constructs
+            # This should be rarely used in general as stubgen output should not be version-specific
+            major, minor = pyversion.split(".", 1)
+            options.pyversion = (int(major), int(minor))
         if "--verbose" not in flag_list:
             options.quiet = True
         else:
@@ -769,35 +958,28 @@ class StubgencSuite(unittest.TestCase):
     """
 
     def test_infer_hash_sig(self) -> None:
-        assert_equal(infer_method_args("__hash__"), [self_arg])
+        assert_equal(infer_c_method_args("__hash__"), [self_arg])
         assert_equal(infer_method_ret_type("__hash__"), "int")
 
     def test_infer_getitem_sig(self) -> None:
-        assert_equal(infer_method_args("__getitem__"), [self_arg, ArgSig(name="index")])
+        assert_equal(infer_c_method_args("__getitem__"), [self_arg, ArgSig(name="index")])
 
     def test_infer_setitem_sig(self) -> None:
         assert_equal(
-            infer_method_args("__setitem__"),
+            infer_c_method_args("__setitem__"),
             [self_arg, ArgSig(name="index"), ArgSig(name="object")],
         )
         assert_equal(infer_method_ret_type("__setitem__"), "None")
 
+    def test_infer_eq_op_sig(self) -> None:
+        for op in ("eq", "ne", "lt", "le", "gt", "ge"):
+            assert_equal(
+                infer_c_method_args(f"__{op}__"), [self_arg, ArgSig(name="other", type="object")]
+            )
+
     def test_infer_binary_op_sig(self) -> None:
-        for op in (
-            "eq",
-            "ne",
-            "lt",
-            "le",
-            "gt",
-            "ge",
-            "add",
-            "radd",
-            "sub",
-            "rsub",
-            "mul",
-            "rmul",
-        ):
-            assert_equal(infer_method_args(f"__{op}__"), [self_arg, ArgSig(name="other")])
+        for op in ("add", "radd", "sub", "rsub", "mul", "rmul"):
+            assert_equal(infer_c_method_args(f"__{op}__"), [self_arg, ArgSig(name="other")])
 
     def test_infer_equality_op_sig(self) -> None:
         for op in ("eq", "ne", "lt", "le", "gt", "ge", "contains"):
@@ -805,82 +987,104 @@ def test_infer_equality_op_sig(self) -> None:
 
     def test_infer_unary_op_sig(self) -> None:
         for op in ("neg", "pos"):
-            assert_equal(infer_method_args(f"__{op}__"), [self_arg])
+            assert_equal(infer_c_method_args(f"__{op}__"), [self_arg])
 
     def test_infer_cast_sig(self) -> None:
         for op in ("float", "bool", "bytes", "int"):
             assert_equal(infer_method_ret_type(f"__{op}__"), op)
 
-    def test_generate_c_type_stub_no_crash_for_object(self) -> None:
+    def test_generate_class_stub_no_crash_for_object(self) -> None:
         output: list[str] = []
         mod = ModuleType("module", "")  # any module is fine
-        imports: list[str] = []
-        generate_c_type_stub(
-            mod,
-            "alias",
-            object,
-            output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
-        assert_equal(imports, [])
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+
+        gen.generate_class_stub("alias", object, output)
+        assert_equal(gen.get_imports().splitlines(), [])
         assert_equal(output[0], "class alias:")
 
-    def test_generate_c_type_stub_variable_type_annotation(self) -> None:
+    def test_generate_class_stub_variable_type_annotation(self) -> None:
         # This class mimics the stubgen unit test 'testClassVariable'
         class TestClassVariableCls:
             x = 1
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType("module", "")  # any module is fine
-        generate_c_type_stub(
-            mod,
-            "C",
-            TestClassVariableCls,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_class_stub("C", TestClassVariableCls, output)
+        assert_equal(gen.get_imports().splitlines(), ["from typing import ClassVar"])
+        assert_equal(output, ["class C:", "    x: ClassVar[int] = ..."])
+
+    def test_generate_c_type_none_default(self) -> None:
+        class TestClass:
+            def test(self, arg0=1, arg1=None) -> None:  # type: ignore[no-untyped-def]
+                pass
+
+        output: list[str] = []
+        mod = ModuleType(TestClass.__module__, "")
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.is_c_module = False
+        gen.generate_function_stub(
+            "test",
+            TestClass.test,
+            output=output,
+            class_info=ClassInfo(
+                self_var="self",
+                cls=TestClass,
+                name="TestClass",
+                docstring=getattr(TestClass, "__doc__", None),
+            ),
+        )
+        assert_equal(
+            output, ["def test(self, arg0: int = ..., arg1: Incomplete | None = ...) -> None: ..."]
+        )
+
+    def test_non_c_generate_signature_with_kw_only_args(self) -> None:
+        class TestClass:
+            def test(
+                self, arg0: str, *, keyword_only: str, keyword_only_with_default: int = 7
+            ) -> None:
+                pass
+
+        output: list[str] = []
+        mod = ModuleType(TestClass.__module__, "")
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.is_c_module = False
+        gen.generate_function_stub(
+            "test",
+            TestClass.test,
+            output=output,
+            class_info=ClassInfo(
+                self_var="self",
+                cls=TestClass,
+                name="TestClass",
+                docstring=getattr(TestClass, "__doc__", None),
+            ),
+        )
+        assert_equal(
             output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            [
+                "def test(self, arg0: str, *, keyword_only: str, keyword_only_with_default: int = ...) -> None: ..."
+            ],
         )
-        assert_equal(imports, [])
-        assert_equal(output, ["class C:", "    x: ClassVar[int] = ..."])
 
     def test_generate_c_type_inheritance(self) -> None:
         class TestClass(KeyError):
             pass
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType("module, ")
-        generate_c_type_stub(
-            mod,
-            "C",
-            TestClass,
-            output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_class_stub("C", TestClass, output)
         assert_equal(output, ["class C(KeyError): ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_inheritance_same_module(self) -> None:
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestBaseClass.__module__, "")
-        generate_c_type_stub(
-            mod,
-            "C",
-            TestClass,
-            output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_class_stub("C", TestClass, output)
         assert_equal(output, ["class C(TestBaseClass): ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_inheritance_other_module(self) -> None:
         import argparse
@@ -889,38 +1093,22 @@ class TestClass(argparse.Action):
             pass
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType("module", "")
-        generate_c_type_stub(
-            mod,
-            "C",
-            TestClass,
-            output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_class_stub("C", TestClass, output)
         assert_equal(output, ["class C(argparse.Action): ..."])
-        assert_equal(imports, ["import argparse"])
+        assert_equal(gen.get_imports().splitlines(), ["import argparse"])
 
     def test_generate_c_type_inheritance_builtin_type(self) -> None:
         class TestClass(type):
             pass
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType("module", "")
-        generate_c_type_stub(
-            mod,
-            "C",
-            TestClass,
-            output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_class_stub("C", TestClass, output)
         assert_equal(output, ["class C(type): ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_with_docstring(self) -> None:
         class TestClass:
@@ -930,22 +1118,16 @@ def test(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
         assert_equal(output, ["def test(self, arg0: int) -> Any: ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_with_docstring_no_self_arg(self) -> None:
         class TestClass:
@@ -955,22 +1137,16 @@ def test(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
         assert_equal(output, ["def test(self, arg0: int) -> Any: ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_classmethod(self) -> None:
         class TestClass:
@@ -979,27 +1155,21 @@ def test(cls, arg0: str) -> None:
                 pass
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="cls",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="cls", cls=TestClass, name="TestClass"),
         )
-        assert_equal(output, ["@classmethod", "def test(cls, *args, **kwargs) -> Any: ..."])
-        assert_equal(imports, [])
+        assert_equal(output, ["@classmethod", "def test(cls, *args, **kwargs): ..."])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_classmethod_with_overloads(self) -> None:
         class TestClass:
             @classmethod
-            def test(self, arg0: str) -> None:
+            def test(cls, arg0: str) -> None:
                 """
                 test(cls, arg0: str)
                 test(cls, arg0: int)
@@ -1007,19 +1177,13 @@ def test(self, arg0: str) -> None:
                 pass
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="cls",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="cls", cls=TestClass, name="TestClass"),
         )
         assert_equal(
             output,
@@ -1032,7 +1196,7 @@ def test(self, arg0: str) -> None:
                 "def test(cls, arg0: int) -> Any: ...",
             ],
         )
-        assert_equal(imports, ["from typing import overload"])
+        assert_equal(gen.get_imports().splitlines(), ["from typing import overload"])
 
     def test_generate_c_type_with_docstring_empty_default(self) -> None:
         class TestClass:
@@ -1042,22 +1206,16 @@ def test(self, arg0: str = "") -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
         assert_equal(output, ["def test(self, arg0: str = ...) -> Any: ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_function_other_module_arg(self) -> None:
         """Test that if argument references type from other module, module will be imported."""
@@ -1070,19 +1228,11 @@ def test(arg0: str) -> None:
             """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(self.__module__, "")
-        generate_c_function_stub(
-            mod,
-            "test",
-            test,
-            output=output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub("test", test, output=output)
         assert_equal(output, ["def test(arg0: argparse.Action) -> Any: ..."])
-        assert_equal(imports, ["import argparse"])
+        assert_equal(gen.get_imports().splitlines(), ["import argparse"])
 
     def test_generate_c_function_same_module(self) -> None:
         """Test that if annotation references type from same module but using full path, no module
@@ -1097,19 +1247,11 @@ def test(arg0: str) -> None:
             """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType("argparse", "")
-        generate_c_function_stub(
-            mod,
-            "test",
-            test,
-            output=output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub("test", test, output=output)
         assert_equal(output, ["def test(arg0: Action) -> Action: ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_function_other_module(self) -> None:
         """Test that if annotation references type from other module, module will be imported."""
@@ -1120,19 +1262,11 @@ def test(arg0: str) -> None:
             """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(self.__module__, "")
-        generate_c_function_stub(
-            mod,
-            "test",
-            test,
-            output=output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub("test", test, output=output)
         assert_equal(output, ["def test(arg0: argparse.Action) -> argparse.Action: ..."])
-        assert_equal(set(imports), {"import argparse"})
+        assert_equal(gen.get_imports().splitlines(), ["import argparse"])
 
     def test_generate_c_function_same_module_nested(self) -> None:
         """Test that if annotation references type from same module but using full path, no module
@@ -1147,19 +1281,11 @@ def test(arg0: str) -> None:
             """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType("argparse", "")
-        generate_c_function_stub(
-            mod,
-            "test",
-            test,
-            output=output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub("test", test, output=output)
         assert_equal(output, ["def test(arg0: list[Action]) -> list[Action]: ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_function_same_module_compound(self) -> None:
         """Test that if annotation references type from same module but using full path, no module
@@ -1174,19 +1300,11 @@ def test(arg0: str) -> None:
             """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType("argparse", "")
-        generate_c_function_stub(
-            mod,
-            "test",
-            test,
-            output=output,
-            imports=imports,
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
-        )
-        assert_equal(output, ["def test(arg0: Union[Action,None]) -> Tuple[Action,None]: ..."])
-        assert_equal(imports, [])
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub("test", test, output=output)
+        assert_equal(output, ["def test(arg0: Union[Action, None]) -> Tuple[Action, None]: ..."])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_function_other_module_nested(self) -> None:
         """Test that if annotation references type from other module, module will be imported,
@@ -1198,19 +1316,25 @@ def test(arg0: str) -> None:
             """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(self.__module__, "")
-        generate_c_function_stub(
-            mod,
-            "test",
-            test,
-            output=output,
-            imports=imports,
-            known_modules=["foo", "foo.spangle", "bar"],
-            sig_generators=get_sig_generators(parse_options([])),
+        gen = InspectionStubGenerator(
+            mod.__name__, known_modules=["foo", "foo.spangle", "bar"], module=mod
         )
+        gen.generate_function_stub("test", test, output=output)
         assert_equal(output, ["def test(arg0: foo.bar.Action) -> other.Thing: ..."])
-        assert_equal(set(imports), {"import foo", "import other"})
+        assert_equal(gen.get_imports().splitlines(), ["import foo", "import other"])
+
+    def test_generate_c_function_no_crash_for_non_str_docstring(self) -> None:
+        def test(arg0: str) -> None: ...
+
+        test.__doc__ = property(lambda self: "test(arg0: str) -> None")  # type: ignore[assignment]
+
+        output: list[str] = []
+        mod = ModuleType(self.__module__, "")
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub("test", test, output=output)
+        assert_equal(output, ["def test(*args, **kwargs): ..."])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_property_with_pybind11(self) -> None:
         """Signatures included by PyBind11 inside property.fget are read."""
@@ -1225,13 +1349,15 @@ def get_attribute(self) -> None:
 
         readwrite_properties: list[str] = []
         readonly_properties: list[str] = []
-        generate_c_property_stub(
+        mod = ModuleType("module", "")  # any module is fine
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_property_stub(
             "attribute",
+            TestClass.__dict__["attribute"],
             TestClass.attribute,
             [],
             readwrite_properties,
             readonly_properties,
-            is_c_property_readonly(TestClass.attribute),
         )
         assert_equal(readwrite_properties, [])
         assert_equal(readonly_properties, ["@property", "def attribute(self) -> str: ..."])
@@ -1251,15 +1377,17 @@ def attribute(self, value: int) -> None:
 
         readwrite_properties: list[str] = []
         readonly_properties: list[str] = []
-        generate_c_property_stub(
+        mod = ModuleType("module", "")  # any module is fine
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_property_stub(
             "attribute",
-            type(TestClass.attribute),
+            TestClass.__dict__["attribute"],
+            TestClass.attribute,
             [],
             readwrite_properties,
             readonly_properties,
-            is_c_property_readonly(TestClass.attribute),
         )
-        assert_equal(readwrite_properties, ["attribute: Any"])
+        assert_equal(readwrite_properties, ["attribute: Incomplete"])
         assert_equal(readonly_properties, [])
 
     def test_generate_c_type_with_single_arg_generic(self) -> None:
@@ -1270,22 +1398,16 @@ def test(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
         assert_equal(output, ["def test(self, arg0: List[int]) -> Any: ..."])
-        assert_equal(imports, [])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_with_double_arg_generic(self) -> None:
         class TestClass:
@@ -1295,22 +1417,16 @@ def test(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
-        assert_equal(output, ["def test(self, arg0: Dict[str,int]) -> Any: ..."])
-        assert_equal(imports, [])
+        assert_equal(output, ["def test(self, arg0: Dict[str, int]) -> Any: ..."])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_with_nested_generic(self) -> None:
         class TestClass:
@@ -1320,22 +1436,16 @@ def test(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
-        assert_equal(output, ["def test(self, arg0: Dict[str,List[int]]) -> Any: ..."])
-        assert_equal(imports, [])
+        assert_equal(output, ["def test(self, arg0: Dict[str, List[int]]) -> Any: ..."])
+        assert_equal(gen.get_imports().splitlines(), [])
 
     def test_generate_c_type_with_generic_using_other_module_first(self) -> None:
         class TestClass:
@@ -1345,22 +1455,16 @@ def test(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
-        assert_equal(output, ["def test(self, arg0: Dict[argparse.Action,int]) -> Any: ..."])
-        assert_equal(imports, ["import argparse"])
+        assert_equal(output, ["def test(self, arg0: Dict[argparse.Action, int]) -> Any: ..."])
+        assert_equal(gen.get_imports().splitlines(), ["import argparse"])
 
     def test_generate_c_type_with_generic_using_other_module_last(self) -> None:
         class TestClass:
@@ -1370,22 +1474,16 @@ def test(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "test",
             TestClass.test,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
-        assert_equal(output, ["def test(self, arg0: Dict[str,argparse.Action]) -> Any: ..."])
-        assert_equal(imports, ["import argparse"])
+        assert_equal(output, ["def test(self, arg0: Dict[str, argparse.Action]) -> Any: ..."])
+        assert_equal(gen.get_imports().splitlines(), ["import argparse"])
 
     def test_generate_c_type_with_overload_pybind11(self) -> None:
         class TestClass:
@@ -1400,19 +1498,13 @@ def __init__(self, arg0: str) -> None:
                 """
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "__init__",
             TestClass.__init__,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(self_var="self", cls=TestClass, name="TestClass"),
         )
         assert_equal(
             output,
@@ -1425,7 +1517,7 @@ def __init__(self, arg0: str) -> None:
                 "def __init__(self, *args, **kwargs) -> Any: ...",
             ],
         )
-        assert_equal(set(imports), {"from typing import overload"})
+        assert_equal(gen.get_imports().splitlines(), ["from typing import overload"])
 
     def test_generate_c_type_with_overload_shiboken(self) -> None:
         class TestClass:
@@ -1438,19 +1530,18 @@ def __init__(self, arg0: str) -> None:
                 pass
 
         output: list[str] = []
-        imports: list[str] = []
         mod = ModuleType(TestClass.__module__, "")
-        generate_c_function_stub(
-            mod,
+        gen = InspectionStubGenerator(mod.__name__, known_modules=[mod.__name__], module=mod)
+        gen.generate_function_stub(
             "__init__",
             TestClass.__init__,
             output=output,
-            imports=imports,
-            self_var="self",
-            cls=TestClass,
-            class_name="TestClass",
-            known_modules=[mod.__name__],
-            sig_generators=get_sig_generators(parse_options([])),
+            class_info=ClassInfo(
+                self_var="self",
+                cls=TestClass,
+                name="TestClass",
+                docstring=getattr(TestClass, "__doc__", None),
+            ),
         )
         assert_equal(
             output,
@@ -1461,7 +1552,7 @@ def __init__(self, arg0: str) -> None:
                 "def __init__(self, arg0: str, arg1: str) -> None: ...",
             ],
         )
-        assert_equal(set(imports), {"from typing import overload"})
+        assert_equal(gen.get_imports().splitlines(), ["from typing import overload"])
 
 
 class ArgSigSuite(unittest.TestCase):
@@ -1488,6 +1579,20 @@ def test_is_valid_type(self) -> None:
         assert is_valid_type("List[int]")
         assert is_valid_type("Dict[str, int]")
         assert is_valid_type("None")
+        assert is_valid_type("Literal[26]")
+        assert is_valid_type("Literal[0x1A]")
+        assert is_valid_type('Literal["hello world"]')
+        assert is_valid_type('Literal[b"hello world"]')
+        assert is_valid_type('Literal[u"hello world"]')
+        assert is_valid_type("Literal[True]")
+        assert is_valid_type("Literal[Color.RED]")
+        assert is_valid_type("Literal[None]")
+        assert is_valid_type("str | int")
+        assert is_valid_type("dict[str, int] | int")
+        assert is_valid_type("tuple[str, ...]")
+        assert is_valid_type(
+            'Literal[26, 0x1A, "hello world", b"hello world", u"hello world", True, Color.RED, None]'
+        )
         assert not is_valid_type("foo-bar")
         assert not is_valid_type("x->y")
         assert not is_valid_type("True")
diff --git a/mypy/test/teststubinfo.py b/mypy/test/teststubinfo.py
index eccee90244f3..e90c72335bf8 100644
--- a/mypy/test/teststubinfo.py
+++ b/mypy/test/teststubinfo.py
@@ -2,11 +2,33 @@
 
 import unittest
 
-from mypy.stubinfo import is_legacy_bundled_package
+from mypy.stubinfo import (
+    is_module_from_legacy_bundled_package,
+    legacy_bundled_packages,
+    non_bundled_packages_flat,
+    stub_distribution_name,
+)
 
 
 class TestStubInfo(unittest.TestCase):
     def test_is_legacy_bundled_packages(self) -> None:
-        assert not is_legacy_bundled_package("foobar_asdf")
-        assert is_legacy_bundled_package("pycurl")
-        assert is_legacy_bundled_package("dataclasses")
+        assert not is_module_from_legacy_bundled_package("foobar_asdf")
+        assert not is_module_from_legacy_bundled_package("PIL")
+        assert is_module_from_legacy_bundled_package("pycurl")
+        assert is_module_from_legacy_bundled_package("dateparser")
+
+    def test_stub_distribution_name(self) -> None:
+        assert stub_distribution_name("foobar_asdf") is None
+        assert stub_distribution_name("pycurl") == "types-pycurl"
+        assert stub_distribution_name("bs4") == "types-beautifulsoup4"
+        assert stub_distribution_name("google.cloud.ndb") == "types-google-cloud-ndb"
+        assert stub_distribution_name("google.cloud.ndb.submodule") == "types-google-cloud-ndb"
+        assert stub_distribution_name("google.cloud.unknown") is None
+        assert stub_distribution_name("google.protobuf") == "types-protobuf"
+        assert stub_distribution_name("google.protobuf.submodule") == "types-protobuf"
+        assert stub_distribution_name("google") is None
+
+    def test_period_in_top_level(self) -> None:
+        for packages in (non_bundled_packages_flat, legacy_bundled_packages):
+            for top_level_module in packages:
+                assert "." not in top_level_module
diff --git a/mypy/test/teststubtest.py b/mypy/test/teststubtest.py
index 275b09c3a240..492897d33a4a 100644
--- a/mypy/test/teststubtest.py
+++ b/mypy/test/teststubtest.py
@@ -9,7 +9,8 @@
 import tempfile
 import textwrap
 import unittest
-from typing import Any, Callable, Iterator
+from collections.abc import Iterator
+from typing import Any, Callable
 
 import mypy.stubtest
 from mypy.stubtest import parse_options, test_stubs
@@ -47,6 +48,11 @@ def __getitem__(self, typeargs: Any) -> object: ...
 Generic: _SpecialForm = ...
 Protocol: _SpecialForm = ...
 Union: _SpecialForm = ...
+ClassVar: _SpecialForm = ...
+
+Final = 0
+Literal = 0
+TypedDict = 0
 
 class TypeVar:
     def __init__(self, name, covariant: bool = ..., contravariant: bool = ...) -> None: ...
@@ -64,11 +70,21 @@ def __init__(self, name: str) -> None: ...
 
 class Coroutine(Generic[_T_co, _S, _R]): ...
 class Iterable(Generic[_T_co]): ...
+class Iterator(Iterable[_T_co]): ...
 class Mapping(Generic[_K, _V]): ...
 class Match(Generic[AnyStr]): ...
 class Sequence(Iterable[_T_co]): ...
 class Tuple(Sequence[_T_co]): ...
+class NamedTuple(tuple[Any, ...]): ...
+class _TypedDict(Mapping[str, object]):
+    __required_keys__: ClassVar[frozenset[str]]
+    __optional_keys__: ClassVar[frozenset[str]]
+    __total__: ClassVar[bool]
+    __readonly_keys__: ClassVar[frozenset[str]]
+    __mutable_keys__: ClassVar[frozenset[str]]
 def overload(func: _T) -> _T: ...
+def type_check_only(func: _T) -> _T: ...
+def final(func: _T) -> _T: ...
 """
 
 stubtest_builtins_stub = """
@@ -82,11 +98,16 @@ def overload(func: _T) -> _T: ...
 class object:
     __module__: str
     def __init__(self) -> None: pass
+    def __repr__(self) -> str: pass
 class type: ...
 
-class tuple(Sequence[T_co], Generic[T_co]): ...
+class tuple(Sequence[T_co], Generic[T_co]):
+    def __ge__(self, __other: tuple[T_co, ...]) -> bool: pass
+
 class dict(Mapping[KT, VT]): ...
 
+class frozenset(Generic[T]): ...
+
 class function: pass
 class ellipsis: pass
 
@@ -103,15 +124,50 @@ def classmethod(f: T) -> T: ...
 def staticmethod(f: T) -> T: ...
 """
 
+stubtest_enum_stub = """
+import sys
+from typing import Any, TypeVar, Iterator
+
+_T = TypeVar('_T')
+
+class EnumMeta(type):
+    def __len__(self) -> int: pass
+    def __iter__(self: type[_T]) -> Iterator[_T]: pass
+    def __reversed__(self: type[_T]) -> Iterator[_T]: pass
+    def __getitem__(self: type[_T], name: str) -> _T: pass
+
+class Enum(metaclass=EnumMeta):
+    def __new__(cls: type[_T], value: object) -> _T: pass
+    def __repr__(self) -> str: pass
+    def __str__(self) -> str: pass
+    def __format__(self, format_spec: str) -> str: pass
+    def __hash__(self) -> Any: pass
+    def __reduce_ex__(self, proto: Any) -> Any: pass
+    name: str
+    value: Any
+
+class Flag(Enum):
+    def __or__(self: _T, other: _T) -> _T: pass
+    def __and__(self: _T, other: _T) -> _T: pass
+    def __xor__(self: _T, other: _T) -> _T: pass
+    def __invert__(self: _T) -> _T: pass
+    if sys.version_info >= (3, 11):
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+"""
 
-def run_stubtest(
+
+def run_stubtest_with_stderr(
     stub: str, runtime: str, options: list[str], config_file: str | None = None
-) -> str:
+) -> tuple[str, str]:
     with use_tmp_dir(TEST_MODULE_NAME) as tmp_dir:
         with open("builtins.pyi", "w") as f:
             f.write(stubtest_builtins_stub)
         with open("typing.pyi", "w") as f:
             f.write(stubtest_typing_stub)
+        with open("enum.pyi", "w") as f:
+            f.write(stubtest_enum_stub)
         with open(f"{TEST_MODULE_NAME}.pyi", "w") as f:
             f.write(stub)
         with open(f"{TEST_MODULE_NAME}.py", "w") as f:
@@ -121,17 +177,30 @@ def run_stubtest(
                 f.write(config_file)
             options = options + ["--mypy-config-file", f"{TEST_MODULE_NAME}_config.ini"]
         output = io.StringIO()
-        with contextlib.redirect_stdout(output):
+        outerr = io.StringIO()
+        with contextlib.redirect_stdout(output), contextlib.redirect_stderr(outerr):
             test_stubs(parse_options([TEST_MODULE_NAME] + options), use_builtins_fixtures=True)
-        return remove_color_code(
-            output.getvalue()
-            # remove cwd as it's not available from outside
-            .replace(os.path.realpath(tmp_dir) + os.sep, "").replace(tmp_dir + os.sep, "")
-        )
+    filtered_output = remove_color_code(
+        output.getvalue()
+        # remove cwd as it's not available from outside
+        .replace(os.path.realpath(tmp_dir) + os.sep, "").replace(tmp_dir + os.sep, "")
+    )
+    filtered_outerr = remove_color_code(
+        outerr.getvalue()
+        # remove cwd as it's not available from outside
+        .replace(os.path.realpath(tmp_dir) + os.sep, "").replace(tmp_dir + os.sep, "")
+    )
+    return filtered_output, filtered_outerr
+
+
+def run_stubtest(
+    stub: str, runtime: str, options: list[str], config_file: str | None = None
+) -> str:
+    return run_stubtest_with_stderr(stub, runtime, options, config_file)[0]
 
 
 class Case:
-    def __init__(self, stub: str, runtime: str, error: str | None):
+    def __init__(self, stub: str, runtime: str, error: str | None) -> None:
         self.stub = stub
         self.runtime = runtime
         self.error = error
@@ -168,7 +237,13 @@ def test(*args: Any, **kwargs: Any) -> None:
         )
 
         actual_errors = set(output.splitlines())
-        assert actual_errors == expected_errors, output
+        if actual_errors != expected_errors:
+            output = run_stubtest(
+                stub="\n\n".join(textwrap.dedent(c.stub.lstrip("\n")) for c in cases),
+                runtime="\n\n".join(textwrap.dedent(c.runtime.lstrip("\n")) for c in cases),
+                options=[],
+            )
+            assert actual_errors == expected_errors, output
 
     return test
 
@@ -232,17 +307,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:
@@ -265,6 +339,21 @@ def __exit__(self, exc_type, exc_val, exc_tb): pass
             """,
             error=None,
         )
+        yield Case(
+            stub="""def dunder_name(__x: int) -> None: ...""",
+            runtime="""def dunder_name(__x: int) -> None: ...""",
+            error=None,
+        )
+        yield Case(
+            stub="""def dunder_name_posonly(__x: int, /) -> None: ...""",
+            runtime="""def dunder_name_posonly(__x: int) -> None: ...""",
+            error=None,
+        )
+        yield Case(
+            stub="""def dunder_name_bad(x: int) -> None: ...""",
+            runtime="""def dunder_name_bad(__x: int) -> None: ...""",
+            error="dunder_name_bad",
+        )
 
     @collect_cases
     def test_arg_kind(self) -> Iterator[Case]:
@@ -283,22 +372,93 @@ 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_private_parameters(self) -> Iterator[Case]:
+        # Private parameters can optionally be omitted.
+        yield Case(
+            stub="def priv_pos_arg_missing() -> None: ...",
+            runtime="def priv_pos_arg_missing(_p1=None): pass",
+            error=None,
+        )
+        yield Case(
+            stub="def multi_priv_args() -> None: ...",
+            runtime="def multi_priv_args(_p='', _q=''): pass",
+            error=None,
+        )
+        yield Case(
+            stub="def priv_kwarg_missing() -> None: ...",
+            runtime="def priv_kwarg_missing(*, _p2=''): pass",
+            error=None,
+        )
+        # But if they are included, they must be correct.
+        yield Case(
+            stub="def priv_pos_arg_wrong(_p: int = ...) -> None: ...",
+            runtime="def priv_pos_arg_wrong(_p=None): pass",
+            error="priv_pos_arg_wrong",
+        )
+        yield Case(
+            stub="def priv_kwarg_wrong(*, _p: int = ...) -> None: ...",
+            runtime="def priv_kwarg_wrong(*, _p=None): pass",
+            error="priv_kwarg_wrong",
+        )
+        # Private parameters must have a default and start with exactly one
+        # underscore.
+        yield Case(
+            stub="def pos_arg_no_default() -> None: ...",
+            runtime="def pos_arg_no_default(_np): pass",
+            error="pos_arg_no_default",
+        )
+        yield Case(
+            stub="def kwarg_no_default() -> None: ...",
+            runtime="def kwarg_no_default(*, _np): pass",
+            error="kwarg_no_default",
+        )
+        yield Case(
+            stub="def double_underscore_pos_arg() -> None: ...",
+            runtime="def double_underscore_pos_arg(__np = None): pass",
+            error="double_underscore_pos_arg",
+        )
+        yield Case(
+            stub="def double_underscore_kwarg() -> None: ...",
+            runtime="def double_underscore_kwarg(*, __np = None): pass",
+            error="double_underscore_kwarg",
+        )
+        # But spot parameters that are accidentally not marked kw-only and
+        # vice-versa.
+        yield Case(
+            stub="def priv_arg_is_kwonly(_p=...) -> None: ...",
+            runtime="def priv_arg_is_kwonly(*, _p=''): pass",
+            error="priv_arg_is_kwonly",
+        )
+        yield Case(
+            stub="def priv_arg_is_positional(*, _p=...) -> None: ...",
+            runtime="def priv_arg_is_positional(_p=''): pass",
+            error="priv_arg_is_positional",
+        )
+        # Private parameters not at the end of the parameter list must be
+        # included so that users can pass the following arguments using
+        # positional syntax.
+        yield Case(
+            stub="def priv_args_not_at_end(*, q='') -> None: ...",
+            runtime="def priv_args_not_at_end(_p='', q=''): pass",
+            error="priv_args_not_at_end",
+        )
 
     @collect_cases
     def test_default_presence(self) -> Iterator[Case]:
@@ -388,6 +548,28 @@ def test_default_value(self) -> Iterator[Case]:
             error=None,
         )
 
+        # Simulate "<unrepresentable>"
+        yield Case(
+            stub="def f11() -> None: ...",
+            runtime="""
+            def f11(text=None) -> None: pass
+            f11.__text_signature__ = "(text=<unrepresentable>)"
+            """,
+            error="f11",
+        )
+
+        # Simulate numpy ndarray.__bool__ that raises an error
+        yield Case(
+            stub="def f12(x=1): ...",
+            runtime="""
+            class _ndarray:
+                def __eq__(self, obj): return self
+                def __bool__(self): raise ValueError
+            def f12(x=_ndarray()) -> None: pass
+            """,
+            error="f12",
+        )
+
     @collect_cases
     def test_static_class_method(self) -> Iterator[Case]:
         yield Case(
@@ -582,17 +764,84 @@ 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="""
+        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="""
+            from typing import final
+            from typing_extensions import deprecated
+            class Foo:
                 @overload
-                def f5(__a: int) -> int: ...
+                @final
+                def f6(self, __a: int) -> int: ...
                 @overload
-                def f5(__b: str) -> str: ...
-                """,
-                runtime="def f5(x, /): pass",
-                error=None,
-            )
+                @deprecated("evil")
+                def f6(self, __b: str) -> str: ...
+            """,
+            runtime="""
+            class Foo:
+                def f6(self, x, /): pass
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            @overload
+            def f7(a: int, /) -> int: ...
+            @overload
+            def f7(b: str, /) -> str: ...
+            """,
+            runtime="def f7(x, /): pass",
+            error=None,
+        )
+        yield Case(
+            stub="""
+            @overload
+            def f8(a: int, c: int = 0, /) -> int: ...
+            @overload
+            def f8(b: str, d: int, /) -> str: ...
+            """,
+            runtime="def f8(x, y, /): pass",
+            error="f8",
+        )
+        yield Case(
+            stub="""
+            @overload
+            def f9(a: int, c: int = 0, /) -> int: ...
+            @overload
+            def f9(b: str, d: int, /) -> str: ...
+            """,
+            runtime="def f9(x, y=0, /): pass",
+            error=None,
+        )
+        yield Case(
+            stub="""
+            class Bar:
+                @overload
+                def f1(self) -> int: ...
+                @overload
+                def f1(self, a: int, /) -> int: ...
+
+                @overload
+                def f2(self, a: int, /) -> int: ...
+                @overload
+                def f2(self, a: str, /) -> int: ...
+            """,
+            runtime="""
+            class Bar:
+                def f1(self, *a) -> int: ...
+                def f2(self, *a) -> int: ...
+            """,
+            error=None,
+        )
 
     @collect_cases
     def test_property(self) -> Iterator[Case]:
@@ -698,6 +947,106 @@ class FineAndDandy:
             error=None,
         )
 
+    @collect_cases
+    def test_cached_property(self) -> Iterator[Case]:
+        yield Case(
+            stub="""
+            from functools import cached_property
+            class Good:
+                @cached_property
+                def read_only_attr(self) -> int: ...
+                @cached_property
+                def read_only_attr2(self) -> int: ...
+            """,
+            runtime="""
+            import functools as ft
+            from functools import cached_property
+            class Good:
+                @cached_property
+                def read_only_attr(self): return 1
+                @ft.cached_property
+                def read_only_attr2(self): return 1
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            from functools import cached_property
+            class Bad:
+                @cached_property
+                def f(self) -> int: ...
+            """,
+            runtime="""
+            class Bad:
+                def f(self) -> int: return 1
+            """,
+            error="Bad.f",
+        )
+        yield Case(
+            stub="""
+            from functools import cached_property
+            class GoodCachedAttr:
+                @cached_property
+                def f(self) -> int: ...
+            """,
+            runtime="""
+            class GoodCachedAttr:
+                f = 1
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            from functools import cached_property
+            class BadCachedAttr:
+                @cached_property
+                def f(self) -> str: ...
+            """,
+            runtime="""
+            class BadCachedAttr:
+                f = 1
+            """,
+            error="BadCachedAttr.f",
+        )
+        yield Case(
+            stub="""
+            from functools import cached_property
+            from typing import final
+            class FinalGood:
+                @cached_property
+                @final
+                def attr(self) -> int: ...
+            """,
+            runtime="""
+            from functools import cached_property
+            from typing import final
+            class FinalGood:
+                @cached_property
+                @final
+                def attr(self):
+                    return 1
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            from functools import cached_property
+            class FinalBad:
+                @cached_property
+                def attr(self) -> int: ...
+            """,
+            runtime="""
+            from functools import cached_property
+            from typing_extensions import final
+            class FinalBad:
+                @cached_property
+                @final
+                def attr(self):
+                    return 1
+            """,
+            error="FinalBad.attr",
+        )
+
     @collect_cases
     def test_var(self) -> Iterator[Case]:
         yield Case(stub="x1: int", runtime="x1 = 5", error=None)
@@ -955,16 +1304,15 @@ def fizz(self): pass
 
     @collect_cases
     def test_enum(self) -> Iterator[Case]:
+        yield Case(stub="import enum", runtime="import enum", error=None)
         yield Case(
             stub="""
-            import enum
             class X(enum.Enum):
-                a: int
-                b: str
-                c: str
+                a = ...
+                b = "asdf"
+                c = "oops"
             """,
             runtime="""
-            import enum
             class X(enum.Enum):
                 a = 1
                 b = "asdf"
@@ -972,6 +1320,105 @@ class X(enum.Enum):
             """,
             error="X.c",
         )
+        yield Case(
+            stub="""
+            class Flags1(enum.Flag):
+                a = ...
+                b = 2
+            def foo(x: Flags1 = ...) -> None: ...
+            """,
+            runtime="""
+            class Flags1(enum.Flag):
+                a = 1
+                b = 2
+            def foo(x=Flags1.a|Flags1.b): pass
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            class Flags2(enum.Flag):
+                a = ...
+                b = 2
+            def bar(x: Flags2 | None = None) -> None: ...
+            """,
+            runtime="""
+            class Flags2(enum.Flag):
+                a = 1
+                b = 2
+            def bar(x=Flags2.a|Flags2.b): pass
+            """,
+            error="bar",
+        )
+        yield Case(
+            stub="""
+            class Flags3(enum.Flag):
+                a = ...
+                b = 2
+            def baz(x: Flags3 | None = ...) -> None: ...
+            """,
+            runtime="""
+            class Flags3(enum.Flag):
+                a = 1
+                b = 2
+            def baz(x=Flags3(0)): pass
+            """,
+            error=None,
+        )
+        yield Case(
+            runtime="""
+            import enum
+            class SomeObject: ...
+
+            class WeirdEnum(enum.Enum):
+                a = SomeObject()
+                b = SomeObject()
+            """,
+            stub="""
+            import enum
+            class SomeObject: ...
+            class WeirdEnum(enum.Enum):
+                _value_: SomeObject
+                a = ...
+                b = ...
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            class Flags4(enum.Flag):
+                a = 1
+                b = 2
+            def spam(x: Flags4 | None = None) -> None: ...
+            """,
+            runtime="""
+            class Flags4(enum.Flag):
+                a = 1
+                b = 2
+            def spam(x=Flags4(0)): pass
+            """,
+            error="spam",
+        )
+        yield Case(
+            stub="""
+            from typing import Final, Literal
+            class BytesEnum(bytes, enum.Enum):
+                a = b'foo'
+            FOO: Literal[BytesEnum.a]
+            BAR: Final = BytesEnum.a
+            BAZ: BytesEnum
+            EGGS: bytes
+            """,
+            runtime="""
+            class BytesEnum(bytes, enum.Enum):
+                a = b'foo'
+            FOO = BytesEnum.a
+            BAR = BytesEnum.a
+            BAZ = BytesEnum.a
+            EGGS = BytesEnum.a
+            """,
+            error=None,
+        )
 
     @collect_cases
     def test_decorator(self) -> Iterator[Case]:
@@ -997,7 +1444,7 @@ def test_all_at_runtime_not_stub(self) -> Iterator[Case]:
             runtime="""
             __all__ = []
             Z = 5""",
-            error=None,
+            error="__all__",
         )
 
     @collect_cases
@@ -1037,7 +1484,7 @@ def h(x: str): ...
             runtime="",
             error="h",
         )
-        yield Case(stub="", runtime="__all__ = []", error=None)  # dummy case
+        yield Case(stub="", runtime="__all__ = []", error="__all__")  # dummy case
         yield Case(stub="", runtime="__all__ += ['y']\ny = 5", error="y")
         yield Case(stub="", runtime="__all__ += ['g']\ndef g(): pass", error="g")
         # Here we should only check that runtime has B, since the stub explicitly re-exports it
@@ -1054,6 +1501,34 @@ def h(x: str): ...
             runtime="__all__ += ['Z']\nclass Z:\n  def __reduce__(self): return (Z,)",
             error=None,
         )
+        # __call__ exists on type, so it appears to exist on the class.
+        # This checks that we identify it as missing at runtime anyway.
+        yield Case(
+            stub="""
+            class ClassWithMetaclassOverride:
+                def __call__(*args, **kwds): ...
+            """,
+            runtime="class ClassWithMetaclassOverride: ...",
+            error="ClassWithMetaclassOverride.__call__",
+        )
+        # Test that we ignore object.__setattr__ and object.__delattr__ inheritance
+        yield Case(
+            stub="""
+            from typing import Any
+            class FakeSetattrClass:
+                def __setattr__(self, name: str, value: Any, /) -> None: ...
+            """,
+            runtime="class FakeSetattrClass: ...",
+            error="FakeSetattrClass.__setattr__",
+        )
+        yield Case(
+            stub="""
+            class FakeDelattrClass:
+                def __delattr__(self, name: str, /) -> None: ...
+            """,
+            runtime="class FakeDelattrClass: ...",
+            error="FakeDelattrClass.__delattr__",
+        )
 
     @collect_cases
     def test_missing_no_runtime_all(self) -> Iterator[Case]:
@@ -1064,6 +1539,24 @@ def test_missing_no_runtime_all(self) -> Iterator[Case]:
         yield Case(stub="", runtime="from json.scanner import NUMBER_RE", error=None)
         yield Case(stub="", runtime="from string import ascii_letters", error=None)
 
+    @collect_cases
+    def test_missing_no_runtime_all_terrible(self) -> Iterator[Case]:
+        yield Case(
+            stub="",
+            runtime="""
+import sys
+import types
+import __future__
+_m = types.SimpleNamespace()
+_m.annotations = __future__.annotations
+sys.modules["_terrible_stubtest_test_module"] = _m
+
+from _terrible_stubtest_test_module import *
+assert annotations
+""",
+            error=None,
+        )
+
     @collect_cases
     def test_non_public_1(self) -> Iterator[Case]:
         yield Case(
@@ -1099,12 +1592,11 @@ def test_dunders(self) -> Iterator[Case]:
             runtime="class C:\n  def __init_subclass__(cls, e=1, **kwargs): pass",
             error=None,
         )
-        if sys.version_info >= (3, 9):
-            yield Case(
-                stub="class D:\n  def __class_getitem__(cls, type: type) -> type: ...",
-                runtime="class D:\n  def __class_getitem__(cls, type): ...",
-                error=None,
-            )
+        yield Case(
+            stub="class D:\n  def __class_getitem__(cls, type: type) -> type: ...",
+            runtime="class D:\n  def __class_getitem__(cls, type): ...",
+            error=None,
+        )
 
     @collect_cases
     def test_not_subclassable(self) -> Iterator[Case]:
@@ -1469,11 +1961,11 @@ def __init__(self, x): pass
     def test_good_literal(self) -> Iterator[Case]:
         yield Case(
             stub=r"""
-            from typing_extensions import Literal
+            from typing import Literal
 
             import enum
             class Color(enum.Enum):
-                RED: int
+                RED = ...
 
             NUM: Literal[1]
             CHAR: Literal['a']
@@ -1501,7 +1993,7 @@ class Color(enum.Enum):
 
     @collect_cases
     def test_bad_literal(self) -> Iterator[Case]:
-        yield Case("from typing_extensions import Literal", "", None)  # dummy case
+        yield Case("from typing import Literal", "", None)  # dummy case
         yield Case(
             stub="INT_FLOAT_MISMATCH: Literal[1]",
             runtime="INT_FLOAT_MISMATCH = 1.0",
@@ -1552,7 +2044,7 @@ def test_special_subtype(self) -> Iterator[Case]:
         )
         yield Case(
             stub="""
-            from typing_extensions import TypedDict
+            from typing import TypedDict
 
             class _Options(TypedDict):
                 a: str
@@ -1573,8 +2065,8 @@ class _Options(TypedDict):
     @collect_cases
     def test_runtime_typing_objects(self) -> Iterator[Case]:
         yield Case(
-            stub="from typing_extensions import Protocol, TypedDict",
-            runtime="from typing_extensions import Protocol, TypedDict",
+            stub="from typing import Protocol, TypedDict",
+            runtime="from typing import Protocol, TypedDict",
             error=None,
         )
         yield Case(
@@ -1602,6 +2094,72 @@ class Y(TypedDict):
             error=None,
         )
 
+    @collect_cases
+    def test_named_tuple(self) -> Iterator[Case]:
+        yield Case(
+            stub="from typing import NamedTuple",
+            runtime="from typing import NamedTuple",
+            error=None,
+        )
+        yield Case(
+            stub="""
+            class X1(NamedTuple):
+                bar: int
+                foo: str = ...
+            """,
+            runtime="""
+            class X1(NamedTuple):
+                bar: int
+                foo: str = 'a'
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            class X2(NamedTuple):
+                bar: int
+                foo: str
+            """,
+            runtime="""
+            class X2(NamedTuple):
+                bar: int
+                foo: str = 'a'
+            """,
+            # `__new__` will miss a default value for a `foo` parameter,
+            # but we don't generate special errors for `foo` missing `...` part.
+            error="X2.__new__",
+        )
+
+    @collect_cases
+    def test_named_tuple_typing_and_collections(self) -> Iterator[Case]:
+        yield Case(
+            stub="from typing import NamedTuple",
+            runtime="from collections import namedtuple",
+            error=None,
+        )
+        yield Case(
+            stub="""
+            class X1(NamedTuple):
+                bar: int
+                foo: str = ...
+            """,
+            runtime="""
+            X1 = namedtuple('X1', ['bar', 'foo'], defaults=['a'])
+            """,
+            error=None,
+        )
+        yield Case(
+            stub="""
+            class X2(NamedTuple):
+                bar: int
+                foo: str
+            """,
+            runtime="""
+            X2 = namedtuple('X1', ['bar', 'foo'], defaults=['a'])
+            """,
+            error="X2.__new__",
+        )
+
     @collect_cases
     def test_type_var(self) -> Iterator[Case]:
         yield Case(
@@ -1845,6 +2403,72 @@ def some(self) -> int: ...
             error=None,
         )
 
+    @collect_cases
+    def test_type_check_only(self) -> Iterator[Case]:
+        yield Case(
+            stub="from typing import type_check_only, overload",
+            runtime="from typing import overload",
+            error=None,
+        )
+        # You can have public types that are only defined in stubs
+        # with `@type_check_only`:
+        yield Case(
+            stub="""
+            @type_check_only
+            class A1: ...
+            """,
+            runtime="",
+            error=None,
+        )
+        # Having `@type_check_only` on a type that exists at runtime is an error
+        yield Case(
+            stub="""
+            @type_check_only
+            class A2: ...
+            """,
+            runtime="class A2: ...",
+            error="A2",
+        )
+        # The same is true for NamedTuples and TypedDicts:
+        yield Case(
+            stub="from typing import NamedTuple, TypedDict",
+            runtime="from typing import NamedTuple, TypedDict",
+            error=None,
+        )
+        yield Case(
+            stub="""
+            @type_check_only
+            class NT1(NamedTuple): ...
+            """,
+            runtime="class NT1(NamedTuple): ...",
+            error="NT1",
+        )
+        yield Case(
+            stub="""
+            @type_check_only
+            class TD1(TypedDict): ...
+            """,
+            runtime="class TD1(TypedDict): ...",
+            error="TD1",
+        )
+        # The same is true for functions:
+        yield Case(
+            stub="""
+            @type_check_only
+            def func1() -> None: ...
+            """,
+            runtime="",
+            error=None,
+        )
+        yield Case(
+            stub="""
+            @type_check_only
+            def func2() -> None: ...
+            """,
+            runtime="def func2() -> None: ...",
+            error="func2",
+        )
+
 
 def remove_color_code(s: str) -> str:
     return re.sub("\\x1b.*?m", "", s)  # this works!
@@ -1948,7 +2572,7 @@ def also_bad(asdf): pass
                 options=["--allowlist", allowlist.name, "--generate-allowlist"],
             )
             assert output == (
-                f"note: unused allowlist entry unused.*\n" f"{TEST_MODULE_NAME}.also_bad\n"
+                f"note: unused allowlist entry unused.*\n{TEST_MODULE_NAME}.also_bad\n"
             )
         finally:
             os.unlink(allowlist.name)
@@ -2013,6 +2637,14 @@ def f(a: int, b: int, *, c: int, d: int = 0, **kwargs: Any) -> None:
             == "def (a, b, *, c, d = ..., **kwargs)"
         )
 
+    def test_builtin_signature_with_unrepresentable_default(self) -> None:
+        sig = mypy.stubtest.safe_inspect_signature(bytes.hex)
+        assert sig is not None
+        assert (
+            str(mypy.stubtest.Signature.from_inspect_signature(sig))
+            == "def (self, sep = ..., bytes_per_sep = ...)"
+        )
+
     def test_config_file(self) -> None:
         runtime = "temp = 5\n"
         stub = "from decimal import Decimal\ntemp: Decimal\n"
@@ -2026,6 +2658,46 @@ def test_config_file(self) -> None:
         output = run_stubtest(stub=stub, runtime=runtime, options=[], config_file=config_file)
         assert output == "Success: no issues found in 1 module\n"
 
+    def test_config_file_error_codes(self) -> None:
+        runtime = "temp = 5\n"
+        stub = "temp = SOME_GLOBAL_CONST"
+        output = run_stubtest(stub=stub, runtime=runtime, options=[])
+        assert output == (
+            "error: not checking stubs due to mypy build errors:\n"
+            'test_module.pyi:1: error: Name "SOME_GLOBAL_CONST" is not defined  [name-defined]\n'
+        )
+
+        config_file = "[mypy]\ndisable_error_code = name-defined\n"
+        output = run_stubtest(stub=stub, runtime=runtime, options=[], config_file=config_file)
+        assert output == "Success: no issues found in 1 module\n"
+
+    def test_config_file_error_codes_invalid(self) -> None:
+        runtime = "temp = 5\n"
+        stub = "temp: int\n"
+        config_file = "[mypy]\ndisable_error_code = not-a-valid-name\n"
+        output, outerr = run_stubtest_with_stderr(
+            stub=stub, runtime=runtime, options=[], config_file=config_file
+        )
+        assert output == "Success: no issues found in 1 module\n"
+        assert outerr == (
+            "test_module_config.ini: [mypy]: disable_error_code: "
+            "Invalid error code(s): not-a-valid-name\n"
+        )
+
+    def test_config_file_wrong_incomplete_feature(self) -> None:
+        runtime = "x = 1\n"
+        stub = "x: int\n"
+        config_file = "[mypy]\nenable_incomplete_feature = Unpack\n"
+        output = run_stubtest(stub=stub, runtime=runtime, options=[], config_file=config_file)
+        assert output == (
+            "warning: Warning: Unpack is already enabled by default\n"
+            "Success: no issues found in 1 module\n"
+        )
+
+        config_file = "[mypy]\nenable_incomplete_feature = not-a-valid-name\n"
+        with self.assertRaises(SystemExit):
+            run_stubtest(stub=stub, runtime=runtime, options=[], config_file=config_file)
+
     def test_no_modules(self) -> None:
         output = io.StringIO()
         with contextlib.redirect_stdout(output):
diff --git a/mypy/test/testsubtypes.py b/mypy/test/testsubtypes.py
index c76a34ff00d7..b75c22bca7f7 100644
--- a/mypy/test/testsubtypes.py
+++ b/mypy/test/testsubtypes.py
@@ -2,9 +2,9 @@
 
 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
+from mypy.types import Instance, TupleType, Type, UninhabitedType, UnpackType
 
 
 class SubtypingSuite(Suite):
@@ -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()
@@ -88,7 +87,7 @@ def test_basic_callable_subtyping(self) -> None:
         )
 
         self.assert_strict_subtype(
-            self.fx.callable(self.fx.a, self.fx.nonet), self.fx.callable(self.fx.a, self.fx.a)
+            self.fx.callable(self.fx.a, UninhabitedType()), self.fx.callable(self.fx.a, self.fx.a)
         )
 
         self.assert_unrelated(
@@ -222,10 +221,6 @@ def test_type_var_tuple(self) -> None:
             Instance(self.fx.gvi, [UnpackType(self.fx.us)]),
         )
 
-        self.assert_subtype(
-            Instance(self.fx.gvi, [UnpackType(self.fx.anyt)]),
-            Instance(self.fx.gvi, [self.fx.anyt]),
-        )
         self.assert_not_subtype(
             Instance(self.fx.gvi, [UnpackType(self.fx.ss)]), Instance(self.fx.gvi, [])
         )
@@ -273,87 +268,15 @@ def test_type_var_tuple_with_prefix_suffix(self) -> None:
             Instance(self.fx.gvi, [self.fx.a, UnpackType(self.fx.ss), self.fx.b, self.fx.c]),
         )
 
-    def test_type_var_tuple_unpacked_varlength_tuple(self) -> None:
-        self.assert_subtype(
-            Instance(
-                self.fx.gvi,
-                [
-                    UnpackType(
-                        TupleType(
-                            [self.fx.a, self.fx.b],
-                            fallback=Instance(self.fx.std_tuplei, [self.fx.o]),
-                        )
-                    )
-                ],
-            ),
-            Instance(self.fx.gvi, [self.fx.a, self.fx.b]),
-        )
-
-    def test_type_var_tuple_unpacked_tuple(self) -> None:
-        self.assert_subtype(
-            Instance(
-                self.fx.gvi,
-                [
-                    UnpackType(
-                        TupleType(
-                            [self.fx.a, self.fx.b],
-                            fallback=Instance(self.fx.std_tuplei, [self.fx.o]),
-                        )
-                    )
-                ],
-            ),
-            Instance(self.fx.gvi, [self.fx.a, self.fx.b]),
-        )
-        self.assert_subtype(
-            Instance(
-                self.fx.gvi,
-                [
-                    UnpackType(
-                        TupleType(
-                            [self.fx.a, self.fx.b],
-                            fallback=Instance(self.fx.std_tuplei, [self.fx.o]),
-                        )
-                    )
-                ],
-            ),
-            Instance(self.fx.gvi, [self.fx.anyt, self.fx.anyt]),
-        )
-        self.assert_not_subtype(
-            Instance(
-                self.fx.gvi,
-                [
-                    UnpackType(
-                        TupleType(
-                            [self.fx.a, self.fx.b],
-                            fallback=Instance(self.fx.std_tuplei, [self.fx.o]),
-                        )
-                    )
-                ],
-            ),
-            Instance(self.fx.gvi, [self.fx.a]),
-        )
-        self.assert_not_subtype(
-            Instance(
-                self.fx.gvi,
-                [
-                    UnpackType(
-                        TupleType(
-                            [self.fx.a, self.fx.b],
-                            fallback=Instance(self.fx.std_tuplei, [self.fx.o]),
-                        )
-                    )
-                ],
-            ),
-            # Order flipped here.
-            Instance(self.fx.gvi, [self.fx.b, self.fx.a]),
-        )
-
     def test_type_var_tuple_unpacked_variable_length_tuple(self) -> None:
-        self.assert_equivalent(
+        self.assert_subtype(
             Instance(self.fx.gvi, [self.fx.a, self.fx.a]),
             Instance(self.fx.gvi, [UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))]),
         )
 
+    def test_fallback_not_subtype_of_tuple(self) -> None:
+        self.assert_not_subtype(self.fx.a, TupleType([self.fx.b], fallback=self.fx.a))
+
     # IDEA: Maybe add these test cases (they are tested pretty well in type
     #       checker tests already):
     #  * more interface subtyping test cases
diff --git a/mypy/test/testtransform.py b/mypy/test/testtransform.py
index ba9fe8668fb4..9388dca02c7a 100644
--- a/mypy/test/testtransform.py
+++ b/mypy/test/testtransform.py
@@ -5,7 +5,6 @@
 from mypy import build
 from mypy.errors import CompileError
 from mypy.modulefinder import BuildSource
-from mypy.options import TYPE_VAR_TUPLE, UNPACK
 from mypy.test.config import test_temp_dir
 from mypy.test.data import DataDrivenTestCase, DataSuite
 from mypy.test.helpers import assert_string_arrays_equal, normalize_error_messages, parse_options
@@ -38,7 +37,6 @@ def test_transform(testcase: DataDrivenTestCase) -> None:
         options = parse_options(src, testcase, 1)
         options.use_builtins_fixtures = True
         options.semantic_analysis_only = True
-        options.enable_incomplete_feature = [TYPE_VAR_TUPLE, UNPACK]
         options.show_traceback = True
         options.force_uppercase_builtins = True
         result = build.build(
diff --git a/mypy/test/testtypes.py b/mypy/test/testtypes.py
index 5f6943de3199..a42519c64956 100644
--- a/mypy/test/testtypes.py
+++ b/mypy/test/testtypes.py
@@ -5,11 +5,9 @@
 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.join import join_types
 from mypy.meet import meet_types, narrow_declared_type
 from mypy.nodes import (
     ARG_NAMED,
@@ -49,10 +47,14 @@
     UnboundType,
     UninhabitedType,
     UnionType,
+    UnpackType,
     get_proper_type,
     has_recursive_types,
 )
 
+# Solving the import cycle:
+import mypy.expandtype  # ruff: isort: skip
+
 
 class TypesSuite(Suite):
     def setUp(self) -> None:
@@ -128,10 +130,10 @@ def test_callable_type_with_var_args(self) -> None:
         )
         assert_equal(str(c3), "def (X? =, *Y?) -> Any")
 
-    def test_tuple_type(self) -> None:
+    def test_tuple_type_upper(self) -> None:
         options = Options()
         options.force_uppercase_builtins = True
-        assert_equal(TupleType([], self.fx.std_tuple).str_with_options(options), "Tuple[]")
+        assert_equal(TupleType([], self.fx.std_tuple).str_with_options(options), "Tuple[()]")
         assert_equal(TupleType([self.x], self.fx.std_tuple).str_with_options(options), "Tuple[X?]")
         assert_equal(
             TupleType(
@@ -142,7 +144,11 @@ def test_tuple_type(self) -> None:
 
     def test_type_variable_binding(self) -> None:
         assert_equal(
-            str(TypeVarType("X", "X", 1, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics))),
+            str(
+                TypeVarType(
+                    "X", "X", TypeVarId(1), [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)
+                )
+            ),
             "X`1",
         )
         assert_equal(
@@ -150,7 +156,7 @@ def test_type_variable_binding(self) -> None:
                 TypeVarType(
                     "X",
                     "X",
-                    1,
+                    TypeVarId(1),
                     [self.x, self.y],
                     self.fx.o,
                     AnyType(TypeOfAny.from_omitted_generics),
@@ -168,14 +174,25 @@ def test_generic_function_type(self) -> None:
             self.function,
             name=None,
             variables=[
-                TypeVarType("X", "X", -1, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics))
+                TypeVarType(
+                    "X",
+                    "X",
+                    TypeVarId(-1),
+                    [],
+                    self.fx.o,
+                    AnyType(TypeOfAny.from_omitted_generics),
+                )
             ],
         )
         assert_equal(str(c), "def [X] (X?, Y?) -> Y?")
 
         v = [
-            TypeVarType("Y", "Y", -1, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)),
-            TypeVarType("X", "X", -2, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)),
+            TypeVarType(
+                "Y", "Y", TypeVarId(-1), [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)
+            ),
+            TypeVarType(
+                "X", "X", TypeVarId(-2), [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)
+            ),
         ]
         c2 = CallableType([], [], [], NoneType(), self.function, name=None, variables=v)
         assert_equal(str(c2), "def [Y, X] ()")
@@ -203,7 +220,9 @@ def test_type_alias_expand_all(self) -> None:
 
     def test_recursive_nested_in_non_recursive(self) -> None:
         A, _ = self.fx.def_alias_1(self.fx.a)
-        T = TypeVarType("T", "T", -1, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics))
+        T = TypeVarType(
+            "T", "T", TypeVarId(-1), [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)
+        )
         NA = self.fx.non_rec_alias(Instance(self.fx.gi, [T]), [T], [A])
         assert not NA.is_recursive
         assert has_recursive_types(NA)
@@ -211,12 +230,14 @@ def test_recursive_nested_in_non_recursive(self) -> None:
     def test_indirection_no_infinite_recursion(self) -> None:
         A, _ = self.fx.def_alias_1(self.fx.a)
         visitor = TypeIndirectionVisitor()
-        modules = A.accept(visitor)
+        A.accept(visitor)
+        modules = visitor.modules
         assert modules == {"__main__", "builtins"}
 
         A, _ = self.fx.def_alias_2(self.fx.a)
         visitor = TypeIndirectionVisitor()
-        modules = A.accept(visitor)
+        A.accept(visitor)
+        modules = visitor.modules
         assert modules == {"__main__", "builtins"}
 
 
@@ -268,7 +289,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))
 
@@ -655,7 +676,9 @@ def callable(self, vars: list[str], *a: Type) -> CallableType:
         n = -1
         for v in vars:
             tv.append(
-                TypeVarType(v, v, n, [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics))
+                TypeVarType(
+                    v, v, TypeVarId(n), [], self.fx.o, AnyType(TypeOfAny.from_omitted_generics)
+                )
             )
             n -= 1
         return CallableType(
@@ -745,18 +768,19 @@ def test_type_vars(self) -> None:
         self.assert_join(self.fx.t, self.fx.s, self.fx.o)
 
     def test_none(self) -> None:
-        # Any type t joined with None results in t.
-        for t in [
-            NoneType(),
-            self.fx.a,
-            self.fx.o,
-            UnboundType("x"),
-            self.fx.t,
-            self.tuple(),
-            self.callable(self.fx.a, self.fx.b),
-            self.fx.anyt,
-        ]:
-            self.assert_join(t, NoneType(), t)
+        with state.strict_optional_set(False):
+            # Any type t joined with None results in t.
+            for t in [
+                NoneType(),
+                self.fx.a,
+                self.fx.o,
+                UnboundType("x"),
+                self.fx.t,
+                self.tuple(),
+                self.callable(self.fx.a, self.fx.b),
+                self.fx.anyt,
+            ]:
+                self.assert_join(t, NoneType(), t)
 
     def test_unbound_type(self) -> None:
         self.assert_join(UnboundType("x"), UnboundType("x"), self.fx.anyt)
@@ -777,6 +801,9 @@ def test_unbound_type(self) -> None:
 
     def test_any_type(self) -> None:
         # Join against 'Any' type always results in 'Any'.
+        with state.strict_optional_set(False):
+            self.assert_join(NoneType(), self.fx.anyt, self.fx.anyt)
+
         for t in [
             self.fx.anyt,
             self.fx.a,
@@ -790,12 +817,12 @@ def test_any_type(self) -> None:
             self.assert_join(t, self.fx.anyt, self.fx.anyt)
 
     def test_mixed_truth_restricted_type_simple(self) -> None:
-        # join_simple against differently restricted truthiness types drops restrictions.
+        # make_simplified_union against differently restricted truthiness types drops restrictions.
         true_a = true_only(self.fx.a)
         false_o = false_only(self.fx.o)
-        j = join_simple(self.fx.o, true_a, false_o)
-        assert j.can_be_true
-        assert j.can_be_false
+        u = make_simplified_union([true_a, false_o])
+        assert u.can_be_true
+        assert u.can_be_false
 
     def test_mixed_truth_restricted_type(self) -> None:
         # join_types against differently restricted truthiness types drops restrictions.
@@ -813,7 +840,11 @@ def test_other_mixed_types(self) -> None:
                     self.assert_join(t1, t2, self.fx.o)
 
     def test_simple_generics(self) -> None:
-        self.assert_join(self.fx.ga, self.fx.nonet, self.fx.ga)
+        with state.strict_optional_set(False):
+            self.assert_join(self.fx.ga, self.fx.nonet, self.fx.ga)
+        with state.strict_optional_set(True):
+            self.assert_join(self.fx.ga, self.fx.nonet, UnionType([self.fx.ga, NoneType()]))
+
         self.assert_join(self.fx.ga, self.fx.anyt, self.fx.anyt)
 
         for t in [
@@ -899,13 +930,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)
@@ -987,6 +1016,54 @@ def test_literal_type(self) -> None:
             UnionType([lit2, lit3]), UnionType([lit1, lit2]), UnionType([lit2, lit3, lit1])
         )
 
+    def test_variadic_tuple_joins(self) -> None:
+        # These tests really test just the "arity", to be sure it is handled correctly.
+        self.assert_join(
+            self.tuple(self.fx.a, self.fx.a),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            Instance(self.fx.std_tuplei, [self.fx.a]),
+        )
+        self.assert_join(
+            self.tuple(self.fx.a, self.fx.a),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a),
+        )
+        self.assert_join(
+            self.tuple(self.fx.a, self.fx.a),
+            self.tuple(self.fx.a, UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            self.tuple(self.fx.a, UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+        )
+        self.assert_join(
+            self.tuple(
+                self.fx.a, UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a
+            ),
+            self.tuple(
+                self.fx.a, UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a
+            ),
+            self.tuple(
+                self.fx.a, UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a
+            ),
+        )
+        self.assert_join(
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            self.tuple(
+                self.fx.a, UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a
+            ),
+            Instance(self.fx.std_tuplei, [self.fx.a]),
+        )
+        self.assert_join(
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            Instance(self.fx.std_tuplei, [self.fx.a]),
+        )
+        self.assert_join(
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a),
+            self.tuple(
+                self.fx.b, UnpackType(Instance(self.fx.std_tuplei, [self.fx.b])), self.fx.b
+            ),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a),
+        )
+
     # There are additional test cases in check-inference.test.
 
     # TODO: Function types + varargs and default args.
@@ -1038,8 +1115,8 @@ def test_class_subtyping(self) -> None:
         self.assert_meet(self.fx.a, self.fx.o, self.fx.a)
         self.assert_meet(self.fx.a, self.fx.b, self.fx.b)
         self.assert_meet(self.fx.b, self.fx.o, self.fx.b)
-        self.assert_meet(self.fx.a, self.fx.d, NoneType())
-        self.assert_meet(self.fx.b, self.fx.c, NoneType())
+        self.assert_meet(self.fx.a, self.fx.d, UninhabitedType())
+        self.assert_meet(self.fx.b, self.fx.c, UninhabitedType())
 
     def test_tuples(self) -> None:
         self.assert_meet(self.tuple(), self.tuple(), self.tuple())
@@ -1047,13 +1124,15 @@ def test_tuples(self) -> None:
         self.assert_meet(
             self.tuple(self.fx.b, self.fx.c),
             self.tuple(self.fx.a, self.fx.d),
-            self.tuple(self.fx.b, NoneType()),
+            self.tuple(self.fx.b, UninhabitedType()),
         )
 
         self.assert_meet(
             self.tuple(self.fx.a, self.fx.a), self.fx.std_tuple, self.tuple(self.fx.a, self.fx.a)
         )
-        self.assert_meet(self.tuple(self.fx.a), self.tuple(self.fx.a, self.fx.a), NoneType())
+        self.assert_meet(
+            self.tuple(self.fx.a), self.tuple(self.fx.a, self.fx.a), UninhabitedType()
+        )
 
     def test_function_types(self) -> None:
         self.assert_meet(
@@ -1076,7 +1155,7 @@ def test_function_types(self) -> None:
     def test_type_vars(self) -> None:
         self.assert_meet(self.fx.t, self.fx.t, self.fx.t)
         self.assert_meet(self.fx.s, self.fx.s, self.fx.s)
-        self.assert_meet(self.fx.t, self.fx.s, NoneType())
+        self.assert_meet(self.fx.t, self.fx.s, UninhabitedType())
 
     def test_none(self) -> None:
         self.assert_meet(NoneType(), NoneType(), NoneType())
@@ -1084,15 +1163,27 @@ def test_none(self) -> None:
         self.assert_meet(NoneType(), self.fx.anyt, NoneType())
 
         # Any type t joined with None results in None, unless t is Any.
-        for t in [
-            self.fx.a,
-            self.fx.o,
-            UnboundType("x"),
-            self.fx.t,
-            self.tuple(),
-            self.callable(self.fx.a, self.fx.b),
-        ]:
-            self.assert_meet(t, NoneType(), NoneType())
+        with state.strict_optional_set(False):
+            for t in [
+                self.fx.a,
+                self.fx.o,
+                UnboundType("x"),
+                self.fx.t,
+                self.tuple(),
+                self.callable(self.fx.a, self.fx.b),
+            ]:
+                self.assert_meet(t, NoneType(), NoneType())
+
+        with state.strict_optional_set(True):
+            self.assert_meet(self.fx.o, NoneType(), NoneType())
+            for t in [
+                self.fx.a,
+                UnboundType("x"),
+                self.fx.t,
+                self.tuple(),
+                self.callable(self.fx.a, self.fx.b),
+            ]:
+                self.assert_meet(t, NoneType(), UninhabitedType())
 
     def test_unbound_type(self) -> None:
         self.assert_meet(UnboundType("x"), UnboundType("x"), self.fx.anyt)
@@ -1130,28 +1221,28 @@ def test_simple_generics(self) -> None:
         self.assert_meet(self.fx.ga, self.fx.ga, self.fx.ga)
         self.assert_meet(self.fx.ga, self.fx.o, self.fx.ga)
         self.assert_meet(self.fx.ga, self.fx.gb, self.fx.gb)
-        self.assert_meet(self.fx.ga, self.fx.gd, self.fx.nonet)
-        self.assert_meet(self.fx.ga, self.fx.g2a, self.fx.nonet)
+        self.assert_meet(self.fx.ga, self.fx.gd, UninhabitedType())
+        self.assert_meet(self.fx.ga, self.fx.g2a, UninhabitedType())
 
-        self.assert_meet(self.fx.ga, self.fx.nonet, self.fx.nonet)
+        self.assert_meet(self.fx.ga, self.fx.nonet, UninhabitedType())
         self.assert_meet(self.fx.ga, self.fx.anyt, self.fx.ga)
 
         for t in [self.fx.a, self.fx.t, self.tuple(), self.callable(self.fx.a, self.fx.b)]:
-            self.assert_meet(t, self.fx.ga, self.fx.nonet)
+            self.assert_meet(t, self.fx.ga, UninhabitedType())
 
     def test_generics_with_multiple_args(self) -> None:
         self.assert_meet(self.fx.hab, self.fx.hab, self.fx.hab)
         self.assert_meet(self.fx.hab, self.fx.haa, self.fx.hab)
-        self.assert_meet(self.fx.hab, self.fx.had, self.fx.nonet)
+        self.assert_meet(self.fx.hab, self.fx.had, UninhabitedType())
         self.assert_meet(self.fx.hab, self.fx.hbb, self.fx.hbb)
 
     def test_generics_with_inheritance(self) -> None:
         self.assert_meet(self.fx.gsab, self.fx.gb, self.fx.gsab)
-        self.assert_meet(self.fx.gsba, self.fx.gb, self.fx.nonet)
+        self.assert_meet(self.fx.gsba, self.fx.gb, UninhabitedType())
 
     def test_generics_with_inheritance_and_shared_supertype(self) -> None:
-        self.assert_meet(self.fx.gsba, self.fx.gs2a, self.fx.nonet)
-        self.assert_meet(self.fx.gsab, self.fx.gs2a, self.fx.nonet)
+        self.assert_meet(self.fx.gsba, self.fx.gs2a, UninhabitedType())
+        self.assert_meet(self.fx.gsab, self.fx.gs2a, UninhabitedType())
 
     def test_generic_types_and_dynamic(self) -> None:
         self.assert_meet(self.fx.gdyn, self.fx.ga, self.fx.ga)
@@ -1165,34 +1256,33 @@ def test_callables_with_dynamic(self) -> None:
 
     def test_meet_interface_types(self) -> None:
         self.assert_meet(self.fx.f, self.fx.f, self.fx.f)
-        self.assert_meet(self.fx.f, self.fx.f2, self.fx.nonet)
+        self.assert_meet(self.fx.f, self.fx.f2, UninhabitedType())
         self.assert_meet(self.fx.f, self.fx.f3, self.fx.f3)
 
     def test_meet_interface_and_class_types(self) -> None:
         self.assert_meet(self.fx.o, self.fx.f, self.fx.f)
-        self.assert_meet(self.fx.a, self.fx.f, self.fx.nonet)
+        self.assert_meet(self.fx.a, self.fx.f, UninhabitedType())
 
         self.assert_meet(self.fx.e, self.fx.f, self.fx.e)
 
     def test_meet_class_types_with_shared_interfaces(self) -> None:
         # These have nothing special with respect to meets, unlike joins. These
         # are for completeness only.
-        self.assert_meet(self.fx.e, self.fx.e2, self.fx.nonet)
-        self.assert_meet(self.fx.e2, self.fx.e3, self.fx.nonet)
+        self.assert_meet(self.fx.e, self.fx.e2, UninhabitedType())
+        self.assert_meet(self.fx.e2, self.fx.e3, UninhabitedType())
 
-    @skip
     def test_meet_with_generic_interfaces(self) -> None:
         fx = InterfaceTypeFixture()
         self.assert_meet(fx.gfa, fx.m1, fx.m1)
         self.assert_meet(fx.gfa, fx.gfa, fx.gfa)
-        self.assert_meet(fx.gfb, fx.m1, fx.nonet)
+        self.assert_meet(fx.gfb, fx.m1, UninhabitedType())
 
     def test_type_type(self) -> None:
         self.assert_meet(self.fx.type_a, self.fx.type_b, self.fx.type_b)
         self.assert_meet(self.fx.type_b, self.fx.type_any, self.fx.type_b)
         self.assert_meet(self.fx.type_b, self.fx.type_type, self.fx.type_b)
-        self.assert_meet(self.fx.type_b, self.fx.type_c, self.fx.nonet)
-        self.assert_meet(self.fx.type_c, self.fx.type_d, self.fx.nonet)
+        self.assert_meet(self.fx.type_b, self.fx.type_c, self.fx.type_never)
+        self.assert_meet(self.fx.type_c, self.fx.type_d, self.fx.type_never)
         self.assert_meet(self.fx.type_type, self.fx.type_any, self.fx.type_any)
         self.assert_meet(self.fx.type_b, self.fx.anyt, self.fx.type_b)
 
@@ -1223,6 +1313,34 @@ def assert_meet_uninhabited(self, s: Type, t: Type) -> None:
         with state.strict_optional_set(True):
             self.assert_meet(s, t, self.fx.uninhabited)
 
+    def test_variadic_tuple_meets(self) -> None:
+        # These tests really test just the "arity", to be sure it is handled correctly.
+        self.assert_meet(
+            self.tuple(self.fx.a, self.fx.a),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            self.tuple(self.fx.a, self.fx.a),
+        )
+        self.assert_meet(
+            self.tuple(self.fx.a, self.fx.a),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a),
+            self.tuple(self.fx.a, self.fx.a),
+        )
+        self.assert_meet(
+            self.tuple(self.fx.a, self.fx.a),
+            self.tuple(self.fx.a, UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            self.tuple(self.fx.a, self.fx.a),
+        )
+        self.assert_meet(
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a]))),
+        )
+        self.assert_meet(
+            self.tuple(UnpackType(Instance(self.fx.std_tuplei, [self.fx.a])), self.fx.a),
+            self.tuple(self.fx.b, UnpackType(Instance(self.fx.std_tuplei, [self.fx.b]))),
+            self.tuple(self.fx.b, UnpackType(Instance(self.fx.std_tuplei, [self.fx.b]))),
+        )
+
     def assert_meet(self, s: Type, t: Type, meet: Type) -> None:
         self.assert_simple_meet(s, t, meet)
         self.assert_simple_meet(t, s, meet)
@@ -1466,11 +1584,12 @@ def make_call(*items: tuple[str, str | None]) -> CallExpr:
 class TestExpandTypeLimitGetProperType(TestCase):
     # WARNING: do not increase this number unless absolutely necessary,
     # and you understand what you are doing.
-    ALLOWED_GET_PROPER_TYPES = 8
+    ALLOWED_GET_PROPER_TYPES = 7
 
     @skipUnless(mypy.expandtype.__file__.endswith(".py"), "Skip for compiled mypy")
     def test_count_get_proper_type(self) -> None:
         with open(mypy.expandtype.__file__) as f:
             code = f.read()
-        get_proper_type_count = len(re.findall("get_proper_type", code))
+        get_proper_type_count = len(re.findall(r"get_proper_type\(", code))
+        get_proper_type_count -= len(re.findall(r"get_proper_type\(\)", code))
         assert get_proper_type_count == self.ALLOWED_GET_PROPER_TYPES
diff --git a/mypy/test/testutil.py b/mypy/test/testutil.py
index 89184b11a826..a7c3f1c00fee 100644
--- a/mypy/test/testutil.py
+++ b/mypy/test/testutil.py
@@ -3,7 +3,8 @@
 import os
 from unittest import TestCase, mock
 
-from mypy.util import get_terminal_width
+from mypy.inspections import parse_location
+from mypy.util import _generate_junit_contents, get_terminal_width
 
 
 class TestGetTerminalSize(TestCase):
@@ -15,3 +16,96 @@ def test_get_terminal_size_in_pty_defaults_to_80(self) -> None:
         with mock.patch.object(os, "get_terminal_size", return_value=ret):
             with mock.patch.dict(os.environ, values=mock_environ, clear=True):
                 assert get_terminal_width() == 80
+
+    def test_parse_location_windows(self) -> None:
+        assert parse_location(r"C:\test.py:1:1") == (r"C:\test.py", [1, 1])
+        assert parse_location(r"C:\test.py:1:1:1:1") == (r"C:\test.py", [1, 1, 1, 1])
+
+
+class TestWriteJunitXml(TestCase):
+    def test_junit_pass(self) -> None:
+        serious = False
+        messages_by_file: dict[str | None, list[str]] = {}
+        expected = """<?xml version="1.0" encoding="utf-8"?>
+<testsuite errors="0" failures="0" name="mypy" skips="0" tests="1" time="1.230">
+  <testcase classname="mypy" file="mypy" line="1" name="mypy-py3.14-test-plat" time="1.230">
+  </testcase>
+</testsuite>
+"""
+        result = _generate_junit_contents(
+            dt=1.23,
+            serious=serious,
+            messages_by_file=messages_by_file,
+            version="3.14",
+            platform="test-plat",
+        )
+        assert result == expected
+
+    def test_junit_fail_escape_xml_chars(self) -> None:
+        serious = False
+        messages_by_file: dict[str | None, list[str]] = {
+            "file1.py": ["Test failed", "another line < > &"]
+        }
+        expected = """<?xml version="1.0" encoding="utf-8"?>
+<testsuite errors="0" failures="1" name="mypy" skips="0" tests="1" time="1.230">
+  <testcase classname="mypy" file="file1.py" line="1" name="mypy-py3.14-test-plat file1.py" time="1.230">
+    <failure message="mypy produced messages">Test failed
+another line &lt; &gt; &amp;</failure>
+  </testcase>
+</testsuite>
+"""
+        result = _generate_junit_contents(
+            dt=1.23,
+            serious=serious,
+            messages_by_file=messages_by_file,
+            version="3.14",
+            platform="test-plat",
+        )
+        assert result == expected
+
+    def test_junit_fail_two_files(self) -> None:
+        serious = False
+        messages_by_file: dict[str | None, list[str]] = {
+            "file1.py": ["Test failed", "another line"],
+            "file2.py": ["Another failure", "line 2"],
+        }
+        expected = """<?xml version="1.0" encoding="utf-8"?>
+<testsuite errors="0" failures="2" name="mypy" skips="0" tests="2" time="1.230">
+  <testcase classname="mypy" file="file1.py" line="1" name="mypy-py3.14-test-plat file1.py" time="1.230">
+    <failure message="mypy produced messages">Test failed
+another line</failure>
+  </testcase>
+  <testcase classname="mypy" file="file2.py" line="1" name="mypy-py3.14-test-plat file2.py" time="1.230">
+    <failure message="mypy produced messages">Another failure
+line 2</failure>
+  </testcase>
+</testsuite>
+"""
+        result = _generate_junit_contents(
+            dt=1.23,
+            serious=serious,
+            messages_by_file=messages_by_file,
+            version="3.14",
+            platform="test-plat",
+        )
+        assert result == expected
+
+    def test_serious_error(self) -> None:
+        serious = True
+        messages_by_file: dict[str | None, list[str]] = {None: ["Error line 1", "Error line 2"]}
+        expected = """<?xml version="1.0" encoding="utf-8"?>
+<testsuite errors="1" failures="0" name="mypy" skips="0" tests="1" time="1.230">
+  <testcase classname="mypy" file="mypy" line="1" name="mypy-py3.14-test-plat" time="1.230">
+    <failure message="mypy produced messages">Error line 1
+Error line 2</failure>
+  </testcase>
+</testsuite>
+"""
+        result = _generate_junit_contents(
+            dt=1.23,
+            serious=serious,
+            messages_by_file=messages_by_file,
+            version="3.14",
+            platform="test-plat",
+        )
+        assert result == expected
diff --git a/mypy/test/typefixture.py b/mypy/test/typefixture.py
index bf1500a3cdec..d6c904732b17 100644
--- a/mypy/test/typefixture.py
+++ b/mypy/test/typefixture.py
@@ -30,6 +30,7 @@
     TypeAliasType,
     TypeOfAny,
     TypeType,
+    TypeVarId,
     TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
@@ -57,7 +58,7 @@ def make_type_var(
             return TypeVarType(
                 name,
                 name,
-                id,
+                TypeVarId(id),
                 values,
                 upper_bound,
                 AnyType(TypeOfAny.from_omitted_generics),
@@ -215,23 +216,29 @@ def make_type_var(
         self.type_d = TypeType.make_normalized(self.d)
         self.type_t = TypeType.make_normalized(self.t)
         self.type_any = TypeType.make_normalized(self.anyt)
+        self.type_never = TypeType.make_normalized(UninhabitedType())
 
         self._add_bool_dunder(self.bool_type_info)
         self._add_bool_dunder(self.ai)
 
+        # TypeVars with non-trivial bounds
+        self.ub = make_type_var("UB", 5, [], self.b, variance)  # UB`5 (type variable)
+        self.uc = make_type_var("UC", 6, [], self.c, variance)  # UC`6 (type variable)
+
         def make_type_var_tuple(name: str, id: int, upper_bound: Type) -> TypeVarTupleType:
             return TypeVarTupleType(
                 name,
                 name,
-                id,
+                TypeVarId(id),
                 upper_bound,
                 self.std_tuple,
                 AnyType(TypeOfAny.from_omitted_generics),
             )
 
-        self.ts = make_type_var_tuple("Ts", 1, self.o)  # Ts`1 (type var tuple)
-        self.ss = make_type_var_tuple("Ss", 2, self.o)  # Ss`2 (type var tuple)
-        self.us = make_type_var_tuple("Us", 3, self.o)  # Us`3 (type var tuple)
+        obj_tuple = self.std_tuple.copy_modified(args=[self.o])
+        self.ts = make_type_var_tuple("Ts", 1, obj_tuple)  # Ts`1 (type var tuple)
+        self.ss = make_type_var_tuple("Ss", 2, obj_tuple)  # Ss`2 (type var tuple)
+        self.us = make_type_var_tuple("Us", 3, obj_tuple)  # Us`3 (type var tuple)
 
         self.gvi = self.make_type_info("GV", mro=[self.oi], typevars=["Ts"], typevar_tuple_index=0)
         self.gv2i = self.make_type_info(
@@ -320,9 +327,9 @@ def make_type_info(
                         TypeVarTupleType(
                             n,
                             n,
-                            id,
-                            self.o,
-                            self.std_tuple,
+                            TypeVarId(id),
+                            self.std_tuple.copy_modified(args=[self.o]),
+                            self.std_tuple.copy_modified(args=[self.o]),
                             AnyType(TypeOfAny.from_omitted_generics),
                         )
                     )
@@ -335,7 +342,7 @@ def make_type_info(
                         TypeVarType(
                             n,
                             n,
-                            id,
+                            TypeVarId(id),
                             [],
                             self.o,
                             AnyType(TypeOfAny.from_omitted_generics),
diff --git a/mypy/test/update_data.py b/mypy/test/update_data.py
index 2d66752f61bd..84b6383b3f0c 100644
--- a/mypy/test/update_data.py
+++ b/mypy/test/update_data.py
@@ -2,7 +2,7 @@
 
 import re
 from collections import defaultdict
-from typing import Iterator
+from collections.abc import Iterator
 
 from mypy.test.data import DataDrivenTestCase, DataFileCollector, DataFileFix, parse_test_data
 
@@ -69,7 +69,7 @@ def _iter_fixes(
                 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
+                # multiline comments are on the first line and then on subsequent lines empty lines
                 # with a continuation backslash
                 for j, (severity, msg) in enumerate(reports):
                     out_l = source_line if j == 0 else " " * len(source_line)
diff --git a/mypy/traverser.py b/mypy/traverser.py
index 2fcc376cfb7c..7d7794822396 100644
--- a/mypy/traverser.py
+++ b/mypy/traverser.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from mypy_extensions import mypyc_attr
+from mypy_extensions import mypyc_attr, trait
 
 from mypy.nodes import (
     REVEAL_TYPE,
@@ -58,6 +58,7 @@
     OverloadedFuncDef,
     ParamSpecExpr,
     PassStmt,
+    PromoteExpr,
     RaiseStmt,
     ReturnStmt,
     RevealExpr,
@@ -67,15 +68,18 @@
     StarExpr,
     StrExpr,
     SuperExpr,
+    TempNode,
     TryStmt,
     TupleExpr,
     TypeAlias,
     TypeAliasExpr,
+    TypeAliasStmt,
     TypeApplication,
     TypedDictExpr,
     TypeVarExpr,
     TypeVarTupleExpr,
     UnaryExpr,
+    Var,
     WhileStmt,
     WithStmt,
     YieldExpr,
@@ -94,6 +98,7 @@
 from mypy.visitor import NodeVisitor
 
 
+@trait
 @mypyc_attr(allow_interpreted_subclasses=True)
 class TraverserVisitor(NodeVisitor[None]):
     """A parse tree visitor that traverses the parse tree during visiting.
@@ -109,15 +114,15 @@ def __init__(self) -> None:
 
     # Visit methods
 
-    def visit_mypy_file(self, o: MypyFile) -> None:
+    def visit_mypy_file(self, o: MypyFile, /) -> None:
         for d in o.defs:
             d.accept(self)
 
-    def visit_block(self, block: Block) -> None:
+    def visit_block(self, block: Block, /) -> None:
         for s in block.body:
             s.accept(self)
 
-    def visit_func(self, o: FuncItem) -> None:
+    def visit_func(self, o: FuncItem, /) -> None:
         if o.arguments is not None:
             for arg in o.arguments:
                 init = arg.initializer
@@ -129,16 +134,16 @@ def visit_func(self, o: FuncItem) -> None:
 
         o.body.accept(self)
 
-    def visit_func_def(self, o: FuncDef) -> None:
+    def visit_func_def(self, o: FuncDef, /) -> None:
         self.visit_func(o)
 
-    def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
+    def visit_overloaded_func_def(self, o: OverloadedFuncDef, /) -> None:
         for item in o.items:
             item.accept(self)
         if o.impl:
             o.impl.accept(self)
 
-    def visit_class_def(self, o: ClassDef) -> None:
+    def visit_class_def(self, o: ClassDef, /) -> None:
         for d in o.decorators:
             d.accept(self)
         for base in o.base_type_exprs:
@@ -151,52 +156,52 @@ def visit_class_def(self, o: ClassDef) -> None:
         if o.analyzed:
             o.analyzed.accept(self)
 
-    def visit_decorator(self, o: Decorator) -> None:
+    def visit_decorator(self, o: Decorator, /) -> None:
         o.func.accept(self)
         o.var.accept(self)
         for decorator in o.decorators:
             decorator.accept(self)
 
-    def visit_expression_stmt(self, o: ExpressionStmt) -> None:
+    def visit_expression_stmt(self, o: ExpressionStmt, /) -> None:
         o.expr.accept(self)
 
-    def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
+    def visit_assignment_stmt(self, o: AssignmentStmt, /) -> None:
         o.rvalue.accept(self)
         for l in o.lvalues:
             l.accept(self)
 
-    def visit_operator_assignment_stmt(self, o: OperatorAssignmentStmt) -> None:
+    def visit_operator_assignment_stmt(self, o: OperatorAssignmentStmt, /) -> None:
         o.rvalue.accept(self)
         o.lvalue.accept(self)
 
-    def visit_while_stmt(self, o: WhileStmt) -> None:
+    def visit_while_stmt(self, o: WhileStmt, /) -> None:
         o.expr.accept(self)
         o.body.accept(self)
         if o.else_body:
             o.else_body.accept(self)
 
-    def visit_for_stmt(self, o: ForStmt) -> None:
+    def visit_for_stmt(self, o: ForStmt, /) -> None:
         o.index.accept(self)
         o.expr.accept(self)
         o.body.accept(self)
         if o.else_body:
             o.else_body.accept(self)
 
-    def visit_return_stmt(self, o: ReturnStmt) -> None:
+    def visit_return_stmt(self, o: ReturnStmt, /) -> None:
         if o.expr is not None:
             o.expr.accept(self)
 
-    def visit_assert_stmt(self, o: AssertStmt) -> None:
+    def visit_assert_stmt(self, o: AssertStmt, /) -> None:
         if o.expr is not None:
             o.expr.accept(self)
         if o.msg is not None:
             o.msg.accept(self)
 
-    def visit_del_stmt(self, o: DelStmt) -> None:
+    def visit_del_stmt(self, o: DelStmt, /) -> None:
         if o.expr is not None:
             o.expr.accept(self)
 
-    def visit_if_stmt(self, o: IfStmt) -> None:
+    def visit_if_stmt(self, o: IfStmt, /) -> None:
         for e in o.expr:
             e.accept(self)
         for b in o.body:
@@ -204,13 +209,13 @@ def visit_if_stmt(self, o: IfStmt) -> None:
         if o.else_body:
             o.else_body.accept(self)
 
-    def visit_raise_stmt(self, o: RaiseStmt) -> None:
+    def visit_raise_stmt(self, o: RaiseStmt, /) -> None:
         if o.expr is not None:
             o.expr.accept(self)
         if o.from_expr is not None:
             o.from_expr.accept(self)
 
-    def visit_try_stmt(self, o: TryStmt) -> None:
+    def visit_try_stmt(self, o: TryStmt, /) -> None:
         o.body.accept(self)
         for i in range(len(o.types)):
             tp = o.types[i]
@@ -225,7 +230,7 @@ def visit_try_stmt(self, o: TryStmt) -> None:
         if o.finally_body is not None:
             o.finally_body.accept(self)
 
-    def visit_with_stmt(self, o: WithStmt) -> None:
+    def visit_with_stmt(self, o: WithStmt, /) -> None:
         for i in range(len(o.expr)):
             o.expr[i].accept(self)
             targ = o.target[i]
@@ -233,7 +238,7 @@ def visit_with_stmt(self, o: WithStmt) -> None:
                 targ.accept(self)
         o.body.accept(self)
 
-    def visit_match_stmt(self, o: MatchStmt) -> None:
+    def visit_match_stmt(self, o: MatchStmt, /) -> None:
         o.subject.accept(self)
         for i in range(len(o.patterns)):
             o.patterns[i].accept(self)
@@ -242,34 +247,38 @@ def visit_match_stmt(self, o: MatchStmt) -> None:
                 guard.accept(self)
             o.bodies[i].accept(self)
 
-    def visit_member_expr(self, o: MemberExpr) -> None:
+    def visit_type_alias_stmt(self, o: TypeAliasStmt, /) -> None:
+        o.name.accept(self)
+        o.value.accept(self)
+
+    def visit_member_expr(self, o: MemberExpr, /) -> None:
         o.expr.accept(self)
 
-    def visit_yield_from_expr(self, o: YieldFromExpr) -> None:
+    def visit_yield_from_expr(self, o: YieldFromExpr, /) -> None:
         o.expr.accept(self)
 
-    def visit_yield_expr(self, o: YieldExpr) -> None:
+    def visit_yield_expr(self, o: YieldExpr, /) -> None:
         if o.expr:
             o.expr.accept(self)
 
-    def visit_call_expr(self, o: CallExpr) -> None:
+    def visit_call_expr(self, o: CallExpr, /) -> None:
         o.callee.accept(self)
         for a in o.args:
             a.accept(self)
         if o.analyzed:
             o.analyzed.accept(self)
 
-    def visit_op_expr(self, o: OpExpr) -> None:
+    def visit_op_expr(self, o: OpExpr, /) -> None:
         o.left.accept(self)
         o.right.accept(self)
         if o.analyzed is not None:
             o.analyzed.accept(self)
 
-    def visit_comparison_expr(self, o: ComparisonExpr) -> None:
+    def visit_comparison_expr(self, o: ComparisonExpr, /) -> None:
         for operand in o.operands:
             operand.accept(self)
 
-    def visit_slice_expr(self, o: SliceExpr) -> None:
+    def visit_slice_expr(self, o: SliceExpr, /) -> None:
         if o.begin_index is not None:
             o.begin_index.accept(self)
         if o.end_index is not None:
@@ -277,13 +286,13 @@ def visit_slice_expr(self, o: SliceExpr) -> None:
         if o.stride is not None:
             o.stride.accept(self)
 
-    def visit_cast_expr(self, o: CastExpr) -> None:
+    def visit_cast_expr(self, o: CastExpr, /) -> None:
         o.expr.accept(self)
 
-    def visit_assert_type_expr(self, o: AssertTypeExpr) -> None:
+    def visit_assert_type_expr(self, o: AssertTypeExpr, /) -> None:
         o.expr.accept(self)
 
-    def visit_reveal_expr(self, o: RevealExpr) -> None:
+    def visit_reveal_expr(self, o: RevealExpr, /) -> None:
         if o.kind == REVEAL_TYPE:
             assert o.expr is not None
             o.expr.accept(self)
@@ -291,38 +300,38 @@ def visit_reveal_expr(self, o: RevealExpr) -> None:
             # RevealLocalsExpr doesn't have an inner expression
             pass
 
-    def visit_assignment_expr(self, o: AssignmentExpr) -> None:
+    def visit_assignment_expr(self, o: AssignmentExpr, /) -> None:
         o.target.accept(self)
         o.value.accept(self)
 
-    def visit_unary_expr(self, o: UnaryExpr) -> None:
+    def visit_unary_expr(self, o: UnaryExpr, /) -> None:
         o.expr.accept(self)
 
-    def visit_list_expr(self, o: ListExpr) -> None:
+    def visit_list_expr(self, o: ListExpr, /) -> None:
         for item in o.items:
             item.accept(self)
 
-    def visit_tuple_expr(self, o: TupleExpr) -> None:
+    def visit_tuple_expr(self, o: TupleExpr, /) -> None:
         for item in o.items:
             item.accept(self)
 
-    def visit_dict_expr(self, o: DictExpr) -> None:
+    def visit_dict_expr(self, o: DictExpr, /) -> None:
         for k, v in o.items:
             if k is not None:
                 k.accept(self)
             v.accept(self)
 
-    def visit_set_expr(self, o: SetExpr) -> None:
+    def visit_set_expr(self, o: SetExpr, /) -> None:
         for item in o.items:
             item.accept(self)
 
-    def visit_index_expr(self, o: IndexExpr) -> None:
+    def visit_index_expr(self, o: IndexExpr, /) -> None:
         o.base.accept(self)
         o.index.accept(self)
         if o.analyzed:
             o.analyzed.accept(self)
 
-    def visit_generator_expr(self, o: GeneratorExpr) -> None:
+    def visit_generator_expr(self, o: GeneratorExpr, /) -> None:
         for index, sequence, conditions in zip(o.indices, o.sequences, o.condlists):
             sequence.accept(self)
             index.accept(self)
@@ -330,7 +339,7 @@ def visit_generator_expr(self, o: GeneratorExpr) -> None:
                 cond.accept(self)
         o.left_expr.accept(self)
 
-    def visit_dictionary_comprehension(self, o: DictionaryComprehension) -> None:
+    def visit_dictionary_comprehension(self, o: DictionaryComprehension, /) -> None:
         for index, sequence, conditions in zip(o.indices, o.sequences, o.condlists):
             sequence.accept(self)
             index.accept(self)
@@ -339,54 +348,54 @@ def visit_dictionary_comprehension(self, o: DictionaryComprehension) -> None:
         o.key.accept(self)
         o.value.accept(self)
 
-    def visit_list_comprehension(self, o: ListComprehension) -> None:
+    def visit_list_comprehension(self, o: ListComprehension, /) -> None:
         o.generator.accept(self)
 
-    def visit_set_comprehension(self, o: SetComprehension) -> None:
+    def visit_set_comprehension(self, o: SetComprehension, /) -> None:
         o.generator.accept(self)
 
-    def visit_conditional_expr(self, o: ConditionalExpr) -> None:
+    def visit_conditional_expr(self, o: ConditionalExpr, /) -> None:
         o.cond.accept(self)
         o.if_expr.accept(self)
         o.else_expr.accept(self)
 
-    def visit_type_application(self, o: TypeApplication) -> None:
+    def visit_type_application(self, o: TypeApplication, /) -> None:
         o.expr.accept(self)
 
-    def visit_lambda_expr(self, o: LambdaExpr) -> None:
+    def visit_lambda_expr(self, o: LambdaExpr, /) -> None:
         self.visit_func(o)
 
-    def visit_star_expr(self, o: StarExpr) -> None:
+    def visit_star_expr(self, o: StarExpr, /) -> None:
         o.expr.accept(self)
 
-    def visit_await_expr(self, o: AwaitExpr) -> None:
+    def visit_await_expr(self, o: AwaitExpr, /) -> None:
         o.expr.accept(self)
 
-    def visit_super_expr(self, o: SuperExpr) -> None:
+    def visit_super_expr(self, o: SuperExpr, /) -> None:
         o.call.accept(self)
 
-    def visit_as_pattern(self, o: AsPattern) -> None:
+    def visit_as_pattern(self, o: AsPattern, /) -> None:
         if o.pattern is not None:
             o.pattern.accept(self)
         if o.name is not None:
             o.name.accept(self)
 
-    def visit_or_pattern(self, o: OrPattern) -> None:
+    def visit_or_pattern(self, o: OrPattern, /) -> None:
         for p in o.patterns:
             p.accept(self)
 
-    def visit_value_pattern(self, o: ValuePattern) -> None:
+    def visit_value_pattern(self, o: ValuePattern, /) -> None:
         o.expr.accept(self)
 
-    def visit_sequence_pattern(self, o: SequencePattern) -> None:
+    def visit_sequence_pattern(self, o: SequencePattern, /) -> None:
         for p in o.patterns:
             p.accept(self)
 
-    def visit_starred_pattern(self, o: StarredPattern) -> None:
+    def visit_starred_pattern(self, o: StarredPattern, /) -> None:
         if o.capture is not None:
             o.capture.accept(self)
 
-    def visit_mapping_pattern(self, o: MappingPattern) -> None:
+    def visit_mapping_pattern(self, o: MappingPattern, /) -> None:
         for key in o.keys:
             key.accept(self)
         for value in o.values:
@@ -394,21 +403,100 @@ def visit_mapping_pattern(self, o: MappingPattern) -> None:
         if o.rest is not None:
             o.rest.accept(self)
 
-    def visit_class_pattern(self, o: ClassPattern) -> None:
+    def visit_class_pattern(self, o: ClassPattern, /) -> None:
         o.class_ref.accept(self)
         for p in o.positionals:
             p.accept(self)
         for v in o.keyword_values:
             v.accept(self)
 
-    def visit_import(self, o: Import) -> None:
+    def visit_import(self, o: Import, /) -> None:
         for a in o.assignments:
             a.accept(self)
 
-    def visit_import_from(self, o: ImportFrom) -> None:
+    def visit_import_from(self, o: ImportFrom, /) -> None:
         for a in o.assignments:
             a.accept(self)
 
+    # leaf nodes
+    def visit_name_expr(self, o: NameExpr, /) -> None:
+        return None
+
+    def visit_str_expr(self, o: StrExpr, /) -> None:
+        return None
+
+    def visit_int_expr(self, o: IntExpr, /) -> None:
+        return None
+
+    def visit_float_expr(self, o: FloatExpr, /) -> None:
+        return None
+
+    def visit_bytes_expr(self, o: BytesExpr, /) -> None:
+        return None
+
+    def visit_ellipsis(self, o: EllipsisExpr, /) -> None:
+        return None
+
+    def visit_var(self, o: Var, /) -> None:
+        return None
+
+    def visit_continue_stmt(self, o: ContinueStmt, /) -> None:
+        return None
+
+    def visit_pass_stmt(self, o: PassStmt, /) -> None:
+        return None
+
+    def visit_break_stmt(self, o: BreakStmt, /) -> None:
+        return None
+
+    def visit_temp_node(self, o: TempNode, /) -> None:
+        return None
+
+    def visit_nonlocal_decl(self, o: NonlocalDecl, /) -> None:
+        return None
+
+    def visit_global_decl(self, o: GlobalDecl, /) -> None:
+        return None
+
+    def visit_import_all(self, o: ImportAll, /) -> None:
+        return None
+
+    def visit_type_var_expr(self, o: TypeVarExpr, /) -> None:
+        return None
+
+    def visit_paramspec_expr(self, o: ParamSpecExpr, /) -> None:
+        return None
+
+    def visit_type_var_tuple_expr(self, o: TypeVarTupleExpr, /) -> None:
+        return None
+
+    def visit_type_alias_expr(self, o: TypeAliasExpr, /) -> None:
+        return None
+
+    def visit_type_alias(self, o: TypeAlias, /) -> None:
+        return None
+
+    def visit_namedtuple_expr(self, o: NamedTupleExpr, /) -> None:
+        return None
+
+    def visit_typeddict_expr(self, o: TypedDictExpr, /) -> None:
+        return None
+
+    def visit_newtype_expr(self, o: NewTypeExpr, /) -> None:
+        return None
+
+    def visit__promote_expr(self, o: PromoteExpr, /) -> None:
+        return None
+
+    def visit_complex_expr(self, o: ComplexExpr, /) -> None:
+        return None
+
+    def visit_enum_call_expr(self, o: EnumCallExpr, /) -> None:
+        return None
+
+    def visit_singleton_pattern(self, o: SingletonPattern, /) -> None:
+        return None
+
 
 class ExtendedTraverserVisitor(TraverserVisitor):
     """This is a more flexible traverser.
@@ -426,402 +514,402 @@ def visit(self, o: Node) -> bool:
         # If returns True, will continue to nested nodes.
         return True
 
-    def visit_mypy_file(self, o: MypyFile) -> None:
+    def visit_mypy_file(self, o: MypyFile, /) -> None:
         if not self.visit(o):
             return
         super().visit_mypy_file(o)
 
     # Module structure
 
-    def visit_import(self, o: Import) -> None:
+    def visit_import(self, o: Import, /) -> None:
         if not self.visit(o):
             return
         super().visit_import(o)
 
-    def visit_import_from(self, o: ImportFrom) -> None:
+    def visit_import_from(self, o: ImportFrom, /) -> None:
         if not self.visit(o):
             return
         super().visit_import_from(o)
 
-    def visit_import_all(self, o: ImportAll) -> None:
+    def visit_import_all(self, o: ImportAll, /) -> None:
         if not self.visit(o):
             return
         super().visit_import_all(o)
 
     # Definitions
 
-    def visit_func_def(self, o: FuncDef) -> None:
+    def visit_func_def(self, o: FuncDef, /) -> None:
         if not self.visit(o):
             return
         super().visit_func_def(o)
 
-    def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
+    def visit_overloaded_func_def(self, o: OverloadedFuncDef, /) -> None:
         if not self.visit(o):
             return
         super().visit_overloaded_func_def(o)
 
-    def visit_class_def(self, o: ClassDef) -> None:
+    def visit_class_def(self, o: ClassDef, /) -> None:
         if not self.visit(o):
             return
         super().visit_class_def(o)
 
-    def visit_global_decl(self, o: GlobalDecl) -> None:
+    def visit_global_decl(self, o: GlobalDecl, /) -> None:
         if not self.visit(o):
             return
         super().visit_global_decl(o)
 
-    def visit_nonlocal_decl(self, o: NonlocalDecl) -> None:
+    def visit_nonlocal_decl(self, o: NonlocalDecl, /) -> None:
         if not self.visit(o):
             return
         super().visit_nonlocal_decl(o)
 
-    def visit_decorator(self, o: Decorator) -> None:
+    def visit_decorator(self, o: Decorator, /) -> None:
         if not self.visit(o):
             return
         super().visit_decorator(o)
 
-    def visit_type_alias(self, o: TypeAlias) -> None:
+    def visit_type_alias(self, o: TypeAlias, /) -> None:
         if not self.visit(o):
             return
         super().visit_type_alias(o)
 
     # Statements
 
-    def visit_block(self, block: Block) -> None:
+    def visit_block(self, block: Block, /) -> None:
         if not self.visit(block):
             return
         super().visit_block(block)
 
-    def visit_expression_stmt(self, o: ExpressionStmt) -> None:
+    def visit_expression_stmt(self, o: ExpressionStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_expression_stmt(o)
 
-    def visit_assignment_stmt(self, o: AssignmentStmt) -> None:
+    def visit_assignment_stmt(self, o: AssignmentStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_assignment_stmt(o)
 
-    def visit_operator_assignment_stmt(self, o: OperatorAssignmentStmt) -> None:
+    def visit_operator_assignment_stmt(self, o: OperatorAssignmentStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_operator_assignment_stmt(o)
 
-    def visit_while_stmt(self, o: WhileStmt) -> None:
+    def visit_while_stmt(self, o: WhileStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_while_stmt(o)
 
-    def visit_for_stmt(self, o: ForStmt) -> None:
+    def visit_for_stmt(self, o: ForStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_for_stmt(o)
 
-    def visit_return_stmt(self, o: ReturnStmt) -> None:
+    def visit_return_stmt(self, o: ReturnStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_return_stmt(o)
 
-    def visit_assert_stmt(self, o: AssertStmt) -> None:
+    def visit_assert_stmt(self, o: AssertStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_assert_stmt(o)
 
-    def visit_del_stmt(self, o: DelStmt) -> None:
+    def visit_del_stmt(self, o: DelStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_del_stmt(o)
 
-    def visit_if_stmt(self, o: IfStmt) -> None:
+    def visit_if_stmt(self, o: IfStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_if_stmt(o)
 
-    def visit_break_stmt(self, o: BreakStmt) -> None:
+    def visit_break_stmt(self, o: BreakStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_break_stmt(o)
 
-    def visit_continue_stmt(self, o: ContinueStmt) -> None:
+    def visit_continue_stmt(self, o: ContinueStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_continue_stmt(o)
 
-    def visit_pass_stmt(self, o: PassStmt) -> None:
+    def visit_pass_stmt(self, o: PassStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_pass_stmt(o)
 
-    def visit_raise_stmt(self, o: RaiseStmt) -> None:
+    def visit_raise_stmt(self, o: RaiseStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_raise_stmt(o)
 
-    def visit_try_stmt(self, o: TryStmt) -> None:
+    def visit_try_stmt(self, o: TryStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_try_stmt(o)
 
-    def visit_with_stmt(self, o: WithStmt) -> None:
+    def visit_with_stmt(self, o: WithStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_with_stmt(o)
 
-    def visit_match_stmt(self, o: MatchStmt) -> None:
+    def visit_match_stmt(self, o: MatchStmt, /) -> None:
         if not self.visit(o):
             return
         super().visit_match_stmt(o)
 
     # Expressions (default no-op implementation)
 
-    def visit_int_expr(self, o: IntExpr) -> None:
+    def visit_int_expr(self, o: IntExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_int_expr(o)
 
-    def visit_str_expr(self, o: StrExpr) -> None:
+    def visit_str_expr(self, o: StrExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_str_expr(o)
 
-    def visit_bytes_expr(self, o: BytesExpr) -> None:
+    def visit_bytes_expr(self, o: BytesExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_bytes_expr(o)
 
-    def visit_float_expr(self, o: FloatExpr) -> None:
+    def visit_float_expr(self, o: FloatExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_float_expr(o)
 
-    def visit_complex_expr(self, o: ComplexExpr) -> None:
+    def visit_complex_expr(self, o: ComplexExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_complex_expr(o)
 
-    def visit_ellipsis(self, o: EllipsisExpr) -> None:
+    def visit_ellipsis(self, o: EllipsisExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_ellipsis(o)
 
-    def visit_star_expr(self, o: StarExpr) -> None:
+    def visit_star_expr(self, o: StarExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_star_expr(o)
 
-    def visit_name_expr(self, o: NameExpr) -> None:
+    def visit_name_expr(self, o: NameExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_name_expr(o)
 
-    def visit_member_expr(self, o: MemberExpr) -> None:
+    def visit_member_expr(self, o: MemberExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_member_expr(o)
 
-    def visit_yield_from_expr(self, o: YieldFromExpr) -> None:
+    def visit_yield_from_expr(self, o: YieldFromExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_yield_from_expr(o)
 
-    def visit_yield_expr(self, o: YieldExpr) -> None:
+    def visit_yield_expr(self, o: YieldExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_yield_expr(o)
 
-    def visit_call_expr(self, o: CallExpr) -> None:
+    def visit_call_expr(self, o: CallExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_call_expr(o)
 
-    def visit_op_expr(self, o: OpExpr) -> None:
+    def visit_op_expr(self, o: OpExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_op_expr(o)
 
-    def visit_comparison_expr(self, o: ComparisonExpr) -> None:
+    def visit_comparison_expr(self, o: ComparisonExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_comparison_expr(o)
 
-    def visit_cast_expr(self, o: CastExpr) -> None:
+    def visit_cast_expr(self, o: CastExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_cast_expr(o)
 
-    def visit_assert_type_expr(self, o: AssertTypeExpr) -> None:
+    def visit_assert_type_expr(self, o: AssertTypeExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_assert_type_expr(o)
 
-    def visit_reveal_expr(self, o: RevealExpr) -> None:
+    def visit_reveal_expr(self, o: RevealExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_reveal_expr(o)
 
-    def visit_super_expr(self, o: SuperExpr) -> None:
+    def visit_super_expr(self, o: SuperExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_super_expr(o)
 
-    def visit_assignment_expr(self, o: AssignmentExpr) -> None:
+    def visit_assignment_expr(self, o: AssignmentExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_assignment_expr(o)
 
-    def visit_unary_expr(self, o: UnaryExpr) -> None:
+    def visit_unary_expr(self, o: UnaryExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_unary_expr(o)
 
-    def visit_list_expr(self, o: ListExpr) -> None:
+    def visit_list_expr(self, o: ListExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_list_expr(o)
 
-    def visit_dict_expr(self, o: DictExpr) -> None:
+    def visit_dict_expr(self, o: DictExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_dict_expr(o)
 
-    def visit_tuple_expr(self, o: TupleExpr) -> None:
+    def visit_tuple_expr(self, o: TupleExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_tuple_expr(o)
 
-    def visit_set_expr(self, o: SetExpr) -> None:
+    def visit_set_expr(self, o: SetExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_set_expr(o)
 
-    def visit_index_expr(self, o: IndexExpr) -> None:
+    def visit_index_expr(self, o: IndexExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_index_expr(o)
 
-    def visit_type_application(self, o: TypeApplication) -> None:
+    def visit_type_application(self, o: TypeApplication, /) -> None:
         if not self.visit(o):
             return
         super().visit_type_application(o)
 
-    def visit_lambda_expr(self, o: LambdaExpr) -> None:
+    def visit_lambda_expr(self, o: LambdaExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_lambda_expr(o)
 
-    def visit_list_comprehension(self, o: ListComprehension) -> None:
+    def visit_list_comprehension(self, o: ListComprehension, /) -> None:
         if not self.visit(o):
             return
         super().visit_list_comprehension(o)
 
-    def visit_set_comprehension(self, o: SetComprehension) -> None:
+    def visit_set_comprehension(self, o: SetComprehension, /) -> None:
         if not self.visit(o):
             return
         super().visit_set_comprehension(o)
 
-    def visit_dictionary_comprehension(self, o: DictionaryComprehension) -> None:
+    def visit_dictionary_comprehension(self, o: DictionaryComprehension, /) -> None:
         if not self.visit(o):
             return
         super().visit_dictionary_comprehension(o)
 
-    def visit_generator_expr(self, o: GeneratorExpr) -> None:
+    def visit_generator_expr(self, o: GeneratorExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_generator_expr(o)
 
-    def visit_slice_expr(self, o: SliceExpr) -> None:
+    def visit_slice_expr(self, o: SliceExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_slice_expr(o)
 
-    def visit_conditional_expr(self, o: ConditionalExpr) -> None:
+    def visit_conditional_expr(self, o: ConditionalExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_conditional_expr(o)
 
-    def visit_type_var_expr(self, o: TypeVarExpr) -> None:
+    def visit_type_var_expr(self, o: TypeVarExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_type_var_expr(o)
 
-    def visit_paramspec_expr(self, o: ParamSpecExpr) -> None:
+    def visit_paramspec_expr(self, o: ParamSpecExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_paramspec_expr(o)
 
-    def visit_type_var_tuple_expr(self, o: TypeVarTupleExpr) -> None:
+    def visit_type_var_tuple_expr(self, o: TypeVarTupleExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_type_var_tuple_expr(o)
 
-    def visit_type_alias_expr(self, o: TypeAliasExpr) -> None:
+    def visit_type_alias_expr(self, o: TypeAliasExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_type_alias_expr(o)
 
-    def visit_namedtuple_expr(self, o: NamedTupleExpr) -> None:
+    def visit_namedtuple_expr(self, o: NamedTupleExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_namedtuple_expr(o)
 
-    def visit_enum_call_expr(self, o: EnumCallExpr) -> None:
+    def visit_enum_call_expr(self, o: EnumCallExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_enum_call_expr(o)
 
-    def visit_typeddict_expr(self, o: TypedDictExpr) -> None:
+    def visit_typeddict_expr(self, o: TypedDictExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_typeddict_expr(o)
 
-    def visit_newtype_expr(self, o: NewTypeExpr) -> None:
+    def visit_newtype_expr(self, o: NewTypeExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_newtype_expr(o)
 
-    def visit_await_expr(self, o: AwaitExpr) -> None:
+    def visit_await_expr(self, o: AwaitExpr, /) -> None:
         if not self.visit(o):
             return
         super().visit_await_expr(o)
 
     # Patterns
 
-    def visit_as_pattern(self, o: AsPattern) -> None:
+    def visit_as_pattern(self, o: AsPattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_as_pattern(o)
 
-    def visit_or_pattern(self, o: OrPattern) -> None:
+    def visit_or_pattern(self, o: OrPattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_or_pattern(o)
 
-    def visit_value_pattern(self, o: ValuePattern) -> None:
+    def visit_value_pattern(self, o: ValuePattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_value_pattern(o)
 
-    def visit_singleton_pattern(self, o: SingletonPattern) -> None:
+    def visit_singleton_pattern(self, o: SingletonPattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_singleton_pattern(o)
 
-    def visit_sequence_pattern(self, o: SequencePattern) -> None:
+    def visit_sequence_pattern(self, o: SequencePattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_sequence_pattern(o)
 
-    def visit_starred_pattern(self, o: StarredPattern) -> None:
+    def visit_starred_pattern(self, o: StarredPattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_starred_pattern(o)
 
-    def visit_mapping_pattern(self, o: MappingPattern) -> None:
+    def visit_mapping_pattern(self, o: MappingPattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_mapping_pattern(o)
 
-    def visit_class_pattern(self, o: ClassPattern) -> None:
+    def visit_class_pattern(self, o: ClassPattern, /) -> None:
         if not self.visit(o):
             return
         super().visit_class_pattern(o)
@@ -952,9 +1040,3 @@ def visit_assignment_stmt(self, stmt: AssignmentStmt) -> None:
 
     def visit_yield_from_expr(self, expr: YieldFromExpr) -> None:
         self.yield_from_expressions.append((expr, self.in_assignment))
-
-
-def all_yield_from_expressions(node: Node) -> list[tuple[YieldFromExpr, bool]]:
-    v = YieldFromCollector()
-    node.accept(v)
-    return v.yield_from_expressions
diff --git a/mypy/treetransform.py b/mypy/treetransform.py
index bb34d8de2884..0abf98a52336 100644
--- a/mypy/treetransform.py
+++ b/mypy/treetransform.py
@@ -5,7 +5,8 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Optional, cast
+from collections.abc import Iterable
+from typing import Optional, cast
 
 from mypy.nodes import (
     GDEF,
@@ -276,7 +277,7 @@ def visit_nonlocal_decl(self, node: NonlocalDecl) -> NonlocalDecl:
         return NonlocalDecl(node.names.copy())
 
     def visit_block(self, node: Block) -> Block:
-        return Block(self.statements(node.body))
+        return Block(self.statements(node.body), is_unreachable=node.is_unreachable)
 
     def visit_decorator(self, node: Decorator) -> Decorator:
         # Note that a Decorator must be transformed to a Decorator.
@@ -558,7 +559,7 @@ def visit_super_expr(self, node: SuperExpr) -> SuperExpr:
         return new
 
     def visit_assignment_expr(self, node: AssignmentExpr) -> AssignmentExpr:
-        return AssignmentExpr(self.expr(node.target), self.expr(node.value))
+        return AssignmentExpr(self.duplicate_name(node.target), self.expr(node.value))
 
     def visit_unary_expr(self, node: UnaryExpr) -> UnaryExpr:
         new = UnaryExpr(node.op, self.expr(node.expr))
diff --git a/mypy/tvar_scope.py b/mypy/tvar_scope.py
index c7a653a1552d..fe97a8359287 100644
--- a/mypy/tvar_scope.py
+++ b/mypy/tvar_scope.py
@@ -15,6 +15,26 @@
     TypeVarTupleType,
     TypeVarType,
 )
+from mypy.typetraverser import TypeTraverserVisitor
+
+
+class TypeVarLikeNamespaceSetter(TypeTraverserVisitor):
+    """Set namespace for all TypeVarLikeTypes types."""
+
+    def __init__(self, namespace: str) -> None:
+        self.namespace = namespace
+
+    def visit_type_var(self, t: TypeVarType) -> None:
+        t.id.namespace = self.namespace
+        super().visit_type_var(t)
+
+    def visit_param_spec(self, t: ParamSpecType) -> None:
+        t.id.namespace = self.namespace
+        return super().visit_param_spec(t)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
+        t.id.namespace = self.namespace
+        super().visit_type_var_tuple(t)
 
 
 class TypeVarLikeScope:
@@ -65,29 +85,29 @@ def allow_binding(self, fullname: str) -> bool:
             return False
         return True
 
-    def method_frame(self) -> TypeVarLikeScope:
+    def method_frame(self, namespace: str) -> TypeVarLikeScope:
         """A new scope frame for binding a method"""
-        return TypeVarLikeScope(self, False, None)
+        return TypeVarLikeScope(self, False, None, namespace=namespace)
 
     def class_frame(self, namespace: str) -> TypeVarLikeScope:
         """A new scope frame for binding a class. Prohibits *this* class's tvars"""
         return TypeVarLikeScope(self.get_function_scope(), True, self, namespace=namespace)
 
-    def new_unique_func_id(self) -> int:
+    def new_unique_func_id(self) -> TypeVarId:
         """Used by plugin-like code that needs to make synthetic generic functions."""
         self.func_id -= 1
-        return self.func_id
+        return TypeVarId(self.func_id)
 
     def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
         if self.is_class_scope:
             self.class_id += 1
             i = self.class_id
-            namespace = self.namespace
         else:
             self.func_id -= 1
             i = self.func_id
-            # TODO: Consider also using namespaces for functions
-            namespace = ""
+        namespace = self.namespace
+        tvar_expr.default.accept(TypeVarLikeNamespaceSetter(namespace))
+
         if isinstance(tvar_expr, TypeVarExpr):
             tvar_def: TypeVarLikeType = TypeVarType(
                 name=name,
@@ -102,9 +122,9 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
             )
         elif isinstance(tvar_expr, ParamSpecExpr):
             tvar_def = ParamSpecType(
-                name,
-                tvar_expr.fullname,
-                i,
+                name=name,
+                fullname=tvar_expr.fullname,
+                id=TypeVarId(i, namespace=namespace),
                 flavor=ParamSpecFlavor.BARE,
                 upper_bound=tvar_expr.upper_bound,
                 default=tvar_expr.default,
@@ -113,9 +133,9 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
             )
         elif isinstance(tvar_expr, TypeVarTupleExpr):
             tvar_def = TypeVarTupleType(
-                name,
-                tvar_expr.fullname,
-                i,
+                name=name,
+                fullname=tvar_expr.fullname,
+                id=TypeVarId(i, namespace=namespace),
                 upper_bound=tvar_expr.upper_bound,
                 tuple_fallback=tvar_expr.tuple_fallback,
                 default=tvar_expr.default,
diff --git a/mypy/type_visitor.py b/mypy/type_visitor.py
index 2efae49e9e10..ab1ec8b46fdd 100644
--- a/mypy/type_visitor.py
+++ b/mypy/type_visitor.py
@@ -14,8 +14,8 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import Any, Callable, Generic, Iterable, Sequence, TypeVar, cast
-from typing_extensions import Final
+from collections.abc import Iterable, Sequence
+from typing import Any, Callable, Final, Generic, TypeVar, cast
 
 from mypy_extensions import mypyc_attr, trait
 
@@ -63,87 +63,87 @@ class TypeVisitor(Generic[T]):
     """
 
     @abstractmethod
-    def visit_unbound_type(self, t: UnboundType) -> T:
+    def visit_unbound_type(self, t: UnboundType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_any(self, t: AnyType) -> T:
+    def visit_any(self, t: AnyType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_none_type(self, t: NoneType) -> T:
+    def visit_none_type(self, t: NoneType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_uninhabited_type(self, t: UninhabitedType) -> T:
+    def visit_uninhabited_type(self, t: UninhabitedType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_erased_type(self, t: ErasedType) -> T:
+    def visit_erased_type(self, t: ErasedType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_deleted_type(self, t: DeletedType) -> T:
+    def visit_deleted_type(self, t: DeletedType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_var(self, t: TypeVarType) -> T:
+    def visit_type_var(self, t: TypeVarType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_param_spec(self, t: ParamSpecType) -> T:
+    def visit_param_spec(self, t: ParamSpecType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_parameters(self, t: Parameters) -> T:
+    def visit_parameters(self, t: Parameters, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> T:
+    def visit_type_var_tuple(self, t: TypeVarTupleType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_instance(self, t: Instance) -> T:
+    def visit_instance(self, t: Instance, /) -> T:
         pass
 
     @abstractmethod
-    def visit_callable_type(self, t: CallableType) -> T:
+    def visit_callable_type(self, t: CallableType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_overloaded(self, t: Overloaded) -> T:
+    def visit_overloaded(self, t: Overloaded, /) -> T:
         pass
 
     @abstractmethod
-    def visit_tuple_type(self, t: TupleType) -> T:
+    def visit_tuple_type(self, t: TupleType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_typeddict_type(self, t: TypedDictType) -> T:
+    def visit_typeddict_type(self, t: TypedDictType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_literal_type(self, t: LiteralType) -> T:
+    def visit_literal_type(self, t: LiteralType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_union_type(self, t: UnionType) -> T:
+    def visit_union_type(self, t: UnionType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_partial_type(self, t: PartialType) -> T:
+    def visit_partial_type(self, t: PartialType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_type(self, t: TypeType) -> T:
+    def visit_type_type(self, t: TypeType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_alias_type(self, t: TypeAliasType) -> T:
+    def visit_type_alias_type(self, t: TypeAliasType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_unpack_type(self, t: UnpackType) -> T:
+    def visit_unpack_type(self, t: UnpackType, /) -> T:
         pass
 
 
@@ -156,23 +156,23 @@ class SyntheticTypeVisitor(TypeVisitor[T]):
     """
 
     @abstractmethod
-    def visit_type_list(self, t: TypeList) -> T:
+    def visit_type_list(self, t: TypeList, /) -> T:
         pass
 
     @abstractmethod
-    def visit_callable_argument(self, t: CallableArgument) -> T:
+    def visit_callable_argument(self, t: CallableArgument, /) -> T:
         pass
 
     @abstractmethod
-    def visit_ellipsis_type(self, t: EllipsisType) -> T:
+    def visit_ellipsis_type(self, t: EllipsisType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_raw_expression_type(self, t: RawExpressionType) -> T:
+    def visit_raw_expression_type(self, t: RawExpressionType, /) -> T:
         pass
 
     @abstractmethod
-    def visit_placeholder_type(self, t: PlaceholderType) -> T:
+    def visit_placeholder_type(self, t: PlaceholderType, /) -> T:
         pass
 
 
@@ -182,27 +182,45 @@ class TypeTranslator(TypeVisitor[Type]):
 
     Subclass this and override some methods to implement a non-trivial
     transformation.
+
+    We cache the results of certain translations to avoid
+    massively expanding the sizes of types.
     """
 
-    def visit_unbound_type(self, t: UnboundType) -> Type:
+    def __init__(self, cache: dict[Type, Type] | None = None) -> None:
+        # For deduplication of results
+        self.cache = cache
+
+    def get_cached(self, t: Type) -> Type | None:
+        if self.cache is None:
+            return None
+        return self.cache.get(t)
+
+    def set_cached(self, orig: Type, new: Type) -> None:
+        if self.cache is None:
+            # Minor optimization: construct lazily
+            self.cache = {}
+        self.cache[orig] = new
+
+    def visit_unbound_type(self, t: UnboundType, /) -> Type:
         return t
 
-    def visit_any(self, t: AnyType) -> Type:
+    def visit_any(self, t: AnyType, /) -> Type:
         return t
 
-    def visit_none_type(self, t: NoneType) -> Type:
+    def visit_none_type(self, t: NoneType, /) -> Type:
         return t
 
-    def visit_uninhabited_type(self, t: UninhabitedType) -> Type:
+    def visit_uninhabited_type(self, t: UninhabitedType, /) -> Type:
         return t
 
-    def visit_erased_type(self, t: ErasedType) -> Type:
+    def visit_erased_type(self, t: ErasedType, /) -> Type:
         return t
 
-    def visit_deleted_type(self, t: DeletedType) -> Type:
+    def visit_deleted_type(self, t: DeletedType, /) -> Type:
         return t
 
-    def visit_instance(self, t: Instance) -> Type:
+    def visit_instance(self, t: Instance, /) -> Type:
         last_known_value: LiteralType | None = None
         if t.last_known_value is not None:
             raw_last_known_value = t.last_known_value.accept(self)
@@ -214,34 +232,35 @@ def visit_instance(self, t: Instance) -> Type:
             line=t.line,
             column=t.column,
             last_known_value=last_known_value,
+            extra_attrs=t.extra_attrs,
         )
 
-    def visit_type_var(self, t: TypeVarType) -> Type:
+    def visit_type_var(self, t: TypeVarType, /) -> Type:
         return t
 
-    def visit_param_spec(self, t: ParamSpecType) -> Type:
+    def visit_param_spec(self, t: ParamSpecType, /) -> Type:
         return t
 
-    def visit_parameters(self, t: Parameters) -> Type:
+    def visit_parameters(self, t: Parameters, /) -> Type:
         return t.copy_modified(arg_types=self.translate_types(t.arg_types))
 
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+    def visit_type_var_tuple(self, t: TypeVarTupleType, /) -> Type:
         return t
 
-    def visit_partial_type(self, t: PartialType) -> Type:
+    def visit_partial_type(self, t: PartialType, /) -> Type:
         return t
 
-    def visit_unpack_type(self, t: UnpackType) -> Type:
+    def visit_unpack_type(self, t: UnpackType, /) -> Type:
         return UnpackType(t.type.accept(self))
 
-    def visit_callable_type(self, t: CallableType) -> Type:
+    def visit_callable_type(self, t: CallableType, /) -> Type:
         return t.copy_modified(
             arg_types=self.translate_types(t.arg_types),
             ret_type=t.ret_type.accept(self),
             variables=self.translate_variables(t.variables),
         )
 
-    def visit_tuple_type(self, t: TupleType) -> Type:
+    def visit_tuple_type(self, t: TupleType, /) -> Type:
         return TupleType(
             self.translate_types(t.items),
             # TODO: This appears to be unsafe.
@@ -250,24 +269,44 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             t.column,
         )
 
-    def visit_typeddict_type(self, t: TypedDictType) -> Type:
+    def visit_typeddict_type(self, t: TypedDictType, /) -> Type:
+        # Use cache to avoid O(n**2) or worse expansion of types during translation
+        if cached := self.get_cached(t):
+            return cached
         items = {item_name: item_type.accept(self) for (item_name, item_type) in t.items.items()}
-        return TypedDictType(
+        result = TypedDictType(
             items,
             t.required_keys,
+            t.readonly_keys,
             # TODO: This appears to be unsafe.
             cast(Any, t.fallback.accept(self)),
             t.line,
             t.column,
         )
+        self.set_cached(t, result)
+        return result
 
-    def visit_literal_type(self, t: LiteralType) -> Type:
+    def visit_literal_type(self, t: LiteralType, /) -> Type:
         fallback = t.fallback.accept(self)
         assert isinstance(fallback, Instance)  # type: ignore[misc]
         return LiteralType(value=t.value, fallback=fallback, line=t.line, column=t.column)
 
-    def visit_union_type(self, t: UnionType) -> Type:
-        return UnionType(self.translate_types(t.items), t.line, t.column)
+    def visit_union_type(self, t: UnionType, /) -> Type:
+        # Use cache to avoid O(n**2) or worse expansion of types during translation
+        # (only for large unions, since caching adds overhead)
+        use_cache = len(t.items) > 3
+        if use_cache and (cached := self.get_cached(t)):
+            return cached
+
+        result = UnionType(
+            self.translate_types(t.items),
+            t.line,
+            t.column,
+            uses_pep604_syntax=t.uses_pep604_syntax,
+        )
+        if use_cache:
+            self.set_cached(t, result)
+        return result
 
     def translate_types(self, types: Iterable[Type]) -> list[Type]:
         return [t.accept(self) for t in types]
@@ -277,7 +316,7 @@ def translate_variables(
     ) -> Sequence[TypeVarLikeType]:
         return variables
 
-    def visit_overloaded(self, t: Overloaded) -> Type:
+    def visit_overloaded(self, t: Overloaded, /) -> Type:
         items: list[CallableType] = []
         for item in t.items:
             new = item.accept(self)
@@ -285,11 +324,11 @@ def visit_overloaded(self, t: Overloaded) -> Type:
             items.append(new)
         return Overloaded(items=items)
 
-    def visit_type_type(self, t: TypeType) -> Type:
+    def visit_type_type(self, t: TypeType, /) -> Type:
         return TypeType.make_normalized(t.item.accept(self), line=t.line, column=t.column)
 
     @abstractmethod
-    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+    def visit_type_alias_type(self, t: TypeAliasType, /) -> Type:
         # This method doesn't have a default implementation for type translators,
         # because type aliases are special: some information is contained in the
         # TypeAlias node, and we normally don't generate new nodes. Every subclass
@@ -305,7 +344,7 @@ class TypeQuery(SyntheticTypeVisitor[T]):
     common use cases involve a boolean query using `any` or `all`.
 
     Note: this visitor keeps an internal state (tracks type aliases to avoid
-    recursion), so it should *never* be re-used for querying different types,
+    recursion), so it should *never* be reused for querying different types,
     create a new visitor instance instead.
 
     # TODO: check that we don't have existing violations of this rule.
@@ -321,83 +360,83 @@ def __init__(self, strategy: Callable[[list[T]], T]) -> None:
         # to skip targets in some cases (e.g. when collecting type variables).
         self.skip_alias_target = False
 
-    def visit_unbound_type(self, t: UnboundType) -> T:
+    def visit_unbound_type(self, t: UnboundType, /) -> T:
         return self.query_types(t.args)
 
-    def visit_type_list(self, t: TypeList) -> T:
+    def visit_type_list(self, t: TypeList, /) -> T:
         return self.query_types(t.items)
 
-    def visit_callable_argument(self, t: CallableArgument) -> T:
+    def visit_callable_argument(self, t: CallableArgument, /) -> T:
         return t.typ.accept(self)
 
-    def visit_any(self, t: AnyType) -> T:
+    def visit_any(self, t: AnyType, /) -> T:
         return self.strategy([])
 
-    def visit_uninhabited_type(self, t: UninhabitedType) -> T:
+    def visit_uninhabited_type(self, t: UninhabitedType, /) -> T:
         return self.strategy([])
 
-    def visit_none_type(self, t: NoneType) -> T:
+    def visit_none_type(self, t: NoneType, /) -> T:
         return self.strategy([])
 
-    def visit_erased_type(self, t: ErasedType) -> T:
+    def visit_erased_type(self, t: ErasedType, /) -> T:
         return self.strategy([])
 
-    def visit_deleted_type(self, t: DeletedType) -> T:
+    def visit_deleted_type(self, t: DeletedType, /) -> T:
         return self.strategy([])
 
-    def visit_type_var(self, t: TypeVarType) -> T:
+    def visit_type_var(self, t: TypeVarType, /) -> T:
         return self.query_types([t.upper_bound, t.default] + t.values)
 
-    def visit_param_spec(self, t: ParamSpecType) -> T:
-        return self.query_types([t.upper_bound, t.default])
+    def visit_param_spec(self, t: ParamSpecType, /) -> T:
+        return self.query_types([t.upper_bound, t.default, t.prefix])
 
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> T:
+    def visit_type_var_tuple(self, t: TypeVarTupleType, /) -> T:
         return self.query_types([t.upper_bound, t.default])
 
-    def visit_unpack_type(self, t: UnpackType) -> T:
+    def visit_unpack_type(self, t: UnpackType, /) -> T:
         return self.query_types([t.type])
 
-    def visit_parameters(self, t: Parameters) -> T:
+    def visit_parameters(self, t: Parameters, /) -> T:
         return self.query_types(t.arg_types)
 
-    def visit_partial_type(self, t: PartialType) -> T:
+    def visit_partial_type(self, t: PartialType, /) -> T:
         return self.strategy([])
 
-    def visit_instance(self, t: Instance) -> T:
+    def visit_instance(self, t: Instance, /) -> T:
         return self.query_types(t.args)
 
-    def visit_callable_type(self, t: CallableType) -> T:
+    def visit_callable_type(self, t: CallableType, /) -> T:
         # FIX generics
         return self.query_types(t.arg_types + [t.ret_type])
 
-    def visit_tuple_type(self, t: TupleType) -> T:
-        return self.query_types(t.items)
+    def visit_tuple_type(self, t: TupleType, /) -> T:
+        return self.query_types([t.partial_fallback] + t.items)
 
-    def visit_typeddict_type(self, t: TypedDictType) -> T:
+    def visit_typeddict_type(self, t: TypedDictType, /) -> T:
         return self.query_types(t.items.values())
 
-    def visit_raw_expression_type(self, t: RawExpressionType) -> T:
+    def visit_raw_expression_type(self, t: RawExpressionType, /) -> T:
         return self.strategy([])
 
-    def visit_literal_type(self, t: LiteralType) -> T:
+    def visit_literal_type(self, t: LiteralType, /) -> T:
         return self.strategy([])
 
-    def visit_union_type(self, t: UnionType) -> T:
+    def visit_union_type(self, t: UnionType, /) -> T:
         return self.query_types(t.items)
 
-    def visit_overloaded(self, t: Overloaded) -> T:
+    def visit_overloaded(self, t: Overloaded, /) -> T:
         return self.query_types(t.items)
 
-    def visit_type_type(self, t: TypeType) -> T:
+    def visit_type_type(self, t: TypeType, /) -> T:
         return t.item.accept(self)
 
-    def visit_ellipsis_type(self, t: EllipsisType) -> T:
+    def visit_ellipsis_type(self, t: EllipsisType, /) -> T:
         return self.strategy([])
 
-    def visit_placeholder_type(self, t: PlaceholderType) -> T:
+    def visit_placeholder_type(self, t: PlaceholderType, /) -> T:
         return self.query_types(t.args)
 
-    def visit_type_alias_type(self, t: TypeAliasType) -> T:
+    def visit_type_alias_type(self, t: TypeAliasType, /) -> T:
         # Skip type aliases already visited types to avoid infinite recursion.
         # TODO: Ideally we should fire subvisitors here (or use caching) if we care
         #       about duplicates.
@@ -428,7 +467,7 @@ class BoolTypeQuery(SyntheticTypeVisitor[bool]):
     be ANY_STRATEGY or ALL_STRATEGY.
 
     Note: This visitor keeps an internal state (tracks type aliases to avoid
-    recursion), so it should *never* be re-used for querying different types
+    recursion), so it should *never* be reused for querying different types
     unless you call reset() first.
     """
 
@@ -455,52 +494,52 @@ def reset(self) -> None:
         """
         self.seen_aliases = None
 
-    def visit_unbound_type(self, t: UnboundType) -> bool:
+    def visit_unbound_type(self, t: UnboundType, /) -> bool:
         return self.query_types(t.args)
 
-    def visit_type_list(self, t: TypeList) -> bool:
+    def visit_type_list(self, t: TypeList, /) -> bool:
         return self.query_types(t.items)
 
-    def visit_callable_argument(self, t: CallableArgument) -> bool:
+    def visit_callable_argument(self, t: CallableArgument, /) -> bool:
         return t.typ.accept(self)
 
-    def visit_any(self, t: AnyType) -> bool:
+    def visit_any(self, t: AnyType, /) -> bool:
         return self.default
 
-    def visit_uninhabited_type(self, t: UninhabitedType) -> bool:
+    def visit_uninhabited_type(self, t: UninhabitedType, /) -> bool:
         return self.default
 
-    def visit_none_type(self, t: NoneType) -> bool:
+    def visit_none_type(self, t: NoneType, /) -> bool:
         return self.default
 
-    def visit_erased_type(self, t: ErasedType) -> bool:
+    def visit_erased_type(self, t: ErasedType, /) -> bool:
         return self.default
 
-    def visit_deleted_type(self, t: DeletedType) -> bool:
+    def visit_deleted_type(self, t: DeletedType, /) -> bool:
         return self.default
 
-    def visit_type_var(self, t: TypeVarType) -> bool:
+    def visit_type_var(self, t: TypeVarType, /) -> bool:
         return self.query_types([t.upper_bound, t.default] + t.values)
 
-    def visit_param_spec(self, t: ParamSpecType) -> bool:
+    def visit_param_spec(self, t: ParamSpecType, /) -> bool:
         return self.query_types([t.upper_bound, t.default])
 
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> bool:
+    def visit_type_var_tuple(self, t: TypeVarTupleType, /) -> bool:
         return self.query_types([t.upper_bound, t.default])
 
-    def visit_unpack_type(self, t: UnpackType) -> bool:
+    def visit_unpack_type(self, t: UnpackType, /) -> bool:
         return self.query_types([t.type])
 
-    def visit_parameters(self, t: Parameters) -> bool:
+    def visit_parameters(self, t: Parameters, /) -> bool:
         return self.query_types(t.arg_types)
 
-    def visit_partial_type(self, t: PartialType) -> bool:
+    def visit_partial_type(self, t: PartialType, /) -> bool:
         return self.default
 
-    def visit_instance(self, t: Instance) -> bool:
+    def visit_instance(self, t: Instance, /) -> bool:
         return self.query_types(t.args)
 
-    def visit_callable_type(self, t: CallableType) -> bool:
+    def visit_callable_type(self, t: CallableType, /) -> bool:
         # FIX generics
         # Avoid allocating any objects here as an optimization.
         args = self.query_types(t.arg_types)
@@ -510,34 +549,34 @@ def visit_callable_type(self, t: CallableType) -> bool:
         else:
             return args and ret
 
-    def visit_tuple_type(self, t: TupleType) -> bool:
-        return self.query_types(t.items)
+    def visit_tuple_type(self, t: TupleType, /) -> bool:
+        return self.query_types([t.partial_fallback] + t.items)
 
-    def visit_typeddict_type(self, t: TypedDictType) -> bool:
+    def visit_typeddict_type(self, t: TypedDictType, /) -> bool:
         return self.query_types(list(t.items.values()))
 
-    def visit_raw_expression_type(self, t: RawExpressionType) -> bool:
+    def visit_raw_expression_type(self, t: RawExpressionType, /) -> bool:
         return self.default
 
-    def visit_literal_type(self, t: LiteralType) -> bool:
+    def visit_literal_type(self, t: LiteralType, /) -> bool:
         return self.default
 
-    def visit_union_type(self, t: UnionType) -> bool:
+    def visit_union_type(self, t: UnionType, /) -> bool:
         return self.query_types(t.items)
 
-    def visit_overloaded(self, t: Overloaded) -> bool:
+    def visit_overloaded(self, t: Overloaded, /) -> bool:
         return self.query_types(t.items)  # type: ignore[arg-type]
 
-    def visit_type_type(self, t: TypeType) -> bool:
+    def visit_type_type(self, t: TypeType, /) -> bool:
         return t.item.accept(self)
 
-    def visit_ellipsis_type(self, t: EllipsisType) -> bool:
+    def visit_ellipsis_type(self, t: EllipsisType, /) -> bool:
         return self.default
 
-    def visit_placeholder_type(self, t: PlaceholderType) -> bool:
+    def visit_placeholder_type(self, t: PlaceholderType, /) -> bool:
         return self.query_types(t.args)
 
-    def visit_type_alias_type(self, t: TypeAliasType) -> bool:
+    def visit_type_alias_type(self, t: TypeAliasType, /) -> bool:
         # Skip type aliases already visited types to avoid infinite recursion.
         # TODO: Ideally we should fire subvisitors here (or use caching) if we care
         #       about duplicates.
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
index d1e6e315b9e3..7bf21709b863 100644
--- a/mypy/typeanal.py
+++ b/mypy/typeanal.py
@@ -3,13 +3,25 @@
 from __future__ import annotations
 
 import itertools
+from collections.abc import Iterable, Iterator, Sequence
 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, Protocol, TypeVar
 
 from mypy import errorcodes as codes, message_registry, nodes
 from mypy.errorcodes import ErrorCode
-from mypy.messages import MessageBuilder, format_type_bare, quote_type_string, wrong_type_arg_count
+from mypy.expandtype import expand_type
+from mypy.message_registry import (
+    INVALID_PARAM_SPEC_LOCATION,
+    INVALID_PARAM_SPEC_LOCATION_NOTE,
+    TYPEDDICT_OVERRIDE_MERGE,
+)
+from mypy.messages import (
+    MessageBuilder,
+    format_type,
+    format_type_bare,
+    quote_type_string,
+    wrong_type_arg_count,
+)
 from mypy.nodes import (
     ARG_NAMED,
     ARG_NAMED_OPT,
@@ -17,10 +29,12 @@
     ARG_POS,
     ARG_STAR,
     ARG_STAR2,
+    MISSING_FALLBACK,
     SYMBOL_FUNCBASE_TYPES,
     ArgKind,
     Context,
     Decorator,
+    ImportFrom,
     MypyFile,
     ParamSpecExpr,
     PlaceholderNode,
@@ -35,17 +49,25 @@
     check_arg_names,
     get_nongen_builtins,
 )
-from mypy.options import UNPACK, Options
+from mypy.options import INLINE_TYPEDDICT, Options
 from mypy.plugin import AnalyzeTypeContext, Plugin, TypeAnalyzerPluginInterface
-from mypy.semanal_shared import SemanticAnalyzerCoreInterface, paramspec_args, paramspec_kwargs
+from mypy.semanal_shared import (
+    SemanticAnalyzerCoreInterface,
+    SemanticAnalyzerInterface,
+    paramspec_args,
+    paramspec_kwargs,
+)
+from mypy.state import state
 from mypy.tvar_scope import TypeVarLikeScope
 from mypy.types import (
     ANNOTATED_TYPE_NAMES,
     ANY_STRATEGY,
+    CONCATENATE_TYPE_NAMES,
     FINAL_TYPE_NAMES,
     LITERAL_TYPE_NAMES,
     NEVER_NAMES,
     TYPE_ALIAS_NAMES,
+    UNPACK_TYPE_NAMES,
     AnyType,
     BoolTypeQuery,
     CallableArgument,
@@ -62,7 +84,9 @@
     ParamSpecType,
     PartialType,
     PlaceholderType,
+    ProperType,
     RawExpressionType,
+    ReadOnlyType,
     RequiredType,
     SyntheticTypeVisitor,
     TrivialSyntheticTypeTranslator,
@@ -74,6 +98,7 @@
     TypeOfAny,
     TypeQuery,
     TypeType,
+    TypeVarId,
     TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
@@ -82,12 +107,12 @@
     UnionType,
     UnpackType,
     callable_with_ellipsis,
-    flatten_nested_unions,
+    find_unpack_in_list,
+    flatten_nested_tuples,
     get_proper_type,
     has_type_vars,
 )
-from mypy.types_utils import is_bad_type_type_item
-from mypy.typetraverser import TypeTraverserVisitor
+from mypy.types_utils import get_bad_type_type_item
 from mypy.typevars import fill_typevars
 
 T = TypeVar("T")
@@ -126,11 +151,14 @@ def analyze_type_alias(
     tvar_scope: TypeVarLikeScope,
     plugin: Plugin,
     options: Options,
+    cur_mod_node: MypyFile,
     is_typeshed_stub: bool,
     allow_placeholder: bool = False,
     in_dynamic_func: bool = False,
     global_scope: bool = True,
     allowed_alias_tvars: list[TypeVarLikeType] | None = None,
+    alias_type_params_names: list[str] | None = None,
+    python_3_12_type_alias: bool = False,
 ) -> tuple[Type, set[str]]:
     """Analyze r.h.s. of a (potential) type alias definition.
 
@@ -143,15 +171,18 @@ def analyze_type_alias(
         tvar_scope,
         plugin,
         options,
+        cur_mod_node,
         is_typeshed_stub,
         defining_alias=True,
         allow_placeholder=allow_placeholder,
         prohibit_self_type="type alias target",
         allowed_alias_tvars=allowed_alias_tvars,
+        alias_type_params_names=alias_type_params_names,
+        python_3_12_type_alias=python_3_12_type_alias,
     )
     analyzer.in_dynamic_func = in_dynamic_func
     analyzer.global_scope = global_scope
-    res = type.accept(analyzer)
+    res = analyzer.anal_type(type, nested=False)
     return res, analyzer.aliases_used
 
 
@@ -187,18 +218,24 @@ def __init__(
         tvar_scope: TypeVarLikeScope,
         plugin: Plugin,
         options: Options,
+        cur_mod_node: MypyFile,
         is_typeshed_stub: bool,
         *,
         defining_alias: bool = False,
+        python_3_12_type_alias: bool = False,
         allow_tuple_literal: bool = False,
         allow_unbound_tvars: bool = False,
         allow_placeholder: bool = False,
-        allow_required: bool = False,
+        allow_typed_dict_special_forms: bool = False,
+        allow_final: bool = True,
         allow_param_spec_literals: bool = False,
+        allow_unpack: bool = False,
         report_invalid_types: bool = True,
         prohibit_self_type: str | None = None,
+        prohibit_special_class_field_types: str | None = None,
         allowed_alias_tvars: list[TypeVarLikeType] | None = None,
         allow_type_any: bool = False,
+        alias_type_params_names: list[str] | None = None,
     ) -> None:
         self.api = api
         self.fail_func = api.fail
@@ -206,6 +243,7 @@ def __init__(
         self.tvar_scope = tvar_scope
         # Are we analysing a type alias definition rvalue?
         self.defining_alias = defining_alias
+        self.python_3_12_type_alias = python_3_12_type_alias
         self.allow_tuple_literal = allow_tuple_literal
         # Positive if we are analyzing arguments of another (outer) type
         self.nesting_level = 0
@@ -220,12 +258,17 @@ def __init__(
         if allowed_alias_tvars is None:
             allowed_alias_tvars = []
         self.allowed_alias_tvars = allowed_alias_tvars
+        self.alias_type_params_names = alias_type_params_names
         # If false, record incomplete ref if we generate PlaceholderType.
         self.allow_placeholder = allow_placeholder
         # Are we in a context where Required[] is allowed?
-        self.allow_required = allow_required
+        self.allow_typed_dict_special_forms = allow_typed_dict_special_forms
+        # Set True when we analyze ClassVar else False
+        self.allow_final = allow_final
         # Are we in a context where ParamSpec literals are allowed?
         self.allow_param_spec_literals = allow_param_spec_literals
+        # Are we in context where literal "..." specifically is allowed?
+        self.allow_ellipsis = False
         # Should we report an error whenever we encounter a RawExpressionType outside
         # of a Literal context: e.g. whenever we encounter an invalid type? Normally,
         # we want to report an error, but the caller may want to do more specialized
@@ -233,20 +276,25 @@ def __init__(
         self.report_invalid_types = report_invalid_types
         self.plugin = plugin
         self.options = options
+        self.cur_mod_node = cur_mod_node
         self.is_typeshed_stub = is_typeshed_stub
         # Names of type aliases encountered while analysing a type will be collected here.
         self.aliases_used: set[str] = set()
         self.prohibit_self_type = prohibit_self_type
+        # Set when we analyze TypedDicts or NamedTuples, since they are special:
+        self.prohibit_special_class_field_types = prohibit_special_class_field_types
         # Allow variables typed as Type[Any] and type (useful for base classes).
         self.allow_type_any = allow_type_any
+        self.allow_type_var_tuple = False
+        self.allow_unpack = allow_unpack
 
     def lookup_qualified(
         self, name: str, ctx: Context, suppress_errors: bool = False
     ) -> SymbolTableNode | None:
         return self.api.lookup_qualified(name, ctx, suppress_errors)
 
-    def lookup_fully_qualified(self, name: str) -> SymbolTableNode:
-        return self.api.lookup_fully_qualified(name)
+    def lookup_fully_qualified(self, fullname: str) -> SymbolTableNode:
+        return self.api.lookup_fully_qualified(fullname)
 
     def visit_unbound_type(self, t: UnboundType, defining_literal: bool = False) -> Type:
         typ = self.visit_unbound_type_nonoptional(t, defining_literal)
@@ -256,8 +304,23 @@ def visit_unbound_type(self, t: UnboundType, defining_literal: bool = False) ->
             return make_optional_type(typ)
         return typ
 
+    def not_declared_in_type_params(self, tvar_name: str) -> bool:
+        return (
+            self.alias_type_params_names is not None
+            and tvar_name not in self.alias_type_params_names
+        )
+
     def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool) -> Type:
         sym = self.lookup_qualified(t.name, t)
+        param_spec_name = None
+        if t.name.endswith((".args", ".kwargs")):
+            param_spec_name = t.name.rsplit(".", 1)[0]
+            maybe_param_spec = self.lookup_qualified(param_spec_name, t)
+            if maybe_param_spec and isinstance(maybe_param_spec.node, ParamSpecExpr):
+                sym = maybe_param_spec
+            else:
+                param_spec_name = None
+
         if sym is not None:
             node = sym.node
             if isinstance(node, PlaceholderNode):
@@ -275,7 +338,10 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                     return PlaceholderType(
                         node.fullname,
                         self.anal_array(
-                            t.args, allow_param_spec=True, allow_param_spec_literals=True
+                            t.args,
+                            allow_param_spec=True,
+                            allow_param_spec_literals=True,
+                            allow_unpack=True,
                         ),
                         t.line,
                     )
@@ -307,13 +373,23 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                 if tvar_def is None:
                     if self.allow_unbound_tvars:
                         return t
-                    self.fail(f'ParamSpec "{t.name}" is unbound', t, code=codes.VALID_TYPE)
+                    name = param_spec_name or t.name
+                    if self.defining_alias and self.not_declared_in_type_params(t.name):
+                        msg = f'ParamSpec "{name}" is not included in type_params'
+                    else:
+                        msg = f'ParamSpec "{name}" is unbound'
+                    self.fail(msg, t, code=codes.VALID_TYPE)
                     return AnyType(TypeOfAny.from_error)
                 assert isinstance(tvar_def, ParamSpecType)
                 if len(t.args) > 0:
                     self.fail(
                         f'ParamSpec "{t.name}" used with arguments', t, code=codes.VALID_TYPE
                     )
+                if param_spec_name is not None and not self.allow_param_spec_literals:
+                    self.fail(
+                        "ParamSpec components are not allowed here", t, code=codes.VALID_TYPE
+                    )
+                    return AnyType(TypeOfAny.from_error)
                 # Change the line number
                 return ParamSpecType(
                     tvar_def.name,
@@ -331,11 +407,16 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                 and not defining_literal
                 and (tvar_def is None or tvar_def not in self.allowed_alias_tvars)
             ):
-                self.fail(
-                    f'Can\'t use bound type variable "{t.name}" to define generic alias',
-                    t,
-                    code=codes.VALID_TYPE,
-                )
+                if self.not_declared_in_type_params(t.name):
+                    if self.python_3_12_type_alias:
+                        msg = message_registry.TYPE_PARAMETERS_SHOULD_BE_DECLARED.format(
+                            f'"{t.name}"'
+                        )
+                    else:
+                        msg = f'Type variable "{t.name}" is not included in type_params'
+                else:
+                    msg = f'Can\'t use bound type variable "{t.name}" to define generic alias'
+                self.fail(msg, t, code=codes.VALID_TYPE)
                 return AnyType(TypeOfAny.from_error)
             if isinstance(sym.node, TypeVarExpr) and tvar_def is not None:
                 assert isinstance(tvar_def, TypeVarType)
@@ -350,19 +431,35 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                 and self.defining_alias
                 and tvar_def not in self.allowed_alias_tvars
             ):
-                self.fail(
-                    f'Can\'t use bound type variable "{t.name}" to define generic alias',
-                    t,
-                    code=codes.VALID_TYPE,
-                )
+                if self.not_declared_in_type_params(t.name):
+                    msg = f'Type variable "{t.name}" is not included in type_params'
+                else:
+                    msg = f'Can\'t use bound type variable "{t.name}" to define generic alias'
+                self.fail(msg, t, code=codes.VALID_TYPE)
                 return AnyType(TypeOfAny.from_error)
             if isinstance(sym.node, TypeVarTupleExpr):
                 if tvar_def is None:
                     if self.allow_unbound_tvars:
                         return t
-                    self.fail(f'TypeVarTuple "{t.name}" is unbound', t, code=codes.VALID_TYPE)
+                    if self.defining_alias and self.not_declared_in_type_params(t.name):
+                        if self.python_3_12_type_alias:
+                            msg = message_registry.TYPE_PARAMETERS_SHOULD_BE_DECLARED.format(
+                                f'"{t.name}"'
+                            )
+                        else:
+                            msg = f'TypeVarTuple "{t.name}" is not included in type_params'
+                    else:
+                        msg = f'TypeVarTuple "{t.name}" is unbound'
+                    self.fail(msg, t, code=codes.VALID_TYPE)
                     return AnyType(TypeOfAny.from_error)
                 assert isinstance(tvar_def, TypeVarTupleType)
+                if not self.allow_type_var_tuple:
+                    self.fail(
+                        f'TypeVarTuple "{t.name}" is only valid with an unpack',
+                        t,
+                        code=codes.VALID_TYPE,
+                    )
+                    return AnyType(TypeOfAny.from_error)
                 if len(t.args) > 0:
                     self.fail(
                         f'Type variable "{t.name}" used with arguments', t, code=codes.VALID_TYPE
@@ -388,6 +485,7 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                     t.args,
                     allow_param_spec=True,
                     allow_param_spec_literals=node.has_param_spec_type,
+                    allow_unpack=True,  # Fixed length unpacks can be used for non-variadic aliases.
                 )
                 if node.has_param_spec_type and len(node.alias_tvars) == 1:
                     an_args = self.pack_paramspec_args(an_args)
@@ -407,10 +505,10 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                 # The only case where instantiate_type_alias() can return an incorrect instance is
                 # when it is top-level instance, so no need to recurse.
                 if (
-                    isinstance(res, Instance)  # type: ignore[misc]
-                    and len(res.args) != len(res.type.type_vars)
-                    and not self.defining_alias
-                    and not res.type.has_type_var_tuple_type
+                    isinstance(res, ProperType)
+                    and isinstance(res, Instance)
+                    and not (self.defining_alias and self.nesting_level == 0)
+                    and not validate_instance(res, self.fail, t.empty_tuple_index)
                 ):
                     fix_instance(
                         res,
@@ -425,11 +523,11 @@ def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool)
                     res = get_proper_type(res)
                 return res
             elif isinstance(node, TypeInfo):
-                return self.analyze_type_with_type_info(node, t.args, t)
+                return self.analyze_type_with_type_info(node, t.args, t, t.empty_tuple_index)
             elif node.fullname in TYPE_ALIAS_NAMES:
                 return AnyType(TypeOfAny.special_form)
             # Concatenate is an operator, no need for a proper type
-            elif node.fullname in ("typing_extensions.Concatenate", "typing.Concatenate"):
+            elif node.fullname in CONCATENATE_TYPE_NAMES:
                 # We check the return type further up the stack for valid use locations
                 return self.apply_concatenate_operator(t)
             else:
@@ -442,18 +540,37 @@ def pack_paramspec_args(self, an_args: Sequence[Type]) -> list[Type]:
         # These do not support mypy_extensions VarArgs, etc. as they were already analyzed
         # TODO: should these be re-analyzed to get rid of this inconsistency?
         count = len(an_args)
-        if count > 0:
-            first_arg = get_proper_type(an_args[0])
-            if not (count == 1 and isinstance(first_arg, (Parameters, ParamSpecType, AnyType))):
-                return [Parameters(an_args, [ARG_POS] * count, [None] * count)]
-        return list(an_args)
+        if count == 0:
+            return []
+        if count == 1 and isinstance(get_proper_type(an_args[0]), AnyType):
+            # Single Any is interpreted as ..., rather that a single argument with Any type.
+            # I didn't find this in the PEP, but it sounds reasonable.
+            return list(an_args)
+        if any(isinstance(a, (Parameters, ParamSpecType)) for a in an_args):
+            if len(an_args) > 1:
+                first_wrong = next(
+                    arg for arg in an_args if isinstance(arg, (Parameters, ParamSpecType))
+                )
+                self.fail(
+                    "Nested parameter specifications are not allowed",
+                    first_wrong,
+                    code=codes.VALID_TYPE,
+                )
+                return [AnyType(TypeOfAny.from_error)]
+            return list(an_args)
+        first = an_args[0]
+        return [
+            Parameters(
+                an_args, [ARG_POS] * count, [None] * count, line=first.line, column=first.column
+            )
+        ]
 
     def cannot_resolve_type(self, t: UnboundType) -> None:
         # TODO: Move error message generation to messages.py. We'd first
         #       need access to MessageBuilder here. Also move the similar
         #       message generation logic in semanal.py.
         self.api.fail(f'Cannot resolve name "{t.name}" (possible cyclic definition)', t)
-        if not self.options.disable_recursive_aliases and self.api.is_func_scope():
+        if self.api.is_func_scope():
             self.note("Recursive types are not allowed at function scope", t)
 
     def apply_concatenate_operator(self, t: UnboundType) -> Type:
@@ -461,9 +578,9 @@ def apply_concatenate_operator(self, t: UnboundType) -> Type:
             self.api.fail("Concatenate needs type arguments", t, code=codes.VALID_TYPE)
             return AnyType(TypeOfAny.from_error)
 
-        # last argument has to be ParamSpec
-        ps = self.anal_type(t.args[-1], allow_param_spec=True)
-        if not isinstance(ps, ParamSpecType):
+        # Last argument has to be ParamSpec or Ellipsis.
+        ps = self.anal_type(t.args[-1], allow_param_spec=True, allow_ellipsis=True)
+        if not isinstance(ps, (ParamSpecType, Parameters)):
             if isinstance(ps, UnboundType) and self.allow_unbound_tvars:
                 sym = self.lookup_qualified(ps.name, t)
                 if sym is not None and isinstance(sym.node, ParamSpecExpr):
@@ -474,22 +591,23 @@ def apply_concatenate_operator(self, t: UnboundType) -> Type:
                 code=codes.VALID_TYPE,
             )
             return AnyType(TypeOfAny.from_error)
-
-        # TODO: this may not work well with aliases, if those worked.
-        #   Those should be special-cased.
-        elif ps.prefix.arg_types:
+        elif isinstance(ps, ParamSpecType) and ps.prefix.arg_types:
             self.api.fail("Nested Concatenates are invalid", t, code=codes.VALID_TYPE)
 
         args = self.anal_array(t.args[:-1])
-        pre = ps.prefix
+        pre = ps.prefix if isinstance(ps, ParamSpecType) else ps
 
         # mypy can't infer this :(
         names: list[str | None] = [None] * len(args)
 
         pre = Parameters(
-            args + pre.arg_types, [ARG_POS] * len(args) + pre.arg_kinds, names + pre.arg_names
+            args + pre.arg_types,
+            [ARG_POS] * len(args) + pre.arg_kinds,
+            names + pre.arg_names,
+            line=t.line,
+            column=t.column,
         )
-        return ps.copy_modified(prefix=pre)
+        return ps.copy_modified(prefix=pre) if isinstance(ps, ParamSpecType) else pre
 
     def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Type | None:
         """Bind special type that is recognized through magic name such as 'typing.Any'.
@@ -498,14 +616,22 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
         """
         if fullname == "builtins.None":
             return NoneType()
-        elif fullname == "typing.Any" or fullname == "builtins.Any":
+        elif fullname == "typing.Any":
             return AnyType(TypeOfAny.explicit, line=t.line, column=t.column)
         elif fullname in FINAL_TYPE_NAMES:
-            self.fail(
-                "Final can be only used as an outermost qualifier in a variable annotation",
-                t,
-                code=codes.VALID_TYPE,
-            )
+            if self.prohibit_special_class_field_types:
+                self.fail(
+                    f"Final[...] can't be used inside a {self.prohibit_special_class_field_types}",
+                    t,
+                    code=codes.VALID_TYPE,
+                )
+            else:
+                if not self.allow_final:
+                    self.fail(
+                        "Final can be only used as an outermost qualifier in a variable annotation",
+                        t,
+                        code=codes.VALID_TYPE,
+                    )
             return AnyType(TypeOfAny.from_error)
         elif fullname == "typing.Tuple" or (
             fullname == "builtins.tuple"
@@ -529,7 +655,9 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                 instance = self.named_type("builtins.tuple", [self.anal_type(t.args[0])])
                 instance.line = t.line
                 return instance
-            return self.tuple_type(self.anal_array(t.args))
+            return self.tuple_type(
+                self.anal_array(t.args, allow_unpack=True), line=t.line, column=t.column
+            )
         elif fullname == "typing.Union":
             items = self.anal_array(t.args)
             return UnionType.make_union(items)
@@ -555,14 +683,15 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                     # To prevent assignment of 'builtins.type' inferred as 'builtins.object'
                     # See https://github.com/python/mypy/issues/9476 for more information
                     return None
+            type_str = "Type[...]" if fullname == "typing.Type" else "type[...]"
             if len(t.args) != 1:
-                type_str = "Type[...]" if fullname == "typing.Type" else "type[...]"
                 self.fail(
-                    type_str + " must have exactly one type argument", t, code=codes.VALID_TYPE
+                    f"{type_str} must have exactly one type argument", t, code=codes.VALID_TYPE
                 )
             item = self.anal_type(t.args[0])
-            if is_bad_type_type_item(item):
-                self.fail("Type[...] can't contain another Type[...]", t, code=codes.VALID_TYPE)
+            bad_item_name = get_bad_type_type_item(item)
+            if bad_item_name:
+                self.fail(f'{type_str} can\'t contain "{bad_item_name}"', t, code=codes.VALID_TYPE)
                 item = AnyType(TypeOfAny.from_error)
             return TypeType.make_normalized(item, line=t.line, column=t.column)
         elif fullname == "typing.ClassVar":
@@ -570,6 +699,12 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                 self.fail(
                     "Invalid type: ClassVar nested inside other type", t, code=codes.VALID_TYPE
                 )
+            if self.prohibit_special_class_field_types:
+                self.fail(
+                    f"ClassVar[...] can't be used inside a {self.prohibit_special_class_field_types}",
+                    t,
+                    code=codes.VALID_TYPE,
+                )
             if len(t.args) == 0:
                 return AnyType(TypeOfAny.from_omitted_generics, line=t.line, column=t.column)
             if len(t.args) != 1:
@@ -577,9 +712,9 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                     "ClassVar[...] must have at most one type argument", t, code=codes.VALID_TYPE
                 )
                 return AnyType(TypeOfAny.from_error)
-            return self.anal_type(t.args[0])
+            return self.anal_type(t.args[0], allow_final=self.options.python_version >= (3, 13))
         elif fullname in NEVER_NAMES:
-            return UninhabitedType(is_noreturn=True)
+            return UninhabitedType()
         elif fullname in LITERAL_TYPE_NAMES:
             return self.analyze_literal_type(t)
         elif fullname in ANNOTATED_TYPE_NAMES:
@@ -591,9 +726,11 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                     code=codes.VALID_TYPE,
                 )
                 return AnyType(TypeOfAny.from_error)
-            return self.anal_type(t.args[0])
+            return self.anal_type(
+                t.args[0], allow_typed_dict_special_forms=self.allow_typed_dict_special_forms
+            )
         elif fullname in ("typing_extensions.Required", "typing.Required"):
-            if not self.allow_required:
+            if not self.allow_typed_dict_special_forms:
                 self.fail(
                     "Required[] can be only used in a TypedDict definition",
                     t,
@@ -605,9 +742,11 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                     "Required[] must have exactly one type argument", t, code=codes.VALID_TYPE
                 )
                 return AnyType(TypeOfAny.from_error)
-            return RequiredType(self.anal_type(t.args[0]), required=True)
+            return RequiredType(
+                self.anal_type(t.args[0], allow_typed_dict_special_forms=True), required=True
+            )
         elif fullname in ("typing_extensions.NotRequired", "typing.NotRequired"):
-            if not self.allow_required:
+            if not self.allow_typed_dict_special_forms:
                 self.fail(
                     "NotRequired[] can be only used in a TypedDict definition",
                     t,
@@ -619,17 +758,40 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Typ
                     "NotRequired[] must have exactly one type argument", t, code=codes.VALID_TYPE
                 )
                 return AnyType(TypeOfAny.from_error)
-            return RequiredType(self.anal_type(t.args[0]), required=False)
-        elif self.anal_type_guard_arg(t, fullname) is not None:
+            return RequiredType(
+                self.anal_type(t.args[0], allow_typed_dict_special_forms=True), required=False
+            )
+        elif fullname in ("typing_extensions.ReadOnly", "typing.ReadOnly"):
+            if not self.allow_typed_dict_special_forms:
+                self.fail(
+                    "ReadOnly[] can be only used in a TypedDict definition",
+                    t,
+                    code=codes.VALID_TYPE,
+                )
+                return AnyType(TypeOfAny.from_error)
+            if len(t.args) != 1:
+                self.fail(
+                    '"ReadOnly[]" must have exactly one type argument', t, code=codes.VALID_TYPE
+                )
+                return AnyType(TypeOfAny.from_error)
+            return ReadOnlyType(self.anal_type(t.args[0], allow_typed_dict_special_forms=True))
+        elif (
+            self.anal_type_guard_arg(t, fullname) is not None
+            or self.anal_type_is_arg(t, fullname) is not None
+        ):
             # In most contexts, TypeGuard[...] acts as an alias for bool (ignoring its args)
             return self.named_type("builtins.bool")
-        elif fullname in ("typing.Unpack", "typing_extensions.Unpack"):
-            if not self.api.incomplete_feature_enabled(UNPACK, t):
-                return AnyType(TypeOfAny.from_error)
+        elif fullname in UNPACK_TYPE_NAMES:
             if len(t.args) != 1:
                 self.fail("Unpack[...] requires exactly one type argument", t)
                 return AnyType(TypeOfAny.from_error)
-            return UnpackType(self.anal_type(t.args[0]), line=t.line, column=t.column)
+            if not self.allow_unpack:
+                self.fail(message_registry.INVALID_UNPACK_POSITION, t, code=codes.VALID_TYPE)
+                return AnyType(TypeOfAny.from_error)
+            self.allow_type_var_tuple = True
+            result = UnpackType(self.anal_type(t.args[0]), line=t.line, column=t.column)
+            self.allow_type_var_tuple = False
+            return result
         elif fullname in SELF_TYPE_NAMES:
             if t.args:
                 self.fail("Self type cannot have type arguments", t)
@@ -654,17 +816,38 @@ def get_omitted_any(self, typ: Type, fullname: str | None = None) -> AnyType:
         disallow_any = not self.is_typeshed_stub and self.options.disallow_any_generics
         return get_omitted_any(disallow_any, self.fail, self.note, typ, self.options, fullname)
 
+    def check_and_warn_deprecated(self, info: TypeInfo, ctx: Context) -> None:
+        """Similar logic to `TypeChecker.check_deprecated` and `TypeChecker.warn_deprecated."""
+
+        if (
+            (deprecated := info.deprecated)
+            and not self.is_typeshed_stub
+            and not (self.api.type and (self.api.type.fullname == info.fullname))
+            and not any(
+                info.fullname == p or info.fullname.startswith(f"{p}.")
+                for p in self.options.deprecated_calls_exclude
+            )
+        ):
+            for imp in self.cur_mod_node.imports:
+                if isinstance(imp, ImportFrom) and any(info.name == n[0] for n in imp.names):
+                    break
+            else:
+                warn = self.note if self.options.report_deprecated_as_note else self.fail
+                warn(deprecated, ctx, code=codes.DEPRECATED)
+
     def analyze_type_with_type_info(
-        self, info: TypeInfo, args: Sequence[Type], ctx: Context
+        self, info: TypeInfo, args: Sequence[Type], ctx: Context, empty_tuple_index: bool
     ) -> Type:
         """Bind unbound type when were able to find target TypeInfo.
 
         This handles simple cases like 'int', 'modname.UserClass[str]', etc.
         """
 
+        self.check_and_warn_deprecated(info, ctx)
+
         if len(args) > 0 and info.fullname == "builtins.tuple":
             fallback = Instance(info, [AnyType(TypeOfAny.special_form)], ctx.line)
-            return TupleType(self.anal_array(args), fallback, ctx.line)
+            return TupleType(self.anal_array(args, allow_unpack=True), fallback, ctx.line)
 
         # Analyze arguments and (usually) construct Instance type. The
         # number of type arguments and their values are
@@ -677,27 +860,24 @@ def analyze_type_with_type_info(
         instance = Instance(
             info,
             self.anal_array(
-                args, allow_param_spec=True, allow_param_spec_literals=info.has_param_spec_type
+                args,
+                allow_param_spec=True,
+                allow_param_spec_literals=info.has_param_spec_type,
+                allow_unpack=True,  # Fixed length tuples can be used for non-variadic types.
             ),
             ctx.line,
             ctx.column,
         )
+        instance.end_line = ctx.end_line
+        instance.end_column = ctx.end_column
         if len(info.type_vars) == 1 and info.has_param_spec_type:
             instance.args = tuple(self.pack_paramspec_args(instance.args))
 
-        if info.has_type_var_tuple_type:
-            if instance.args:
-                # -1 to account for empty tuple
-                valid_arg_length = len(instance.args) >= len(info.type_vars) - 1
-            # Empty case is special cased and we want to infer a Tuple[Any, ...]
-            # instead of the empty tuple, so no - 1 here.
-            else:
-                valid_arg_length = False
-        else:
-            valid_arg_length = len(instance.args) == len(info.type_vars)
-
         # Check type argument count.
-        if not valid_arg_length and not self.defining_alias:
+        instance.args = tuple(flatten_nested_tuples(instance.args))
+        if not (self.defining_alias and self.nesting_level == 0) and not validate_instance(
+            instance, self.fail, empty_tuple_index
+        ):
             fix_instance(
                 instance,
                 self.fail,
@@ -714,14 +894,16 @@ def analyze_type_with_type_info(
                 return instantiate_type_alias(
                     info.special_alias,
                     # TODO: should we allow NamedTuples generic in ParamSpec?
-                    self.anal_array(args),
+                    self.anal_array(args, allow_unpack=True),
                     self.fail,
                     False,
                     ctx,
                     self.options,
                     use_standard_error=True,
                 )
-            return tup.copy_modified(items=self.anal_array(tup.items), fallback=instance)
+            return tup.copy_modified(
+                items=self.anal_array(tup.items, allow_unpack=True), fallback=instance
+            )
         td = info.typeddict_type
         if td is not None:
             # The class has a TypedDict[...] base class so it will be
@@ -730,7 +912,7 @@ def analyze_type_with_type_info(
                 return instantiate_type_alias(
                     info.special_alias,
                     # TODO: should we allow TypedDicts generic in ParamSpec?
-                    self.anal_array(args),
+                    self.anal_array(args, allow_unpack=True),
                     self.fail,
                     False,
                     ctx,
@@ -798,7 +980,12 @@ def analyze_unbound_type_without_type_info(
         # If, in the distant future, we decide to permit things like
         # `def foo(x: Color.RED) -> None: ...`, we can remove that
         # check entirely.
-        if isinstance(sym.node, Var) and sym.node.info and sym.node.info.is_enum:
+        if (
+            isinstance(sym.node, Var)
+            and sym.node.info
+            and sym.node.info.is_enum
+            and not sym.node.name.startswith("__")
+        ):
             value = sym.node.name
             base_enum_short_name = sym.node.info.name
             if not defining_literal:
@@ -819,6 +1006,7 @@ def analyze_unbound_type_without_type_info(
         t = t.copy_modified(args=self.anal_array(t.args))
         # TODO: Move this message building logic to messages.py.
         notes: list[str] = []
+        error_code = codes.VALID_TYPE
         if isinstance(sym.node, Var):
             notes.append(
                 "See https://mypy.readthedocs.io/en/"
@@ -837,25 +1025,31 @@ def analyze_unbound_type_without_type_info(
             message = 'Module "{}" is not valid as a type'
             notes.append("Perhaps you meant to use a protocol matching the module structure?")
         elif unbound_tvar:
-            message = 'Type variable "{}" is unbound'
-            short = name.split(".")[-1]
-            notes.append(
-                (
-                    '(Hint: Use "Generic[{}]" or "Protocol[{}]" base class'
-                    ' to bind "{}" inside a class)'
-                ).format(short, short, short)
-            )
-            notes.append(
-                '(Hint: Use "{}" in function signature to bind "{}"'
-                " inside a function)".format(short, short)
-            )
+            assert isinstance(sym.node, TypeVarLikeExpr)
+            if sym.node.is_new_style:
+                # PEP 695 type parameters are never considered unbound -- they are undefined
+                # in contexts where they aren't valid, such as in argument default values.
+                message = 'Name "{}" is not defined'
+                name = name.split(".")[-1]
+                error_code = codes.NAME_DEFINED
+            else:
+                message = 'Type variable "{}" is unbound'
+                short = name.split(".")[-1]
+                notes.append(
+                    f'(Hint: Use "Generic[{short}]" or "Protocol[{short}]" base class'
+                    f' to bind "{short}" inside a class)'
+                )
+                notes.append(
+                    f'(Hint: Use "{short}" in function signature '
+                    f'to bind "{short}" inside a function)'
+                )
         else:
             message = 'Cannot interpret reference "{}" as a type'
         if not defining_literal:
             # Literal check already gives a custom error. Avoid duplicating errors.
-            self.fail(message.format(name), t, code=codes.VALID_TYPE)
+            self.fail(message.format(name), t, code=error_code)
             for note in notes:
-                self.note(note, t, code=codes.VALID_TYPE)
+                self.note(note, t, code=error_code)
 
         # TODO: Would it be better to always return Any instead of UnboundType
         # in case of an error? On one hand, UnboundType has a name so error messages
@@ -880,20 +1074,21 @@ def visit_deleted_type(self, t: DeletedType) -> Type:
         return t
 
     def visit_type_list(self, t: TypeList) -> Type:
-        # paramspec literal (Z[[int, str, Whatever]])
+        # Parameters literal (Z[[int, str, Whatever]])
         if self.allow_param_spec_literals:
             params = self.analyze_callable_args(t)
             if params:
                 ts, kinds, names = params
                 # bind these types
-                return Parameters(self.anal_array(ts), kinds, names)
+                return Parameters(self.anal_array(ts), kinds, names, line=t.line, column=t.column)
             else:
                 return AnyType(TypeOfAny.from_error)
         else:
             self.fail(
                 'Bracketed expression "[...]" is not valid as a type', t, code=codes.VALID_TYPE
             )
-            self.note('Did you mean "List[...]"?', t)
+            if len(t.items) == 1:
+                self.note('Did you mean "List[...]"?', t)
             return AnyType(TypeOfAny.from_error)
 
     def visit_callable_argument(self, t: CallableArgument) -> Type:
@@ -917,27 +1112,81 @@ def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
         return t
 
     def visit_unpack_type(self, t: UnpackType) -> Type:
-        raise NotImplementedError
+        if not self.allow_unpack:
+            self.fail(message_registry.INVALID_UNPACK_POSITION, t.type, code=codes.VALID_TYPE)
+            return AnyType(TypeOfAny.from_error)
+        self.allow_type_var_tuple = True
+        result = UnpackType(self.anal_type(t.type), from_star_syntax=t.from_star_syntax)
+        self.allow_type_var_tuple = False
+        return result
 
     def visit_parameters(self, t: Parameters) -> Type:
         raise NotImplementedError("ParamSpec literals cannot have unbound TypeVars")
 
-    def visit_callable_type(self, t: CallableType, nested: bool = True) -> Type:
+    def visit_callable_type(
+        self, t: CallableType, nested: bool = True, namespace: str = ""
+    ) -> Type:
         # Every Callable can bind its own type variables, if they're not in the outer scope
-        with self.tvar_scope_frame():
+        # TODO: attach namespace for nested free type variables (these appear in return type only).
+        with self.tvar_scope_frame(namespace=namespace):
+            unpacked_kwargs = t.unpack_kwargs
             if self.defining_alias:
                 variables = t.variables
             else:
                 variables, _ = self.bind_function_type_variables(t, t)
-            special = self.anal_type_guard(t.ret_type)
+            type_guard = self.anal_type_guard(t.ret_type)
+            type_is = self.anal_type_is(t.ret_type)
+
             arg_kinds = t.arg_kinds
-            if len(arg_kinds) >= 2 and arg_kinds[-2] == ARG_STAR and arg_kinds[-1] == ARG_STAR2:
-                arg_types = self.anal_array(t.arg_types[:-2], nested=nested) + [
-                    self.anal_star_arg_type(t.arg_types[-2], ARG_STAR, nested=nested),
-                    self.anal_star_arg_type(t.arg_types[-1], ARG_STAR2, nested=nested),
-                ]
-            else:
-                arg_types = self.anal_array(t.arg_types, nested=nested)
+            arg_types = []
+            param_spec_with_args = param_spec_with_kwargs = None
+            param_spec_invalid = False
+            for kind, ut in zip(arg_kinds, t.arg_types):
+                if kind == ARG_STAR:
+                    param_spec_with_args, at = self.anal_star_arg_type(ut, kind, nested=nested)
+                elif kind == ARG_STAR2:
+                    param_spec_with_kwargs, at = self.anal_star_arg_type(ut, kind, nested=nested)
+                else:
+                    if param_spec_with_args:
+                        param_spec_invalid = True
+                        self.fail(
+                            "Arguments not allowed after ParamSpec.args", t, code=codes.VALID_TYPE
+                        )
+                    at = self.anal_type(ut, nested=nested, allow_unpack=False)
+                arg_types.append(at)
+
+            if nested and arg_types:
+                # If we've got a Callable[[Unpack[SomeTypedDict]], None], make sure
+                # Unpack is interpreted as `**` and not as `*`.
+                last = arg_types[-1]
+                if isinstance(last, UnpackType):
+                    # TODO: it would be better to avoid this get_proper_type() call.
+                    p_at = get_proper_type(last.type)
+                    if isinstance(p_at, TypedDictType) and not last.from_star_syntax:
+                        # Automatically detect Unpack[Foo] in Callable as backwards
+                        # compatible syntax for **Foo, if Foo is a TypedDict.
+                        arg_kinds[-1] = ARG_STAR2
+                        arg_types[-1] = p_at
+                        unpacked_kwargs = True
+                arg_types = self.check_unpacks_in_list(arg_types)
+
+            if not param_spec_invalid and param_spec_with_args != param_spec_with_kwargs:
+                # If already invalid, do not report more errors - definition has
+                # to be fixed anyway
+                name = param_spec_with_args or param_spec_with_kwargs
+                self.fail(
+                    f'ParamSpec must have "*args" typed as "{name}.args" and "**kwargs" typed as "{name}.kwargs"',
+                    t,
+                    code=codes.VALID_TYPE,
+                )
+                param_spec_invalid = True
+
+            if param_spec_invalid:
+                if ARG_STAR in arg_kinds:
+                    arg_types[arg_kinds.index(ARG_STAR)] = AnyType(TypeOfAny.from_error)
+                if ARG_STAR2 in arg_kinds:
+                    arg_types[arg_kinds.index(ARG_STAR2)] = AnyType(TypeOfAny.from_error)
+
             # If there were multiple (invalid) unpacks, the arg types list will become shorter,
             # we need to trim the kinds/names as well to avoid crashes.
             arg_kinds = t.arg_kinds[: len(arg_types)]
@@ -952,7 +1201,9 @@ def visit_callable_type(self, t: CallableType, nested: bool = True) -> Type:
                 # its type will be the falsey FakeInfo
                 fallback=(t.fallback if t.fallback.type else self.named_type("builtins.function")),
                 variables=self.anal_var_defs(variables),
-                type_guard=special,
+                type_guard=type_guard,
+                type_is=type_is,
+                unpack_kwargs=unpacked_kwargs,
             )
         return ret
 
@@ -974,7 +1225,23 @@ def anal_type_guard_arg(self, t: UnboundType, fullname: str) -> Type | None:
             return self.anal_type(t.args[0])
         return None
 
-    def anal_star_arg_type(self, t: Type, kind: ArgKind, nested: bool) -> Type:
+    def anal_type_is(self, t: Type) -> Type | None:
+        if isinstance(t, UnboundType):
+            sym = self.lookup_qualified(t.name, t)
+            if sym is not None and sym.node is not None:
+                return self.anal_type_is_arg(t, sym.node.fullname)
+        # TODO: What if it's an Instance? Then use t.type.fullname?
+        return None
+
+    def anal_type_is_arg(self, t: UnboundType, fullname: str) -> Type | None:
+        if fullname in ("typing_extensions.TypeIs", "typing.TypeIs"):
+            if len(t.args) != 1:
+                self.fail("TypeIs must have exactly one type argument", t, code=codes.VALID_TYPE)
+                return AnyType(TypeOfAny.from_error)
+            return self.anal_type(t.args[0])
+        return None
+
+    def anal_star_arg_type(self, t: Type, kind: ArgKind, nested: bool) -> tuple[str | None, Type]:
         """Analyze signature argument type for *args and **kwargs argument."""
         if isinstance(t, UnboundType) and t.name and "." in t.name and not t.args:
             components = t.name.split(".")
@@ -1001,7 +1268,7 @@ def anal_star_arg_type(self, t: Type, kind: ArgKind, nested: bool) -> Type:
                             )
                     else:
                         assert False, kind
-                    return make_paramspec(
+                    return tvar_name, make_paramspec(
                         tvar_def.name,
                         tvar_def.fullname,
                         tvar_def.id,
@@ -1009,7 +1276,7 @@ def anal_star_arg_type(self, t: Type, kind: ArgKind, nested: bool) -> Type:
                         line=t.line,
                         column=t.column,
                     )
-        return self.anal_type(t, nested=nested)
+        return None, self.anal_type(t, nested=nested, allow_unpack=True)
 
     def visit_overloaded(self, t: Overloaded) -> Type:
         # Overloaded types are manually constructed in semanal.py by analyzing the
@@ -1048,13 +1315,55 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             if t.partial_fallback.type
             else self.named_type("builtins.tuple", [any_type])
         )
-        return TupleType(self.anal_array(t.items), fallback, t.line)
+        return TupleType(self.anal_array(t.items, allow_unpack=True), fallback, t.line)
 
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
-        items = {
-            item_name: self.anal_type(item_type) for (item_name, item_type) in t.items.items()
-        }
-        return TypedDictType(items, set(t.required_keys), t.fallback)
+        req_keys = set()
+        readonly_keys = set()
+        items = {}
+        for item_name, item_type in t.items.items():
+            # TODO: rework
+            analyzed = self.anal_type(item_type, allow_typed_dict_special_forms=True)
+            if isinstance(analyzed, RequiredType):
+                if analyzed.required:
+                    req_keys.add(item_name)
+                analyzed = analyzed.item
+            else:
+                # Keys are required by default.
+                req_keys.add(item_name)
+            if isinstance(analyzed, ReadOnlyType):
+                readonly_keys.add(item_name)
+                analyzed = analyzed.item
+            items[item_name] = analyzed
+        if t.fallback.type is MISSING_FALLBACK:  # anonymous/inline TypedDict
+            if INLINE_TYPEDDICT not in self.options.enable_incomplete_feature:
+                self.fail(
+                    "Inline TypedDict is experimental,"
+                    " must be enabled with --enable-incomplete-feature=InlineTypedDict",
+                    t,
+                )
+            required_keys = req_keys
+            fallback = self.named_type("typing._TypedDict")
+            for typ in t.extra_items_from:
+                analyzed = self.analyze_type(typ)
+                p_analyzed = get_proper_type(analyzed)
+                if not isinstance(p_analyzed, TypedDictType):
+                    if not isinstance(p_analyzed, (AnyType, PlaceholderType)):
+                        self.fail("Can only merge-in other TypedDict", t, code=codes.VALID_TYPE)
+                    continue
+                for sub_item_name, sub_item_type in p_analyzed.items.items():
+                    if sub_item_name in items:
+                        self.fail(TYPEDDICT_OVERRIDE_MERGE.format(sub_item_name), t)
+                        continue
+                    items[sub_item_name] = sub_item_type
+                    if sub_item_name in p_analyzed.required_keys:
+                        req_keys.add(sub_item_name)
+                    if sub_item_name in p_analyzed.readonly_keys:
+                        readonly_keys.add(sub_item_name)
+        else:
+            required_keys = t.required_keys
+            fallback = t.fallback
+        return TypedDictType(items, required_keys, readonly_keys, fallback, t.line, t.column)
 
     def visit_raw_expression_type(self, t: RawExpressionType) -> Type:
         # We should never see a bare Literal. We synthesize these raw literals
@@ -1100,13 +1409,13 @@ def visit_union_type(self, t: UnionType) -> Type:
             and not self.options.python_version >= (3, 10)
         ):
             self.fail("X | Y syntax for unions requires Python 3.10", t, code=codes.SYNTAX)
-        return UnionType(self.anal_array(t.items), t.line)
+        return UnionType(self.anal_array(t.items), t.line, uses_pep604_syntax=t.uses_pep604_syntax)
 
     def visit_partial_type(self, t: PartialType) -> Type:
         assert False, "Internal error: Unexpected partial type"
 
     def visit_ellipsis_type(self, t: EllipsisType) -> Type:
-        if self.allow_param_spec_literals:
+        if self.allow_ellipsis or self.allow_param_spec_literals:
             any_type = AnyType(TypeOfAny.explicit)
             return Parameters(
                 [any_type, any_type], [ARG_STAR, ARG_STAR2], [None, None], is_ellipsis_args=True
@@ -1132,7 +1441,7 @@ def visit_placeholder_type(self, t: PlaceholderType) -> Type:
         else:
             # TODO: Handle non-TypeInfo
             assert isinstance(n.node, TypeInfo)
-            return self.analyze_type_with_type_info(n.node, t.args, t)
+            return self.analyze_type_with_type_info(n.node, t.args, t, False)
 
     def analyze_callable_args_for_paramspec(
         self, callable_args: Type, ret_type: Type, fallback: Instance
@@ -1156,6 +1465,21 @@ def analyze_callable_args_for_paramspec(
                     AnyType(TypeOfAny.explicit), ret_type=ret_type, fallback=fallback
                 )
             return None
+        elif (
+            self.defining_alias
+            and self.not_declared_in_type_params(tvar_def.name)
+            and tvar_def not in self.allowed_alias_tvars
+        ):
+            if self.python_3_12_type_alias:
+                msg = message_registry.TYPE_PARAMETERS_SHOULD_BE_DECLARED.format(
+                    f'"{tvar_def.name}"'
+                )
+            else:
+                msg = f'ParamSpec "{tvar_def.name}" is not included in type_params'
+            self.fail(msg, callable_args, code=codes.VALID_TYPE)
+            return callable_with_ellipsis(
+                AnyType(TypeOfAny.special_form), ret_type=ret_type, fallback=fallback
+            )
 
         return CallableType(
             [
@@ -1174,7 +1498,7 @@ def analyze_callable_args_for_paramspec(
 
     def analyze_callable_args_for_concatenate(
         self, callable_args: Type, ret_type: Type, fallback: Instance
-    ) -> CallableType | None:
+    ) -> CallableType | AnyType | None:
         """Construct a 'Callable[C, RET]', where C is Concatenate[..., P], returning None if we
         cannot.
         """
@@ -1185,11 +1509,11 @@ def analyze_callable_args_for_concatenate(
             return None
         if sym.node is None:
             return None
-        if sym.node.fullname not in ("typing_extensions.Concatenate", "typing.Concatenate"):
+        if sym.node.fullname not in CONCATENATE_TYPE_NAMES:
             return None
 
         tvar_def = self.anal_type(callable_args, allow_param_spec=True)
-        if not isinstance(tvar_def, ParamSpecType):
+        if not isinstance(tvar_def, (ParamSpecType, Parameters)):
             if self.allow_unbound_tvars and isinstance(tvar_def, UnboundType):
                 sym = self.lookup_qualified(tvar_def.name, callable_args)
                 if sym is not None and isinstance(sym.node, ParamSpecExpr):
@@ -1198,7 +1522,18 @@ def analyze_callable_args_for_concatenate(
                     return callable_with_ellipsis(
                         AnyType(TypeOfAny.explicit), ret_type=ret_type, fallback=fallback
                     )
-            return None
+            # Error was already given, so prevent further errors.
+            return AnyType(TypeOfAny.from_error)
+        if isinstance(tvar_def, Parameters):
+            # This comes from Concatenate[int, ...]
+            return CallableType(
+                arg_types=tvar_def.arg_types,
+                arg_names=tvar_def.arg_names,
+                arg_kinds=tvar_def.arg_kinds,
+                ret_type=ret_type,
+                fallback=fallback,
+                from_concatenate=True,
+            )
 
         # ick, CallableType should take ParamSpecType
         prefix = tvar_def.prefix
@@ -1244,9 +1579,21 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
                 )
             else:
                 # Callable[P, RET] (where P is ParamSpec)
-                maybe_ret = self.analyze_callable_args_for_paramspec(
-                    callable_args, ret_type, fallback
-                ) or self.analyze_callable_args_for_concatenate(callable_args, ret_type, fallback)
+                with self.tvar_scope_frame(namespace=""):
+                    # Temporarily bind ParamSpecs to allow code like this:
+                    #     my_fun: Callable[Q, Foo[Q]]
+                    # We usually do this later in visit_callable_type(), but the analysis
+                    # below happens at very early stage.
+                    variables = []
+                    for name, tvar_expr in self.find_type_var_likes(callable_args):
+                        variables.append(self.tvar_scope.bind_new(name, tvar_expr))
+                    maybe_ret = self.analyze_callable_args_for_paramspec(
+                        callable_args, ret_type, fallback
+                    ) or self.analyze_callable_args_for_concatenate(
+                        callable_args, ret_type, fallback
+                    )
+                    if isinstance(maybe_ret, CallableType):
+                        maybe_ret = maybe_ret.copy_modified(variables=variables)
                 if maybe_ret is None:
                     # Callable[?, RET] (where ? is something invalid)
                     self.fail(
@@ -1256,10 +1603,12 @@ 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)
+                elif isinstance(maybe_ret, AnyType):
+                    return maybe_ret
                 ret = maybe_ret
         else:
             if self.options.disallow_any_generics:
@@ -1270,13 +1619,24 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
         assert isinstance(ret, CallableType)
         return ret.accept(self)
 
+    def refers_to_full_names(self, arg: UnboundType, names: Sequence[str]) -> bool:
+        sym = self.lookup_qualified(arg.name, arg)
+        if sym is not None:
+            if sym.fullname in names:
+                return True
+        return False
+
     def analyze_callable_args(
         self, arglist: TypeList
     ) -> tuple[list[Type], list[ArgKind], list[str | None]] | None:
         args: list[Type] = []
         kinds: list[ArgKind] = []
         names: list[str | None] = []
-        for arg in arglist.items:
+        seen_unpack = False
+        unpack_types: list[Type] = []
+        invalid_unpacks: list[Type] = []
+        second_unpack_last = False
+        for i, arg in enumerate(arglist.items):
             if isinstance(arg, CallableArgument):
                 args.append(arg.typ)
                 names.append(arg.name)
@@ -1296,20 +1656,47 @@ def analyze_callable_args(
                     if arg.name is not None and kind.is_star():
                         self.fail(f"{arg.constructor} arguments should not have names", arg)
                         return None
-            elif isinstance(arg, UnboundType):
-                kind = ARG_POS
-                # Potentially a unpack.
-                sym = self.lookup_qualified(arg.name, arg)
-                if sym is not None:
-                    if sym.fullname in ("typing_extensions.Unpack", "typing.Unpack"):
-                        kind = ARG_STAR
-                args.append(arg)
-                kinds.append(kind)
-                names.append(None)
+            elif (
+                isinstance(arg, UnboundType)
+                and self.refers_to_full_names(arg, UNPACK_TYPE_NAMES)
+                or isinstance(arg, UnpackType)
+            ):
+                if seen_unpack:
+                    # Multiple unpacks, preserve them, so we can give an error later.
+                    if i == len(arglist.items) - 1 and not invalid_unpacks:
+                        # Special case: if there are just two unpacks, and the second one appears
+                        # as last type argument, it can be still valid, if the second unpacked type
+                        # is a TypedDict. This should be checked by the caller.
+                        second_unpack_last = True
+                    invalid_unpacks.append(arg)
+                    continue
+                seen_unpack = True
+                unpack_types.append(arg)
             else:
-                args.append(arg)
-                kinds.append(ARG_POS)
-                names.append(None)
+                if seen_unpack:
+                    unpack_types.append(arg)
+                else:
+                    args.append(arg)
+                    kinds.append(ARG_POS)
+                    names.append(None)
+        if seen_unpack:
+            if len(unpack_types) == 1:
+                args.append(unpack_types[0])
+            else:
+                first = unpack_types[0]
+                if isinstance(first, UnpackType):
+                    # UnpackType doesn't have its own line/column numbers,
+                    # so use the unpacked type for error messages.
+                    first = first.type
+                args.append(
+                    UnpackType(self.tuple_type(unpack_types, line=first.line, column=first.column))
+                )
+            kinds.append(ARG_STAR)
+            names.append(None)
+        for arg in invalid_unpacks:
+            args.append(arg)
+            kinds.append(ARG_STAR2 if second_unpack_last else ARG_STAR)
+            names.append(None)
         # Note that arglist below is only used for error context.
         check_arg_names(names, [arglist] * len(args), self.fail, "Callable")
         check_arg_kinds(kinds, [arglist] * len(args), self.fail)
@@ -1331,7 +1718,11 @@ def analyze_literal_type(self, t: UnboundType) -> Type:
 
     def analyze_literal_param(self, idx: int, arg: Type, ctx: Context) -> list[Type] | None:
         # This UnboundType was originally defined as a string.
-        if isinstance(arg, UnboundType) and arg.original_str_expr is not None:
+        if (
+            isinstance(arg, ProperType)
+            and isinstance(arg, (UnboundType, UnionType))
+            and arg.original_str_expr is not None
+        ):
             assert arg.original_str_fallback is not None
             return [
                 LiteralType(
@@ -1409,8 +1800,8 @@ def analyze_literal_param(self, idx: int, arg: Type, ctx: Context) -> list[Type]
             self.fail(f"Parameter {idx} of Literal[...] is invalid", ctx, code=codes.VALID_TYPE)
             return None
 
-    def analyze_type(self, t: Type) -> Type:
-        return t.accept(self)
+    def analyze_type(self, typ: Type) -> Type:
+        return typ.accept(self)
 
     def fail(self, msg: str, ctx: Context, *, code: ErrorCode | None = None) -> None:
         self.fail_func(msg, ctx, code=code)
@@ -1419,38 +1810,38 @@ def note(self, msg: str, ctx: Context, *, code: ErrorCode | None = None) -> None
         self.note_func(msg, ctx, code=code)
 
     @contextmanager
-    def tvar_scope_frame(self) -> Iterator[None]:
+    def tvar_scope_frame(self, namespace: str) -> Iterator[None]:
         old_scope = self.tvar_scope
-        self.tvar_scope = self.tvar_scope.method_frame()
+        self.tvar_scope = self.tvar_scope.method_frame(namespace)
         yield
         self.tvar_scope = old_scope
 
-    def find_type_var_likes(self, t: Type, include_callables: bool = True) -> TypeVarLikeList:
-        return t.accept(
-            TypeVarLikeQuery(self.api, self.tvar_scope, include_callables=include_callables)
-        )
+    def find_type_var_likes(self, t: Type) -> TypeVarLikeList:
+        visitor = FindTypeVarVisitor(self.api, self.tvar_scope)
+        t.accept(visitor)
+        return visitor.type_var_likes
+
+    def infer_type_variables(
+        self, type: CallableType
+    ) -> tuple[list[tuple[str, TypeVarLikeExpr]], bool]:
+        """Infer type variables from a callable.
 
-    def infer_type_variables(self, type: CallableType) -> list[tuple[str, TypeVarLikeExpr]]:
-        """Return list of unique type variables referred to in a callable."""
-        names: list[str] = []
-        tvars: list[TypeVarLikeExpr] = []
+        Return tuple with these items:
+         - list of unique type variables referred to in a callable
+         - whether there is a reference to the Self type
+        """
+        visitor = FindTypeVarVisitor(self.api, self.tvar_scope)
         for arg in type.arg_types:
-            for name, tvar_expr in self.find_type_var_likes(arg):
-                if name not in names:
-                    names.append(name)
-                    tvars.append(tvar_expr)
+            arg.accept(visitor)
+
         # When finding type variables in the return type of a function, don't
         # look inside Callable types.  Type variables only appearing in
         # functions in the return type belong to those functions, not the
         # function we're currently analyzing.
-        for name, tvar_expr in self.find_type_var_likes(type.ret_type, include_callables=False):
-            if name not in names:
-                names.append(name)
-                tvars.append(tvar_expr)
+        visitor.include_callables = False
+        type.ret_type.accept(visitor)
 
-        if not names:
-            return []  # Fast path
-        return list(zip(names, tvars))
+        return visitor.type_var_likes, visitor.has_self_type
 
     def bind_function_type_variables(
         self, fun_type: CallableType, defn: Context
@@ -1470,10 +1861,7 @@ def bind_function_type_variables(
                 binding = self.tvar_scope.bind_new(var.name, var_expr)
                 defs.append(binding)
             return defs, has_self_type
-        typevars = self.infer_type_variables(fun_type)
-        has_self_type = find_self_type(
-            fun_type, lambda name: self.api.lookup_qualified(name, defn, suppress_errors=True)
-        )
+        typevars, has_self_type = self.infer_type_variables(fun_type)
         # Do not define a new type variable if already defined in scope.
         typevars = [
             (name, tvar) for name, tvar in typevars if not self.is_defined_type_var(name, defn)
@@ -1504,26 +1892,48 @@ def anal_array(
         *,
         allow_param_spec: bool = False,
         allow_param_spec_literals: bool = False,
+        allow_unpack: bool = False,
     ) -> list[Type]:
         old_allow_param_spec_literals = self.allow_param_spec_literals
         self.allow_param_spec_literals = allow_param_spec_literals
         res: list[Type] = []
         for t in a:
-            res.append(self.anal_type(t, nested, allow_param_spec=allow_param_spec))
+            res.append(
+                self.anal_type(
+                    t, nested, allow_param_spec=allow_param_spec, allow_unpack=allow_unpack
+                )
+            )
         self.allow_param_spec_literals = old_allow_param_spec_literals
         return self.check_unpacks_in_list(res)
 
-    def anal_type(self, t: Type, nested: bool = True, *, allow_param_spec: bool = False) -> Type:
+    def anal_type(
+        self,
+        t: Type,
+        nested: bool = True,
+        *,
+        allow_param_spec: bool = False,
+        allow_unpack: bool = False,
+        allow_ellipsis: bool = False,
+        allow_typed_dict_special_forms: bool = False,
+        allow_final: bool = False,
+    ) -> Type:
         if nested:
             self.nesting_level += 1
-        old_allow_required = self.allow_required
-        self.allow_required = False
+        old_allow_typed_dict_special_forms = self.allow_typed_dict_special_forms
+        self.allow_typed_dict_special_forms = allow_typed_dict_special_forms
+        self.allow_final = allow_final
+        old_allow_ellipsis = self.allow_ellipsis
+        self.allow_ellipsis = allow_ellipsis
+        old_allow_unpack = self.allow_unpack
+        self.allow_unpack = allow_unpack
         try:
             analyzed = t.accept(self)
         finally:
             if nested:
                 self.nesting_level -= 1
-            self.allow_required = old_allow_required
+            self.allow_typed_dict_special_forms = old_allow_typed_dict_special_forms
+            self.allow_ellipsis = old_allow_ellipsis
+            self.allow_unpack = old_allow_unpack
         if (
             not allow_param_spec
             and isinstance(analyzed, ParamSpecType)
@@ -1532,15 +1942,19 @@ def anal_type(self, t: Type, nested: bool = True, *, allow_param_spec: bool = Fa
             if analyzed.prefix.arg_types:
                 self.fail("Invalid location for Concatenate", t, code=codes.VALID_TYPE)
                 self.note("You can use Concatenate as the first argument to Callable", t)
+                analyzed = AnyType(TypeOfAny.from_error)
             else:
                 self.fail(
-                    f'Invalid location for ParamSpec "{analyzed.name}"', t, code=codes.VALID_TYPE
+                    INVALID_PARAM_SPEC_LOCATION.format(format_type(analyzed, self.options)),
+                    t,
+                    code=codes.VALID_TYPE,
                 )
                 self.note(
-                    "You can use ParamSpec as the first argument to Callable, e.g., "
-                    "'Callable[{}, int]'".format(analyzed.name),
+                    INVALID_PARAM_SPEC_LOCATION_NOTE.format(analyzed.name),
                     t,
+                    code=codes.VALID_TYPE,
                 )
+                analyzed = AnyType(TypeOfAny.from_error)
         return analyzed
 
     def anal_var_def(self, var_def: TypeVarLikeType) -> TypeVarLikeType:
@@ -1548,7 +1962,7 @@ def anal_var_def(self, var_def: TypeVarLikeType) -> TypeVarLikeType:
             return TypeVarType(
                 name=var_def.name,
                 fullname=var_def.fullname,
-                id=var_def.id.raw_id,
+                id=var_def.id,
                 values=self.anal_array(var_def.values),
                 upper_bound=var_def.upper_bound.accept(self),
                 default=var_def.default.accept(self),
@@ -1563,13 +1977,9 @@ def anal_var_defs(self, var_defs: Sequence[TypeVarLikeType]) -> list[TypeVarLike
         return [self.anal_var_def(vd) for vd in var_defs]
 
     def named_type(
-        self,
-        fully_qualified_name: str,
-        args: list[Type] | None = None,
-        line: int = -1,
-        column: int = -1,
+        self, fullname: str, args: list[Type] | None = None, line: int = -1, column: int = -1
     ) -> Instance:
-        node = self.lookup_fully_qualified(fully_qualified_name)
+        node = self.lookup_fully_qualified(fullname)
         assert isinstance(node.node, TypeInfo)
         any_type = AnyType(TypeOfAny.special_form)
         if args is not None:
@@ -1583,6 +1993,7 @@ def check_unpacks_in_list(self, items: list[Type]) -> list[Type]:
         num_unpacks = 0
         final_unpack = None
         for item in items:
+            # TODO: handle forward references here, they appear as Unpack[Any].
             if isinstance(item, UnpackType) and not isinstance(
                 get_proper_type(item.type), TupleType
             ):
@@ -1595,20 +2006,21 @@ def check_unpacks_in_list(self, items: list[Type]) -> list[Type]:
 
         if num_unpacks > 1:
             assert final_unpack is not None
-            self.fail("More than one Unpack in a type is not allowed", final_unpack)
+            self.fail("More than one Unpack in a type is not allowed", final_unpack.type)
         return new_items
 
-    def tuple_type(self, items: list[Type]) -> TupleType:
+    def tuple_type(self, items: list[Type], line: int, column: int) -> TupleType:
         any_type = AnyType(TypeOfAny.special_form)
-        return TupleType(items, fallback=self.named_type("builtins.tuple", [any_type]))
+        return TupleType(
+            items, fallback=self.named_type("builtins.tuple", [any_type]), line=line, column=column
+        )
 
 
-TypeVarLikeList = List[Tuple[str, TypeVarLikeExpr]]
+TypeVarLikeList = list[tuple[str, TypeVarLikeExpr]]
 
 
 class MsgCallback(Protocol):
-    def __call__(self, __msg: str, __ctx: Context, *, code: ErrorCode | None = None) -> None:
-        ...
+    def __call__(self, __msg: str, __ctx: Context, *, code: ErrorCode | None = None) -> None: ...
 
 
 def get_omitted_any(
@@ -1668,14 +2080,14 @@ def get_omitted_any(
     return any_type
 
 
-def fix_type_var_tuple_argument(any_type: Type, t: Instance) -> None:
+def fix_type_var_tuple_argument(t: Instance) -> None:
     if t.type.has_type_var_tuple_type:
         args = list(t.args)
         assert t.type.type_var_tuple_prefix is not None
         tvt = t.type.defn.type_vars[t.type.type_var_tuple_prefix]
         assert isinstance(tvt, TypeVarTupleType)
         args[t.type.type_var_tuple_prefix] = UnpackType(
-            Instance(tvt.tuple_fallback.type, [any_type])
+            Instance(tvt.tuple_fallback.type, [args[t.type.type_var_tuple_prefix]])
         )
         t.args = tuple(args)
 
@@ -1689,32 +2101,47 @@ def fix_instance(
     use_generic_error: bool = False,
     unexpanded_type: Type | None = None,
 ) -> None:
-    """Fix a malformed instance by replacing all type arguments with Any.
+    """Fix a malformed instance by replacing all type arguments with TypeVar default or Any.
 
     Also emit a suitable error if this is not due to implicit Any's.
     """
-    if len(t.args) == 0:
-        if use_generic_error:
-            fullname: str | None = None
-        else:
-            fullname = t.type.fullname
-        any_type = get_omitted_any(disallow_any, fail, note, t, options, fullname, unexpanded_type)
-        t.args = (any_type,) * len(t.type.type_vars)
-        fix_type_var_tuple_argument(any_type, t)
-
-        return
-    # Invalid number of type parameters.
-    fail(
-        wrong_type_arg_count(len(t.type.type_vars), str(len(t.args)), t.type.name),
-        t,
-        code=codes.TYPE_ARG,
-    )
-    # Construct the correct number of type arguments, as
-    # otherwise the type checker may crash as it expects
-    # things to be right.
-    t.args = tuple(AnyType(TypeOfAny.from_error) for _ in t.type.type_vars)
-    fix_type_var_tuple_argument(AnyType(TypeOfAny.from_error), t)
-    t.invalid = True
+    arg_count = len(t.args)
+    min_tv_count = sum(not tv.has_default() for tv in t.type.defn.type_vars)
+    max_tv_count = len(t.type.type_vars)
+    if arg_count < min_tv_count or arg_count > max_tv_count:
+        # Don't use existing args if arg_count doesn't match
+        if arg_count > max_tv_count:
+            # Already wrong arg count error, don't emit missing type parameters error as well.
+            disallow_any = False
+        t.args = ()
+        arg_count = 0
+
+    args: list[Type] = [*(t.args[:max_tv_count])]
+    any_type: AnyType | None = None
+    env: dict[TypeVarId, Type] = {}
+
+    for tv, arg in itertools.zip_longest(t.type.defn.type_vars, t.args, fillvalue=None):
+        if tv is None:
+            continue
+        if arg is None:
+            if tv.has_default():
+                arg = tv.default
+            else:
+                if any_type is None:
+                    fullname = None if use_generic_error else t.type.fullname
+                    any_type = get_omitted_any(
+                        disallow_any, fail, note, t, options, fullname, unexpanded_type
+                    )
+                arg = any_type
+            args.append(arg)
+        env[tv.id] = arg
+    t.args = tuple(args)
+    fix_type_var_tuple_argument(t)
+    if not t.type.has_type_var_tuple_type:
+        with state.strict_optional_set(options.strict_optional):
+            fixed = expand_type(t, env)
+        assert isinstance(fixed, Instance)
+        t.args = fixed.args
 
 
 def instantiate_type_alias(
@@ -1742,16 +2169,26 @@ def instantiate_type_alias(
         ctx: context where expansion happens
         unexpanded_type, disallow_any, use_standard_error: used to customize error messages
     """
-    exp_len = len(node.alias_tvars)
+    # Type aliases are special, since they can be expanded during semantic analysis,
+    # so we need to normalize them as soon as possible.
+    # TODO: can this cause an infinite recursion?
+    args = flatten_nested_tuples(args)
+    if any(unknown_unpack(a) for a in args):
+        # This type is not ready to be validated, because of unknown total count.
+        # Note that we keep the kind of Any for consistency.
+        return set_any_tvars(node, [], ctx.line, ctx.column, options, special_form=True)
+
+    max_tv_count = len(node.alias_tvars)
     act_len = len(args)
     if (
-        exp_len > 0
+        max_tv_count > 0
         and act_len == 0
         and not (empty_tuple_index and node.tvar_tuple_index is not None)
     ):
         # Interpret bare Alias same as normal generic, i.e., Alias[Any, Any, ...]
         return set_any_tvars(
             node,
+            args,
             ctx.line,
             ctx.column,
             options,
@@ -1759,7 +2196,7 @@ def instantiate_type_alias(
             fail=fail,
             unexpanded_type=unexpanded_type,
         )
-    if exp_len == 0 and act_len == 0:
+    if max_tv_count == 0 and act_len == 0:
         if no_args:
             assert isinstance(node.target, Instance)  # type: ignore[misc]
             # Note: this is the only case where we use an eager expansion. See more info about
@@ -1767,7 +2204,7 @@ def instantiate_type_alias(
             return Instance(node.target.type, [], line=ctx.line, column=ctx.column)
         return TypeAliasType(node, [], line=ctx.line, column=ctx.column)
     if (
-        exp_len == 0
+        max_tv_count == 0
         and act_len > 0
         and isinstance(node.target, Instance)  # type: ignore[misc]
         and no_args
@@ -1775,16 +2212,69 @@ def instantiate_type_alias(
         tp = Instance(node.target.type, args)
         tp.line = ctx.line
         tp.column = ctx.column
+        tp.end_line = ctx.end_line
+        tp.end_column = ctx.end_column
         return tp
-    if act_len != exp_len and node.tvar_tuple_index is None:
-        if use_standard_error:
-            # This is used if type alias is an internal representation of another type,
-            # for example a generic TypedDict or NamedTuple.
-            msg = wrong_type_arg_count(exp_len, str(act_len), node.name)
-        else:
-            msg = f"Bad number of arguments for type alias, expected: {exp_len}, given: {act_len}"
-        fail(msg, ctx, code=codes.TYPE_ARG)
-        return set_any_tvars(node, ctx.line, ctx.column, options, from_error=True)
+    if node.tvar_tuple_index is None:
+        if any(isinstance(a, UnpackType) for a in args):
+            # A variadic unpack in fixed size alias (fixed unpacks must be flattened by the caller)
+            fail(message_registry.INVALID_UNPACK_POSITION, ctx, code=codes.VALID_TYPE)
+            return set_any_tvars(node, [], ctx.line, ctx.column, options, from_error=True)
+        min_tv_count = sum(not tv.has_default() for tv in node.alias_tvars)
+        fill_typevars = act_len != max_tv_count
+        correct = min_tv_count <= act_len <= max_tv_count
+    else:
+        min_tv_count = sum(
+            not tv.has_default() and not isinstance(tv, TypeVarTupleType)
+            for tv in node.alias_tvars
+        )
+        correct = act_len >= min_tv_count
+        for a in args:
+            if isinstance(a, UnpackType):
+                unpacked = get_proper_type(a.type)
+                if isinstance(unpacked, Instance) and unpacked.type.fullname == "builtins.tuple":
+                    # Variadic tuple is always correct.
+                    correct = True
+        fill_typevars = not correct
+    if fill_typevars:
+        if not correct:
+            if use_standard_error:
+                # This is used if type alias is an internal representation of another type,
+                # for example a generic TypedDict or NamedTuple.
+                msg = wrong_type_arg_count(max_tv_count, max_tv_count, str(act_len), node.name)
+            else:
+                if node.tvar_tuple_index is not None:
+                    msg = (
+                        "Bad number of arguments for type alias,"
+                        f" expected at least {min_tv_count}, given {act_len}"
+                    )
+                elif min_tv_count != max_tv_count:
+                    msg = (
+                        "Bad number of arguments for type alias,"
+                        f" expected between {min_tv_count} and {max_tv_count}, given {act_len}"
+                    )
+                else:
+                    msg = (
+                        "Bad number of arguments for type alias,"
+                        f" expected {min_tv_count}, given {act_len}"
+                    )
+            fail(msg, ctx, code=codes.TYPE_ARG)
+            args = []
+        return set_any_tvars(node, args, ctx.line, ctx.column, options, from_error=True)
+    elif node.tvar_tuple_index is not None:
+        # We also need to check if we are not performing a type variable tuple split.
+        unpack = find_unpack_in_list(args)
+        if unpack is not None:
+            unpack_arg = args[unpack]
+            assert isinstance(unpack_arg, UnpackType)
+            if isinstance(unpack_arg.type, TypeVarTupleType):
+                exp_prefix = node.tvar_tuple_index
+                act_prefix = unpack
+                exp_suffix = len(node.alias_tvars) - node.tvar_tuple_index - 1
+                act_suffix = len(args) - unpack - 1
+                if act_prefix < exp_prefix or act_suffix < exp_suffix:
+                    fail("TypeVarTuple cannot be split", ctx, code=codes.TYPE_ARG)
+                    return set_any_tvars(node, [], ctx.line, ctx.column, options, from_error=True)
     # TODO: we need to check args validity w.r.t alias.alias_tvars.
     # Otherwise invalid instantiations will be allowed in runtime context.
     # Note: in type context, these will be still caught by semanal_typeargs.
@@ -1803,20 +2293,51 @@ def instantiate_type_alias(
 
 def set_any_tvars(
     node: TypeAlias,
+    args: list[Type],
     newline: int,
     newcolumn: int,
     options: Options,
     *,
     from_error: bool = False,
     disallow_any: bool = False,
+    special_form: bool = False,
     fail: MsgCallback | None = None,
     unexpanded_type: Type | None = None,
 ) -> TypeAliasType:
     if from_error or disallow_any:
         type_of_any = TypeOfAny.from_error
+    elif special_form:
+        type_of_any = TypeOfAny.special_form
     else:
         type_of_any = TypeOfAny.from_omitted_generics
-    if disallow_any and node.alias_tvars:
+    any_type = AnyType(type_of_any, line=newline, column=newcolumn)
+
+    env: dict[TypeVarId, Type] = {}
+    used_any_type = False
+    has_type_var_tuple_type = False
+    for tv, arg in itertools.zip_longest(node.alias_tvars, args, fillvalue=None):
+        if tv is None:
+            continue
+        if arg is None:
+            if tv.has_default():
+                arg = tv.default
+            else:
+                arg = any_type
+                used_any_type = True
+            if isinstance(tv, TypeVarTupleType):
+                # TODO Handle TypeVarTuple defaults
+                has_type_var_tuple_type = True
+                arg = UnpackType(Instance(tv.tuple_fallback.type, [any_type]))
+            args.append(arg)
+        env[tv.id] = arg
+    t = TypeAliasType(node, args, newline, newcolumn)
+    if not has_type_var_tuple_type:
+        with state.strict_optional_set(options.strict_optional):
+            fixed = expand_type(t, env)
+        assert isinstance(fixed, TypeAliasType)
+        t.args = fixed.args
+
+    if used_any_type and disallow_any and node.alias_tvars:
         assert fail is not None
         if unexpanded_type:
             type_str = (
@@ -1832,98 +2353,7 @@ def set_any_tvars(
             Context(newline, newcolumn),
             code=codes.TYPE_ARG,
         )
-    any_type = AnyType(type_of_any, line=newline, column=newcolumn)
-
-    args: list[Type] = []
-    for tv in node.alias_tvars:
-        if isinstance(tv, TypeVarTupleType):
-            args.append(UnpackType(Instance(tv.tuple_fallback.type, [any_type])))
-        else:
-            args.append(any_type)
-    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:
-        for item in lst:
-            if item not in result:
-                result.append(item)
-    return result
-
-
-class TypeVarLikeQuery(TypeQuery[TypeVarLikeList]):
-    """Find TypeVar and ParamSpec references in an unbound type."""
-
-    def __init__(
-        self,
-        api: SemanticAnalyzerCoreInterface,
-        scope: TypeVarLikeScope,
-        *,
-        include_callables: bool = True,
-    ) -> None:
-        super().__init__(flatten_tvars)
-        self.api = api
-        self.scope = scope
-        self.include_callables = include_callables
-        # Only include type variables in type aliases args. This would be anyway
-        # that case if we expand (as target variables would be overridden with args)
-        # and it may cause infinite recursion on invalid (diverging) recursive aliases.
-        self.skip_alias_target = True
-
-    def _seems_like_callable(self, type: UnboundType) -> bool:
-        if not type.args:
-            return False
-        return isinstance(type.args[0], (EllipsisType, TypeList, ParamSpecType))
-
-    def visit_unbound_type(self, t: UnboundType) -> TypeVarLikeList:
-        name = t.name
-        node = None
-        # Special case P.args and P.kwargs for ParamSpecs only.
-        if name.endswith("args"):
-            if name.endswith(".args") or name.endswith(".kwargs"):
-                base = ".".join(name.split(".")[:-1])
-                n = self.api.lookup_qualified(base, t)
-                if n is not None and isinstance(n.node, ParamSpecExpr):
-                    node = n
-                    name = base
-        if node is None:
-            node = self.api.lookup_qualified(name, t)
-        if (
-            node
-            and isinstance(node.node, TypeVarLikeExpr)
-            and self.scope.get_binding(node) is None
-        ):
-            assert isinstance(node.node, TypeVarLikeExpr)
-            return [(name, node.node)]
-        elif not self.include_callables and self._seems_like_callable(t):
-            return []
-        elif node and node.fullname in LITERAL_TYPE_NAMES:
-            return []
-        elif node and node.fullname in ANNOTATED_TYPE_NAMES and t.args:
-            # Don't query the second argument to Annotated for TypeVars
-            return self.query_types([t.args[0]])
-        else:
-            return super().visit_unbound_type(t)
-
-    def visit_callable_type(self, t: CallableType) -> TypeVarLikeList:
-        if self.include_callables:
-            return super().visit_callable_type(t)
-        else:
-            return []
+    return t
 
 
 class DivergingAliasDetector(TrivialSyntheticTypeTranslator):
@@ -1936,6 +2366,7 @@ def __init__(
         lookup: Callable[[str, Context], SymbolTableNode | None],
         scope: TypeVarLikeScope,
     ) -> None:
+        super().__init__()
         self.seen_nodes = seen_nodes
         self.lookup = lookup
         self.scope = scope
@@ -2042,7 +2473,7 @@ def collect_all_inner_types(t: Type) -> list[Type]:
     return t.accept(CollectAllInnerTypesQuery())
 
 
-class CollectAllInnerTypesQuery(TypeQuery[List[Type]]):
+class CollectAllInnerTypesQuery(TypeQuery[list[Type]]):
     def __init__(self) -> None:
         super().__init__(self.combine_lists_strategy)
 
@@ -2061,47 +2492,86 @@ def make_optional_type(t: Type) -> Type:
     is called during semantic analysis and simplification only works during
     type checking.
     """
-    p_t = get_proper_type(t)
-    if isinstance(p_t, NoneType):
+    if isinstance(t, ProperType) and isinstance(t, NoneType):
         return t
-    elif isinstance(p_t, UnionType):
+    elif isinstance(t, ProperType) and isinstance(t, UnionType):
         # Eagerly expanding aliases is not safe during semantic analysis.
-        items = [
-            item
-            for item in flatten_nested_unions(p_t.items, handle_type_alias_type=False)
-            if not isinstance(get_proper_type(item), NoneType)
-        ]
+        items = [item for item in t.items if not isinstance(get_proper_type(item), NoneType)]
         return UnionType(items + [NoneType()], t.line, t.column)
     else:
         return UnionType([t, NoneType()], t.line, t.column)
 
 
-def fix_instance_types(t: Type, fail: MsgCallback, note: MsgCallback, options: Options) -> None:
-    """Recursively fix all instance types (type argument count) in a given type.
-
-    For example 'Union[Dict, List[str, int]]' will be transformed into
-    'Union[Dict[Any, Any], List[Any]]' in place.
-    """
-    t.accept(InstanceFixer(fail, note, options))
-
-
-class InstanceFixer(TypeTraverserVisitor):
-    def __init__(self, fail: MsgCallback, note: MsgCallback, options: Options) -> None:
-        self.fail = fail
-        self.note = note
-        self.options = options
-
-    def visit_instance(self, typ: Instance) -> None:
-        super().visit_instance(typ)
-        if len(typ.args) != len(typ.type.type_vars) and not typ.type.has_type_var_tuple_type:
-            fix_instance(
-                typ,
-                self.fail,
-                self.note,
-                disallow_any=False,
-                options=self.options,
-                use_generic_error=True,
+def validate_instance(t: Instance, fail: MsgCallback, empty_tuple_index: bool) -> bool:
+    """Check if this is a well-formed instance with respect to argument count/positions."""
+    # TODO: combine logic with instantiate_type_alias().
+    if any(unknown_unpack(a) for a in t.args):
+        # This type is not ready to be validated, because of unknown total count.
+        # TODO: is it OK to fill with TypeOfAny.from_error instead of special form?
+        return False
+    if t.type.has_type_var_tuple_type:
+        min_tv_count = sum(
+            not tv.has_default() and not isinstance(tv, TypeVarTupleType)
+            for tv in t.type.defn.type_vars
+        )
+        correct = len(t.args) >= min_tv_count
+        if any(
+            isinstance(a, UnpackType) and isinstance(get_proper_type(a.type), Instance)
+            for a in t.args
+        ):
+            correct = True
+        if not t.args:
+            if not (empty_tuple_index and len(t.type.type_vars) == 1):
+                # The Any arguments should be set by the caller.
+                if empty_tuple_index and min_tv_count:
+                    fail(
+                        f"At least {min_tv_count} type argument(s) expected, none given",
+                        t,
+                        code=codes.TYPE_ARG,
+                    )
+                return False
+        elif not correct:
+            fail(
+                f"Bad number of arguments, expected: at least {min_tv_count}, given: {len(t.args)}",
+                t,
+                code=codes.TYPE_ARG,
+            )
+            return False
+        else:
+            # We also need to check if we are not performing a type variable tuple split.
+            unpack = find_unpack_in_list(t.args)
+            if unpack is not None:
+                unpack_arg = t.args[unpack]
+                assert isinstance(unpack_arg, UnpackType)
+                if isinstance(unpack_arg.type, TypeVarTupleType):
+                    assert t.type.type_var_tuple_prefix is not None
+                    assert t.type.type_var_tuple_suffix is not None
+                    exp_prefix = t.type.type_var_tuple_prefix
+                    act_prefix = unpack
+                    exp_suffix = t.type.type_var_tuple_suffix
+                    act_suffix = len(t.args) - unpack - 1
+                    if act_prefix < exp_prefix or act_suffix < exp_suffix:
+                        fail("TypeVarTuple cannot be split", t, code=codes.TYPE_ARG)
+                        return False
+    elif any(isinstance(a, UnpackType) for a in t.args):
+        # A variadic unpack in fixed size instance (fixed unpacks must be flattened by the caller)
+        fail(message_registry.INVALID_UNPACK_POSITION, t, code=codes.VALID_TYPE)
+        t.args = ()
+        return False
+    elif len(t.args) != len(t.type.type_vars):
+        # Invalid number of type parameters.
+        arg_count = len(t.args)
+        min_tv_count = sum(not tv.has_default() for tv in t.type.defn.type_vars)
+        max_tv_count = len(t.type.type_vars)
+        if arg_count and (arg_count < min_tv_count or arg_count > max_tv_count):
+            fail(
+                wrong_type_arg_count(min_tv_count, max_tv_count, str(arg_count), t.type.name),
+                t,
+                code=codes.TYPE_ARG,
             )
+            t.invalid = True
+        return False
+    return True
 
 
 def find_self_type(typ: Type, lookup: Callable[[str], SymbolTableNode | None]) -> bool:
@@ -2118,3 +2588,182 @@ def visit_unbound_type(self, t: UnboundType) -> bool:
         if sym and sym.fullname in SELF_TYPE_NAMES:
             return True
         return super().visit_unbound_type(t)
+
+
+def unknown_unpack(t: Type) -> bool:
+    """Check if a given type is an unpack of an unknown type.
+
+    Unfortunately, there is no robust way to distinguish forward references from
+    genuine undefined names here. But this worked well so far, although it looks
+    quite fragile.
+    """
+    if isinstance(t, UnpackType):
+        unpacked = get_proper_type(t.type)
+        if isinstance(unpacked, AnyType) and unpacked.type_of_any == TypeOfAny.special_form:
+            return True
+    return False
+
+
+class FindTypeVarVisitor(SyntheticTypeVisitor[None]):
+    """Type visitor that looks for type variable types and self types."""
+
+    def __init__(self, api: SemanticAnalyzerCoreInterface, scope: TypeVarLikeScope) -> None:
+        self.api = api
+        self.scope = scope
+        self.type_var_likes: list[tuple[str, TypeVarLikeExpr]] = []
+        self.has_self_type = False
+        self.seen_aliases: set[TypeAliasType] | None = None
+        self.include_callables = True
+
+    def _seems_like_callable(self, type: UnboundType) -> bool:
+        if not type.args:
+            return False
+        return isinstance(type.args[0], (EllipsisType, TypeList, ParamSpecType))
+
+    def visit_unbound_type(self, t: UnboundType) -> None:
+        name = t.name
+        node = self.api.lookup_qualified(name, t)
+        if node and node.fullname in SELF_TYPE_NAMES:
+            self.has_self_type = True
+        if (
+            node
+            and isinstance(node.node, TypeVarLikeExpr)
+            and self.scope.get_binding(node) is None
+        ):
+            if (name, node.node) not in self.type_var_likes:
+                self.type_var_likes.append((name, node.node))
+        elif not self.include_callables and self._seems_like_callable(t):
+            if find_self_type(
+                t, lambda name: self.api.lookup_qualified(name, t, suppress_errors=True)
+            ):
+                self.has_self_type = True
+            return
+        elif node and node.fullname in LITERAL_TYPE_NAMES:
+            return
+        elif node and node.fullname in ANNOTATED_TYPE_NAMES and t.args:
+            # Don't query the second argument to Annotated for TypeVars
+            self.process_types([t.args[0]])
+        elif t.args:
+            self.process_types(t.args)
+
+    def visit_type_list(self, t: TypeList) -> None:
+        self.process_types(t.items)
+
+    def visit_callable_argument(self, t: CallableArgument) -> None:
+        t.typ.accept(self)
+
+    def visit_any(self, t: AnyType) -> None:
+        pass
+
+    def visit_uninhabited_type(self, t: UninhabitedType) -> None:
+        pass
+
+    def visit_none_type(self, t: NoneType) -> None:
+        pass
+
+    def visit_erased_type(self, t: ErasedType) -> None:
+        pass
+
+    def visit_deleted_type(self, t: DeletedType) -> None:
+        pass
+
+    def visit_type_var(self, t: TypeVarType) -> None:
+        self.process_types([t.upper_bound, t.default] + t.values)
+
+    def visit_param_spec(self, t: ParamSpecType) -> None:
+        self.process_types([t.upper_bound, t.default])
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
+        self.process_types([t.upper_bound, t.default])
+
+    def visit_unpack_type(self, t: UnpackType) -> None:
+        self.process_types([t.type])
+
+    def visit_parameters(self, t: Parameters) -> None:
+        self.process_types(t.arg_types)
+
+    def visit_partial_type(self, t: PartialType) -> None:
+        pass
+
+    def visit_instance(self, t: Instance) -> None:
+        self.process_types(t.args)
+
+    def visit_callable_type(self, t: CallableType) -> None:
+        # FIX generics
+        self.process_types(t.arg_types)
+        t.ret_type.accept(self)
+
+    def visit_tuple_type(self, t: TupleType) -> None:
+        self.process_types(t.items)
+
+    def visit_typeddict_type(self, t: TypedDictType) -> None:
+        self.process_types(list(t.items.values()))
+
+    def visit_raw_expression_type(self, t: RawExpressionType) -> None:
+        pass
+
+    def visit_literal_type(self, t: LiteralType) -> None:
+        pass
+
+    def visit_union_type(self, t: UnionType) -> None:
+        self.process_types(t.items)
+
+    def visit_overloaded(self, t: Overloaded) -> None:
+        self.process_types(t.items)  # type: ignore[arg-type]
+
+    def visit_type_type(self, t: TypeType) -> None:
+        t.item.accept(self)
+
+    def visit_ellipsis_type(self, t: EllipsisType) -> None:
+        pass
+
+    def visit_placeholder_type(self, t: PlaceholderType) -> None:
+        return self.process_types(t.args)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> None:
+        # Skip type aliases in already visited types to avoid infinite recursion.
+        if self.seen_aliases is None:
+            self.seen_aliases = set()
+        elif t in self.seen_aliases:
+            return
+        self.seen_aliases.add(t)
+        self.process_types(t.args)
+
+    def process_types(self, types: list[Type] | tuple[Type, ...]) -> None:
+        # Redundant type check helps mypyc.
+        if isinstance(types, list):
+            for t in types:
+                t.accept(self)
+        else:
+            for t in types:
+                t.accept(self)
+
+
+class TypeVarDefaultTranslator(TrivialSyntheticTypeTranslator):
+    """Type translate visitor that replaces UnboundTypes with in-scope TypeVars."""
+
+    def __init__(
+        self, api: SemanticAnalyzerInterface, tvar_expr_name: str, context: Context
+    ) -> None:
+        super().__init__()
+        self.api = api
+        self.tvar_expr_name = tvar_expr_name
+        self.context = context
+
+    def visit_unbound_type(self, t: UnboundType) -> Type:
+        sym = self.api.lookup_qualified(t.name, t, suppress_errors=True)
+        if sym is not None:
+            if type_var := self.api.tvar_scope.get_binding(sym):
+                return type_var
+            if isinstance(sym.node, TypeVarLikeExpr):
+                self.api.fail(
+                    f'Type parameter "{self.tvar_expr_name}" has a default type '
+                    "that refers to one or more type variables that are out of scope",
+                    self.context,
+                )
+                return AnyType(TypeOfAny.from_error)
+        return super().visit_unbound_type(t)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        # TypeAliasTypes are analyzed separately already, just return it
+        return t
diff --git a/mypy/typeops.py b/mypy/typeops.py
index ee544c6740bb..bcf946900563 100644
--- a/mypy/typeops.py
+++ b/mypy/typeops.py
@@ -8,12 +8,14 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, Iterable, List, Sequence, TypeVar, cast
+from collections.abc import Iterable, Sequence
+from typing import Any, Callable, TypeVar, cast
 
 from mypy.copytype import copy_type
 from mypy.expandtype import expand_type, expand_type_by_instance
 from mypy.maptype import map_instance_to_supertype
 from mypy.nodes import (
+    ARG_OPT,
     ARG_POS,
     ARG_STAR,
     ARG_STAR2,
@@ -25,12 +27,12 @@
     FuncItem,
     OverloadedFuncDef,
     StrExpr,
+    SymbolNode,
     TypeInfo,
     Var,
 )
 from mypy.state import state
 from mypy.types import (
-    ENUM_REMOVED_PROPS,
     AnyType,
     CallableType,
     ExtraAttrs,
@@ -39,6 +41,7 @@
     Instance,
     LiteralType,
     NoneType,
+    NormalizedCallableType,
     Overloaded,
     Parameters,
     ParamSpecType,
@@ -61,6 +64,7 @@
     get_proper_type,
     get_proper_types,
 )
+from mypy.typetraverser import TypeTraverserVisitor
 from mypy.typevars import fill_typevars
 
 
@@ -76,20 +80,24 @@ 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
 
 
 def tuple_fallback(typ: TupleType) -> Instance:
     """Return fallback type for a tuple."""
-    from mypy.join import join_type_list
-
     info = typ.partial_fallback.type
     if info.fullname != "builtins.tuple":
         return typ.partial_fallback
@@ -98,12 +106,8 @@ def tuple_fallback(typ: TupleType) -> Instance:
         if isinstance(item, UnpackType):
             unpacked_type = get_proper_type(item.type)
             if isinstance(unpacked_type, TypeVarTupleType):
-                items.append(unpacked_type.upper_bound)
-            elif isinstance(unpacked_type, TupleType):
-                # TODO: might make sense to do recursion here to support nested unpacks
-                # of tuple constants
-                items.extend(unpacked_type.items)
-            elif (
+                unpacked_type = get_proper_type(unpacked_type.upper_bound)
+            if (
                 isinstance(unpacked_type, Instance)
                 and unpacked_type.type.fullname == "builtins.tuple"
             ):
@@ -112,7 +116,13 @@ def tuple_fallback(typ: TupleType) -> Instance:
                 raise NotImplementedError
         else:
             items.append(item)
-    return Instance(info, [join_type_list(items)], extra_attrs=typ.partial_fallback.extra_attrs)
+    return Instance(
+        info,
+        # Note: flattening recursive unions is dangerous, since it can fool recursive
+        # types optimization in subtypes.py and go into infinite recursion.
+        [make_simplified_union(items, handle_recursive=False)],
+        extra_attrs=typ.partial_fallback.extra_attrs,
+    )
 
 
 def get_self_type(func: CallableType, default_self: Instance | TupleType) -> Type | None:
@@ -124,6 +134,90 @@ def get_self_type(func: CallableType, default_self: Instance | TupleType) -> Typ
         return None
 
 
+def type_object_type(info: TypeInfo, named_type: Callable[[str], Instance]) -> ProperType:
+    """Return the type of a type object.
+
+    For a generic type G with type variables T and S the type is generally of form
+
+      Callable[..., G[T, S]]
+
+    where ... are argument types for the __init__/__new__ method (without the self
+    argument). Also, the fallback type will be 'type' instead of 'function'.
+    """
+
+    # We take the type from whichever of __init__ and __new__ is first
+    # in the MRO, preferring __init__ if there is a tie.
+    init_method = info.get("__init__")
+    new_method = info.get("__new__")
+    if not init_method or not is_valid_constructor(init_method.node):
+        # Must be an invalid class definition.
+        return AnyType(TypeOfAny.from_error)
+    # There *should* always be a __new__ method except the test stubs
+    # lack it, so just copy init_method in that situation
+    new_method = new_method or init_method
+    if not is_valid_constructor(new_method.node):
+        # Must be an invalid class definition.
+        return AnyType(TypeOfAny.from_error)
+
+    # The two is_valid_constructor() checks ensure this.
+    assert isinstance(new_method.node, (SYMBOL_FUNCBASE_TYPES, Decorator))
+    assert isinstance(init_method.node, (SYMBOL_FUNCBASE_TYPES, Decorator))
+
+    init_index = info.mro.index(init_method.node.info)
+    new_index = info.mro.index(new_method.node.info)
+
+    fallback = info.metaclass_type or named_type("builtins.type")
+    if init_index < new_index:
+        method: FuncBase | Decorator = init_method.node
+        is_new = False
+    elif init_index > new_index:
+        method = new_method.node
+        is_new = True
+    else:
+        if init_method.node.info.fullname == "builtins.object":
+            # Both are defined by object.  But if we've got a bogus
+            # base class, we can't know for sure, so check for that.
+            if info.fallback_to_any:
+                # Construct a universal callable as the prototype.
+                any_type = AnyType(TypeOfAny.special_form)
+                sig = CallableType(
+                    arg_types=[any_type, any_type],
+                    arg_kinds=[ARG_STAR, ARG_STAR2],
+                    arg_names=["_args", "_kwds"],
+                    ret_type=any_type,
+                    fallback=named_type("builtins.function"),
+                )
+                return class_callable(sig, info, fallback, None, is_new=False)
+
+        # Otherwise prefer __init__ in a tie. It isn't clear that this
+        # is the right thing, but __new__ caused problems with
+        # typeshed (#5647).
+        method = init_method.node
+        is_new = False
+    # Construct callable type based on signature of __init__. Adjust
+    # return type and insert type arguments.
+    if isinstance(method, FuncBase):
+        t = function_type(method, fallback)
+    else:
+        assert isinstance(method.type, ProperType)
+        assert isinstance(method.type, FunctionLike)  # is_valid_constructor() ensures this
+        t = method.type
+    return type_object_type_from_function(t, info, method.info, fallback, is_new)
+
+
+def is_valid_constructor(n: SymbolNode | None) -> bool:
+    """Does this node represents a valid constructor method?
+
+    This includes normal functions, overloaded functions, and decorators
+    that return a callable type.
+    """
+    if isinstance(n, SYMBOL_FUNCBASE_TYPES):
+        return True
+    if isinstance(n, Decorator):
+        return isinstance(get_proper_type(n.type), FunctionLike)
+    return False
+
+
 def type_object_type_from_function(
     signature: FunctionLike, info: TypeInfo, def_info: TypeInfo, fallback: Instance, is_new: bool
 ) -> FunctionLike:
@@ -148,7 +242,14 @@ def type_object_type_from_function(
     #      ...
     #
     # We need to map B's __init__ to the type (List[T]) -> None.
-    signature = bind_self(signature, original_type=default_self, is_classmethod=is_new)
+    signature = bind_self(
+        signature,
+        original_type=default_self,
+        is_classmethod=is_new,
+        # Explicit instance self annotations have special handling in class_callable(),
+        # we don't need to bind any type variables in them if they are generic.
+        ignore_instances=True,
+    )
     signature = cast(FunctionLike, map_type_from_supertype(signature, info, def_info))
 
     special_sig: str | None = None
@@ -240,23 +341,34 @@ class C(D[E[T]], Generic[T]): ...
     return expand_type_by_instance(typ, inst_type)
 
 
-def supported_self_type(typ: ProperType) -> bool:
+def supported_self_type(
+    typ: ProperType, allow_callable: bool = True, allow_instances: bool = True
+) -> bool:
     """Is this a supported kind of explicit self-types?
 
-    Currently, this means a X or Type[X], where X is an instance or
+    Currently, this means an X or Type[X], where X is an instance or
     a type variable with an instance upper bound.
     """
     if isinstance(typ, TypeType):
         return supported_self_type(typ.item)
+    if allow_callable and isinstance(typ, CallableType):
+        # Special case: allow class callable instead of Type[...] as cls annotation,
+        # as well as callable self for callback protocols.
+        return True
     return isinstance(typ, TypeVarType) or (
-        isinstance(typ, Instance) and typ != fill_typevars(typ.type)
+        allow_instances and isinstance(typ, Instance) and typ != fill_typevars(typ.type)
     )
 
 
 F = TypeVar("F", bound=FunctionLike)
 
 
-def bind_self(method: F, original_type: Type | None = None, is_classmethod: bool = False) -> F:
+def bind_self(
+    method: F,
+    original_type: Type | None = None,
+    is_classmethod: bool = False,
+    ignore_instances: bool = False,
+) -> F:
     """Return a copy of `method`, with the type of its first parameter (usually
     self or cls) bound to original_type.
 
@@ -280,25 +392,52 @@ class B(A): pass
 
     """
     if isinstance(method, Overloaded):
-        return cast(
-            F, Overloaded([bind_self(c, original_type, is_classmethod) for c in method.items])
-        )
+        items = []
+        original_type = get_proper_type(original_type)
+        for c in method.items:
+            if isinstance(original_type, Instance):
+                # Filter based on whether declared self type can match actual object type.
+                # For example, if self has type C[int] and method is accessed on a C[str] value,
+                # omit this item. This is best effort since bind_self can be called in many
+                # contexts, and doing complete validation might trigger infinite recursion.
+                #
+                # Note that overload item filtering normally happens elsewhere. This is needed
+                # at least during constraint inference.
+                keep = is_valid_self_type_best_effort(c, original_type)
+            else:
+                keep = True
+            if keep:
+                items.append(bind_self(c, original_type, is_classmethod, ignore_instances))
+        if len(items) == 0:
+            # If no item matches, returning all items helps avoid some spurious errors
+            items = [
+                bind_self(c, original_type, is_classmethod, ignore_instances) for c in method.items
+            ]
+        return cast(F, Overloaded(items))
     assert isinstance(method, CallableType)
     func = method
     if not func.arg_types:
         # Invalid method, return something.
         return cast(F, func)
-    if func.arg_kinds[0] == ARG_STAR:
+    if func.arg_kinds[0] in (ARG_STAR, ARG_STAR2):
         # The signature is of the form 'def foo(*args, ...)'.
         # In this case we shouldn't drop the first arg,
         # since func will be absorbed by the *args.
-
         # TODO: infer bounds on the type of *args?
+
+        # In the case of **kwargs we should probably emit an error, but
+        # for now we simply skip it, to avoid crashes down the line.
         return cast(F, func)
     self_param_type = get_proper_type(func.arg_types[0])
 
-    variables: Sequence[TypeVarLikeType] = []
-    if func.variables and supported_self_type(self_param_type):
+    variables: Sequence[TypeVarLikeType]
+    # Having a def __call__(self: Callable[...], ...) can cause infinite recursion. Although
+    # this special-casing looks not very principled, there is nothing meaningful we can infer
+    # from such definition, since it is inherently indefinitely recursive.
+    allow_callable = func.name is None or not func.name.startswith("__call__ of")
+    if func.variables and supported_self_type(
+        self_param_type, allow_callable=allow_callable, allow_instances=not ignore_instances
+    ):
         from mypy.infer import infer_type_arguments
 
         if original_type is None:
@@ -306,49 +445,82 @@ class B(A): pass
             original_type = erase_to_bound(self_param_type)
         original_type = get_proper_type(original_type)
 
-        all_ids = func.type_var_ids()
-        typeargs = infer_type_arguments(all_ids, self_param_type, original_type, is_supertype=True)
+        # Find which of method type variables appear in the type of "self".
+        self_ids = {tv.id for tv in get_all_type_vars(self_param_type)}
+        self_vars = [tv for tv in func.variables if tv.id in self_ids]
+
+        # Solve for these type arguments using the actual class or instance type.
+        typeargs = infer_type_arguments(
+            self_vars, self_param_type, original_type, is_supertype=True
+        )
         if (
             is_classmethod
-            # TODO: why do we need the extra guards here?
             and any(isinstance(get_proper_type(t), UninhabitedType) for t in typeargs)
             and isinstance(original_type, (Instance, TypeVarType, TupleType))
         ):
-            # In case we call a classmethod through an instance x, fallback to type(x)
+            # In case we call a classmethod through an instance x, fallback to type(x).
             typeargs = infer_type_arguments(
-                all_ids, self_param_type, TypeType(original_type), is_supertype=True
+                self_vars, self_param_type, TypeType(original_type), is_supertype=True
             )
 
-        ids = [tid for tid in all_ids if any(tid == t.id for t in get_type_vars(self_param_type))]
-
-        # Technically, some constrains might be unsolvable, make them <nothing>.
+        # Update the method signature with the solutions found.
+        # Technically, some constraints might be unsolvable, make them Never.
         to_apply = [t if t is not None else UninhabitedType() for t in typeargs]
-
-        def expand(target: Type) -> Type:
-            return expand_type(target, {id: to_apply[all_ids.index(id)] for id in ids})
-
-        arg_types = [expand(x) for x in func.arg_types[1:]]
-        ret_type = expand(func.ret_type)
-        variables = [v for v in func.variables if v.id not in ids]
+        func = expand_type(func, {tv.id: arg for tv, arg in zip(self_vars, to_apply)})
+        variables = [v for v in func.variables if v not in self_vars]
     else:
-        arg_types = func.arg_types[1:]
-        ret_type = func.ret_type
         variables = func.variables
 
     original_type = get_proper_type(original_type)
     if isinstance(original_type, CallableType) and original_type.is_type_obj():
         original_type = TypeType.make_normalized(original_type.ret_type)
     res = func.copy_modified(
-        arg_types=arg_types,
+        arg_types=func.arg_types[1:],
         arg_kinds=func.arg_kinds[1:],
         arg_names=func.arg_names[1:],
         variables=variables,
-        ret_type=ret_type,
         bound_args=[original_type],
     )
     return cast(F, res)
 
 
+def is_valid_self_type_best_effort(c: CallableType, self_type: Instance) -> bool:
+    """Quickly check if self_type might match the self in a callable.
+
+    Avoid performing any complex type operations. This is performance-critical.
+
+    Default to returning True if we don't know (or it would be too expensive).
+    """
+    if (
+        self_type.args
+        and c.arg_types
+        and isinstance((arg_type := get_proper_type(c.arg_types[0])), Instance)
+        and c.arg_kinds[0] in (ARG_POS, ARG_OPT)
+        and arg_type.args
+        and self_type.type.fullname != "functools._SingleDispatchCallable"
+    ):
+        if self_type.type is not arg_type.type:
+            # We can't map to supertype, since it could trigger expensive checks for
+            # protocol types, so we consevatively assume this is fine.
+            return True
+
+        # Fast path: no explicit annotation on self
+        if all(
+            (
+                type(arg) is TypeVarType
+                and type(arg.upper_bound) is Instance
+                and arg.upper_bound.type.fullname == "builtins.object"
+            )
+            for arg in arg_type.args
+        ):
+            return True
+
+        from mypy.meet import is_overlapping_types
+
+        return is_overlapping_types(self_type, c.arg_types[0])
+    return True
+
+
 def erase_to_bound(t: Type) -> Type:
     # TODO: use value restrictions to produce a union?
     t = get_proper_type(t)
@@ -361,7 +533,7 @@ def erase_to_bound(t: Type) -> Type:
 
 
 def callable_corresponding_argument(
-    typ: CallableType | Parameters, model: FormalArgument
+    typ: NormalizedCallableType | Parameters, model: FormalArgument
 ) -> FormalArgument | None:
     """Return the argument a function that corresponds to `model`"""
 
@@ -414,6 +586,7 @@ def make_simplified_union(
     *,
     keep_erased: bool = False,
     contract_literals: bool = True,
+    handle_recursive: bool = True,
 ) -> ProperType:
     """Build union type with redundant union items removed.
 
@@ -439,7 +612,7 @@ def make_simplified_union(
     to_union().
     """
     # Step 1: expand all nested unions
-    items = flatten_nested_unions(items)
+    items = flatten_nested_unions(items, handle_recursive=handle_recursive)
 
     # Step 2: fast path for single item
     if len(items) == 1:
@@ -561,15 +734,18 @@ def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[
     return items
 
 
-def _get_type_special_method_bool_ret_type(t: Type) -> Type | None:
-    t = get_proper_type(t)
+def _get_type_method_ret_type(t: ProperType, *, name: str) -> Type | None:
+    # For Enum literals the ret_type can change based on the Enum
+    # we need to check the type of the enum rather than the literal
+    if isinstance(t, LiteralType) and t.is_enum_literal():
+        t = t.fallback
 
     if isinstance(t, Instance):
-        bool_method = t.type.get("__bool__")
-        if bool_method:
-            callee = get_proper_type(bool_method.type)
-            if isinstance(callee, CallableType):
-                return callee.ret_type
+        sym = t.type.get(name)
+        if sym:
+            sym_type = get_proper_type(sym.type)
+            if isinstance(sym_type, CallableType):
+                return sym_type.ret_type
 
     return None
 
@@ -592,12 +768,12 @@ def true_only(t: Type) -> ProperType:
         can_be_true_items = [item for item in new_items if item.can_be_true]
         return make_simplified_union(can_be_true_items, line=t.line, column=t.column)
     else:
-        ret_type = _get_type_special_method_bool_ret_type(t)
+        ret_type = _get_type_method_ret_type(t, name="__bool__") or _get_type_method_ret_type(
+            t, name="__len__"
+        )
 
-        if ret_type and ret_type.can_be_false and not ret_type.can_be_true:
-            new_t = copy_type(t)
-            new_t.can_be_true = False
-            return new_t
+        if ret_type and not ret_type.can_be_true:
+            return UninhabitedType(line=t.line, column=t.column)
 
         new_t = copy_type(t)
         new_t.can_be_false = False
@@ -626,13 +802,23 @@ def false_only(t: Type) -> ProperType:
         new_items = [false_only(item) for item in t.items]
         can_be_false_items = [item for item in new_items if item.can_be_false]
         return make_simplified_union(can_be_false_items, line=t.line, column=t.column)
+    elif isinstance(t, Instance) and t.type.fullname in ("builtins.str", "builtins.bytes"):
+        return LiteralType("", fallback=t)
+    elif isinstance(t, Instance) and t.type.fullname == "builtins.int":
+        return LiteralType(0, fallback=t)
     else:
-        ret_type = _get_type_special_method_bool_ret_type(t)
+        ret_type = _get_type_method_ret_type(t, name="__bool__") or _get_type_method_ret_type(
+            t, name="__len__"
+        )
 
-        if ret_type and ret_type.can_be_true and not ret_type.can_be_false:
-            new_t = copy_type(t)
-            new_t.can_be_false = False
-            return new_t
+        if ret_type:
+            if not ret_type.can_be_false:
+                return UninhabitedType(line=t.line)
+        elif isinstance(t, Instance):
+            if t.type.is_final or t.type.is_enum:
+                return UninhabitedType(line=t.line)
+        elif isinstance(t, LiteralType) and t.is_enum_literal():
+            return UninhabitedType(line=t.line)
 
         new_t = copy_type(t)
         new_t.can_be_true = False
@@ -659,8 +845,7 @@ def erase_def_to_union_or_bound(tdef: TypeVarLikeType) -> Type:
     # TODO(PEP612): fix for ParamSpecType
     if isinstance(tdef, ParamSpecType):
         return AnyType(TypeOfAny.from_error)
-    assert isinstance(tdef, TypeVarType)
-    if tdef.values:
+    if isinstance(tdef, TypeVarType) and tdef.values:
         return make_simplified_union(tdef.values)
     else:
         return tdef.upper_bound
@@ -704,7 +889,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)
@@ -856,7 +1041,7 @@ class Status(Enum):
             FAILURE = 2
             UNKNOWN = 3
 
-    ...and if we call `try_expanding_enum_to_union(Union[Color, Status], 'module.Color')`,
+    ...and if we call `try_expanding_sum_type_to_union(Union[Color, Status], 'module.Color')`,
     this function will return Literal[Color.RED, Color.BLUE, Color.YELLOW, Status].
     """
     typ = get_proper_type(typ)
@@ -866,21 +1051,17 @@ class Status(Enum):
             try_expanding_sum_type_to_union(item, target_fullname) for item in typ.relevant_items()
         ]
         return make_simplified_union(items, contract_literals=False)
-    elif isinstance(typ, Instance) and typ.type.fullname == target_fullname:
+
+    if isinstance(typ, Instance) and typ.type.fullname == target_fullname:
+        if typ.type.fullname == "builtins.bool":
+            items = [LiteralType(True, typ), LiteralType(False, typ)]
+            return make_simplified_union(items, contract_literals=False)
+
         if typ.type.is_enum:
-            new_items = []
-            for name, symbol in typ.type.names.items():
-                if not isinstance(symbol.node, Var):
-                    continue
-                # Skip these since Enum will remove it
-                if name in ENUM_REMOVED_PROPS:
-                    continue
-                new_items.append(LiteralType(name, typ))
-            return make_simplified_union(new_items, contract_literals=False)
-        elif typ.type.fullname == "builtins.bool":
-            return make_simplified_union(
-                [LiteralType(True, typ), LiteralType(False, typ)], contract_literals=False
-            )
+            items = [LiteralType(name, typ) for name in typ.type.enum_members]
+            if not items:
+                return typ
+            return make_simplified_union(items, contract_literals=False)
 
     return typ
 
@@ -888,6 +1069,8 @@ class Status(Enum):
 def try_contracting_literals_in_union(types: Sequence[Type]) -> list[ProperType]:
     """Contracts any literal types back into a sum type if possible.
 
+    Requires a flattened union and does not descend into children.
+
     Will replace the first instance of the literal with the sum type and
     remove all others.
 
@@ -905,9 +1088,11 @@ def try_contracting_literals_in_union(types: Sequence[Type]) -> list[ProperType]
             if typ.fallback.type.is_enum or isinstance(typ.value, bool):
                 if fullname not in sum_types:
                     sum_types[fullname] = (
-                        set(typ.fallback.get_enum_values())
-                        if typ.fallback.type.is_enum
-                        else {True, False},
+                        (
+                            set(typ.fallback.type.enum_members)
+                            if typ.fallback.type.is_enum
+                            else {True, False}
+                        ),
                         [],
                     )
                 literals, indexes = sum_types[fullname]
@@ -937,29 +1122,52 @@ def coerce_to_literal(typ: Type) -> Type:
         if typ.last_known_value:
             return typ.last_known_value
         elif typ.type.is_enum:
-            enum_values = typ.get_enum_values()
+            enum_values = typ.type.enum_members
             if len(enum_values) == 1:
                 return LiteralType(value=enum_values[0], fallback=typ)
     return original_type
 
 
 def get_type_vars(tp: Type) -> list[TypeVarType]:
-    return tp.accept(TypeVarExtractor())
+    return cast("list[TypeVarType]", tp.accept(TypeVarExtractor()))
+
+
+def get_all_type_vars(tp: Type) -> list[TypeVarLikeType]:
+    # TODO: should we always use this function instead of get_type_vars() above?
+    return tp.accept(TypeVarExtractor(include_all=True))
 
 
-class TypeVarExtractor(TypeQuery[List[TypeVarType]]):
-    def __init__(self) -> None:
+class TypeVarExtractor(TypeQuery[list[TypeVarLikeType]]):
+    def __init__(self, include_all: bool = False) -> None:
         super().__init__(self._merge)
+        self.include_all = include_all
 
-    def _merge(self, iter: Iterable[list[TypeVarType]]) -> list[TypeVarType]:
+    def _merge(self, iter: Iterable[list[TypeVarLikeType]]) -> list[TypeVarLikeType]:
         out = []
         for item in iter:
             out.extend(item)
         return out
 
-    def visit_type_var(self, t: TypeVarType) -> list[TypeVarType]:
+    def visit_type_var(self, t: TypeVarType) -> list[TypeVarLikeType]:
         return [t]
 
+    def visit_param_spec(self, t: ParamSpecType) -> list[TypeVarLikeType]:
+        return [t] if self.include_all else []
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> list[TypeVarLikeType]:
+        return [t] if self.include_all else []
+
+
+def freeze_all_type_vars(member_type: Type) -> None:
+    member_type.accept(FreezeTypeVarsVisitor())
+
+
+class FreezeTypeVarsVisitor(TypeTraverserVisitor):
+    def visit_callable_type(self, t: CallableType) -> None:
+        for v in t.variables:
+            v.id.meta_level = 0
+        super().visit_callable_type(t)
+
 
 def custom_special_method(typ: Type, name: str, check_all: bool = False) -> bool:
     """Does this type have a custom special method such as __format__() or __eq__()?
@@ -971,7 +1179,7 @@ def custom_special_method(typ: Type, name: str, check_all: bool = False) -> bool
         method = typ.type.get(name)
         if method and isinstance(method.node, (SYMBOL_FUNCBASE_TYPES, Decorator, Var)):
             if method.node.info:
-                return not method.node.info.fullname.startswith("builtins.")
+                return not method.node.info.fullname.startswith(("builtins.", "typing."))
         return False
     if isinstance(typ, UnionType):
         if check_all:
@@ -979,7 +1187,7 @@ def custom_special_method(typ: Type, name: str, check_all: bool = False) -> bool
         return any(custom_special_method(t, name) for t in typ.items)
     if isinstance(typ, TupleType):
         return custom_special_method(tuple_fallback(typ), name, check_all)
-    if isinstance(typ, CallableType) and typ.is_type_obj():
+    if isinstance(typ, FunctionLike) and typ.is_type_obj():
         # Look up __method__ on the metaclass for class objects.
         return custom_special_method(typ.fallback, name, check_all)
     if isinstance(typ, AnyType):
@@ -1038,10 +1246,11 @@ def fixup_partial_type(typ: Type) -> Type:
         return Instance(typ.type, [AnyType(TypeOfAny.unannotated)] * len(typ.type.type_vars))
 
 
-def get_protocol_member(left: Instance, member: str, class_obj: bool) -> ProperType | None:
+def get_protocol_member(
+    left: Instance, member: str, class_obj: bool, is_lvalue: bool = False
+) -> Type | None:
     if member == "__call__" and class_obj:
         # Special case: class objects always have __call__ that is just the constructor.
-        from mypy.checkmember import type_object_type
 
         def named_type(fullname: str) -> Instance:
             return Instance(left.type.mro[-1], [])
@@ -1055,4 +1264,13 @@ def named_type(fullname: str) -> Instance:
 
     from mypy.subtypes import find_member
 
-    return get_proper_type(find_member(member, left, left, class_obj=class_obj))
+    subtype = find_member(member, left, left, class_obj=class_obj, is_lvalue=is_lvalue)
+    if isinstance(subtype, PartialType):
+        subtype = (
+            NoneType()
+            if subtype.type is None
+            else Instance(
+                subtype.type, [AnyType(TypeOfAny.unannotated)] * len(subtype.type.type_vars)
+            )
+        )
+    return subtype
diff --git a/mypy/types.py b/mypy/types.py
index 5fbdd385826c..41a958ae93cc 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -4,20 +4,20 @@
 
 import sys
 from abc import abstractmethod
+from collections.abc import Iterable, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
     ClassVar,
-    Dict,
-    Iterable,
+    Final,
     NamedTuple,
     NewType,
-    Sequence,
     TypeVar,
     Union,
     cast,
+    overload,
 )
-from typing_extensions import Final, Self, TypeAlias as _TypeAlias, TypeGuard, overload
+from typing_extensions import Self, TypeAlias as _TypeAlias, TypeGuard
 
 import mypy.nodes
 from mypy.bogus_type import Bogus
@@ -37,7 +37,7 @@
 
 T = TypeVar("T")
 
-JsonDict: _TypeAlias = Dict[str, Any]
+JsonDict: _TypeAlias = dict[str, Any]
 
 # The set of all valid expressions that can currently be contained
 # inside of a Literal[...].
@@ -55,7 +55,7 @@
 # 1. types.LiteralType's serialize and deserialize methods: this method
 #    needs to make sure it can convert the below types into JSON and back.
 #
-# 2. types.LiteralType's 'alue_repr` method: this method is ultimately used
+# 2. types.LiteralType's 'value_repr` method: this method is ultimately used
 #    by TypeStrVisitor's visit_literal_type to generate a reasonable
 #    repr-able output.
 #
@@ -84,6 +84,15 @@
         TypeVisitor as TypeVisitor,
     )
 
+TYPE_VAR_LIKE_NAMES: Final = (
+    "typing.TypeVar",
+    "typing_extensions.TypeVar",
+    "typing.ParamSpec",
+    "typing_extensions.ParamSpec",
+    "typing.TypeVarTuple",
+    "typing_extensions.TypeVarTuple",
+)
+
 TYPED_NAMEDTUPLE_NAMES: Final = ("typing.NamedTuple", "typing_extensions.NamedTuple")
 
 # Supported names of TypedDict type constructors.
@@ -112,12 +121,24 @@
 # Supported @final decorator names.
 FINAL_DECORATOR_NAMES: Final = ("typing.final", "typing_extensions.final")
 
+# Supported @type_check_only names.
+TYPE_CHECK_ONLY_NAMES: Final = ("typing.type_check_only", "typing_extensions.type_check_only")
+
 # Supported Literal type names.
 LITERAL_TYPE_NAMES: Final = ("typing.Literal", "typing_extensions.Literal")
 
 # Supported Annotated type names.
 ANNOTATED_TYPE_NAMES: Final = ("typing.Annotated", "typing_extensions.Annotated")
 
+# Supported Concatenate type names.
+CONCATENATE_TYPE_NAMES: Final = ("typing.Concatenate", "typing_extensions.Concatenate")
+
+# Supported Unpack type names.
+UNPACK_TYPE_NAMES: Final = ("typing.Unpack", "typing_extensions.Unpack")
+
+# Supported @deprecated type names
+DEPRECATED_TYPE_NAMES: Final = ("warnings.deprecated", "typing_extensions.deprecated")
+
 # We use this constant in various places when checking `tuple` subtyping:
 TUPLE_LIKE_INSTANCE_NAMES: Final = (
     "builtins.tuple",
@@ -127,20 +148,13 @@
     "typing.Reversible",
 )
 
-REVEAL_TYPE_NAMES: Final = (
-    "builtins.reveal_type",
-    "typing.reveal_type",
-    "typing_extensions.reveal_type",
-)
+IMPORTED_REVEAL_TYPE_NAMES: Final = ("typing.reveal_type", "typing_extensions.reveal_type")
+REVEAL_TYPE_NAMES: Final = ("builtins.reveal_type", *IMPORTED_REVEAL_TYPE_NAMES)
 
 ASSERT_TYPE_NAMES: Final = ("typing.assert_type", "typing_extensions.assert_type")
 
 OVERLOAD_NAMES: Final = ("typing.overload", "typing_extensions.overload")
 
-# Attributes that can optionally be defined in the body of a subclass of
-# enum.Enum but are removed from the class __dict__ by EnumMeta.
-ENUM_REMOVED_PROPS: Final = ("_ignore_", "_order_", "__order__")
-
 NEVER_NAMES: Final = (
     "typing.NoReturn",
     "typing_extensions.NoReturn",
@@ -150,7 +164,12 @@
 )
 
 # 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",
+    "mypy_extensions.u8",
+)
 
 DATACLASS_TRANSFORM_NAMES: Final = (
     "typing.dataclass_transform",
@@ -254,7 +273,7 @@ def can_be_false_default(self) -> bool:
         return True
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
-        raise RuntimeError("Not implemented")
+        raise RuntimeError("Not implemented", type(self))
 
     def __repr__(self) -> str:
         return self.accept(TypeStrVisitor(options=Options()))
@@ -316,6 +335,7 @@ def _expand_once(self) -> Type:
             assert isinstance(self.alias.target, Instance)  # type: ignore[misc]
             return self.alias.target.copy_modified(args=self.args)
 
+        # TODO: this logic duplicates the one in expand_type_by_instance().
         if self.alias.tvar_tuple_index is None:
             mapping = {v.id: s for (v, s) in zip(self.alias.alias_tvars, self.args)}
         else:
@@ -338,7 +358,7 @@ def _expand_once(self) -> Type:
 
     def _partial_expansion(self, nothing_args: bool = False) -> tuple[ProperType, bool]:
         # Private method mostly for debugging and testing.
-        unroller = UnrollAliasVisitor(set())
+        unroller = UnrollAliasVisitor(set(), {})
         if nothing_args:
             alias = self.copy_modified(args=[UninhabitedType()] * len(self.args))
         else:
@@ -431,7 +451,7 @@ class TypeGuardedType(Type):
 
     __slots__ = ("type_guard",)
 
-    def __init__(self, type_guard: Type):
+    def __init__(self, type_guard: Type) -> None:
         super().__init__(line=type_guard.line, column=type_guard.column)
         self.type_guard = type_guard
 
@@ -457,6 +477,20 @@ def accept(self, visitor: TypeVisitor[T]) -> T:
         return self.item.accept(visitor)
 
 
+class ReadOnlyType(Type):
+    """ReadOnly[T] Only usable at top-level of a TypedDict definition."""
+
+    def __init__(self, item: Type) -> None:
+        super().__init__(line=item.line, column=item.column)
+        self.item = item
+
+    def __repr__(self) -> str:
+        return f"ReadOnly[{self.item}]"
+
+    def accept(self, visitor: TypeVisitor[T]) -> T:
+        return self.item.accept(visitor)
+
+
 class ProperType(Type):
     """Not a type alias.
 
@@ -479,7 +513,7 @@ class TypeVarId:
     # function type variables.
 
     # Metavariables are allocated unique ids starting from 1.
-    raw_id: int = 0
+    raw_id: int
 
     # Level of the variable in type inference. Currently either 0 for
     # declared types, or 1 for type inference metavariables.
@@ -488,9 +522,8 @@ class TypeVarId:
     # Class variable used for allocating fresh ids for metavariables.
     next_raw_id: ClassVar[int] = 1
 
-    # Fullname of class (or potentially function in the future) which
-    # declares this type variable (not the fullname of the TypeVar
-    # definition!), or ''
+    # Fullname of class or function/method which declares this type
+    # variable (not the fullname of the TypeVar definition!), or ''
     namespace: str
 
     def __init__(self, raw_id: int, meta_level: int = 0, *, namespace: str = "") -> None:
@@ -524,6 +557,10 @@ def __hash__(self) -> int:
     def is_meta_var(self) -> bool:
         return self.meta_level > 0
 
+    def is_self(self) -> bool:
+        # This is a special value indicating typing.Self variable.
+        return self.raw_id == 0
+
 
 class TypeVarLikeType(ProperType):
     __slots__ = ("name", "fullname", "id", "upper_bound", "default")
@@ -538,7 +575,7 @@ def __init__(
         self,
         name: str,
         fullname: str,
-        id: TypeVarId | int,
+        id: TypeVarId,
         upper_bound: Type,
         default: Type,
         line: int = -1,
@@ -547,8 +584,6 @@ def __init__(
         super().__init__(line, column)
         self.name = name
         self.fullname = fullname
-        if isinstance(id, int):
-            id = TypeVarId(id)
         self.id = id
         self.upper_bound = upper_bound
         self.default = default
@@ -585,7 +620,7 @@ def __init__(
         self,
         name: str,
         fullname: str,
-        id: TypeVarId | int,
+        id: TypeVarId,
         values: list[Type],
         upper_bound: Type,
         default: Type,
@@ -604,7 +639,7 @@ def copy_modified(
         values: Bogus[list[Type]] = _dummy,
         upper_bound: Bogus[Type] = _dummy,
         default: Bogus[Type] = _dummy,
-        id: Bogus[TypeVarId | int] = _dummy,
+        id: Bogus[TypeVarId] = _dummy,
         line: int = _dummy_int,
         column: int = _dummy_int,
         **kwargs: Any,
@@ -700,7 +735,7 @@ def __init__(
         self,
         name: str,
         fullname: str,
-        id: TypeVarId | int,
+        id: TypeVarId,
         flavor: int,
         upper_bound: Type,
         default: Type,
@@ -727,7 +762,7 @@ def with_flavor(self, flavor: int) -> ParamSpecType:
     def copy_modified(
         self,
         *,
-        id: Bogus[TypeVarId | int] = _dummy,
+        id: Bogus[TypeVarId] = _dummy,
         flavor: int = _dummy_int,
         prefix: Bogus[Parameters] = _dummy,
         default: Bogus[Type] = _dummy,
@@ -772,6 +807,7 @@ def serialize(self) -> JsonDict:
             "name": self.name,
             "fullname": self.fullname,
             "id": self.id.raw_id,
+            "namespace": self.id.namespace,
             "flavor": self.flavor,
             "upper_bound": self.upper_bound.serialize(),
             "default": self.default.serialize(),
@@ -784,7 +820,7 @@ def deserialize(cls, data: JsonDict) -> ParamSpecType:
         return ParamSpecType(
             data["name"],
             data["fullname"],
-            data["id"],
+            TypeVarId(data["id"], namespace=data["namespace"]),
             data["flavor"],
             deserialize_type(data["upper_bound"]),
             deserialize_type(data["default"]),
@@ -798,20 +834,26 @@ class TypeVarTupleType(TypeVarLikeType):
     See PEP646 for more information.
     """
 
+    __slots__ = ("tuple_fallback", "min_len")
+
     def __init__(
         self,
         name: str,
         fullname: str,
-        id: TypeVarId | int,
+        id: TypeVarId,
         upper_bound: Type,
         tuple_fallback: Instance,
         default: Type,
         *,
         line: int = -1,
         column: int = -1,
+        min_len: int = 0,
     ) -> None:
         super().__init__(name, fullname, id, upper_bound, default, line=line, column=column)
         self.tuple_fallback = tuple_fallback
+        # This value is not settable by a user. It is an internal-only thing to support
+        # len()-narrowing of variadic tuples.
+        self.min_len = min_len
 
     def serialize(self) -> JsonDict:
         assert not self.id.is_meta_var()
@@ -820,9 +862,11 @@ def serialize(self) -> JsonDict:
             "name": self.name,
             "fullname": self.fullname,
             "id": self.id.raw_id,
+            "namespace": self.id.namespace,
             "upper_bound": self.upper_bound.serialize(),
             "tuple_fallback": self.tuple_fallback.serialize(),
             "default": self.default.serialize(),
+            "min_len": self.min_len,
         }
 
     @classmethod
@@ -831,29 +875,31 @@ def deserialize(cls, data: JsonDict) -> TypeVarTupleType:
         return TypeVarTupleType(
             data["name"],
             data["fullname"],
-            data["id"],
+            TypeVarId(data["id"], namespace=data["namespace"]),
             deserialize_type(data["upper_bound"]),
             Instance.deserialize(data["tuple_fallback"]),
             deserialize_type(data["default"]),
+            min_len=data["min_len"],
         )
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         return visitor.visit_type_var_tuple(self)
 
     def __hash__(self) -> int:
-        return hash(self.id)
+        return hash((self.id, self.min_len))
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, TypeVarTupleType):
             return NotImplemented
-        return self.id == other.id
+        return self.id == other.id and self.min_len == other.min_len
 
     def copy_modified(
         self,
         *,
-        id: Bogus[TypeVarId | int] = _dummy,
+        id: Bogus[TypeVarId] = _dummy,
         upper_bound: Bogus[Type] = _dummy,
         default: Bogus[Type] = _dummy,
+        min_len: Bogus[int] = _dummy,
         **kwargs: Any,
     ) -> TypeVarTupleType:
         return TypeVarTupleType(
@@ -865,6 +911,7 @@ def copy_modified(
             self.default if default is _dummy else default,
             line=self.line,
             column=self.column,
+            min_len=self.min_len if min_len is _dummy else min_len,
         )
 
 
@@ -882,7 +929,7 @@ class UnboundType(ProperType):
 
     def __init__(
         self,
-        name: str | None,
+        name: str,
         args: Sequence[Type] | None = None,
         line: int = -1,
         column: int = -1,
@@ -894,7 +941,6 @@ def __init__(
         super().__init__(line, column)
         if not args:
             args = []
-        assert name is not None
         self.name = name
         self.args = tuple(args)
         # Should this type be wrapped in an Optional?
@@ -1038,15 +1084,22 @@ class UnpackType(ProperType):
     """Type operator Unpack from PEP646. Can be either with Unpack[]
     or unpacking * syntax.
 
-    The inner type should be either a TypeVarTuple, a constant size
-    tuple, or a variable length tuple, or a union of one of those.
+    The inner type should be either a TypeVarTuple, or a variable length tuple.
+    In an exceptional case of callable star argument it can be a fixed length tuple.
+
+    Note: the above restrictions are only guaranteed by normalizations after semantic
+    analysis, if your code needs to handle UnpackType *during* semantic analysis, it is
+    wild west, technically anything can be present in the wrapped type.
     """
 
-    __slots__ = ["type"]
+    __slots__ = ["type", "from_star_syntax"]
 
-    def __init__(self, typ: Type, line: int = -1, column: int = -1) -> None:
+    def __init__(
+        self, typ: Type, line: int = -1, column: int = -1, from_star_syntax: bool = False
+    ) -> None:
         super().__init__(line, column)
         self.type = typ
+        self.from_star_syntax = from_star_syntax
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         return visitor.visit_unpack_type(self)
@@ -1115,15 +1168,18 @@ def copy_modified(
         # Mark with Bogus because _dummy is just an object (with type Any)
         type_of_any: int = _dummy_int,
         original_any: Bogus[AnyType | None] = _dummy,
+        missing_import_name: Bogus[str | None] = _dummy,
     ) -> AnyType:
         if type_of_any == _dummy_int:
             type_of_any = self.type_of_any
         if original_any is _dummy:
             original_any = self.source_any
+        if missing_import_name is _dummy:
+            missing_import_name = self.missing_import_name
         return AnyType(
             type_of_any=type_of_any,
             source_any=original_any,
-            missing_import_name=self.missing_import_name,
+            missing_import_name=missing_import_name,
             line=self.line,
             column=self.column,
         )
@@ -1167,17 +1223,12 @@ class UninhabitedType(ProperType):
         is_subtype(UninhabitedType, T) = True
     """
 
-    __slots__ = ("ambiguous", "is_noreturn")
+    __slots__ = ("ambiguous",)
 
-    is_noreturn: bool  # Does this come from a NoReturn?  Purely for error messages.
-    # It is important to track whether this is an actual NoReturn type, or just a result
-    # of ambiguous type inference, in the latter case we don't want to mark a branch as
-    # unreachable in binder.
     ambiguous: bool  # Is this a result of inference for a variable without constraints?
 
-    def __init__(self, is_noreturn: bool = False, line: int = -1, column: int = -1) -> None:
+    def __init__(self, line: int = -1, column: int = -1) -> None:
         super().__init__(line, column)
-        self.is_noreturn = is_noreturn
         self.ambiguous = False
 
     def can_be_true_default(self) -> bool:
@@ -1196,12 +1247,12 @@ def __eq__(self, other: object) -> bool:
         return isinstance(other, UninhabitedType)
 
     def serialize(self) -> JsonDict:
-        return {".class": "UninhabitedType", "is_noreturn": self.is_noreturn}
+        return {".class": "UninhabitedType"}
 
     @classmethod
     def deserialize(cls, data: JsonDict) -> UninhabitedType:
         assert data[".class"] == "UninhabitedType"
-        return UninhabitedType(is_noreturn=data["is_noreturn"])
+        return UninhabitedType()
 
 
 class NoneType(ProperType):
@@ -1320,6 +1371,23 @@ def copy(self) -> ExtraAttrs:
     def __repr__(self) -> str:
         return f"ExtraAttrs({self.attrs!r}, {self.immutable!r}, {self.mod_name!r})"
 
+    def serialize(self) -> JsonDict:
+        return {
+            ".class": "ExtraAttrs",
+            "attrs": {k: v.serialize() for k, v in self.attrs.items()},
+            "immutable": list(self.immutable),
+            "mod_name": self.mod_name,
+        }
+
+    @classmethod
+    def deserialize(cls, data: JsonDict) -> ExtraAttrs:
+        assert data[".class"] == "ExtraAttrs"
+        return ExtraAttrs(
+            {k: deserialize_type(v) for k, v in data["attrs"].items()},
+            set(data["immutable"]),
+            data["mod_name"],
+        )
+
 
 class Instance(ProperType):
     """An instance type of form C[T1, ..., Tn].
@@ -1400,8 +1468,7 @@ def __init__(
         self._hash = -1
 
         # Additional attributes defined per instance of this type. For example modules
-        # have different attributes per instance of types.ModuleType. This is intended
-        # to be "short-lived", we don't serialize it, and even don't store as variable type.
+        # have different attributes per instance of types.ModuleType.
         self.extra_attrs = extra_attrs
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
@@ -1427,11 +1494,14 @@ def serialize(self) -> JsonDict | str:
         type_ref = self.type.fullname
         if not self.args and not self.last_known_value:
             return type_ref
-        data: JsonDict = {".class": "Instance"}
-        data["type_ref"] = type_ref
-        data["args"] = [arg.serialize() for arg in self.args]
+        data: JsonDict = {
+            ".class": "Instance",
+            "type_ref": type_ref,
+            "args": [arg.serialize() for arg in self.args],
+        }
         if self.last_known_value is not None:
             data["last_known_value"] = self.last_known_value.serialize()
+        data["extra_attrs"] = self.extra_attrs.serialize() if self.extra_attrs else None
         return data
 
     @classmethod
@@ -1450,6 +1520,8 @@ def deserialize(cls, data: JsonDict | str) -> Instance:
         inst.type_ref = data["type_ref"]  # Will be fixed up by fixup.py later.
         if "last_known_value" in data:
             inst.last_known_value = LiteralType.deserialize(data["last_known_value"])
+        if data.get("extra_attrs") is not None:
+            inst.extra_attrs = ExtraAttrs.deserialize(data["extra_attrs"])
         return inst
 
     def copy_modified(
@@ -1459,13 +1531,14 @@ def copy_modified(
         last_known_value: Bogus[LiteralType | None] = _dummy,
     ) -> Instance:
         new = Instance(
-            self.type,
-            args if args is not _dummy else self.args,
-            self.line,
-            self.column,
-            last_known_value=last_known_value
-            if last_known_value is not _dummy
-            else self.last_known_value,
+            typ=self.type,
+            args=args if args is not _dummy else self.args,
+            line=self.line,
+            column=self.column,
+            last_known_value=(
+                last_known_value if last_known_value is not _dummy else self.last_known_value
+            ),
+            extra_attrs=self.extra_attrs,
         )
         # We intentionally don't copy the extra_attrs here, so they will be erased.
         new.can_be_true = self.can_be_true
@@ -1487,16 +1560,10 @@ def is_singleton_type(self) -> bool:
         # Also make this return True if the type corresponds to NotImplemented?
         return (
             self.type.is_enum
-            and len(self.get_enum_values()) == 1
-            or self.type.fullname == "builtins.ellipsis"
+            and len(self.type.enum_members) == 1
+            or self.type.fullname in {"builtins.ellipsis", "types.EllipsisType"}
         )
 
-    def get_enum_values(self) -> list[str]:
-        """Return the list of values for an Enum."""
-        return [
-            name for name, sym in self.type.names.items() if isinstance(sym.node, mypy.nodes.Var)
-        ]
-
 
 class FunctionLike(ProperType):
     """Abstract base class for function types."""
@@ -1538,13 +1605,13 @@ class FormalArgument(NamedTuple):
     required: bool
 
 
-# TODO: should this take bound typevars too? what would this take?
-#   ex: class Z(Generic[P, T]): ...; Z[[V], V]
-# What does a typevar even mean in this context?
 class Parameters(ProperType):
     """Type that represents the parameters to a function.
 
-    Used for ParamSpec analysis."""
+    Used for ParamSpec analysis. Note that by convention we handle this
+    type as a Callable without return type, not as a "tuple with names",
+    so that it behaves contravariantly, in particular [x: int] <: [int].
+    """
 
     __slots__ = (
         "arg_types",
@@ -1552,7 +1619,10 @@ class Parameters(ProperType):
         "arg_names",
         "min_args",
         "is_ellipsis_args",
+        # TODO: variables don't really belong here, but they are used to allow hacky support
+        # for forall . Foo[[x: T], T] by capturing generic callable with ParamSpec, see #15909
         "variables",
+        "imprecise_arg_kinds",
     )
 
     def __init__(
@@ -1563,6 +1633,7 @@ def __init__(
         *,
         variables: Sequence[TypeVarLikeType] | None = None,
         is_ellipsis_args: bool = False,
+        imprecise_arg_kinds: bool = False,
         line: int = -1,
         column: int = -1,
     ) -> None:
@@ -1571,9 +1642,11 @@ def __init__(
         self.arg_kinds = arg_kinds
         self.arg_names = list(arg_names)
         assert len(arg_types) == len(arg_kinds) == len(arg_names)
+        assert not any(isinstance(t, Parameters) for t in arg_types)
         self.min_args = arg_kinds.count(ARG_POS)
         self.is_ellipsis_args = is_ellipsis_args
         self.variables = variables or []
+        self.imprecise_arg_kinds = imprecise_arg_kinds
 
     def copy_modified(
         self,
@@ -1583,6 +1656,7 @@ def copy_modified(
         *,
         variables: Bogus[Sequence[TypeVarLikeType]] = _dummy,
         is_ellipsis_args: Bogus[bool] = _dummy,
+        imprecise_arg_kinds: Bogus[bool] = _dummy,
     ) -> Parameters:
         return Parameters(
             arg_types=arg_types if arg_types is not _dummy else self.arg_types,
@@ -1592,9 +1666,14 @@ def copy_modified(
                 is_ellipsis_args if is_ellipsis_args is not _dummy else self.is_ellipsis_args
             ),
             variables=variables if variables is not _dummy else self.variables,
+            imprecise_arg_kinds=(
+                imprecise_arg_kinds
+                if imprecise_arg_kinds is not _dummy
+                else self.imprecise_arg_kinds
+            ),
         )
 
-    # the following are copied from CallableType. Is there a way to decrease code duplication?
+    # TODO: here is a lot of code duplication with Callable type, fix this.
     def var_arg(self) -> FormalArgument | None:
         """The formal argument for *args."""
         for position, (type, kind) in enumerate(zip(self.arg_types, self.arg_kinds)):
@@ -1688,6 +1767,7 @@ def serialize(self) -> JsonDict:
             "arg_kinds": [int(x.value) for x in self.arg_kinds],
             "arg_names": self.arg_names,
             "variables": [tv.serialize() for tv in self.variables],
+            "imprecise_arg_kinds": self.imprecise_arg_kinds,
         }
 
     @classmethod
@@ -1698,6 +1778,7 @@ def deserialize(cls, data: JsonDict) -> Parameters:
             [ArgKind(x) for x in data["arg_kinds"]],
             data["arg_names"],
             variables=[cast(TypeVarLikeType, deserialize_type(v)) for v in data["variables"]],
+            imprecise_arg_kinds=data["imprecise_arg_kinds"],
         )
 
     def __hash__(self) -> int:
@@ -1738,13 +1819,11 @@ class CallableType(FunctionLike):
         "definition",  # For error messages.  May be None.
         "variables",  # Type variables for a generic function
         "is_ellipsis_args",  # Is this Callable[..., t] (with literal '...')?
-        "is_classmethod_class",  # Is this callable constructed for the benefit
-        # of a classmethod's 'cls' argument?
         "implicit",  # Was this type implicitly generated instead of explicitly
         # specified by the user?
         "special_sig",  # Non-None for signatures that require special handling
-        # (currently only value is 'dict' for a signature similar to
-        # 'dict')
+        # (currently only values are 'dict' for a signature similar to
+        # 'dict' and 'partial' for a `functools.partial` evaluation)
         "from_type_type",  # Was this callable generated by analyzing Type[...]
         # instantiation?
         "bound_args",  # Bound type args, mostly unused but may be useful for
@@ -1752,8 +1831,10 @@ class CallableType(FunctionLike):
         "def_extras",  # Information about original definition we want to serialize.
         # This is used for more detailed error messages.
         "type_guard",  # T, if -> TypeGuard[T] (ret_type is bool in this case).
+        "type_is",  # T, if -> TypeIs[T] (ret_type is bool in this case).
         "from_concatenate",  # whether this callable is from a concatenate object
         # (this is used for error messages)
+        "imprecise_arg_kinds",
         "unpack_kwargs",  # Was an Unpack[...] with **kwargs used to define this callable?
     )
 
@@ -1777,11 +1858,18 @@ def __init__(
         bound_args: Sequence[Type | None] = (),
         def_extras: dict[str, Any] | None = None,
         type_guard: Type | None = None,
+        type_is: Type | None = None,
         from_concatenate: bool = False,
+        imprecise_arg_kinds: bool = False,
         unpack_kwargs: bool = False,
     ) -> None:
         super().__init__(line, column)
         assert len(arg_types) == len(arg_kinds) == len(arg_names)
+        for t, k in zip(arg_types, arg_kinds):
+            if isinstance(t, ParamSpecType):
+                assert not t.prefix.arg_types
+                # TODO: should we assert that only ARG_STAR contain ParamSpecType?
+                # See testParamSpecJoin, that relies on passing e.g `P.args` as plain argument.
         if variables is None:
             variables = []
         self.arg_types = list(arg_types)
@@ -1799,6 +1887,7 @@ def __init__(
         self.special_sig = special_sig
         self.from_type_type = from_type_type
         self.from_concatenate = from_concatenate
+        self.imprecise_arg_kinds = imprecise_arg_kinds
         if not bound_args:
             bound_args = ()
         self.bound_args = bound_args
@@ -1819,6 +1908,7 @@ def __init__(
         else:
             self.def_extras = {}
         self.type_guard = type_guard
+        self.type_is = type_is
         self.unpack_kwargs = unpack_kwargs
 
     def copy_modified(
@@ -1840,7 +1930,9 @@ def copy_modified(
         bound_args: Bogus[list[Type | None]] = _dummy,
         def_extras: Bogus[dict[str, Any]] = _dummy,
         type_guard: Bogus[Type | None] = _dummy,
+        type_is: Bogus[Type | None] = _dummy,
         from_concatenate: Bogus[bool] = _dummy,
+        imprecise_arg_kinds: Bogus[bool] = _dummy,
         unpack_kwargs: Bogus[bool] = _dummy,
     ) -> CT:
         modified = CallableType(
@@ -1863,9 +1955,15 @@ def copy_modified(
             bound_args=bound_args if bound_args is not _dummy else self.bound_args,
             def_extras=def_extras if def_extras is not _dummy else dict(self.def_extras),
             type_guard=type_guard if type_guard is not _dummy else self.type_guard,
+            type_is=type_is if type_is is not _dummy else self.type_is,
             from_concatenate=(
                 from_concatenate if from_concatenate is not _dummy else self.from_concatenate
             ),
+            imprecise_arg_kinds=(
+                imprecise_arg_kinds
+                if imprecise_arg_kinds is not _dummy
+                else self.imprecise_arg_kinds
+            ),
             unpack_kwargs=unpack_kwargs if unpack_kwargs is not _dummy else self.unpack_kwargs,
         )
         # Optimization: Only NewTypes are supported as subtypes since
@@ -2027,36 +2125,21 @@ def param_spec(self) -> ParamSpecType | None:
         if not isinstance(arg_type, ParamSpecType):
             return None
 
-        # sometimes paramspectypes are analyzed in from mysterious places,
-        # e.g. def f(prefix..., *args: P.args, **kwargs: P.kwargs) -> ...: ...
-        prefix = arg_type.prefix
-        if not prefix.arg_types:
-            # TODO: confirm that all arg kinds are positional
-            prefix = Parameters(self.arg_types[:-2], self.arg_kinds[:-2], self.arg_names[:-2])
-
+        # Prepend prefix for def f(prefix..., *args: P.args, **kwargs: P.kwargs) -> ...
+        # TODO: confirm that all arg kinds are positional
+        prefix = Parameters(self.arg_types[:-2], self.arg_kinds[:-2], self.arg_names[:-2])
         return arg_type.copy_modified(flavor=ParamSpecFlavor.BARE, prefix=prefix)
 
-    def expand_param_spec(
-        self, c: CallableType | Parameters, no_prefix: bool = False
-    ) -> CallableType:
-        variables = c.variables
-
-        if no_prefix:
-            return self.copy_modified(
-                arg_types=c.arg_types,
-                arg_kinds=c.arg_kinds,
-                arg_names=c.arg_names,
-                is_ellipsis_args=c.is_ellipsis_args,
-                variables=[*variables, *self.variables],
-            )
-        else:
-            return self.copy_modified(
-                arg_types=self.arg_types[:-2] + c.arg_types,
-                arg_kinds=self.arg_kinds[:-2] + c.arg_kinds,
-                arg_names=self.arg_names[:-2] + c.arg_names,
-                is_ellipsis_args=c.is_ellipsis_args,
-                variables=[*variables, *self.variables],
-            )
+    def normalize_trivial_unpack(self) -> None:
+        # Normalize trivial unpack in var args as *args: *tuple[X, ...] -> *args: X in place.
+        if self.is_var_arg:
+            star_index = self.arg_kinds.index(ARG_STAR)
+            star_type = self.arg_types[star_index]
+            if isinstance(star_type, UnpackType):
+                p_type = get_proper_type(star_type.type)
+                if isinstance(p_type, Instance):
+                    assert p_type.type.fullname == "builtins.tuple"
+                    self.arg_types[star_index] = p_type.args[0]
 
     def with_unpacked_kwargs(self) -> NormalizedCallableType:
         if not self.unpack_kwargs:
@@ -2079,6 +2162,72 @@ def with_unpacked_kwargs(self) -> NormalizedCallableType:
             )
         )
 
+    def with_normalized_var_args(self) -> Self:
+        var_arg = self.var_arg()
+        if not var_arg or not isinstance(var_arg.typ, UnpackType):
+            return self
+        unpacked = get_proper_type(var_arg.typ.type)
+        if not isinstance(unpacked, TupleType):
+            # Note that we don't normalize *args: *tuple[X, ...] -> *args: X,
+            # this should be done once in semanal_typeargs.py for user-defined types,
+            # and we ourselves rarely construct such type.
+            return self
+        unpack_index = find_unpack_in_list(unpacked.items)
+        if unpack_index == 0 and len(unpacked.items) > 1:
+            # Already normalized.
+            return self
+
+        # Boilerplate:
+        var_arg_index = self.arg_kinds.index(ARG_STAR)
+        types_prefix = self.arg_types[:var_arg_index]
+        kinds_prefix = self.arg_kinds[:var_arg_index]
+        names_prefix = self.arg_names[:var_arg_index]
+        types_suffix = self.arg_types[var_arg_index + 1 :]
+        kinds_suffix = self.arg_kinds[var_arg_index + 1 :]
+        names_suffix = self.arg_names[var_arg_index + 1 :]
+        no_name: str | None = None  # to silence mypy
+
+        # Now we have something non-trivial to do.
+        if unpack_index is None:
+            # Plain *Tuple[X, Y, Z] -> replace with ARG_POS completely
+            types_middle = unpacked.items
+            kinds_middle = [ARG_POS] * len(unpacked.items)
+            names_middle = [no_name] * len(unpacked.items)
+        else:
+            # *Tuple[X, *Ts, Y, Z] or *Tuple[X, *tuple[T, ...], X, Z], here
+            # we replace the prefix by ARG_POS (this is how some places expect
+            # Callables to be represented)
+            nested_unpack = unpacked.items[unpack_index]
+            assert isinstance(nested_unpack, UnpackType)
+            nested_unpacked = get_proper_type(nested_unpack.type)
+            if unpack_index == len(unpacked.items) - 1:
+                # Normalize also single item tuples like
+                #   *args: *Tuple[*tuple[X, ...]] -> *args: X
+                #   *args: *Tuple[*Ts] -> *args: *Ts
+                # This may be not strictly necessary, but these are very verbose.
+                if isinstance(nested_unpacked, Instance):
+                    assert nested_unpacked.type.fullname == "builtins.tuple"
+                    new_unpack = nested_unpacked.args[0]
+                else:
+                    if not isinstance(nested_unpacked, TypeVarTupleType):
+                        # We found a non-normalized tuple type, this means this method
+                        # is called during semantic analysis (e.g. from get_proper_type())
+                        # there is no point in normalizing callables at this stage.
+                        return self
+                    new_unpack = nested_unpack
+            else:
+                new_unpack = UnpackType(
+                    unpacked.copy_modified(items=unpacked.items[unpack_index:])
+                )
+            types_middle = unpacked.items[:unpack_index] + [new_unpack]
+            kinds_middle = [ARG_POS] * unpack_index + [ARG_STAR]
+            names_middle = [no_name] * unpack_index + [self.arg_names[var_arg_index]]
+        return self.copy_modified(
+            arg_types=types_prefix + types_middle + types_suffix,
+            arg_kinds=kinds_prefix + kinds_middle + kinds_suffix,
+            arg_names=names_prefix + names_middle + names_suffix,
+        )
+
     def __hash__(self) -> int:
         # self.is_type_obj() will fail if self.fallback.type is a FakeInfo
         if isinstance(self.fallback.type, FakeInfo):
@@ -2131,7 +2280,9 @@ def serialize(self) -> JsonDict:
             "bound_args": [(None if t is None else t.serialize()) for t in self.bound_args],
             "def_extras": dict(self.def_extras),
             "type_guard": self.type_guard.serialize() if self.type_guard is not None else None,
+            "type_is": (self.type_is.serialize() if self.type_is is not None else None),
             "from_concatenate": self.from_concatenate,
+            "imprecise_arg_kinds": self.imprecise_arg_kinds,
             "unpack_kwargs": self.unpack_kwargs,
         }
 
@@ -2154,7 +2305,9 @@ def deserialize(cls, data: JsonDict) -> CallableType:
             type_guard=(
                 deserialize_type(data["type_guard"]) if data["type_guard"] is not None else None
             ),
+            type_is=(deserialize_type(data["type_is"]) if data["type_is"] is not None else None),
             from_concatenate=data["from_concatenate"],
+            imprecise_arg_kinds=data["imprecise_arg_kinds"],
             unpack_kwargs=data["unpack_kwargs"],
         )
 
@@ -2278,7 +2431,18 @@ def can_be_false_default(self) -> bool:
             # Corner case: it is a `NamedTuple` with `__bool__` method defined.
             # It can be anything: both `True` and `False`.
             return True
-        return self.length() == 0
+        if self.length() == 0:
+            return True
+        if self.length() > 1:
+            return False
+        # Special case tuple[*Ts] may or may not be false.
+        item = self.items[0]
+        if not isinstance(item, UnpackType):
+            return False
+        if not isinstance(item.type, TypeVarTupleType):
+            # Non-normalized tuple[int, ...] can be false.
+            return True
+        return item.type.min_len == 0
 
     def can_be_any_bool(self) -> bool:
         return bool(
@@ -2327,14 +2491,61 @@ def copy_modified(
             items = self.items
         return TupleType(items, fallback, self.line, self.column)
 
-    def slice(self, begin: int | None, end: int | None, stride: int | None) -> TupleType:
-        return TupleType(
-            self.items[begin:end:stride],
-            self.partial_fallback,
-            self.line,
-            self.column,
-            self.implicit,
-        )
+    def slice(
+        self, begin: int | None, end: int | None, stride: int | None, *, fallback: Instance | None
+    ) -> TupleType | None:
+        if fallback is None:
+            fallback = self.partial_fallback
+
+        if stride == 0:
+            return None
+
+        if any(isinstance(t, UnpackType) for t in self.items):
+            total = len(self.items)
+            unpack_index = find_unpack_in_list(self.items)
+            assert unpack_index is not None
+            if begin is None and end is None:
+                # We special-case this to support reversing variadic tuples.
+                # General support for slicing is tricky, so we handle only simple cases.
+                if stride == -1:
+                    slice_items = self.items[::-1]
+                elif stride is None or stride == 1:
+                    slice_items = self.items
+                else:
+                    return None
+            elif (begin is None or unpack_index >= begin >= 0) and (
+                end is not None and unpack_index >= end >= 0
+            ):
+                # Start and end are in the prefix, everything works in this case.
+                slice_items = self.items[begin:end:stride]
+            elif (begin is not None and unpack_index - total < begin < 0) and (
+                end is None or unpack_index - total < end < 0
+            ):
+                # Start and end are in the suffix, everything works in this case.
+                slice_items = self.items[begin:end:stride]
+            elif (begin is None or unpack_index >= begin >= 0) and (
+                end is None or unpack_index - total < end < 0
+            ):
+                # Start in the prefix, end in the suffix, we can support only trivial strides.
+                if stride is None or stride == 1:
+                    slice_items = self.items[begin:end:stride]
+                else:
+                    return None
+            elif (begin is not None and unpack_index - total < begin < 0) and (
+                end is not None and unpack_index >= end >= 0
+            ):
+                # Start in the suffix, end in the prefix, we can support only trivial strides.
+                if stride is None or stride == -1:
+                    slice_items = self.items[begin:end:stride]
+                else:
+                    return None
+            else:
+                # TODO: there some additional cases we can support for homogeneous variadic
+                # items, we can "eat away" finite number of items.
+                return None
+        else:
+            slice_items = self.items[begin:end:stride]
+        return TupleType(slice_items, fallback, self.line, self.column, self.implicit)
 
 
 class TypedDictType(ProperType):
@@ -2357,16 +2568,28 @@ class TypedDictType(ProperType):
     TODO: The fallback structure is perhaps overly complicated.
     """
 
-    __slots__ = ("items", "required_keys", "fallback")
+    __slots__ = (
+        "items",
+        "required_keys",
+        "readonly_keys",
+        "fallback",
+        "extra_items_from",
+        "to_be_mutated",
+    )
 
     items: dict[str, Type]  # item_name -> item_type
     required_keys: set[str]
+    readonly_keys: set[str]
     fallback: Instance
 
+    extra_items_from: list[ProperType]  # only used during semantic analysis
+    to_be_mutated: bool  # only used in a plugin for `.update`, `|=`, etc
+
     def __init__(
         self,
         items: dict[str, Type],
         required_keys: set[str],
+        readonly_keys: set[str],
         fallback: Instance,
         line: int = -1,
         column: int = -1,
@@ -2374,20 +2597,31 @@ def __init__(
         super().__init__(line, column)
         self.items = items
         self.required_keys = required_keys
+        self.readonly_keys = readonly_keys
         self.fallback = fallback
         self.can_be_true = len(self.items) > 0
         self.can_be_false = len(self.required_keys) == 0
+        self.extra_items_from = []
+        self.to_be_mutated = False
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         return visitor.visit_typeddict_type(self)
 
     def __hash__(self) -> int:
-        return hash((frozenset(self.items.items()), self.fallback, frozenset(self.required_keys)))
+        return hash(
+            (
+                frozenset(self.items.items()),
+                self.fallback,
+                frozenset(self.required_keys),
+                frozenset(self.readonly_keys),
+            )
+        )
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, TypedDictType):
             return NotImplemented
-
+        if self is other:
+            return True
         return (
             frozenset(self.items.keys()) == frozenset(other.items.keys())
             and all(
@@ -2396,6 +2630,7 @@ def __eq__(self, other: object) -> bool:
             )
             and self.fallback == other.fallback
             and self.required_keys == other.required_keys
+            and self.readonly_keys == other.readonly_keys
         )
 
     def serialize(self) -> JsonDict:
@@ -2403,6 +2638,7 @@ def serialize(self) -> JsonDict:
             ".class": "TypedDictType",
             "items": [[n, t.serialize()] for (n, t) in self.items.items()],
             "required_keys": sorted(self.required_keys),
+            "readonly_keys": sorted(self.readonly_keys),
             "fallback": self.fallback.serialize(),
         }
 
@@ -2412,6 +2648,7 @@ def deserialize(cls, data: JsonDict) -> TypedDictType:
         return TypedDictType(
             {n: deserialize_type(t) for (n, t) in data["items"]},
             set(data["required_keys"]),
+            set(data["readonly_keys"]),
             Instance.deserialize(data["fallback"]),
         )
 
@@ -2433,7 +2670,9 @@ 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,
+        readonly_keys: set[str] | None = None,
     ) -> TypedDictType:
         if fallback is None:
             fallback = self.fallback
@@ -2443,7 +2682,12 @@ def copy_modified(
             items = dict(zip(self.items, item_types))
         if required_keys is None:
             required_keys = self.required_keys
-        return TypedDictType(items, required_keys, fallback, self.line, self.column)
+        if readonly_keys is None:
+            readonly_keys = self.readonly_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, readonly_keys, fallback, self.line, self.column)
 
     def create_anonymous_fallback(self) -> Instance:
         anonymous = self.as_anonymous()
@@ -2579,10 +2823,28 @@ def __init__(
         self.fallback = fallback
         self._hash = -1  # Cached hash value
 
+    # NOTE: Enum types are always truthy by default, but this can be changed
+    #       in subclasses, so we need to get the truthyness from the Enum
+    #       type rather than base it on the value (which is a non-empty
+    #       string for enums, so always truthy)
+    # TODO: We should consider moving this branch to the `can_be_true`
+    #       `can_be_false` properties instead, so the truthyness only
+    #       needs to be determined once per set of Enum literals.
+    #       However, the same can be said for `TypeAliasType` in some
+    #       cases and we only set the default based on the type it is
+    #       aliasing. So if we decide to change this, we may want to
+    #       change that as well. perf_compare output was inconclusive
+    #       but slightly favored this version, probably because we have
+    #       almost no test cases where we would redundantly compute
+    #       `can_be_false`/`can_be_true`.
     def can_be_false_default(self) -> bool:
+        if self.fallback.type.is_enum:
+            return self.fallback.can_be_false
         return not self.value
 
     def can_be_true_default(self) -> bool:
+        if self.fallback.type.is_enum:
+            return self.fallback.can_be_true
         return bool(self.value)
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
@@ -2645,13 +2907,20 @@ def is_singleton_type(self) -> bool:
 class UnionType(ProperType):
     """The union type Union[T1, ..., Tn] (at least one type argument)."""
 
-    __slots__ = ("items", "is_evaluated", "uses_pep604_syntax")
+    __slots__ = (
+        "items",
+        "is_evaluated",
+        "uses_pep604_syntax",
+        "original_str_expr",
+        "original_str_fallback",
+    )
 
     def __init__(
         self,
         items: Sequence[Type],
         line: int = -1,
         column: int = -1,
+        *,
         is_evaluated: bool = True,
         uses_pep604_syntax: bool = False,
     ) -> None:
@@ -2663,6 +2932,11 @@ def __init__(
         self.is_evaluated = is_evaluated
         # uses_pep604_syntax is True if Union uses OR syntax (X | Y)
         self.uses_pep604_syntax = uses_pep604_syntax
+        # The meaning of these two is the same as for UnboundType. A UnionType can be
+        # return by type parser from a string "A|B", and we need to be able to fall back
+        # to plain string, when such a string appears inside a Literal[...].
+        self.original_str_expr: str | None = None
+        self.original_str_fallback: str | None = None
 
     def can_be_true_default(self) -> bool:
         return any(item.can_be_true for item in self.items)
@@ -2680,13 +2954,13 @@ def __eq__(self, other: object) -> bool:
 
     @overload
     @staticmethod
-    def make_union(items: Sequence[ProperType], line: int = -1, column: int = -1) -> ProperType:
-        ...
+    def make_union(
+        items: Sequence[ProperType], line: int = -1, column: int = -1
+    ) -> ProperType: ...
 
     @overload
     @staticmethod
-    def make_union(items: Sequence[Type], line: int = -1, column: int = -1) -> Type:
-        ...
+    def make_union(items: Sequence[Type], line: int = -1, column: int = -1) -> Type: ...
 
     @staticmethod
     def make_union(items: Sequence[Type], line: int = -1, column: int = -1) -> Type:
@@ -2711,12 +2985,19 @@ def relevant_items(self) -> list[Type]:
             return [i for i in self.items if not isinstance(get_proper_type(i), NoneType)]
 
     def serialize(self) -> JsonDict:
-        return {".class": "UnionType", "items": [t.serialize() for t in self.items]}
+        return {
+            ".class": "UnionType",
+            "items": [t.serialize() for t in self.items],
+            "uses_pep604_syntax": self.uses_pep604_syntax,
+        }
 
     @classmethod
     def deserialize(cls, data: JsonDict) -> UnionType:
         assert data[".class"] == "UnionType"
-        return UnionType([deserialize_type(t) for t in data["items"]])
+        return UnionType(
+            [deserialize_type(t) for t in data["items"]],
+            uses_pep604_syntax=data["uses_pep604_syntax"],
+        )
 
 
 class PartialType(ProperType):
@@ -2898,13 +3179,11 @@ def serialize(self) -> str:
 
 
 @overload
-def get_proper_type(typ: None) -> None:
-    ...
+def get_proper_type(typ: None) -> None: ...
 
 
 @overload
-def get_proper_type(typ: Type) -> ProperType:
-    ...
+def get_proper_type(typ: Type) -> ProperType: ...
 
 
 def get_proper_type(typ: Type | None) -> ProperType | None:
@@ -2927,19 +3206,17 @@ def get_proper_type(typ: Type | None) -> ProperType | None:
 
 
 @overload
-def get_proper_types(types: list[Type] | tuple[Type, ...]) -> list[ProperType]:  # type: ignore[misc]
-    ...
+def get_proper_types(types: list[Type] | tuple[Type, ...]) -> list[ProperType]: ...
 
 
 @overload
 def get_proper_types(
-    types: list[Type | None] | tuple[Type | None, ...]
-) -> list[ProperType | None]:
-    ...
+    types: list[Type | None] | tuple[Type | None, ...],
+) -> list[ProperType | None]: ...
 
 
 def get_proper_types(
-    types: list[Type] | list[Type | None] | tuple[Type | None, ...]
+    types: list[Type] | list[Type | None] | tuple[Type | None, ...],
 ) -> list[ProperType] | list[ProperType | None]:
     if isinstance(types, list):
         typelist = types
@@ -2957,7 +3234,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 (
     ALL_STRATEGY as ALL_STRATEGY,
     ANY_STRATEGY as ANY_STRATEGY,
     BoolTypeQuery as BoolTypeQuery,
@@ -2986,43 +3263,43 @@ def __init__(self, id_mapper: IdMapper | None = None, *, options: Options) -> No
         self.any_as_dots = False
         self.options = options
 
-    def visit_unbound_type(self, t: UnboundType) -> str:
+    def visit_unbound_type(self, t: UnboundType, /) -> str:
         s = t.name + "?"
         if t.args:
             s += f"[{self.list_str(t.args)}]"
         return s
 
-    def visit_type_list(self, t: TypeList) -> str:
+    def visit_type_list(self, t: TypeList, /) -> str:
         return f"<TypeList {self.list_str(t.items)}>"
 
-    def visit_callable_argument(self, t: CallableArgument) -> str:
+    def visit_callable_argument(self, t: CallableArgument, /) -> str:
         typ = t.typ.accept(self)
         if t.name is None:
             return f"{t.constructor}({typ})"
         else:
             return f"{t.constructor}({typ}, {t.name})"
 
-    def visit_any(self, t: AnyType) -> str:
+    def visit_any(self, t: AnyType, /) -> str:
         if self.any_as_dots and t.type_of_any == TypeOfAny.special_form:
             return "..."
         return "Any"
 
-    def visit_none_type(self, t: NoneType) -> str:
+    def visit_none_type(self, t: NoneType, /) -> str:
         return "None"
 
-    def visit_uninhabited_type(self, t: UninhabitedType) -> str:
-        return "<nothing>"
+    def visit_uninhabited_type(self, t: UninhabitedType, /) -> str:
+        return "Never"
 
-    def visit_erased_type(self, t: ErasedType) -> str:
+    def visit_erased_type(self, t: ErasedType, /) -> str:
         return "<Erased>"
 
-    def visit_deleted_type(self, t: DeletedType) -> str:
+    def visit_deleted_type(self, t: DeletedType, /) -> str:
         if t.source is None:
             return "<Deleted>"
         else:
             return f"<Deleted '{t.source}'>"
 
-    def visit_instance(self, t: Instance) -> str:
+    def visit_instance(self, t: Instance, /) -> str:
         if t.last_known_value and not t.args:
             # Instances with a literal fallback should never be generic. If they are,
             # something went wrong so we fall back to showing the full Instance repr.
@@ -3036,41 +3313,33 @@ def visit_instance(self, t: Instance) -> str:
                 s += f"[{self.list_str(t.args)}, ...]"
             else:
                 s += f"[{self.list_str(t.args)}]"
+        elif t.type.has_type_var_tuple_type and len(t.type.type_vars) == 1:
+            s += "[()]"
         if self.id_mapper:
             s += f"<{self.id_mapper.id(t.type)}>"
         return s
 
-    def visit_type_var(self, t: TypeVarType) -> str:
-        if t.name is None:
-            # Anonymous type variable type (only numeric id).
-            s = f"`{t.id}"
-        else:
-            # Named type variable type.
-            s = f"{t.name}`{t.id}"
+    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:
+    def visit_param_spec(self, t: ParamSpecType, /) -> str:
         # prefixes are displayed as Concatenate
         s = ""
         if t.prefix.arg_types:
             s += f"[{self.list_str(t.prefix.arg_types)}, **"
-        if t.name is None:
-            # Anonymous type variable type (only numeric id).
-            s += f"`{t.id}"
-        else:
-            # Named type variable type.
-            s += f"{t.name_with_suffix()}`{t.id}"
+        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:
+    def visit_parameters(self, t: Parameters, /) -> str:
         # This is copied from visit_callable -- is there a way to decrease duplication?
         if t.is_ellipsis_args:
             return "..."
@@ -3099,18 +3368,13 @@ def visit_parameters(self, t: Parameters) -> str:
 
         return f"[{s}]"
 
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> str:
-        if t.name is None:
-            # Anonymous type variable type (only numeric id).
-            s = f"`{t.id}"
-        else:
-            # Named type variable type.
-            s = f"{t.name}`{t.id}"
+    def visit_type_var_tuple(self, t: TypeVarTupleType, /) -> str:
+        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:
+    def visit_callable_type(self, t: CallableType, /) -> str:
         param_spec = t.param_spec()
         if param_spec is not None:
             num_skip = 2
@@ -3118,15 +3382,16 @@ def visit_callable_type(self, t: CallableType) -> str:
             num_skip = 0
 
         s = ""
-        bare_asterisk = False
+        asterisk = False
         for i in range(len(t.arg_types) - num_skip):
             if s != "":
                 s += ", "
-            if t.arg_kinds[i].is_named() and not bare_asterisk:
+            if t.arg_kinds[i].is_named() and not asterisk:
                 s += "*, "
-                bare_asterisk = True
+                asterisk = True
             if t.arg_kinds[i] == ARG_STAR:
                 s += "*"
+                asterisk = True
             if t.arg_kinds[i] == ARG_STAR2:
                 s += "**"
             name = t.arg_names[i]
@@ -3152,6 +3417,8 @@ def visit_callable_type(self, t: CallableType) -> str:
         if not isinstance(get_proper_type(t.ret_type), NoneType):
             if t.type_guard is not None:
                 s += f" -> TypeGuard[{t.type_guard.accept(self)}]"
+            elif t.type_is is not None:
+                s += f" -> TypeIs[{t.type_is.accept(self)}]"
             else:
                 s += f" -> {t.ret_type.accept(self)}"
 
@@ -3180,14 +3447,14 @@ def visit_callable_type(self, t: CallableType) -> str:
 
         return f"def {s}"
 
-    def visit_overloaded(self, t: Overloaded) -> str:
+    def visit_overloaded(self, t: Overloaded, /) -> str:
         a = []
         for i in t.items:
             a.append(i.accept(self))
         return f"Overload({', '.join(a)})"
 
-    def visit_tuple_type(self, t: TupleType) -> str:
-        s = self.list_str(t.items)
+    def visit_tuple_type(self, t: TupleType, /) -> str:
+        s = self.list_str(t.items) or "()"
         tuple_name = "tuple" if self.options.use_lowercase_names() else "Tuple"
         if t.partial_fallback and t.partial_fallback.type:
             fallback_name = t.partial_fallback.type.fullname
@@ -3195,12 +3462,14 @@ def visit_tuple_type(self, t: TupleType) -> str:
                 return f"{tuple_name}[{s}, fallback={t.partial_fallback.accept(self)}]"
         return f"{tuple_name}[{s}]"
 
-    def visit_typeddict_type(self, t: TypedDictType) -> str:
+    def visit_typeddict_type(self, t: TypedDictType, /) -> str:
         def item_str(name: str, typ: str) -> str:
-            if name in t.required_keys:
-                return f"{name!r}: {typ}"
-            else:
-                return f"{name!r}?: {typ}"
+            modifier = ""
+            if name not in t.required_keys:
+                modifier += "?"
+            if name in t.readonly_keys:
+                modifier += "="
+            return f"{name!r}{modifier}: {typ}"
 
         s = (
             "{"
@@ -3213,32 +3482,36 @@ def item_str(name: str, typ: str) -> str:
                 prefix = repr(t.fallback.type.fullname) + ", "
         return f"TypedDict({prefix}{s})"
 
-    def visit_raw_expression_type(self, t: RawExpressionType) -> str:
+    def visit_raw_expression_type(self, t: RawExpressionType, /) -> str:
         return repr(t.literal_value)
 
-    def visit_literal_type(self, t: LiteralType) -> str:
+    def visit_literal_type(self, t: LiteralType, /) -> str:
         return f"Literal[{t.value_repr()}]"
 
-    def visit_union_type(self, t: UnionType) -> str:
+    def visit_union_type(self, t: UnionType, /) -> str:
         s = self.list_str(t.items)
         return f"Union[{s}]"
 
-    def visit_partial_type(self, t: PartialType) -> str:
+    def visit_partial_type(self, t: PartialType, /) -> str:
         if t.type is None:
             return "<partial None>"
         else:
             return "<partial {}[{}]>".format(t.type.name, ", ".join(["?"] * len(t.type.type_vars)))
 
-    def visit_ellipsis_type(self, t: EllipsisType) -> str:
+    def visit_ellipsis_type(self, t: EllipsisType, /) -> str:
         return "..."
 
-    def visit_type_type(self, t: TypeType) -> str:
-        return f"Type[{t.item.accept(self)}]"
+    def visit_type_type(self, t: TypeType, /) -> str:
+        if self.options.use_lowercase_names():
+            type_name = "type"
+        else:
+            type_name = "Type"
+        return f"{type_name}[{t.item.accept(self)}]"
 
-    def visit_placeholder_type(self, t: PlaceholderType) -> str:
+    def visit_placeholder_type(self, t: PlaceholderType, /) -> str:
         return f"<placeholder {t.fullname}>"
 
-    def visit_type_alias_type(self, t: TypeAliasType) -> str:
+    def visit_type_alias_type(self, t: TypeAliasType, /) -> str:
         if t.alias is not None:
             unrolled, recursed = t._partial_expansion()
             self.any_as_dots = recursed
@@ -3247,7 +3520,7 @@ def visit_type_alias_type(self, t: TypeAliasType) -> str:
             return type_str
         return "<alias (unfixed)>"
 
-    def visit_unpack_type(self, t: UnpackType) -> str:
+    def visit_unpack_type(self, t: UnpackType, /) -> str:
         return f"Unpack[{t.type.accept(self)}]"
 
     def list_str(self, a: Iterable[Type]) -> str:
@@ -3263,24 +3536,28 @@ def list_str(self, a: Iterable[Type]) -> str:
 class TrivialSyntheticTypeTranslator(TypeTranslator, SyntheticTypeVisitor[Type]):
     """A base class for type translators that need to be run during semantic analysis."""
 
-    def visit_placeholder_type(self, t: PlaceholderType) -> Type:
+    def visit_placeholder_type(self, t: PlaceholderType, /) -> Type:
         return t
 
-    def visit_callable_argument(self, t: CallableArgument) -> Type:
+    def visit_callable_argument(self, t: CallableArgument, /) -> Type:
         return t
 
-    def visit_ellipsis_type(self, t: EllipsisType) -> Type:
+    def visit_ellipsis_type(self, t: EllipsisType, /) -> Type:
         return t
 
-    def visit_raw_expression_type(self, t: RawExpressionType) -> Type:
+    def visit_raw_expression_type(self, t: RawExpressionType, /) -> Type:
         return t
 
-    def visit_type_list(self, t: TypeList) -> Type:
+    def visit_type_list(self, t: TypeList, /) -> Type:
         return t
 
 
 class UnrollAliasVisitor(TrivialSyntheticTypeTranslator):
-    def __init__(self, initial_aliases: set[TypeAliasType]) -> None:
+    def __init__(
+        self, initial_aliases: set[TypeAliasType], cache: dict[Type, Type] | None
+    ) -> None:
+        assert cache is not None
+        super().__init__(cache)
         self.recursed = False
         self.initial_aliases = initial_aliases
 
@@ -3292,7 +3569,7 @@ def visit_type_alias_type(self, t: TypeAliasType) -> Type:
         #     A = Tuple[B, B]
         #     B = int
         # will not be detected as recursive on the second encounter of B.
-        subvisitor = UnrollAliasVisitor(self.initial_aliases | {t})
+        subvisitor = UnrollAliasVisitor(self.initial_aliases | {t}, self.cache)
         result = get_proper_type(t).accept(subvisitor)
         if subvisitor.recursed:
             self.recursed = True
@@ -3318,8 +3595,15 @@ def visit_instance(self, typ: Instance) -> None:
         typ.column = self.column
         super().visit_instance(typ)
 
+    def visit_type_alias_type(self, typ: TypeAliasType) -> None:
+        typ.line = self.line
+        typ.column = self.column
+        super().visit_type_alias_type(typ)
+
 
 class HasTypeVars(BoolTypeQuery):
+    """Visitor for querying whether a type has a type variable component."""
+
     def __init__(self) -> None:
         super().__init__(ANY_STRATEGY)
         self.skip_alias_target = True
@@ -3397,7 +3681,7 @@ def extend_args_for_prefix_and_suffix(
 
 
 def flatten_nested_unions(
-    types: Sequence[Type], handle_type_alias_type: bool = True
+    types: Sequence[Type], *, handle_type_alias_type: bool = True, handle_recursive: bool = True
 ) -> list[Type]:
     """Flatten nested unions in a type list."""
     if not isinstance(types, list):
@@ -3411,7 +3695,13 @@ def flatten_nested_unions(
 
     flat_items: list[Type] = []
     for t in typelist:
-        tp = get_proper_type(t) if handle_type_alias_type else t
+        if handle_type_alias_type:
+            if not handle_recursive and isinstance(t, TypeAliasType) and t.is_recursive:
+                tp: Type = t
+            else:
+                tp = get_proper_type(t)
+        else:
+            tp = t
         if isinstance(tp, ProperType) and isinstance(tp, UnionType):
             flat_items.extend(
                 flatten_nested_unions(tp.items, handle_type_alias_type=handle_type_alias_type)
@@ -3422,7 +3712,21 @@ def flatten_nested_unions(
     return flat_items
 
 
-def flatten_nested_tuples(types: Sequence[Type]) -> list[Type]:
+def find_unpack_in_list(items: Sequence[Type]) -> int | None:
+    unpack_index: int | None = None
+    for i, item in enumerate(items):
+        if isinstance(item, UnpackType):
+            # We cannot fail here, so we must check this in an earlier
+            # semanal phase.
+            # Funky code here avoids mypyc narrowing the type of unpack_index.
+            old_index = unpack_index
+            assert old_index is None
+            # Don't return so that we can also sanity check there is only one.
+            unpack_index = i
+    return unpack_index
+
+
+def flatten_nested_tuples(types: Iterable[Type]) -> list[Type]:
     """Recursively flatten TupleTypes nested with Unpack.
 
     For example this will transform
@@ -3475,6 +3779,30 @@ 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
+
+
+def type_vars_as_args(type_vars: Sequence[TypeVarLikeType]) -> tuple[Type, ...]:
+    """Represent type variables as they would appear in a type argument list."""
+    args: list[Type] = []
+    for tv in type_vars:
+        if isinstance(tv, TypeVarTupleType):
+            args.append(UnpackType(tv))
+        else:
+            args.append(tv)
+    return tuple(args)
+
+
 # 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/types_utils.py b/mypy/types_utils.py
index 43bca05d6bf9..124d024e8c1e 100644
--- a/mypy/types_utils.py
+++ b/mypy/types_utils.py
@@ -8,13 +8,15 @@
 
 from __future__ import annotations
 
-from typing import Callable, Iterable, cast
+from collections.abc import Iterable
+from typing import Callable, cast
 
 from mypy.nodes import ARG_STAR, ARG_STAR2, FuncItem, TypeAlias
 from mypy.types import (
     AnyType,
     CallableType,
     Instance,
+    LiteralType,
     NoneType,
     Overloaded,
     ParamSpecType,
@@ -54,7 +56,7 @@ def strip_type(typ: Type) -> Type:
 
 
 def is_invalid_recursive_alias(seen_nodes: set[TypeAlias], target: Type) -> bool:
-    """Flag aliases like A = Union[int, A] (and similar mutual aliases).
+    """Flag aliases like A = Union[int, A], T = tuple[int, *T] (and similar mutual aliases).
 
     Such aliases don't make much sense, and cause problems in later phases.
     """
@@ -64,26 +66,44 @@ def is_invalid_recursive_alias(seen_nodes: set[TypeAlias], target: Type) -> bool
         assert target.alias, f"Unfixed type alias {target.type_ref}"
         return is_invalid_recursive_alias(seen_nodes | {target.alias}, get_proper_type(target))
     assert isinstance(target, ProperType)
-    if not isinstance(target, UnionType):
+    if not isinstance(target, (UnionType, TupleType)):
         return False
-    return any(is_invalid_recursive_alias(seen_nodes, item) for item in target.items)
+    if isinstance(target, UnionType):
+        return any(is_invalid_recursive_alias(seen_nodes, item) for item in target.items)
+    for item in target.items:
+        if isinstance(item, UnpackType):
+            if is_invalid_recursive_alias(seen_nodes, item.type):
+                return True
+    return False
 
 
-def is_bad_type_type_item(item: Type) -> bool:
+def get_bad_type_type_item(item: Type) -> str | None:
     """Prohibit types like Type[Type[...]].
 
     Such types are explicitly prohibited by PEP 484. Also, they cause problems
     with recursive types like T = Type[T], because internal representation of
     TypeType item is normalized (i.e. always a proper type).
+
+    Also forbids `Type[Literal[...]]`, because typing spec does not allow it.
     """
+    # TODO: what else cannot be present in `type[...]`?
     item = get_proper_type(item)
     if isinstance(item, TypeType):
-        return True
+        return "Type[...]"
+    if isinstance(item, LiteralType):
+        return "Literal[...]"
     if isinstance(item, UnionType):
-        return any(
-            isinstance(get_proper_type(i), TypeType) for i in flatten_nested_unions(item.items)
-        )
-    return False
+        items = [
+            bad_item
+            for typ in flatten_nested_unions(item.items)
+            if (bad_item := get_bad_type_type_item(typ)) is not None
+        ]
+        if not items:
+            return None
+        if len(items) == 1:
+            return items[0]
+        return f"Union[{', '.join(items)}]"
+    return None
 
 
 def is_union_with_any(tp: Type) -> bool:
@@ -101,10 +121,10 @@ def is_generic_instance(tp: Type) -> bool:
     return isinstance(tp, Instance) and bool(tp.args)
 
 
-def is_optional(t: Type) -> bool:
+def is_overlapping_none(t: Type) -> bool:
     t = get_proper_type(t)
-    return isinstance(t, UnionType) and any(
-        isinstance(get_proper_type(e), NoneType) for e in t.items
+    return isinstance(t, NoneType) or (
+        isinstance(t, UnionType) and any(isinstance(get_proper_type(e), NoneType) for e in t.items)
     )
 
 
@@ -138,8 +158,7 @@ def store_argument_type(
         elif isinstance(arg_type, UnpackType):
             unpacked_type = get_proper_type(arg_type.type)
             if isinstance(unpacked_type, TupleType):
-                # Instead of using Tuple[Unpack[Tuple[...]]], just use
-                # Tuple[...]
+                # Instead of using Tuple[Unpack[Tuple[...]]], just use Tuple[...]
                 arg_type = unpacked_type
             elif (
                 isinstance(unpacked_type, Instance)
@@ -147,6 +166,7 @@ def store_argument_type(
             ):
                 arg_type = unpacked_type
             else:
+                # TODO: verify that we can only have a TypeVarTuple here.
                 arg_type = TupleType(
                     [arg_type],
                     fallback=named_type("builtins.tuple", [named_type("builtins.object", [])]),
diff --git a/mypy/typeshed/stdlib/VERSIONS b/mypy/typeshed/stdlib/VERSIONS
index 86e8da78677c..3c6898dc1a77 100644
--- a/mypy/typeshed/stdlib/VERSIONS
+++ b/mypy/typeshed/stdlib/VERSIONS
@@ -1,7 +1,7 @@
 # The structure of this file is as follows:
 # - Blank lines and comments starting with `#` are ignored.
 # - Lines contain the name of a module, followed by a colon,
-#   a space, and a version range (for example: `symbol: 2.7-3.9`).
+#   a space, and a version range (for example: `symbol: 3.0-3.9`).
 #
 # Version ranges may be of the form "X.Y-A.B" or "X.Y-". The
 # first form means that a module was introduced in version X.Y and last
@@ -12,289 +12,332 @@
 # If a submodule is not listed separately, it has the same lifetime as
 # its parent module.
 #
-# Python versions before 2.7 are ignored, so any module that was already
-# present in 2.7 will have "2.7" as its minimum version. Version ranges
+# Python versions before 3.0 are ignored, so any module that was already
+# present in 3.0 will have "3.0" as its minimum version. Version ranges
 # for unsupported versions of Python 3 are generally accurate but we do
 # not guarantee their correctness.
 
-__future__: 2.7-
-__main__: 2.7-
-_ast: 2.7-
-_bisect: 2.7-
+__future__: 3.0-
+__main__: 3.0-
+_ast: 3.0-
+_asyncio: 3.0-
+_bisect: 3.0-
+_blake2: 3.6-
 _bootlocale: 3.4-3.9
-_codecs: 2.7-
+_bz2: 3.3-
+_codecs: 3.0-
 _collections_abc: 3.3-
 _compat_pickle: 3.1-
 _compression: 3.5-
-_csv: 2.7-
-_ctypes: 2.7-
-_curses: 2.7-
+_contextvars: 3.7-
+_csv: 3.0-
+_ctypes: 3.0-
+_curses: 3.0-
+_curses_panel: 3.0-
+_dbm: 3.0-
 _decimal: 3.3-
 _dummy_thread: 3.0-3.8
-_dummy_threading: 2.7-3.8
-_heapq: 2.7-
+_dummy_threading: 3.0-3.8
+_frozen_importlib: 3.0-
+_frozen_importlib_external: 3.5-
+_gdbm: 3.0-
+_hashlib: 3.0-
+_heapq: 3.0-
 _imp: 3.0-
-_json: 2.7-
-_markupbase: 2.7-
-_msi: 2.7-
+_interpchannels: 3.13-
+_interpqueues: 3.13-
+_interpreters: 3.13-
+_io: 3.0-
+_json: 3.0-
+_locale: 3.0-
+_lsprof: 3.0-
+_lzma: 3.3-
+_markupbase: 3.0-
+_msi: 3.0-3.12
+_multibytecodec: 3.0-
 _operator: 3.4-
-_osx_support: 2.7-
+_osx_support: 3.0-
+_pickle: 3.0-
 _posixsubprocess: 3.2-
 _py_abc: 3.7-
 _pydecimal: 3.5-
-_random: 2.7-
+_queue: 3.7-
+_random: 3.0-
 _sitebuiltins: 3.4-
-_socket: 3.0-  # present in 2.7 at runtime, but not in typeshed
+_socket: 3.0-  # present in 3.0 at runtime, but not in typeshed
+_sqlite3: 3.0-
+_ssl: 3.0-
 _stat: 3.4-
-_thread: 2.7-
-_threading_local: 2.7-
-_tkinter: 2.7-
+_struct: 3.0-
+_thread: 3.0-
+_threading_local: 3.0-
+_tkinter: 3.0-
 _tracemalloc: 3.4-
-_typeshed: 2.7-  # not present at runtime, only for type checking
-_warnings: 2.7-
-_weakref: 2.7-
-_weakrefset: 2.7-
+_typeshed: 3.0-  # not present at runtime, only for type checking
+_warnings: 3.0-
+_weakref: 3.0-
+_weakrefset: 3.0-
 _winapi: 3.3-
-abc: 2.7-
-aifc: 2.7-
-antigravity: 2.7-
-argparse: 2.7-
-array: 2.7-
-ast: 2.7-
-asynchat: 2.7-3.11
+abc: 3.0-
+aifc: 3.0-3.12
+antigravity: 3.0-
+argparse: 3.0-
+array: 3.0-
+ast: 3.0-
+asynchat: 3.0-3.11
 asyncio: 3.4-
-asyncio.mixins: 3.10-
 asyncio.exceptions: 3.8-
 asyncio.format_helpers: 3.7-
+asyncio.mixins: 3.10-
 asyncio.runners: 3.7-
 asyncio.staggered: 3.8-
 asyncio.taskgroups: 3.11-
 asyncio.threads: 3.9-
 asyncio.timeouts: 3.11-
 asyncio.trsock: 3.8-
-asyncore: 2.7-3.11
-atexit: 2.7-
-audioop: 2.7-
-base64: 2.7-
-bdb: 2.7-
-binascii: 2.7-
-binhex: 2.7-3.10
-bisect: 2.7-
+asyncore: 3.0-3.11
+atexit: 3.0-
+audioop: 3.0-3.12
+base64: 3.0-
+bdb: 3.0-
+binascii: 3.0-
+binhex: 3.0-3.10
+bisect: 3.0-
 builtins: 3.0-
-bz2: 2.7-
-cProfile: 2.7-
-calendar: 2.7-
-cgi: 2.7-
-cgitb: 2.7-
-chunk: 2.7-
-cmath: 2.7-
-cmd: 2.7-
-code: 2.7-
-codecs: 2.7-
-codeop: 2.7-
-collections: 2.7-
+bz2: 3.0-
+cProfile: 3.0-
+calendar: 3.0-
+cgi: 3.0-3.12
+cgitb: 3.0-3.12
+chunk: 3.0-3.12
+cmath: 3.0-
+cmd: 3.0-
+code: 3.0-
+codecs: 3.0-
+codeop: 3.0-
+collections: 3.0-
 collections.abc: 3.3-
-colorsys: 2.7-
-compileall: 2.7-
+colorsys: 3.0-
+compileall: 3.0-
 concurrent: 3.2-
 configparser: 3.0-
-contextlib: 2.7-
+contextlib: 3.0-
 contextvars: 3.7-
-copy: 2.7-
-copyreg: 2.7-
-crypt: 2.7-
-csv: 2.7-
-ctypes: 2.7-
-curses: 2.7-
+copy: 3.0-
+copyreg: 3.0-
+crypt: 3.0-3.12
+csv: 3.0-
+ctypes: 3.0-
+curses: 3.0-
 dataclasses: 3.7-
-datetime: 2.7-
-dbm: 2.7-
-decimal: 2.7-
-difflib: 2.7-
-dis: 2.7-
-distutils: 2.7-
-distutils.command.bdist_msi: 2.7-3.10
-distutils.command.bdist_wininst: 2.7-3.9
-doctest: 2.7-
-dummy_threading: 2.7-3.8
-email: 2.7-
-encodings: 2.7-
-ensurepip: 2.7-
+datetime: 3.0-
+dbm: 3.0-
+dbm.sqlite3: 3.13-
+decimal: 3.0-
+difflib: 3.0-
+dis: 3.0-
+distutils: 3.0-3.11
+distutils.command.bdist_msi: 3.0-3.10
+distutils.command.bdist_wininst: 3.0-3.9
+doctest: 3.0-
+dummy_threading: 3.0-3.8
+email: 3.0-
+encodings: 3.0-
+encodings.cp1125: 3.4-
+encodings.cp273: 3.4-
+encodings.cp858: 3.2-
+encodings.koi8_t: 3.5-
+encodings.kz1048: 3.5-
+encodings.mac_centeuro: 3.0-3.8
+ensurepip: 3.0-
 enum: 3.4-
-errno: 2.7-
+errno: 3.0-
 faulthandler: 3.3-
-fcntl: 2.7-
-filecmp: 2.7-
-fileinput: 2.7-
-fnmatch: 2.7-
-formatter: 2.7-3.9
-fractions: 2.7-
-ftplib: 2.7-
-functools: 2.7-
-gc: 2.7-
-genericpath: 2.7-
-getopt: 2.7-
-getpass: 2.7-
-gettext: 2.7-
-glob: 2.7-
+fcntl: 3.0-
+filecmp: 3.0-
+fileinput: 3.0-
+fnmatch: 3.0-
+formatter: 3.0-3.9
+fractions: 3.0-
+ftplib: 3.0-
+functools: 3.0-
+gc: 3.0-
+genericpath: 3.0-
+getopt: 3.0-
+getpass: 3.0-
+gettext: 3.0-
+glob: 3.0-
 graphlib: 3.9-
-grp: 2.7-
-gzip: 2.7-
-hashlib: 2.7-
-heapq: 2.7-
-hmac: 2.7-
+grp: 3.0-
+gzip: 3.0-
+hashlib: 3.0-
+heapq: 3.0-
+hmac: 3.0-
 html: 3.0-
 http: 3.0-
-imaplib: 2.7-
-imghdr: 2.7-
-imp: 2.7-
-importlib: 2.7-
+imaplib: 3.0-
+imghdr: 3.0-3.12
+imp: 3.0-3.11
+importlib: 3.0-
+importlib._abc: 3.10-
+importlib._bootstrap: 3.0-
+importlib._bootstrap_external: 3.5-
 importlib.metadata: 3.8-
 importlib.metadata._meta: 3.10-
+importlib.metadata.diagnose: 3.13-
+importlib.readers: 3.10-
 importlib.resources: 3.7-
+importlib.resources._common: 3.11-
+importlib.resources._functional: 3.13-
 importlib.resources.abc: 3.11-
-inspect: 2.7-
-io: 2.7-
+importlib.resources.readers: 3.11-
+importlib.resources.simple: 3.11-
+importlib.simple: 3.11-
+inspect: 3.0-
+io: 3.0-
 ipaddress: 3.3-
-itertools: 2.7-
-json: 2.7-
-keyword: 2.7-
-lib2to3: 2.7-
-linecache: 2.7-
-locale: 2.7-
-logging: 2.7-
+itertools: 3.0-
+json: 3.0-
+keyword: 3.0-
+lib2to3: 3.0-3.12
+linecache: 3.0-
+locale: 3.0-
+logging: 3.0-
 lzma: 3.3-
-macpath: 2.7-3.7
-mailbox: 2.7-
-mailcap: 2.7-
-marshal: 2.7-
-math: 2.7-
-mimetypes: 2.7-
-mmap: 2.7-
-modulefinder: 2.7-
-msilib: 2.7-
-msvcrt: 2.7-
-multiprocessing: 2.7-
+mailbox: 3.0-
+mailcap: 3.0-3.12
+marshal: 3.0-
+math: 3.0-
+mimetypes: 3.0-
+mmap: 3.0-
+modulefinder: 3.0-
+msilib: 3.0-3.12
+msvcrt: 3.0-
+multiprocessing: 3.0-
 multiprocessing.resource_tracker: 3.8-
 multiprocessing.shared_memory: 3.8-
-netrc: 2.7-
-nis: 2.7-
-nntplib: 2.7-
-ntpath: 2.7-
-nturl2path: 2.7-
-numbers: 2.7-
-opcode: 2.7-
-operator: 2.7-
-optparse: 2.7-
-os: 2.7-
-ossaudiodev: 2.7-
-parser: 2.7-3.9
+netrc: 3.0-
+nis: 3.0-3.12
+nntplib: 3.0-3.12
+nt: 3.0-
+ntpath: 3.0-
+nturl2path: 3.0-
+numbers: 3.0-
+opcode: 3.0-
+operator: 3.0-
+optparse: 3.0-
+os: 3.0-
+ossaudiodev: 3.0-3.12
+parser: 3.0-3.9
 pathlib: 3.4-
-pdb: 2.7-
-pickle: 2.7-
-pickletools: 2.7-
-pipes: 2.7-
-pkgutil: 2.7-
-platform: 2.7-
-plistlib: 2.7-
-poplib: 2.7-
-posix: 2.7-
-posixpath: 2.7-
-pprint: 2.7-
-profile: 2.7-
-pstats: 2.7-
-pty: 2.7-
-pwd: 2.7-
-py_compile: 2.7-
-pyclbr: 2.7-
-pydoc: 2.7-
-pydoc_data: 2.7-
-pyexpat: 2.7-
+pdb: 3.0-
+pickle: 3.0-
+pickletools: 3.0-
+pipes: 3.0-3.12
+pkgutil: 3.0-
+platform: 3.0-
+plistlib: 3.0-
+poplib: 3.0-
+posix: 3.0-
+posixpath: 3.0-
+pprint: 3.0-
+profile: 3.0-
+pstats: 3.0-
+pty: 3.0-
+pwd: 3.0-
+py_compile: 3.0-
+pyclbr: 3.0-
+pydoc: 3.0-
+pydoc_data: 3.0-
+pyexpat: 3.0-
 queue: 3.0-
-quopri: 2.7-
-random: 2.7-
-re: 2.7-
-readline: 2.7-
+quopri: 3.0-
+random: 3.0-
+re: 3.0-
+readline: 3.0-
 reprlib: 3.0-
-resource: 2.7-
-rlcompleter: 2.7-
-runpy: 2.7-
-sched: 2.7-
+resource: 3.0-
+rlcompleter: 3.0-
+runpy: 3.0-
+sched: 3.0-
 secrets: 3.6-
-select: 2.7-
+select: 3.0-
 selectors: 3.4-
-shelve: 2.7-
-shlex: 2.7-
-shutil: 2.7-
-signal: 2.7-
-site: 2.7-
-smtpd: 2.7-3.11
-smtplib: 2.7-
-sndhdr: 2.7-
-socket: 2.7-
+shelve: 3.0-
+shlex: 3.0-
+shutil: 3.0-
+signal: 3.0-
+site: 3.0-
+smtpd: 3.0-3.11
+smtplib: 3.0-
+sndhdr: 3.0-3.12
+socket: 3.0-
 socketserver: 3.0-
-spwd: 2.7-
-sqlite3: 2.7-
-sre_compile: 2.7-
-sre_constants: 2.7-
-sre_parse: 2.7-
-ssl: 2.7-
-stat: 2.7-
+spwd: 3.0-3.12
+sqlite3: 3.0-
+sre_compile: 3.0-
+sre_constants: 3.0-
+sre_parse: 3.0-
+ssl: 3.0-
+stat: 3.0-
 statistics: 3.4-
-string: 2.7-
-stringprep: 2.7-
-struct: 2.7-
-subprocess: 2.7-
-sunau: 2.7-
-symbol: 2.7-3.9
-symtable: 2.7-
-sys: 2.7-
-sysconfig: 2.7-
-syslog: 2.7-
-tabnanny: 2.7-
-tarfile: 2.7-
-telnetlib: 2.7-
-tempfile: 2.7-
-termios: 2.7-
-textwrap: 2.7-
-this: 2.7-
-threading: 2.7-
-time: 2.7-
-timeit: 2.7-
+string: 3.0-
+stringprep: 3.0-
+struct: 3.0-
+subprocess: 3.0-
+sunau: 3.0-3.12
+symbol: 3.0-3.9
+symtable: 3.0-
+sys: 3.0-
+sys._monitoring: 3.12-  # Doesn't actually exist. See comments in the stub.
+sysconfig: 3.0-
+syslog: 3.0-
+tabnanny: 3.0-
+tarfile: 3.0-
+telnetlib: 3.0-3.12
+tempfile: 3.0-
+termios: 3.0-
+textwrap: 3.0-
+this: 3.0-
+threading: 3.0-
+time: 3.0-
+timeit: 3.0-
 tkinter: 3.0-
-token: 2.7-
-tokenize: 2.7-
+tkinter.tix: 3.0-3.12
+token: 3.0-
+tokenize: 3.0-
 tomllib: 3.11-
-trace: 2.7-
-traceback: 2.7-
+trace: 3.0-
+traceback: 3.0-
 tracemalloc: 3.4-
-tty: 2.7-
-turtle: 2.7-
-types: 2.7-
+tty: 3.0-
+turtle: 3.0-
+types: 3.0-
 typing: 3.5-
-typing_extensions: 2.7-
-unicodedata: 2.7-
-unittest: 2.7-
+typing_extensions: 3.0-
+unicodedata: 3.0-
+unittest: 3.0-
 unittest._log: 3.9-
 unittest.async_case: 3.8-
-urllib: 2.7-
-uu: 2.7-
-uuid: 2.7-
+urllib: 3.0-
+uu: 3.0-3.12
+uuid: 3.0-
 venv: 3.3-
-warnings: 2.7-
-wave: 2.7-
-weakref: 2.7-
-webbrowser: 2.7-
+warnings: 3.0-
+wave: 3.0-
+weakref: 3.0-
+webbrowser: 3.0-
 winreg: 3.0-
-winsound: 2.7-
-wsgiref: 2.7-
+winsound: 3.0-
+wsgiref: 3.0-
 wsgiref.types: 3.11-
-xdrlib: 2.7-
-xml: 2.7-
+xdrlib: 3.0-3.12
+xml: 3.0-
 xmlrpc: 3.0-
 xxlimited: 3.2-
 zipapp: 3.5-
-zipfile: 2.7-
-zipimport: 2.7-
-zlib: 2.7-
+zipfile: 3.0-
+zipfile._path: 3.12-
+zipimport: 3.0-
+zlib: 3.0-
 zoneinfo: 3.9-
diff --git a/mypy/typeshed/stdlib/_ast.pyi b/mypy/typeshed/stdlib/_ast.pyi
index 7bc47266d713..8dc1bcbea32c 100644
--- a/mypy/typeshed/stdlib/_ast.pyi
+++ b/mypy/typeshed/stdlib/_ast.pyi
@@ -1,573 +1,149 @@
 import sys
-from typing import Any, ClassVar
-from typing_extensions import Literal, TypeAlias
-
-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
-
-class AST:
-    if sys.version_info >= (3, 10):
-        __match_args__ = ()
-    _attributes: ClassVar[tuple[str, ...]]
-    _fields: ClassVar[tuple[str, ...]]
-    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    # TODO: Not all nodes have all of the following attributes
-    lineno: int
-    col_offset: int
-    if sys.version_info >= (3, 8):
-        end_lineno: int | None
-        end_col_offset: int | None
-        type_comment: str | None
-
-class mod(AST): ...
-
-if sys.version_info >= (3, 8):
-    class type_ignore(AST): ...
-
-    class TypeIgnore(type_ignore):
-        if sys.version_info >= (3, 10):
-            __match_args__ = ("lineno", "tag")
-        tag: str
-
-    class FunctionType(mod):
-        if sys.version_info >= (3, 10):
-            __match_args__ = ("argtypes", "returns")
-        argtypes: list[expr]
-        returns: expr
-
-class Module(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body", "type_ignores")
-    body: list[stmt]
-    if sys.version_info >= (3, 8):
-        type_ignores: list[TypeIgnore]
-
-class Interactive(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body",)
-    body: list[stmt]
-
-class Expression(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body",)
-    body: expr
-
-class stmt(AST): ...
-
-class FunctionDef(stmt):
-    if 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
-
-class AsyncFunctionDef(stmt):
-    if 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
-
-class ClassDef(stmt):
-    if 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]
-
-class Return(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr | None
-
-class Delete(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("targets",)
-    targets: list[expr]
-
-class Assign(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("targets", "value", "type_comment")
-    targets: list[expr]
-    value: expr
-
-class AugAssign(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "op", "value")
-    target: Name | Attribute | Subscript
-    op: operator
-    value: expr
-
-class AnnAssign(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "annotation", "value", "simple")
-    target: Name | Attribute | Subscript
-    annotation: expr
-    value: expr | None
-    simple: int
-
-class For(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
-    target: expr
-    iter: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class AsyncFor(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
-    target: expr
-    iter: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class While(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "body", "orelse")
-    test: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class If(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "body", "orelse")
-    test: expr
-    body: list[stmt]
-    orelse: list[stmt]
-
-class With(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("items", "body", "type_comment")
-    items: list[withitem]
-    body: list[stmt]
-
-class AsyncWith(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("items", "body", "type_comment")
-    items: list[withitem]
-    body: list[stmt]
-
-class Raise(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("exc", "cause")
-    exc: expr | None
-    cause: expr | None
-
-class Try(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("body", "handlers", "orelse", "finalbody")
-    body: list[stmt]
-    handlers: list[ExceptHandler]
-    orelse: list[stmt]
-    finalbody: list[stmt]
+from ast import (
+    AST as AST,
+    Add as Add,
+    And as And,
+    AnnAssign as AnnAssign,
+    Assert as Assert,
+    Assign as Assign,
+    AsyncFor as AsyncFor,
+    AsyncFunctionDef as AsyncFunctionDef,
+    AsyncWith as AsyncWith,
+    Attribute as Attribute,
+    AugAssign as AugAssign,
+    Await as Await,
+    BinOp as BinOp,
+    BitAnd as BitAnd,
+    BitOr as BitOr,
+    BitXor as BitXor,
+    BoolOp as BoolOp,
+    Break as Break,
+    Call as Call,
+    ClassDef as ClassDef,
+    Compare as Compare,
+    Constant as Constant,
+    Continue as Continue,
+    Del as Del,
+    Delete as Delete,
+    Dict as Dict,
+    DictComp as DictComp,
+    Div as Div,
+    Eq as Eq,
+    ExceptHandler as ExceptHandler,
+    Expr as Expr,
+    Expression as Expression,
+    FloorDiv as FloorDiv,
+    For as For,
+    FormattedValue as FormattedValue,
+    FunctionDef as FunctionDef,
+    FunctionType as FunctionType,
+    GeneratorExp as GeneratorExp,
+    Global as Global,
+    Gt as Gt,
+    GtE as GtE,
+    If as If,
+    IfExp as IfExp,
+    Import as Import,
+    ImportFrom as ImportFrom,
+    In as In,
+    Interactive as Interactive,
+    Invert as Invert,
+    Is as Is,
+    IsNot as IsNot,
+    JoinedStr as JoinedStr,
+    Lambda as Lambda,
+    List as List,
+    ListComp as ListComp,
+    Load as Load,
+    LShift as LShift,
+    Lt as Lt,
+    LtE as LtE,
+    MatMult as MatMult,
+    Mod as Mod,
+    Module as Module,
+    Mult as Mult,
+    Name as Name,
+    NamedExpr as NamedExpr,
+    Nonlocal as Nonlocal,
+    Not as Not,
+    NotEq as NotEq,
+    NotIn as NotIn,
+    Or as Or,
+    Pass as Pass,
+    Pow as Pow,
+    Raise as Raise,
+    Return as Return,
+    RShift as RShift,
+    Set as Set,
+    SetComp as SetComp,
+    Slice as Slice,
+    Starred as Starred,
+    Store as Store,
+    Sub as Sub,
+    Subscript as Subscript,
+    Try as Try,
+    Tuple as Tuple,
+    TypeIgnore as TypeIgnore,
+    UAdd as UAdd,
+    UnaryOp as UnaryOp,
+    USub as USub,
+    While as While,
+    With as With,
+    Yield as Yield,
+    YieldFrom as YieldFrom,
+    alias as alias,
+    arg as arg,
+    arguments as arguments,
+    boolop as boolop,
+    cmpop as cmpop,
+    comprehension as comprehension,
+    excepthandler as excepthandler,
+    expr as expr,
+    expr_context as expr_context,
+    keyword as keyword,
+    mod as mod,
+    operator as operator,
+    stmt as stmt,
+    type_ignore as type_ignore,
+    unaryop as unaryop,
+    withitem as withitem,
+)
+from typing import Literal
+
+if sys.version_info >= (3, 12):
+    from ast import ParamSpec as ParamSpec, TypeVar as TypeVar, TypeVarTuple as TypeVarTuple, type_param as type_param
 
 if sys.version_info >= (3, 11):
-    class TryStar(stmt):
-        __match_args__ = ("body", "handlers", "orelse", "finalbody")
-        body: list[stmt]
-        handlers: list[ExceptHandler]
-        orelse: list[stmt]
-        finalbody: list[stmt]
-
-class Assert(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "msg")
-    test: expr
-    msg: expr | None
-
-class Import(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("names",)
-    names: list[alias]
-
-class ImportFrom(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("module", "names", "level")
-    module: str | None
-    names: list[alias]
-    level: int
-
-class Global(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("names",)
-    names: list[_Identifier]
-
-class Nonlocal(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("names",)
-    names: list[_Identifier]
-
-class Expr(stmt):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr
-
-class Pass(stmt): ...
-class Break(stmt): ...
-class Continue(stmt): ...
-class expr(AST): ...
-
-class BoolOp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("op", "values")
-    op: boolop
-    values: list[expr]
-
-class BinOp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("left", "op", "right")
-    left: expr
-    op: operator
-    right: expr
-
-class UnaryOp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("op", "operand")
-    op: unaryop
-    operand: expr
-
-class Lambda(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("args", "body")
-    args: arguments
-    body: expr
-
-class IfExp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("test", "body", "orelse")
-    test: expr
-    body: expr
-    orelse: expr
-
-class Dict(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("keys", "values")
-    keys: list[expr | None]
-    values: list[expr]
-
-class Set(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elts",)
-    elts: list[expr]
-
-class ListComp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elt", "generators")
-    elt: expr
-    generators: list[comprehension]
-
-class SetComp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elt", "generators")
-    elt: expr
-    generators: list[comprehension]
-
-class DictComp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("key", "value", "generators")
-    key: expr
-    value: expr
-    generators: list[comprehension]
-
-class GeneratorExp(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elt", "generators")
-    elt: expr
-    generators: list[comprehension]
-
-class Await(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr
-
-class Yield(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr | None
-
-class YieldFrom(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value",)
-    value: expr
-
-class Compare(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("left", "ops", "comparators")
-    left: expr
-    ops: list[cmpop]
-    comparators: list[expr]
-
-class Call(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("func", "args", "keywords")
-    func: expr
-    args: list[expr]
-    keywords: list[keyword]
-
-class FormattedValue(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "conversion", "format_spec")
-    value: expr
-    conversion: int
-    format_spec: expr | None
-
-class JoinedStr(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("values",)
-    values: list[expr]
-
-if sys.version_info < (3, 8):
-    class Num(expr):  # Deprecated in 3.8; use Constant
-        n: int | float | complex
-
-    class Str(expr):  # Deprecated in 3.8; use Constant
-        s: str
-
-    class Bytes(expr):  # Deprecated in 3.8; use Constant
-        s: bytes
-
-    class NameConstant(expr):  # Deprecated in 3.8; use Constant
-        value: Any
-
-    class Ellipsis(expr): ...  # Deprecated in 3.8; use Constant
-
-class Constant(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "kind")
-    value: Any  # None, str, bytes, bool, int, float, complex, Ellipsis
-    kind: str | None
-    # Aliases for value, for backwards compatibility
-    s: Any
-    n: int | float | complex
-
-if sys.version_info >= (3, 8):
-    class NamedExpr(expr):
-        if sys.version_info >= (3, 10):
-            __match_args__ = ("target", "value")
-        target: Name
-        value: expr
-
-class Attribute(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "attr", "ctx")
-    value: expr
-    attr: _Identifier
-    ctx: expr_context
-
-if sys.version_info >= (3, 9):
-    _Slice: TypeAlias = expr
-else:
-    class slice(AST): ...
-    _Slice: TypeAlias = slice
-
-class Slice(_Slice):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("lower", "upper", "step")
-    lower: expr | None
-    upper: expr | None
-    step: expr | None
-
-if sys.version_info < (3, 9):
-    class ExtSlice(slice):
-        dims: list[slice]
-
-    class Index(slice):
-        value: expr
-
-class Subscript(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "slice", "ctx")
-    value: expr
-    slice: _Slice
-    ctx: expr_context
-
-class Starred(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("value", "ctx")
-    value: expr
-    ctx: expr_context
-
-class Name(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("id", "ctx")
-    id: _Identifier
-    ctx: expr_context
-
-class List(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elts", "ctx")
-    elts: list[expr]
-    ctx: expr_context
-
-class Tuple(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("elts", "ctx")
-    elts: list[expr]
-    ctx: expr_context
-    if sys.version_info >= (3, 9):
-        dims: list[expr]
-
-class expr_context(AST): ...
-
-if sys.version_info < (3, 9):
-    class AugLoad(expr_context): ...
-    class AugStore(expr_context): ...
-    class Param(expr_context): ...
-
-    class Suite(mod):
-        body: list[stmt]
-
-class Del(expr_context): ...
-class Load(expr_context): ...
-class Store(expr_context): ...
-class boolop(AST): ...
-class And(boolop): ...
-class Or(boolop): ...
-class operator(AST): ...
-class Add(operator): ...
-class BitAnd(operator): ...
-class BitOr(operator): ...
-class BitXor(operator): ...
-class Div(operator): ...
-class FloorDiv(operator): ...
-class LShift(operator): ...
-class Mod(operator): ...
-class Mult(operator): ...
-class MatMult(operator): ...
-class Pow(operator): ...
-class RShift(operator): ...
-class Sub(operator): ...
-class unaryop(AST): ...
-class Invert(unaryop): ...
-class Not(unaryop): ...
-class UAdd(unaryop): ...
-class USub(unaryop): ...
-class cmpop(AST): ...
-class Eq(cmpop): ...
-class Gt(cmpop): ...
-class GtE(cmpop): ...
-class In(cmpop): ...
-class Is(cmpop): ...
-class IsNot(cmpop): ...
-class Lt(cmpop): ...
-class LtE(cmpop): ...
-class NotEq(cmpop): ...
-class NotIn(cmpop): ...
-
-class comprehension(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "iter", "ifs", "is_async")
-    target: expr
-    iter: expr
-    ifs: list[expr]
-    is_async: int
-
-class excepthandler(AST): ...
-
-class ExceptHandler(excepthandler):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("type", "name", "body")
-    type: expr | None
-    name: _Identifier | None
-    body: list[stmt]
-
-class arguments(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("posonlyargs", "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults")
-    if sys.version_info >= (3, 8):
-        posonlyargs: list[arg]
-    args: list[arg]
-    vararg: arg | None
-    kwonlyargs: list[arg]
-    kw_defaults: list[expr | None]
-    kwarg: arg | None
-    defaults: list[expr]
-
-class arg(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("arg", "annotation", "type_comment")
-    arg: _Identifier
-    annotation: expr | None
-
-class keyword(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("arg", "value")
-    arg: _Identifier | None
-    value: expr
-
-class alias(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("name", "asname")
-    name: _Identifier
-    asname: _Identifier | None
-
-class withitem(AST):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("context_expr", "optional_vars")
-    context_expr: expr
-    optional_vars: expr | None
+    from ast import TryStar as TryStar
 
 if sys.version_info >= (3, 10):
-    class Match(stmt):
-        __match_args__ = ("subject", "cases")
-        subject: expr
-        cases: list[match_case]
-
-    class pattern(AST): ...
-    # Without the alias, Pyright complains variables named pattern are recursively defined
-    _Pattern: TypeAlias = pattern
-
-    class match_case(AST):
-        __match_args__ = ("pattern", "guard", "body")
-        pattern: _Pattern
-        guard: expr | None
-        body: list[stmt]
-
-    class MatchValue(pattern):
-        __match_args__ = ("value",)
-        value: expr
-
-    class MatchSingleton(pattern):
-        __match_args__ = ("value",)
-        value: Literal[True, False, None]
-
-    class MatchSequence(pattern):
-        __match_args__ = ("patterns",)
-        patterns: list[pattern]
+    from ast import (
+        MatchAs as MatchAs,
+        MatchClass as MatchClass,
+        MatchMapping as MatchMapping,
+        MatchOr as MatchOr,
+        MatchSequence as MatchSequence,
+        MatchSingleton as MatchSingleton,
+        MatchStar as MatchStar,
+        MatchValue as MatchValue,
+        match_case as match_case,
+        pattern as pattern,
+    )
 
-    class MatchStar(pattern):
-        __match_args__ = ("name",)
-        name: _Identifier | None
-
-    class MatchMapping(pattern):
-        __match_args__ = ("keys", "patterns", "rest")
-        keys: list[expr]
-        patterns: list[pattern]
-        rest: _Identifier | None
-
-    class MatchClass(pattern):
-        __match_args__ = ("cls", "patterns", "kwd_attrs", "kwd_patterns")
-        cls: expr
-        patterns: list[pattern]
-        kwd_attrs: list[_Identifier]
-        kwd_patterns: list[pattern]
-
-    class MatchAs(pattern):
-        __match_args__ = ("pattern", "name")
-        pattern: _Pattern | None
-        name: _Identifier | None
+if sys.version_info < (3, 9):
+    from ast import (
+        AugLoad as AugLoad,
+        AugStore as AugStore,
+        ExtSlice as ExtSlice,
+        Index as Index,
+        Param as Param,
+        Suite as Suite,
+        slice as slice,
+    )
+
+PyCF_ALLOW_TOP_LEVEL_AWAIT: Literal[8192]
+PyCF_ONLY_AST: Literal[1024]
+PyCF_TYPE_COMMENTS: Literal[4096]
 
-    class MatchOr(pattern):
-        __match_args__ = ("patterns",)
-        patterns: list[pattern]
+if sys.version_info >= (3, 13):
+    PyCF_OPTIMIZED_AST: Literal[33792]
diff --git a/mypy/typeshed/stdlib/_asyncio.pyi b/mypy/typeshed/stdlib/_asyncio.pyi
new file mode 100644
index 000000000000..1397e579d53b
--- /dev/null
+++ b/mypy/typeshed/stdlib/_asyncio.pyi
@@ -0,0 +1,120 @@
+import sys
+from asyncio.events import AbstractEventLoop
+from collections.abc import Awaitable, Callable, Coroutine, Generator, Iterable
+from contextvars import Context
+from types import FrameType
+from typing import Any, Literal, TextIO, TypeVar
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_TaskYieldType: TypeAlias = Future[object] | None
+
+class Future(Awaitable[_T], Iterable[_T]):
+    _state: str
+    @property
+    def _exception(self) -> BaseException | None: ...
+    _blocking: bool
+    @property
+    def _log_traceback(self) -> bool: ...
+    @_log_traceback.setter
+    def _log_traceback(self, val: Literal[False]) -> None: ...
+    _asyncio_future_blocking: bool  # is a part of duck-typing contract for `Future`
+    def __init__(self, *, loop: AbstractEventLoop | None = ...) -> None: ...
+    def __del__(self) -> None: ...
+    def get_loop(self) -> AbstractEventLoop: ...
+    @property
+    def _callbacks(self) -> list[tuple[Callable[[Self], Any], Context]]: ...
+    def add_done_callback(self, fn: Callable[[Self], object], /, *, context: Context | None = None) -> None: ...
+    if sys.version_info >= (3, 9):
+        def cancel(self, msg: Any | None = None) -> bool: ...
+    else:
+        def cancel(self) -> bool: ...
+
+    def cancelled(self) -> bool: ...
+    def done(self) -> bool: ...
+    def result(self) -> _T: ...
+    def exception(self) -> BaseException | None: ...
+    def remove_done_callback(self, fn: Callable[[Self], object], /) -> int: ...
+    def set_result(self, result: _T, /) -> None: ...
+    def set_exception(self, exception: type | BaseException, /) -> None: ...
+    def __iter__(self) -> Generator[Any, None, _T]: ...
+    def __await__(self) -> Generator[Any, None, _T]: ...
+    @property
+    def _loop(self) -> AbstractEventLoop: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+if sys.version_info >= (3, 12):
+    _TaskCompatibleCoro: TypeAlias = Coroutine[Any, Any, _T_co]
+elif sys.version_info >= (3, 9):
+    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | 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,
+# and `asyncio.Task.set_result()` always raises.
+class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportInvalidTypeArguments]
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            coro: _TaskCompatibleCoro[_T_co],
+            *,
+            loop: AbstractEventLoop | None = None,
+            name: str | None = ...,
+            context: Context | None = None,
+            eager_start: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            coro: _TaskCompatibleCoro[_T_co],
+            *,
+            loop: AbstractEventLoop | None = None,
+            name: str | None = ...,
+            context: Context | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, coro: _TaskCompatibleCoro[_T_co], *, loop: AbstractEventLoop | None = None, name: str | None = ...
+        ) -> None: ...
+
+    if sys.version_info >= (3, 12):
+        def get_coro(self) -> _TaskCompatibleCoro[_T_co] | None: ...
+    else:
+        def get_coro(self) -> _TaskCompatibleCoro[_T_co]: ...
+
+    def get_name(self) -> str: ...
+    def set_name(self, value: object, /) -> None: ...
+    if sys.version_info >= (3, 12):
+        def get_context(self) -> Context: ...
+
+    def get_stack(self, *, limit: int | None = None) -> list[FrameType]: ...
+    def print_stack(self, *, limit: int | None = None, file: TextIO | None = None) -> None: ...
+    if sys.version_info >= (3, 11):
+        def cancelling(self) -> int: ...
+        def uncancel(self) -> int: ...
+    if sys.version_info < (3, 9):
+        @classmethod
+        def current_task(cls, loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
+        @classmethod
+        def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+def get_event_loop() -> AbstractEventLoop: ...
+def get_running_loop() -> AbstractEventLoop: ...
+def _set_running_loop(loop: AbstractEventLoop | None, /) -> None: ...
+def _get_running_loop() -> AbstractEventLoop: ...
+def _register_task(task: Task[Any]) -> None: ...
+def _unregister_task(task: Task[Any]) -> None: ...
+def _enter_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
+def _leave_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
+
+if sys.version_info >= (3, 12):
+    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
diff --git a/mypy/typeshed/stdlib/_blake2.pyi b/mypy/typeshed/stdlib/_blake2.pyi
new file mode 100644
index 000000000000..3d17cb59c79b
--- /dev/null
+++ b/mypy/typeshed/stdlib/_blake2.pyi
@@ -0,0 +1,117 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import ClassVar, final
+from typing_extensions import Self
+
+BLAKE2B_MAX_DIGEST_SIZE: int = 64
+BLAKE2B_MAX_KEY_SIZE: int = 64
+BLAKE2B_PERSON_SIZE: int = 16
+BLAKE2B_SALT_SIZE: int = 16
+BLAKE2S_MAX_DIGEST_SIZE: int = 32
+BLAKE2S_MAX_KEY_SIZE: int = 32
+BLAKE2S_PERSON_SIZE: int = 8
+BLAKE2S_SALT_SIZE: int = 8
+
+@final
+class blake2b:
+    MAX_DIGEST_SIZE: ClassVar[int] = 64
+    MAX_KEY_SIZE: ClassVar[int] = 64
+    PERSON_SIZE: ClassVar[int] = 16
+    SALT_SIZE: ClassVar[int] = 16
+    block_size: int
+    digest_size: int
+    name: str
+    if sys.version_info >= (3, 9):
+        def __new__(
+            cls,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 64,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+            usedforsecurity: bool = True,
+        ) -> Self: ...
+    else:
+        def __new__(
+            cls,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 64,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+        ) -> Self: ...
+
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, data: ReadableBuffer, /) -> None: ...
+
+@final
+class blake2s:
+    MAX_DIGEST_SIZE: ClassVar[int] = 32
+    MAX_KEY_SIZE: ClassVar[int] = 32
+    PERSON_SIZE: ClassVar[int] = 8
+    SALT_SIZE: ClassVar[int] = 8
+    block_size: int
+    digest_size: int
+    name: str
+    if sys.version_info >= (3, 9):
+        def __new__(
+            cls,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 32,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+            usedforsecurity: bool = True,
+        ) -> Self: ...
+    else:
+        def __new__(
+            cls,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 32,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+        ) -> Self: ...
+
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, data: ReadableBuffer, /) -> None: ...
diff --git a/mypy/typeshed/stdlib/_bz2.pyi b/mypy/typeshed/stdlib/_bz2.pyi
new file mode 100644
index 000000000000..fdad932ca22e
--- /dev/null
+++ b/mypy/typeshed/stdlib/_bz2.pyi
@@ -0,0 +1,24 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import final
+from typing_extensions import Self
+
+@final
+class BZ2Compressor:
+    if sys.version_info >= (3, 12):
+        def __new__(cls, compresslevel: int = 9, /) -> Self: ...
+    else:
+        def __init__(self, compresslevel: int = 9, /) -> None: ...
+
+    def compress(self, data: ReadableBuffer, /) -> bytes: ...
+    def flush(self) -> bytes: ...
+
+@final
+class BZ2Decompressor:
+    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    @property
+    def eof(self) -> bool: ...
+    @property
+    def needs_input(self) -> bool: ...
+    @property
+    def unused_data(self) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/_codecs.pyi b/mypy/typeshed/stdlib/_codecs.pyi
index 51f17f01ca71..11c5d58a855b 100644
--- a/mypy/typeshed/stdlib/_codecs.pyi
+++ b/mypy/typeshed/stdlib/_codecs.pyi
@@ -2,10 +2,13 @@ import codecs
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Callable
-from typing import overload
-from typing_extensions import Literal, TypeAlias
+from typing import Literal, final, overload, type_check_only
+from typing_extensions import TypeAlias
 
 # This type is not exposed; it is defined in unicodeobject.c
+# At runtime it calls itself builtins.EncodingMap
+@final
+@type_check_only
 class _EncodingMap:
     def size(self) -> int: ...
 
@@ -13,13 +16,13 @@ _CharMap: TypeAlias = dict[int, int] | _EncodingMap
 _Handler: TypeAlias = Callable[[UnicodeError], tuple[str | bytes, int]]
 _SearchFunction: TypeAlias = Callable[[str], codecs.CodecInfo | None]
 
-def register(__search_function: _SearchFunction) -> None: ...
+def register(search_function: _SearchFunction, /) -> None: ...
 
 if sys.version_info >= (3, 10):
-    def unregister(__search_function: _SearchFunction) -> None: ...
+    def unregister(search_function: _SearchFunction, /) -> None: ...
 
-def register_error(__errors: str, __handler: _Handler) -> None: ...
-def lookup_error(__name: str) -> _Handler: ...
+def register_error(errors: str, handler: _Handler, /) -> None: ...
+def lookup_error(name: str, /) -> _Handler: ...
 
 # The type ignore on `encode` and `decode` is to avoid issues with overlapping overloads, for more details, see #300
 # https://docs.python.org/3/library/codecs.html#binary-transforms
@@ -47,11 +50,11 @@ _StrToStrEncoding: TypeAlias = Literal["rot13", "rot_13"]
 @overload
 def encode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes: ...
 @overload
-def encode(obj: str, encoding: _StrToStrEncoding, errors: str = "strict") -> str: ...  # type: ignore[misc]
+def encode(obj: str, encoding: _StrToStrEncoding, errors: str = "strict") -> str: ...  # type: ignore[overload-overlap]
 @overload
 def encode(obj: str, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
 @overload
-def decode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes: ...  # type: ignore[misc]
+def decode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes: ...  # type: ignore[overload-overlap]
 @overload
 def decode(obj: str, encoding: _StrToStrEncoding, errors: str = "strict") -> str: ...
 
@@ -68,71 +71,66 @@ def decode(
 def decode(obj: str, encoding: Literal["hex", "hex_codec"], errors: str = "strict") -> bytes: ...
 @overload
 def decode(obj: ReadableBuffer, encoding: str = "utf-8", errors: str = "strict") -> str: ...
-def lookup(__encoding: str) -> codecs.CodecInfo: ...
-def charmap_build(__map: str) -> _CharMap: ...
-def ascii_decode(__data: ReadableBuffer, __errors: str | None = None) -> tuple[str, int]: ...
-def ascii_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def charmap_decode(__data: ReadableBuffer, __errors: str | None = None, __mapping: _CharMap | None = None) -> tuple[str, int]: ...
-def charmap_encode(__str: str, __errors: str | None = None, __mapping: _CharMap | None = None) -> tuple[bytes, int]: ...
-def escape_decode(__data: str | ReadableBuffer, __errors: str | None = None) -> tuple[str, int]: ...
-def escape_encode(__data: bytes, __errors: str | None = None) -> tuple[bytes, int]: ...
-def latin_1_decode(__data: ReadableBuffer, __errors: str | None = None) -> tuple[str, int]: ...
-def latin_1_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def lookup(encoding: str, /) -> codecs.CodecInfo: ...
+def charmap_build(map: str, /) -> _CharMap: ...
+def ascii_decode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+def ascii_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def charmap_decode(data: ReadableBuffer, errors: str | None = None, mapping: _CharMap | None = None, /) -> tuple[str, int]: ...
+def charmap_encode(str: str, errors: str | None = None, mapping: _CharMap | None = None, /) -> tuple[bytes, int]: ...
+def escape_decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+def escape_encode(data: bytes, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def latin_1_decode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+def latin_1_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
 
 if sys.version_info >= (3, 9):
     def raw_unicode_escape_decode(
-        __data: str | ReadableBuffer, __errors: str | None = None, __final: bool = True
+        data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /
     ) -> tuple[str, int]: ...
 
 else:
-    def raw_unicode_escape_decode(__data: str | ReadableBuffer, __errors: str | None = None) -> tuple[str, int]: ...
+    def raw_unicode_escape_decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
 
-def raw_unicode_escape_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def readbuffer_encode(__data: str | ReadableBuffer, __errors: str | None = None) -> tuple[bytes, int]: ...
+def raw_unicode_escape_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def readbuffer_encode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[bytes, int]: ...
 
 if sys.version_info >= (3, 9):
     def unicode_escape_decode(
-        __data: str | ReadableBuffer, __errors: str | None = None, __final: bool = True
+        data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /
     ) -> tuple[str, int]: ...
 
 else:
-    def unicode_escape_decode(__data: str | ReadableBuffer, __errors: str | None = None) -> tuple[str, int]: ...
+    def unicode_escape_decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
 
-def unicode_escape_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-
-if sys.version_info < (3, 8):
-    def unicode_internal_decode(__obj: str | ReadableBuffer, __errors: str | None = None) -> tuple[str, int]: ...
-    def unicode_internal_encode(__obj: str | ReadableBuffer, __errors: str | None = None) -> tuple[bytes, int]: ...
-
-def utf_16_be_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_16_be_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def utf_16_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_16_encode(__str: str, __errors: str | None = None, __byteorder: int = 0) -> tuple[bytes, int]: ...
+def unicode_escape_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def utf_16_be_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_16_be_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def utf_16_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_16_encode(str: str, errors: str | None = None, byteorder: int = 0, /) -> tuple[bytes, int]: ...
 def utf_16_ex_decode(
-    __data: ReadableBuffer, __errors: str | None = None, __byteorder: int = 0, __final: bool = False
+    data: ReadableBuffer, errors: str | None = None, byteorder: int = 0, final: bool = False, /
 ) -> tuple[str, int, int]: ...
-def utf_16_le_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_16_le_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def utf_32_be_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_32_be_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def utf_32_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_32_encode(__str: str, __errors: str | None = None, __byteorder: int = 0) -> tuple[bytes, int]: ...
+def utf_16_le_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_16_le_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def utf_32_be_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_32_be_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def utf_32_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_32_encode(str: str, errors: str | None = None, byteorder: int = 0, /) -> tuple[bytes, int]: ...
 def utf_32_ex_decode(
-    __data: ReadableBuffer, __errors: str | None = None, __byteorder: int = 0, __final: bool = False
+    data: ReadableBuffer, errors: str | None = None, byteorder: int = 0, final: bool = False, /
 ) -> tuple[str, int, int]: ...
-def utf_32_le_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_32_le_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def utf_7_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_7_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def utf_8_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-def utf_8_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def utf_32_le_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_32_le_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def utf_7_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_7_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+def utf_8_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+def utf_8_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
 
 if sys.platform == "win32":
-    def mbcs_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-    def mbcs_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+    def mbcs_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+    def mbcs_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
     def code_page_decode(
-        __codepage: int, __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+        codepage: int, data: ReadableBuffer, errors: str | None = None, final: bool = False, /
     ) -> tuple[str, int]: ...
-    def code_page_encode(__code_page: int, __str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-    def oem_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
-    def oem_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+    def code_page_encode(code_page: int, str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    def oem_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+    def oem_encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
diff --git a/mypy/typeshed/stdlib/_collections_abc.pyi b/mypy/typeshed/stdlib/_collections_abc.pyi
index 05b5421c21f3..8bac0ce1dca3 100644
--- a/mypy/typeshed/stdlib/_collections_abc.pyi
+++ b/mypy/typeshed/stdlib/_collections_abc.pyi
@@ -7,8 +7,8 @@ from typing import (  # noqa: Y022,Y038
     AsyncIterable as AsyncIterable,
     AsyncIterator as AsyncIterator,
     Awaitable as Awaitable,
-    ByteString as ByteString,
     Callable as Callable,
+    ClassVar,
     Collection as Collection,
     Container as Container,
     Coroutine as Coroutine,
@@ -30,9 +30,9 @@ from typing import (  # noqa: Y022,Y038
     Sized as Sized,
     TypeVar,
     ValuesView as ValuesView,
+    final,
     runtime_checkable,
 )
-from typing_extensions import final
 
 __all__ = [
     "Awaitable",
@@ -59,8 +59,12 @@ __all__ = [
     "ValuesView",
     "Sequence",
     "MutableSequence",
-    "ByteString",
 ]
+if sys.version_info < (3, 14):
+    from typing import ByteString as ByteString  # noqa: Y057
+
+    __all__ += ["ByteString"]
+
 if sys.version_info >= (3, 12):
     __all__ += ["Buffer"]
 
@@ -69,18 +73,29 @@ _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
 
 @final
 class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
+    def __eq__(self, value: object, /) -> bool: ...
+    def __reversed__(self) -> Iterator[_KT_co]: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    if sys.version_info >= (3, 13):
+        def isdisjoint(self, other: Iterable[_KT_co], /) -> bool: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
 
 @final
 class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
+    def __reversed__(self) -> Iterator[_VT_co]: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
 
 @final
-class dict_items(ItemsView[_KT_co, _VT_co], Generic[_KT_co, _VT_co]):  # undocumented
+class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
+    def __eq__(self, value: object, /) -> bool: ...
+    def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    if sys.version_info >= (3, 13):
+        def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
@@ -89,4 +104,4 @@ if sys.version_info >= (3, 12):
     @runtime_checkable
     class Buffer(Protocol):
         @abstractmethod
-        def __buffer__(self, __flags: int) -> memoryview: ...
+        def __buffer__(self, flags: int, /) -> memoryview: ...
diff --git a/mypy/typeshed/stdlib/_compression.pyi b/mypy/typeshed/stdlib/_compression.pyi
index 24e11261140b..a41a8142cc3a 100644
--- a/mypy/typeshed/stdlib/_compression.pyi
+++ b/mypy/typeshed/stdlib/_compression.pyi
@@ -6,9 +6,9 @@ from typing import Any, Protocol
 BUFFER_SIZE = DEFAULT_BUFFER_SIZE
 
 class _Reader(Protocol):
-    def read(self, __n: int) -> bytes: ...
+    def read(self, n: int, /) -> bytes: ...
     def seekable(self) -> bool: ...
-    def seek(self, __n: int) -> Any: ...
+    def seek(self, n: int, /) -> Any: ...
 
 class BaseStream(BufferedIOBase): ...
 
diff --git a/mypy/typeshed/stdlib/_contextvars.pyi b/mypy/typeshed/stdlib/_contextvars.pyi
new file mode 100644
index 000000000000..c7d0814b3cb4
--- /dev/null
+++ b/mypy/typeshed/stdlib/_contextvars.pyi
@@ -0,0 +1,63 @@
+import sys
+from collections.abc import Callable, Iterator, Mapping
+from typing import Any, ClassVar, Generic, TypeVar, final, overload
+from typing_extensions import ParamSpec, Self
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+_D = TypeVar("_D")
+_P = ParamSpec("_P")
+
+@final
+class ContextVar(Generic[_T]):
+    @overload
+    def __new__(cls, name: str) -> Self: ...
+    @overload
+    def __new__(cls, name: str, *, default: _T) -> Self: ...
+    def __hash__(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    @overload
+    def get(self) -> _T: ...
+    @overload
+    def get(self, default: _T, /) -> _T: ...
+    @overload
+    def get(self, default: _D, /) -> _D | _T: ...
+    def set(self, value: _T, /) -> Token[_T]: ...
+    def reset(self, token: Token[_T], /) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+@final
+class Token(Generic[_T]):
+    @property
+    def var(self) -> ContextVar[_T]: ...
+    @property
+    def old_value(self) -> Any: ...  # returns either _T or MISSING, but that's hard to express
+    MISSING: ClassVar[object]
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+def copy_context() -> Context: ...
+
+# It doesn't make sense to make this generic, because for most Contexts each ContextVar will have
+# a different value.
+@final
+class Context(Mapping[ContextVar[Any], Any]):
+    def __init__(self) -> None: ...
+    @overload
+    def get(self, key: ContextVar[_T], default: None = None, /) -> _T | None: ...
+    @overload
+    def get(self, key: ContextVar[_T], default: _T, /) -> _T: ...
+    @overload
+    def get(self, key: ContextVar[_T], default: _D, /) -> _T | _D: ...
+    def run(self, callable: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> _T: ...
+    def copy(self) -> Context: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    def __getitem__(self, key: ContextVar[_T], /) -> _T: ...
+    def __iter__(self) -> Iterator[ContextVar[Any]]: ...
+    def __len__(self) -> int: ...
+    def __eq__(self, value: object, /) -> bool: ...
diff --git a/mypy/typeshed/stdlib/_csv.pyi b/mypy/typeshed/stdlib/_csv.pyi
index c9b9f47e6217..aa9fc538417e 100644
--- a/mypy/typeshed/stdlib/_csv.pyi
+++ b/mypy/typeshed/stdlib/_csv.pyi
@@ -1,14 +1,19 @@
+import csv
+import sys
 from _typeshed import SupportsWrite
-from collections.abc import Iterable, Iterator
-from typing import Any
-from typing_extensions import Final, Literal, TypeAlias
+from collections.abc import Iterable
+from typing import Any, Final, type_check_only
+from typing_extensions import Self, TypeAlias
 
 __version__: Final[str]
 
-QUOTE_ALL: Literal[1]
-QUOTE_MINIMAL: Literal[0]
-QUOTE_NONE: Literal[3]
-QUOTE_NONNUMERIC: Literal[2]
+QUOTE_ALL: Final = 1
+QUOTE_MINIMAL: Final = 0
+QUOTE_NONE: Final = 3
+QUOTE_NONNUMERIC: Final = 2
+if sys.version_info >= (3, 12):
+    QUOTE_STRINGS: Final = 4
+    QUOTE_NOTNULL: Final = 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)
@@ -16,6 +21,8 @@ _QuotingType: TypeAlias = int
 
 class Error(Exception): ...
 
+_DialectLike: TypeAlias = str | Dialect | csv.Dialect | type[Dialect | csv.Dialect]
+
 class Dialect:
     delimiter: str
     quotechar: str | None
@@ -25,21 +32,60 @@ class Dialect:
     lineterminator: str
     quoting: _QuotingType
     strict: bool
-    def __init__(self) -> None: ...
+    def __new__(
+        cls,
+        dialect: _DialectLike | None = ...,
+        delimiter: str = ",",
+        doublequote: bool = True,
+        escapechar: str | None = None,
+        lineterminator: str = "\r\n",
+        quotechar: str | None = '"',
+        quoting: _QuotingType = 0,
+        skipinitialspace: bool = False,
+        strict: bool = False,
+    ) -> Self: ...
+
+if sys.version_info >= (3, 10):
+    # This class calls itself _csv.reader.
+    class Reader:
+        @property
+        def dialect(self) -> Dialect: ...
+        line_num: int
+        def __iter__(self) -> Self: ...
+        def __next__(self) -> list[str]: ...
 
-_DialectLike: TypeAlias = str | Dialect | type[Dialect]
+    # This class calls itself _csv.writer.
+    class Writer:
+        @property
+        def dialect(self) -> Dialect: ...
+        if sys.version_info >= (3, 13):
+            def writerow(self, row: Iterable[Any], /) -> Any: ...
+            def writerows(self, rows: Iterable[Iterable[Any]], /) -> None: ...
+        else:
+            def writerow(self, row: Iterable[Any]) -> Any: ...
+            def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
 
-class _reader(Iterator[list[str]]):
-    @property
-    def dialect(self) -> Dialect: ...
-    line_num: int
-    def __next__(self) -> list[str]: ...
+    # For the return types below.
+    # These aliases can be removed when typeshed drops support for 3.9.
+    _reader = Reader
+    _writer = Writer
+else:
+    # This class is not exposed. It calls itself _csv.reader.
+    @type_check_only
+    class _reader:
+        @property
+        def dialect(self) -> Dialect: ...
+        line_num: int
+        def __iter__(self) -> Self: ...
+        def __next__(self) -> list[str]: ...
 
-class _writer:
-    @property
-    def dialect(self) -> Dialect: ...
-    def writerow(self, row: Iterable[Any]) -> Any: ...
-    def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
+    # This class is not exposed. It calls itself _csv.writer.
+    @type_check_only
+    class _writer:
+        @property
+        def dialect(self) -> Dialect: ...
+        def writerow(self, row: Iterable[Any]) -> Any: ...
+        def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
 
 def writer(
     csvfile: SupportsWrite[str],
@@ -69,7 +115,7 @@ def reader(
 ) -> _reader: ...
 def register_dialect(
     name: str,
-    dialect: type[Dialect] = ...,
+    dialect: type[Dialect | csv.Dialect] = ...,
     *,
     delimiter: str = ",",
     quotechar: str | None = '"',
diff --git a/mypy/typeshed/stdlib/_ctypes.pyi b/mypy/typeshed/stdlib/_ctypes.pyi
index 8e8bcbe84bd4..2977bf5afa94 100644
--- a/mypy/typeshed/stdlib/_ctypes.pyi
+++ b/mypy/typeshed/stdlib/_ctypes.pyi
@@ -1,9 +1,10 @@
+import _typeshed
 import sys
-from _typeshed import ReadableBuffer, WriteableBuffer
+from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
-from ctypes import CDLL
-from typing import Any, ClassVar, Generic, TypeVar, overload
+from ctypes import CDLL, ArgumentError as ArgumentError, c_void_p
+from typing import Any, ClassVar, Generic, TypeVar, final, overload, type_check_only
 from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
@@ -22,6 +23,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]
@@ -41,41 +45,82 @@ if sys.platform == "win32":
     def FormatError(code: int = ...) -> str: ...
     def get_last_error() -> int: ...
     def set_last_error(value: int) -> int: ...
+    def LoadLibrary(name: str, load_flags: int = 0, /) -> int: ...
+    def FreeLibrary(handle: int, /) -> None: ...
+
+else:
+    def dlclose(handle: int, /) -> None: ...
+    # The default for flag is RTLD_GLOBAL|RTLD_LOCAL, which is platform dependent.
+    def dlopen(name: StrOrBytesPath, flag: int = ..., /) -> int: ...
+    def dlsym(handle: int, name: str, /) -> int: ...
+
+if sys.version_info >= (3, 13):
+    # This class is not exposed. It calls itself _ctypes.CType_Type.
+    @type_check_only
+    class _CType_Type(type):
+        # By default mypy complains about the following two methods, because strictly speaking cls
+        # might not be a Type[_CT]. However this doesn't happen because this is only a
+        # metaclass for subclasses of _CData.
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
-class _CDataMeta(type):
-    # By default mypy complains about the following two methods, because strictly speaking cls
-    # might not be a Type[_CT]. However this can never actually happen, because the only class that
-    # uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here.
-    def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
-    def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    _CTypeBaseType = _CType_Type
 
-class _CData(metaclass=_CDataMeta):
+else:
+    _CTypeBaseType = type
+
+# This class is not exposed.
+@type_check_only
+class _CData:
     _b_base_: int
     _b_needsfree_: bool
     _objects: Mapping[Any, int] | None
-    @classmethod
-    def from_buffer(cls, source: WriteableBuffer, offset: int = ...) -> Self: ...
-    @classmethod
-    def from_buffer_copy(cls, source: ReadableBuffer, offset: int = ...) -> Self: ...
-    @classmethod
-    def from_address(cls, address: int) -> Self: ...
-    @classmethod
-    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):
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __ctypes_from_outparam__(self, /) -> Self: ...
+
+# this is a union of all the subclasses of _CData, which is useful because of
+# the methods that are present on each of those subclasses which are not present
+# on _CData itself.
+_CDataType: TypeAlias = _SimpleCData[Any] | _Pointer[Any] | CFuncPtr | Union | Structure | Array[Any]
+
+# This class is not exposed. It calls itself _ctypes.PyCSimpleType.
+@type_check_only
+class _PyCSimpleType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(self: type[_CT], value: int, /) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(self: type[_CT], value: int, /) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class _SimpleCData(_CData, Generic[_T], metaclass=_PyCSimpleType):
     value: _T
     # The TypeVar can be unsolved here,
     # but we can't use overloads without creating many, many mypy false-positive errors
     def __init__(self, value: _T = ...) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]
+    def __ctypes_from_outparam__(self, /) -> _T: ...  # type: ignore[override]
 
 class _CanCastTo(_CData): ...
 class _PointerLike(_CanCastTo): ...
 
-class _Pointer(Generic[_CT], _PointerLike, _CData):
+# This type is not exposed. It calls itself _ctypes.PyCPointerType.
+@type_check_only
+class _PyCPointerType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    def set_type(self, type: Any, /) -> None: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class _Pointer(_PointerLike, _CData, Generic[_CT], metaclass=_PyCPointerType):
     _type_: type[_CT]
     contents: _CT
     @overload
@@ -83,61 +128,154 @@ class _Pointer(Generic[_CT], _PointerLike, _CData):
     @overload
     def __init__(self, arg: _CT) -> None: ...
     @overload
-    def __getitem__(self, __key: int) -> Any: ...
+    def __getitem__(self, key: int, /) -> Any: ...
     @overload
-    def __getitem__(self, __key: slice) -> list[Any]: ...
-    def __setitem__(self, __key: int, __value: Any) -> None: ...
+    def __getitem__(self, key: slice, /) -> list[Any]: ...
+    def __setitem__(self, key: int, value: Any, /) -> None: ...
 
-def POINTER(type: type[_CT]) -> type[_Pointer[_CT]]: ...
-def pointer(__arg: _CT) -> _Pointer[_CT]: ...
+@overload
+def POINTER(type: None, /) -> type[c_void_p]: ...
+@overload
+def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]: ...
+def pointer(obj: _CT, /) -> _Pointer[_CT]: ...
 
+# This class is not exposed. It calls itself _ctypes.CArgObject.
+@final
+@type_check_only
 class _CArgObject: ...
 
-def byref(obj: _CData, offset: int = ...) -> _CArgObject: ...
+def byref(obj: _CData | _CDataType, offset: int = ...) -> _CArgObject: ...
 
-_ECT: TypeAlias = Callable[[type[_CData] | None, CFuncPtr, tuple[_CData, ...]], _CData]
+_ECT: TypeAlias = Callable[[_CData | _CDataType | None, CFuncPtr, tuple[_CData | _CDataType, ...]], _CDataType]
 _PF: TypeAlias = tuple[int] | tuple[int, str | None] | tuple[int, str | None, Any]
 
-class CFuncPtr(_PointerLike, _CData):
-    restype: type[_CData] | Callable[[int], Any] | None
-    argtypes: Sequence[type[_CData]]
+# This class is not exposed. It calls itself _ctypes.PyCFuncPtrType.
+@type_check_only
+class _PyCFuncPtrType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class CFuncPtr(_PointerLike, _CData, metaclass=_PyCFuncPtrType):
+    restype: type[_CDataType] | Callable[[int], Any] | None
+    argtypes: Sequence[type[_CDataType]]
     errcheck: _ECT
-    _flags_: ClassVar[int]  # Abstract attribute that must be defined on subclasses
+    # Abstract attribute that must be defined on subclasses
+    _flags_: ClassVar[int]
     @overload
-    def __init__(self) -> None: ...
+    def __new__(cls) -> Self: ...
     @overload
-    def __init__(self, __address: int) -> None: ...
+    def __new__(cls, address: int, /) -> Self: ...
     @overload
-    def __init__(self, __callable: Callable[..., Any]) -> None: ...
+    def __new__(cls, callable: Callable[..., Any], /) -> Self: ...
     @overload
-    def __init__(self, __func_spec: tuple[str | int, CDLL], __paramflags: tuple[_PF, ...] | None = ...) -> None: ...
+    def __new__(cls, func_spec: tuple[str | int, CDLL], paramflags: tuple[_PF, ...] | None = ..., /) -> Self: ...
     if sys.platform == "win32":
         @overload
-        def __init__(
-            self, __vtbl_index: int, __name: str, __paramflags: tuple[_PF, ...] | None = ..., __iid: _CData | None = ...
-        ) -> None: ...
+        def __new__(
+            cls, vtbl_index: int, name: str, paramflags: tuple[_PF, ...] | None = ..., iid: _CData | _CDataType | None = ..., /
+        ) -> Self: ...
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
 
-class _CField:
+_GetT = TypeVar("_GetT")
+_SetT = TypeVar("_SetT")
+
+# This class is not exposed. It calls itself _ctypes.CField.
+@final
+@type_check_only
+class _CField(Generic[_CT, _GetT, _SetT]):
     offset: int
     size: int
+    if sys.version_info >= (3, 10):
+        @overload
+        def __get__(self, instance: None, owner: type[Any] | None = None, /) -> Self: ...
+        @overload
+        def __get__(self, instance: Any, owner: type[Any] | None = None, /) -> _GetT: ...
+    else:
+        @overload
+        def __get__(self, instance: None, owner: type[Any] | None, /) -> Self: ...
+        @overload
+        def __get__(self, instance: Any, owner: type[Any] | None, /) -> _GetT: ...
+
+    def __set__(self, instance: Any, value: _SetT, /) -> None: ...
+
+# This class is not exposed. It calls itself _ctypes.UnionType.
+@type_check_only
+class _UnionType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    # At runtime, various attributes are created on a Union subclass based
+    # on its _fields_. This method doesn't exist, but represents those
+    # dynamically created attributes.
+    def __getattr__(self, name: str) -> _CField[Any, Any, Any]: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class Union(_CData, metaclass=_UnionType):
+    _fields_: ClassVar[Sequence[tuple[str, type[_CDataType]] | tuple[str, type[_CDataType], int]]]
+    _pack_: ClassVar[int]
+    _anonymous_: ClassVar[Sequence[str]]
+    if sys.version_info >= (3, 13):
+        _align_: ClassVar[int]
 
-class _StructUnionMeta(_CDataMeta):
-    _fields_: Sequence[tuple[str, type[_CData]] | tuple[str, type[_CData], int]]
-    _pack_: int
-    _anonymous_: Sequence[str]
-    def __getattr__(self, name: str) -> _CField: ...
+    def __init__(self, *args: Any, **kw: Any) -> None: ...
+    def __getattr__(self, name: str) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+
+# This class is not exposed. It calls itself _ctypes.PyCStructType.
+@type_check_only
+class _PyCStructType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    # At runtime, various attributes are created on a Structure subclass based
+    # on its _fields_. This method doesn't exist, but represents those
+    # dynamically created attributes.
+    def __getattr__(self, name: str) -> _CField[Any, Any, Any]: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+
+class Structure(_CData, metaclass=_PyCStructType):
+    _fields_: ClassVar[Sequence[tuple[str, type[_CDataType]] | tuple[str, type[_CDataType], int]]]
+    _pack_: ClassVar[int]
+    _anonymous_: ClassVar[Sequence[str]]
+    if sys.version_info >= (3, 13):
+        _align_: ClassVar[int]
 
-class _StructUnionBase(_CData, metaclass=_StructUnionMeta):
     def __init__(self, *args: Any, **kw: Any) -> None: ...
     def __getattr__(self, name: str) -> Any: ...
     def __setattr__(self, name: str, value: Any) -> None: ...
 
-class Union(_StructUnionBase): ...
-class Structure(_StructUnionBase): ...
+# This class is not exposed. It calls itself _ctypes.PyCArrayType.
+@type_check_only
+class _PyCArrayType(_CTypeBaseType):
+    def from_address(self: type[_typeshed.Self], value: int, /) -> _typeshed.Self: ...
+    def from_buffer(self: type[_typeshed.Self], obj: WriteableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_buffer_copy(self: type[_typeshed.Self], buffer: ReadableBuffer, offset: int = 0, /) -> _typeshed.Self: ...
+    def from_param(self: type[_typeshed.Self], value: Any, /) -> _typeshed.Self | _CArgObject: ...
+    def in_dll(self: type[_typeshed.Self], dll: CDLL, name: str, /) -> _typeshed.Self: ...
+    if sys.version_info < (3, 13):
+        # Inherited from CType_Type starting on 3.13
+        def __mul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
+        def __rmul__(cls: type[_CT], other: int) -> type[Array[_CT]]: ...  # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues]
 
-class Array(Generic[_CT], _CData):
+class Array(_CData, Generic[_CT], metaclass=_PyCArrayType):
     @property
     @abstractmethod
     def _length_(self) -> int: ...
@@ -164,25 +302,29 @@ class Array(Generic[_CT], _CData):
     # the array element type would belong are annotated with Any instead.
     def __init__(self, *args: Any) -> None: ...
     @overload
-    def __getitem__(self, __key: int) -> Any: ...
+    def __getitem__(self, key: int, /) -> Any: ...
     @overload
-    def __getitem__(self, __key: slice) -> list[Any]: ...
+    def __getitem__(self, key: slice, /) -> list[Any]: ...
     @overload
-    def __setitem__(self, __key: int, __value: Any) -> None: ...
+    def __setitem__(self, key: int, value: Any, /) -> None: ...
     @overload
-    def __setitem__(self, __key: slice, __value: Iterable[Any]) -> None: ...
+    def __setitem__(self, key: slice, value: Iterable[Any], /) -> None: ...
     def __iter__(self) -> Iterator[Any]: ...
     # Can't inherit from Sized because the metaclass conflict between
     # Sized and _CData prevents using _CDataMeta.
     def __len__(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-class ArgumentError(Exception): ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-def addressof(obj: _CData) -> int: ...
-def alignment(obj_or_type: _CData | type[_CData]) -> int: ...
+def addressof(obj: _CData | _CDataType, /) -> int: ...
+def alignment(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...
 def get_errno() -> int: ...
-def resize(obj: _CData, size: int) -> None: ...
-def set_errno(value: int) -> int: ...
-def sizeof(obj_or_type: _CData | type[_CData]) -> int: ...
+def resize(obj: _CData | _CDataType, size: int, /) -> None: ...
+def set_errno(value: int, /) -> int: ...
+def sizeof(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...
+def PyObj_FromPtr(address: int, /) -> Any: ...
+def Py_DECREF(o: _T, /) -> _T: ...
+def Py_INCREF(o: _T, /) -> _T: ...
+def buffer_info(o: _CData | _CDataType | type[_CData | _CDataType], /) -> tuple[str, int, tuple[int, ...]]: ...
+def call_cdeclfunction(address: int, arguments: tuple[Any, ...], /) -> Any: ...
+def call_function(address: int, arguments: tuple[Any, ...], /) -> Any: ...
diff --git a/mypy/typeshed/stdlib/_curses.pyi b/mypy/typeshed/stdlib/_curses.pyi
index 61881fc09199..52c5185727e7 100644
--- a/mypy/typeshed/stdlib/_curses.pyi
+++ b/mypy/typeshed/stdlib/_curses.pyi
@@ -1,555 +1,553 @@
 import sys
-from _typeshed import ReadOnlyBuffer, SupportsRead
-from typing import IO, Any, NamedTuple, overload
-from typing_extensions import TypeAlias, final
+from _typeshed import ReadOnlyBuffer, SupportsRead, SupportsWrite
+from curses import _ncurses_version
+from typing import Any, final, overload
+from typing_extensions import TypeAlias
 
-if sys.platform != "win32":
-    # Handled by PyCurses_ConvertToChtype in _cursesmodule.c.
-    _ChType: TypeAlias = str | bytes | int
+# NOTE: This module is ordinarily only available on Unix, but the windows-curses
+# package makes it available on Windows as well with the same contents.
 
-    # ACS codes are only initialized after initscr is called
-    ACS_BBSS: int
-    ACS_BLOCK: int
-    ACS_BOARD: int
-    ACS_BSBS: int
-    ACS_BSSB: int
-    ACS_BSSS: int
-    ACS_BTEE: int
-    ACS_BULLET: int
-    ACS_CKBOARD: int
-    ACS_DARROW: int
-    ACS_DEGREE: int
-    ACS_DIAMOND: int
-    ACS_GEQUAL: int
-    ACS_HLINE: int
-    ACS_LANTERN: int
-    ACS_LARROW: int
-    ACS_LEQUAL: int
-    ACS_LLCORNER: int
-    ACS_LRCORNER: int
-    ACS_LTEE: int
-    ACS_NEQUAL: int
-    ACS_PI: int
-    ACS_PLMINUS: int
-    ACS_PLUS: int
-    ACS_RARROW: int
-    ACS_RTEE: int
-    ACS_S1: int
-    ACS_S3: int
-    ACS_S7: int
-    ACS_S9: int
-    ACS_SBBS: int
-    ACS_SBSB: int
-    ACS_SBSS: int
-    ACS_SSBB: int
-    ACS_SSBS: int
-    ACS_SSSB: int
-    ACS_SSSS: int
-    ACS_STERLING: int
-    ACS_TTEE: int
-    ACS_UARROW: int
-    ACS_ULCORNER: int
-    ACS_URCORNER: int
-    ACS_VLINE: int
-    ALL_MOUSE_EVENTS: int
-    A_ALTCHARSET: int
-    A_ATTRIBUTES: int
-    A_BLINK: int
-    A_BOLD: int
-    A_CHARTEXT: int
-    A_COLOR: int
-    A_DIM: int
-    A_HORIZONTAL: int
-    A_INVIS: int
-    A_ITALIC: int
-    A_LEFT: int
-    A_LOW: int
-    A_NORMAL: int
-    A_PROTECT: int
-    A_REVERSE: int
-    A_RIGHT: int
-    A_STANDOUT: int
-    A_TOP: int
-    A_UNDERLINE: int
-    A_VERTICAL: int
-    BUTTON1_CLICKED: int
-    BUTTON1_DOUBLE_CLICKED: int
-    BUTTON1_PRESSED: int
-    BUTTON1_RELEASED: int
-    BUTTON1_TRIPLE_CLICKED: int
-    BUTTON2_CLICKED: int
-    BUTTON2_DOUBLE_CLICKED: int
-    BUTTON2_PRESSED: int
-    BUTTON2_RELEASED: int
-    BUTTON2_TRIPLE_CLICKED: int
-    BUTTON3_CLICKED: int
-    BUTTON3_DOUBLE_CLICKED: int
-    BUTTON3_PRESSED: int
-    BUTTON3_RELEASED: int
-    BUTTON3_TRIPLE_CLICKED: int
-    BUTTON4_CLICKED: int
-    BUTTON4_DOUBLE_CLICKED: int
-    BUTTON4_PRESSED: int
-    BUTTON4_RELEASED: int
-    BUTTON4_TRIPLE_CLICKED: int
-    # Darwin ncurses doesn't provide BUTTON5_* constants
-    if sys.version_info >= (3, 10) and sys.platform != "darwin":
-        BUTTON5_PRESSED: int
-        BUTTON5_RELEASED: int
-        BUTTON5_CLICKED: int
-        BUTTON5_DOUBLE_CLICKED: int
-        BUTTON5_TRIPLE_CLICKED: int
-    BUTTON_ALT: int
-    BUTTON_CTRL: int
-    BUTTON_SHIFT: int
-    COLOR_BLACK: int
-    COLOR_BLUE: int
-    COLOR_CYAN: int
-    COLOR_GREEN: int
-    COLOR_MAGENTA: int
-    COLOR_RED: int
-    COLOR_WHITE: int
-    COLOR_YELLOW: int
-    ERR: int
-    KEY_A1: int
-    KEY_A3: int
-    KEY_B2: int
-    KEY_BACKSPACE: int
-    KEY_BEG: int
-    KEY_BREAK: int
-    KEY_BTAB: int
-    KEY_C1: int
-    KEY_C3: int
-    KEY_CANCEL: int
-    KEY_CATAB: int
-    KEY_CLEAR: int
-    KEY_CLOSE: int
-    KEY_COMMAND: int
-    KEY_COPY: int
-    KEY_CREATE: int
-    KEY_CTAB: int
-    KEY_DC: int
-    KEY_DL: int
-    KEY_DOWN: int
-    KEY_EIC: int
-    KEY_END: int
-    KEY_ENTER: int
-    KEY_EOL: int
-    KEY_EOS: int
-    KEY_EXIT: int
-    KEY_F0: int
-    KEY_F1: int
-    KEY_F10: int
-    KEY_F11: int
-    KEY_F12: int
-    KEY_F13: int
-    KEY_F14: int
-    KEY_F15: int
-    KEY_F16: int
-    KEY_F17: int
-    KEY_F18: int
-    KEY_F19: int
-    KEY_F2: int
-    KEY_F20: int
-    KEY_F21: int
-    KEY_F22: int
-    KEY_F23: int
-    KEY_F24: int
-    KEY_F25: int
-    KEY_F26: int
-    KEY_F27: int
-    KEY_F28: int
-    KEY_F29: int
-    KEY_F3: int
-    KEY_F30: int
-    KEY_F31: int
-    KEY_F32: int
-    KEY_F33: int
-    KEY_F34: int
-    KEY_F35: int
-    KEY_F36: int
-    KEY_F37: int
-    KEY_F38: int
-    KEY_F39: int
-    KEY_F4: int
-    KEY_F40: int
-    KEY_F41: int
-    KEY_F42: int
-    KEY_F43: int
-    KEY_F44: int
-    KEY_F45: int
-    KEY_F46: int
-    KEY_F47: int
-    KEY_F48: int
-    KEY_F49: int
-    KEY_F5: int
-    KEY_F50: int
-    KEY_F51: int
-    KEY_F52: int
-    KEY_F53: int
-    KEY_F54: int
-    KEY_F55: int
-    KEY_F56: int
-    KEY_F57: int
-    KEY_F58: int
-    KEY_F59: int
-    KEY_F6: int
-    KEY_F60: int
-    KEY_F61: int
-    KEY_F62: int
-    KEY_F63: int
-    KEY_F7: int
-    KEY_F8: int
-    KEY_F9: int
-    KEY_FIND: int
-    KEY_HELP: int
-    KEY_HOME: int
-    KEY_IC: int
-    KEY_IL: int
-    KEY_LEFT: int
-    KEY_LL: int
-    KEY_MARK: int
-    KEY_MAX: int
-    KEY_MESSAGE: int
-    KEY_MIN: int
-    KEY_MOUSE: int
-    KEY_MOVE: int
-    KEY_NEXT: int
-    KEY_NPAGE: int
-    KEY_OPEN: int
-    KEY_OPTIONS: int
-    KEY_PPAGE: int
-    KEY_PREVIOUS: int
-    KEY_PRINT: int
-    KEY_REDO: int
-    KEY_REFERENCE: int
-    KEY_REFRESH: int
-    KEY_REPLACE: int
-    KEY_RESET: int
-    KEY_RESIZE: int
-    KEY_RESTART: int
-    KEY_RESUME: int
-    KEY_RIGHT: int
-    KEY_SAVE: int
-    KEY_SBEG: int
-    KEY_SCANCEL: int
-    KEY_SCOMMAND: int
-    KEY_SCOPY: int
-    KEY_SCREATE: int
-    KEY_SDC: int
-    KEY_SDL: int
-    KEY_SELECT: int
-    KEY_SEND: int
-    KEY_SEOL: int
-    KEY_SEXIT: int
-    KEY_SF: int
-    KEY_SFIND: int
-    KEY_SHELP: int
-    KEY_SHOME: int
-    KEY_SIC: int
-    KEY_SLEFT: int
-    KEY_SMESSAGE: int
-    KEY_SMOVE: int
-    KEY_SNEXT: int
-    KEY_SOPTIONS: int
-    KEY_SPREVIOUS: int
-    KEY_SPRINT: int
-    KEY_SR: int
-    KEY_SREDO: int
-    KEY_SREPLACE: int
-    KEY_SRESET: int
-    KEY_SRIGHT: int
-    KEY_SRSUME: int
-    KEY_SSAVE: int
-    KEY_SSUSPEND: int
-    KEY_STAB: int
-    KEY_SUNDO: int
-    KEY_SUSPEND: int
-    KEY_UNDO: int
-    KEY_UP: int
-    OK: int
-    REPORT_MOUSE_POSITION: int
-    _C_API: Any
-    version: bytes
-    def baudrate() -> int: ...
-    def beep() -> None: ...
-    def can_change_color() -> bool: ...
-    def cbreak(__flag: bool = True) -> None: ...
-    def color_content(__color_number: int) -> tuple[int, int, int]: ...
-    # Changed in Python 3.8.8 and 3.9.2
-    if sys.version_info >= (3, 8):
-        def color_pair(pair_number: int) -> int: ...
-    else:
-        def color_pair(__color_number: int) -> int: ...
+# Handled by PyCurses_ConvertToChtype in _cursesmodule.c.
+_ChType: TypeAlias = str | bytes | int
 
-    def curs_set(__visibility: int) -> int: ...
-    def def_prog_mode() -> None: ...
-    def def_shell_mode() -> None: ...
-    def delay_output(__ms: int) -> None: ...
-    def doupdate() -> None: ...
-    def echo(__flag: bool = True) -> None: ...
-    def endwin() -> None: ...
-    def erasechar() -> bytes: ...
-    def filter() -> None: ...
-    def flash() -> None: ...
-    def flushinp() -> None: ...
-    if sys.version_info >= (3, 9):
-        def get_escdelay() -> int: ...
-        def get_tabsize() -> int: ...
+# ACS codes are only initialized after initscr is called
+ACS_BBSS: int
+ACS_BLOCK: int
+ACS_BOARD: int
+ACS_BSBS: int
+ACS_BSSB: int
+ACS_BSSS: int
+ACS_BTEE: int
+ACS_BULLET: int
+ACS_CKBOARD: int
+ACS_DARROW: int
+ACS_DEGREE: int
+ACS_DIAMOND: int
+ACS_GEQUAL: int
+ACS_HLINE: int
+ACS_LANTERN: int
+ACS_LARROW: int
+ACS_LEQUAL: int
+ACS_LLCORNER: int
+ACS_LRCORNER: int
+ACS_LTEE: int
+ACS_NEQUAL: int
+ACS_PI: int
+ACS_PLMINUS: int
+ACS_PLUS: int
+ACS_RARROW: int
+ACS_RTEE: int
+ACS_S1: int
+ACS_S3: int
+ACS_S7: int
+ACS_S9: int
+ACS_SBBS: int
+ACS_SBSB: int
+ACS_SBSS: int
+ACS_SSBB: int
+ACS_SSBS: int
+ACS_SSSB: int
+ACS_SSSS: int
+ACS_STERLING: int
+ACS_TTEE: int
+ACS_UARROW: int
+ACS_ULCORNER: int
+ACS_URCORNER: int
+ACS_VLINE: int
+ALL_MOUSE_EVENTS: int
+A_ALTCHARSET: int
+A_ATTRIBUTES: int
+A_BLINK: int
+A_BOLD: int
+A_CHARTEXT: int
+A_COLOR: int
+A_DIM: int
+A_HORIZONTAL: int
+A_INVIS: int
+A_ITALIC: int
+A_LEFT: int
+A_LOW: int
+A_NORMAL: int
+A_PROTECT: int
+A_REVERSE: int
+A_RIGHT: int
+A_STANDOUT: int
+A_TOP: int
+A_UNDERLINE: int
+A_VERTICAL: int
+BUTTON1_CLICKED: int
+BUTTON1_DOUBLE_CLICKED: int
+BUTTON1_PRESSED: int
+BUTTON1_RELEASED: int
+BUTTON1_TRIPLE_CLICKED: int
+BUTTON2_CLICKED: int
+BUTTON2_DOUBLE_CLICKED: int
+BUTTON2_PRESSED: int
+BUTTON2_RELEASED: int
+BUTTON2_TRIPLE_CLICKED: int
+BUTTON3_CLICKED: int
+BUTTON3_DOUBLE_CLICKED: int
+BUTTON3_PRESSED: int
+BUTTON3_RELEASED: int
+BUTTON3_TRIPLE_CLICKED: int
+BUTTON4_CLICKED: int
+BUTTON4_DOUBLE_CLICKED: int
+BUTTON4_PRESSED: int
+BUTTON4_RELEASED: int
+BUTTON4_TRIPLE_CLICKED: int
+# Darwin ncurses doesn't provide BUTTON5_* constants
+if sys.version_info >= (3, 10) and sys.platform != "darwin":
+    BUTTON5_PRESSED: int
+    BUTTON5_RELEASED: int
+    BUTTON5_CLICKED: int
+    BUTTON5_DOUBLE_CLICKED: int
+    BUTTON5_TRIPLE_CLICKED: int
+BUTTON_ALT: int
+BUTTON_CTRL: int
+BUTTON_SHIFT: int
+COLOR_BLACK: int
+COLOR_BLUE: int
+COLOR_CYAN: int
+COLOR_GREEN: int
+COLOR_MAGENTA: int
+COLOR_RED: int
+COLOR_WHITE: int
+COLOR_YELLOW: int
+ERR: int
+KEY_A1: int
+KEY_A3: int
+KEY_B2: int
+KEY_BACKSPACE: int
+KEY_BEG: int
+KEY_BREAK: int
+KEY_BTAB: int
+KEY_C1: int
+KEY_C3: int
+KEY_CANCEL: int
+KEY_CATAB: int
+KEY_CLEAR: int
+KEY_CLOSE: int
+KEY_COMMAND: int
+KEY_COPY: int
+KEY_CREATE: int
+KEY_CTAB: int
+KEY_DC: int
+KEY_DL: int
+KEY_DOWN: int
+KEY_EIC: int
+KEY_END: int
+KEY_ENTER: int
+KEY_EOL: int
+KEY_EOS: int
+KEY_EXIT: int
+KEY_F0: int
+KEY_F1: int
+KEY_F10: int
+KEY_F11: int
+KEY_F12: int
+KEY_F13: int
+KEY_F14: int
+KEY_F15: int
+KEY_F16: int
+KEY_F17: int
+KEY_F18: int
+KEY_F19: int
+KEY_F2: int
+KEY_F20: int
+KEY_F21: int
+KEY_F22: int
+KEY_F23: int
+KEY_F24: int
+KEY_F25: int
+KEY_F26: int
+KEY_F27: int
+KEY_F28: int
+KEY_F29: int
+KEY_F3: int
+KEY_F30: int
+KEY_F31: int
+KEY_F32: int
+KEY_F33: int
+KEY_F34: int
+KEY_F35: int
+KEY_F36: int
+KEY_F37: int
+KEY_F38: int
+KEY_F39: int
+KEY_F4: int
+KEY_F40: int
+KEY_F41: int
+KEY_F42: int
+KEY_F43: int
+KEY_F44: int
+KEY_F45: int
+KEY_F46: int
+KEY_F47: int
+KEY_F48: int
+KEY_F49: int
+KEY_F5: int
+KEY_F50: int
+KEY_F51: int
+KEY_F52: int
+KEY_F53: int
+KEY_F54: int
+KEY_F55: int
+KEY_F56: int
+KEY_F57: int
+KEY_F58: int
+KEY_F59: int
+KEY_F6: int
+KEY_F60: int
+KEY_F61: int
+KEY_F62: int
+KEY_F63: int
+KEY_F7: int
+KEY_F8: int
+KEY_F9: int
+KEY_FIND: int
+KEY_HELP: int
+KEY_HOME: int
+KEY_IC: int
+KEY_IL: int
+KEY_LEFT: int
+KEY_LL: int
+KEY_MARK: int
+KEY_MAX: int
+KEY_MESSAGE: int
+KEY_MIN: int
+KEY_MOUSE: int
+KEY_MOVE: int
+KEY_NEXT: int
+KEY_NPAGE: int
+KEY_OPEN: int
+KEY_OPTIONS: int
+KEY_PPAGE: int
+KEY_PREVIOUS: int
+KEY_PRINT: int
+KEY_REDO: int
+KEY_REFERENCE: int
+KEY_REFRESH: int
+KEY_REPLACE: int
+KEY_RESET: int
+KEY_RESIZE: int
+KEY_RESTART: int
+KEY_RESUME: int
+KEY_RIGHT: int
+KEY_SAVE: int
+KEY_SBEG: int
+KEY_SCANCEL: int
+KEY_SCOMMAND: int
+KEY_SCOPY: int
+KEY_SCREATE: int
+KEY_SDC: int
+KEY_SDL: int
+KEY_SELECT: int
+KEY_SEND: int
+KEY_SEOL: int
+KEY_SEXIT: int
+KEY_SF: int
+KEY_SFIND: int
+KEY_SHELP: int
+KEY_SHOME: int
+KEY_SIC: int
+KEY_SLEFT: int
+KEY_SMESSAGE: int
+KEY_SMOVE: int
+KEY_SNEXT: int
+KEY_SOPTIONS: int
+KEY_SPREVIOUS: int
+KEY_SPRINT: int
+KEY_SR: int
+KEY_SREDO: int
+KEY_SREPLACE: int
+KEY_SRESET: int
+KEY_SRIGHT: int
+KEY_SRSUME: int
+KEY_SSAVE: int
+KEY_SSUSPEND: int
+KEY_STAB: int
+KEY_SUNDO: int
+KEY_SUSPEND: int
+KEY_UNDO: int
+KEY_UP: int
+OK: int
+REPORT_MOUSE_POSITION: int
+_C_API: Any
+version: bytes
 
-    def getmouse() -> tuple[int, int, int, int, int]: ...
-    def getsyx() -> tuple[int, int]: ...
-    def getwin(__file: SupportsRead[bytes]) -> _CursesWindow: ...
-    def halfdelay(__tenths: int) -> None: ...
-    def has_colors() -> bool: ...
-    if sys.version_info >= (3, 10):
-        def has_extended_color_support() -> bool: ...
+def baudrate() -> int: ...
+def beep() -> None: ...
+def can_change_color() -> bool: ...
+def cbreak(flag: bool = True, /) -> None: ...
+def color_content(color_number: int, /) -> tuple[int, int, int]: ...
+def color_pair(pair_number: int, /) -> int: ...
+def curs_set(visibility: int, /) -> int: ...
+def def_prog_mode() -> None: ...
+def def_shell_mode() -> None: ...
+def delay_output(ms: int, /) -> None: ...
+def doupdate() -> None: ...
+def echo(flag: bool = True, /) -> None: ...
+def endwin() -> None: ...
+def erasechar() -> bytes: ...
+def filter() -> None: ...
+def flash() -> None: ...
+def flushinp() -> None: ...
 
-    def has_ic() -> bool: ...
-    def has_il() -> bool: ...
-    def has_key(__key: int) -> bool: ...
-    def init_color(__color_number: int, __r: int, __g: int, __b: int) -> None: ...
-    def init_pair(__pair_number: int, __fg: int, __bg: int) -> None: ...
-    def initscr() -> _CursesWindow: ...
-    def intrflush(__flag: bool) -> None: ...
-    def is_term_resized(__nlines: int, __ncols: int) -> bool: ...
-    def isendwin() -> bool: ...
-    def keyname(__key: int) -> bytes: ...
-    def killchar() -> bytes: ...
-    def longname() -> bytes: ...
-    def meta(__yes: bool) -> None: ...
-    def mouseinterval(__interval: int) -> None: ...
-    def mousemask(__newmask: int) -> tuple[int, int]: ...
-    def napms(__ms: int) -> int: ...
-    def newpad(__nlines: int, __ncols: int) -> _CursesWindow: ...
-    def newwin(__nlines: int, __ncols: int, __begin_y: int = ..., __begin_x: int = ...) -> _CursesWindow: ...
-    def nl(__flag: bool = True) -> None: ...
-    def nocbreak() -> None: ...
-    def noecho() -> None: ...
-    def nonl() -> None: ...
-    def noqiflush() -> None: ...
-    def noraw() -> None: ...
-    def pair_content(__pair_number: int) -> tuple[int, int]: ...
-    def pair_number(__attr: int) -> int: ...
-    def putp(__string: ReadOnlyBuffer) -> None: ...
-    def qiflush(__flag: bool = True) -> None: ...
-    def raw(__flag: bool = True) -> None: ...
-    def reset_prog_mode() -> None: ...
-    def reset_shell_mode() -> None: ...
-    def resetty() -> None: ...
-    def resize_term(__nlines: int, __ncols: int) -> None: ...
-    def resizeterm(__nlines: int, __ncols: int) -> None: ...
-    def savetty() -> None: ...
-    if sys.version_info >= (3, 9):
-        def set_escdelay(__ms: int) -> None: ...
-        def set_tabsize(__size: int) -> None: ...
+if sys.version_info >= (3, 9):
+    def get_escdelay() -> int: ...
+    def get_tabsize() -> int: ...
 
-    def setsyx(__y: int, __x: int) -> None: ...
-    def setupterm(term: str | None = None, fd: int = -1) -> None: ...
-    def start_color() -> None: ...
-    def termattrs() -> int: ...
-    def termname() -> bytes: ...
-    def tigetflag(__capname: str) -> int: ...
-    def tigetnum(__capname: str) -> int: ...
-    def tigetstr(__capname: str) -> bytes | None: ...
-    def tparm(
-        __str: ReadOnlyBuffer,
-        __i1: int = 0,
-        __i2: int = 0,
-        __i3: int = 0,
-        __i4: int = 0,
-        __i5: int = 0,
-        __i6: int = 0,
-        __i7: int = 0,
-        __i8: int = 0,
-        __i9: int = 0,
-    ) -> bytes: ...
-    def typeahead(__fd: int) -> None: ...
-    def unctrl(__ch: _ChType) -> bytes: ...
-    def unget_wch(__ch: int | str) -> None: ...
-    def ungetch(__ch: _ChType) -> None: ...
-    def ungetmouse(__id: int, __x: int, __y: int, __z: int, __bstate: int) -> None: ...
-    def update_lines_cols() -> None: ...
-    def use_default_colors() -> None: ...
-    def use_env(__flag: bool) -> None: ...
+def getmouse() -> tuple[int, int, int, int, int]: ...
+def getsyx() -> tuple[int, int]: ...
+def getwin(file: SupportsRead[bytes], /) -> window: ...
+def halfdelay(tenths: int, /) -> None: ...
+def has_colors() -> bool: ...
 
-    class error(Exception): ...
+if sys.version_info >= (3, 10):
+    def has_extended_color_support() -> bool: ...
 
-    @final
-    class _CursesWindow:
-        encoding: str
-        @overload
-        def addch(self, ch: _ChType, attr: int = ...) -> None: ...
-        @overload
-        def addch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None: ...
-        @overload
-        def addnstr(self, str: str, n: int, attr: int = ...) -> None: ...
-        @overload
-        def addnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
-        @overload
-        def addstr(self, str: str, attr: int = ...) -> None: ...
-        @overload
-        def addstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
-        def attroff(self, __attr: int) -> None: ...
-        def attron(self, __attr: int) -> None: ...
-        def attrset(self, __attr: int) -> None: ...
-        def bkgd(self, __ch: _ChType, __attr: int = ...) -> None: ...
-        def bkgdset(self, __ch: _ChType, __attr: int = ...) -> None: ...
-        def border(
-            self,
-            ls: _ChType = ...,
-            rs: _ChType = ...,
-            ts: _ChType = ...,
-            bs: _ChType = ...,
-            tl: _ChType = ...,
-            tr: _ChType = ...,
-            bl: _ChType = ...,
-            br: _ChType = ...,
-        ) -> None: ...
-        @overload
-        def box(self) -> None: ...
-        @overload
-        def box(self, vertch: _ChType = ..., horch: _ChType = ...) -> None: ...
-        @overload
-        def chgat(self, attr: int) -> None: ...
-        @overload
-        def chgat(self, num: int, attr: int) -> None: ...
-        @overload
-        def chgat(self, y: int, x: int, attr: int) -> None: ...
-        @overload
-        def chgat(self, y: int, x: int, num: int, attr: int) -> None: ...
-        def clear(self) -> None: ...
-        def clearok(self, yes: int) -> None: ...
-        def clrtobot(self) -> None: ...
-        def clrtoeol(self) -> None: ...
-        def cursyncup(self) -> None: ...
-        @overload
-        def delch(self) -> None: ...
-        @overload
-        def delch(self, y: int, x: int) -> None: ...
-        def deleteln(self) -> None: ...
-        @overload
-        def derwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
-        @overload
-        def derwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
-        def echochar(self, __ch: _ChType, __attr: int = ...) -> None: ...
-        def enclose(self, __y: int, __x: int) -> bool: ...
-        def erase(self) -> None: ...
-        def getbegyx(self) -> tuple[int, int]: ...
-        def getbkgd(self) -> tuple[int, int]: ...
-        @overload
-        def getch(self) -> int: ...
-        @overload
-        def getch(self, y: int, x: int) -> int: ...
-        @overload
-        def get_wch(self) -> int | str: ...
-        @overload
-        def get_wch(self, y: int, x: int) -> int | str: ...
-        @overload
-        def getkey(self) -> str: ...
-        @overload
-        def getkey(self, y: int, x: int) -> str: ...
-        def getmaxyx(self) -> tuple[int, int]: ...
-        def getparyx(self) -> tuple[int, int]: ...
-        @overload
-        def getstr(self) -> bytes: ...
-        @overload
-        def getstr(self, n: int) -> bytes: ...
-        @overload
-        def getstr(self, y: int, x: int) -> bytes: ...
-        @overload
-        def getstr(self, y: int, x: int, n: int) -> bytes: ...
-        def getyx(self) -> tuple[int, int]: ...
-        @overload
-        def hline(self, ch: _ChType, n: int) -> None: ...
-        @overload
-        def hline(self, y: int, x: int, ch: _ChType, n: int) -> None: ...
-        def idcok(self, flag: bool) -> None: ...
-        def idlok(self, yes: bool) -> None: ...
-        def immedok(self, flag: bool) -> None: ...
-        @overload
-        def inch(self) -> int: ...
-        @overload
-        def inch(self, y: int, x: int) -> int: ...
-        @overload
-        def insch(self, ch: _ChType, attr: int = ...) -> None: ...
-        @overload
-        def insch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None: ...
-        def insdelln(self, nlines: int) -> None: ...
-        def insertln(self) -> None: ...
-        @overload
-        def insnstr(self, str: str, n: int, attr: int = ...) -> None: ...
-        @overload
-        def insnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
-        @overload
-        def insstr(self, str: str, attr: int = ...) -> None: ...
-        @overload
-        def insstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
-        @overload
-        def instr(self, n: int = ...) -> bytes: ...
-        @overload
-        def instr(self, y: int, x: int, n: int = ...) -> bytes: ...
-        def is_linetouched(self, __line: int) -> bool: ...
-        def is_wintouched(self) -> bool: ...
-        def keypad(self, yes: bool) -> None: ...
-        def leaveok(self, yes: bool) -> None: ...
-        def move(self, new_y: int, new_x: int) -> None: ...
-        def mvderwin(self, y: int, x: int) -> None: ...
-        def mvwin(self, new_y: int, new_x: int) -> None: ...
-        def nodelay(self, yes: bool) -> None: ...
-        def notimeout(self, yes: bool) -> None: ...
-        @overload
-        def noutrefresh(self) -> None: ...
-        @overload
-        def noutrefresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ...
-        @overload
-        def overlay(self, destwin: _CursesWindow) -> None: ...
-        @overload
-        def overlay(
-            self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
-        ) -> None: ...
-        @overload
-        def overwrite(self, destwin: _CursesWindow) -> None: ...
-        @overload
-        def overwrite(
-            self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
-        ) -> None: ...
-        def putwin(self, __file: IO[Any]) -> None: ...
-        def redrawln(self, __beg: int, __num: int) -> None: ...
-        def redrawwin(self) -> None: ...
-        @overload
-        def refresh(self) -> None: ...
-        @overload
-        def refresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ...
-        def resize(self, nlines: int, ncols: int) -> None: ...
-        def scroll(self, lines: int = ...) -> None: ...
-        def scrollok(self, flag: bool) -> None: ...
-        def setscrreg(self, __top: int, __bottom: int) -> None: ...
-        def standend(self) -> None: ...
-        def standout(self) -> None: ...
-        @overload
-        def subpad(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
-        @overload
-        def subpad(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
-        @overload
-        def subwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ...
-        @overload
-        def subwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ...
-        def syncdown(self) -> None: ...
-        def syncok(self, flag: bool) -> None: ...
-        def syncup(self) -> None: ...
-        def timeout(self, delay: int) -> None: ...
-        def touchline(self, start: int, count: int, changed: bool = ...) -> None: ...
-        def touchwin(self) -> None: ...
-        def untouchwin(self) -> None: ...
-        @overload
-        def vline(self, ch: _ChType, n: int) -> None: ...
-        @overload
-        def vline(self, y: int, x: int, ch: _ChType, n: int) -> None: ...
-    if sys.version_info >= (3, 8):
-        class _ncurses_version(NamedTuple):
-            major: int
-            minor: int
-            patch: int
-        ncurses_version: _ncurses_version
-        window = _CursesWindow  # undocumented
+def has_ic() -> bool: ...
+def has_il() -> bool: ...
+def has_key(key: int, /) -> bool: ...
+def init_color(color_number: int, r: int, g: int, b: int, /) -> None: ...
+def init_pair(pair_number: int, fg: int, bg: int, /) -> None: ...
+def initscr() -> window: ...
+def intrflush(flag: bool, /) -> None: ...
+def is_term_resized(nlines: int, ncols: int, /) -> bool: ...
+def isendwin() -> bool: ...
+def keyname(key: int, /) -> bytes: ...
+def killchar() -> bytes: ...
+def longname() -> bytes: ...
+def meta(yes: bool, /) -> None: ...
+def mouseinterval(interval: int, /) -> None: ...
+def mousemask(newmask: int, /) -> tuple[int, int]: ...
+def napms(ms: int, /) -> int: ...
+def newpad(nlines: int, ncols: int, /) -> window: ...
+def newwin(nlines: int, ncols: int, begin_y: int = ..., begin_x: int = ..., /) -> window: ...
+def nl(flag: bool = True, /) -> None: ...
+def nocbreak() -> None: ...
+def noecho() -> None: ...
+def nonl() -> None: ...
+def noqiflush() -> None: ...
+def noraw() -> None: ...
+def pair_content(pair_number: int, /) -> tuple[int, int]: ...
+def pair_number(attr: int, /) -> int: ...
+def putp(string: ReadOnlyBuffer, /) -> None: ...
+def qiflush(flag: bool = True, /) -> None: ...
+def raw(flag: bool = True, /) -> None: ...
+def reset_prog_mode() -> None: ...
+def reset_shell_mode() -> None: ...
+def resetty() -> None: ...
+def resize_term(nlines: int, ncols: int, /) -> None: ...
+def resizeterm(nlines: int, ncols: int, /) -> None: ...
+def savetty() -> None: ...
+
+if sys.version_info >= (3, 9):
+    def set_escdelay(ms: int, /) -> None: ...
+    def set_tabsize(size: int, /) -> None: ...
+
+def setsyx(y: int, x: int, /) -> None: ...
+def setupterm(term: str | None = None, fd: int = -1) -> None: ...
+def start_color() -> None: ...
+def termattrs() -> int: ...
+def termname() -> bytes: ...
+def tigetflag(capname: str, /) -> int: ...
+def tigetnum(capname: str, /) -> int: ...
+def tigetstr(capname: str, /) -> bytes | None: ...
+def tparm(
+    str: ReadOnlyBuffer,
+    i1: int = 0,
+    i2: int = 0,
+    i3: int = 0,
+    i4: int = 0,
+    i5: int = 0,
+    i6: int = 0,
+    i7: int = 0,
+    i8: int = 0,
+    i9: int = 0,
+    /,
+) -> bytes: ...
+def typeahead(fd: int, /) -> None: ...
+def unctrl(ch: _ChType, /) -> bytes: ...
+def unget_wch(ch: int | str, /) -> None: ...
+def ungetch(ch: _ChType, /) -> None: ...
+def ungetmouse(id: int, x: int, y: int, z: int, bstate: int, /) -> None: ...
+def update_lines_cols() -> None: ...
+def use_default_colors() -> None: ...
+def use_env(flag: bool, /) -> None: ...
+
+class error(Exception): ...
+
+@final
+class window:  # undocumented
+    encoding: str
+    @overload
+    def addch(self, ch: _ChType, attr: int = ...) -> None: ...
+    @overload
+    def addch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None: ...
+    @overload
+    def addnstr(self, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def addnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def addstr(self, str: str, attr: int = ...) -> None: ...
+    @overload
+    def addstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
+    def attroff(self, attr: int, /) -> None: ...
+    def attron(self, attr: int, /) -> None: ...
+    def attrset(self, attr: int, /) -> None: ...
+    def bkgd(self, ch: _ChType, attr: int = ..., /) -> None: ...
+    def bkgdset(self, ch: _ChType, attr: int = ..., /) -> None: ...
+    def border(
+        self,
+        ls: _ChType = ...,
+        rs: _ChType = ...,
+        ts: _ChType = ...,
+        bs: _ChType = ...,
+        tl: _ChType = ...,
+        tr: _ChType = ...,
+        bl: _ChType = ...,
+        br: _ChType = ...,
+    ) -> None: ...
+    @overload
+    def box(self) -> None: ...
+    @overload
+    def box(self, vertch: _ChType = ..., horch: _ChType = ...) -> None: ...
+    @overload
+    def chgat(self, attr: int) -> None: ...
+    @overload
+    def chgat(self, num: int, attr: int) -> None: ...
+    @overload
+    def chgat(self, y: int, x: int, attr: int) -> None: ...
+    @overload
+    def chgat(self, y: int, x: int, num: int, attr: int) -> None: ...
+    def clear(self) -> None: ...
+    def clearok(self, yes: int) -> None: ...
+    def clrtobot(self) -> None: ...
+    def clrtoeol(self) -> None: ...
+    def cursyncup(self) -> None: ...
+    @overload
+    def delch(self) -> None: ...
+    @overload
+    def delch(self, y: int, x: int) -> None: ...
+    def deleteln(self) -> None: ...
+    @overload
+    def derwin(self, begin_y: int, begin_x: int) -> window: ...
+    @overload
+    def derwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> window: ...
+    def echochar(self, ch: _ChType, attr: int = ..., /) -> None: ...
+    def enclose(self, y: int, x: int, /) -> bool: ...
+    def erase(self) -> None: ...
+    def getbegyx(self) -> tuple[int, int]: ...
+    def getbkgd(self) -> tuple[int, int]: ...
+    @overload
+    def getch(self) -> int: ...
+    @overload
+    def getch(self, y: int, x: int) -> int: ...
+    @overload
+    def get_wch(self) -> int | str: ...
+    @overload
+    def get_wch(self, y: int, x: int) -> int | str: ...
+    @overload
+    def getkey(self) -> str: ...
+    @overload
+    def getkey(self, y: int, x: int) -> str: ...
+    def getmaxyx(self) -> tuple[int, int]: ...
+    def getparyx(self) -> tuple[int, int]: ...
+    @overload
+    def getstr(self) -> bytes: ...
+    @overload
+    def getstr(self, n: int) -> bytes: ...
+    @overload
+    def getstr(self, y: int, x: int) -> bytes: ...
+    @overload
+    def getstr(self, y: int, x: int, n: int) -> bytes: ...
+    def getyx(self) -> tuple[int, int]: ...
+    @overload
+    def hline(self, ch: _ChType, n: int) -> None: ...
+    @overload
+    def hline(self, y: int, x: int, ch: _ChType, n: int) -> None: ...
+    def idcok(self, flag: bool) -> None: ...
+    def idlok(self, yes: bool) -> None: ...
+    def immedok(self, flag: bool) -> None: ...
+    @overload
+    def inch(self) -> int: ...
+    @overload
+    def inch(self, y: int, x: int) -> int: ...
+    @overload
+    def insch(self, ch: _ChType, attr: int = ...) -> None: ...
+    @overload
+    def insch(self, y: int, x: int, ch: _ChType, attr: int = ...) -> None: ...
+    def insdelln(self, nlines: int) -> None: ...
+    def insertln(self) -> None: ...
+    @overload
+    def insnstr(self, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def insnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ...
+    @overload
+    def insstr(self, str: str, attr: int = ...) -> None: ...
+    @overload
+    def insstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ...
+    @overload
+    def instr(self, n: int = ...) -> bytes: ...
+    @overload
+    def instr(self, y: int, x: int, n: int = ...) -> bytes: ...
+    def is_linetouched(self, line: int, /) -> bool: ...
+    def is_wintouched(self) -> bool: ...
+    def keypad(self, yes: bool, /) -> None: ...
+    def leaveok(self, yes: bool) -> None: ...
+    def move(self, new_y: int, new_x: int) -> None: ...
+    def mvderwin(self, y: int, x: int) -> None: ...
+    def mvwin(self, new_y: int, new_x: int) -> None: ...
+    def nodelay(self, yes: bool) -> None: ...
+    def notimeout(self, yes: bool) -> None: ...
+    @overload
+    def noutrefresh(self) -> None: ...
+    @overload
+    def noutrefresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ...
+    @overload
+    def overlay(self, destwin: window) -> None: ...
+    @overload
+    def overlay(
+        self, destwin: window, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
+    ) -> None: ...
+    @overload
+    def overwrite(self, destwin: window) -> None: ...
+    @overload
+    def overwrite(
+        self, destwin: window, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int
+    ) -> None: ...
+    def putwin(self, file: SupportsWrite[bytes], /) -> None: ...
+    def redrawln(self, beg: int, num: int, /) -> None: ...
+    def redrawwin(self) -> None: ...
+    @overload
+    def refresh(self) -> None: ...
+    @overload
+    def refresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ...
+    def resize(self, nlines: int, ncols: int) -> None: ...
+    def scroll(self, lines: int = ...) -> None: ...
+    def scrollok(self, flag: bool) -> None: ...
+    def setscrreg(self, top: int, bottom: int, /) -> None: ...
+    def standend(self) -> None: ...
+    def standout(self) -> None: ...
+    @overload
+    def subpad(self, begin_y: int, begin_x: int) -> window: ...
+    @overload
+    def subpad(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> window: ...
+    @overload
+    def subwin(self, begin_y: int, begin_x: int) -> window: ...
+    @overload
+    def subwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> window: ...
+    def syncdown(self) -> None: ...
+    def syncok(self, flag: bool) -> None: ...
+    def syncup(self) -> None: ...
+    def timeout(self, delay: int) -> None: ...
+    def touchline(self, start: int, count: int, changed: bool = ...) -> None: ...
+    def touchwin(self) -> None: ...
+    def untouchwin(self) -> None: ...
+    @overload
+    def vline(self, ch: _ChType, n: int) -> None: ...
+    @overload
+    def vline(self, y: int, x: int, ch: _ChType, n: int) -> None: ...
+
+ncurses_version: _ncurses_version
diff --git a/mypy/typeshed/stdlib/_curses_panel.pyi b/mypy/typeshed/stdlib/_curses_panel.pyi
new file mode 100644
index 000000000000..ddec22236b96
--- /dev/null
+++ b/mypy/typeshed/stdlib/_curses_panel.pyi
@@ -0,0 +1,27 @@
+from _curses import window
+from typing import final
+
+__version__: str
+version: str
+
+class error(Exception): ...
+
+@final
+class panel:
+    def above(self) -> panel: ...
+    def below(self) -> panel: ...
+    def bottom(self) -> None: ...
+    def hidden(self) -> bool: ...
+    def hide(self) -> None: ...
+    def move(self, y: int, x: int, /) -> None: ...
+    def replace(self, win: window, /) -> None: ...
+    def set_userptr(self, obj: object, /) -> None: ...
+    def show(self) -> None: ...
+    def top(self) -> None: ...
+    def userptr(self) -> object: ...
+    def window(self) -> window: ...
+
+def bottom_panel() -> panel: ...
+def new_panel(win: window, /) -> panel: ...
+def top_panel() -> panel: ...
+def update_panels() -> panel: ...
diff --git a/mypy/typeshed/stdlib/_dbm.pyi b/mypy/typeshed/stdlib/_dbm.pyi
new file mode 100644
index 000000000000..7e53cca3c704
--- /dev/null
+++ b/mypy/typeshed/stdlib/_dbm.pyi
@@ -0,0 +1,44 @@
+import sys
+from _typeshed import ReadOnlyBuffer, StrOrBytesPath
+from types import TracebackType
+from typing import TypeVar, final, overload, type_check_only
+from typing_extensions import Self, TypeAlias
+
+if sys.platform != "win32":
+    _T = TypeVar("_T")
+    _KeyType: TypeAlias = str | ReadOnlyBuffer
+    _ValueType: TypeAlias = str | ReadOnlyBuffer
+
+    class error(OSError): ...
+    library: str
+
+    # Actual typename dbm, not exposed by the implementation
+    @final
+    @type_check_only
+    class _dbm:
+        def close(self) -> None: ...
+        if sys.version_info >= (3, 13):
+            def clear(self) -> None: ...
+
+        def __getitem__(self, item: _KeyType) -> bytes: ...
+        def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
+        def __delitem__(self, key: _KeyType) -> None: ...
+        def __len__(self) -> int: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+        ) -> None: ...
+        @overload
+        def get(self, k: _KeyType, /) -> bytes | None: ...
+        @overload
+        def get(self, k: _KeyType, default: _T, /) -> bytes | _T: ...
+        def keys(self) -> list[bytes]: ...
+        def setdefault(self, k: _KeyType, default: _ValueType = ..., /) -> bytes: ...
+        # This isn't true, but the class can't be instantiated. See #13024
+        __new__: None  # type: ignore[assignment]
+        __init__: None  # type: ignore[assignment]
+
+    if sys.version_info >= (3, 11):
+        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...
+    else:
+        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _dbm: ...
diff --git a/mypy/typeshed/stdlib/_decimal.pyi b/mypy/typeshed/stdlib/_decimal.pyi
index 60c609456954..06c0197dcf07 100644
--- a/mypy/typeshed/stdlib/_decimal.pyi
+++ b/mypy/typeshed/stdlib/_decimal.pyi
@@ -1,53 +1,48 @@
-import numbers
 import sys
-from collections.abc import Container, Sequence
-from types import TracebackType
-from typing import Any, ClassVar, NamedTuple, overload
-from typing_extensions import Final, Literal, Self, TypeAlias
+from decimal import (
+    Clamped as Clamped,
+    Context as Context,
+    ConversionSyntax as ConversionSyntax,
+    Decimal as Decimal,
+    DecimalException as DecimalException,
+    DecimalTuple as DecimalTuple,
+    DivisionByZero as DivisionByZero,
+    DivisionImpossible as DivisionImpossible,
+    DivisionUndefined as DivisionUndefined,
+    FloatOperation as FloatOperation,
+    Inexact as Inexact,
+    InvalidContext as InvalidContext,
+    InvalidOperation as InvalidOperation,
+    Overflow as Overflow,
+    Rounded as Rounded,
+    Subnormal as Subnormal,
+    Underflow as Underflow,
+    _ContextManager,
+)
+from typing import Final
+from typing_extensions import TypeAlias
 
-_Decimal: TypeAlias = Decimal | int
-_DecimalNew: TypeAlias = Decimal | float | str | tuple[int, Sequence[int], int]
-_ComparableNum: TypeAlias = Decimal | float | numbers.Rational
+_TrapType: TypeAlias = type[DecimalException]
 
 __version__: Final[str]
 __libmpdec_version__: Final[str]
 
-class DecimalTuple(NamedTuple):
-    sign: int
-    digits: tuple[int, ...]
-    exponent: int | Literal["n", "N", "F"]
-
-ROUND_DOWN: str
-ROUND_HALF_UP: str
-ROUND_HALF_EVEN: str
-ROUND_CEILING: str
-ROUND_FLOOR: str
-ROUND_UP: str
-ROUND_HALF_DOWN: str
-ROUND_05UP: str
-HAVE_CONTEXTVAR: bool
-HAVE_THREADS: bool
-MAX_EMAX: int
-MAX_PREC: int
-MIN_EMIN: int
-MIN_ETINY: int
+ROUND_DOWN: Final = "ROUND_DOWN"
+ROUND_HALF_UP: Final = "ROUND_HALF_UP"
+ROUND_HALF_EVEN: Final = "ROUND_HALF_EVEN"
+ROUND_CEILING: Final = "ROUND_CEILING"
+ROUND_FLOOR: Final = "ROUND_FLOOR"
+ROUND_UP: Final = "ROUND_UP"
+ROUND_HALF_DOWN: Final = "ROUND_HALF_DOWN"
+ROUND_05UP: Final = "ROUND_05UP"
+HAVE_CONTEXTVAR: Final[bool]
+HAVE_THREADS: Final[bool]
+MAX_EMAX: Final[int]
+MAX_PREC: Final[int]
+MIN_EMIN: Final[int]
+MIN_ETINY: Final[int]
 
-class DecimalException(ArithmeticError): ...
-class Clamped(DecimalException): ...
-class InvalidOperation(DecimalException): ...
-class ConversionSyntax(InvalidOperation): ...
-class DivisionByZero(DecimalException, ZeroDivisionError): ...
-class DivisionImpossible(InvalidOperation): ...
-class DivisionUndefined(InvalidOperation, ZeroDivisionError): ...
-class Inexact(DecimalException): ...
-class InvalidContext(InvalidOperation): ...
-class Rounded(DecimalException): ...
-class Subnormal(DecimalException): ...
-class Overflow(Inexact, Rounded): ...
-class Underflow(Inexact, Rounded, Subnormal): ...
-class FloatOperation(DecimalException, TypeError): ...
-
-def setcontext(__context: Context) -> None: ...
+def setcontext(context: Context, /) -> None: ...
 def getcontext() -> Context: ...
 
 if sys.version_info >= (3, 11):
@@ -67,214 +62,6 @@ if sys.version_info >= (3, 11):
 else:
     def localcontext(ctx: Context | None = None) -> _ContextManager: ...
 
-class Decimal:
-    def __new__(cls, value: _DecimalNew = ..., context: Context | None = ...) -> Self: ...
-    @classmethod
-    def from_float(cls, __f: float) -> Self: ...
-    def __bool__(self) -> bool: ...
-    def compare(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def as_tuple(self) -> DecimalTuple: ...
-    def as_integer_ratio(self) -> tuple[int, int]: ...
-    def to_eng_string(self, context: Context | None = None) -> str: ...
-    def __abs__(self) -> Decimal: ...
-    def __add__(self, __value: _Decimal) -> Decimal: ...
-    def __divmod__(self, __value: _Decimal) -> tuple[Decimal, Decimal]: ...
-    def __eq__(self, __value: object) -> bool: ...
-    def __floordiv__(self, __value: _Decimal) -> Decimal: ...
-    def __ge__(self, __value: _ComparableNum) -> bool: ...
-    def __gt__(self, __value: _ComparableNum) -> bool: ...
-    def __le__(self, __value: _ComparableNum) -> bool: ...
-    def __lt__(self, __value: _ComparableNum) -> bool: ...
-    def __mod__(self, __value: _Decimal) -> Decimal: ...
-    def __mul__(self, __value: _Decimal) -> Decimal: ...
-    def __neg__(self) -> Decimal: ...
-    def __pos__(self) -> Decimal: ...
-    def __pow__(self, __value: _Decimal, __mod: _Decimal | None = None) -> Decimal: ...
-    def __radd__(self, __value: _Decimal) -> Decimal: ...
-    def __rdivmod__(self, __value: _Decimal) -> tuple[Decimal, Decimal]: ...
-    def __rfloordiv__(self, __value: _Decimal) -> Decimal: ...
-    def __rmod__(self, __value: _Decimal) -> Decimal: ...
-    def __rmul__(self, __value: _Decimal) -> Decimal: ...
-    def __rsub__(self, __value: _Decimal) -> Decimal: ...
-    def __rtruediv__(self, __value: _Decimal) -> Decimal: ...
-    def __sub__(self, __value: _Decimal) -> Decimal: ...
-    def __truediv__(self, __value: _Decimal) -> Decimal: ...
-    def remainder_near(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def __float__(self) -> float: ...
-    def __int__(self) -> int: ...
-    def __trunc__(self) -> int: ...
-    @property
-    def real(self) -> Decimal: ...
-    @property
-    def imag(self) -> Decimal: ...
-    def conjugate(self) -> Decimal: ...
-    def __complex__(self) -> complex: ...
-    @overload
-    def __round__(self) -> int: ...
-    @overload
-    def __round__(self, __ndigits: int) -> Decimal: ...
-    def __floor__(self) -> int: ...
-    def __ceil__(self) -> int: ...
-    def fma(self, other: _Decimal, third: _Decimal, context: Context | None = None) -> Decimal: ...
-    def __rpow__(self, __value: _Decimal, __mod: Context | None = None) -> Decimal: ...
-    def normalize(self, context: Context | None = None) -> Decimal: ...
-    def quantize(self, exp: _Decimal, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
-    def same_quantum(self, other: _Decimal, context: Context | None = None) -> bool: ...
-    def to_integral_exact(self, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
-    def to_integral_value(self, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
-    def to_integral(self, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
-    def sqrt(self, context: Context | None = None) -> Decimal: ...
-    def max(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def min(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def adjusted(self) -> int: ...
-    def canonical(self) -> Decimal: ...
-    def compare_signal(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def compare_total(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def compare_total_mag(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def copy_abs(self) -> Decimal: ...
-    def copy_negate(self) -> Decimal: ...
-    def copy_sign(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def exp(self, context: Context | None = None) -> Decimal: ...
-    def is_canonical(self) -> bool: ...
-    def is_finite(self) -> bool: ...
-    def is_infinite(self) -> bool: ...
-    def is_nan(self) -> bool: ...
-    def is_normal(self, context: Context | None = None) -> bool: ...
-    def is_qnan(self) -> bool: ...
-    def is_signed(self) -> bool: ...
-    def is_snan(self) -> bool: ...
-    def is_subnormal(self, context: Context | None = None) -> bool: ...
-    def is_zero(self) -> bool: ...
-    def ln(self, context: Context | None = None) -> Decimal: ...
-    def log10(self, context: Context | None = None) -> Decimal: ...
-    def logb(self, context: Context | None = None) -> Decimal: ...
-    def logical_and(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def logical_invert(self, context: Context | None = None) -> Decimal: ...
-    def logical_or(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def logical_xor(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def max_mag(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def min_mag(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def next_minus(self, context: Context | None = None) -> Decimal: ...
-    def next_plus(self, context: Context | None = None) -> Decimal: ...
-    def next_toward(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def number_class(self, context: Context | None = None) -> str: ...
-    def radix(self) -> Decimal: ...
-    def rotate(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def scaleb(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def shift(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
-    def __reduce__(self) -> tuple[type[Self], tuple[str]]: ...
-    def __copy__(self) -> Self: ...
-    def __deepcopy__(self, __memo: Any) -> Self: ...
-    def __format__(self, __specifier: str, __context: Context | None = ...) -> str: ...
-
-class _ContextManager:
-    new_context: Context
-    saved_context: Context
-    def __init__(self, new_context: Context) -> None: ...
-    def __enter__(self) -> Context: ...
-    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
-
-_TrapType: TypeAlias = type[DecimalException]
-
-class Context:
-    # TODO: Context doesn't allow you to delete *any* attributes from instances of the class at runtime,
-    # even settable attributes like `prec` and `rounding`,
-    # but that's inexpressable in the stub.
-    # Type checkers either ignore it or misinterpret it
-    # if you add a `def __delattr__(self, __name: str) -> NoReturn` method to the stub
-    prec: int
-    rounding: str
-    Emin: int
-    Emax: int
-    capitals: int
-    clamp: int
-    traps: dict[_TrapType, bool]
-    flags: dict[_TrapType, bool]
-    def __init__(
-        self,
-        prec: int | None = ...,
-        rounding: str | None = ...,
-        Emin: int | None = ...,
-        Emax: int | None = ...,
-        capitals: int | None = ...,
-        clamp: int | None = ...,
-        flags: None | dict[_TrapType, bool] | Container[_TrapType] = ...,
-        traps: None | dict[_TrapType, bool] | Container[_TrapType] = ...,
-        _ignored_flags: list[_TrapType] | None = ...,
-    ) -> None: ...
-    def __reduce__(self) -> tuple[type[Self], tuple[Any, ...]]: ...
-    def clear_flags(self) -> None: ...
-    def clear_traps(self) -> None: ...
-    def copy(self) -> Context: ...
-    def __copy__(self) -> Context: ...
-    # see https://github.com/python/cpython/issues/94107
-    __hash__: ClassVar[None]  # type: ignore[assignment]
-    def Etiny(self) -> int: ...
-    def Etop(self) -> int: ...
-    def create_decimal(self, __num: _DecimalNew = "0") -> Decimal: ...
-    def create_decimal_from_float(self, __f: float) -> Decimal: ...
-    def abs(self, __x: _Decimal) -> Decimal: ...
-    def add(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def canonical(self, __x: Decimal) -> Decimal: ...
-    def compare(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def compare_signal(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def compare_total(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def compare_total_mag(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def copy_abs(self, __x: _Decimal) -> Decimal: ...
-    def copy_decimal(self, __x: _Decimal) -> Decimal: ...
-    def copy_negate(self, __x: _Decimal) -> Decimal: ...
-    def copy_sign(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def divide(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def divide_int(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def divmod(self, __x: _Decimal, __y: _Decimal) -> tuple[Decimal, Decimal]: ...
-    def exp(self, __x: _Decimal) -> Decimal: ...
-    def fma(self, __x: _Decimal, __y: _Decimal, __z: _Decimal) -> Decimal: ...
-    def is_canonical(self, __x: _Decimal) -> bool: ...
-    def is_finite(self, __x: _Decimal) -> bool: ...
-    def is_infinite(self, __x: _Decimal) -> bool: ...
-    def is_nan(self, __x: _Decimal) -> bool: ...
-    def is_normal(self, __x: _Decimal) -> bool: ...
-    def is_qnan(self, __x: _Decimal) -> bool: ...
-    def is_signed(self, __x: _Decimal) -> bool: ...
-    def is_snan(self, __x: _Decimal) -> bool: ...
-    def is_subnormal(self, __x: _Decimal) -> bool: ...
-    def is_zero(self, __x: _Decimal) -> bool: ...
-    def ln(self, __x: _Decimal) -> Decimal: ...
-    def log10(self, __x: _Decimal) -> Decimal: ...
-    def logb(self, __x: _Decimal) -> Decimal: ...
-    def logical_and(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def logical_invert(self, __x: _Decimal) -> Decimal: ...
-    def logical_or(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def logical_xor(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def max(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def max_mag(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def min(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def min_mag(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def minus(self, __x: _Decimal) -> Decimal: ...
-    def multiply(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def next_minus(self, __x: _Decimal) -> Decimal: ...
-    def next_plus(self, __x: _Decimal) -> Decimal: ...
-    def next_toward(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def normalize(self, __x: _Decimal) -> Decimal: ...
-    def number_class(self, __x: _Decimal) -> str: ...
-    def plus(self, __x: _Decimal) -> Decimal: ...
-    def power(self, a: _Decimal, b: _Decimal, modulo: _Decimal | None = None) -> Decimal: ...
-    def quantize(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def radix(self) -> Decimal: ...
-    def remainder(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def remainder_near(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def rotate(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def same_quantum(self, __x: _Decimal, __y: _Decimal) -> bool: ...
-    def scaleb(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def shift(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def sqrt(self, __x: _Decimal) -> Decimal: ...
-    def subtract(self, __x: _Decimal, __y: _Decimal) -> Decimal: ...
-    def to_eng_string(self, __x: _Decimal) -> str: ...
-    def to_sci_string(self, __x: _Decimal) -> str: ...
-    def to_integral_exact(self, __x: _Decimal) -> Decimal: ...
-    def to_integral_value(self, __x: _Decimal) -> Decimal: ...
-    def to_integral(self, __x: _Decimal) -> Decimal: ...
-
 DefaultContext: Context
 BasicContext: Context
 ExtendedContext: Context
diff --git a/mypy/typeshed/stdlib/_dummy_thread.pyi b/mypy/typeshed/stdlib/_dummy_thread.pyi
index 541096734a91..1182e53c66c3 100644
--- a/mypy/typeshed/stdlib/_dummy_thread.pyi
+++ b/mypy/typeshed/stdlib/_dummy_thread.pyi
@@ -1,13 +1,19 @@
 from collections.abc import Callable
 from types import TracebackType
-from typing import Any, NoReturn
+from typing import Any, NoReturn, overload
+from typing_extensions import TypeVarTuple, Unpack
 
 __all__ = ["error", "start_new_thread", "exit", "get_ident", "allocate_lock", "interrupt_main", "LockType", "RLock"]
 
+_Ts = TypeVarTuple("_Ts")
+
 TIMEOUT_MAX: int
 error = RuntimeError
 
-def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any] = {}) -> None: ...
+@overload
+def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]]) -> None: ...
+@overload
+def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> None: ...
 def exit() -> NoReturn: ...
 def get_ident() -> int: ...
 def allocate_lock() -> LockType: ...
diff --git a/mypy/typeshed/stdlib/_dummy_threading.pyi b/mypy/typeshed/stdlib/_dummy_threading.pyi
index abcf3a13a496..1b66fb414d7a 100644
--- a/mypy/typeshed/stdlib/_dummy_threading.pyi
+++ b/mypy/typeshed/stdlib/_dummy_threading.pyi
@@ -1,10 +1,23 @@
-import sys
+from _threading_local import local as local
 from _typeshed import ProfileFunction, TraceFunction
-from collections.abc import Callable, Iterable, Mapping
-from types import TracebackType
-from typing import Any, TypeVar
-
-_T = TypeVar("_T")
+from threading import (
+    TIMEOUT_MAX as TIMEOUT_MAX,
+    Barrier as Barrier,
+    BoundedSemaphore as BoundedSemaphore,
+    BrokenBarrierError as BrokenBarrierError,
+    Condition as Condition,
+    Event as Event,
+    ExceptHookArgs as ExceptHookArgs,
+    Lock as Lock,
+    RLock as RLock,
+    Semaphore as Semaphore,
+    Thread as Thread,
+    ThreadError as ThreadError,
+    Timer as Timer,
+    _DummyThread as _DummyThread,
+    _RLock as _RLock,
+    excepthook as excepthook,
+)
 
 __all__ = [
     "get_ident",
@@ -28,11 +41,10 @@ __all__ = [
     "settrace",
     "local",
     "stack_size",
+    "ExceptHookArgs",
+    "excepthook",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["ExceptHookArgs", "excepthook"]
-
 def active_count() -> int: ...
 def current_thread() -> Thread: ...
 def currentThread() -> Thread: ...
@@ -42,128 +54,3 @@ def main_thread() -> Thread: ...
 def settrace(func: TraceFunction) -> None: ...
 def setprofile(func: ProfileFunction | None) -> None: ...
 def stack_size(size: int | None = None) -> int: ...
-
-TIMEOUT_MAX: float
-
-class ThreadError(Exception): ...
-
-class local:
-    def __getattribute__(self, name: str) -> Any: ...
-    def __setattr__(self, name: str, value: Any) -> None: ...
-    def __delattr__(self, name: str) -> None: ...
-
-class Thread:
-    name: str
-    daemon: bool
-    @property
-    def ident(self) -> int | None: ...
-    def __init__(
-        self,
-        group: None = None,
-        target: Callable[..., object] | None = None,
-        name: str | None = None,
-        args: Iterable[Any] = (),
-        kwargs: Mapping[str, Any] | None = None,
-        *,
-        daemon: bool | None = None,
-    ) -> None: ...
-    def start(self) -> None: ...
-    def run(self) -> None: ...
-    def join(self, timeout: float | None = None) -> None: ...
-    def getName(self) -> str: ...
-    def setName(self, name: str) -> None: ...
-    if sys.version_info >= (3, 8):
-        @property
-        def native_id(self) -> int | None: ...  # only available on some platforms
-
-    def is_alive(self) -> bool: ...
-    if sys.version_info < (3, 9):
-        def isAlive(self) -> bool: ...
-
-    def isDaemon(self) -> bool: ...
-    def setDaemon(self, daemonic: bool) -> None: ...
-
-class _DummyThread(Thread): ...
-
-class Lock:
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
-    def release(self) -> None: ...
-    def locked(self) -> bool: ...
-
-class _RLock:
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
-    def release(self) -> None: ...
-
-RLock = _RLock
-
-class Condition:
-    def __init__(self, lock: Lock | _RLock | None = None) -> None: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
-    def release(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-    def wait_for(self, predicate: Callable[[], _T], timeout: float | None = None) -> _T: ...
-    def notify(self, n: int = 1) -> None: ...
-    def notify_all(self) -> None: ...
-    def notifyAll(self) -> None: ...
-
-class Semaphore:
-    def __init__(self, value: int = 1) -> None: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
-    def __enter__(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def release(self, n: int = ...) -> None: ...
-    else:
-        def release(self) -> None: ...
-
-class BoundedSemaphore(Semaphore): ...
-
-class Event:
-    def is_set(self) -> bool: ...
-    def set(self) -> None: ...
-    def clear(self) -> None: ...
-    def wait(self, timeout: float | None = None) -> bool: ...
-
-if sys.version_info >= (3, 8):
-    from _thread import _excepthook, _ExceptHookArgs
-
-    excepthook = _excepthook
-    ExceptHookArgs = _ExceptHookArgs
-
-class Timer(Thread):
-    def __init__(
-        self,
-        interval: float,
-        function: Callable[..., object],
-        args: Iterable[Any] | None = None,
-        kwargs: Mapping[str, Any] | None = None,
-    ) -> None: ...
-    def cancel(self) -> None: ...
-
-class Barrier:
-    @property
-    def parties(self) -> int: ...
-    @property
-    def n_waiting(self) -> int: ...
-    @property
-    def broken(self) -> bool: ...
-    def __init__(self, parties: int, action: Callable[[], None] | None = None, timeout: float | None = None) -> None: ...
-    def wait(self, timeout: float | None = None) -> int: ...
-    def reset(self) -> None: ...
-    def abort(self) -> None: ...
-
-class BrokenBarrierError(RuntimeError): ...
diff --git a/mypy/typeshed/stdlib/_frozen_importlib.pyi b/mypy/typeshed/stdlib/_frozen_importlib.pyi
new file mode 100644
index 000000000000..3dbc8c6b52f0
--- /dev/null
+++ b/mypy/typeshed/stdlib/_frozen_importlib.pyi
@@ -0,0 +1,113 @@
+import importlib.abc
+import importlib.machinery
+import sys
+import types
+from _typeshed.importlib import LoaderProtocol
+from collections.abc import Mapping, Sequence
+from types import ModuleType
+from typing import Any, ClassVar
+
+# Signature of `builtins.__import__` should be kept identical to `importlib.__import__`
+def __import__(
+    name: str,
+    globals: Mapping[str, object] | None = None,
+    locals: Mapping[str, object] | None = None,
+    fromlist: Sequence[str] = (),
+    level: int = 0,
+) -> ModuleType: ...
+def spec_from_loader(
+    name: str, loader: LoaderProtocol | None, *, origin: str | None = None, is_package: bool | None = None
+) -> importlib.machinery.ModuleSpec | None: ...
+def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
+def _init_module_attrs(
+    spec: importlib.machinery.ModuleSpec, module: types.ModuleType, *, override: bool = False
+) -> types.ModuleType: ...
+
+class ModuleSpec:
+    def __init__(
+        self,
+        name: str,
+        loader: importlib.abc.Loader | None,
+        *,
+        origin: str | None = None,
+        loader_state: Any = None,
+        is_package: bool | None = None,
+    ) -> None: ...
+    name: str
+    loader: importlib.abc.Loader | None
+    origin: str | None
+    submodule_search_locations: list[str] | None
+    loader_state: Any
+    cached: str | None
+    @property
+    def parent(self) -> str | None: ...
+    has_location: bool
+    def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
+    # MetaPathFinder
+    if sys.version_info < (3, 12):
+        @classmethod
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+
+    @classmethod
+    def find_spec(
+        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
+    ) -> ModuleSpec | None: ...
+    # InspectLoader
+    @classmethod
+    def is_package(cls, fullname: str) -> bool: ...
+    @classmethod
+    def load_module(cls, fullname: str) -> types.ModuleType: ...
+    @classmethod
+    def get_code(cls, fullname: str) -> None: ...
+    @classmethod
+    def get_source(cls, fullname: str) -> None: ...
+    # Loader
+    if sys.version_info < (3, 12):
+        @staticmethod
+        def module_repr(module: types.ModuleType) -> str: ...
+    if sys.version_info >= (3, 10):
+        @staticmethod
+        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
+        @staticmethod
+        def exec_module(module: types.ModuleType) -> None: ...
+    else:
+        @classmethod
+        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
+        @classmethod
+        def exec_module(cls, module: types.ModuleType) -> None: ...
+
+class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
+    # MetaPathFinder
+    if sys.version_info < (3, 12):
+        @classmethod
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+
+    @classmethod
+    def find_spec(
+        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
+    ) -> ModuleSpec | None: ...
+    # InspectLoader
+    @classmethod
+    def is_package(cls, fullname: str) -> bool: ...
+    @classmethod
+    def load_module(cls, fullname: str) -> types.ModuleType: ...
+    @classmethod
+    def get_code(cls, fullname: str) -> None: ...
+    @classmethod
+    def get_source(cls, fullname: str) -> None: ...
+    # Loader
+    if sys.version_info < (3, 12):
+        @staticmethod
+        def module_repr(m: types.ModuleType) -> str: ...
+    if sys.version_info >= (3, 10):
+        @staticmethod
+        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
+    else:
+        @classmethod
+        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
+
+    @staticmethod
+    def exec_module(module: types.ModuleType) -> None: ...
diff --git a/mypy/typeshed/stdlib/_frozen_importlib_external.pyi b/mypy/typeshed/stdlib/_frozen_importlib_external.pyi
new file mode 100644
index 000000000000..386cf20808e4
--- /dev/null
+++ b/mypy/typeshed/stdlib/_frozen_importlib_external.pyi
@@ -0,0 +1,178 @@
+import _ast
+import _io
+import importlib.abc
+import importlib.machinery
+import sys
+import types
+from _typeshed import ReadableBuffer, StrOrBytesPath, StrPath
+from _typeshed.importlib import LoaderProtocol
+from collections.abc import Callable, Iterable, Iterator, Mapping, MutableSequence, Sequence
+from importlib.machinery import ModuleSpec
+from importlib.metadata import DistributionFinder, PathDistribution
+from typing import Any, Literal
+from typing_extensions import Self, deprecated
+
+if sys.version_info >= (3, 10):
+    import importlib.readers
+
+if sys.platform == "win32":
+    path_separators: Literal["\\/"]
+    path_sep: Literal["\\"]
+    path_sep_tuple: tuple[Literal["\\"], Literal["/"]]
+else:
+    path_separators: Literal["/"]
+    path_sep: Literal["/"]
+    path_sep_tuple: tuple[Literal["/"]]
+
+MAGIC_NUMBER: bytes
+
+def cache_from_source(path: StrPath, debug_override: bool | None = None, *, optimization: Any | None = None) -> str: ...
+def source_from_cache(path: StrPath) -> str: ...
+def decode_source(source_bytes: ReadableBuffer) -> str: ...
+def spec_from_file_location(
+    name: str,
+    location: StrOrBytesPath | None = None,
+    *,
+    loader: LoaderProtocol | None = None,
+    submodule_search_locations: list[str] | None = ...,
+) -> importlib.machinery.ModuleSpec | None: ...
+
+class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
+    if sys.version_info < (3, 12):
+        @classmethod
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+
+    @classmethod
+    def find_spec(
+        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
+    ) -> ModuleSpec | None: ...
+
+class PathFinder(importlib.abc.MetaPathFinder):
+    if sys.version_info >= (3, 10):
+        @staticmethod
+        def invalidate_caches() -> None: ...
+    else:
+        @classmethod
+        def invalidate_caches(cls) -> None: ...
+    if sys.version_info >= (3, 10):
+        @staticmethod
+        def find_distributions(context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
+    else:
+        @classmethod
+        def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
+
+    @classmethod
+    def find_spec(
+        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
+    ) -> ModuleSpec | None: ...
+    if sys.version_info < (3, 12):
+        @classmethod
+        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
+
+SOURCE_SUFFIXES: list[str]
+DEBUG_BYTECODE_SUFFIXES: list[str]
+OPTIMIZED_BYTECODE_SUFFIXES: list[str]
+BYTECODE_SUFFIXES: list[str]
+EXTENSION_SUFFIXES: list[str]
+
+class FileFinder(importlib.abc.PathEntryFinder):
+    path: str
+    def __init__(self, path: str, *loader_details: tuple[type[importlib.abc.Loader], list[str]]) -> None: ...
+    @classmethod
+    def path_hook(
+        cls, *loader_details: tuple[type[importlib.abc.Loader], list[str]]
+    ) -> Callable[[str], importlib.abc.PathEntryFinder]: ...
+
+class _LoaderBasics:
+    def is_package(self, fullname: str) -> bool: ...
+    def create_module(self, spec: ModuleSpec) -> types.ModuleType | None: ...
+    def exec_module(self, module: types.ModuleType) -> None: ...
+    def load_module(self, fullname: str) -> types.ModuleType: ...
+
+class SourceLoader(_LoaderBasics):
+    def path_mtime(self, path: str) -> float: ...
+    def set_data(self, path: str, data: bytes) -> None: ...
+    def get_source(self, fullname: str) -> str | None: ...
+    def path_stats(self, path: str) -> Mapping[str, Any]: ...
+    def source_to_code(
+        self, data: ReadableBuffer | str | _ast.Module | _ast.Expression | _ast.Interactive, path: ReadableBuffer | StrPath
+    ) -> types.CodeType: ...
+    def get_code(self, fullname: str) -> types.CodeType | None: ...
+
+class FileLoader:
+    name: str
+    path: str
+    def __init__(self, fullname: str, path: str) -> None: ...
+    def get_data(self, path: str) -> bytes: ...
+    def get_filename(self, name: str | None = None) -> str: ...
+    def load_module(self, name: str | None = None) -> types.ModuleType: ...
+    if sys.version_info >= (3, 10):
+        def get_resource_reader(self, name: str | None = None) -> importlib.readers.FileReader: ...
+    else:
+        def get_resource_reader(self, name: str | None = None) -> Self | None: ...
+        def open_resource(self, resource: str) -> _io.FileIO: ...
+        def resource_path(self, resource: str) -> str: ...
+        def is_resource(self, name: str) -> bool: ...
+        def contents(self) -> Iterator[str]: ...
+
+class SourceFileLoader(importlib.abc.FileLoader, FileLoader, importlib.abc.SourceLoader, SourceLoader):  # type: ignore[misc]  # incompatible method arguments in base classes
+    def set_data(self, path: str, data: ReadableBuffer, *, _mode: int = 0o666) -> None: ...
+    def path_stats(self, path: str) -> Mapping[str, Any]: ...
+
+class SourcelessFileLoader(importlib.abc.FileLoader, FileLoader, _LoaderBasics):
+    def get_code(self, fullname: str) -> types.CodeType | None: ...
+    def get_source(self, fullname: str) -> None: ...
+
+class ExtensionFileLoader(FileLoader, _LoaderBasics, importlib.abc.ExecutionLoader):
+    def __init__(self, name: str, path: str) -> None: ...
+    def get_filename(self, name: str | None = None) -> str: ...
+    def get_source(self, fullname: str) -> None: ...
+    def create_module(self, spec: ModuleSpec) -> types.ModuleType: ...
+    def exec_module(self, module: types.ModuleType) -> None: ...
+    def get_code(self, fullname: str) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+
+if sys.version_info >= (3, 11):
+    class NamespaceLoader(importlib.abc.InspectLoader):
+        def __init__(
+            self, name: str, path: MutableSequence[str], path_finder: Callable[[str, tuple[str, ...]], ModuleSpec]
+        ) -> None: ...
+        def is_package(self, fullname: str) -> Literal[True]: ...
+        def get_source(self, fullname: str) -> Literal[""]: ...
+        def get_code(self, fullname: str) -> types.CodeType: ...
+        def create_module(self, spec: ModuleSpec) -> None: ...
+        def exec_module(self, module: types.ModuleType) -> None: ...
+        @deprecated("load_module() is deprecated; use exec_module() instead")
+        def load_module(self, fullname: str) -> types.ModuleType: ...
+        def get_resource_reader(self, module: types.ModuleType) -> importlib.readers.NamespaceReader: ...
+        if sys.version_info < (3, 12):
+            @staticmethod
+            @deprecated("module_repr() is deprecated, and has been removed in Python 3.12")
+            def module_repr(module: types.ModuleType) -> str: ...
+
+    _NamespaceLoader = NamespaceLoader
+else:
+    class _NamespaceLoader:
+        def __init__(
+            self, name: str, path: MutableSequence[str], path_finder: Callable[[str, tuple[str, ...]], ModuleSpec]
+        ) -> None: ...
+        def is_package(self, fullname: str) -> Literal[True]: ...
+        def get_source(self, fullname: str) -> Literal[""]: ...
+        def get_code(self, fullname: str) -> types.CodeType: ...
+        def create_module(self, spec: ModuleSpec) -> None: ...
+        def exec_module(self, module: types.ModuleType) -> None: ...
+        @deprecated("load_module() is deprecated; use exec_module() instead")
+        def load_module(self, fullname: str) -> types.ModuleType: ...
+        if sys.version_info >= (3, 10):
+            @staticmethod
+            @deprecated("module_repr() is deprecated, and has been removed in Python 3.12")
+            def module_repr(module: types.ModuleType) -> str: ...
+            def get_resource_reader(self, module: types.ModuleType) -> importlib.readers.NamespaceReader: ...
+        else:
+            @classmethod
+            @deprecated("module_repr() is deprecated, and has been removed in Python 3.12")
+            def module_repr(cls, module: types.ModuleType) -> str: ...
+
+if sys.version_info >= (3, 13):
+    class AppleFrameworkLoader(ExtensionFileLoader, importlib.abc.ExecutionLoader): ...
diff --git a/mypy/typeshed/stdlib/_gdbm.pyi b/mypy/typeshed/stdlib/_gdbm.pyi
new file mode 100644
index 000000000000..1d1d541f5477
--- /dev/null
+++ b/mypy/typeshed/stdlib/_gdbm.pyi
@@ -0,0 +1,47 @@
+import sys
+from _typeshed import ReadOnlyBuffer, StrOrBytesPath
+from types import TracebackType
+from typing import TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.platform != "win32":
+    _T = TypeVar("_T")
+    _KeyType: TypeAlias = str | ReadOnlyBuffer
+    _ValueType: TypeAlias = str | ReadOnlyBuffer
+
+    open_flags: str
+
+    class error(OSError): ...
+    # Actual typename gdbm, not exposed by the implementation
+    class _gdbm:
+        def firstkey(self) -> bytes | None: ...
+        def nextkey(self, key: _KeyType) -> bytes | None: ...
+        def reorganize(self) -> None: ...
+        def sync(self) -> None: ...
+        def close(self) -> None: ...
+        if sys.version_info >= (3, 13):
+            def clear(self) -> None: ...
+
+        def __getitem__(self, item: _KeyType) -> bytes: ...
+        def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
+        def __delitem__(self, key: _KeyType) -> None: ...
+        def __contains__(self, key: _KeyType) -> bool: ...
+        def __len__(self) -> int: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+        ) -> None: ...
+        @overload
+        def get(self, k: _KeyType) -> bytes | None: ...
+        @overload
+        def get(self, k: _KeyType, default: _T) -> bytes | _T: ...
+        def keys(self) -> list[bytes]: ...
+        def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
+        # Don't exist at runtime
+        __new__: None  # type: ignore[assignment]
+        __init__: None  # type: ignore[assignment]
+
+    if sys.version_info >= (3, 11):
+        def open(filename: StrOrBytesPath, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...
+    else:
+        def open(filename: str, flags: str = "r", mode: int = 0o666, /) -> _gdbm: ...
diff --git a/mypy/typeshed/stdlib/_hashlib.pyi b/mypy/typeshed/stdlib/_hashlib.pyi
new file mode 100644
index 000000000000..e91f2cdb331c
--- /dev/null
+++ b/mypy/typeshed/stdlib/_hashlib.pyi
@@ -0,0 +1,93 @@
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Callable
+from types import ModuleType
+from typing import AnyStr, Protocol, final, overload, type_check_only
+from typing_extensions import Self, TypeAlias
+
+_DigestMod: TypeAlias = str | Callable[[], _HashObject] | ModuleType | None
+
+openssl_md_meth_names: frozenset[str]
+
+@type_check_only
+class _HashObject(Protocol):
+    @property
+    def digest_size(self) -> int: ...
+    @property
+    def block_size(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, obj: ReadableBuffer, /) -> None: ...
+
+class HASH:
+    @property
+    def digest_size(self) -> int: ...
+    @property
+    def block_size(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, obj: ReadableBuffer, /) -> None: ...
+
+if sys.version_info >= (3, 10):
+    class UnsupportedDigestmodError(ValueError): ...
+
+if sys.version_info >= (3, 9):
+    class HASHXOF(HASH):
+        def digest(self, length: int) -> bytes: ...  # type: ignore[override]
+        def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
+
+    @final
+    class HMAC:
+        @property
+        def digest_size(self) -> int: ...
+        @property
+        def block_size(self) -> int: ...
+        @property
+        def name(self) -> str: ...
+        def copy(self) -> Self: ...
+        def digest(self) -> bytes: ...
+        def hexdigest(self) -> str: ...
+        def update(self, msg: ReadableBuffer) -> None: ...
+
+    @overload
+    def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
+    @overload
+    def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
+    def get_fips_mode() -> int: ...
+    def hmac_new(key: bytes | bytearray, msg: ReadableBuffer = b"", digestmod: _DigestMod = None) -> HMAC: ...
+    def new(name: str, string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_sha3_512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+    def openssl_shake_128(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
+    def openssl_shake_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
+
+else:
+    def new(name: str, string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_md5(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha1(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha224(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha256(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha384(string: ReadableBuffer = b"") -> HASH: ...
+    def openssl_sha512(string: ReadableBuffer = b"") -> HASH: ...
+
+def hmac_digest(key: bytes | bytearray, msg: ReadableBuffer, digest: str) -> bytes: ...
+def pbkdf2_hmac(
+    hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: int | None = None
+) -> bytes: ...
+def scrypt(
+    password: ReadableBuffer, *, salt: ReadableBuffer, n: int, r: int, p: int, maxmem: int = 0, dklen: int = 64
+) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/_heapq.pyi b/mypy/typeshed/stdlib/_heapq.pyi
index 8d6c3e88103e..9f731bf91eef 100644
--- a/mypy/typeshed/stdlib/_heapq.pyi
+++ b/mypy/typeshed/stdlib/_heapq.pyi
@@ -1,12 +1,11 @@
-from typing import Any, TypeVar
-from typing_extensions import Final
+from typing import Any, Final, TypeVar
 
 _T = TypeVar("_T")
 
 __about__: Final[str]
 
-def heapify(__heap: list[Any]) -> None: ...
-def heappop(__heap: list[_T]) -> _T: ...
-def heappush(__heap: list[_T], __item: _T) -> None: ...
-def heappushpop(__heap: list[_T], __item: _T) -> _T: ...
-def heapreplace(__heap: list[_T], __item: _T) -> _T: ...
+def heapify(heap: list[Any], /) -> None: ...
+def heappop(heap: list[_T], /) -> _T: ...
+def heappush(heap: list[_T], item: _T, /) -> None: ...
+def heappushpop(heap: list[_T], item: _T, /) -> _T: ...
+def heapreplace(heap: list[_T], item: _T, /) -> _T: ...
diff --git a/mypy/typeshed/stdlib/_imp.pyi b/mypy/typeshed/stdlib/_imp.pyi
index adab2e803efe..de3549a91da5 100644
--- a/mypy/typeshed/stdlib/_imp.pyi
+++ b/mypy/typeshed/stdlib/_imp.pyi
@@ -7,22 +7,22 @@ from typing import Any
 check_hash_based_pycs: str
 
 def source_hash(key: int, source: ReadableBuffer) -> bytes: ...
-def create_builtin(__spec: ModuleSpec) -> types.ModuleType: ...
-def create_dynamic(__spec: ModuleSpec, __file: Any = None) -> types.ModuleType: ...
+def create_builtin(spec: ModuleSpec, /) -> types.ModuleType: ...
+def create_dynamic(spec: ModuleSpec, file: Any = None, /) -> types.ModuleType: ...
 def acquire_lock() -> None: ...
-def exec_builtin(__mod: types.ModuleType) -> int: ...
-def exec_dynamic(__mod: types.ModuleType) -> int: ...
+def exec_builtin(mod: types.ModuleType, /) -> int: ...
+def exec_dynamic(mod: types.ModuleType, /) -> int: ...
 def extension_suffixes() -> list[str]: ...
-def init_frozen(__name: str) -> types.ModuleType: ...
-def is_builtin(__name: str) -> int: ...
-def is_frozen(__name: str) -> bool: ...
-def is_frozen_package(__name: str) -> bool: ...
+def init_frozen(name: str, /) -> types.ModuleType: ...
+def is_builtin(name: str, /) -> int: ...
+def is_frozen(name: str, /) -> bool: ...
+def is_frozen_package(name: str, /) -> bool: ...
 def lock_held() -> bool: ...
 def release_lock() -> None: ...
 
 if sys.version_info >= (3, 11):
-    def find_frozen(__name: str, *, withdata: bool = False) -> tuple[memoryview | None, bool, str | None] | None: ...
-    def get_frozen_object(__name: str, __data: ReadableBuffer | None = None) -> types.CodeType: ...
+    def find_frozen(name: str, /, *, withdata: bool = False) -> tuple[memoryview | None, bool, str | None] | None: ...
+    def get_frozen_object(name: str, data: ReadableBuffer | None = None, /) -> types.CodeType: ...
 
 else:
-    def get_frozen_object(__name: str) -> types.CodeType: ...
+    def get_frozen_object(name: str, /) -> types.CodeType: ...
diff --git a/mypy/typeshed/stdlib/_interpchannels.pyi b/mypy/typeshed/stdlib/_interpchannels.pyi
new file mode 100644
index 000000000000..c03496044df0
--- /dev/null
+++ b/mypy/typeshed/stdlib/_interpchannels.pyi
@@ -0,0 +1,86 @@
+from _typeshed import structseq
+from typing import Any, Final, Literal, SupportsIndex, final
+from typing_extensions import Buffer, Self
+
+class ChannelError(RuntimeError): ...
+class ChannelClosedError(ChannelError): ...
+class ChannelEmptyError(ChannelError): ...
+class ChannelNotEmptyError(ChannelError): ...
+class ChannelNotFoundError(ChannelError): ...
+
+# Mark as final, since instantiating ChannelID is not supported.
+@final
+class ChannelID:
+    @property
+    def end(self) -> Literal["send", "recv", "both"]: ...
+    @property
+    def send(self) -> Self: ...
+    @property
+    def recv(self) -> Self: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ge__(self, other: ChannelID) -> bool: ...
+    def __gt__(self, other: ChannelID) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __int__(self) -> int: ...
+    def __le__(self, other: ChannelID) -> bool: ...
+    def __lt__(self, other: ChannelID) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+
+@final
+class ChannelInfo(structseq[int], tuple[bool, bool, bool, int, int, int, int, int]):
+    __match_args__: Final = (
+        "open",
+        "closing",
+        "closed",
+        "count",
+        "num_interp_send",
+        "num_interp_send_released",
+        "num_interp_recv",
+        "num_interp_recv_released",
+    )
+    @property
+    def open(self) -> bool: ...
+    @property
+    def closing(self) -> bool: ...
+    @property
+    def closed(self) -> bool: ...
+    @property
+    def count(self) -> int: ...  # type: ignore[override]
+    @property
+    def num_interp_send(self) -> int: ...
+    @property
+    def num_interp_send_released(self) -> int: ...
+    @property
+    def num_interp_recv(self) -> int: ...
+    @property
+    def num_interp_recv_released(self) -> int: ...
+    @property
+    def num_interp_both(self) -> int: ...
+    @property
+    def num_interp_both_recv_released(self) -> int: ...
+    @property
+    def num_interp_both_send_released(self) -> int: ...
+    @property
+    def num_interp_both_released(self) -> int: ...
+    @property
+    def recv_associated(self) -> bool: ...
+    @property
+    def recv_released(self) -> bool: ...
+    @property
+    def send_associated(self) -> bool: ...
+    @property
+    def send_released(self) -> bool: ...
+
+def create(unboundop: Literal[1, 2, 3]) -> ChannelID: ...
+def destroy(cid: SupportsIndex) -> None: ...
+def list_all() -> list[ChannelID]: ...
+def list_interpreters(cid: SupportsIndex, *, send: bool) -> list[int]: ...
+def send(cid: SupportsIndex, obj: object, *, blocking: bool = True, timeout: float | None = None) -> None: ...
+def send_buffer(cid: SupportsIndex, obj: Buffer, *, blocking: bool = True, timeout: float | None = None) -> None: ...
+def recv(cid: SupportsIndex, default: object = ...) -> tuple[Any, Literal[1, 2, 3]]: ...
+def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None: ...
+def get_count(cid: SupportsIndex) -> int: ...
+def get_info(cid: SupportsIndex) -> ChannelInfo: ...
+def get_channel_defaults(cid: SupportsIndex) -> Literal[1, 2, 3]: ...
+def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None: ...
diff --git a/mypy/typeshed/stdlib/_interpqueues.pyi b/mypy/typeshed/stdlib/_interpqueues.pyi
new file mode 100644
index 000000000000..c9323b106f3d
--- /dev/null
+++ b/mypy/typeshed/stdlib/_interpqueues.pyi
@@ -0,0 +1,19 @@
+from typing import Any, Literal, SupportsIndex
+from typing_extensions import TypeAlias
+
+_UnboundOp: TypeAlias = Literal[1, 2, 3]
+
+class QueueError(RuntimeError): ...
+class QueueNotFoundError(QueueError): ...
+
+def bind(qid: SupportsIndex) -> None: ...
+def create(maxsize: SupportsIndex, fmt: SupportsIndex, unboundop: _UnboundOp) -> int: ...
+def destroy(qid: SupportsIndex) -> None: ...
+def get(qid: SupportsIndex) -> tuple[Any, int, _UnboundOp | None]: ...
+def get_count(qid: SupportsIndex) -> int: ...
+def get_maxsize(qid: SupportsIndex) -> int: ...
+def get_queue_defaults(qid: SupportsIndex) -> tuple[int, _UnboundOp]: ...
+def is_full(qid: SupportsIndex) -> bool: ...
+def list_all() -> list[tuple[int, int, _UnboundOp]]: ...
+def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex, unboundop: _UnboundOp) -> None: ...
+def release(qid: SupportsIndex) -> None: ...
diff --git a/mypy/typeshed/stdlib/_interpreters.pyi b/mypy/typeshed/stdlib/_interpreters.pyi
new file mode 100644
index 000000000000..caa1115e9d3d
--- /dev/null
+++ b/mypy/typeshed/stdlib/_interpreters.pyi
@@ -0,0 +1,52 @@
+import types
+from collections.abc import Callable, Mapping
+from typing import Final, Literal, SupportsIndex
+from typing_extensions import TypeAlias
+
+_Configs: TypeAlias = Literal["default", "isolated", "legacy", "empty", ""]
+
+class InterpreterError(Exception): ...
+class InterpreterNotFoundError(InterpreterError): ...
+class NotShareableError(ValueError): ...
+
+class CrossInterpreterBufferView:
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+
+def new_config(name: _Configs = "isolated", /, **overides: object) -> types.SimpleNamespace: ...
+def create(config: types.SimpleNamespace | _Configs | None = "isolated", *, reqrefs: bool = False) -> int: ...
+def destroy(id: SupportsIndex, *, restrict: bool = False) -> None: ...
+def list_all(*, require_ready: bool) -> list[tuple[int, int]]: ...
+def get_current() -> tuple[int, int]: ...
+def get_main() -> tuple[int, int]: ...
+def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool: ...
+def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace: ...
+def whence(id: SupportsIndex) -> int: ...
+def exec(
+    id: SupportsIndex, code: str | types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None | types.SimpleNamespace: ...
+def call(
+    id: SupportsIndex,
+    callable: Callable[..., object],
+    args: tuple[object, ...] | None = None,
+    kwargs: dict[str, object] | None = None,
+    *,
+    restrict: bool = False,
+) -> object: ...
+def run_string(
+    id: SupportsIndex, script: str | types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None: ...
+def run_func(
+    id: SupportsIndex, func: types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None: ...
+def set___main___attrs(id: SupportsIndex, updates: Mapping[str, object], *, restrict: bool = False) -> None: ...
+def incref(id: SupportsIndex, *, implieslink: bool = False, restrict: bool = False) -> None: ...
+def decref(id: SupportsIndex, *, restrict: bool = False) -> None: ...
+def is_shareable(obj: object) -> bool: ...
+def capture_exception(exc: BaseException | None = None) -> types.SimpleNamespace: ...
+
+WHENCE_UNKNOWN: Final = 0
+WHENCE_RUNTIME: Final = 1
+WHENCE_LEGACY_CAPI: Final = 2
+WHENCE_CAPI: Final = 3
+WHENCE_XI: Final = 4
+WHENCE_STDLIB: Final = 5
diff --git a/mypy/typeshed/stdlib/_io.pyi b/mypy/typeshed/stdlib/_io.pyi
new file mode 100644
index 000000000000..54efd3199760
--- /dev/null
+++ b/mypy/typeshed/stdlib/_io.pyi
@@ -0,0 +1,216 @@
+import builtins
+import codecs
+import sys
+from _typeshed import FileDescriptorOrPath, MaybeNone, ReadableBuffer, WriteableBuffer
+from collections.abc import Callable, Iterable, Iterator
+from io import BufferedIOBase, RawIOBase, TextIOBase, UnsupportedOperation as UnsupportedOperation
+from os import _Opener
+from types import TracebackType
+from typing import IO, Any, BinaryIO, Final, Generic, Literal, Protocol, TextIO, TypeVar, overload, type_check_only
+from typing_extensions import Self
+
+_T = TypeVar("_T")
+
+DEFAULT_BUFFER_SIZE: Final = 8192
+
+open = builtins.open
+
+def open_code(path: str) -> IO[bytes]: ...
+
+BlockingIOError = builtins.BlockingIOError
+
+class _IOBase:
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __next__(self) -> bytes: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def close(self) -> None: ...
+    def fileno(self) -> int: ...
+    def flush(self) -> None: ...
+    def isatty(self) -> bool: ...
+    def readable(self) -> bool: ...
+    read: Callable[..., Any]
+    def readlines(self, hint: int = -1, /) -> list[bytes]: ...
+    def seek(self, offset: int, whence: int = 0, /) -> int: ...
+    def seekable(self) -> bool: ...
+    def tell(self) -> int: ...
+    def truncate(self, size: int | None = None, /) -> int: ...
+    def writable(self) -> bool: ...
+    write: Callable[..., Any]
+    def writelines(self, lines: Iterable[ReadableBuffer], /) -> None: ...
+    def readline(self, size: int | None = -1, /) -> bytes: ...
+    def __del__(self) -> None: ...
+    @property
+    def closed(self) -> bool: ...
+    def _checkClosed(self) -> None: ...  # undocumented
+
+class _RawIOBase(_IOBase):
+    def readall(self) -> bytes: ...
+    # The following methods can return None if the file is in non-blocking mode
+    # and no data is available.
+    def readinto(self, buffer: WriteableBuffer, /) -> int | MaybeNone: ...
+    def write(self, b: ReadableBuffer, /) -> int | MaybeNone: ...
+    def read(self, size: int = -1, /) -> bytes | MaybeNone: ...
+
+class _BufferedIOBase(_IOBase):
+    def detach(self) -> RawIOBase: ...
+    def readinto(self, buffer: WriteableBuffer, /) -> int: ...
+    def write(self, buffer: ReadableBuffer, /) -> int: ...
+    def readinto1(self, buffer: WriteableBuffer, /) -> int: ...
+    def read(self, size: int | None = -1, /) -> bytes: ...
+    def read1(self, size: int = -1, /) -> bytes: ...
+
+class FileIO(RawIOBase, _RawIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+    mode: str
+    # The type of "name" equals the argument passed in to the constructor,
+    # but that can make FileIO incompatible with other I/O types that assume
+    # "name" is a str. In the future, making FileIO generic might help.
+    name: Any
+    def __init__(
+        self, file: FileDescriptorOrPath, mode: str = "r", closefd: bool = True, opener: _Opener | None = None
+    ) -> None: ...
+    @property
+    def closefd(self) -> bool: ...
+    def seek(self, pos: int, whence: int = 0, /) -> int: ...
+    def read(self, size: int | None = -1, /) -> bytes | MaybeNone: ...
+
+class BytesIO(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+    def __init__(self, initial_bytes: ReadableBuffer = b"") -> None: ...
+    # BytesIO does not contain a "name" field. This workaround is necessary
+    # to allow BytesIO sub-classes to add this field, as it is defined
+    # as a read-only property on IO[].
+    name: Any
+    def getvalue(self) -> bytes: ...
+    def getbuffer(self) -> memoryview: ...
+    def read1(self, size: int | None = -1, /) -> bytes: ...
+    def readlines(self, size: int | None = None, /) -> list[bytes]: ...
+    def seek(self, pos: int, whence: int = 0, /) -> int: ...
+
+class BufferedReader(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+    raw: RawIOBase
+    def __init__(self, raw: RawIOBase, buffer_size: int = 8192) -> None: ...
+    def peek(self, size: int = 0, /) -> bytes: ...
+    def seek(self, target: int, whence: int = 0, /) -> int: ...
+    def truncate(self, pos: int | None = None, /) -> int: ...
+
+class BufferedWriter(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+    raw: RawIOBase
+    def __init__(self, raw: RawIOBase, buffer_size: int = 8192) -> None: ...
+    def write(self, buffer: ReadableBuffer, /) -> int: ...
+    def seek(self, target: int, whence: int = 0, /) -> int: ...
+    def truncate(self, pos: int | None = None, /) -> int: ...
+
+class BufferedRandom(BufferedIOBase, _BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
+    mode: str
+    name: Any
+    raw: RawIOBase
+    def __init__(self, raw: RawIOBase, buffer_size: int = 8192) -> None: ...
+    def seek(self, target: int, whence: int = 0, /) -> int: ...  # stubtest needs this
+    def peek(self, size: int = 0, /) -> bytes: ...
+    def truncate(self, pos: int | None = None, /) -> int: ...
+
+class BufferedRWPair(BufferedIOBase, _BufferedIOBase):
+    def __init__(self, reader: RawIOBase, writer: RawIOBase, buffer_size: int = 8192, /) -> None: ...
+    def peek(self, size: int = 0, /) -> bytes: ...
+
+class _TextIOBase(_IOBase):
+    encoding: str
+    errors: str | None
+    newlines: str | tuple[str, ...] | None
+    def __iter__(self) -> Iterator[str]: ...  # type: ignore[override]
+    def __next__(self) -> str: ...  # type: ignore[override]
+    def detach(self) -> BinaryIO: ...
+    def write(self, s: str, /) -> int: ...
+    def writelines(self, lines: Iterable[str], /) -> None: ...  # type: ignore[override]
+    def readline(self, size: int = -1, /) -> str: ...  # type: ignore[override]
+    def readlines(self, hint: int = -1, /) -> list[str]: ...  # type: ignore[override]
+    def read(self, size: int | None = -1, /) -> str: ...
+
+@type_check_only
+class _WrappedBuffer(Protocol):
+    # "name" is wrapped by TextIOWrapper. Its type is inconsistent between
+    # the various I/O types, see the comments on TextIOWrapper.name and
+    # TextIO.name.
+    @property
+    def name(self) -> Any: ...
+    @property
+    def closed(self) -> bool: ...
+    def read(self, size: int = ..., /) -> ReadableBuffer: ...
+    # Optional: def read1(self, size: int, /) -> ReadableBuffer: ...
+    def write(self, b: bytes, /) -> object: ...
+    def flush(self) -> object: ...
+    def close(self) -> object: ...
+    def seekable(self) -> bool: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def truncate(self, size: int, /) -> int: ...
+    def fileno(self) -> int: ...
+    def isatty(self) -> bool: ...
+    # Optional: Only needs to be present if seekable() returns True.
+    # def seek(self, offset: Literal[0], whence: Literal[2]) -> int: ...
+    # def tell(self) -> int: ...
+
+_BufferT_co = TypeVar("_BufferT_co", bound=_WrappedBuffer, default=_WrappedBuffer, covariant=True)
+
+class TextIOWrapper(TextIOBase, _TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[misc]  # incompatible definitions of write in the base classes
+    def __init__(
+        self,
+        buffer: _BufferT_co,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+        line_buffering: bool = False,
+        write_through: bool = False,
+    ) -> None: ...
+    # Equals the "buffer" argument passed in to the constructor.
+    @property
+    def buffer(self) -> _BufferT_co: ...  # type: ignore[override]
+    @property
+    def line_buffering(self) -> bool: ...
+    @property
+    def write_through(self) -> bool: ...
+    def reconfigure(
+        self,
+        *,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+        line_buffering: bool | None = None,
+        write_through: bool | None = None,
+    ) -> None: ...
+    def readline(self, size: int = -1, /) -> str: ...  # type: ignore[override]
+    # Equals the "buffer" argument passed in to the constructor.
+    def detach(self) -> _BufferT_co: ...  # type: ignore[override]
+    # TextIOWrapper's version of seek only supports a limited subset of
+    # operations.
+    def seek(self, cookie: int, whence: int = 0, /) -> int: ...
+    def truncate(self, pos: int | None = None, /) -> int: ...
+
+class StringIO(TextIOBase, _TextIOBase, TextIO):  # type: ignore[misc]  # incompatible definitions of write in the base classes
+    def __init__(self, initial_value: str | None = "", newline: str | None = "\n") -> None: ...
+    # StringIO does not contain a "name" field. This workaround is necessary
+    # to allow StringIO sub-classes to add this field, as it is defined
+    # as a read-only property on IO[].
+    name: Any
+    def getvalue(self) -> str: ...
+    @property
+    def line_buffering(self) -> bool: ...
+    def seek(self, pos: int, whence: int = 0, /) -> int: ...
+    def truncate(self, pos: int | None = None, /) -> int: ...
+
+class IncrementalNewlineDecoder:
+    def __init__(self, decoder: codecs.IncrementalDecoder | None, translate: bool, errors: str = "strict") -> None: ...
+    def decode(self, input: ReadableBuffer | str, final: bool = False) -> str: ...
+    @property
+    def newlines(self) -> str | tuple[str, ...] | None: ...
+    def getstate(self) -> tuple[bytes, int]: ...
+    def reset(self) -> None: ...
+    def setstate(self, state: tuple[bytes, int], /) -> None: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def text_encoding(encoding: None, stacklevel: int = 2, /) -> Literal["locale", "utf-8"]: ...
+    @overload
+    def text_encoding(encoding: _T, stacklevel: int = 2, /) -> _T: ...
diff --git a/mypy/typeshed/stdlib/_json.pyi b/mypy/typeshed/stdlib/_json.pyi
index 130f7ab92e97..5296b8e62a02 100644
--- a/mypy/typeshed/stdlib/_json.pyi
+++ b/mypy/typeshed/stdlib/_json.pyi
@@ -1,6 +1,6 @@
 from collections.abc import Callable
-from typing import Any
-from typing_extensions import final
+from typing import Any, final
+from typing_extensions import Self
 
 @final
 class make_encoder:
@@ -20,8 +20,8 @@ class make_encoder:
     def encoder(self) -> Callable[[str], str]: ...
     @property
     def item_separator(self) -> str: ...
-    def __init__(
-        self,
+    def __new__(
+        cls,
         markers: dict[int, Any] | None,
         default: Callable[[Any], Any],
         encoder: Callable[[str], str],
@@ -31,7 +31,7 @@ class make_encoder:
         sort_keys: bool,
         skipkeys: bool,
         allow_nan: bool,
-    ) -> None: ...
+    ) -> Self: ...
     def __call__(self, obj: object, _current_indent_level: int) -> Any: ...
 
 @final
@@ -43,8 +43,9 @@ class make_scanner:
     parse_float: Any
     strict: bool
     # TODO: 'context' needs the attrs above (ducktype), but not __call__.
-    def __init__(self, context: make_scanner) -> None: ...
+    def __new__(cls, context: make_scanner) -> Self: ...
     def __call__(self, string: str, index: int) -> tuple[Any, int]: ...
 
-def encode_basestring_ascii(s: str) -> str: ...
+def encode_basestring(s: str, /) -> str: ...
+def encode_basestring_ascii(s: str, /) -> str: ...
 def scanstring(string: str, end: int, strict: bool = ...) -> tuple[str, int]: ...
diff --git a/mypy/typeshed/stdlib/_locale.pyi b/mypy/typeshed/stdlib/_locale.pyi
new file mode 100644
index 000000000000..ccce7a0d9d70
--- /dev/null
+++ b/mypy/typeshed/stdlib/_locale.pyi
@@ -0,0 +1,121 @@
+import sys
+from _typeshed import StrPath
+from typing import Final, Literal, TypedDict, type_check_only
+
+@type_check_only
+class _LocaleConv(TypedDict):
+    decimal_point: str
+    grouping: list[int]
+    thousands_sep: str
+    int_curr_symbol: str
+    currency_symbol: str
+    p_cs_precedes: Literal[0, 1, 127]
+    n_cs_precedes: Literal[0, 1, 127]
+    p_sep_by_space: Literal[0, 1, 127]
+    n_sep_by_space: Literal[0, 1, 127]
+    mon_decimal_point: str
+    frac_digits: int
+    int_frac_digits: int
+    mon_thousands_sep: str
+    mon_grouping: list[int]
+    positive_sign: str
+    negative_sign: str
+    p_sign_posn: Literal[0, 1, 2, 3, 4, 127]
+    n_sign_posn: Literal[0, 1, 2, 3, 4, 127]
+
+LC_CTYPE: Final[int]
+LC_COLLATE: Final[int]
+LC_TIME: Final[int]
+LC_MONETARY: Final[int]
+LC_NUMERIC: Final[int]
+LC_ALL: Final[int]
+CHAR_MAX: Final = 127
+
+def setlocale(category: int, locale: str | None = None, /) -> str: ...
+def localeconv() -> _LocaleConv: ...
+
+if sys.version_info >= (3, 11):
+    def getencoding() -> str: ...
+
+def strcoll(os1: str, os2: str, /) -> int: ...
+def strxfrm(string: str, /) -> str: ...
+
+# native gettext functions
+# https://docs.python.org/3/library/locale.html#access-to-message-catalogs
+# https://github.com/python/cpython/blob/f4c03484da59049eb62a9bf7777b963e2267d187/Modules/_localemodule.c#L626
+if sys.platform != "win32":
+    LC_MESSAGES: int
+
+    ABDAY_1: Final[int]
+    ABDAY_2: Final[int]
+    ABDAY_3: Final[int]
+    ABDAY_4: Final[int]
+    ABDAY_5: Final[int]
+    ABDAY_6: Final[int]
+    ABDAY_7: Final[int]
+
+    ABMON_1: Final[int]
+    ABMON_2: Final[int]
+    ABMON_3: Final[int]
+    ABMON_4: Final[int]
+    ABMON_5: Final[int]
+    ABMON_6: Final[int]
+    ABMON_7: Final[int]
+    ABMON_8: Final[int]
+    ABMON_9: Final[int]
+    ABMON_10: Final[int]
+    ABMON_11: Final[int]
+    ABMON_12: Final[int]
+
+    DAY_1: Final[int]
+    DAY_2: Final[int]
+    DAY_3: Final[int]
+    DAY_4: Final[int]
+    DAY_5: Final[int]
+    DAY_6: Final[int]
+    DAY_7: Final[int]
+
+    ERA: Final[int]
+    ERA_D_T_FMT: Final[int]
+    ERA_D_FMT: Final[int]
+    ERA_T_FMT: Final[int]
+
+    MON_1: Final[int]
+    MON_2: Final[int]
+    MON_3: Final[int]
+    MON_4: Final[int]
+    MON_5: Final[int]
+    MON_6: Final[int]
+    MON_7: Final[int]
+    MON_8: Final[int]
+    MON_9: Final[int]
+    MON_10: Final[int]
+    MON_11: Final[int]
+    MON_12: Final[int]
+
+    CODESET: Final[int]
+    D_T_FMT: Final[int]
+    D_FMT: Final[int]
+    T_FMT: Final[int]
+    T_FMT_AMPM: Final[int]
+    AM_STR: Final[int]
+    PM_STR: Final[int]
+
+    RADIXCHAR: Final[int]
+    THOUSEP: Final[int]
+    YESEXPR: Final[int]
+    NOEXPR: Final[int]
+    CRNCYSTR: Final[int]
+    ALT_DIGITS: Final[int]
+
+    def nl_langinfo(key: int, /) -> str: ...
+
+    # This is dependent on `libintl.h` which is a part of `gettext`
+    # system dependency. These functions might be missing.
+    # But, we always say that they are present.
+    def gettext(msg: str, /) -> str: ...
+    def dgettext(domain: str | None, msg: str, /) -> str: ...
+    def dcgettext(domain: str | None, msg: str, category: int, /) -> str: ...
+    def textdomain(domain: str | None, /) -> str: ...
+    def bindtextdomain(domain: str, dir: StrPath | None, /) -> str: ...
+    def bind_textdomain_codeset(domain: str, codeset: str | None, /) -> str | None: ...
diff --git a/mypy/typeshed/stdlib/_lsprof.pyi b/mypy/typeshed/stdlib/_lsprof.pyi
new file mode 100644
index 000000000000..8a6934162c92
--- /dev/null
+++ b/mypy/typeshed/stdlib/_lsprof.pyi
@@ -0,0 +1,35 @@
+import sys
+from _typeshed import structseq
+from collections.abc import Callable
+from types import CodeType
+from typing import Any, Final, final
+
+class Profiler:
+    def __init__(
+        self, timer: Callable[[], float] | None = None, timeunit: float = 0.0, subcalls: bool = True, builtins: bool = True
+    ) -> None: ...
+    def getstats(self) -> list[profiler_entry]: ...
+    def enable(self, subcalls: bool = True, builtins: bool = True) -> None: ...
+    def disable(self) -> None: ...
+    def clear(self) -> None: ...
+
+@final
+class profiler_entry(structseq[Any], tuple[CodeType | str, int, int, float, float, list[profiler_subentry]]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("code", "callcount", "reccallcount", "totaltime", "inlinetime", "calls")
+    code: CodeType | str
+    callcount: int
+    reccallcount: int
+    totaltime: float
+    inlinetime: float
+    calls: list[profiler_subentry]
+
+@final
+class profiler_subentry(structseq[Any], tuple[CodeType | str, int, int, float, float]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("code", "callcount", "reccallcount", "totaltime", "inlinetime")
+    code: CodeType | str
+    callcount: int
+    reccallcount: int
+    totaltime: float
+    inlinetime: float
diff --git a/mypy/typeshed/stdlib/_lzma.pyi b/mypy/typeshed/stdlib/_lzma.pyi
new file mode 100644
index 000000000000..1a27c7428e8e
--- /dev/null
+++ b/mypy/typeshed/stdlib/_lzma.pyi
@@ -0,0 +1,71 @@
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Mapping, Sequence
+from typing import Any, Final, final
+from typing_extensions import Self, TypeAlias
+
+_FilterChain: TypeAlias = Sequence[Mapping[str, Any]]
+
+FORMAT_AUTO: Final = 0
+FORMAT_XZ: Final = 1
+FORMAT_ALONE: Final = 2
+FORMAT_RAW: Final = 3
+CHECK_NONE: Final = 0
+CHECK_CRC32: Final = 1
+CHECK_CRC64: Final = 4
+CHECK_SHA256: Final = 10
+CHECK_ID_MAX: Final = 15
+CHECK_UNKNOWN: Final = 16
+FILTER_LZMA1: int  # v big number
+FILTER_LZMA2: Final = 33
+FILTER_DELTA: Final = 3
+FILTER_X86: Final = 4
+FILTER_IA64: Final = 6
+FILTER_ARM: Final = 7
+FILTER_ARMTHUMB: Final = 8
+FILTER_SPARC: Final = 9
+FILTER_POWERPC: Final = 5
+MF_HC3: Final = 3
+MF_HC4: Final = 4
+MF_BT2: Final = 18
+MF_BT3: Final = 19
+MF_BT4: Final = 20
+MODE_FAST: Final = 1
+MODE_NORMAL: Final = 2
+PRESET_DEFAULT: Final = 6
+PRESET_EXTREME: int  # v big number
+
+@final
+class LZMADecompressor:
+    if sys.version_info >= (3, 12):
+        def __new__(cls, format: int | None = ..., memlimit: int | None = ..., filters: _FilterChain | None = ...) -> Self: ...
+    else:
+        def __init__(self, format: int | None = ..., memlimit: int | None = ..., filters: _FilterChain | None = ...) -> None: ...
+
+    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    @property
+    def check(self) -> int: ...
+    @property
+    def eof(self) -> bool: ...
+    @property
+    def unused_data(self) -> bytes: ...
+    @property
+    def needs_input(self) -> bool: ...
+
+@final
+class LZMACompressor:
+    if sys.version_info >= (3, 12):
+        def __new__(
+            cls, format: int | None = ..., check: int = ..., preset: int | None = ..., filters: _FilterChain | None = ...
+        ) -> Self: ...
+    else:
+        def __init__(
+            self, format: int | None = ..., check: int = ..., preset: int | None = ..., filters: _FilterChain | None = ...
+        ) -> None: ...
+
+    def compress(self, data: ReadableBuffer, /) -> bytes: ...
+    def flush(self) -> bytes: ...
+
+class LZMAError(Exception): ...
+
+def is_check_supported(check_id: int, /) -> bool: ...
diff --git a/mypy/typeshed/stdlib/_msi.pyi b/mypy/typeshed/stdlib/_msi.pyi
index 2fdbdfd0e9f4..779fda3b67fe 100644
--- a/mypy/typeshed/stdlib/_msi.pyi
+++ b/mypy/typeshed/stdlib/_msi.pyi
@@ -1,6 +1,7 @@
 import sys
 
 if sys.platform == "win32":
+    class MSIError(Exception): ...
     # Actual typename View, not exposed by the implementation
     class _View:
         def Execute(self, params: _Record | None = ...) -> None: ...
@@ -44,10 +45,11 @@ if sys.platform == "win32":
         # Don't exist at runtime
         __new__: None  # type: ignore[assignment]
         __init__: None  # type: ignore[assignment]
+
     def UuidCreate() -> str: ...
-    def FCICreate(__cabname: str, __files: list[str]) -> None: ...
-    def OpenDatabase(__path: str, __persist: int) -> _Database: ...
-    def CreateRecord(__count: int) -> _Record: ...
+    def FCICreate(cabname: str, files: list[str], /) -> None: ...
+    def OpenDatabase(path: str, persist: int, /) -> _Database: ...
+    def CreateRecord(count: int, /) -> _Record: ...
 
     MSICOLINFO_NAMES: int
     MSICOLINFO_TYPES: int
diff --git a/mypy/typeshed/stdlib/_multibytecodec.pyi b/mypy/typeshed/stdlib/_multibytecodec.pyi
new file mode 100644
index 000000000000..7e408f2aa30e
--- /dev/null
+++ b/mypy/typeshed/stdlib/_multibytecodec.pyi
@@ -0,0 +1,44 @@
+from _typeshed import ReadableBuffer
+from codecs import _ReadableStream, _WritableStream
+from collections.abc import Iterable
+from typing import final, type_check_only
+
+# This class is not exposed. It calls itself _multibytecodec.MultibyteCodec.
+@final
+@type_check_only
+class _MultibyteCodec:
+    def decode(self, input: ReadableBuffer, errors: str | None = None) -> str: ...
+    def encode(self, input: str, errors: str | None = None) -> bytes: ...
+
+class MultibyteIncrementalDecoder:
+    errors: str
+    def __init__(self, errors: str = "strict") -> None: ...
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+    def getstate(self) -> tuple[bytes, int]: ...
+    def reset(self) -> None: ...
+    def setstate(self, state: tuple[bytes, int], /) -> None: ...
+
+class MultibyteIncrementalEncoder:
+    errors: str
+    def __init__(self, errors: str = "strict") -> None: ...
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+    def getstate(self) -> int: ...
+    def reset(self) -> None: ...
+    def setstate(self, state: int, /) -> None: ...
+
+class MultibyteStreamReader:
+    errors: str
+    stream: _ReadableStream
+    def __init__(self, stream: _ReadableStream, errors: str = "strict") -> None: ...
+    def read(self, sizeobj: int | None = None, /) -> str: ...
+    def readline(self, sizeobj: int | None = None, /) -> str: ...
+    def readlines(self, sizehintobj: int | None = None, /) -> list[str]: ...
+    def reset(self) -> None: ...
+
+class MultibyteStreamWriter:
+    errors: str
+    stream: _WritableStream
+    def __init__(self, stream: _WritableStream, errors: str = "strict") -> None: ...
+    def reset(self) -> None: ...
+    def write(self, strobj: str, /) -> None: ...
+    def writelines(self, lines: Iterable[str], /) -> None: ...
diff --git a/mypy/typeshed/stdlib/_operator.pyi b/mypy/typeshed/stdlib/_operator.pyi
index e7d1a98c4027..967215d8fa21 100644
--- a/mypy/typeshed/stdlib/_operator.pyi
+++ b/mypy/typeshed/stdlib/_operator.pyi
@@ -1,8 +1,9 @@
 import sys
 from _typeshed import SupportsGetItem
 from collections.abc import Callable, Container, Iterable, MutableMapping, MutableSequence, Sequence
-from typing import Any, AnyStr, Generic, Protocol, SupportsAbs, TypeVar, overload
-from typing_extensions import ParamSpec, SupportsIndex, TypeAlias, final
+from operator import attrgetter as attrgetter, itemgetter as itemgetter, methodcaller as methodcaller
+from typing import Any, AnyStr, Protocol, SupportsAbs, SupportsIndex, TypeVar, overload
+from typing_extensions import ParamSpec, TypeAlias, TypeIs
 
 _R = TypeVar("_R")
 _T = TypeVar("_T")
@@ -16,16 +17,16 @@ _P = ParamSpec("_P")
 # the numpy.array comparison dunders return another numpy.array.
 
 class _SupportsDunderLT(Protocol):
-    def __lt__(self, __other: Any) -> Any: ...
+    def __lt__(self, other: Any, /) -> Any: ...
 
 class _SupportsDunderGT(Protocol):
-    def __gt__(self, __other: Any) -> Any: ...
+    def __gt__(self, other: Any, /) -> Any: ...
 
 class _SupportsDunderLE(Protocol):
-    def __le__(self, __other: Any) -> Any: ...
+    def __le__(self, other: Any, /) -> Any: ...
 
 class _SupportsDunderGE(Protocol):
-    def __ge__(self, __other: Any) -> Any: ...
+    def __ge__(self, other: Any, /) -> Any: ...
 
 _SupportsComparison: TypeAlias = _SupportsDunderLE | _SupportsDunderGE | _SupportsDunderGT | _SupportsDunderLT
 
@@ -39,118 +40,76 @@ class _SupportsPos(Protocol[_T_co]):
     def __pos__(self) -> _T_co: ...
 
 # All four comparison functions must have the same signature, or we get false-positive errors
-def lt(__a: _SupportsComparison, __b: _SupportsComparison) -> Any: ...
-def le(__a: _SupportsComparison, __b: _SupportsComparison) -> Any: ...
-def eq(__a: object, __b: object) -> Any: ...
-def ne(__a: object, __b: object) -> Any: ...
-def ge(__a: _SupportsComparison, __b: _SupportsComparison) -> Any: ...
-def gt(__a: _SupportsComparison, __b: _SupportsComparison) -> Any: ...
-def not_(__a: object) -> bool: ...
-def truth(__a: object) -> bool: ...
-def is_(__a: object, __b: object) -> bool: ...
-def is_not(__a: object, __b: object) -> bool: ...
-def abs(__a: SupportsAbs[_T]) -> _T: ...
-def add(__a: Any, __b: Any) -> Any: ...
-def and_(__a: Any, __b: Any) -> Any: ...
-def floordiv(__a: Any, __b: Any) -> Any: ...
-def index(__a: SupportsIndex) -> int: ...
-def inv(__a: _SupportsInversion[_T_co]) -> _T_co: ...
-def invert(__a: _SupportsInversion[_T_co]) -> _T_co: ...
-def lshift(__a: Any, __b: Any) -> Any: ...
-def mod(__a: Any, __b: Any) -> Any: ...
-def mul(__a: Any, __b: Any) -> Any: ...
-def matmul(__a: Any, __b: Any) -> Any: ...
-def neg(__a: _SupportsNeg[_T_co]) -> _T_co: ...
-def or_(__a: Any, __b: Any) -> Any: ...
-def pos(__a: _SupportsPos[_T_co]) -> _T_co: ...
-def pow(__a: Any, __b: Any) -> Any: ...
-def rshift(__a: Any, __b: Any) -> Any: ...
-def sub(__a: Any, __b: Any) -> Any: ...
-def truediv(__a: Any, __b: Any) -> Any: ...
-def xor(__a: Any, __b: Any) -> Any: ...
-def concat(__a: Sequence[_T], __b: Sequence[_T]) -> Sequence[_T]: ...
-def contains(__a: Container[object], __b: object) -> bool: ...
-def countOf(__a: Iterable[object], __b: object) -> int: ...
+def lt(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+def le(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+def eq(a: object, b: object, /) -> Any: ...
+def ne(a: object, b: object, /) -> Any: ...
+def ge(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+def gt(a: _SupportsComparison, b: _SupportsComparison, /) -> Any: ...
+def not_(a: object, /) -> bool: ...
+def truth(a: object, /) -> bool: ...
+def is_(a: object, b: object, /) -> bool: ...
+def is_not(a: object, b: object, /) -> bool: ...
+def abs(a: SupportsAbs[_T], /) -> _T: ...
+def add(a: Any, b: Any, /) -> Any: ...
+def and_(a: Any, b: Any, /) -> Any: ...
+def floordiv(a: Any, b: Any, /) -> Any: ...
+def index(a: SupportsIndex, /) -> int: ...
+def inv(a: _SupportsInversion[_T_co], /) -> _T_co: ...
+def invert(a: _SupportsInversion[_T_co], /) -> _T_co: ...
+def lshift(a: Any, b: Any, /) -> Any: ...
+def mod(a: Any, b: Any, /) -> Any: ...
+def mul(a: Any, b: Any, /) -> Any: ...
+def matmul(a: Any, b: Any, /) -> Any: ...
+def neg(a: _SupportsNeg[_T_co], /) -> _T_co: ...
+def or_(a: Any, b: Any, /) -> Any: ...
+def pos(a: _SupportsPos[_T_co], /) -> _T_co: ...
+def pow(a: Any, b: Any, /) -> Any: ...
+def rshift(a: Any, b: Any, /) -> Any: ...
+def sub(a: Any, b: Any, /) -> Any: ...
+def truediv(a: Any, b: Any, /) -> Any: ...
+def xor(a: Any, b: Any, /) -> Any: ...
+def concat(a: Sequence[_T], b: Sequence[_T], /) -> Sequence[_T]: ...
+def contains(a: Container[object], b: object, /) -> bool: ...
+def countOf(a: Iterable[object], b: object, /) -> int: ...
 @overload
-def delitem(__a: MutableSequence[Any], __b: SupportsIndex) -> None: ...
+def delitem(a: MutableSequence[Any], b: SupportsIndex, /) -> None: ...
 @overload
-def delitem(__a: MutableSequence[Any], __b: slice) -> None: ...
+def delitem(a: MutableSequence[Any], b: slice, /) -> None: ...
 @overload
-def delitem(__a: MutableMapping[_K, Any], __b: _K) -> None: ...
+def delitem(a: MutableMapping[_K, Any], b: _K, /) -> None: ...
 @overload
-def getitem(__a: Sequence[_T], __b: slice) -> Sequence[_T]: ...
+def getitem(a: Sequence[_T], b: slice, /) -> Sequence[_T]: ...
 @overload
-def getitem(__a: SupportsGetItem[_K, _V], __b: _K) -> _V: ...
-def indexOf(__a: Iterable[_T], __b: _T) -> int: ...
+def getitem(a: SupportsGetItem[_K, _V], b: _K, /) -> _V: ...
+def indexOf(a: Iterable[_T], b: _T, /) -> int: ...
 @overload
-def setitem(__a: MutableSequence[_T], __b: SupportsIndex, __c: _T) -> None: ...
+def setitem(a: MutableSequence[_T], b: SupportsIndex, c: _T, /) -> None: ...
 @overload
-def setitem(__a: MutableSequence[_T], __b: slice, __c: Sequence[_T]) -> None: ...
+def setitem(a: MutableSequence[_T], b: slice, c: Sequence[_T], /) -> None: ...
 @overload
-def setitem(__a: MutableMapping[_K, _V], __b: _K, __c: _V) -> None: ...
-def length_hint(__obj: object, __default: int = 0) -> int: ...
-@final
-class attrgetter(Generic[_T_co]):
-    @overload
-    def __new__(cls, attr: str) -> attrgetter[Any]: ...
-    @overload
-    def __new__(cls, attr: str, __attr2: str) -> attrgetter[tuple[Any, Any]]: ...
-    @overload
-    def __new__(cls, attr: str, __attr2: str, __attr3: str) -> attrgetter[tuple[Any, Any, Any]]: ...
-    @overload
-    def __new__(cls, attr: str, __attr2: str, __attr3: str, __attr4: str) -> attrgetter[tuple[Any, Any, Any, Any]]: ...
-    @overload
-    def __new__(cls, attr: str, *attrs: str) -> attrgetter[tuple[Any, ...]]: ...
-    def __call__(self, obj: Any) -> _T_co: ...
-
-@final
-class itemgetter(Generic[_T_co]):
-    # mypy lacks support for PEP 646 https://github.com/python/mypy/issues/12280
-    # So we have to define all of these overloads to simulate unpacking the arguments
-    @overload
-    def __new__(cls, item: _T_co) -> itemgetter[_T_co]: ...
-    @overload
-    def __new__(cls, item: _T_co, __item2: _T_co) -> itemgetter[tuple[_T_co, _T_co]]: ...
-    @overload
-    def __new__(cls, item: _T_co, __item2: _T_co, __item3: _T_co) -> itemgetter[tuple[_T_co, _T_co, _T_co]]: ...
-    @overload
-    def __new__(
-        cls, item: _T_co, __item2: _T_co, __item3: _T_co, __item4: _T_co
-    ) -> itemgetter[tuple[_T_co, _T_co, _T_co, _T_co]]: ...
-    @overload
-    def __new__(
-        cls, item: _T_co, __item2: _T_co, __item3: _T_co, __item4: _T_co, *items: _T_co
-    ) -> itemgetter[tuple[_T_co, ...]]: ...
-    # __key: _KT_contra in SupportsGetItem seems to be causing variance issues, ie:
-    # TypeVar "_KT_contra@SupportsGetItem" is contravariant
-    #   "tuple[int, int]" is incompatible with protocol "SupportsIndex"
-    # preventing [_T_co, ...] instead of [Any, ...]
-    #
-    # A suspected mypy issue prevents using [..., _T] instead of [..., Any] here.
-    # https://github.com/python/mypy/issues/14032
-    def __call__(self, obj: SupportsGetItem[Any, Any]) -> Any: ...
-
-@final
-class methodcaller:
-    def __init__(self, __name: str, *args: Any, **kwargs: Any) -> None: ...
-    def __call__(self, obj: Any) -> Any: ...
-
-def iadd(__a: Any, __b: Any) -> Any: ...
-def iand(__a: Any, __b: Any) -> Any: ...
-def iconcat(__a: Any, __b: Any) -> Any: ...
-def ifloordiv(__a: Any, __b: Any) -> Any: ...
-def ilshift(__a: Any, __b: Any) -> Any: ...
-def imod(__a: Any, __b: Any) -> Any: ...
-def imul(__a: Any, __b: Any) -> Any: ...
-def imatmul(__a: Any, __b: Any) -> Any: ...
-def ior(__a: Any, __b: Any) -> Any: ...
-def ipow(__a: Any, __b: Any) -> Any: ...
-def irshift(__a: Any, __b: Any) -> Any: ...
-def isub(__a: Any, __b: Any) -> Any: ...
-def itruediv(__a: Any, __b: Any) -> Any: ...
-def ixor(__a: Any, __b: Any) -> Any: ...
+def setitem(a: MutableMapping[_K, _V], b: _K, c: _V, /) -> None: ...
+def length_hint(obj: object, default: int = 0, /) -> int: ...
+def iadd(a: Any, b: Any, /) -> Any: ...
+def iand(a: Any, b: Any, /) -> Any: ...
+def iconcat(a: Any, b: Any, /) -> Any: ...
+def ifloordiv(a: Any, b: Any, /) -> Any: ...
+def ilshift(a: Any, b: Any, /) -> Any: ...
+def imod(a: Any, b: Any, /) -> Any: ...
+def imul(a: Any, b: Any, /) -> Any: ...
+def imatmul(a: Any, b: Any, /) -> Any: ...
+def ior(a: Any, b: Any, /) -> Any: ...
+def ipow(a: Any, b: Any, /) -> Any: ...
+def irshift(a: Any, b: Any, /) -> Any: ...
+def isub(a: Any, b: Any, /) -> Any: ...
+def itruediv(a: Any, b: Any, /) -> Any: ...
+def ixor(a: Any, b: Any, /) -> Any: ...
 
 if sys.version_info >= (3, 11):
-    def call(__obj: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+    def call(obj: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+
+def _compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
 
-def _compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ...
+if sys.version_info >= (3, 14):
+    def is_none(a: object, /) -> TypeIs[None]: ...
+    def is_not_none(a: _T | None, /) -> TypeIs[_T]: ...
diff --git a/mypy/typeshed/stdlib/_osx_support.pyi b/mypy/typeshed/stdlib/_osx_support.pyi
index 3eb6f4ddc67c..fb00e6986dd0 100644
--- a/mypy/typeshed/stdlib/_osx_support.pyi
+++ b/mypy/typeshed/stdlib/_osx_support.pyi
@@ -1,6 +1,5 @@
-import sys
 from collections.abc import Iterable, Sequence
-from typing import TypeVar
+from typing import Final, TypeVar
 
 _T = TypeVar("_T")
 _K = TypeVar("_K")
@@ -8,21 +7,15 @@ _V = TypeVar("_V")
 
 __all__ = ["compiler_fixup", "customize_config_vars", "customize_compiler", "get_platform_osx"]
 
-_UNIVERSAL_CONFIG_VARS: tuple[str, ...]  # undocumented
-_COMPILER_CONFIG_VARS: tuple[str, ...]  # undocumented
-_INITPRE: str  # undocumented
+_UNIVERSAL_CONFIG_VARS: Final[tuple[str, ...]]  # undocumented
+_COMPILER_CONFIG_VARS: Final[tuple[str, ...]]  # undocumented
+_INITPRE: Final[str]  # undocumented
 
 def _find_executable(executable: str, path: str | None = None) -> str | None: ...  # undocumented
-
-if sys.version_info >= (3, 8):
-    def _read_output(commandstring: str, capture_stderr: bool = False) -> str | None: ...  # undocumented
-
-else:
-    def _read_output(commandstring: str) -> str | None: ...  # undocumented
-
+def _read_output(commandstring: str, capture_stderr: bool = False) -> str | None: ...  # undocumented
 def _find_build_tool(toolname: str) -> str: ...  # undocumented
 
-_SYSTEM_VERSION: str | None  # undocumented
+_SYSTEM_VERSION: Final[str | None]  # undocumented
 
 def _get_system_version() -> str: ...  # undocumented
 def _remove_original_values(_config_vars: dict[str, str]) -> None: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/_pickle.pyi b/mypy/typeshed/stdlib/_pickle.pyi
new file mode 100644
index 000000000000..50bbb6bc16cd
--- /dev/null
+++ b/mypy/typeshed/stdlib/_pickle.pyi
@@ -0,0 +1,107 @@
+import sys
+from _typeshed import ReadableBuffer, SupportsWrite
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from pickle import PickleBuffer as PickleBuffer
+from typing import Any, Protocol, type_check_only
+from typing_extensions import TypeAlias
+
+class _ReadableFileobj(Protocol):
+    def read(self, n: int, /) -> bytes: ...
+    def readline(self) -> bytes: ...
+
+_BufferCallback: TypeAlias = Callable[[PickleBuffer], Any] | None
+
+_ReducedType: TypeAlias = (
+    str
+    | tuple[Callable[..., Any], tuple[Any, ...]]
+    | tuple[Callable[..., Any], tuple[Any, ...], Any]
+    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None]
+    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None, Iterator[Any] | None]
+)
+
+def dump(
+    obj: Any,
+    file: SupportsWrite[bytes],
+    protocol: int | None = None,
+    *,
+    fix_imports: bool = True,
+    buffer_callback: _BufferCallback = None,
+) -> None: ...
+def dumps(
+    obj: Any, protocol: int | None = None, *, fix_imports: bool = True, buffer_callback: _BufferCallback = None
+) -> bytes: ...
+def load(
+    file: _ReadableFileobj,
+    *,
+    fix_imports: bool = True,
+    encoding: str = "ASCII",
+    errors: str = "strict",
+    buffers: Iterable[Any] | None = (),
+) -> Any: ...
+def loads(
+    data: ReadableBuffer,
+    /,
+    *,
+    fix_imports: bool = True,
+    encoding: str = "ASCII",
+    errors: str = "strict",
+    buffers: Iterable[Any] | None = (),
+) -> Any: ...
+
+class PickleError(Exception): ...
+class PicklingError(PickleError): ...
+class UnpicklingError(PickleError): ...
+
+@type_check_only
+class PicklerMemoProxy:
+    def clear(self, /) -> None: ...
+    def copy(self, /) -> dict[int, tuple[int, Any]]: ...
+
+class Pickler:
+    fast: bool
+    dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
+    reducer_override: Callable[[Any], Any]
+    bin: bool  # undocumented
+    def __init__(
+        self,
+        file: SupportsWrite[bytes],
+        protocol: int | None = None,
+        fix_imports: bool = True,
+        buffer_callback: _BufferCallback = None,
+    ) -> None: ...
+    @property
+    def memo(self) -> PicklerMemoProxy: ...
+    @memo.setter
+    def memo(self, value: PicklerMemoProxy | dict[int, tuple[int, Any]]) -> None: ...
+    def dump(self, obj: Any, /) -> None: ...
+    def clear_memo(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def persistent_id(self, obj: Any, /) -> Any: ...
+    else:
+        persistent_id: Callable[[Any], Any]
+
+@type_check_only
+class UnpicklerMemoProxy:
+    def clear(self, /) -> None: ...
+    def copy(self, /) -> dict[int, tuple[int, Any]]: ...
+
+class Unpickler:
+    def __init__(
+        self,
+        file: _ReadableFileobj,
+        *,
+        fix_imports: bool = True,
+        encoding: str = "ASCII",
+        errors: str = "strict",
+        buffers: Iterable[Any] | None = (),
+    ) -> None: ...
+    @property
+    def memo(self) -> UnpicklerMemoProxy: ...
+    @memo.setter
+    def memo(self, value: UnpicklerMemoProxy | dict[int, tuple[int, Any]]) -> None: ...
+    def load(self) -> Any: ...
+    def find_class(self, module_name: str, global_name: str, /) -> Any: ...
+    if sys.version_info >= (3, 13):
+        def persistent_load(self, pid: Any, /) -> Any: ...
+    else:
+        persistent_load: Callable[[Any], Any]
diff --git a/mypy/typeshed/stdlib/_posixsubprocess.pyi b/mypy/typeshed/stdlib/_posixsubprocess.pyi
index ca95336bb503..df05dcd80be8 100644
--- a/mypy/typeshed/stdlib/_posixsubprocess.pyi
+++ b/mypy/typeshed/stdlib/_posixsubprocess.pyi
@@ -1,32 +1,32 @@
 import sys
 from _typeshed import StrOrBytesPath
 from collections.abc import Callable, Sequence
-from typing_extensions import SupportsIndex
+from typing import SupportsIndex
 
 if sys.platform != "win32":
-    def cloexec_pipe() -> tuple[int, int]: ...
     def fork_exec(
-        __process_args: Sequence[StrOrBytesPath] | None,
-        __executable_list: Sequence[bytes],
-        __close_fds: bool,
-        __fds_to_keep: tuple[int, ...],
-        __cwd_obj: str,
-        __env_list: Sequence[bytes] | None,
-        __p2cread: int,
-        __p2cwrite: int,
-        __c2pred: int,
-        __c2pwrite: int,
-        __errread: int,
-        __errwrite: int,
-        __errpipe_read: int,
-        __errpipe_write: int,
-        __restore_signals: int,
-        __call_setsid: int,
-        __pgid_to_set: int,
-        __gid_object: SupportsIndex | None,
-        __groups_list: list[int] | None,
-        __uid_object: SupportsIndex | None,
-        __child_umask: int,
-        __preexec_fn: Callable[[], None],
-        __allow_vfork: bool,
+        args: Sequence[StrOrBytesPath] | None,
+        executable_list: Sequence[bytes],
+        close_fds: bool,
+        pass_fds: tuple[int, ...],
+        cwd: str,
+        env: Sequence[bytes] | None,
+        p2cread: int,
+        p2cwrite: int,
+        c2pread: int,
+        c2pwrite: int,
+        errread: int,
+        errwrite: int,
+        errpipe_read: int,
+        errpipe_write: int,
+        restore_signals: int,
+        call_setsid: int,
+        pgid_to_set: int,
+        gid: SupportsIndex | None,
+        extra_groups: list[int] | None,
+        uid: SupportsIndex | None,
+        child_umask: int,
+        preexec_fn: Callable[[], None],
+        allow_vfork: bool,
+        /,
     ) -> int: ...
diff --git a/mypy/typeshed/stdlib/_py_abc.pyi b/mypy/typeshed/stdlib/_py_abc.pyi
index cc45c6ad3814..1260717489e4 100644
--- a/mypy/typeshed/stdlib/_py_abc.pyi
+++ b/mypy/typeshed/stdlib/_py_abc.pyi
@@ -9,6 +9,6 @@ def get_cache_token() -> _CacheToken: ...
 
 class ABCMeta(type):
     def __new__(
-        __mcls: type[_typeshed.Self], __name: str, __bases: tuple[type[Any], ...], __namespace: dict[str, Any]
+        mcls: type[_typeshed.Self], name: str, bases: tuple[type[Any], ...], namespace: dict[str, Any], /
     ) -> _typeshed.Self: ...
     def register(cls, subclass: type[_T]) -> type[_T]: ...
diff --git a/mypy/typeshed/stdlib/_queue.pyi b/mypy/typeshed/stdlib/_queue.pyi
new file mode 100644
index 000000000000..0d4caea7442e
--- /dev/null
+++ b/mypy/typeshed/stdlib/_queue.pyi
@@ -0,0 +1,20 @@
+import sys
+from typing import Any, Generic, TypeVar
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+
+class Empty(Exception): ...
+
+class SimpleQueue(Generic[_T]):
+    def __init__(self) -> None: ...
+    def empty(self) -> bool: ...
+    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
+    def get_nowait(self) -> _T: ...
+    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
+    def put_nowait(self, item: _T) -> None: ...
+    def qsize(self) -> int: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/mypy/typeshed/stdlib/_random.pyi b/mypy/typeshed/stdlib/_random.pyi
index 7c5803ede781..4082344ade8e 100644
--- a/mypy/typeshed/stdlib/_random.pyi
+++ b/mypy/typeshed/stdlib/_random.pyi
@@ -5,8 +5,8 @@ _State: TypeAlias = tuple[int, ...]
 
 class Random:
     def __init__(self, seed: object = ...) -> None: ...
-    def seed(self, __n: object = None) -> None: ...
+    def seed(self, n: object = None, /) -> None: ...
     def getstate(self) -> _State: ...
-    def setstate(self, __state: _State) -> None: ...
+    def setstate(self, state: _State, /) -> None: ...
     def random(self) -> float: ...
-    def getrandbits(self, __k: int) -> int: ...
+    def getrandbits(self, k: int, /) -> int: ...
diff --git a/mypy/typeshed/stdlib/_sitebuiltins.pyi b/mypy/typeshed/stdlib/_sitebuiltins.pyi
index 94ad701d4a73..eb6c81129421 100644
--- a/mypy/typeshed/stdlib/_sitebuiltins.pyi
+++ b/mypy/typeshed/stdlib/_sitebuiltins.pyi
@@ -1,12 +1,12 @@
+import sys
 from collections.abc import Iterable
-from typing import ClassVar, NoReturn
-from typing_extensions import Literal
+from typing import ClassVar, Literal, NoReturn
 
 class Quitter:
     name: str
     eof: str
     def __init__(self, name: str, eof: str) -> None: ...
-    def __call__(self, code: int | None = None) -> NoReturn: ...
+    def __call__(self, code: sys._ExitCode = None) -> NoReturn: ...
 
 class _Printer:
     MAXLINES: ClassVar[Literal[23]]
@@ -14,4 +14,4 @@ class _Printer:
     def __call__(self) -> None: ...
 
 class _Helper:
-    def __call__(self, request: object) -> None: ...
+    def __call__(self, request: object = ...) -> None: ...
diff --git a/mypy/typeshed/stdlib/_socket.pyi b/mypy/typeshed/stdlib/_socket.pyi
index f7b0e6901bf4..649728257c1a 100644
--- a/mypy/typeshed/stdlib/_socket.pyi
+++ b/mypy/typeshed/stdlib/_socket.pyi
@@ -1,15 +1,9 @@
 import sys
 from _typeshed import ReadableBuffer, WriteableBuffer
 from collections.abc import Iterable
-from typing import Any, SupportsInt, overload
-from typing_extensions import TypeAlias
-
-if sys.version_info >= (3, 8):
-    from typing import SupportsIndex
-
-    _FD: TypeAlias = SupportsIndex
-else:
-    _FD: TypeAlias = SupportsInt
+from socket import error as error, gaierror as gaierror, herror as herror, timeout as timeout
+from typing import Any, SupportsIndex, overload
+from typing_extensions import CapsuleType, TypeAlias
 
 _CMSG: TypeAlias = tuple[int, int, bytes]
 _CMSGArg: TypeAlias = tuple[int, int, ReadableBuffer]
@@ -20,19 +14,18 @@ _CMSGArg: TypeAlias = tuple[int, int, ReadableBuffer]
 _Address: TypeAlias = tuple[Any, ...] | str | ReadableBuffer
 _RetAddress: TypeAlias = Any
 
-# ----- Constants -----
-# Some socket families are listed in the "Socket families" section of the docs,
-# but not the "Constants" section. These are listed at the end of the list of
-# constants.
-#
-# Besides those and the first few constants listed, the constants are listed in
-# documentation order.
+# ===== Constants =====
+# This matches the order in the CPython documentation
+# https://docs.python.org/3/library/socket.html#constants
 
-has_ipv6: bool
+if sys.platform != "win32":
+    AF_UNIX: int
 
 AF_INET: int
 AF_INET6: int
 
+AF_UNSPEC: int
+
 SOCK_STREAM: int
 SOCK_DGRAM: int
 SOCK_RAW: int
@@ -40,60 +33,174 @@ SOCK_RDM: int
 SOCK_SEQPACKET: int
 
 if sys.platform == "linux":
+    # Availability: Linux >= 2.6.27
     SOCK_CLOEXEC: int
     SOCK_NONBLOCK: int
 
-# Address families not mentioned in the docs
-AF_APPLETALK: int
-AF_DECnet: int
-AF_IPX: int
-AF_SNA: int
-AF_UNSPEC: int
+# --------------------
+# Many constants of these forms, documented in the Unix documentation on
+# sockets and/or the IP protocol, are also defined in the socket module.
+# SO_*
+# socket.SOMAXCONN
+# MSG_*
+# SOL_*
+# SCM_*
+# IPPROTO_*
+# IPPORT_*
+# INADDR_*
+# IP_*
+# IPV6_*
+# EAI_*
+# AI_*
+# NI_*
+# TCP_*
+# --------------------
 
+SO_ACCEPTCONN: int
+SO_BROADCAST: int
+SO_DEBUG: int
+SO_DONTROUTE: int
+SO_ERROR: int
+SO_KEEPALIVE: int
+SO_LINGER: int
+SO_OOBINLINE: int
+SO_RCVBUF: int
+SO_RCVLOWAT: int
+SO_RCVTIMEO: int
+SO_REUSEADDR: int
+SO_SNDBUF: int
+SO_SNDLOWAT: int
+SO_SNDTIMEO: int
+SO_TYPE: int
+if sys.platform != "linux":
+    SO_USELOOPBACK: int
+if sys.platform == "win32":
+    SO_EXCLUSIVEADDRUSE: int
 if sys.platform != "win32":
-    AF_ROUTE: int
-    AF_SYSTEM: int
-    AF_UNIX: int
+    SO_REUSEPORT: int
+    if sys.platform != "darwin":
+        SO_BINDTODEVICE: int
 
+if sys.platform != "win32" and sys.platform != "darwin":
+    SO_DOMAIN: int
+    SO_MARK: int
+    SO_PASSCRED: int
+    SO_PASSSEC: int
+    SO_PEERCRED: int
+    SO_PEERSEC: int
+    SO_PRIORITY: int
+    SO_PROTOCOL: int
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+    SO_SETFIB: int
+if sys.platform == "linux" and sys.version_info >= (3, 13):
+    SO_BINDTOIFINDEX: int
+
+SOMAXCONN: int
+
+MSG_CTRUNC: int
+MSG_DONTROUTE: int
+MSG_OOB: int
+MSG_PEEK: int
+MSG_TRUNC: int
+MSG_WAITALL: int
+if sys.platform != "win32":
+    MSG_DONTWAIT: int
+    MSG_EOR: int
+    MSG_NOSIGNAL: int  # Sometimes this exists on darwin, sometimes not
 if sys.platform != "darwin":
-    AF_IRDA: int
+    MSG_ERRQUEUE: int
+if sys.platform == "win32":
+    MSG_BCAST: int
+    MSG_MCAST: int
+if sys.platform != "win32" and sys.platform != "darwin":
+    MSG_CMSG_CLOEXEC: int
+    MSG_CONFIRM: int
+    MSG_FASTOPEN: int
+    MSG_MORE: int
+if sys.platform != "win32" and sys.platform != "linux":
+    MSG_EOF: int
+if sys.platform != "win32" and sys.platform != "linux" and sys.platform != "darwin":
+    MSG_NOTIFICATION: int
+    MSG_BTAG: int  # Not FreeBSD either
+    MSG_ETAG: int  # Not FreeBSD either
 
-if sys.platform != "darwin" and sys.platform != "win32":
-    AF_AAL5: int
-    AF_ASH: int
-    AF_ATMPVC: int
-    AF_ATMSVC: int
-    AF_AX25: int
-    AF_BRIDGE: int
-    AF_ECONET: int
-    AF_KEY: int
-    AF_LLC: int
-    AF_NETBEUI: int
-    AF_NETROM: int
-    AF_PPPOX: int
-    AF_ROSE: int
-    AF_SECURITY: int
-    AF_WANPIPE: int
-    AF_X25: int
+SOL_IP: int
+SOL_SOCKET: int
+SOL_TCP: int
+SOL_UDP: int
+if sys.platform != "win32" and sys.platform != "darwin":
+    # Defined in socket.h for Linux, but these aren't always present for
+    # some reason.
+    SOL_ATALK: int
+    SOL_AX25: int
+    SOL_HCI: int
+    SOL_IPX: int
+    SOL_NETROM: int
+    SOL_ROSE: int
+
+if sys.platform != "win32":
+    SCM_RIGHTS: int
+if sys.platform != "win32" and sys.platform != "darwin":
+    SCM_CREDENTIALS: int
+if sys.platform != "win32" and sys.platform != "linux":
+    SCM_CREDS: int
+
+IPPROTO_ICMP: int
+IPPROTO_IP: int
+IPPROTO_RAW: int
+IPPROTO_TCP: int
+IPPROTO_UDP: int
+IPPROTO_AH: int
+IPPROTO_DSTOPTS: int
+IPPROTO_EGP: int
+IPPROTO_ESP: int
+IPPROTO_FRAGMENT: int
+IPPROTO_HOPOPTS: int
+IPPROTO_ICMPV6: int
+IPPROTO_IDP: int
+IPPROTO_IGMP: int
+IPPROTO_IPV6: int
+IPPROTO_NONE: int
+IPPROTO_PIM: int
+IPPROTO_PUP: int
+IPPROTO_ROUTING: int
+IPPROTO_SCTP: int
+if sys.platform != "linux":
+    IPPROTO_GGP: int
+    IPPROTO_IPV4: int
+    IPPROTO_MAX: int
+    IPPROTO_ND: int
+if sys.platform == "win32":
+    IPPROTO_CBT: int
+    IPPROTO_ICLFXBM: int
+    IPPROTO_IGP: int
+    IPPROTO_L2TP: int
+    IPPROTO_PGM: int
+    IPPROTO_RDP: int
+    IPPROTO_ST: int
+if sys.platform != "win32":
+    IPPROTO_GRE: int
+    IPPROTO_IPIP: int
+    IPPROTO_RSVP: int
+    IPPROTO_TP: int
+if sys.platform != "win32" and sys.platform != "linux":
+    IPPROTO_EON: int
+    IPPROTO_HELLO: int
+    IPPROTO_IPCOMP: int
+    IPPROTO_XTP: int
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+    IPPROTO_BIP: int  # Not FreeBSD either
+    IPPROTO_MOBILE: int  # Not FreeBSD either
+    IPPROTO_VRRP: int  # Not FreeBSD either
+if sys.version_info >= (3, 9) and sys.platform == "linux":
+    # Availability: Linux >= 2.6.20, FreeBSD >= 10.1
+    IPPROTO_UDPLITE: int
+if sys.version_info >= (3, 10) and sys.platform == "linux":
+    IPPROTO_MPTCP: int
+
+IPPORT_RESERVED: int
+IPPORT_USERRESERVED: int
 
-# The "many constants" referenced by the docs
-SOMAXCONN: int
-AI_ADDRCONFIG: int
-AI_ALL: int
-AI_CANONNAME: int
-AI_NUMERICHOST: int
-AI_NUMERICSERV: int
-AI_PASSIVE: int
-AI_V4MAPPED: int
-EAI_AGAIN: int
-EAI_BADFLAGS: int
-EAI_FAIL: int
-EAI_FAMILY: int
-EAI_MEMORY: int
-EAI_NODATA: int
-EAI_NONAME: int
-EAI_SERVICE: int
-EAI_SOCKTYPE: int
 INADDR_ALLHOSTS_GROUP: int
 INADDR_ANY: int
 INADDR_BROADCAST: int
@@ -101,44 +208,38 @@ INADDR_LOOPBACK: int
 INADDR_MAX_LOCAL_GROUP: int
 INADDR_NONE: int
 INADDR_UNSPEC_GROUP: int
-IPPORT_RESERVED: int
-IPPORT_USERRESERVED: int
-
-if sys.platform != "win32" or sys.version_info >= (3, 8):
-    IPPROTO_AH: int
-    IPPROTO_DSTOPTS: int
-    IPPROTO_EGP: int
-    IPPROTO_ESP: int
-    IPPROTO_FRAGMENT: int
-    IPPROTO_GGP: int
-    IPPROTO_HOPOPTS: int
-    IPPROTO_ICMPV6: int
-    IPPROTO_IDP: int
-    IPPROTO_IGMP: int
-    IPPROTO_IPV4: int
-    IPPROTO_IPV6: int
-    IPPROTO_MAX: int
-    IPPROTO_ND: int
-    IPPROTO_NONE: int
-    IPPROTO_PIM: int
-    IPPROTO_PUP: int
-    IPPROTO_ROUTING: int
-    IPPROTO_SCTP: int
 
-    if sys.platform != "darwin":
-        IPPROTO_CBT: int
-        IPPROTO_ICLFXBM: int
-        IPPROTO_IGP: int
-        IPPROTO_L2TP: int
-        IPPROTO_PGM: int
-        IPPROTO_RDP: int
-        IPPROTO_ST: int
+IP_ADD_MEMBERSHIP: int
+IP_DROP_MEMBERSHIP: int
+IP_HDRINCL: int
+IP_MULTICAST_IF: int
+IP_MULTICAST_LOOP: int
+IP_MULTICAST_TTL: int
+IP_OPTIONS: int
+if sys.platform != "linux":
+    IP_RECVDSTADDR: int
+if sys.version_info >= (3, 10):
+    IP_RECVTOS: int
+IP_TOS: int
+IP_TTL: int
+if sys.platform != "win32":
+    IP_DEFAULT_MULTICAST_LOOP: int
+    IP_DEFAULT_MULTICAST_TTL: int
+    IP_MAX_MEMBERSHIPS: int
+    IP_RECVOPTS: int
+    IP_RECVRETOPTS: int
+    IP_RETOPTS: int
+if sys.platform != "win32" and sys.platform != "darwin":
+    IP_TRANSPARENT: int
+if sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 11):
+    IP_BIND_ADDRESS_NO_PORT: int
+if sys.version_info >= (3, 12):
+    IP_ADD_SOURCE_MEMBERSHIP: int
+    IP_BLOCK_SOURCE: int
+    IP_DROP_SOURCE_MEMBERSHIP: int
+    IP_PKTINFO: int
+    IP_UNBLOCK_SOURCE: int
 
-IPPROTO_ICMP: int
-IPPROTO_IP: int
-IPPROTO_RAW: int
-IPPROTO_TCP: int
-IPPROTO_UDP: int
 IPV6_CHECKSUM: int
 IPV6_JOIN_GROUP: int
 IPV6_LEAVE_GROUP: int
@@ -149,39 +250,60 @@ IPV6_RECVTCLASS: int
 IPV6_TCLASS: int
 IPV6_UNICAST_HOPS: int
 IPV6_V6ONLY: int
-
-if sys.platform != "darwin" or sys.version_info >= (3, 9):
+if sys.version_info >= (3, 9) or sys.platform != "darwin":
     IPV6_DONTFRAG: int
     IPV6_HOPLIMIT: int
     IPV6_HOPOPTS: int
     IPV6_PKTINFO: int
     IPV6_RECVRTHDR: int
     IPV6_RTHDR: int
+if sys.platform != "win32":
+    IPV6_RTHDR_TYPE_0: int
+    if sys.version_info >= (3, 9) or sys.platform != "darwin":
+        IPV6_DSTOPTS: int
+        IPV6_NEXTHOP: int
+        IPV6_PATHMTU: int
+        IPV6_RECVDSTOPTS: int
+        IPV6_RECVHOPLIMIT: int
+        IPV6_RECVHOPOPTS: int
+        IPV6_RECVPATHMTU: int
+        IPV6_RECVPKTINFO: int
+        IPV6_RTHDRDSTOPTS: int
 
-IP_ADD_MEMBERSHIP: int
-IP_DROP_MEMBERSHIP: int
-IP_HDRINCL: int
-IP_MULTICAST_IF: int
-IP_MULTICAST_LOOP: int
-IP_MULTICAST_TTL: int
-IP_OPTIONS: int
-IP_RECVDSTADDR: int
-if sys.version_info >= (3, 10):
-    IP_RECVTOS: int
-elif sys.platform != "win32" and sys.platform != "darwin":
-    IP_RECVTOS: int
-IP_TOS: int
-IP_TTL: int
-MSG_CTRUNC: int
-MSG_DONTROUTE: int
+if sys.platform != "win32" and sys.platform != "linux":
+    if sys.version_info >= (3, 9) or sys.platform != "darwin":
+        IPV6_USE_MIN_MTU: int
 
-if sys.platform != "darwin":
-    MSG_ERRQUEUE: int
+EAI_AGAIN: int
+EAI_BADFLAGS: int
+EAI_FAIL: int
+EAI_FAMILY: int
+EAI_MEMORY: int
+EAI_NODATA: int
+EAI_NONAME: int
+EAI_SERVICE: int
+EAI_SOCKTYPE: int
+if sys.platform != "win32":
+    EAI_ADDRFAMILY: int
+    EAI_OVERFLOW: int
+    EAI_SYSTEM: int
+if sys.platform != "win32" and sys.platform != "linux":
+    EAI_BADHINTS: int
+    EAI_MAX: int
+    EAI_PROTOCOL: int
+
+AI_ADDRCONFIG: int
+AI_ALL: int
+AI_CANONNAME: int
+AI_NUMERICHOST: int
+AI_NUMERICSERV: int
+AI_PASSIVE: int
+AI_V4MAPPED: int
+if sys.platform != "win32" and sys.platform != "linux":
+    AI_DEFAULT: int
+    AI_MASK: int
+    AI_V4MAPPED_CFG: int
 
-MSG_OOB: int
-MSG_PEEK: int
-MSG_TRUNC: int
-MSG_WAITALL: int
 NI_DGRAM: int
 NI_MAXHOST: int
 NI_MAXSERV: int
@@ -189,137 +311,61 @@ NI_NAMEREQD: int
 NI_NOFQDN: int
 NI_NUMERICHOST: int
 NI_NUMERICSERV: int
-SHUT_RD: int
-SHUT_RDWR: int
-SHUT_WR: int
-SOL_IP: int
-SOL_SOCKET: int
-SOL_TCP: int
-SOL_UDP: int
-SO_ACCEPTCONN: int
-SO_BROADCAST: int
-SO_DEBUG: int
-SO_DONTROUTE: int
-SO_ERROR: int
-SO_KEEPALIVE: int
-SO_LINGER: int
-SO_OOBINLINE: int
-SO_RCVBUF: int
-SO_RCVLOWAT: int
-SO_RCVTIMEO: int
-SO_REUSEADDR: int
-SO_SNDBUF: int
-SO_SNDLOWAT: int
-SO_SNDTIMEO: int
-SO_TYPE: int
-SO_USELOOPBACK: int
-if sys.platform == "linux" and sys.version_info >= (3, 11):
-    SO_INCOMING_CPU: int
+if sys.platform == "linux" and sys.version_info >= (3, 13):
+    NI_IDN: int
+
 TCP_FASTOPEN: int
 TCP_KEEPCNT: int
 TCP_KEEPINTVL: int
-
-if sys.platform != "darwin":
-    TCP_KEEPIDLE: int
-
 TCP_MAXSEG: int
 TCP_NODELAY: int
 if sys.platform != "win32":
     TCP_NOTSENT_LOWAT: int
+if sys.platform != "darwin":
+    TCP_KEEPIDLE: int
 if sys.version_info >= (3, 10) and sys.platform == "darwin":
     TCP_KEEPALIVE: int
 if sys.version_info >= (3, 11) and sys.platform == "darwin":
     TCP_CONNECTION_INFO: int
 
-if sys.platform != "darwin":
-    MSG_BCAST: int
-    MSG_MCAST: int
-    SO_EXCLUSIVEADDRUSE: int
-
-if sys.platform != "win32":
-    AI_DEFAULT: int
-    AI_MASK: int
-    AI_V4MAPPED_CFG: int
-    EAI_ADDRFAMILY: int
-    EAI_BADHINTS: int
-    EAI_MAX: int
-    EAI_OVERFLOW: int
-    EAI_PROTOCOL: int
-    EAI_SYSTEM: int
-    IPPROTO_EON: int
-    IPPROTO_GRE: int
-    IPPROTO_HELLO: int
-    IPPROTO_IPCOMP: int
-    IPPROTO_IPIP: int
-    IPPROTO_RSVP: int
-    IPPROTO_TP: int
-    IPPROTO_XTP: int
-    IPV6_RTHDR_TYPE_0: int
-    IP_DEFAULT_MULTICAST_LOOP: int
-    IP_DEFAULT_MULTICAST_TTL: int
-    IP_MAX_MEMBERSHIPS: int
-    IP_RECVOPTS: int
-    IP_RECVRETOPTS: int
-    IP_RETOPTS: int
-    LOCAL_PEERCRED: int
-    MSG_DONTWAIT: int
-    MSG_EOF: int
-    MSG_EOR: int
-    MSG_NOSIGNAL: int  # Sometimes this exists on darwin, sometimes not
-    SCM_CREDS: int
-    SCM_RIGHTS: int
-    SO_REUSEPORT: int
-
-if sys.platform != "win32":
-    if sys.platform != "darwin" or sys.version_info >= (3, 9):
-        IPV6_DSTOPTS: int
-        IPV6_NEXTHOP: int
-        IPV6_PATHMTU: int
-        IPV6_RECVDSTOPTS: int
-        IPV6_RECVHOPLIMIT: int
-        IPV6_RECVHOPOPTS: int
-        IPV6_RECVPATHMTU: int
-        IPV6_RECVPKTINFO: int
-        IPV6_RTHDRDSTOPTS: int
-        IPV6_USE_MIN_MTU: int
-
 if sys.platform != "win32" and sys.platform != "darwin":
-    IPPROTO_BIP: int
-    IPPROTO_MOBILE: int
-    IPPROTO_VRRP: int
-    IPX_TYPE: int
-    IP_TRANSPARENT: int
-    MSG_BTAG: int
-    MSG_CMSG_CLOEXEC: int
-    MSG_CONFIRM: int
-    MSG_ETAG: int
-    MSG_FASTOPEN: int
-    MSG_MORE: int
-    MSG_NOTIFICATION: int
-    SCM_CREDENTIALS: int
-    SOL_ATALK: int
-    SOL_AX25: int
-    SOL_HCI: int
-    SOL_IPX: int
-    SOL_NETROM: int
-    SOL_ROSE: int
-    SO_BINDTODEVICE: int
-    SO_MARK: int
-    SO_PASSCRED: int
-    SO_PEERCRED: int
-    SO_PRIORITY: int
-    SO_SETFIB: int
+    TCP_CONGESTION: int
     TCP_CORK: int
     TCP_DEFER_ACCEPT: int
     TCP_INFO: int
     TCP_LINGER2: int
     TCP_QUICKACK: int
     TCP_SYNCNT: int
+    TCP_USER_TIMEOUT: int
     TCP_WINDOW_CLAMP: int
-
-# Specifically-documented constants
+if sys.platform == "linux" and sys.version_info >= (3, 12):
+    TCP_CC_INFO: int
+    TCP_FASTOPEN_CONNECT: int
+    TCP_FASTOPEN_KEY: int
+    TCP_FASTOPEN_NO_COOKIE: int
+    TCP_INQ: int
+    TCP_MD5SIG: int
+    TCP_MD5SIG_EXT: int
+    TCP_QUEUE_SEQ: int
+    TCP_REPAIR: int
+    TCP_REPAIR_OPTIONS: int
+    TCP_REPAIR_QUEUE: int
+    TCP_REPAIR_WINDOW: int
+    TCP_SAVED_SYN: int
+    TCP_SAVE_SYN: int
+    TCP_THIN_DUPACK: int
+    TCP_THIN_LINEAR_TIMEOUTS: int
+    TCP_TIMESTAMP: int
+    TCP_TX_DELAY: int
+    TCP_ULP: int
+    TCP_ZEROCOPY_RECEIVE: int
+
+# --------------------
+# Specifically documented constants
+# --------------------
 
 if sys.platform == "linux":
+    # Availability: Linux >= 2.6.25, NetBSD >= 8
     AF_CAN: int
     PF_CAN: int
     SOL_CAN_BASE: int
@@ -329,13 +375,16 @@ if sys.platform == "linux":
     CAN_ERR_FLAG: int
     CAN_ERR_MASK: int
     CAN_RAW: int
-    CAN_RAW_ERR_FILTER: int
     CAN_RAW_FILTER: int
     CAN_RAW_LOOPBACK: int
     CAN_RAW_RECV_OWN_MSGS: int
     CAN_RTR_FLAG: int
     CAN_SFF_MASK: int
+    if sys.version_info < (3, 11):
+        CAN_RAW_ERR_FILTER: int
 
+if sys.platform == "linux":
+    # Availability: Linux >= 2.6.25
     CAN_BCM: int
     CAN_BCM_TX_SETUP: int
     CAN_BCM_TX_DELETE: int
@@ -349,10 +398,6 @@ if sys.platform == "linux":
     CAN_BCM_RX_STATUS: int
     CAN_BCM_RX_TIMEOUT: int
     CAN_BCM_RX_CHANGED: int
-
-    CAN_RAW_FD_FRAMES: int
-
-if sys.platform == "linux" and sys.version_info >= (3, 8):
     CAN_BCM_SETTIMER: int
     CAN_BCM_STARTTIMER: int
     CAN_BCM_TX_COUNTEVT: int
@@ -367,11 +412,20 @@ if sys.platform == "linux" and sys.version_info >= (3, 8):
     CAN_BCM_CAN_FD_FRAME: int
 
 if sys.platform == "linux":
+    # Availability: Linux >= 3.6
+    CAN_RAW_FD_FRAMES: int
+
+if sys.platform == "linux" and sys.version_info >= (3, 9):
+    # Availability: Linux >= 4.1
+    CAN_RAW_JOIN_FILTERS: int
+
+if sys.platform == "linux":
+    # Availability: Linux >= 2.6.25
     CAN_ISOTP: int
 
 if sys.platform == "linux" and sys.version_info >= (3, 9):
+    # Availability: Linux >= 5.4
     CAN_J1939: int
-    CAN_RAW_JOIN_FILTERS: int
 
     J1939_MAX_UNICAST_ADDR: int
     J1939_IDLE_ADDR: int
@@ -396,16 +450,17 @@ if sys.platform == "linux" and sys.version_info >= (3, 9):
 
     J1939_NLA_PAD: int
     J1939_NLA_BYTES_ACKED: int
-
     J1939_EE_INFO_NONE: int
     J1939_EE_INFO_TX_ABORT: int
-
     J1939_FILTER_MAX: int
 
-if sys.platform == "linux" and sys.version_info >= (3, 10):
-    IPPROTO_MPTCP: int
+if sys.version_info >= (3, 12) and sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin":
+    # Availability: FreeBSD >= 14.0
+    AF_DIVERT: int
+    PF_DIVERT: int
 
 if sys.platform == "linux":
+    # Availability: Linux >= 2.2
     AF_PACKET: int
     PF_PACKET: int
     PACKET_BROADCAST: int
@@ -416,16 +471,21 @@ if sys.platform == "linux":
     PACKET_OTHERHOST: int
     PACKET_OUTGOING: int
 
+if sys.version_info >= (3, 12) and sys.platform == "linux":
+    ETH_P_ALL: int
+
 if sys.platform == "linux":
+    # Availability: Linux >= 2.6.30
     AF_RDS: int
     PF_RDS: int
     SOL_RDS: int
+    # These are present in include/linux/rds.h but don't always show up
+    # here.
     RDS_CANCEL_SENT_TO: int
     RDS_CMSG_RDMA_ARGS: int
     RDS_CMSG_RDMA_DEST: int
     RDS_CMSG_RDMA_MAP: int
     RDS_CMSG_RDMA_STATUS: int
-    RDS_CMSG_RDMA_UPDATE: int
     RDS_CONG_MONITOR: int
     RDS_FREE_MR: int
     RDS_GET_MR: int
@@ -439,6 +499,10 @@ if sys.platform == "linux":
     RDS_RDMA_USE_ONCE: int
     RDS_RECVERR: int
 
+    # This is supported by CPython but doesn't seem to be a real thing.
+    # The closest existing constant in rds.h is RDS_CMSG_CONG_UPDATE
+    # RDS_CMSG_RDMA_UPDATE: int
+
 if sys.platform == "win32":
     SIO_RCVALL: int
     SIO_KEEPALIVE_VALS: int
@@ -476,6 +540,7 @@ if sys.platform == "linux":
     TIPC_ZONE_SCOPE: int
 
 if sys.platform == "linux":
+    # Availability: Linux >= 2.6.38
     AF_ALG: int
     SOL_ALG: int
     ALG_OP_DECRYPT: int
@@ -490,6 +555,7 @@ if sys.platform == "linux":
     ALG_SET_PUBKEY: int
 
 if sys.platform == "linux":
+    # Availability: Linux >= 4.8 (or maybe 3.9, CPython docs are confusing)
     AF_VSOCK: int
     IOCTL_VM_SOCKETS_GET_LOCAL_CID: int
     VMADDR_CID_ANY: int
@@ -498,81 +564,162 @@ if sys.platform == "linux":
     SO_VM_SOCKETS_BUFFER_MAX_SIZE: int
     SO_VM_SOCKETS_BUFFER_SIZE: int
     SO_VM_SOCKETS_BUFFER_MIN_SIZE: int
-    VM_SOCKETS_INVALID_VERSION: int
+    VM_SOCKETS_INVALID_VERSION: int  # undocumented
 
 if sys.platform != "win32" or sys.version_info >= (3, 9):
-    AF_LINK: int
+    # Documented as only available on BSD, macOS, but empirically sometimes
+    # available on Windows
+    if sys.platform != "linux":
+        AF_LINK: int
 
-# BDADDR_* and HCI_* listed with other bluetooth constants below
+has_ipv6: bool
 
-if sys.platform != "win32" and sys.platform != "darwin":
-    SO_DOMAIN: int
-    SO_PASSSEC: int
-    SO_PEERSEC: int
-    SO_PROTOCOL: int
-    TCP_CONGESTION: int
-    TCP_USER_TIMEOUT: int
+if sys.platform != "darwin" and sys.platform != "linux":
+    if sys.platform != "win32" or sys.version_info >= (3, 9):
+        BDADDR_ANY: str
+        BDADDR_LOCAL: str
 
-if sys.platform == "linux" and sys.version_info >= (3, 8):
-    AF_QIPCRTR: int
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+    HCI_FILTER: int  # not in NetBSD or DragonFlyBSD
+    HCI_TIME_STAMP: int  # not in FreeBSD, NetBSD, or DragonFlyBSD
+    HCI_DATA_DIR: int  # not in FreeBSD, NetBSD, or DragonFlyBSD
+
+if sys.platform == "linux":
+    AF_QIPCRTR: int  # Availability: Linux >= 4.7
+
+if sys.version_info >= (3, 11) and sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin":
+    # FreeBSD
+    SCM_CREDS2: int
+    LOCAL_CREDS: int
+    LOCAL_CREDS_PERSISTENT: int
+
+if sys.version_info >= (3, 11) and sys.platform == "linux":
+    SO_INCOMING_CPU: int  # Availability: Linux >= 3.9
+
+if sys.version_info >= (3, 12) and sys.platform == "win32":
+    # Availability: Windows
+    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
+
+if sys.version_info >= (3, 12):
+    if sys.platform != "win32":
+        # Availability: Linux, FreeBSD, macOS
+        ETHERTYPE_ARP: int
+        ETHERTYPE_IP: int
+        ETHERTYPE_IPV6: int
+        ETHERTYPE_VLAN: int
 
+# --------------------
 # Semi-documented constants
-# (Listed under "Socket families" in the docs, but not "Constants")
+# These are alluded to under the "Socket families" section in the docs
+# https://docs.python.org/3/library/socket.html#socket-families
+# --------------------
 
 if sys.platform == "linux":
     # Netlink is defined by Linux
     AF_NETLINK: int
-    NETLINK_ARPD: int
     NETLINK_CRYPTO: int
     NETLINK_DNRTMSG: int
     NETLINK_FIREWALL: int
     NETLINK_IP6_FW: int
     NETLINK_NFLOG: int
-    NETLINK_ROUTE6: int
     NETLINK_ROUTE: int
-    NETLINK_SKIP: int
-    NETLINK_TAPBASE: int
-    NETLINK_TCPDIAG: int
     NETLINK_USERSOCK: int
-    NETLINK_W1: int
     NETLINK_XFRM: int
+    # Technically still supported by CPython
+    # NETLINK_ARPD: int  # linux 2.0 to 2.6.12 (EOL August 2005)
+    # NETLINK_ROUTE6: int  # linux 2.2 to 2.6.12 (EOL August 2005)
+    # NETLINK_SKIP: int  # linux 2.0 to 2.6.12 (EOL August 2005)
+    # NETLINK_TAPBASE: int  # linux 2.2 to 2.6.12 (EOL August 2005)
+    # NETLINK_TCPDIAG: int  # linux 2.6.0 to 2.6.13 (EOL December 2005)
+    # NETLINK_W1: int  # linux 2.6.13 to 2.6.17 (EOL October 2006)
 
-if sys.platform != "darwin":
-    if sys.platform != "win32" or sys.version_info >= (3, 9):
+if sys.platform == "darwin":
+    PF_SYSTEM: int
+    SYSPROTO_CONTROL: int
+
+if sys.platform != "darwin" and sys.platform != "linux":
+    if sys.version_info >= (3, 9) or sys.platform != "win32":
         AF_BLUETOOTH: int
-        BDADDR_ANY: str
-        BDADDR_LOCAL: str
-        BTPROTO_RFCOMM: int
 
-if sys.platform != "win32" and sys.platform != "darwin":
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     # Linux and some BSD support is explicit in the docs
     # Windows and macOS do not support in practice
     BTPROTO_HCI: int
     BTPROTO_L2CAP: int
     BTPROTO_SCO: int  # not in FreeBSD
-    HCI_FILTER: int  # not in NetBSD or DragonFlyBSD
-    # not in FreeBSD, NetBSD, or DragonFlyBSD
-    HCI_TIME_STAMP: int
-    HCI_DATA_DIR: int
+if sys.platform != "darwin" and sys.platform != "linux":
+    if sys.version_info >= (3, 9) or sys.platform != "win32":
+        BTPROTO_RFCOMM: int
+
+if sys.version_info >= (3, 9) and sys.platform == "linux":
+    UDPLITE_RECV_CSCOV: int
+    UDPLITE_SEND_CSCOV: int
+
+# --------------------
+# Documented under socket.shutdown
+# --------------------
+SHUT_RD: int
+SHUT_RDWR: int
+SHUT_WR: int
+
+# --------------------
+# Undocumented constants
+# --------------------
+
+# Undocumented address families
+AF_APPLETALK: int
+AF_DECnet: int
+AF_IPX: int
+AF_SNA: int
+
+if sys.platform != "win32":
+    AF_ROUTE: int
 
 if sys.platform == "darwin":
-    # PF_SYSTEM is defined by macOS
-    PF_SYSTEM: int
-    SYSPROTO_CONTROL: int
+    AF_SYSTEM: int
 
-# ----- Exceptions -----
+if sys.platform != "darwin":
+    AF_IRDA: int
+
+if sys.platform != "win32" and sys.platform != "darwin":
+    AF_ASH: int
+    AF_ATMPVC: int
+    AF_ATMSVC: int
+    AF_AX25: int
+    AF_BRIDGE: int
+    AF_ECONET: int
+    AF_KEY: int
+    AF_LLC: int
+    AF_NETBEUI: int
+    AF_NETROM: int
+    AF_PPPOX: int
+    AF_ROSE: int
+    AF_SECURITY: int
+    AF_WANPIPE: int
+    AF_X25: int
 
-error = OSError
+# Miscellaneous undocumented
 
-class herror(error): ...
-class gaierror(error): ...
+if sys.platform != "win32" and sys.platform != "linux":
+    LOCAL_PEERCRED: int
 
-if sys.version_info >= (3, 10):
-    timeout = TimeoutError
-else:
-    class timeout(error): ...
+if sys.platform != "win32" and sys.platform != "darwin":
+    # Defined in linux socket.h, but this isn't always present for
+    # some reason.
+    IPX_TYPE: int
 
-# ----- Classes -----
+# ===== Classes =====
 
 class socket:
     @property
@@ -581,77 +728,81 @@ class socket:
     def type(self) -> int: ...
     @property
     def proto(self) -> int: ...
+    # F811: "Redefinition of unused `timeout`"
     @property
-    def timeout(self) -> float | None: ...
+    def timeout(self) -> float | None: ...  # noqa: F811
     if sys.platform == "win32":
-        def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: _FD | bytes | None = ...) -> None: ...
+        def __init__(
+            self, family: int = ..., type: int = ..., proto: int = ..., fileno: SupportsIndex | bytes | None = ...
+        ) -> None: ...
     else:
-        def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: _FD | None = ...) -> None: ...
+        def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: SupportsIndex | None = ...) -> None: ...
 
-    def bind(self, __address: _Address) -> None: ...
+    def bind(self, address: _Address, /) -> None: ...
     def close(self) -> None: ...
-    def connect(self, __address: _Address) -> None: ...
-    def connect_ex(self, __address: _Address) -> int: ...
+    def connect(self, address: _Address, /) -> None: ...
+    def connect_ex(self, address: _Address, /) -> int: ...
     def detach(self) -> int: ...
     def fileno(self) -> int: ...
     def getpeername(self) -> _RetAddress: ...
     def getsockname(self) -> _RetAddress: ...
     @overload
-    def getsockopt(self, __level: int, __optname: int) -> int: ...
+    def getsockopt(self, level: int, optname: int, /) -> int: ...
     @overload
-    def getsockopt(self, __level: int, __optname: int, __buflen: int) -> bytes: ...
+    def getsockopt(self, level: int, optname: int, buflen: int, /) -> bytes: ...
     def getblocking(self) -> bool: ...
     def gettimeout(self) -> float | None: ...
     if sys.platform == "win32":
-        def ioctl(self, __control: int, __option: int | tuple[int, int, int] | bool) -> None: ...
+        def ioctl(self, control: int, option: int | tuple[int, int, int] | bool, /) -> None: ...
 
-    def listen(self, __backlog: int = ...) -> None: ...
-    def recv(self, __bufsize: int, __flags: int = ...) -> bytes: ...
-    def recvfrom(self, __bufsize: int, __flags: int = ...) -> tuple[bytes, _RetAddress]: ...
+    def listen(self, backlog: int = ..., /) -> None: ...
+    def recv(self, bufsize: int, flags: int = ..., /) -> bytes: ...
+    def recvfrom(self, bufsize: int, flags: int = ..., /) -> tuple[bytes, _RetAddress]: ...
     if sys.platform != "win32":
-        def recvmsg(self, __bufsize: int, __ancbufsize: int = ..., __flags: int = ...) -> tuple[bytes, list[_CMSG], int, Any]: ...
+        def recvmsg(self, bufsize: int, ancbufsize: int = ..., flags: int = ..., /) -> tuple[bytes, list[_CMSG], int, Any]: ...
         def recvmsg_into(
-            self, __buffers: Iterable[WriteableBuffer], __ancbufsize: int = ..., __flags: int = ...
+            self, buffers: Iterable[WriteableBuffer], ancbufsize: int = ..., flags: int = ..., /
         ) -> tuple[int, list[_CMSG], int, Any]: ...
 
     def recvfrom_into(self, buffer: WriteableBuffer, nbytes: int = ..., flags: int = ...) -> tuple[int, _RetAddress]: ...
     def recv_into(self, buffer: WriteableBuffer, nbytes: int = ..., flags: int = ...) -> int: ...
-    def send(self, __data: ReadableBuffer, __flags: int = ...) -> int: ...
-    def sendall(self, __data: ReadableBuffer, __flags: int = ...) -> None: ...
+    def send(self, data: ReadableBuffer, flags: int = ..., /) -> int: ...
+    def sendall(self, data: ReadableBuffer, flags: int = ..., /) -> None: ...
     @overload
-    def sendto(self, __data: ReadableBuffer, __address: _Address) -> int: ...
+    def sendto(self, data: ReadableBuffer, address: _Address, /) -> int: ...
     @overload
-    def sendto(self, __data: ReadableBuffer, __flags: int, __address: _Address) -> int: ...
+    def sendto(self, data: ReadableBuffer, flags: int, address: _Address, /) -> int: ...
     if sys.platform != "win32":
         def sendmsg(
             self,
-            __buffers: Iterable[ReadableBuffer],
-            __ancdata: Iterable[_CMSGArg] = ...,
-            __flags: int = ...,
-            __address: _Address | None = ...,
+            buffers: Iterable[ReadableBuffer],
+            ancdata: Iterable[_CMSGArg] = ...,
+            flags: int = ...,
+            address: _Address | None = ...,
+            /,
         ) -> int: ...
     if sys.platform == "linux":
         def sendmsg_afalg(
             self, msg: Iterable[ReadableBuffer] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ...
         ) -> int: ...
 
-    def setblocking(self, __flag: bool) -> None: ...
-    def settimeout(self, __value: float | None) -> None: ...
+    def setblocking(self, flag: bool, /) -> None: ...
+    def settimeout(self, value: float | None, /) -> None: ...
     @overload
-    def setsockopt(self, __level: int, __optname: int, __value: int | ReadableBuffer) -> None: ...
+    def setsockopt(self, level: int, optname: int, value: int | ReadableBuffer, /) -> None: ...
     @overload
-    def setsockopt(self, __level: int, __optname: int, __value: None, __optlen: int) -> None: ...
+    def setsockopt(self, level: int, optname: int, value: None, optlen: int, /) -> None: ...
     if sys.platform == "win32":
-        def share(self, __process_id: int) -> bytes: ...
+        def share(self, process_id: int, /) -> bytes: ...
 
-    def shutdown(self, __how: int) -> None: ...
+    def shutdown(self, how: int, /) -> None: ...
 
 SocketType = socket
 
-# ----- Functions -----
+# ===== Functions =====
 
-def close(__fd: _FD) -> None: ...
-def dup(__fd: _FD) -> int: ...
+def close(fd: SupportsIndex, /) -> None: ...
+def dup(fd: SupportsIndex, /) -> int: ...
 
 # the 5th tuple item is an address
 def getaddrinfo(
@@ -661,34 +812,36 @@ def getaddrinfo(
     type: int = ...,
     proto: int = ...,
     flags: int = ...,
-) -> list[tuple[int, int, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
-def gethostbyname(__hostname: str) -> str: ...
-def gethostbyname_ex(__hostname: str) -> tuple[str, list[str], list[str]]: ...
+) -> list[tuple[int, int, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]: ...
+def gethostbyname(hostname: str, /) -> str: ...
+def gethostbyname_ex(hostname: str, /) -> tuple[str, list[str], list[str]]: ...
 def gethostname() -> str: ...
-def gethostbyaddr(__ip_address: str) -> tuple[str, list[str], list[str]]: ...
-def getnameinfo(__sockaddr: tuple[str, int] | tuple[str, int, int, int], __flags: int) -> tuple[str, str]: ...
-def getprotobyname(__protocolname: str) -> int: ...
-def getservbyname(__servicename: str, __protocolname: str = ...) -> int: ...
-def getservbyport(__port: int, __protocolname: str = ...) -> str: ...
-def ntohl(__x: int) -> int: ...  # param & ret val are 32-bit ints
-def ntohs(__x: int) -> int: ...  # param & ret val are 16-bit ints
-def htonl(__x: int) -> int: ...  # param & ret val are 32-bit ints
-def htons(__x: int) -> int: ...  # param & ret val are 16-bit ints
-def inet_aton(__ip_string: str) -> bytes: ...  # ret val 4 bytes in length
-def inet_ntoa(__packed_ip: ReadableBuffer) -> str: ...
-def inet_pton(__address_family: int, __ip_string: str) -> bytes: ...
-def inet_ntop(__address_family: int, __packed_ip: ReadableBuffer) -> str: ...
+def gethostbyaddr(ip_address: str, /) -> tuple[str, list[str], list[str]]: ...
+def getnameinfo(sockaddr: tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes], flags: int, /) -> tuple[str, str]: ...
+def getprotobyname(protocolname: str, /) -> int: ...
+def getservbyname(servicename: str, protocolname: str = ..., /) -> int: ...
+def getservbyport(port: int, protocolname: str = ..., /) -> str: ...
+def ntohl(x: int, /) -> int: ...  # param & ret val are 32-bit ints
+def ntohs(x: int, /) -> int: ...  # param & ret val are 16-bit ints
+def htonl(x: int, /) -> int: ...  # param & ret val are 32-bit ints
+def htons(x: int, /) -> int: ...  # param & ret val are 16-bit ints
+def inet_aton(ip_addr: str, /) -> bytes: ...  # ret val 4 bytes in length
+def inet_ntoa(packed_ip: ReadableBuffer, /) -> str: ...
+def inet_pton(address_family: int, ip_string: str, /) -> bytes: ...
+def inet_ntop(address_family: int, packed_ip: ReadableBuffer, /) -> str: ...
 def getdefaulttimeout() -> float | None: ...
-def setdefaulttimeout(__timeout: float | None) -> None: ...
+
+# F811: "Redefinition of unused `timeout`"
+def setdefaulttimeout(timeout: float | None, /) -> None: ...  # noqa: F811
 
 if sys.platform != "win32":
-    def sethostname(__name: str) -> None: ...
-    def CMSG_LEN(__length: int) -> int: ...
-    def CMSG_SPACE(__length: int) -> int: ...
-    def socketpair(__family: int = ..., __type: int = ..., __proto: int = ...) -> tuple[socket, socket]: ...
-
-# Windows added these in 3.8, but didn't have them before
-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: ...
+    def sethostname(name: str, /) -> None: ...
+    def CMSG_LEN(length: int, /) -> int: ...
+    def CMSG_SPACE(length: int, /) -> int: ...
+    def socketpair(family: int = ..., type: int = ..., proto: int = ..., /) -> tuple[socket, socket]: ...
+
+def if_nameindex() -> list[tuple[int, str]]: ...
+def if_nametoindex(oname: str, /) -> int: ...
+def if_indextoname(index: int, /) -> str: ...
+
+CAPI: CapsuleType
diff --git a/mypy/typeshed/stdlib/_sqlite3.pyi b/mypy/typeshed/stdlib/_sqlite3.pyi
new file mode 100644
index 000000000000..6f06542c1ba7
--- /dev/null
+++ b/mypy/typeshed/stdlib/_sqlite3.pyi
@@ -0,0 +1,312 @@
+import sys
+from _typeshed import ReadableBuffer, StrOrBytesPath
+from collections.abc import Callable
+from sqlite3 import (
+    Connection as Connection,
+    Cursor as Cursor,
+    DatabaseError as DatabaseError,
+    DataError as DataError,
+    Error as Error,
+    IntegrityError as IntegrityError,
+    InterfaceError as InterfaceError,
+    InternalError as InternalError,
+    NotSupportedError as NotSupportedError,
+    OperationalError as OperationalError,
+    PrepareProtocol as PrepareProtocol,
+    ProgrammingError as ProgrammingError,
+    Row as Row,
+    Warning as Warning,
+)
+from typing import Any, Final, Literal, TypeVar, overload
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 11):
+    from sqlite3 import Blob as Blob
+
+_T = TypeVar("_T")
+_ConnectionT = TypeVar("_ConnectionT", bound=Connection)
+_SqliteData: TypeAlias = str | ReadableBuffer | int | float | None
+_Adapter: TypeAlias = Callable[[_T], _SqliteData]
+_Converter: TypeAlias = Callable[[bytes], Any]
+
+PARSE_COLNAMES: Final[int]
+PARSE_DECLTYPES: Final[int]
+SQLITE_ALTER_TABLE: Final[int]
+SQLITE_ANALYZE: Final[int]
+SQLITE_ATTACH: Final[int]
+SQLITE_CREATE_INDEX: Final[int]
+SQLITE_CREATE_TABLE: Final[int]
+SQLITE_CREATE_TEMP_INDEX: Final[int]
+SQLITE_CREATE_TEMP_TABLE: Final[int]
+SQLITE_CREATE_TEMP_TRIGGER: Final[int]
+SQLITE_CREATE_TEMP_VIEW: Final[int]
+SQLITE_CREATE_TRIGGER: Final[int]
+SQLITE_CREATE_VIEW: Final[int]
+SQLITE_CREATE_VTABLE: Final[int]
+SQLITE_DELETE: Final[int]
+SQLITE_DENY: Final[int]
+SQLITE_DETACH: Final[int]
+SQLITE_DONE: Final[int]
+SQLITE_DROP_INDEX: Final[int]
+SQLITE_DROP_TABLE: Final[int]
+SQLITE_DROP_TEMP_INDEX: Final[int]
+SQLITE_DROP_TEMP_TABLE: Final[int]
+SQLITE_DROP_TEMP_TRIGGER: Final[int]
+SQLITE_DROP_TEMP_VIEW: Final[int]
+SQLITE_DROP_TRIGGER: Final[int]
+SQLITE_DROP_VIEW: Final[int]
+SQLITE_DROP_VTABLE: Final[int]
+SQLITE_FUNCTION: Final[int]
+SQLITE_IGNORE: Final[int]
+SQLITE_INSERT: Final[int]
+SQLITE_OK: Final[int]
+SQLITE_PRAGMA: Final[int]
+SQLITE_READ: Final[int]
+SQLITE_RECURSIVE: Final[int]
+SQLITE_REINDEX: Final[int]
+SQLITE_SAVEPOINT: Final[int]
+SQLITE_SELECT: Final[int]
+SQLITE_TRANSACTION: Final[int]
+SQLITE_UPDATE: Final[int]
+adapters: dict[tuple[type[Any], type[Any]], _Adapter[Any]]
+converters: dict[str, _Converter]
+sqlite_version: str
+
+if sys.version_info < (3, 12):
+    version: str
+
+if sys.version_info >= (3, 12):
+    LEGACY_TRANSACTION_CONTROL: Final[int]
+    SQLITE_DBCONFIG_DEFENSIVE: Final[int]
+    SQLITE_DBCONFIG_DQS_DDL: Final[int]
+    SQLITE_DBCONFIG_DQS_DML: Final[int]
+    SQLITE_DBCONFIG_ENABLE_FKEY: Final[int]
+    SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: Final[int]
+    SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: Final[int]
+    SQLITE_DBCONFIG_ENABLE_QPSG: Final[int]
+    SQLITE_DBCONFIG_ENABLE_TRIGGER: Final[int]
+    SQLITE_DBCONFIG_ENABLE_VIEW: Final[int]
+    SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: Final[int]
+    SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: Final[int]
+    SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: Final[int]
+    SQLITE_DBCONFIG_RESET_DATABASE: Final[int]
+    SQLITE_DBCONFIG_TRIGGER_EQP: Final[int]
+    SQLITE_DBCONFIG_TRUSTED_SCHEMA: Final[int]
+    SQLITE_DBCONFIG_WRITABLE_SCHEMA: Final[int]
+
+if sys.version_info >= (3, 11):
+    SQLITE_ABORT: Final[int]
+    SQLITE_ABORT_ROLLBACK: Final[int]
+    SQLITE_AUTH: Final[int]
+    SQLITE_AUTH_USER: Final[int]
+    SQLITE_BUSY: Final[int]
+    SQLITE_BUSY_RECOVERY: Final[int]
+    SQLITE_BUSY_SNAPSHOT: Final[int]
+    SQLITE_BUSY_TIMEOUT: Final[int]
+    SQLITE_CANTOPEN: Final[int]
+    SQLITE_CANTOPEN_CONVPATH: Final[int]
+    SQLITE_CANTOPEN_DIRTYWAL: Final[int]
+    SQLITE_CANTOPEN_FULLPATH: Final[int]
+    SQLITE_CANTOPEN_ISDIR: Final[int]
+    SQLITE_CANTOPEN_NOTEMPDIR: Final[int]
+    SQLITE_CANTOPEN_SYMLINK: Final[int]
+    SQLITE_CONSTRAINT: Final[int]
+    SQLITE_CONSTRAINT_CHECK: Final[int]
+    SQLITE_CONSTRAINT_COMMITHOOK: Final[int]
+    SQLITE_CONSTRAINT_FOREIGNKEY: Final[int]
+    SQLITE_CONSTRAINT_FUNCTION: Final[int]
+    SQLITE_CONSTRAINT_NOTNULL: Final[int]
+    SQLITE_CONSTRAINT_PINNED: Final[int]
+    SQLITE_CONSTRAINT_PRIMARYKEY: Final[int]
+    SQLITE_CONSTRAINT_ROWID: Final[int]
+    SQLITE_CONSTRAINT_TRIGGER: Final[int]
+    SQLITE_CONSTRAINT_UNIQUE: Final[int]
+    SQLITE_CONSTRAINT_VTAB: Final[int]
+    SQLITE_CORRUPT: Final[int]
+    SQLITE_CORRUPT_INDEX: Final[int]
+    SQLITE_CORRUPT_SEQUENCE: Final[int]
+    SQLITE_CORRUPT_VTAB: Final[int]
+    SQLITE_EMPTY: Final[int]
+    SQLITE_ERROR: Final[int]
+    SQLITE_ERROR_MISSING_COLLSEQ: Final[int]
+    SQLITE_ERROR_RETRY: Final[int]
+    SQLITE_ERROR_SNAPSHOT: Final[int]
+    SQLITE_FORMAT: Final[int]
+    SQLITE_FULL: Final[int]
+    SQLITE_INTERNAL: Final[int]
+    SQLITE_INTERRUPT: Final[int]
+    SQLITE_IOERR: Final[int]
+    SQLITE_IOERR_ACCESS: Final[int]
+    SQLITE_IOERR_AUTH: Final[int]
+    SQLITE_IOERR_BEGIN_ATOMIC: Final[int]
+    SQLITE_IOERR_BLOCKED: Final[int]
+    SQLITE_IOERR_CHECKRESERVEDLOCK: Final[int]
+    SQLITE_IOERR_CLOSE: Final[int]
+    SQLITE_IOERR_COMMIT_ATOMIC: Final[int]
+    SQLITE_IOERR_CONVPATH: Final[int]
+    SQLITE_IOERR_CORRUPTFS: Final[int]
+    SQLITE_IOERR_DATA: Final[int]
+    SQLITE_IOERR_DELETE: Final[int]
+    SQLITE_IOERR_DELETE_NOENT: Final[int]
+    SQLITE_IOERR_DIR_CLOSE: Final[int]
+    SQLITE_IOERR_DIR_FSYNC: Final[int]
+    SQLITE_IOERR_FSTAT: Final[int]
+    SQLITE_IOERR_FSYNC: Final[int]
+    SQLITE_IOERR_GETTEMPPATH: Final[int]
+    SQLITE_IOERR_LOCK: Final[int]
+    SQLITE_IOERR_MMAP: Final[int]
+    SQLITE_IOERR_NOMEM: Final[int]
+    SQLITE_IOERR_RDLOCK: Final[int]
+    SQLITE_IOERR_READ: Final[int]
+    SQLITE_IOERR_ROLLBACK_ATOMIC: Final[int]
+    SQLITE_IOERR_SEEK: Final[int]
+    SQLITE_IOERR_SHMLOCK: Final[int]
+    SQLITE_IOERR_SHMMAP: Final[int]
+    SQLITE_IOERR_SHMOPEN: Final[int]
+    SQLITE_IOERR_SHMSIZE: Final[int]
+    SQLITE_IOERR_SHORT_READ: Final[int]
+    SQLITE_IOERR_TRUNCATE: Final[int]
+    SQLITE_IOERR_UNLOCK: Final[int]
+    SQLITE_IOERR_VNODE: Final[int]
+    SQLITE_IOERR_WRITE: Final[int]
+    SQLITE_LIMIT_ATTACHED: Final[int]
+    SQLITE_LIMIT_COLUMN: Final[int]
+    SQLITE_LIMIT_COMPOUND_SELECT: Final[int]
+    SQLITE_LIMIT_EXPR_DEPTH: Final[int]
+    SQLITE_LIMIT_FUNCTION_ARG: Final[int]
+    SQLITE_LIMIT_LENGTH: Final[int]
+    SQLITE_LIMIT_LIKE_PATTERN_LENGTH: Final[int]
+    SQLITE_LIMIT_SQL_LENGTH: Final[int]
+    SQLITE_LIMIT_TRIGGER_DEPTH: Final[int]
+    SQLITE_LIMIT_VARIABLE_NUMBER: Final[int]
+    SQLITE_LIMIT_VDBE_OP: Final[int]
+    SQLITE_LIMIT_WORKER_THREADS: Final[int]
+    SQLITE_LOCKED: Final[int]
+    SQLITE_LOCKED_SHAREDCACHE: Final[int]
+    SQLITE_LOCKED_VTAB: Final[int]
+    SQLITE_MISMATCH: Final[int]
+    SQLITE_MISUSE: Final[int]
+    SQLITE_NOLFS: Final[int]
+    SQLITE_NOMEM: Final[int]
+    SQLITE_NOTADB: Final[int]
+    SQLITE_NOTFOUND: Final[int]
+    SQLITE_NOTICE: Final[int]
+    SQLITE_NOTICE_RECOVER_ROLLBACK: Final[int]
+    SQLITE_NOTICE_RECOVER_WAL: Final[int]
+    SQLITE_OK_LOAD_PERMANENTLY: Final[int]
+    SQLITE_OK_SYMLINK: Final[int]
+    SQLITE_PERM: Final[int]
+    SQLITE_PROTOCOL: Final[int]
+    SQLITE_RANGE: Final[int]
+    SQLITE_READONLY: Final[int]
+    SQLITE_READONLY_CANTINIT: Final[int]
+    SQLITE_READONLY_CANTLOCK: Final[int]
+    SQLITE_READONLY_DBMOVED: Final[int]
+    SQLITE_READONLY_DIRECTORY: Final[int]
+    SQLITE_READONLY_RECOVERY: Final[int]
+    SQLITE_READONLY_ROLLBACK: Final[int]
+    SQLITE_ROW: Final[int]
+    SQLITE_SCHEMA: Final[int]
+    SQLITE_TOOBIG: Final[int]
+    SQLITE_WARNING: Final[int]
+    SQLITE_WARNING_AUTOINDEX: Final[int]
+    threadsafety: Final[int]
+
+# Can take or return anything depending on what's in the registry.
+@overload
+def adapt(obj: Any, proto: Any, /) -> Any: ...
+@overload
+def adapt(obj: Any, proto: Any, alt: _T, /) -> Any | _T: ...
+def complete_statement(statement: str) -> bool: ...
+
+if sys.version_info >= (3, 12):
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        cached_statements: int = 128,
+        uri: bool = False,
+        *,
+        autocommit: bool = ...,
+    ) -> Connection: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float,
+        detect_types: int,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None,
+        check_same_thread: bool,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+        *,
+        autocommit: bool = ...,
+    ) -> _ConnectionT: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        *,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+        autocommit: bool = ...,
+    ) -> _ConnectionT: ...
+
+else:
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        cached_statements: int = 128,
+        uri: bool = False,
+    ) -> Connection: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float,
+        detect_types: int,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None,
+        check_same_thread: bool,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+    ) -> _ConnectionT: ...
+    @overload
+    def connect(
+        database: StrOrBytesPath,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None = "DEFERRED",
+        check_same_thread: bool = True,
+        *,
+        factory: type[_ConnectionT],
+        cached_statements: int = 128,
+        uri: bool = False,
+    ) -> _ConnectionT: ...
+
+def enable_callback_tracebacks(enable: bool, /) -> None: ...
+
+if sys.version_info < (3, 12):
+    # takes a pos-or-keyword argument because there is a C wrapper
+    def enable_shared_cache(do_enable: int) -> None: ...
+
+if sys.version_info >= (3, 10):
+    def register_adapter(type: type[_T], adapter: _Adapter[_T], /) -> None: ...
+    def register_converter(typename: str, converter: _Converter, /) -> None: ...
+
+else:
+    def register_adapter(type: type[_T], caster: _Adapter[_T], /) -> None: ...
+    def register_converter(name: str, converter: _Converter, /) -> None: ...
+
+if sys.version_info < (3, 10):
+    OptimizedUnicode = str
diff --git a/mypy/typeshed/stdlib/_ssl.pyi b/mypy/typeshed/stdlib/_ssl.pyi
new file mode 100644
index 000000000000..e39ab5eb6de8
--- /dev/null
+++ b/mypy/typeshed/stdlib/_ssl.pyi
@@ -0,0 +1,291 @@
+import sys
+from _typeshed import ReadableBuffer, StrOrBytesPath
+from collections.abc import Callable
+from ssl import (
+    SSLCertVerificationError as SSLCertVerificationError,
+    SSLContext,
+    SSLEOFError as SSLEOFError,
+    SSLError as SSLError,
+    SSLObject,
+    SSLSyscallError as SSLSyscallError,
+    SSLWantReadError as SSLWantReadError,
+    SSLWantWriteError as SSLWantWriteError,
+    SSLZeroReturnError as SSLZeroReturnError,
+)
+from typing import Any, ClassVar, Literal, TypedDict, final, overload
+from typing_extensions import NotRequired, Self, TypeAlias
+
+_PasswordType: TypeAlias = Callable[[], str | bytes | bytearray] | str | bytes | bytearray
+_PCTRTT: TypeAlias = tuple[tuple[str, str], ...]
+_PCTRTTT: TypeAlias = tuple[_PCTRTT, ...]
+_PeerCertRetDictType: TypeAlias = dict[str, str | _PCTRTTT | _PCTRTT]
+
+class _Cipher(TypedDict):
+    aead: bool
+    alg_bits: int
+    auth: str
+    description: str
+    digest: str | None
+    id: int
+    kea: str
+    name: str
+    protocol: str
+    strength_bits: int
+    symmetric: str
+
+class _CertInfo(TypedDict):
+    subject: tuple[tuple[tuple[str, str], ...], ...]
+    issuer: tuple[tuple[tuple[str, str], ...], ...]
+    version: int
+    serialNumber: str
+    notBefore: str
+    notAfter: str
+    subjectAltName: NotRequired[tuple[tuple[str, str], ...] | None]
+    OCSP: NotRequired[tuple[str, ...] | None]
+    caIssuers: NotRequired[tuple[str, ...] | None]
+    crlDistributionPoints: NotRequired[tuple[str, ...] | None]
+
+def RAND_add(string: str | ReadableBuffer, entropy: float, /) -> None: ...
+def RAND_bytes(n: int, /) -> bytes: ...
+
+if sys.version_info < (3, 12):
+    def RAND_pseudo_bytes(n: int, /) -> tuple[bytes, bool]: ...
+
+if sys.version_info < (3, 10):
+    def RAND_egd(path: str) -> None: ...
+
+def RAND_status() -> bool: ...
+def get_default_verify_paths() -> tuple[str, str, str, str]: ...
+
+if sys.platform == "win32":
+    _EnumRetType: TypeAlias = list[tuple[bytes, str, set[str] | bool]]
+    def enum_certificates(store_name: str) -> _EnumRetType: ...
+    def enum_crls(store_name: str) -> _EnumRetType: ...
+
+def txt2obj(txt: str, name: bool = False) -> tuple[int, str, str, str]: ...
+def nid2obj(nid: int, /) -> tuple[int, str, str, str]: ...
+
+class _SSLContext:
+    check_hostname: bool
+    keylog_filename: str | None
+    maximum_version: int
+    minimum_version: int
+    num_tickets: int
+    options: int
+    post_handshake_auth: bool
+    protocol: int
+    if sys.version_info >= (3, 10):
+        security_level: int
+    sni_callback: Callable[[SSLObject, str, SSLContext], None | int] | None
+    verify_flags: int
+    verify_mode: int
+    def __new__(cls, protocol: int, /) -> Self: ...
+    def cert_store_stats(self) -> dict[str, int]: ...
+    @overload
+    def get_ca_certs(self, binary_form: Literal[False] = False) -> list[_PeerCertRetDictType]: ...
+    @overload
+    def get_ca_certs(self, binary_form: Literal[True]) -> list[bytes]: ...
+    @overload
+    def get_ca_certs(self, binary_form: bool = False) -> Any: ...
+    def get_ciphers(self) -> list[_Cipher]: ...
+    def load_cert_chain(
+        self, certfile: StrOrBytesPath, keyfile: StrOrBytesPath | None = None, password: _PasswordType | None = None
+    ) -> None: ...
+    def load_dh_params(self, path: str, /) -> None: ...
+    def load_verify_locations(
+        self,
+        cafile: StrOrBytesPath | None = None,
+        capath: StrOrBytesPath | None = None,
+        cadata: str | ReadableBuffer | None = None,
+    ) -> None: ...
+    def session_stats(self) -> dict[str, int]: ...
+    def set_ciphers(self, cipherlist: str, /) -> None: ...
+    def set_default_verify_paths(self) -> None: ...
+    def set_ecdh_curve(self, name: str, /) -> None: ...
+    if sys.version_info >= (3, 13):
+        def set_psk_client_callback(self, callback: Callable[[str | None], tuple[str | None, bytes]] | None) -> None: ...
+        def set_psk_server_callback(
+            self, callback: Callable[[str | None], bytes] | None, identity_hint: str | None = None
+        ) -> None: ...
+
+@final
+class MemoryBIO:
+    eof: bool
+    pending: int
+    def __new__(self) -> Self: ...
+    def read(self, size: int = -1, /) -> bytes: ...
+    def write(self, b: ReadableBuffer, /) -> int: ...
+    def write_eof(self) -> None: ...
+
+@final
+class SSLSession:
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    @property
+    def has_ticket(self) -> bool: ...
+    @property
+    def id(self) -> bytes: ...
+    @property
+    def ticket_lifetime_hint(self) -> int: ...
+    @property
+    def time(self) -> int: ...
+    @property
+    def timeout(self) -> int: ...
+
+# _ssl.Certificate is weird: it can't be instantiated or subclassed.
+# Instances can only be created via methods of the private _ssl._SSLSocket class,
+# for which the relevant method signatures are:
+#
+# class _SSLSocket:
+#     def get_unverified_chain(self) -> list[Certificate] | None: ...
+#     def get_verified_chain(self) -> list[Certificate] | None: ...
+#
+# You can find a _ssl._SSLSocket object as the _sslobj attribute of a ssl.SSLSocket object
+
+if sys.version_info >= (3, 10):
+    @final
+    class Certificate:
+        def get_info(self) -> _CertInfo: ...
+        @overload
+        def public_bytes(self) -> str: ...
+        @overload
+        def public_bytes(self, format: Literal[1] = 1, /) -> str: ...  # ENCODING_PEM
+        @overload
+        def public_bytes(self, format: Literal[2], /) -> bytes: ...  # ENCODING_DER
+        @overload
+        def public_bytes(self, format: int, /) -> str | bytes: ...
+
+if sys.version_info < (3, 12):
+    err_codes_to_names: dict[tuple[int, int], str]
+    err_names_to_codes: dict[str, tuple[int, int]]
+    lib_codes_to_names: dict[int, str]
+
+_DEFAULT_CIPHERS: str
+
+# SSL error numbers
+SSL_ERROR_ZERO_RETURN: int
+SSL_ERROR_WANT_READ: int
+SSL_ERROR_WANT_WRITE: int
+SSL_ERROR_WANT_X509_LOOKUP: int
+SSL_ERROR_SYSCALL: int
+SSL_ERROR_SSL: int
+SSL_ERROR_WANT_CONNECT: int
+SSL_ERROR_EOF: int
+SSL_ERROR_INVALID_ERROR_CODE: int
+
+# verify modes
+CERT_NONE: int
+CERT_OPTIONAL: int
+CERT_REQUIRED: int
+
+# verify flags
+VERIFY_DEFAULT: int
+VERIFY_CRL_CHECK_LEAF: int
+VERIFY_CRL_CHECK_CHAIN: int
+VERIFY_X509_STRICT: int
+VERIFY_X509_TRUSTED_FIRST: int
+if sys.version_info >= (3, 10):
+    VERIFY_ALLOW_PROXY_CERTS: int
+    VERIFY_X509_PARTIAL_CHAIN: int
+
+# alert descriptions
+ALERT_DESCRIPTION_CLOSE_NOTIFY: int
+ALERT_DESCRIPTION_UNEXPECTED_MESSAGE: int
+ALERT_DESCRIPTION_BAD_RECORD_MAC: int
+ALERT_DESCRIPTION_RECORD_OVERFLOW: int
+ALERT_DESCRIPTION_DECOMPRESSION_FAILURE: int
+ALERT_DESCRIPTION_HANDSHAKE_FAILURE: int
+ALERT_DESCRIPTION_BAD_CERTIFICATE: int
+ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE: int
+ALERT_DESCRIPTION_CERTIFICATE_REVOKED: int
+ALERT_DESCRIPTION_CERTIFICATE_EXPIRED: int
+ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN: int
+ALERT_DESCRIPTION_ILLEGAL_PARAMETER: int
+ALERT_DESCRIPTION_UNKNOWN_CA: int
+ALERT_DESCRIPTION_ACCESS_DENIED: int
+ALERT_DESCRIPTION_DECODE_ERROR: int
+ALERT_DESCRIPTION_DECRYPT_ERROR: int
+ALERT_DESCRIPTION_PROTOCOL_VERSION: int
+ALERT_DESCRIPTION_INSUFFICIENT_SECURITY: int
+ALERT_DESCRIPTION_INTERNAL_ERROR: int
+ALERT_DESCRIPTION_USER_CANCELLED: int
+ALERT_DESCRIPTION_NO_RENEGOTIATION: int
+ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION: int
+ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE: int
+ALERT_DESCRIPTION_UNRECOGNIZED_NAME: int
+ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE: int
+ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE: int
+ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY: int
+
+# protocol versions
+PROTOCOL_SSLv23: int
+PROTOCOL_TLS: int
+PROTOCOL_TLS_CLIENT: int
+PROTOCOL_TLS_SERVER: int
+PROTOCOL_TLSv1: int
+PROTOCOL_TLSv1_1: int
+PROTOCOL_TLSv1_2: int
+
+# protocol options
+OP_ALL: int
+OP_NO_SSLv2: int
+OP_NO_SSLv3: int
+OP_NO_TLSv1: int
+OP_NO_TLSv1_1: int
+OP_NO_TLSv1_2: int
+OP_NO_TLSv1_3: int
+OP_CIPHER_SERVER_PREFERENCE: int
+OP_SINGLE_DH_USE: int
+OP_NO_TICKET: int
+OP_SINGLE_ECDH_USE: int
+OP_NO_COMPRESSION: int
+OP_ENABLE_MIDDLEBOX_COMPAT: int
+OP_NO_RENEGOTIATION: int
+if sys.version_info >= (3, 11) or sys.platform == "linux":
+    OP_IGNORE_UNEXPECTED_EOF: int
+if sys.version_info >= (3, 12):
+    OP_LEGACY_SERVER_CONNECT: int
+    OP_ENABLE_KTLS: int
+
+# host flags
+HOSTFLAG_ALWAYS_CHECK_SUBJECT: int
+HOSTFLAG_NEVER_CHECK_SUBJECT: int
+HOSTFLAG_NO_WILDCARDS: int
+HOSTFLAG_NO_PARTIAL_WILDCARDS: int
+HOSTFLAG_MULTI_LABEL_WILDCARDS: int
+HOSTFLAG_SINGLE_LABEL_SUBDOMAINS: int
+
+if sys.version_info >= (3, 10):
+    # certificate file types
+    # Typed as Literal so the overload on Certificate.public_bytes can work properly.
+    ENCODING_PEM: Literal[1]
+    ENCODING_DER: Literal[2]
+
+# protocol versions
+PROTO_MINIMUM_SUPPORTED: int
+PROTO_MAXIMUM_SUPPORTED: int
+PROTO_SSLv3: int
+PROTO_TLSv1: int
+PROTO_TLSv1_1: int
+PROTO_TLSv1_2: int
+PROTO_TLSv1_3: int
+
+# feature support
+HAS_SNI: bool
+HAS_TLS_UNIQUE: bool
+HAS_ECDH: bool
+HAS_NPN: bool
+if sys.version_info >= (3, 13):
+    HAS_PSK: bool
+HAS_ALPN: bool
+HAS_SSLv2: bool
+HAS_SSLv3: bool
+HAS_TLSv1: bool
+HAS_TLSv1_1: bool
+HAS_TLSv1_2: bool
+HAS_TLSv1_3: bool
+
+# version info
+OPENSSL_VERSION_NUMBER: int
+OPENSSL_VERSION_INFO: tuple[int, int, int, int, int]
+OPENSSL_VERSION: str
+_OPENSSL_API_VERSION: tuple[int, int, int, int, int]
diff --git a/mypy/typeshed/stdlib/_stat.pyi b/mypy/typeshed/stdlib/_stat.pyi
index 83d832e4dd8e..7129a282b574 100644
--- a/mypy/typeshed/stdlib/_stat.pyi
+++ b/mypy/typeshed/stdlib/_stat.pyi
@@ -1,103 +1,119 @@
 import sys
-from typing_extensions import Literal
-
-SF_APPEND: Literal[0x00040000]
-SF_ARCHIVED: Literal[0x00010000]
-SF_IMMUTABLE: Literal[0x00020000]
-SF_NOUNLINK: Literal[0x00100000]
-SF_SNAPSHOT: Literal[0x00200000]
-
-ST_MODE: Literal[0]
-ST_INO: Literal[1]
-ST_DEV: Literal[2]
-ST_NLINK: Literal[3]
-ST_UID: Literal[4]
-ST_GID: Literal[5]
-ST_SIZE: Literal[6]
-ST_ATIME: Literal[7]
-ST_MTIME: Literal[8]
-ST_CTIME: Literal[9]
-
-S_IFIFO: Literal[0o010000]
-S_IFLNK: Literal[0o120000]
-S_IFREG: Literal[0o100000]
-S_IFSOCK: Literal[0o140000]
-S_IFBLK: Literal[0o060000]
-S_IFCHR: Literal[0o020000]
-S_IFDIR: Literal[0o040000]
+from typing import Final
+
+SF_APPEND: Final = 0x00040000
+SF_ARCHIVED: Final = 0x00010000
+SF_IMMUTABLE: Final = 0x00020000
+SF_NOUNLINK: Final = 0x00100000
+SF_SNAPSHOT: Final = 0x00200000
+
+ST_MODE: Final = 0
+ST_INO: Final = 1
+ST_DEV: Final = 2
+ST_NLINK: Final = 3
+ST_UID: Final = 4
+ST_GID: Final = 5
+ST_SIZE: Final = 6
+ST_ATIME: Final = 7
+ST_MTIME: Final = 8
+ST_CTIME: Final = 9
+
+S_IFIFO: Final = 0o010000
+S_IFLNK: Final = 0o120000
+S_IFREG: Final = 0o100000
+S_IFSOCK: Final = 0o140000
+S_IFBLK: Final = 0o060000
+S_IFCHR: Final = 0o020000
+S_IFDIR: Final = 0o040000
 
 # These are 0 on systems that don't support the specific kind of file.
 # Example: Linux doesn't support door files, so S_IFDOOR is 0 on linux.
-S_IFDOOR: int
-S_IFPORT: int
-S_IFWHT: int
-
-S_ISUID: Literal[0o4000]
-S_ISGID: Literal[0o2000]
-S_ISVTX: Literal[0o1000]
-
-S_IRWXU: Literal[0o0700]
-S_IRUSR: Literal[0o0400]
-S_IWUSR: Literal[0o0200]
-S_IXUSR: Literal[0o0100]
-
-S_IRWXG: Literal[0o0070]
-S_IRGRP: Literal[0o0040]
-S_IWGRP: Literal[0o0020]
-S_IXGRP: Literal[0o0010]
-
-S_IRWXO: Literal[0o0007]
-S_IROTH: Literal[0o0004]
-S_IWOTH: Literal[0o0002]
-S_IXOTH: Literal[0o0001]
-
-S_ENFMT: Literal[0o2000]
-S_IREAD: Literal[0o0400]
-S_IWRITE: Literal[0o0200]
-S_IEXEC: Literal[0o0100]
-
-UF_APPEND: Literal[0x00000004]
-UF_COMPRESSED: Literal[0x00000020]  # OS X 10.6+ only
-UF_HIDDEN: Literal[0x00008000]  # OX X 10.5+ only
-UF_IMMUTABLE: Literal[0x00000002]
-UF_NODUMP: Literal[0x00000001]
-UF_NOUNLINK: Literal[0x00000010]
-UF_OPAQUE: Literal[0x00000008]
-
-def S_IMODE(mode: int) -> int: ...
-def S_IFMT(mode: int) -> int: ...
-def S_ISBLK(mode: int) -> bool: ...
-def S_ISCHR(mode: int) -> bool: ...
-def S_ISDIR(mode: int) -> bool: ...
-def S_ISDOOR(mode: int) -> bool: ...
-def S_ISFIFO(mode: int) -> bool: ...
-def S_ISLNK(mode: int) -> bool: ...
-def S_ISPORT(mode: int) -> bool: ...
-def S_ISREG(mode: int) -> bool: ...
-def S_ISSOCK(mode: int) -> bool: ...
-def S_ISWHT(mode: int) -> bool: ...
-def filemode(mode: int) -> str: ...
-
-if sys.platform == "win32" and sys.version_info >= (3, 8):
-    IO_REPARSE_TAG_SYMLINK: int
-    IO_REPARSE_TAG_MOUNT_POINT: int
-    IO_REPARSE_TAG_APPEXECLINK: int
+S_IFDOOR: Final[int]
+S_IFPORT: Final[int]
+S_IFWHT: Final[int]
+
+S_ISUID: Final = 0o4000
+S_ISGID: Final = 0o2000
+S_ISVTX: Final = 0o1000
+
+S_IRWXU: Final = 0o0700
+S_IRUSR: Final = 0o0400
+S_IWUSR: Final = 0o0200
+S_IXUSR: Final = 0o0100
+
+S_IRWXG: Final = 0o0070
+S_IRGRP: Final = 0o0040
+S_IWGRP: Final = 0o0020
+S_IXGRP: Final = 0o0010
+
+S_IRWXO: Final = 0o0007
+S_IROTH: Final = 0o0004
+S_IWOTH: Final = 0o0002
+S_IXOTH: Final = 0o0001
+
+S_ENFMT: Final = 0o2000
+S_IREAD: Final = 0o0400
+S_IWRITE: Final = 0o0200
+S_IEXEC: Final = 0o0100
+
+UF_APPEND: Final = 0x00000004
+UF_COMPRESSED: Final = 0x00000020  # OS X 10.6+ only
+UF_HIDDEN: Final = 0x00008000  # OX X 10.5+ only
+UF_IMMUTABLE: Final = 0x00000002
+UF_NODUMP: Final = 0x00000001
+UF_NOUNLINK: Final = 0x00000010
+UF_OPAQUE: Final = 0x00000008
+
+def S_IMODE(mode: int, /) -> int: ...
+def S_IFMT(mode: int, /) -> int: ...
+def S_ISBLK(mode: int, /) -> bool: ...
+def S_ISCHR(mode: int, /) -> bool: ...
+def S_ISDIR(mode: int, /) -> bool: ...
+def S_ISDOOR(mode: int, /) -> bool: ...
+def S_ISFIFO(mode: int, /) -> bool: ...
+def S_ISLNK(mode: int, /) -> bool: ...
+def S_ISPORT(mode: int, /) -> bool: ...
+def S_ISREG(mode: int, /) -> bool: ...
+def S_ISSOCK(mode: int, /) -> bool: ...
+def S_ISWHT(mode: int, /) -> bool: ...
+def filemode(mode: int, /) -> str: ...
+
+if sys.platform == "win32":
+    IO_REPARSE_TAG_SYMLINK: Final = 0xA000000C
+    IO_REPARSE_TAG_MOUNT_POINT: Final = 0xA0000003
+    IO_REPARSE_TAG_APPEXECLINK: Final = 0x8000001B
 
 if sys.platform == "win32":
-    FILE_ATTRIBUTE_ARCHIVE: Literal[32]
-    FILE_ATTRIBUTE_COMPRESSED: Literal[2048]
-    FILE_ATTRIBUTE_DEVICE: Literal[64]
-    FILE_ATTRIBUTE_DIRECTORY: Literal[16]
-    FILE_ATTRIBUTE_ENCRYPTED: Literal[16384]
-    FILE_ATTRIBUTE_HIDDEN: Literal[2]
-    FILE_ATTRIBUTE_INTEGRITY_STREAM: Literal[32768]
-    FILE_ATTRIBUTE_NORMAL: Literal[128]
-    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: Literal[8192]
-    FILE_ATTRIBUTE_NO_SCRUB_DATA: Literal[131072]
-    FILE_ATTRIBUTE_OFFLINE: Literal[4096]
-    FILE_ATTRIBUTE_READONLY: Literal[1]
-    FILE_ATTRIBUTE_REPARSE_POINT: Literal[1024]
-    FILE_ATTRIBUTE_SPARSE_FILE: Literal[512]
-    FILE_ATTRIBUTE_SYSTEM: Literal[4]
-    FILE_ATTRIBUTE_TEMPORARY: Literal[256]
-    FILE_ATTRIBUTE_VIRTUAL: Literal[65536]
+    FILE_ATTRIBUTE_ARCHIVE: Final = 32
+    FILE_ATTRIBUTE_COMPRESSED: Final = 2048
+    FILE_ATTRIBUTE_DEVICE: Final = 64
+    FILE_ATTRIBUTE_DIRECTORY: Final = 16
+    FILE_ATTRIBUTE_ENCRYPTED: Final = 16384
+    FILE_ATTRIBUTE_HIDDEN: Final = 2
+    FILE_ATTRIBUTE_INTEGRITY_STREAM: Final = 32768
+    FILE_ATTRIBUTE_NORMAL: Final = 128
+    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: Final = 8192
+    FILE_ATTRIBUTE_NO_SCRUB_DATA: Final = 131072
+    FILE_ATTRIBUTE_OFFLINE: Final = 4096
+    FILE_ATTRIBUTE_READONLY: Final = 1
+    FILE_ATTRIBUTE_REPARSE_POINT: Final = 1024
+    FILE_ATTRIBUTE_SPARSE_FILE: Final = 512
+    FILE_ATTRIBUTE_SYSTEM: Final = 4
+    FILE_ATTRIBUTE_TEMPORARY: Final = 256
+    FILE_ATTRIBUTE_VIRTUAL: Final = 65536
+
+if sys.version_info >= (3, 13):
+    # Varies by platform.
+    SF_SETTABLE: Final[int]
+    # https://github.com/python/cpython/issues/114081#issuecomment-2119017790
+    # SF_RESTRICTED: Literal[0x00080000]
+    SF_FIRMLINK: Final = 0x00800000
+    SF_DATALESS: Final = 0x40000000
+
+    if sys.platform == "darwin":
+        SF_SUPPORTED: Final = 0x9F0000
+        SF_SYNTHETIC: Final = 0xC0000000
+
+    UF_TRACKED: Final = 0x00000040
+    UF_DATAVAULT: Final = 0x00000080
+    UF_SETTABLE: Final = 0x0000FFFF
diff --git a/mypy/typeshed/stdlib/_struct.pyi b/mypy/typeshed/stdlib/_struct.pyi
new file mode 100644
index 000000000000..662170e869f3
--- /dev/null
+++ b/mypy/typeshed/stdlib/_struct.pyi
@@ -0,0 +1,22 @@
+from _typeshed import ReadableBuffer, WriteableBuffer
+from collections.abc import Iterator
+from typing import Any
+
+def pack(fmt: str | bytes, /, *v: Any) -> bytes: ...
+def pack_into(fmt: str | bytes, buffer: WriteableBuffer, offset: int, /, *v: Any) -> None: ...
+def unpack(format: str | bytes, buffer: ReadableBuffer, /) -> tuple[Any, ...]: ...
+def unpack_from(format: str | bytes, /, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]: ...
+def iter_unpack(format: str | bytes, buffer: ReadableBuffer, /) -> Iterator[tuple[Any, ...]]: ...
+def calcsize(format: str | bytes, /) -> int: ...
+
+class Struct:
+    @property
+    def format(self) -> str: ...
+    @property
+    def size(self) -> int: ...
+    def __init__(self, format: str | bytes) -> None: ...
+    def pack(self, *v: Any) -> bytes: ...
+    def pack_into(self, buffer: WriteableBuffer, offset: int, *v: Any) -> None: ...
+    def unpack(self, buffer: ReadableBuffer, /) -> tuple[Any, ...]: ...
+    def unpack_from(self, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]: ...
+    def iter_unpack(self, buffer: ReadableBuffer, /) -> Iterator[tuple[Any, ...]]: ...
diff --git a/mypy/typeshed/stdlib/_thread.pyi b/mypy/typeshed/stdlib/_thread.pyi
index 152362edcaea..378ac2423757 100644
--- a/mypy/typeshed/stdlib/_thread.pyi
+++ b/mypy/typeshed/stdlib/_thread.pyi
@@ -1,45 +1,111 @@
+import signal
 import sys
 from _typeshed import structseq
 from collections.abc import Callable
 from threading import Thread
 from types import TracebackType
-from typing import Any, NoReturn
-from typing_extensions import Final, final
+from typing import Any, Final, NoReturn, final, overload
+from typing_extensions import TypeVarTuple, Unpack
+
+_Ts = TypeVarTuple("_Ts")
 
 error = RuntimeError
 
 def _count() -> int: ...
 @final
-class LockType:
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+class RLock:
+    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
     def release(self) -> None: ...
-    def locked(self) -> bool: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
-
-def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any] = ...) -> int: ...
-def interrupt_main() -> None: ...
+    __enter__ = acquire
+    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+
+if sys.version_info >= (3, 13):
+    @final
+    class _ThreadHandle:
+        ident: int
+
+        def join(self, timeout: float | None = None, /) -> None: ...
+        def is_done(self) -> bool: ...
+        def _set_done(self) -> None: ...
+
+    def start_joinable_thread(
+        function: Callable[[], object], handle: _ThreadHandle | None = None, daemon: bool = True
+    ) -> _ThreadHandle: ...
+    @final
+    class lock:
+        def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        def release(self) -> None: ...
+        def locked(self) -> bool: ...
+        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        def release_lock(self) -> None: ...
+        def locked_lock(self) -> bool: ...
+        def __enter__(self) -> bool: ...
+        def __exit__(
+            self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+        ) -> None: ...
+
+    LockType = lock
+else:
+    @final
+    class LockType:
+        def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        def release(self) -> None: ...
+        def locked(self) -> bool: ...
+        def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+        def release_lock(self) -> None: ...
+        def locked_lock(self) -> bool: ...
+        def __enter__(self) -> bool: ...
+        def __exit__(
+            self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+        ) -> None: ...
+
+@overload
+def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int: ...
+@overload
+def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
+
+# Obsolete synonym for start_new_thread()
+@overload
+def start_new(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int: ...
+@overload
+def start_new(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
+
+if sys.version_info >= (3, 10):
+    def interrupt_main(signum: signal.Signals = ..., /) -> None: ...
+
+else:
+    def interrupt_main() -> None: ...
+
 def exit() -> NoReturn: ...
+def exit_thread() -> NoReturn: ...  # Obsolete synonym for exit()
 def allocate_lock() -> LockType: ...
+def allocate() -> LockType: ...  # Obsolete synonym for allocate_lock()
 def get_ident() -> int: ...
-def stack_size(size: int = ...) -> int: ...
+def stack_size(size: int = 0, /) -> int: ...
 
 TIMEOUT_MAX: float
 
-if sys.version_info >= (3, 8):
-    def get_native_id() -> int: ...  # only available on some platforms
-    @final
-    class _ExceptHookArgs(structseq[Any], tuple[type[BaseException], BaseException | None, TracebackType | None, Thread | None]):
-        if sys.version_info >= (3, 10):
-            __match_args__: Final = ("exc_type", "exc_value", "exc_traceback", "thread")
-        @property
-        def exc_type(self) -> type[BaseException]: ...
-        @property
-        def exc_value(self) -> BaseException | None: ...
-        @property
-        def exc_traceback(self) -> TracebackType | None: ...
-        @property
-        def thread(self) -> Thread | None: ...
-    _excepthook: Callable[[_ExceptHookArgs], Any]
+def get_native_id() -> int: ...  # only available on some platforms
+@final
+class _ExceptHookArgs(structseq[Any], tuple[type[BaseException], BaseException | None, TracebackType | None, Thread | None]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("exc_type", "exc_value", "exc_traceback", "thread")
+
+    @property
+    def exc_type(self) -> type[BaseException]: ...
+    @property
+    def exc_value(self) -> BaseException | None: ...
+    @property
+    def exc_traceback(self) -> TracebackType | None: ...
+    @property
+    def thread(self) -> Thread | None: ...
+
+_excepthook: Callable[[_ExceptHookArgs], Any]
+
+if sys.version_info >= (3, 12):
+    def daemon_threads_allowed() -> bool: ...
+
+class _local:
+    def __getattribute__(self, name: str, /) -> Any: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
+    def __delattr__(self, name: str, /) -> None: ...
diff --git a/mypy/typeshed/stdlib/_threading_local.pyi b/mypy/typeshed/stdlib/_threading_local.pyi
index 98683dabcef8..07a825f0d816 100644
--- a/mypy/typeshed/stdlib/_threading_local.pyi
+++ b/mypy/typeshed/stdlib/_threading_local.pyi
@@ -1,5 +1,6 @@
+from threading import RLock
 from typing import Any
-from typing_extensions import TypeAlias
+from typing_extensions import Self, TypeAlias
 from weakref import ReferenceType
 
 __all__ = ["local"]
@@ -8,10 +9,14 @@ _LocalDict: TypeAlias = dict[Any, Any]
 class _localimpl:
     key: str
     dicts: dict[int, tuple[ReferenceType[Any], _LocalDict]]
+    # Keep localargs in sync with the *args, **kwargs annotation on local.__new__
+    localargs: tuple[list[Any], dict[str, Any]]
+    locallock: RLock
     def get_dict(self) -> _LocalDict: ...
     def create_dict(self) -> _LocalDict: ...
 
 class local:
+    def __new__(cls, /, *args: Any, **kw: Any) -> Self: ...
     def __getattribute__(self, name: str) -> Any: ...
     def __setattr__(self, name: str, value: Any) -> None: ...
     def __delattr__(self, name: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/_tkinter.pyi b/mypy/typeshed/stdlib/_tkinter.pyi
index 89610e21d9e7..4206a2114f95 100644
--- a/mypy/typeshed/stdlib/_tkinter.pyi
+++ b/mypy/typeshed/stdlib/_tkinter.pyi
@@ -1,6 +1,7 @@
 import sys
-from typing import Any, ClassVar
-from typing_extensions import Literal, final
+from collections.abc import Callable
+from typing import Any, ClassVar, Final, final
+from typing_extensions import TypeAlias
 
 # _tkinter is meant to be only used internally by tkinter, but some tkinter
 # functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl
@@ -22,15 +23,17 @@ class Tcl_Obj:
     @property
     def typename(self) -> str: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __eq__(self, __value): ...
-    def __ge__(self, __value): ...
-    def __gt__(self, __value): ...
-    def __le__(self, __value): ...
-    def __lt__(self, __value): ...
-    def __ne__(self, __value): ...
+    def __eq__(self, value, /): ...
+    def __ge__(self, value, /): ...
+    def __gt__(self, value, /): ...
+    def __le__(self, value, /): ...
+    def __lt__(self, value, /): ...
+    def __ne__(self, value, /): ...
 
 class TclError(Exception): ...
 
+_TkinterTraceFunc: TypeAlias = Callable[[tuple[str, ...]], object]
+
 # This class allows running Tcl code. Tkinter uses it internally a lot, and
 # it's often handy to drop a piece of Tcl code into a tkinter program. Example:
 #
@@ -51,85 +54,90 @@ class TclError(Exception): ...
 @final
 class TkappType:
     # Please keep in sync with tkinter.Tk
-    def adderrorinfo(self, __msg): ...
-    def call(self, __command: Any, *args: Any) -> Any: ...
-    def createcommand(self, __name, __func): ...
+    def adderrorinfo(self, msg, /): ...
+    def call(self, command: Any, /, *args: Any) -> Any: ...
+    def createcommand(self, name, func, /): ...
     if sys.platform != "win32":
-        def createfilehandler(self, __file, __mask, __func): ...
-        def deletefilehandler(self, __file): ...
+        def createfilehandler(self, file, mask, func, /): ...
+        def deletefilehandler(self, file, /): ...
 
-    def createtimerhandler(self, __milliseconds, __func): ...
-    def deletecommand(self, __name): ...
-    def dooneevent(self, __flags: int = 0): ...
-    def eval(self, __script: str) -> str: ...
-    def evalfile(self, __fileName): ...
-    def exprboolean(self, __s): ...
-    def exprdouble(self, __s): ...
-    def exprlong(self, __s): ...
-    def exprstring(self, __s): ...
-    def getboolean(self, __arg): ...
-    def getdouble(self, __arg): ...
-    def getint(self, __arg): ...
+    def createtimerhandler(self, milliseconds, func, /): ...
+    def deletecommand(self, name, /): ...
+    def dooneevent(self, flags: int = 0, /): ...
+    def eval(self, script: str, /) -> str: ...
+    def evalfile(self, fileName, /): ...
+    def exprboolean(self, s, /): ...
+    def exprdouble(self, s, /): ...
+    def exprlong(self, s, /): ...
+    def exprstring(self, s, /): ...
+    def getboolean(self, arg, /): ...
+    def getdouble(self, arg, /): ...
+    def getint(self, arg, /): ...
     def getvar(self, *args, **kwargs): ...
     def globalgetvar(self, *args, **kwargs): ...
     def globalsetvar(self, *args, **kwargs): ...
     def globalunsetvar(self, *args, **kwargs): ...
     def interpaddr(self): ...
     def loadtk(self) -> None: ...
-    def mainloop(self, __threshold: int = 0): ...
+    def mainloop(self, threshold: int = 0, /): ...
     def quit(self): ...
-    def record(self, __script): ...
+    def record(self, script, /): ...
     def setvar(self, *ags, **kwargs): ...
     if sys.version_info < (3, 11):
-        def split(self, __arg): ...
+        def split(self, arg, /): ...
 
-    def splitlist(self, __arg): ...
+    def splitlist(self, arg, /): ...
     def unsetvar(self, *args, **kwargs): ...
     def wantobjects(self, *args, **kwargs): ...
     def willdispatch(self): ...
+    if sys.version_info >= (3, 12):
+        def gettrace(self, /) -> _TkinterTraceFunc | None: ...
+        def settrace(self, func: _TkinterTraceFunc | None, /) -> None: ...
 
 # These should be kept in sync with tkinter.tix constants, except ALL_EVENTS which doesn't match TCL_ALL_EVENTS
-ALL_EVENTS: Literal[-3]
-FILE_EVENTS: Literal[8]
-IDLE_EVENTS: Literal[32]
-TIMER_EVENTS: Literal[16]
-WINDOW_EVENTS: Literal[4]
+ALL_EVENTS: Final = -3
+FILE_EVENTS: Final = 8
+IDLE_EVENTS: Final = 32
+TIMER_EVENTS: Final = 16
+WINDOW_EVENTS: Final = 4
 
-DONT_WAIT: Literal[2]
-EXCEPTION: Literal[8]
-READABLE: Literal[2]
-WRITABLE: Literal[4]
+DONT_WAIT: Final = 2
+EXCEPTION: Final = 8
+READABLE: Final = 2
+WRITABLE: Final = 4
 
-TCL_VERSION: str
-TK_VERSION: str
+TCL_VERSION: Final[str]
+TK_VERSION: Final[str]
 
 @final
 class TkttType:
     def deletetimerhandler(self): ...
 
-if sys.version_info >= (3, 8):
+if sys.version_info >= (3, 13):
     def create(
-        __screenName: str | None = None,
-        __baseName: str = "",
-        __className: str = "Tk",
-        __interactive: bool = False,
-        __wantobjects: bool = False,
-        __wantTk: bool = True,
-        __sync: bool = False,
-        __use: str | None = None,
+        screenName: str | None = None,
+        baseName: str = "",
+        className: str = "Tk",
+        interactive: bool = False,
+        wantobjects: int = 0,
+        wantTk: bool = True,
+        sync: bool = False,
+        use: str | None = None,
+        /,
     ): ...
 
 else:
     def create(
-        __screenName: str | None = None,
-        __baseName: str | None = None,
-        __className: str = "Tk",
-        __interactive: bool = False,
-        __wantobjects: bool = False,
-        __wantTk: bool = True,
-        __sync: bool = False,
-        __use: str | None = None,
+        screenName: str | None = None,
+        baseName: str = "",
+        className: str = "Tk",
+        interactive: bool = False,
+        wantobjects: bool = False,
+        wantTk: bool = True,
+        sync: bool = False,
+        use: str | None = None,
+        /,
     ): ...
 
 def getbusywaitinterval(): ...
-def setbusywaitinterval(__new_val): ...
+def setbusywaitinterval(new_val, /): ...
diff --git a/mypy/typeshed/stdlib/_tracemalloc.pyi b/mypy/typeshed/stdlib/_tracemalloc.pyi
index 1b79d9dc5785..b1aeb710233e 100644
--- a/mypy/typeshed/stdlib/_tracemalloc.pyi
+++ b/mypy/typeshed/stdlib/_tracemalloc.pyi
@@ -2,7 +2,7 @@ import sys
 from collections.abc import Sequence
 from tracemalloc import _FrameTuple, _TraceTuple
 
-def _get_object_traceback(__obj: object) -> Sequence[_FrameTuple] | None: ...
+def _get_object_traceback(obj: object, /) -> Sequence[_FrameTuple] | None: ...
 def _get_traces() -> Sequence[_TraceTuple]: ...
 def clear_traces() -> None: ...
 def get_traceback_limit() -> int: ...
@@ -13,5 +13,5 @@ def is_tracing() -> bool: ...
 if sys.version_info >= (3, 9):
     def reset_peak() -> None: ...
 
-def start(__nframe: int = 1) -> None: ...
+def start(nframe: int = 1, /) -> None: ...
 def stop() -> None: ...
diff --git a/mypy/typeshed/stdlib/_typeshed/__init__.pyi b/mypy/typeshed/stdlib/_typeshed/__init__.pyi
index 5d03142c6d71..99d21b67360a 100644
--- a/mypy/typeshed/stdlib/_typeshed/__init__.pyi
+++ b/mypy/typeshed/stdlib/_typeshed/__init__.pyi
@@ -3,12 +3,27 @@
 # See the README.md file in this directory for more information.
 
 import sys
+import typing_extensions
 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, overload
-from typing_extensions import Buffer, Final, Literal, LiteralString, TypeAlias, final
+from typing import (
+    Any,
+    AnyStr,
+    ClassVar,
+    Final,
+    Generic,
+    Literal,
+    Protocol,
+    SupportsFloat,
+    SupportsIndex,
+    SupportsInt,
+    TypeVar,
+    final,
+    overload,
+)
+from typing_extensions import Buffer, LiteralString, TypeAlias
 
 _KT = TypeVar("_KT")
 _KT_co = TypeVar("_KT_co", covariant=True)
@@ -19,8 +34,10 @@ _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
 _T_contra = TypeVar("_T_contra", contravariant=True)
 
-# Use for "self" annotations:
-#   def __enter__(self: Self) -> Self: ...
+# Alternative to `typing_extensions.Self`, exclusively for use with `__new__`
+# in metaclasses:
+#     def __new__(cls: type[Self], ...) -> Self: ...
+# In other cases, use `typing_extensions.Self`.
 Self = TypeVar("Self")  # noqa: Y001
 
 # covariant version of typing.AnyStr, useful for protocols
@@ -31,14 +48,32 @@ AnyStr_co = TypeVar("AnyStr_co", str, bytes, covariant=True)  # noqa: Y001
 # isn't possible or a type is already partially known. In cases like these,
 # use Incomplete instead of Any as a marker. For example, use
 # "Incomplete | None" instead of "Any | None".
-Incomplete: TypeAlias = Any
+Incomplete: TypeAlias = Any  # stable
 
 # To describe a function parameter that is unused and will work with anything.
-Unused: TypeAlias = object
+Unused: TypeAlias = object  # stable
+
+# Marker for return types that include None, but where forcing the user to
+# check for None can be detrimental. Sometimes called "the Any trick". See
+# CONTRIBUTING.md for more information.
+MaybeNone: TypeAlias = Any  # stable
+
+# Used to mark arguments that default to a sentinel value. This prevents
+# stubtest from complaining about the default value not matching.
+#
+# def foo(x: int | None = sentinel) -> None: ...
+#
+# In cases where the sentinel object is exported and can be used by user code,
+# a construct like this is better:
+#
+# _SentinelType = NewType("_SentinelType", object)
+# sentinel: _SentinelType
+# def foo(x: int | None | _SentinelType = ...) -> None: ...
+sentinel: Any
 
 # stable
 class IdentityFunction(Protocol):
-    def __call__(self, __x: _T) -> _T: ...
+    def __call__(self, x: _T, /) -> _T: ...
 
 # stable
 class SupportsNext(Protocol[_T_co]):
@@ -51,16 +86,16 @@ class SupportsAnext(Protocol[_T_co]):
 # Comparison protocols
 
 class SupportsDunderLT(Protocol[_T_contra]):
-    def __lt__(self, __other: _T_contra) -> bool: ...
+    def __lt__(self, other: _T_contra, /) -> bool: ...
 
 class SupportsDunderGT(Protocol[_T_contra]):
-    def __gt__(self, __other: _T_contra) -> bool: ...
+    def __gt__(self, other: _T_contra, /) -> bool: ...
 
 class SupportsDunderLE(Protocol[_T_contra]):
-    def __le__(self, __other: _T_contra) -> bool: ...
+    def __le__(self, other: _T_contra, /) -> bool: ...
 
 class SupportsDunderGE(Protocol[_T_contra]):
-    def __ge__(self, __other: _T_contra) -> bool: ...
+    def __ge__(self, other: _T_contra, /) -> bool: ...
 
 class SupportsAllComparisons(
     SupportsDunderLT[Any], SupportsDunderGT[Any], SupportsDunderLE[Any], SupportsDunderGE[Any], Protocol
@@ -72,22 +107,28 @@ SupportsRichComparisonT = TypeVar("SupportsRichComparisonT", bound=SupportsRichC
 # Dunder protocols
 
 class SupportsAdd(Protocol[_T_contra, _T_co]):
-    def __add__(self, __x: _T_contra) -> _T_co: ...
+    def __add__(self, x: _T_contra, /) -> _T_co: ...
 
 class SupportsRAdd(Protocol[_T_contra, _T_co]):
-    def __radd__(self, __x: _T_contra) -> _T_co: ...
+    def __radd__(self, x: _T_contra, /) -> _T_co: ...
 
 class SupportsSub(Protocol[_T_contra, _T_co]):
-    def __sub__(self, __x: _T_contra) -> _T_co: ...
+    def __sub__(self, x: _T_contra, /) -> _T_co: ...
 
 class SupportsRSub(Protocol[_T_contra, _T_co]):
-    def __rsub__(self, __x: _T_contra) -> _T_co: ...
+    def __rsub__(self, x: _T_contra, /) -> _T_co: ...
+
+class SupportsMul(Protocol[_T_contra, _T_co]):
+    def __mul__(self, x: _T_contra, /) -> _T_co: ...
+
+class SupportsRMul(Protocol[_T_contra, _T_co]):
+    def __rmul__(self, x: _T_contra, /) -> _T_co: ...
 
 class SupportsDivMod(Protocol[_T_contra, _T_co]):
-    def __divmod__(self, __other: _T_contra) -> _T_co: ...
+    def __divmod__(self, other: _T_contra, /) -> _T_co: ...
 
 class SupportsRDivMod(Protocol[_T_contra, _T_co]):
-    def __rdivmod__(self, __other: _T_contra) -> _T_co: ...
+    def __rdivmod__(self, other: _T_contra, /) -> _T_co: ...
 
 # This protocol is generic over the iterator type, while Iterable is
 # generic over the type that is iterated over.
@@ -101,7 +142,7 @@ class SupportsAiter(Protocol[_T_co]):
 
 class SupportsLenAndGetItem(Protocol[_T_co]):
     def __len__(self) -> int: ...
-    def __getitem__(self, __k: int) -> _T_co: ...
+    def __getitem__(self, k: int, /) -> _T_co: ...
 
 class SupportsTrunc(Protocol):
     def __trunc__(self) -> int: ...
@@ -115,17 +156,23 @@ class SupportsItems(Protocol[_KT_co, _VT_co]):
 # stable
 class SupportsKeysAndGetItem(Protocol[_KT, _VT_co]):
     def keys(self) -> Iterable[_KT]: ...
-    def __getitem__(self, __key: _KT) -> _VT_co: ...
+    def __getitem__(self, key: _KT, /) -> _VT_co: ...
 
 # stable
 class SupportsGetItem(Protocol[_KT_contra, _VT_co]):
-    def __contains__(self, __x: Any) -> bool: ...
-    def __getitem__(self, __key: _KT_contra) -> _VT_co: ...
+    def __getitem__(self, key: _KT_contra, /) -> _VT_co: ...
 
 # stable
-class SupportsItemAccess(SupportsGetItem[_KT_contra, _VT], Protocol[_KT_contra, _VT]):
-    def __setitem__(self, __key: _KT_contra, __value: _VT) -> None: ...
-    def __delitem__(self, __key: _KT_contra) -> None: ...
+class SupportsContainsAndGetItem(Protocol[_KT_contra, _VT_co]):
+    def __contains__(self, x: Any, /) -> bool: ...
+    def __getitem__(self, key: _KT_contra, /) -> _VT_co: ...
+
+# stable
+class SupportsItemAccess(Protocol[_KT_contra, _VT]):
+    def __contains__(self, x: Any, /) -> bool: ...
+    def __getitem__(self, key: _KT_contra, /) -> _VT: ...
+    def __setitem__(self, key: _KT_contra, value: _VT, /) -> None: ...
+    def __delitem__(self, key: _KT_contra, /) -> None: ...
 
 StrPath: TypeAlias = str | PathLike[str]  # stable
 BytesPath: TypeAlias = bytes | PathLike[bytes]  # stable
@@ -209,11 +256,11 @@ FileDescriptorOrPath: TypeAlias = int | StrOrBytesPath
 
 # stable
 class SupportsRead(Protocol[_T_co]):
-    def read(self, __length: int = ...) -> _T_co: ...
+    def read(self, length: int = ..., /) -> _T_co: ...
 
 # stable
 class SupportsReadline(Protocol[_T_co]):
-    def readline(self, __length: int = ...) -> _T_co: ...
+    def readline(self, length: int = ..., /) -> _T_co: ...
 
 # stable
 class SupportsNoArgReadline(Protocol[_T_co]):
@@ -221,7 +268,11 @@ class SupportsNoArgReadline(Protocol[_T_co]):
 
 # stable
 class SupportsWrite(Protocol[_T_contra]):
-    def write(self, __s: _T_contra) -> object: ...
+    def write(self, s: _T_contra, /) -> object: ...
+
+# stable
+class SupportsFlush(Protocol):
+    def flush(self) -> object: ...
 
 # Unfortunately PEP 688 does not allow us to distinguish read-only
 # from writable buffers. We use these aliases for readability for now.
@@ -234,17 +285,17 @@ WriteableBuffer: TypeAlias = Buffer
 ReadableBuffer: TypeAlias = Buffer  # stable
 
 class SliceableBuffer(Buffer, Protocol):
-    def __getitem__(self, __slice: slice) -> Sequence[int]: ...
+    def __getitem__(self, slice: slice, /) -> Sequence[int]: ...
 
 class IndexableBuffer(Buffer, Protocol):
-    def __getitem__(self, __i: int) -> int: ...
+    def __getitem__(self, i: int, /) -> int: ...
 
 class SupportsGetItemBuffer(SliceableBuffer, IndexableBuffer, Protocol):
-    def __contains__(self, __x: Any) -> bool: ...
+    def __contains__(self, x: Any, /) -> bool: ...
     @overload
-    def __getitem__(self, __slice: slice) -> Sequence[int]: ...
+    def __getitem__(self, slice: slice, /) -> Sequence[int]: ...
     @overload
-    def __getitem__(self, __i: int) -> int: ...
+    def __getitem__(self, i: int, /) -> int: ...
 
 class SizedBuffer(Sized, Buffer, Protocol): ...
 
@@ -278,7 +329,9 @@ class structseq(Generic[_T_co]):
     # The second parameter will accept a dict of any kind without raising an exception,
     # but only has any meaning if you supply it a dict where the keys are strings.
     # https://github.com/python/typeshed/pull/6560#discussion_r767149830
-    def __new__(cls: type[Self], sequence: Iterable[_T_co], dict: dict[str, Any] = ...) -> Self: ...
+    def __new__(cls, sequence: Iterable[_T_co], dict: dict[str, Any] = ...) -> typing_extensions.Self: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, **kwargs: Any) -> typing_extensions.Self: ...
 
 # Superset of typing.AnyStr that also includes LiteralString
 AnyOrLiteralStr = TypeVar("AnyOrLiteralStr", str, bytes, LiteralString)  # noqa: Y001
@@ -299,3 +352,16 @@ TraceFunction: TypeAlias = Callable[[FrameType, str, Any], TraceFunction | None]
 #   https://github.com/microsoft/pyright/issues/4339
 class DataclassInstance(Protocol):
     __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
+
+# Anything that can be passed to the int/float constructors
+ConvertibleToInt: TypeAlias = str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc
+ConvertibleToFloat: TypeAlias = str | ReadableBuffer | SupportsFloat | SupportsIndex
+
+# A few classes updated from Foo(str, Enum) to Foo(StrEnum). This is a convenience so these
+# can be accurate on all python versions without getting too wordy
+if sys.version_info >= (3, 11):
+    from enum import StrEnum as StrEnum
+else:
+    from enum import Enum
+
+    class StrEnum(str, Enum): ...
diff --git a/mypy/typeshed/stdlib/_typeshed/dbapi.pyi b/mypy/typeshed/stdlib/_typeshed/dbapi.pyi
index 022e95996bb3..d54fbee57042 100644
--- a/mypy/typeshed/stdlib/_typeshed/dbapi.pyi
+++ b/mypy/typeshed/stdlib/_typeshed/dbapi.pyi
@@ -23,15 +23,15 @@ class DBAPICursor(Protocol):
     @property
     def rowcount(self) -> int: ...
     # optional:
-    # def callproc(self, __procname: str, __parameters: Sequence[Any] = ...) -> Sequence[Any]: ...
+    # def callproc(self, procname: str, parameters: Sequence[Any] = ..., /) -> Sequence[Any]: ...
     def close(self) -> object: ...
-    def execute(self, __operation: str, __parameters: Sequence[Any] | Mapping[str, Any] = ...) -> object: ...
-    def executemany(self, __operation: str, __seq_of_parameters: Sequence[Sequence[Any]]) -> object: ...
+    def execute(self, operation: str, parameters: Sequence[Any] | Mapping[str, Any] = ..., /) -> object: ...
+    def executemany(self, operation: str, seq_of_parameters: Sequence[Sequence[Any]], /) -> object: ...
     def fetchone(self) -> Sequence[Any] | None: ...
-    def fetchmany(self, __size: int = ...) -> Sequence[Sequence[Any]]: ...
+    def fetchmany(self, size: int = ..., /) -> Sequence[Sequence[Any]]: ...
     def fetchall(self) -> Sequence[Sequence[Any]]: ...
     # optional:
     # def nextset(self) -> None | Literal[True]: ...
     arraysize: int
-    def setinputsizes(self, __sizes: Sequence[DBAPITypeCode | int | None]) -> object: ...
-    def setoutputsize(self, __size: int, __column: int = ...) -> object: ...
+    def setinputsizes(self, sizes: Sequence[DBAPITypeCode | int | None], /) -> object: ...
+    def setoutputsize(self, size: int, column: int = ..., /) -> object: ...
diff --git a/mypy/typeshed/stdlib/_typeshed/importlib.pyi b/mypy/typeshed/stdlib/_typeshed/importlib.pyi
new file mode 100644
index 000000000000..a4e56cdaff62
--- /dev/null
+++ b/mypy/typeshed/stdlib/_typeshed/importlib.pyi
@@ -0,0 +1,18 @@
+# Implicit protocols used in importlib.
+# We intentionally omit deprecated and optional methods.
+
+from collections.abc import Sequence
+from importlib.machinery import ModuleSpec
+from types import ModuleType
+from typing import Protocol
+
+__all__ = ["LoaderProtocol", "MetaPathFinderProtocol", "PathEntryFinderProtocol"]
+
+class LoaderProtocol(Protocol):
+    def load_module(self, fullname: str, /) -> ModuleType: ...
+
+class MetaPathFinderProtocol(Protocol):
+    def find_spec(self, fullname: str, path: Sequence[str] | None, target: ModuleType | None = ..., /) -> ModuleSpec | None: ...
+
+class PathEntryFinderProtocol(Protocol):
+    def find_spec(self, fullname: str, target: ModuleType | None = ..., /) -> ModuleSpec | None: ...
diff --git a/mypy/typeshed/stdlib/_typeshed/wsgi.pyi b/mypy/typeshed/stdlib/_typeshed/wsgi.pyi
index de731aea918b..63f204eb889b 100644
--- a/mypy/typeshed/stdlib/_typeshed/wsgi.pyi
+++ b/mypy/typeshed/stdlib/_typeshed/wsgi.pyi
@@ -11,7 +11,7 @@ from typing import Any, Protocol
 from typing_extensions import TypeAlias
 
 class _Readable(Protocol):
-    def read(self, size: int = ...) -> bytes: ...
+    def read(self, size: int = ..., /) -> bytes: ...
     # Optional: def close(self) -> object: ...
 
 if sys.version_info >= (3, 11):
@@ -20,7 +20,7 @@ else:
     # stable
     class StartResponse(Protocol):
         def __call__(
-            self, __status: str, __headers: list[tuple[str, str]], __exc_info: OptExcInfo | None = ...
+            self, status: str, headers: list[tuple[str, str]], exc_info: OptExcInfo | None = ..., /
         ) -> Callable[[bytes], object]: ...
 
     WSGIEnvironment: TypeAlias = dict[str, Any]  # stable
@@ -28,17 +28,17 @@ else:
 
     # WSGI input streams per PEP 3333, stable
     class InputStream(Protocol):
-        def read(self, __size: int = ...) -> bytes: ...
-        def readline(self, __size: int = ...) -> bytes: ...
-        def readlines(self, __hint: int = ...) -> list[bytes]: ...
+        def read(self, size: int = ..., /) -> bytes: ...
+        def readline(self, size: int = ..., /) -> bytes: ...
+        def readlines(self, hint: int = ..., /) -> list[bytes]: ...
         def __iter__(self) -> Iterator[bytes]: ...
 
     # WSGI error streams per PEP 3333, stable
     class ErrorStream(Protocol):
         def flush(self) -> object: ...
-        def write(self, __s: str) -> object: ...
-        def writelines(self, __seq: list[str]) -> object: ...
+        def write(self, s: str, /) -> object: ...
+        def writelines(self, seq: list[str], /) -> object: ...
 
     # Optional file wrapper in wsgi.file_wrapper
     class FileWrapper(Protocol):
-        def __call__(self, __file: _Readable, __block_size: int = ...) -> Iterable[bytes]: ...
+        def __call__(self, file: _Readable, block_size: int = ..., /) -> Iterable[bytes]: ...
diff --git a/mypy/typeshed/stdlib/_typeshed/xml.pyi b/mypy/typeshed/stdlib/_typeshed/xml.pyi
index 231c2b86e912..6cd1b39af628 100644
--- a/mypy/typeshed/stdlib/_typeshed/xml.pyi
+++ b/mypy/typeshed/stdlib/_typeshed/xml.pyi
@@ -4,6 +4,6 @@ from typing import Any, Protocol
 
 # As defined https://docs.python.org/3/library/xml.dom.html#domimplementation-objects
 class DOMImplementation(Protocol):
-    def hasFeature(self, feature: str, version: str | None) -> bool: ...
-    def createDocument(self, namespaceUri: str, qualifiedName: str, doctype: Any | None) -> Any: ...
-    def createDocumentType(self, qualifiedName: str, publicId: str, systemId: str) -> Any: ...
+    def hasFeature(self, feature: str, version: str | None, /) -> bool: ...
+    def createDocument(self, namespaceUri: str, qualifiedName: str, doctype: Any | None, /) -> Any: ...
+    def createDocumentType(self, qualifiedName: str, publicId: str, systemId: str, /) -> Any: ...
diff --git a/mypy/typeshed/stdlib/_warnings.pyi b/mypy/typeshed/stdlib/_warnings.pyi
index 0981dfeaafee..2e571e676c97 100644
--- a/mypy/typeshed/stdlib/_warnings.pyi
+++ b/mypy/typeshed/stdlib/_warnings.pyi
@@ -1,13 +1,36 @@
+import sys
 from typing import Any, overload
 
 _defaultaction: str
 _onceregistry: dict[Any, Any]
 filters: list[tuple[str, str | None, type[Warning], str | None, int]]
 
-@overload
-def warn(message: str, category: type[Warning] | None = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
-@overload
-def warn(message: Warning, category: Any = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
+if sys.version_info >= (3, 12):
+    @overload
+    def warn(
+        message: str,
+        category: type[Warning] | None = None,
+        stacklevel: int = 1,
+        source: Any | None = None,
+        *,
+        skip_file_prefixes: tuple[str, ...] = (),
+    ) -> None: ...
+    @overload
+    def warn(
+        message: Warning,
+        category: Any = None,
+        stacklevel: int = 1,
+        source: Any | None = None,
+        *,
+        skip_file_prefixes: tuple[str, ...] = (),
+    ) -> None: ...
+
+else:
+    @overload
+    def warn(message: str, category: type[Warning] | None = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
+    @overload
+    def warn(message: Warning, category: Any = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
+
 @overload
 def warn_explicit(
     message: str,
diff --git a/mypy/typeshed/stdlib/_weakref.pyi b/mypy/typeshed/stdlib/_weakref.pyi
index b6044fac4628..a744340afaab 100644
--- a/mypy/typeshed/stdlib/_weakref.pyi
+++ b/mypy/typeshed/stdlib/_weakref.pyi
@@ -1,37 +1,15 @@
-import sys
 from collections.abc import Callable
-from typing import Any, Generic, TypeVar, overload
-from typing_extensions import Self, final
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
+from typing import Any, TypeVar, overload
+from weakref import CallableProxyType as CallableProxyType, ProxyType as ProxyType, ReferenceType as ReferenceType, ref as ref
 
 _C = TypeVar("_C", bound=Callable[..., Any])
 _T = TypeVar("_T")
 
-@final
-class CallableProxyType(Generic[_C]):  # "weakcallableproxy"
-    def __getattr__(self, attr: str) -> Any: ...
-    __call__: _C
-
-@final
-class ProxyType(Generic[_T]):  # "weakproxy"
-    def __getattr__(self, attr: str) -> Any: ...
-
-class ReferenceType(Generic[_T]):
-    __callback__: Callable[[ReferenceType[_T]], Any]
-    def __new__(cls, __o: _T, __callback: Callable[[ReferenceType[_T]], Any] | None = ...) -> Self: ...
-    def __call__(self) -> _T | None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-ref = ReferenceType
-
-def getweakrefcount(__object: Any) -> int: ...
-def getweakrefs(__object: Any) -> list[Any]: ...
+def getweakrefcount(object: Any, /) -> int: ...
+def getweakrefs(object: Any, /) -> list[Any]: ...
 
 # Return CallableProxyType if object is callable, ProxyType otherwise
 @overload
-def proxy(__object: _C, __callback: Callable[[_C], Any] | None = None) -> CallableProxyType[_C]: ...
+def proxy(object: _C, callback: Callable[[_C], Any] | None = None, /) -> CallableProxyType[_C]: ...
 @overload
-def proxy(__object: _T, __callback: Callable[[_T], Any] | None = None) -> Any: ...
+def proxy(object: _T, callback: Callable[[_T], Any] | None = None, /) -> Any: ...
diff --git a/mypy/typeshed/stdlib/_weakrefset.pyi b/mypy/typeshed/stdlib/_weakrefset.pyi
index d73d79155329..b55318528208 100644
--- a/mypy/typeshed/stdlib/_weakrefset.pyi
+++ b/mypy/typeshed/stdlib/_weakrefset.pyi
@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Iterable, Iterator, MutableSet
-from typing import Any, Generic, TypeVar, overload
+from typing import Any, ClassVar, TypeVar, overload
 from typing_extensions import Self
 
 if sys.version_info >= (3, 9):
@@ -11,7 +11,7 @@ __all__ = ["WeakSet"]
 _S = TypeVar("_S")
 _T = TypeVar("_T")
 
-class WeakSet(MutableSet[_T], Generic[_T]):
+class WeakSet(MutableSet[_T]):
     @overload
     def __init__(self, data: None = None) -> None: ...
     @overload
@@ -21,6 +21,7 @@ class WeakSet(MutableSet[_T], Generic[_T]):
     def copy(self) -> Self: ...
     def remove(self, item: _T) -> None: ...
     def update(self, other: Iterable[_T]) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __contains__(self, item: object) -> bool: ...
     def __len__(self) -> int: ...
     def __iter__(self) -> Iterator[_T]: ...
@@ -48,4 +49,4 @@ class WeakSet(MutableSet[_T], Generic[_T]):
     def __or__(self, other: Iterable[_S]) -> WeakSet[_S | _T]: ...
     def isdisjoint(self, other: Iterable[_T]) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/mypy/typeshed/stdlib/_winapi.pyi b/mypy/typeshed/stdlib/_winapi.pyi
index ca1e61f0f19f..0f71a0687748 100644
--- a/mypy/typeshed/stdlib/_winapi.pyi
+++ b/mypy/typeshed/stdlib/_winapi.pyi
@@ -1,124 +1,131 @@
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Sequence
-from typing import Any, NoReturn, overload
-from typing_extensions import Literal, final
+from typing import Any, Final, Literal, NoReturn, final, overload
 
 if sys.platform == "win32":
-    ABOVE_NORMAL_PRIORITY_CLASS: Literal[0x8000]
-    BELOW_NORMAL_PRIORITY_CLASS: Literal[0x4000]
-
-    CREATE_BREAKAWAY_FROM_JOB: Literal[0x1000000]
-    CREATE_DEFAULT_ERROR_MODE: Literal[0x4000000]
-    CREATE_NO_WINDOW: Literal[0x8000000]
-    CREATE_NEW_CONSOLE: Literal[0x10]
-    CREATE_NEW_PROCESS_GROUP: Literal[0x200]
-
-    DETACHED_PROCESS: Literal[8]
-    DUPLICATE_CLOSE_SOURCE: Literal[1]
-    DUPLICATE_SAME_ACCESS: Literal[2]
-
-    ERROR_ALREADY_EXISTS: Literal[183]
-    ERROR_BROKEN_PIPE: Literal[109]
-    ERROR_IO_PENDING: Literal[997]
-    ERROR_MORE_DATA: Literal[234]
-    ERROR_NETNAME_DELETED: Literal[64]
-    ERROR_NO_DATA: Literal[232]
-    ERROR_NO_SYSTEM_RESOURCES: Literal[1450]
-    ERROR_OPERATION_ABORTED: Literal[995]
-    ERROR_PIPE_BUSY: Literal[231]
-    ERROR_PIPE_CONNECTED: Literal[535]
-    ERROR_SEM_TIMEOUT: Literal[121]
-
-    FILE_FLAG_FIRST_PIPE_INSTANCE: Literal[0x80000]
-    FILE_FLAG_OVERLAPPED: Literal[0x40000000]
-
-    FILE_GENERIC_READ: Literal[1179785]
-    FILE_GENERIC_WRITE: Literal[1179926]
-
-    if sys.version_info >= (3, 8):
-        FILE_MAP_ALL_ACCESS: Literal[983071]
-        FILE_MAP_COPY: Literal[1]
-        FILE_MAP_EXECUTE: Literal[32]
-        FILE_MAP_READ: Literal[4]
-        FILE_MAP_WRITE: Literal[2]
-
-    FILE_TYPE_CHAR: Literal[2]
-    FILE_TYPE_DISK: Literal[1]
-    FILE_TYPE_PIPE: Literal[3]
-    FILE_TYPE_REMOTE: Literal[32768]
-    FILE_TYPE_UNKNOWN: Literal[0]
-
-    GENERIC_READ: Literal[0x80000000]
-    GENERIC_WRITE: Literal[0x40000000]
-    HIGH_PRIORITY_CLASS: Literal[0x80]
-    INFINITE: Literal[0xFFFFFFFF]
-    if sys.version_info >= (3, 8):
-        # Ignore the flake8 error -- flake8-pyi assumes
-        # most numbers this long will be implementation details,
-        # but here we can see that it's a power of 2
-        INVALID_HANDLE_VALUE: Literal[0xFFFFFFFFFFFFFFFF]  # noqa: Y054
-    IDLE_PRIORITY_CLASS: Literal[0x40]
-    NORMAL_PRIORITY_CLASS: Literal[0x20]
-    REALTIME_PRIORITY_CLASS: Literal[0x100]
-    NMPWAIT_WAIT_FOREVER: Literal[0xFFFFFFFF]
-
-    if sys.version_info >= (3, 8):
-        MEM_COMMIT: Literal[0x1000]
-        MEM_FREE: Literal[0x10000]
-        MEM_IMAGE: Literal[0x1000000]
-        MEM_MAPPED: Literal[0x40000]
-        MEM_PRIVATE: Literal[0x20000]
-        MEM_RESERVE: Literal[0x2000]
-
-    NULL: Literal[0]
-    OPEN_EXISTING: Literal[3]
-
-    PIPE_ACCESS_DUPLEX: Literal[3]
-    PIPE_ACCESS_INBOUND: Literal[1]
-    PIPE_READMODE_MESSAGE: Literal[2]
-    PIPE_TYPE_MESSAGE: Literal[4]
-    PIPE_UNLIMITED_INSTANCES: Literal[255]
-    PIPE_WAIT: Literal[0]
-
-    if sys.version_info >= (3, 8):
-        PAGE_EXECUTE: Literal[0x10]
-        PAGE_EXECUTE_READ: Literal[0x20]
-        PAGE_EXECUTE_READWRITE: Literal[0x40]
-        PAGE_EXECUTE_WRITECOPY: Literal[0x80]
-        PAGE_GUARD: Literal[0x100]
-        PAGE_NOACCESS: Literal[0x1]
-        PAGE_NOCACHE: Literal[0x200]
-        PAGE_READONLY: Literal[0x2]
-        PAGE_READWRITE: Literal[0x4]
-        PAGE_WRITECOMBINE: Literal[0x400]
-        PAGE_WRITECOPY: Literal[0x8]
-
-    PROCESS_ALL_ACCESS: Literal[0x1FFFFF]
-    PROCESS_DUP_HANDLE: Literal[0x40]
-
-    if sys.version_info >= (3, 8):
-        SEC_COMMIT: Literal[0x8000000]
-        SEC_IMAGE: Literal[0x1000000]
-        SEC_LARGE_PAGES: Literal[0x80000000]
-        SEC_NOCACHE: Literal[0x10000000]
-        SEC_RESERVE: Literal[0x4000000]
-        SEC_WRITECOMBINE: Literal[0x40000000]
-
-    STARTF_USESHOWWINDOW: Literal[0x1]
-    STARTF_USESTDHANDLES: Literal[0x100]
-
-    STD_ERROR_HANDLE: Literal[0xFFFFFFF4]
-    STD_OUTPUT_HANDLE: Literal[0xFFFFFFF5]
-    STD_INPUT_HANDLE: Literal[0xFFFFFFF6]
-
-    STILL_ACTIVE: Literal[259]
-    SW_HIDE: Literal[0]
-    if sys.version_info >= (3, 8):
-        SYNCHRONIZE: Literal[0x100000]
-    WAIT_ABANDONED_0: Literal[128]
-    WAIT_OBJECT_0: Literal[0]
-    WAIT_TIMEOUT: Literal[258]
+    ABOVE_NORMAL_PRIORITY_CLASS: Final = 0x8000
+    BELOW_NORMAL_PRIORITY_CLASS: Final = 0x4000
+
+    CREATE_BREAKAWAY_FROM_JOB: Final = 0x1000000
+    CREATE_DEFAULT_ERROR_MODE: Final = 0x4000000
+    CREATE_NO_WINDOW: Final = 0x8000000
+    CREATE_NEW_CONSOLE: Final = 0x10
+    CREATE_NEW_PROCESS_GROUP: Final = 0x200
+
+    DETACHED_PROCESS: Final = 8
+    DUPLICATE_CLOSE_SOURCE: Final = 1
+    DUPLICATE_SAME_ACCESS: Final = 2
+
+    ERROR_ALREADY_EXISTS: Final = 183
+    ERROR_BROKEN_PIPE: Final = 109
+    ERROR_IO_PENDING: Final = 997
+    ERROR_MORE_DATA: Final = 234
+    ERROR_NETNAME_DELETED: Final = 64
+    ERROR_NO_DATA: Final = 232
+    ERROR_NO_SYSTEM_RESOURCES: Final = 1450
+    ERROR_OPERATION_ABORTED: Final = 995
+    ERROR_PIPE_BUSY: Final = 231
+    ERROR_PIPE_CONNECTED: Final = 535
+    ERROR_SEM_TIMEOUT: Final = 121
+
+    FILE_FLAG_FIRST_PIPE_INSTANCE: Final = 0x80000
+    FILE_FLAG_OVERLAPPED: Final = 0x40000000
+
+    FILE_GENERIC_READ: Final = 1179785
+    FILE_GENERIC_WRITE: Final = 1179926
+
+    FILE_MAP_ALL_ACCESS: Final = 983071
+    FILE_MAP_COPY: Final = 1
+    FILE_MAP_EXECUTE: Final = 32
+    FILE_MAP_READ: Final = 4
+    FILE_MAP_WRITE: Final = 2
+
+    FILE_TYPE_CHAR: Final = 2
+    FILE_TYPE_DISK: Final = 1
+    FILE_TYPE_PIPE: Final = 3
+    FILE_TYPE_REMOTE: Final = 32768
+    FILE_TYPE_UNKNOWN: Final = 0
+
+    GENERIC_READ: Final = 0x80000000
+    GENERIC_WRITE: Final = 0x40000000
+    HIGH_PRIORITY_CLASS: Final = 0x80
+    INFINITE: Final = 0xFFFFFFFF
+    # Ignore the Flake8 error -- flake8-pyi assumes
+    # most numbers this long will be implementation details,
+    # but here we can see that it's a power of 2
+    INVALID_HANDLE_VALUE: Final = 0xFFFFFFFFFFFFFFFF  # noqa: Y054
+    IDLE_PRIORITY_CLASS: Final = 0x40
+    NORMAL_PRIORITY_CLASS: Final = 0x20
+    REALTIME_PRIORITY_CLASS: Final = 0x100
+    NMPWAIT_WAIT_FOREVER: Final = 0xFFFFFFFF
+
+    MEM_COMMIT: Final = 0x1000
+    MEM_FREE: Final = 0x10000
+    MEM_IMAGE: Final = 0x1000000
+    MEM_MAPPED: Final = 0x40000
+    MEM_PRIVATE: Final = 0x20000
+    MEM_RESERVE: Final = 0x2000
+
+    NULL: Final = 0
+    OPEN_EXISTING: Final = 3
+
+    PIPE_ACCESS_DUPLEX: Final = 3
+    PIPE_ACCESS_INBOUND: Final = 1
+    PIPE_READMODE_MESSAGE: Final = 2
+    PIPE_TYPE_MESSAGE: Final = 4
+    PIPE_UNLIMITED_INSTANCES: Final = 255
+    PIPE_WAIT: Final = 0
+
+    PAGE_EXECUTE: Final = 0x10
+    PAGE_EXECUTE_READ: Final = 0x20
+    PAGE_EXECUTE_READWRITE: Final = 0x40
+    PAGE_EXECUTE_WRITECOPY: Final = 0x80
+    PAGE_GUARD: Final = 0x100
+    PAGE_NOACCESS: Final = 0x1
+    PAGE_NOCACHE: Final = 0x200
+    PAGE_READONLY: Final = 0x2
+    PAGE_READWRITE: Final = 0x4
+    PAGE_WRITECOMBINE: Final = 0x400
+    PAGE_WRITECOPY: Final = 0x8
+
+    PROCESS_ALL_ACCESS: Final = 0x1FFFFF
+    PROCESS_DUP_HANDLE: Final = 0x40
+
+    SEC_COMMIT: Final = 0x8000000
+    SEC_IMAGE: Final = 0x1000000
+    SEC_LARGE_PAGES: Final = 0x80000000
+    SEC_NOCACHE: Final = 0x10000000
+    SEC_RESERVE: Final = 0x4000000
+    SEC_WRITECOMBINE: Final = 0x40000000
+
+    if sys.version_info >= (3, 13):
+        STARTF_FORCEOFFFEEDBACK: Final = 0x80
+        STARTF_FORCEONFEEDBACK: Final = 0x40
+        STARTF_PREVENTPINNING: Final = 0x2000
+        STARTF_RUNFULLSCREEN: Final = 0x20
+        STARTF_TITLEISAPPID: Final = 0x1000
+        STARTF_TITLEISLINKNAME: Final = 0x800
+        STARTF_UNTRUSTEDSOURCE: Final = 0x8000
+        STARTF_USECOUNTCHARS: Final = 0x8
+        STARTF_USEFILLATTRIBUTE: Final = 0x10
+        STARTF_USEHOTKEY: Final = 0x200
+        STARTF_USEPOSITION: Final = 0x4
+        STARTF_USESIZE: Final = 0x2
+
+    STARTF_USESHOWWINDOW: Final = 0x1
+    STARTF_USESTDHANDLES: Final = 0x100
+
+    STD_ERROR_HANDLE: Final = 0xFFFFFFF4
+    STD_OUTPUT_HANDLE: Final = 0xFFFFFFF5
+    STD_INPUT_HANDLE: Final = 0xFFFFFFF6
+
+    STILL_ACTIVE: Final = 259
+    SW_HIDE: Final = 0
+    SYNCHRONIZE: Final = 0x100000
+    WAIT_ABANDONED_0: Final = 128
+    WAIT_OBJECT_0: Final = 0
+    WAIT_TIMEOUT: Final = 258
 
     if sys.version_info >= (3, 10):
         LOCALE_NAME_INVARIANT: str
@@ -137,7 +144,35 @@ if sys.platform == "win32":
         LCMAP_TRADITIONAL_CHINESE: int
         LCMAP_UPPERCASE: int
 
-    def CloseHandle(__handle: int) -> None: ...
+    if sys.version_info >= (3, 12):
+        COPYFILE2_CALLBACK_CHUNK_STARTED: Final = 1
+        COPYFILE2_CALLBACK_CHUNK_FINISHED: Final = 2
+        COPYFILE2_CALLBACK_STREAM_STARTED: Final = 3
+        COPYFILE2_CALLBACK_STREAM_FINISHED: Final = 4
+        COPYFILE2_CALLBACK_POLL_CONTINUE: Final = 5
+        COPYFILE2_CALLBACK_ERROR: Final = 6
+
+        COPYFILE2_PROGRESS_CONTINUE: Final = 0
+        COPYFILE2_PROGRESS_CANCEL: Final = 1
+        COPYFILE2_PROGRESS_STOP: Final = 2
+        COPYFILE2_PROGRESS_QUIET: Final = 3
+        COPYFILE2_PROGRESS_PAUSE: Final = 4
+
+        COPY_FILE_FAIL_IF_EXISTS: Final = 0x1
+        COPY_FILE_RESTARTABLE: Final = 0x2
+        COPY_FILE_OPEN_SOURCE_FOR_WRITE: Final = 0x4
+        COPY_FILE_ALLOW_DECRYPTED_DESTINATION: Final = 0x8
+        COPY_FILE_COPY_SYMLINK: Final = 0x800
+        COPY_FILE_NO_BUFFERING: Final = 0x1000
+        COPY_FILE_REQUEST_SECURITY_PRIVILEGES: Final = 0x2000
+        COPY_FILE_RESUME_FROM_PAUSE: Final = 0x4000
+        COPY_FILE_NO_OFFLOAD: Final = 0x40000
+        COPY_FILE_REQUEST_COMPRESSED_TRAFFIC: Final = 0x10000000
+
+        ERROR_ACCESS_DENIED: Final = 5
+        ERROR_PRIVILEGE_NOT_HELD: Final = 1314
+
+    def CloseHandle(handle: int, /) -> None: ...
     @overload
     def ConnectNamedPipe(handle: int, overlapped: Literal[True]) -> Overlapped: ...
     @overload
@@ -145,59 +180,63 @@ if sys.platform == "win32":
     @overload
     def ConnectNamedPipe(handle: int, overlapped: bool) -> Overlapped | None: ...
     def CreateFile(
-        __file_name: str,
-        __desired_access: int,
-        __share_mode: int,
-        __security_attributes: int,
-        __creation_disposition: int,
-        __flags_and_attributes: int,
-        __template_file: int,
+        file_name: str,
+        desired_access: int,
+        share_mode: int,
+        security_attributes: int,
+        creation_disposition: int,
+        flags_and_attributes: int,
+        template_file: int,
+        /,
     ) -> int: ...
-    def CreateJunction(__src_path: str, __dst_path: str) -> None: ...
+    def CreateJunction(src_path: str, dst_path: str, /) -> None: ...
     def CreateNamedPipe(
-        __name: str,
-        __open_mode: int,
-        __pipe_mode: int,
-        __max_instances: int,
-        __out_buffer_size: int,
-        __in_buffer_size: int,
-        __default_timeout: int,
-        __security_attributes: int,
+        name: str,
+        open_mode: int,
+        pipe_mode: int,
+        max_instances: int,
+        out_buffer_size: int,
+        in_buffer_size: int,
+        default_timeout: int,
+        security_attributes: int,
+        /,
     ) -> int: ...
-    def CreatePipe(__pipe_attrs: Any, __size: int) -> tuple[int, int]: ...
+    def CreatePipe(pipe_attrs: Any, size: int, /) -> tuple[int, int]: ...
     def CreateProcess(
-        __application_name: str | None,
-        __command_line: str | None,
-        __proc_attrs: Any,
-        __thread_attrs: Any,
-        __inherit_handles: bool,
-        __creation_flags: int,
-        __env_mapping: dict[str, str],
-        __current_directory: str | None,
-        __startup_info: Any,
+        application_name: str | None,
+        command_line: str | None,
+        proc_attrs: Any,
+        thread_attrs: Any,
+        inherit_handles: bool,
+        creation_flags: int,
+        env_mapping: dict[str, str],
+        current_directory: str | None,
+        startup_info: Any,
+        /,
     ) -> tuple[int, int, int, int]: ...
     def DuplicateHandle(
-        __source_process_handle: int,
-        __source_handle: int,
-        __target_process_handle: int,
-        __desired_access: int,
-        __inherit_handle: bool,
-        __options: int = 0,
+        source_process_handle: int,
+        source_handle: int,
+        target_process_handle: int,
+        desired_access: int,
+        inherit_handle: bool,
+        options: int = 0,
+        /,
     ) -> int: ...
-    def ExitProcess(__ExitCode: int) -> NoReturn: ...
+    def ExitProcess(ExitCode: int, /) -> NoReturn: ...
     def GetACP() -> int: ...
     def GetFileType(handle: int) -> int: ...
     def GetCurrentProcess() -> int: ...
-    def GetExitCodeProcess(__process: int) -> int: ...
+    def GetExitCodeProcess(process: int, /) -> int: ...
     def GetLastError() -> int: ...
-    def GetModuleFileName(__module_handle: int) -> str: ...
-    def GetStdHandle(__std_handle: int) -> int: ...
+    def GetModuleFileName(module_handle: int, /) -> str: ...
+    def GetStdHandle(std_handle: int, /) -> int: ...
     def GetVersion() -> int: ...
-    def OpenProcess(__desired_access: int, __inherit_handle: bool, __process_id: int) -> int: ...
-    def PeekNamedPipe(__handle: int, __size: int = 0) -> tuple[int, int] | tuple[bytes, int, int]: ...
+    def OpenProcess(desired_access: int, inherit_handle: bool, process_id: int, /) -> int: ...
+    def PeekNamedPipe(handle: int, size: int = 0, /) -> tuple[int, int] | tuple[bytes, int, int]: ...
     if sys.version_info >= (3, 10):
         def LCMapStringEx(locale: str, flags: int, src: str) -> str: ...
-        def UnmapViewOfFile(__address: int) -> None: ...
+        def UnmapViewOfFile(address: int, /) -> None: ...
 
     @overload
     def ReadFile(handle: int, size: int, overlapped: Literal[True]) -> tuple[Overlapped, int]: ...
@@ -206,12 +245,12 @@ if sys.platform == "win32":
     @overload
     def ReadFile(handle: int, size: int, overlapped: int | bool) -> tuple[Any, int]: ...
     def SetNamedPipeHandleState(
-        __named_pipe: int, __mode: int | None, __max_collection_count: int | None, __collect_data_timeout: int | None
+        named_pipe: int, mode: int | None, max_collection_count: int | None, collect_data_timeout: int | None, /
     ) -> None: ...
-    def TerminateProcess(__handle: int, __exit_code: int) -> None: ...
-    def WaitForMultipleObjects(__handle_seq: Sequence[int], __wait_flag: bool, __milliseconds: int = 0xFFFFFFFF) -> int: ...
-    def WaitForSingleObject(__handle: int, __milliseconds: int) -> int: ...
-    def WaitNamedPipe(__name: str, __timeout: int) -> None: ...
+    def TerminateProcess(handle: int, exit_code: int, /) -> None: ...
+    def WaitForMultipleObjects(handle_seq: Sequence[int], wait_flag: bool, milliseconds: int = 0xFFFFFFFF, /) -> int: ...
+    def WaitForSingleObject(handle: int, milliseconds: int, /) -> int: ...
+    def WaitNamedPipe(name: str, timeout: int, /) -> None: ...
     @overload
     def WriteFile(handle: int, buffer: ReadableBuffer, overlapped: Literal[True]) -> tuple[Overlapped, int]: ...
     @overload
@@ -221,6 +260,24 @@ if sys.platform == "win32":
     @final
     class Overlapped:
         event: int
-        def GetOverlappedResult(self, __wait: bool) -> tuple[int, int]: ...
+        def GetOverlappedResult(self, wait: bool, /) -> tuple[int, int]: ...
         def cancel(self) -> None: ...
         def getbuffer(self) -> bytes | None: ...
+
+    if sys.version_info >= (3, 13):
+        def BatchedWaitForMultipleObjects(
+            handle_seq: Sequence[int], wait_all: bool, milliseconds: int = 0xFFFFFFFF
+        ) -> list[int]: ...
+        def CreateEventW(security_attributes: int, manual_reset: bool, initial_state: bool, name: str | None) -> int: ...
+        def CreateMutexW(security_attributes: int, initial_owner: bool, name: str) -> int: ...
+        def GetLongPathName(path: str) -> str: ...
+        def GetShortPathName(path: str) -> str: ...
+        def OpenEventW(desired_access: int, inherit_handle: bool, name: str) -> int: ...
+        def OpenMutexW(desired_access: int, inherit_handle: bool, name: str) -> int: ...
+        def ReleaseMutex(mutex: int) -> None: ...
+        def ResetEvent(event: int) -> None: ...
+        def SetEvent(event: int) -> 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: ...
+        def NeedCurrentDirectoryForExePath(exe_name: str, /) -> bool: ...
diff --git a/mypy/typeshed/stdlib/abc.pyi b/mypy/typeshed/stdlib/abc.pyi
index ec04d8f85d12..fdca48ac7aaf 100644
--- a/mypy/typeshed/stdlib/abc.pyi
+++ b/mypy/typeshed/stdlib/abc.pyi
@@ -2,8 +2,8 @@ import _typeshed
 import sys
 from _typeshed import SupportsWrite
 from collections.abc import Callable
-from typing import Any, TypeVar
-from typing_extensions import Concatenate, Literal, ParamSpec
+from typing import Any, Literal, TypeVar
+from typing_extensions import Concatenate, ParamSpec, deprecated
 
 _T = TypeVar("_T")
 _R_co = TypeVar("_R_co", covariant=True)
@@ -15,7 +15,7 @@ class ABCMeta(type):
     __abstractmethods__: frozenset[str]
     if sys.version_info >= (3, 11):
         def __new__(
-            __mcls: type[_typeshed.Self], __name: str, __bases: tuple[type, ...], __namespace: dict[str, Any], **kwargs: Any
+            mcls: type[_typeshed.Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], /, **kwargs: Any
         ) -> _typeshed.Self: ...
     else:
         def __new__(
@@ -28,19 +28,22 @@ class ABCMeta(type):
     def register(cls: ABCMeta, subclass: type[_T]) -> type[_T]: ...
 
 def abstractmethod(funcobj: _FuncT) -> _FuncT: ...
-
+@deprecated("Use 'classmethod' with 'abstractmethod' instead")
 class abstractclassmethod(classmethod[_T, _P, _R_co]):
     __isabstractmethod__: Literal[True]
-    def __init__(self, callable: Callable[Concatenate[_T, _P], _R_co]) -> None: ...
+    def __init__(self, callable: Callable[Concatenate[type[_T], _P], _R_co]) -> None: ...
 
+@deprecated("Use 'staticmethod' with 'abstractmethod' instead")
 class abstractstaticmethod(staticmethod[_P, _R_co]):
     __isabstractmethod__: Literal[True]
     def __init__(self, callable: Callable[_P, _R_co]) -> None: ...
 
+@deprecated("Use 'property' with 'abstractmethod' instead")
 class abstractproperty(property):
     __isabstractmethod__: Literal[True]
 
-class ABC(metaclass=ABCMeta): ...
+class ABC(metaclass=ABCMeta):
+    __slots__ = ()
 
 def get_cache_token() -> object: ...
 
diff --git a/mypy/typeshed/stdlib/aifc.pyi b/mypy/typeshed/stdlib/aifc.pyi
index ab0c18ed6623..05bf53986b29 100644
--- a/mypy/typeshed/stdlib/aifc.pyi
+++ b/mypy/typeshed/stdlib/aifc.pyi
@@ -1,7 +1,7 @@
 import sys
 from types import TracebackType
-from typing import IO, Any, NamedTuple, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, Literal, NamedTuple, overload
+from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
     __all__ = ["Error", "open"]
diff --git a/mypy/typeshed/stdlib/argparse.pyi b/mypy/typeshed/stdlib/argparse.pyi
index c986b9cdb082..9dbd8c308b59 100644
--- a/mypy/typeshed/stdlib/argparse.pyi
+++ b/mypy/typeshed/stdlib/argparse.pyi
@@ -1,8 +1,9 @@
 import sys
+from _typeshed import SupportsWrite, sentinel
 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, Self, TypeAlias
+from typing import IO, Any, ClassVar, Final, Generic, NewType, NoReturn, Protocol, TypeVar, overload
+from typing_extensions import Self, TypeAlias, deprecated
 
 __all__ = [
     "ArgumentParser",
@@ -31,25 +32,17 @@ _T = TypeVar("_T")
 _ActionT = TypeVar("_ActionT", bound=Action)
 _ArgumentParserT = TypeVar("_ArgumentParserT", bound=ArgumentParser)
 _N = TypeVar("_N")
-# more precisely, Literal["store", "store_const", "store_true",
-# "store_false", "append", "append_const", "count", "help", "version",
-# "extend"], but using this would make it hard to annotate callers
-# that don't use a literal argument
-_ActionStr: TypeAlias = str
-# more precisely, Literal["?", "*", "+", "...", "A...",
-# "==SUPPRESS=="], but using this would make it hard to annotate
-# callers that don't use a literal argument
-_NArgsStr: TypeAlias = str
-
-ONE_OR_MORE: Literal["+"]
-OPTIONAL: Literal["?"]
-PARSER: Literal["A..."]
-REMAINDER: Literal["..."]
+_ActionType: TypeAlias = Callable[[str], Any] | FileType | str
+
+ONE_OR_MORE: Final = "+"
+OPTIONAL: Final = "?"
+PARSER: Final = "A..."
+REMAINDER: Final = "..."
 _SUPPRESS_T = NewType("_SUPPRESS_T", str)
 SUPPRESS: _SUPPRESS_T | str  # not using Literal because argparse sometimes compares SUPPRESS with is
 # the | str is there so that foo = argparse.SUPPRESS; foo = "test" checks out in mypy
-ZERO_OR_MORE: Literal["*"]
-_UNRECOGNIZED_ARGS_ATTR: str  # undocumented
+ZERO_OR_MORE: Final = "*"
+_UNRECOGNIZED_ARGS_ATTR: Final = "_unrecognized_args"  # undocumented
 
 class ArgumentError(Exception):
     argument_name: str | None
@@ -84,11 +77,16 @@ class _ActionsContainer:
     def add_argument(
         self,
         *name_or_flags: str,
-        action: _ActionStr | type[Action] = ...,
-        nargs: int | _NArgsStr | _SUPPRESS_T = ...,
+        # str covers predefined actions ("store_true", "count", etc.)
+        # and user registered actions via the `register` method.
+        action: str | type[Action] = ...,
+        # more precisely, Literal["?", "*", "+", "...", "A...", "==SUPPRESS=="],
+        # but using this would make it hard to annotate callers that don't use a
+        # literal argument and for subclasses to override this method.
+        nargs: int | str | _SUPPRESS_T | None = None,
         const: Any = ...,
         default: Any = ...,
-        type: Callable[[str], _T] | FileType = ...,
+        type: _ActionType = ...,
         choices: Iterable[_T] | None = ...,
         required: bool = ...,
         help: str | None = ...,
@@ -97,8 +95,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: ...
@@ -111,7 +117,7 @@ class _ActionsContainer:
     def _handle_conflict_resolve(self, action: Action, conflicting_actions: Iterable[tuple[str, Action]]) -> None: ...
 
 class _FormatterClass(Protocol):
-    def __call__(self, prog: str) -> HelpFormatter: ...
+    def __call__(self, *, prog: str) -> HelpFormatter: ...
 
 class ArgumentParser(_AttributeHolder, _ActionsContainer):
     prog: str
@@ -161,9 +167,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: None = None) -> Namespace: ...
     @overload
     def parse_args(self, args: Sequence[str] | None, namespace: _N) -> _N: ...
     @overload
@@ -172,49 +178,68 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     def add_subparsers(
         self: _ArgumentParserT,
         *,
-        title: str = ...,
-        description: str | None = ...,
-        prog: str = ...,
+        title: str = "subcommands",
+        description: str | None = None,
+        prog: str | None = None,
         action: type[Action] = ...,
         option_string: str = ...,
-        dest: str | None = ...,
-        required: bool = ...,
-        help: str | None = ...,
-        metavar: str | None = ...,
+        dest: str | None = None,
+        required: bool = False,
+        help: str | None = None,
+        metavar: str | None = None,
     ) -> _SubParsersAction[_ArgumentParserT]: ...
     @overload
     def add_subparsers(
         self,
         *,
-        title: str = ...,
-        description: str | None = ...,
-        prog: str = ...,
+        title: str = "subcommands",
+        description: str | None = None,
+        prog: str | None = None,
         parser_class: type[_ArgumentParserT],
         action: type[Action] = ...,
         option_string: str = ...,
-        dest: str | None = ...,
-        required: bool = ...,
-        help: str | None = ...,
-        metavar: str | None = ...,
+        dest: str | None = None,
+        required: bool = False,
+        help: str | None = None,
+        metavar: str | None = None,
     ) -> _SubParsersAction[_ArgumentParserT]: ...
-    def print_usage(self, file: IO[str] | None = None) -> None: ...
-    def print_help(self, file: IO[str] | None = None) -> None: ...
+    def print_usage(self, file: SupportsWrite[str] | None = None) -> None: ...
+    def print_help(self, file: SupportsWrite[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: None = None) -> tuple[Namespace, list[str]]: ...
+    @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: ...
+    @overload
+    def parse_intermixed_args(self, args: Sequence[str] | None = None, namespace: None = None) -> Namespace: ...
+    @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
+        self, args: Sequence[str] | None = None, namespace: None = None
     ) -> tuple[Namespace, list[str]]: ...
+    @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]: ...
-    def _parse_known_args(self, arg_strings: list[str], namespace: Namespace) -> tuple[Namespace, list[str]]: ...
+    if sys.version_info >= (3, 12):
+        def _parse_known_args(
+            self, arg_strings: list[str], namespace: Namespace, intermixed: bool
+        ) -> tuple[Namespace, list[str]]: ...
+    else:
+        def _parse_known_args(self, arg_strings: list[str], namespace: Namespace) -> tuple[Namespace, list[str]]: ...
+
     def _read_args_from_files(self, arg_strings: list[str]) -> list[str]: ...
     def _match_argument(self, action: Action, arg_strings_pattern: str) -> int: ...
     def _match_arguments_partial(self, actions: Sequence[Action], arg_strings_pattern: str) -> list[int]: ...
@@ -225,7 +250,7 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     def _get_value(self, action: Action, arg_string: str) -> Any: ...
     def _check_value(self, action: Action, value: Any) -> None: ...
     def _get_formatter(self) -> HelpFormatter: ...
-    def _print_message(self, message: str, file: IO[str] | None = None) -> None: ...
+    def _print_message(self, message: str, file: SupportsWrite[str] | None = None) -> None: ...
 
 class HelpFormatter:
     # undocumented
@@ -291,37 +316,129 @@ class Action(_AttributeHolder):
     nargs: int | str | None
     const: Any
     default: Any
-    type: Callable[[str], Any] | FileType | None
+    type: _ActionType | None
     choices: Iterable[Any] | None
     required: bool
     help: str | None
     metavar: str | tuple[str, ...] | None
-    def __init__(
-        self,
-        option_strings: Sequence[str],
-        dest: str,
-        nargs: int | str | None = None,
-        const: _T | None = None,
-        default: _T | str | None = None,
-        type: Callable[[str], _T] | FileType | None = None,
-        choices: Iterable[_T] | None = None,
-        required: bool = False,
-        help: str | None = None,
-        metavar: str | tuple[str, ...] | None = None,
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            nargs: int | str | None = None,
+            const: _T | None = None,
+            default: _T | str | None = None,
+            type: Callable[[str], _T] | FileType | None = None,
+            choices: Iterable[_T] | None = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | tuple[str, ...] | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            nargs: int | str | None = None,
+            const: _T | None = None,
+            default: _T | str | None = None,
+            type: Callable[[str], _T] | FileType | None = None,
+            choices: Iterable[_T] | None = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | tuple[str, ...] | None = None,
+        ) -> None: ...
+
     def __call__(
         self, parser: ArgumentParser, namespace: Namespace, values: str | Sequence[Any] | None, option_string: str | None = None
     ) -> None: ...
     if sys.version_info >= (3, 9):
         def format_usage(self) -> str: ...
 
-if sys.version_info >= (3, 9):
+if sys.version_info >= (3, 12):
     class BooleanOptionalAction(Action):
+        if sys.version_info >= (3, 14):
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: bool | None = None,
+                required: bool = False,
+                help: str | None = None,
+                deprecated: bool = False,
+            ) -> None: ...
+        elif sys.version_info >= (3, 13):
+            @overload
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: bool | None = None,
+                *,
+                required: bool = False,
+                help: str | None = None,
+                deprecated: bool = False,
+            ) -> None: ...
+            @overload
+            @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: _T | bool | None = None,
+                type: Callable[[str], _T] | FileType | None = sentinel,
+                choices: Iterable[_T] | None = sentinel,
+                required: bool = False,
+                help: str | None = None,
+                metavar: str | tuple[str, ...] | None = sentinel,
+                deprecated: bool = False,
+            ) -> None: ...
+        else:
+            @overload
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: bool | None = None,
+                *,
+                required: bool = False,
+                help: str | None = None,
+            ) -> None: ...
+            @overload
+            @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: _T | bool | None = None,
+                type: Callable[[str], _T] | FileType | None = sentinel,
+                choices: Iterable[_T] | None = sentinel,
+                required: bool = False,
+                help: str | None = None,
+                metavar: str | tuple[str, ...] | None = sentinel,
+            ) -> None: ...
+
+elif sys.version_info >= (3, 9):
+    class BooleanOptionalAction(Action):
+        @overload
         def __init__(
             self,
             option_strings: Sequence[str],
             dest: str,
-            default: _T | str | None = None,
+            default: bool | None = None,
+            *,
+            required: bool = False,
+            help: str | None = None,
+        ) -> None: ...
+        @overload
+        @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: _T | bool | None = None,
             type: Callable[[str], _T] | FileType | None = None,
             choices: Iterable[_T] | None = None,
             required: bool = False,
@@ -332,9 +449,10 @@ if sys.version_info >= (3, 9):
 class Namespace(_AttributeHolder):
     def __init__(self, **kwargs: Any) -> None: ...
     def __getattr__(self, name: str) -> Any: ...
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
     def __contains__(self, key: str) -> bool: ...
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class FileType:
     # undocumented
@@ -350,7 +468,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
@@ -364,7 +489,19 @@ class _StoreAction(Action): ...
 
 # undocumented
 class _StoreConstAction(Action):
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            const: Any | None = None,
+            default: Any = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | tuple[str, ...] | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
         def __init__(
             self,
             option_strings: Sequence[str],
@@ -389,26 +526,59 @@ class _StoreConstAction(Action):
 
 # undocumented
 class _StoreTrueAction(_StoreConstAction):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str, default: bool = False, required: bool = False, help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: bool = False,
+            required: bool = False,
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, option_strings: Sequence[str], dest: str, default: bool = False, required: bool = False, help: str | None = None
+        ) -> None: ...
 
 # undocumented
 class _StoreFalseAction(_StoreConstAction):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str, default: bool = True, required: bool = False, help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: bool = True,
+            required: bool = False,
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, option_strings: Sequence[str], dest: str, default: bool = True, required: bool = False, help: str | None = None
+        ) -> None: ...
 
 # undocumented
 class _AppendAction(Action): ...
 
 # undocumented
-if sys.version_info >= (3, 8):
-    class _ExtendAction(_AppendAction): ...
+class _ExtendAction(_AppendAction): ...
 
 # undocumented
 class _AppendConstAction(Action):
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            const: Any | None = None,
+            default: Any = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | tuple[str, ...] | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
         def __init__(
             self,
             option_strings: Sequence[str],
@@ -433,27 +603,72 @@ class _AppendConstAction(Action):
 
 # undocumented
 class _CountAction(Action):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str, default: Any = None, required: bool = False, help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: Any = None,
+            required: bool = False,
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, option_strings: Sequence[str], dest: str, default: Any = None, required: bool = False, help: str | None = None
+        ) -> None: ...
 
 # undocumented
 class _HelpAction(Action):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str = "==SUPPRESS==", default: str = "==SUPPRESS==", help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+        ) -> None: ...
 
 # undocumented
 class _VersionAction(Action):
     version: str | None
-    def __init__(
-        self,
-        option_strings: Sequence[str],
-        version: str | None = None,
-        dest: str = "==SUPPRESS==",
-        default: str = "==SUPPRESS==",
-        help: str = "show program's version number and exit",
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            version: str | None = None,
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            version: str | None = None,
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            version: str | None = None,
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str = "show program's version number and exit",
+        ) -> None: ...
 
 # undocumented
 class _SubParsersAction(Action, Generic[_ArgumentParserT]):
@@ -476,7 +691,31 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
 
     # Note: `add_parser` accepts all kwargs of `ArgumentParser.__init__`. It also
     # accepts its own `help` and `aliases` kwargs.
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 13):
+        def add_parser(
+            self,
+            name: str,
+            *,
+            deprecated: bool = False,
+            help: str | None = ...,
+            aliases: Sequence[str] = ...,
+            # Kwargs from ArgumentParser constructor
+            prog: str | None = ...,
+            usage: str | None = ...,
+            description: str | None = ...,
+            epilog: str | None = ...,
+            parents: Sequence[_ArgumentParserT] = ...,
+            formatter_class: _FormatterClass = ...,
+            prefix_chars: str = ...,
+            fromfile_prefix_chars: str | None = ...,
+            argument_default: Any = ...,
+            conflict_handler: str = ...,
+            add_help: bool = ...,
+            allow_abbrev: bool = ...,
+            exit_on_error: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
+        ) -> _ArgumentParserT: ...
+    elif sys.version_info >= (3, 9):
         def add_parser(
             self,
             name: str,
@@ -497,6 +736,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             add_help: bool = ...,
             allow_abbrev: bool = ...,
             exit_on_error: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
     else:
         def add_parser(
@@ -518,6 +758,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             conflict_handler: str = ...,
             add_help: bool = ...,
             allow_abbrev: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
 
     def _get_subactions(self) -> list[Action]: ...
diff --git a/mypy/typeshed/stdlib/array.pyi b/mypy/typeshed/stdlib/array.pyi
index 8b003503bc9b..19ec8c1e78f9 100644
--- a/mypy/typeshed/stdlib/array.pyi
+++ b/mypy/typeshed/stdlib/array.pyi
@@ -3,8 +3,11 @@ from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
 from collections.abc import Iterable
 
 # pytype crashes if array inherits from collections.abc.MutableSequence instead of typing.MutableSequence
-from typing import Any, Generic, MutableSequence, TypeVar, overload  # noqa: Y022
-from typing_extensions import Literal, Self, SupportsIndex, TypeAlias
+from typing import Any, ClassVar, Literal, MutableSequence, SupportsIndex, TypeVar, overload  # noqa: Y022
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 12):
+    from types import GenericAlias
 
 _IntTypeCode: TypeAlias = Literal["b", "B", "h", "H", "i", "I", "l", "L", "q", "Q"]
 _FloatTypeCode: TypeAlias = Literal["f", "d"]
@@ -15,72 +18,78 @@ _T = TypeVar("_T", int, float, str)
 
 typecodes: str
 
-class array(MutableSequence[_T], Generic[_T]):
+class array(MutableSequence[_T]):
     @property
     def typecode(self) -> _TypeCode: ...
     @property
     def itemsize(self) -> int: ...
     @overload
-    def __init__(self: array[int], __typecode: _IntTypeCode, __initializer: bytes | bytearray | Iterable[int] = ...) -> None: ...
+    def __new__(
+        cls: type[array[int]], typecode: _IntTypeCode, initializer: bytes | bytearray | Iterable[int] = ..., /
+    ) -> array[int]: ...
     @overload
-    def __init__(
-        self: array[float], __typecode: _FloatTypeCode, __initializer: bytes | bytearray | Iterable[float] = ...
-    ) -> None: ...
+    def __new__(
+        cls: type[array[float]], typecode: _FloatTypeCode, initializer: bytes | bytearray | Iterable[float] = ..., /
+    ) -> array[float]: ...
     @overload
-    def __init__(
-        self: array[str], __typecode: _UnicodeTypeCode, __initializer: bytes | bytearray | Iterable[str] = ...
-    ) -> None: ...
+    def __new__(
+        cls: type[array[str]], typecode: _UnicodeTypeCode, initializer: bytes | bytearray | Iterable[str] = ..., /
+    ) -> array[str]: ...
     @overload
-    def __init__(self, __typecode: str, __initializer: Iterable[_T]) -> None: ...
+    def __new__(cls, typecode: str, initializer: Iterable[_T], /) -> Self: ...
     @overload
-    def __init__(self, __typecode: str, __initializer: bytes | bytearray = ...) -> None: ...
-    def append(self, __v: _T) -> None: ...
+    def __new__(cls, typecode: str, initializer: bytes | bytearray = ..., /) -> Self: ...
+    def append(self, v: _T, /) -> None: ...
     def buffer_info(self) -> tuple[int, int]: ...
     def byteswap(self) -> None: ...
-    def count(self, __v: _T) -> int: ...
-    def extend(self, __bb: Iterable[_T]) -> None: ...
-    def frombytes(self, __buffer: ReadableBuffer) -> None: ...
-    def fromfile(self, __f: SupportsRead[bytes], __n: int) -> None: ...
-    def fromlist(self, __list: list[_T]) -> None: ...
-    def fromunicode(self, __ustr: str) -> None: ...
+    def count(self, v: _T, /) -> int: ...
+    def extend(self, bb: Iterable[_T], /) -> None: ...
+    def frombytes(self, buffer: ReadableBuffer, /) -> None: ...
+    def fromfile(self, f: SupportsRead[bytes], n: int, /) -> None: ...
+    def fromlist(self, list: list[_T], /) -> None: ...
+    def fromunicode(self, ustr: str, /) -> None: ...
     if sys.version_info >= (3, 10):
-        def index(self, __v: _T, __start: int = 0, __stop: int = sys.maxsize) -> int: ...
+        def index(self, v: _T, start: int = 0, stop: int = sys.maxsize, /) -> int: ...
     else:
-        def index(self, __v: _T) -> int: ...  # type: ignore[override]
+        def index(self, v: _T, /) -> int: ...  # type: ignore[override]
 
-    def insert(self, __i: int, __v: _T) -> None: ...
-    def pop(self, __i: int = -1) -> _T: ...
-    def remove(self, __v: _T) -> None: ...
+    def insert(self, i: int, v: _T, /) -> None: ...
+    def pop(self, i: int = -1, /) -> _T: ...
+    def remove(self, v: _T, /) -> None: ...
     def tobytes(self) -> bytes: ...
-    def tofile(self, __f: SupportsWrite[bytes]) -> None: ...
+    def tofile(self, f: SupportsWrite[bytes], /) -> None: ...
     def tolist(self) -> list[_T]: ...
     def tounicode(self) -> str: ...
     if sys.version_info < (3, 9):
-        def fromstring(self, __buffer: str | ReadableBuffer) -> None: ...
+        def fromstring(self, buffer: str | ReadableBuffer, /) -> None: ...
         def tostring(self) -> bytes: ...
 
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __len__(self) -> int: ...
     @overload
-    def __getitem__(self, __key: SupportsIndex) -> _T: ...
+    def __getitem__(self, key: SupportsIndex, /) -> _T: ...
     @overload
-    def __getitem__(self, __key: slice) -> array[_T]: ...
+    def __getitem__(self, key: slice, /) -> array[_T]: ...
     @overload  # type: ignore[override]
-    def __setitem__(self, __key: SupportsIndex, __value: _T) -> None: ...
+    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...
     @overload
-    def __setitem__(self, __key: slice, __value: array[_T]) -> None: ...
-    def __delitem__(self, __key: SupportsIndex | slice) -> None: ...
-    def __add__(self, __value: array[_T]) -> array[_T]: ...
-    def __ge__(self, __value: array[_T]) -> bool: ...
-    def __gt__(self, __value: array[_T]) -> bool: ...
-    def __iadd__(self, __value: array[_T]) -> Self: ...  # type: ignore[override]
-    def __imul__(self, __value: int) -> Self: ...
-    def __le__(self, __value: array[_T]) -> bool: ...
-    def __lt__(self, __value: array[_T]) -> bool: ...
-    def __mul__(self, __value: int) -> array[_T]: ...
-    def __rmul__(self, __value: int) -> array[_T]: ...
+    def __setitem__(self, key: slice, value: array[_T], /) -> None: ...
+    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
+    def __add__(self, value: array[_T], /) -> array[_T]: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ge__(self, value: array[_T], /) -> bool: ...
+    def __gt__(self, value: array[_T], /) -> bool: ...
+    def __iadd__(self, value: array[_T], /) -> Self: ...  # type: ignore[override]
+    def __imul__(self, value: int, /) -> Self: ...
+    def __le__(self, value: array[_T], /) -> bool: ...
+    def __lt__(self, value: array[_T], /) -> bool: ...
+    def __mul__(self, value: int, /) -> array[_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: ...
+    def __deepcopy__(self, unused: Any, /) -> array[_T]: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 ArrayType = array
diff --git a/mypy/typeshed/stdlib/ast.pyi b/mypy/typeshed/stdlib/ast.pyi
index ea899e150f97..7a4438a33fbc 100644
--- a/mypy/typeshed/stdlib/ast.pyi
+++ b/mypy/typeshed/stdlib/ast.pyi
@@ -1,40 +1,1918 @@
 import os
 import sys
-from _ast import *
+import typing_extensions
+from _ast import (
+    PyCF_ALLOW_TOP_LEVEL_AWAIT as PyCF_ALLOW_TOP_LEVEL_AWAIT,
+    PyCF_ONLY_AST as PyCF_ONLY_AST,
+    PyCF_TYPE_COMMENTS as PyCF_TYPE_COMMENTS,
+)
 from _typeshed import ReadableBuffer, Unused
-from collections.abc import Iterator
-from typing import Any, TypeVar, overload
-from typing_extensions import Literal
+from collections.abc import Iterable, Iterator
+from typing import Any, ClassVar, Generic, Literal, TypedDict, TypeVar as _TypeVar, overload
+from typing_extensions import Self, Unpack, deprecated
 
-if sys.version_info >= (3, 8):
-    class _ABC(type):
-        if sys.version_info >= (3, 9):
-            def __init__(cls, *args: Unused) -> None: ...
+if sys.version_info >= (3, 13):
+    from _ast import PyCF_OPTIMIZED_AST as PyCF_OPTIMIZED_AST
 
+# Alias used for fields that must always be valid identifiers
+# A string `x` counts as a valid identifier if both the following are True
+# (1) `x.isidentifier()` evaluates to `True`
+# (2) `keyword.iskeyword(x)` evaluates to `False`
+_Identifier: typing_extensions.TypeAlias = str
+
+# Used for node end positions in constructor keyword arguments
+_EndPositionT = typing_extensions.TypeVar("_EndPositionT", int, int | None, default=int | None)
+
+# Corresponds to the names in the `_attributes` class variable which is non-empty in certain AST nodes
+class _Attributes(TypedDict, Generic[_EndPositionT], total=False):
+    lineno: int
+    col_offset: int
+    end_lineno: _EndPositionT
+    end_col_offset: _EndPositionT
+
+# The various AST classes are implemented in C, and imported from _ast at runtime,
+# but they consider themselves to live in the ast module,
+# so we'll define the stubs in this file.
+class AST:
+    if sys.version_info >= (3, 10):
+        __match_args__ = ()
+    _attributes: ClassVar[tuple[str, ...]]
+    _fields: ClassVar[tuple[str, ...]]
+    if sys.version_info >= (3, 13):
+        _field_types: ClassVar[dict[str, Any]]
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self) -> Self: ...
+
+class mod(AST): ...
+
+class Module(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body", "type_ignores")
+    body: list[stmt]
+    type_ignores: list[TypeIgnore]
+    if sys.version_info >= (3, 13):
+        def __init__(self, body: list[stmt] = ..., type_ignores: list[TypeIgnore] = ...) -> None: ...
+    else:
+        def __init__(self, body: list[stmt], type_ignores: list[TypeIgnore]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, body: list[stmt] = ..., type_ignores: list[TypeIgnore] = ...) -> Self: ...
+
+class Interactive(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body",)
+    body: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(self, body: list[stmt] = ...) -> None: ...
+    else:
+        def __init__(self, body: list[stmt]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, body: list[stmt] = ...) -> Self: ...
+
+class Expression(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body",)
+    body: expr
+    def __init__(self, body: expr) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, body: expr = ...) -> Self: ...
+
+class FunctionType(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("argtypes", "returns")
+    argtypes: list[expr]
+    returns: expr
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
+        @overload
+        def __init__(self, argtypes: list[expr] = ..., *, returns: expr) -> None: ...
+    else:
+        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, argtypes: list[expr] = ..., returns: expr = ...) -> Self: ...
+
+class stmt(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class FunctionDef(stmt):
+    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
+    type_comment: str | None
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            type_params: list[type_param] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    elif sys.version_info >= (3, 12):
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None,
+            type_comment: str | None,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            *,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            name: _Identifier = ...,
+            args: arguments = ...,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            returns: expr | None = ...,
+            type_comment: str | None = ...,
+            type_params: list[type_param] = ...,
+        ) -> Self: ...
+
+class AsyncFunctionDef(stmt):
+    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
+    type_comment: str | None
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            type_params: list[type_param] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    elif sys.version_info >= (3, 12):
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None,
+            type_comment: str | None,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            *,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            name: _Identifier = ...,
+            args: arguments = ...,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None,
+            type_comment: str | None,
+            type_params: list[type_param],
+        ) -> Self: ...
+
+class ClassDef(stmt):
+    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]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            name: _Identifier,
+            bases: list[expr] = ...,
+            keywords: list[keyword] = ...,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            type_params: list[type_param] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    elif sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            name: _Identifier,
+            bases: list[expr],
+            keywords: list[keyword],
+            body: list[stmt],
+            decorator_list: list[expr],
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: _Identifier,
+            bases: list[expr],
+            keywords: list[keyword],
+            body: list[stmt],
+            decorator_list: list[expr],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            name: _Identifier,
+            bases: list[expr],
+            keywords: list[keyword],
+            body: list[stmt],
+            decorator_list: list[expr],
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class Return(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr | None
+    def __init__(self, value: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Delete(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("targets",)
+    targets: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, targets: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, targets: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, targets: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Assign(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("targets", "value", "type_comment")
+    targets: list[expr]
+    value: expr
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(
+            self, targets: list[expr], value: expr, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+        @overload
+        def __init__(
+            self, targets: list[expr] = ..., *, value: expr, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(
+            self, targets: list[expr], value: expr, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, targets: list[expr] = ..., value: expr = ..., type_comment: str | None = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+if sys.version_info >= (3, 12):
+    class TypeAlias(stmt):
+        __match_args__ = ("name", "type_params", "value")
+        name: Name
+        type_params: list[type_param]
+        value: expr
+        if sys.version_info >= (3, 13):
+            @overload
+            def __init__(
+                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+            @overload
+            def __init__(
+                self, name: Name, type_params: list[type_param] = ..., *, value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+        else:
+            def __init__(
+                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                name: Name = ...,
+                type_params: list[type_param] = ...,
+                value: expr = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
+class AugAssign(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "op", "value")
+    target: Name | Attribute | Subscript
+    op: operator
+    value: expr
+    def __init__(
+        self, target: Name | Attribute | Subscript, op: operator, value: expr, **kwargs: Unpack[_Attributes]
+    ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: Name | Attribute | Subscript = ...,
+            op: operator = ...,
+            value: expr = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class AnnAssign(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "annotation", "value", "simple")
+    target: Name | Attribute | Subscript
+    annotation: expr
+    value: expr | None
+    simple: int
+    @overload
+    def __init__(
+        self,
+        target: Name | Attribute | Subscript,
+        annotation: expr,
+        value: expr | None,
+        simple: int,
+        **kwargs: Unpack[_Attributes],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        target: Name | Attribute | Subscript,
+        annotation: expr,
+        value: expr | None = None,
+        *,
+        simple: int,
+        **kwargs: Unpack[_Attributes],
+    ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: Name | Attribute | Subscript = ...,
+            annotation: expr = ...,
+            value: expr | None = ...,
+            simple: int = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class For(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
+    target: expr
+    iter: expr
+    body: list[stmt]
+    orelse: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt],
+            orelse: list[stmt],
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: expr = ...,
+            iter: expr = ...,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class AsyncFor(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "iter", "body", "orelse", "type_comment")
+    target: expr
+    iter: expr
+    body: list[stmt]
+    orelse: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt],
+            orelse: list[stmt],
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            target: expr = ...,
+            iter: expr = ...,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class While(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "body", "orelse")
+    test: expr
+    body: list[stmt]
+    orelse: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, test: expr, body: list[stmt] = ..., orelse: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class If(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "body", "orelse")
+    test: expr
+    body: list[stmt]
+    orelse: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, test: expr, body: list[stmt] = ..., orelse: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, test: expr = ..., body: list[stmt] = ..., orelse: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class With(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("items", "body", "type_comment")
+    items: list[withitem]
+    body: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self, items: list[withitem], body: list[stmt], type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class AsyncWith(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("items", "body", "type_comment")
+    items: list[withitem]
+    body: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self, items: list[withitem], body: list[stmt], type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+if sys.version_info >= (3, 10):
+    class Match(stmt):
+        __match_args__ = ("subject", "cases")
+        subject: expr
+        cases: list[match_case]
+        if sys.version_info >= (3, 13):
+            def __init__(self, subject: expr, cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+        else:
+            def __init__(self, subject: expr, cases: list[match_case], **kwargs: Unpack[_Attributes]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, subject: expr = ..., cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]
+            ) -> Self: ...
+
+class Raise(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("exc", "cause")
+    exc: expr | None
+    cause: expr | None
+    def __init__(self, exc: expr | None = None, cause: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, exc: expr | None = ..., cause: expr | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Try(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("body", "handlers", "orelse", "finalbody")
+    body: list[stmt]
+    handlers: list[ExceptHandler]
+    orelse: list[stmt]
+    finalbody: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            body: list[stmt] = ...,
+            handlers: list[ExceptHandler] = ...,
+            orelse: list[stmt] = ...,
+            finalbody: list[stmt] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            body: list[stmt],
+            handlers: list[ExceptHandler],
+            orelse: list[stmt],
+            finalbody: list[stmt],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            body: list[stmt] = ...,
+            handlers: list[ExceptHandler] = ...,
+            orelse: list[stmt] = ...,
+            finalbody: list[stmt] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+if sys.version_info >= (3, 11):
+    class TryStar(stmt):
+        __match_args__ = ("body", "handlers", "orelse", "finalbody")
+        body: list[stmt]
+        handlers: list[ExceptHandler]
+        orelse: list[stmt]
+        finalbody: list[stmt]
+        if sys.version_info >= (3, 13):
+            def __init__(
+                self,
+                body: list[stmt] = ...,
+                handlers: list[ExceptHandler] = ...,
+                orelse: list[stmt] = ...,
+                finalbody: list[stmt] = ...,
+                **kwargs: Unpack[_Attributes],
+            ) -> None: ...
+        else:
+            def __init__(
+                self,
+                body: list[stmt],
+                handlers: list[ExceptHandler],
+                orelse: list[stmt],
+                finalbody: list[stmt],
+                **kwargs: Unpack[_Attributes],
+            ) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                body: list[stmt] = ...,
+                handlers: list[ExceptHandler] = ...,
+                orelse: list[stmt] = ...,
+                finalbody: list[stmt] = ...,
+                **kwargs: Unpack[_Attributes],
+            ) -> Self: ...
+
+class Assert(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "msg")
+    test: expr
+    msg: expr | None
+    def __init__(self, test: expr, msg: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, test: expr, msg: expr | None, **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Import(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("names",)
+    names: list[alias]
+    if sys.version_info >= (3, 13):
+        def __init__(self, names: list[alias] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, names: list[alias], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, names: list[alias] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class ImportFrom(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("module", "names", "level")
+    module: str | None
+    names: list[alias]
+    level: int
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(self, module: str | None, names: list[alias], level: int, **kwargs: Unpack[_Attributes]) -> None: ...
+        @overload
+        def __init__(
+            self, module: str | None = None, names: list[alias] = ..., *, level: int, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(self, module: str | None, names: list[alias], level: int, **kwargs: Unpack[_Attributes]) -> None: ...
+        @overload
+        def __init__(
+            self, module: str | None = None, *, names: list[alias], level: int, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, module: str | None = ..., names: list[alias] = ..., level: int = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class Global(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("names",)
+    names: list[_Identifier]
+    if sys.version_info >= (3, 13):
+        def __init__(self, names: list[_Identifier] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Nonlocal(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("names",)
+    names: list[_Identifier]
+    if sys.version_info >= (3, 13):
+        def __init__(self, names: list[_Identifier] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, names: list[_Identifier] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Expr(stmt):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr
+    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Pass(stmt): ...
+class Break(stmt): ...
+class Continue(stmt): ...
+
+class expr(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class BoolOp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("op", "values")
+    op: boolop
+    values: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, op: boolop, values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, op: boolop, values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, op: boolop = ..., values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class NamedExpr(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "value")
+    target: Name
+    value: expr
+    def __init__(self, target: Name, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, target: Name = ..., value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class BinOp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("left", "op", "right")
+    left: expr
+    op: operator
+    right: expr
+    def __init__(self, left: expr, op: operator, right: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, left: expr = ..., op: operator = ..., right: expr = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class UnaryOp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("op", "operand")
+    op: unaryop
+    operand: expr
+    def __init__(self, op: unaryop, operand: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, op: unaryop = ..., operand: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Lambda(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("args", "body")
+    args: arguments
+    body: expr
+    def __init__(self, args: arguments, body: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, args: arguments = ..., body: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class IfExp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("test", "body", "orelse")
+    test: expr
+    body: expr
+    orelse: expr
+    def __init__(self, test: expr, body: expr, orelse: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, test: expr = ..., body: expr = ..., orelse: expr = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class Dict(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("keys", "values")
+    keys: list[expr | None]
+    values: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, keys: list[expr | None] = ..., values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, keys: list[expr | None], values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, keys: list[expr | None] = ..., values: list[expr] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class Set(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elts",)
+    elts: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elts: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elts: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, elts: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class ListComp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elt", "generators")
+    elt: expr
+    generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elt: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, elt: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class SetComp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elt", "generators")
+    elt: expr
+    generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elt: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, elt: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class DictComp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("key", "value", "generators")
+    key: expr
+    value: expr
+    generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, key: expr, value: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, key: expr, value: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, key: expr = ..., value: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class GeneratorExp(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elt", "generators")
+    elt: expr
+    generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elt: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, elt: expr = ..., generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class Await(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr
+    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Yield(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr | None
+    def __init__(self, value: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class YieldFrom(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value",)
+    value: expr
+    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Compare(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("left", "ops", "comparators")
+    left: expr
+    ops: list[cmpop]
+    comparators: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, left: expr, ops: list[cmpop] = ..., comparators: list[expr] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, left: expr, ops: list[cmpop], comparators: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, left: expr = ..., ops: list[cmpop] = ..., comparators: list[expr] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class Call(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("func", "args", "keywords")
+    func: expr
+    args: list[expr]
+    keywords: list[keyword]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, func: expr, args: list[expr] = ..., keywords: list[keyword] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, func: expr, args: list[expr], keywords: list[keyword], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, func: expr = ..., args: list[expr] = ..., keywords: list[keyword] = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class FormattedValue(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "conversion", "format_spec")
+    value: expr
+    conversion: int
+    format_spec: expr | None
+    def __init__(self, value: expr, conversion: int, format_spec: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, value: expr = ..., conversion: int = ..., format_spec: expr | None = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class JoinedStr(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("values",)
+    values: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Constant(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "kind")
+    value: Any  # None, str, bytes, bool, int, float, complex, Ellipsis
+    kind: str | None
+    if sys.version_info < (3, 14):
+        # Aliases for value, for backwards compatibility
+        s: Any
+        n: int | float | complex
+
+    def __init__(self, value: Any, kind: str | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: Any = ..., kind: str | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Attribute(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "attr", "ctx")
+    value: expr
+    attr: _Identifier
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, value: expr, attr: _Identifier, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, value: expr = ..., attr: _Identifier = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class Subscript(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "slice", "ctx")
+    value: expr
+    slice: _Slice
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, value: expr, slice: _Slice, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, value: expr = ..., slice: _Slice = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]
+        ) -> Self: ...
+
+class Starred(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("value", "ctx")
+    value: expr
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, value: expr, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, value: expr = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Name(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("id", "ctx")
+    id: _Identifier
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, id: _Identifier, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, id: _Identifier = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class List(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elts", "ctx")
+    elts: list[expr]
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    if sys.version_info >= (3, 13):
+        def __init__(self, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elts: list[expr], ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class Tuple(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("elts", "ctx")
+    elts: list[expr]
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    if sys.version_info >= (3, 9):
+        dims: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elts: list[expr], ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+@deprecated("Deprecated since Python 3.9.")
+class slice(AST): ...  # deprecated and moved to ast.py for >= (3, 9)
+
+if sys.version_info >= (3, 9):
+    _Slice: typing_extensions.TypeAlias = expr
+    _SliceAttributes: typing_extensions.TypeAlias = _Attributes
+else:
+    # alias for use with variables named slice
+    _Slice: typing_extensions.TypeAlias = slice
+
+    class _SliceAttributes(TypedDict): ...
+
+class Slice(_Slice):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("lower", "upper", "step")
+    lower: expr | None
+    upper: expr | None
+    step: expr | None
+    def __init__(
+        self, lower: expr | None = None, upper: expr | None = None, step: expr | None = None, **kwargs: Unpack[_SliceAttributes]
+    ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            lower: expr | None = ...,
+            upper: expr | None = ...,
+            step: expr | None = ...,
+            **kwargs: Unpack[_SliceAttributes],
+        ) -> Self: ...
+
+@deprecated("Deprecated since Python 3.9. Use ast.Tuple instead.")
+class ExtSlice(slice):  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+    if sys.version_info >= (3, 9):
+        def __new__(cls, dims: Iterable[slice] = (), **kwargs: Unpack[_SliceAttributes]) -> Tuple: ...  # type: ignore[misc]
+    else:
+        dims: list[slice]
+        def __init__(self, dims: list[slice], **kwargs: Unpack[_SliceAttributes]) -> None: ...
+
+@deprecated("Deprecated since Python 3.9. Use the index value directly instead.")
+class Index(slice):  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+    if sys.version_info >= (3, 9):
+        def __new__(cls, value: expr, **kwargs: Unpack[_SliceAttributes]) -> expr: ...  # type: ignore[misc]
+    else:
+        value: expr
+        def __init__(self, value: expr, **kwargs: Unpack[_SliceAttributes]) -> None: ...
+
+class expr_context(AST): ...
+
+@deprecated("Deprecated since Python 3.9. Unused in Python 3.")
+class AugLoad(expr_context): ...  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+
+@deprecated("Deprecated since Python 3.9. Unused in Python 3.")
+class AugStore(expr_context): ...  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+
+@deprecated("Deprecated since Python 3.9. Unused in Python 3.")
+class Param(expr_context): ...  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+
+@deprecated("Deprecated since Python 3.9. Unused in Python 3.")
+class Suite(mod):  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+    if sys.version_info < (3, 9):
+        body: list[stmt]
+        def __init__(self, body: list[stmt]) -> None: ...
+
+class Load(expr_context): ...
+class Store(expr_context): ...
+class Del(expr_context): ...
+class boolop(AST): ...
+class And(boolop): ...
+class Or(boolop): ...
+class operator(AST): ...
+class Add(operator): ...
+class Sub(operator): ...
+class Mult(operator): ...
+class MatMult(operator): ...
+class Div(operator): ...
+class Mod(operator): ...
+class Pow(operator): ...
+class LShift(operator): ...
+class RShift(operator): ...
+class BitOr(operator): ...
+class BitXor(operator): ...
+class BitAnd(operator): ...
+class FloorDiv(operator): ...
+class unaryop(AST): ...
+class Invert(unaryop): ...
+class Not(unaryop): ...
+class UAdd(unaryop): ...
+class USub(unaryop): ...
+class cmpop(AST): ...
+class Eq(cmpop): ...
+class NotEq(cmpop): ...
+class Lt(cmpop): ...
+class LtE(cmpop): ...
+class Gt(cmpop): ...
+class GtE(cmpop): ...
+class Is(cmpop): ...
+class IsNot(cmpop): ...
+class In(cmpop): ...
+class NotIn(cmpop): ...
+
+class comprehension(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "iter", "ifs", "is_async")
+    target: expr
+    iter: expr
+    ifs: list[expr]
+    is_async: int
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(self, target: expr, iter: expr, ifs: list[expr], is_async: int) -> None: ...
+        @overload
+        def __init__(self, target: expr, iter: expr, ifs: list[expr] = ..., *, is_async: int) -> None: ...
+    else:
+        def __init__(self, target: expr, iter: expr, ifs: list[expr], is_async: int) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, target: expr = ..., iter: expr = ..., ifs: list[expr] = ..., is_async: int = ...) -> Self: ...
+
+class excepthandler(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self, *, lineno: int = ..., col_offset: int = ..., end_lineno: int | None = ..., end_col_offset: int | None = ...
+        ) -> Self: ...
+
+class ExceptHandler(excepthandler):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("type", "name", "body")
+    type: expr | None
+    name: _Identifier | None
+    body: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, type: expr | None = None, name: _Identifier | None = None, body: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self, type: expr | None, name: _Identifier | None, body: list[stmt], **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+        @overload
+        def __init__(
+            self, type: expr | None = None, name: _Identifier | None = None, *, body: list[stmt], **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            type: expr | None = ...,
+            name: _Identifier | None = ...,
+            body: list[stmt] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class arguments(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("posonlyargs", "args", "vararg", "kwonlyargs", "kw_defaults", "kwarg", "defaults")
+    posonlyargs: list[arg]
+    args: list[arg]
+    vararg: arg | None
+    kwonlyargs: list[arg]
+    kw_defaults: list[expr | None]
+    kwarg: arg | None
+    defaults: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            posonlyargs: list[arg] = ...,
+            args: list[arg] = ...,
+            vararg: arg | None = None,
+            kwonlyargs: list[arg] = ...,
+            kw_defaults: list[expr | None] = ...,
+            kwarg: arg | None = None,
+            defaults: list[expr] = ...,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            posonlyargs: list[arg],
+            args: list[arg],
+            vararg: arg | None,
+            kwonlyargs: list[arg],
+            kw_defaults: list[expr | None],
+            kwarg: arg | None,
+            defaults: list[expr],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            posonlyargs: list[arg],
+            args: list[arg],
+            vararg: arg | None,
+            kwonlyargs: list[arg],
+            kw_defaults: list[expr | None],
+            kwarg: arg | None = None,
+            *,
+            defaults: list[expr],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            posonlyargs: list[arg],
+            args: list[arg],
+            vararg: arg | None = None,
+            *,
+            kwonlyargs: list[arg],
+            kw_defaults: list[expr | None],
+            kwarg: arg | None = None,
+            defaults: list[expr],
+        ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            posonlyargs: list[arg] = ...,
+            args: list[arg] = ...,
+            vararg: arg | None = ...,
+            kwonlyargs: list[arg] = ...,
+            kw_defaults: list[expr | None] = ...,
+            kwarg: arg | None = ...,
+            defaults: list[expr] = ...,
+        ) -> Self: ...
+
+class arg(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("arg", "annotation", "type_comment")
+    arg: _Identifier
+    annotation: expr | None
+    type_comment: str | None
+    def __init__(
+        self, arg: _Identifier, annotation: expr | None = None, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+    ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            arg: _Identifier = ...,
+            annotation: expr | None = ...,
+            type_comment: str | None = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> Self: ...
+
+class keyword(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("arg", "value")
+    arg: _Identifier | None
+    value: expr
+    @overload
+    def __init__(self, arg: _Identifier | None, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+    @overload
+    def __init__(self, arg: _Identifier | None = None, *, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, arg: _Identifier | None = ..., value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class alias(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("name", "asname")
+    name: str
+    asname: _Identifier | None
+    def __init__(self, name: str, asname: _Identifier | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, name: str = ..., asname: _Identifier | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
+class withitem(AST):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("context_expr", "optional_vars")
+    context_expr: expr
+    optional_vars: expr | None
+    def __init__(self, context_expr: expr, optional_vars: expr | None = None) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, context_expr: expr = ..., optional_vars: expr | None = ...) -> Self: ...
+
+if sys.version_info >= (3, 10):
+    class match_case(AST):
+        __match_args__ = ("pattern", "guard", "body")
+        pattern: _Pattern
+        guard: expr | None
+        body: list[stmt]
+        if sys.version_info >= (3, 13):
+            def __init__(self, pattern: _Pattern, guard: expr | None = None, body: list[stmt] = ...) -> None: ...
+        else:
+            @overload
+            def __init__(self, pattern: _Pattern, guard: expr | None, body: list[stmt]) -> None: ...
+            @overload
+            def __init__(self, pattern: _Pattern, guard: expr | None = None, *, body: list[stmt]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, pattern: _Pattern = ..., guard: expr | None = ..., body: list[stmt] = ...) -> Self: ...
+
+    class pattern(AST):
+        lineno: int
+        col_offset: int
+        end_lineno: int
+        end_col_offset: int
+        def __init__(self, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, lineno: int = ..., col_offset: int = ..., end_lineno: int = ..., end_col_offset: int = ...
+            ) -> Self: ...
+
+    # Without the alias, Pyright complains variables named pattern are recursively defined
+    _Pattern: typing_extensions.TypeAlias = pattern
+
+    class MatchValue(pattern):
+        __match_args__ = ("value",)
+        value: expr
+        def __init__(self, value: expr, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, value: expr = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
+    class MatchSingleton(pattern):
+        __match_args__ = ("value",)
+        value: Literal[True, False] | None
+        def __init__(self, value: Literal[True, False] | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, value: Literal[True, False] | None = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
+    class MatchSequence(pattern):
+        __match_args__ = ("patterns",)
+        patterns: list[pattern]
+        if sys.version_info >= (3, 13):
+            def __init__(self, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> None: ...
+        else:
+            def __init__(self, patterns: list[pattern], **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
+    class MatchMapping(pattern):
+        __match_args__ = ("keys", "patterns", "rest")
+        keys: list[expr]
+        patterns: list[pattern]
+        rest: _Identifier | None
+        if sys.version_info >= (3, 13):
+            def __init__(
+                self,
+                keys: list[expr] = ...,
+                patterns: list[pattern] = ...,
+                rest: _Identifier | None = None,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+        else:
+            def __init__(
+                self,
+                keys: list[expr],
+                patterns: list[pattern],
+                rest: _Identifier | None = None,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                keys: list[expr] = ...,
+                patterns: list[pattern] = ...,
+                rest: _Identifier | None = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
+    class MatchClass(pattern):
+        __match_args__ = ("cls", "patterns", "kwd_attrs", "kwd_patterns")
+        cls: expr
+        patterns: list[pattern]
+        kwd_attrs: list[_Identifier]
+        kwd_patterns: list[pattern]
+        if sys.version_info >= (3, 13):
+            def __init__(
+                self,
+                cls: expr,
+                patterns: list[pattern] = ...,
+                kwd_attrs: list[_Identifier] = ...,
+                kwd_patterns: list[pattern] = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+        else:
+            def __init__(
+                self,
+                cls: expr,
+                patterns: list[pattern],
+                kwd_attrs: list[_Identifier],
+                kwd_patterns: list[pattern],
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                cls: expr = ...,
+                patterns: list[pattern] = ...,
+                kwd_attrs: list[_Identifier] = ...,
+                kwd_patterns: list[pattern] = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
+    class MatchStar(pattern):
+        __match_args__ = ("name",)
+        name: _Identifier | None
+        def __init__(self, name: _Identifier | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, name: _Identifier | None = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
+    class MatchAs(pattern):
+        __match_args__ = ("pattern", "name")
+        pattern: _Pattern | None
+        name: _Identifier | None
+        def __init__(
+            self, pattern: _Pattern | None = None, name: _Identifier | None = None, **kwargs: Unpack[_Attributes[int]]
+        ) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, pattern: _Pattern | None = ..., name: _Identifier | None = ..., **kwargs: Unpack[_Attributes[int]]
+            ) -> Self: ...
+
+    class MatchOr(pattern):
+        __match_args__ = ("patterns",)
+        patterns: list[pattern]
+        if sys.version_info >= (3, 13):
+            def __init__(self, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> None: ...
+        else:
+            def __init__(self, patterns: list[pattern], **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
+class type_ignore(AST): ...
+
+class TypeIgnore(type_ignore):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("lineno", "tag")
+    lineno: int
+    tag: str
+    def __init__(self, lineno: int, tag: str) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, lineno: int = ..., tag: str = ...) -> Self: ...
+
+if sys.version_info >= (3, 12):
+    class type_param(AST):
+        lineno: int
+        col_offset: int
+        end_lineno: int
+        end_col_offset: int
+        def __init__(self, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
+    class TypeVar(type_param):
+        if sys.version_info >= (3, 13):
+            __match_args__ = ("name", "bound", "default_value")
+        else:
+            __match_args__ = ("name", "bound")
+        name: _Identifier
+        bound: expr | None
+        if sys.version_info >= (3, 13):
+            default_value: expr | None
+            def __init__(
+                self,
+                name: _Identifier,
+                bound: expr | None = None,
+                default_value: expr | None = None,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+        else:
+            def __init__(self, name: _Identifier, bound: expr | None = None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                name: _Identifier = ...,
+                bound: expr | None = ...,
+                default_value: expr | None = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
+    class ParamSpec(type_param):
+        if sys.version_info >= (3, 13):
+            __match_args__ = ("name", "default_value")
+        else:
+            __match_args__ = ("name",)
+        name: _Identifier
+        if sys.version_info >= (3, 13):
+            default_value: expr | None
+            def __init__(
+                self, name: _Identifier, default_value: expr | None = None, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+        else:
+            def __init__(self, name: _Identifier, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, name: _Identifier = ..., default_value: expr | None = ..., **kwargs: Unpack[_Attributes[int]]
+            ) -> Self: ...
+
+    class TypeVarTuple(type_param):
+        if sys.version_info >= (3, 13):
+            __match_args__ = ("name", "default_value")
+        else:
+            __match_args__ = ("name",)
+        name: _Identifier
+        if sys.version_info >= (3, 13):
+            default_value: expr | None
+            def __init__(
+                self, name: _Identifier, default_value: expr | None = None, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+        else:
+            def __init__(self, name: _Identifier, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, name: _Identifier = ..., default_value: expr | None = ..., **kwargs: Unpack[_Attributes[int]]
+            ) -> Self: ...
+
+class _ABC(type):
+    if sys.version_info >= (3, 9):
+        def __init__(cls, *args: Unused) -> None: ...
+
+if sys.version_info < (3, 14):
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
     class Num(Constant, metaclass=_ABC):
         value: int | float | complex
 
-    class Str(Constant, metaclass=_ABC):
-        value: str
-        # Aliases for value, for backwards compatibility
-        s: str
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class Str(Constant, metaclass=_ABC):
+        value: str
+        # Aliases for value, for backwards compatibility
+        s: str
+
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class Bytes(Constant, metaclass=_ABC):
+        value: bytes
+        # Aliases for value, for backwards compatibility
+        s: bytes
+
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class NameConstant(Constant, metaclass=_ABC): ...
+
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class Ellipsis(Constant, metaclass=_ABC): ...
+
+# everything below here is defined in ast.py
+
+_T = _TypeVar("_T", bound=AST)
+
+if sys.version_info >= (3, 13):
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: Literal["exec"] = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Module: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["eval"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["func_type"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["single"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["eval"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["func_type"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["single"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: str = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> AST: ...
+
+else:
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: Literal["exec"] = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Module: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["eval"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["func_type"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["single"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["eval"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["func_type"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["single"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: str = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> AST: ...
 
-    class Bytes(Constant, metaclass=_ABC):
-        value: bytes
-        # Aliases for value, for backwards compatibility
-        s: bytes
+def literal_eval(node_or_string: str | AST) -> Any: ...
 
-    class NameConstant(Constant, metaclass=_ABC): ...
-    class Ellipsis(Constant, metaclass=_ABC): ...
+if sys.version_info >= (3, 13):
+    def dump(
+        node: AST,
+        annotate_fields: bool = True,
+        include_attributes: bool = False,
+        *,
+        indent: int | str | None = None,
+        show_empty: bool = False,
+    ) -> str: ...
 
-if sys.version_info >= (3, 9):
-    class slice(AST): ...
-    class ExtSlice(slice): ...
-    class Index(slice): ...
-    class Suite(mod): ...
-    class AugLoad(expr_context): ...
-    class AugStore(expr_context): ...
-    class Param(expr_context): ...
+elif sys.version_info >= (3, 9):
+    def dump(
+        node: AST, annotate_fields: bool = True, include_attributes: bool = False, *, indent: int | str | None = None
+    ) -> str: ...
+
+else:
+    def dump(node: AST, annotate_fields: bool = True, include_attributes: bool = False) -> str: ...
+
+def copy_location(new_node: _T, old_node: AST) -> _T: ...
+def fix_missing_locations(node: _T) -> _T: ...
+def increment_lineno(node: _T, n: int = 1) -> _T: ...
+def iter_fields(node: AST) -> Iterator[tuple[str, Any]]: ...
+def iter_child_nodes(node: AST) -> Iterator[AST]: ...
+def get_docstring(node: AsyncFunctionDef | FunctionDef | ClassDef | Module, clean: bool = True) -> str | None: ...
+def get_source_segment(source: str, node: AST, *, padded: bool = False) -> str | None: ...
+def walk(node: AST) -> Iterator[AST]: ...
+
+if sys.version_info >= (3, 14):
+    def compare(left: AST, right: AST, /, *, compare_attributes: bool = False) -> bool: ...
 
 class NodeVisitor:
     def visit(self, node: AST) -> Any: ...
@@ -87,10 +1965,8 @@ class NodeVisitor:
     def visit_FormattedValue(self, node: FormattedValue) -> Any: ...
     def visit_JoinedStr(self, node: JoinedStr) -> Any: ...
     def visit_Constant(self, node: Constant) -> Any: ...
-    if sys.version_info >= (3, 8):
-        def visit_NamedExpr(self, node: NamedExpr) -> Any: ...
-        def visit_TypeIgnore(self, node: TypeIgnore) -> Any: ...
-
+    def visit_NamedExpr(self, node: NamedExpr) -> Any: ...
+    def visit_TypeIgnore(self, node: TypeIgnore) -> Any: ...
     def visit_Attribute(self, node: Attribute) -> Any: ...
     def visit_Subscript(self, node: Subscript) -> Any: ...
     def visit_Starred(self, node: Starred) -> Any: ...
@@ -138,8 +2014,10 @@ class NodeVisitor:
     def visit_withitem(self, node: withitem) -> Any: ...
     if sys.version_info >= (3, 10):
         def visit_Match(self, node: Match) -> Any: ...
+        def visit_match_case(self, node: match_case) -> Any: ...
         def visit_MatchValue(self, node: MatchValue) -> Any: ...
         def visit_MatchSequence(self, node: MatchSequence) -> Any: ...
+        def visit_MatchSingleton(self, node: MatchSingleton) -> Any: ...
         def visit_MatchStar(self, node: MatchStar) -> Any: ...
         def visit_MatchMapping(self, node: MatchMapping) -> Any: ...
         def visit_MatchClass(self, node: MatchClass) -> Any: ...
@@ -149,6 +2027,12 @@ class NodeVisitor:
     if sys.version_info >= (3, 11):
         def visit_TryStar(self, node: TryStar) -> Any: ...
 
+    if sys.version_info >= (3, 12):
+        def visit_TypeVar(self, node: TypeVar) -> Any: ...
+        def visit_ParamSpec(self, node: ParamSpec) -> Any: ...
+        def visit_TypeVarTuple(self, node: TypeVarTuple) -> Any: ...
+        def visit_TypeAlias(self, node: TypeAlias) -> Any: ...
+
     # visit methods for deprecated nodes
     def visit_ExtSlice(self, node: ExtSlice) -> Any: ...
     def visit_Index(self, node: Index) -> Any: ...
@@ -156,11 +2040,18 @@ class NodeVisitor:
     def visit_AugLoad(self, node: AugLoad) -> Any: ...
     def visit_AugStore(self, node: AugStore) -> Any: ...
     def visit_Param(self, node: Param) -> Any: ...
-    def visit_Num(self, node: Num) -> Any: ...
-    def visit_Str(self, node: Str) -> Any: ...
-    def visit_Bytes(self, node: Bytes) -> Any: ...
-    def visit_NameConstant(self, node: NameConstant) -> Any: ...
-    def visit_Ellipsis(self, node: Ellipsis) -> Any: ...
+
+    if sys.version_info < (3, 14):
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Num(self, node: Num) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Str(self, node: Str) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Bytes(self, node: Bytes) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_NameConstant(self, node: NameConstant) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Ellipsis(self, node: Ellipsis) -> Any: ...  # type: ignore[deprecated]
 
 class NodeTransformer(NodeVisitor):
     def generic_visit(self, node: AST) -> AST: ...
@@ -168,127 +2059,8 @@ 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)
-
-if sys.version_info >= (3, 8):
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
-        mode: Literal["exec"] = "exec",
-        *,
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> Module: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        filename: str | ReadableBuffer | os.PathLike[Any],
-        mode: Literal["eval"],
-        *,
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> Expression: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        filename: str | ReadableBuffer | os.PathLike[Any],
-        mode: Literal["func_type"],
-        *,
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> FunctionType: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        filename: str | ReadableBuffer | os.PathLike[Any],
-        mode: Literal["single"],
-        *,
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> Interactive: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        *,
-        mode: Literal["eval"],
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> Expression: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        *,
-        mode: Literal["func_type"],
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> FunctionType: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        *,
-        mode: Literal["single"],
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> Interactive: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
-        mode: str = "exec",
-        *,
-        type_comments: bool = False,
-        feature_version: None | int | tuple[int, int] = None,
-    ) -> AST: ...
-
-else:
-    @overload
-    def parse(
-        source: str | ReadableBuffer,
-        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
-        mode: Literal["exec"] = "exec",
-    ) -> Module: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer, filename: str | ReadableBuffer | os.PathLike[Any], mode: Literal["eval"]
-    ) -> Expression: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer, filename: str | ReadableBuffer | os.PathLike[Any], mode: Literal["single"]
-    ) -> Interactive: ...
-    @overload
-    def parse(source: str | ReadableBuffer, *, mode: Literal["eval"]) -> Expression: ...
-    @overload
-    def parse(source: str | ReadableBuffer, *, mode: Literal["single"]) -> Interactive: ...
-    @overload
-    def parse(
-        source: str | ReadableBuffer, filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>", mode: str = "exec"
-    ) -> AST: ...
-
 if sys.version_info >= (3, 9):
     def unparse(ast_obj: AST) -> str: ...
 
-def copy_location(new_node: _T, old_node: AST) -> _T: ...
-
-if sys.version_info >= (3, 9):
-    def dump(
-        node: AST, annotate_fields: bool = True, include_attributes: bool = False, *, indent: int | str | None = None
-    ) -> str: ...
-
-else:
-    def dump(node: AST, annotate_fields: bool = True, include_attributes: bool = False) -> str: ...
-
-def fix_missing_locations(node: _T) -> _T: ...
-def get_docstring(node: AsyncFunctionDef | FunctionDef | ClassDef | Module, clean: bool = True) -> str | None: ...
-def increment_lineno(node: _T, n: int = 1) -> _T: ...
-def iter_child_nodes(node: AST) -> Iterator[AST]: ...
-def iter_fields(node: AST) -> Iterator[tuple[str, Any]]: ...
-def literal_eval(node_or_string: str | AST) -> Any: ...
-
-if sys.version_info >= (3, 8):
-    def get_source_segment(source: str, node: AST, *, padded: bool = False) -> str | None: ...
-
-def walk(node: AST) -> Iterator[AST]: ...
-
 if sys.version_info >= (3, 9):
     def main() -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/__init__.pyi b/mypy/typeshed/stdlib/asyncio/__init__.pyi
index 2ce066cac982..e47f640a1f9b 100644
--- a/mypy/typeshed/stdlib/asyncio/__init__.pyi
+++ b/mypy/typeshed/stdlib/asyncio/__init__.pyi
@@ -1,3 +1,5 @@
+# ruff: noqa: PLR5501 # This condition is so big, it's clearer to keep to platform condition in two blocks
+# Can't NOQA on a specific line: https://github.com/plinss/flake8-noqa/issues/22
 import sys
 from collections.abc import Awaitable, Coroutine, Generator
 from typing import Any, TypeVar
@@ -7,6 +9,7 @@ from typing_extensions import TypeAlias
 from .base_events import *
 from .coroutines import *
 from .events import *
+from .exceptions import *
 from .futures import *
 from .locks import *
 from .protocols import *
@@ -17,9 +20,6 @@ from .subprocess import *
 from .tasks import *
 from .transports import *
 
-if sys.version_info >= (3, 8):
-    from .exceptions import *
-
 if sys.version_info >= (3, 9):
     from .threads import *
 
@@ -32,12 +32,1134 @@ if sys.platform == "win32":
 else:
     from .unix_events import *
 
-_T = TypeVar("_T")
+if sys.platform == "win32":
+    if sys.version_info >= (3, 14):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "QueueShutDown",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "create_eager_task_factory",  # from tasks
+            "eager_task_factory",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "TaskGroup",  # from taskgroups
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from windows_events
+            "ProactorEventLoop",  # from windows_events
+            "IocpProactor",  # from windows_events
+            "DefaultEventLoopPolicy",  # from windows_events
+            "WindowsSelectorEventLoopPolicy",  # from windows_events
+            "WindowsProactorEventLoopPolicy",  # from windows_events
+            "EventLoop",  # from windows_events
+        )
+    elif sys.version_info >= (3, 13):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "QueueShutDown",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "create_eager_task_factory",  # from tasks
+            "eager_task_factory",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "TaskGroup",  # from taskgroups
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from windows_events
+            "ProactorEventLoop",  # from windows_events
+            "IocpProactor",  # from windows_events
+            "DefaultEventLoopPolicy",  # from windows_events
+            "WindowsSelectorEventLoopPolicy",  # from windows_events
+            "WindowsProactorEventLoopPolicy",  # from windows_events
+            "EventLoop",  # from windows_events
+        )
+    elif sys.version_info >= (3, 12):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "create_eager_task_factory",  # from tasks
+            "eager_task_factory",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "TaskGroup",  # from taskgroups
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from windows_events
+            "ProactorEventLoop",  # from windows_events
+            "IocpProactor",  # from windows_events
+            "DefaultEventLoopPolicy",  # from windows_events
+            "WindowsSelectorEventLoopPolicy",  # from windows_events
+            "WindowsProactorEventLoopPolicy",  # from windows_events
+        )
+    elif sys.version_info >= (3, 11):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from windows_events
+            "ProactorEventLoop",  # from windows_events
+            "IocpProactor",  # from windows_events
+            "DefaultEventLoopPolicy",  # from windows_events
+            "WindowsSelectorEventLoopPolicy",  # from windows_events
+            "WindowsProactorEventLoopPolicy",  # from windows_events
+        )
+    elif sys.version_info >= (3, 9):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "coroutine",  # from coroutines
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "to_thread",  # from threads
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from windows_events
+            "ProactorEventLoop",  # from windows_events
+            "IocpProactor",  # from windows_events
+            "DefaultEventLoopPolicy",  # from windows_events
+            "WindowsSelectorEventLoopPolicy",  # from windows_events
+            "WindowsProactorEventLoopPolicy",  # from windows_events
+        )
+    else:
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "coroutine",  # from coroutines
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from windows_events
+            "ProactorEventLoop",  # from windows_events
+            "IocpProactor",  # from windows_events
+            "DefaultEventLoopPolicy",  # from windows_events
+            "WindowsSelectorEventLoopPolicy",  # from windows_events
+            "WindowsProactorEventLoopPolicy",  # from windows_events
+        )
+else:
+    if sys.version_info >= (3, 14):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "QueueShutDown",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "open_unix_connection",  # from streams
+            "start_unix_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "create_eager_task_factory",  # from tasks
+            "eager_task_factory",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "TaskGroup",  # from taskgroups
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from unix_events
+            "DefaultEventLoopPolicy",  # from unix_events
+            "EventLoop",  # from unix_events
+        )
+    elif sys.version_info >= (3, 13):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "QueueShutDown",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "open_unix_connection",  # from streams
+            "start_unix_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "create_eager_task_factory",  # from tasks
+            "eager_task_factory",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "TaskGroup",  # from taskgroups
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from unix_events
+            "AbstractChildWatcher",  # from unix_events
+            "SafeChildWatcher",  # from unix_events
+            "FastChildWatcher",  # from unix_events
+            "PidfdChildWatcher",  # from unix_events
+            "MultiLoopChildWatcher",  # from unix_events
+            "ThreadedChildWatcher",  # from unix_events
+            "DefaultEventLoopPolicy",  # from unix_events
+            "EventLoop",  # from unix_events
+        )
+    elif sys.version_info >= (3, 12):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "open_unix_connection",  # from streams
+            "start_unix_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "create_eager_task_factory",  # from tasks
+            "eager_task_factory",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "TaskGroup",  # from taskgroups
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from unix_events
+            "AbstractChildWatcher",  # from unix_events
+            "SafeChildWatcher",  # from unix_events
+            "FastChildWatcher",  # from unix_events
+            "PidfdChildWatcher",  # from unix_events
+            "MultiLoopChildWatcher",  # from unix_events
+            "ThreadedChildWatcher",  # from unix_events
+            "DefaultEventLoopPolicy",  # from unix_events
+        )
+    elif sys.version_info >= (3, 11):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "BrokenBarrierError",  # from exceptions
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "Barrier",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "Runner",  # from runners
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "open_unix_connection",  # from streams
+            "start_unix_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "to_thread",  # from threads
+            "Timeout",  # from timeouts
+            "timeout",  # from timeouts
+            "timeout_at",  # from timeouts
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from unix_events
+            "AbstractChildWatcher",  # from unix_events
+            "SafeChildWatcher",  # from unix_events
+            "FastChildWatcher",  # from unix_events
+            "PidfdChildWatcher",  # from unix_events
+            "MultiLoopChildWatcher",  # from unix_events
+            "ThreadedChildWatcher",  # from unix_events
+            "DefaultEventLoopPolicy",  # from unix_events
+        )
+    elif sys.version_info >= (3, 9):
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "Server",  # from base_events
+            "coroutine",  # from coroutines
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "open_unix_connection",  # from streams
+            "start_unix_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "to_thread",  # from threads
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from unix_events
+            "AbstractChildWatcher",  # from unix_events
+            "SafeChildWatcher",  # from unix_events
+            "FastChildWatcher",  # from unix_events
+            "PidfdChildWatcher",  # from unix_events
+            "MultiLoopChildWatcher",  # from unix_events
+            "ThreadedChildWatcher",  # from unix_events
+            "DefaultEventLoopPolicy",  # from unix_events
+        )
+    else:
+        __all__ = (
+            "BaseEventLoop",  # from base_events
+            "coroutine",  # from coroutines
+            "iscoroutinefunction",  # from coroutines
+            "iscoroutine",  # from coroutines
+            "AbstractEventLoopPolicy",  # from events
+            "AbstractEventLoop",  # from events
+            "AbstractServer",  # from events
+            "Handle",  # from events
+            "TimerHandle",  # from events
+            "get_event_loop_policy",  # from events
+            "set_event_loop_policy",  # from events
+            "get_event_loop",  # from events
+            "set_event_loop",  # from events
+            "new_event_loop",  # from events
+            "get_child_watcher",  # from events
+            "set_child_watcher",  # from events
+            "_set_running_loop",  # from events
+            "get_running_loop",  # from events
+            "_get_running_loop",  # from events
+            "CancelledError",  # from exceptions
+            "InvalidStateError",  # from exceptions
+            "TimeoutError",  # from exceptions
+            "IncompleteReadError",  # from exceptions
+            "LimitOverrunError",  # from exceptions
+            "SendfileNotAvailableError",  # from exceptions
+            "Future",  # from futures
+            "wrap_future",  # from futures
+            "isfuture",  # from futures
+            "Lock",  # from locks
+            "Event",  # from locks
+            "Condition",  # from locks
+            "Semaphore",  # from locks
+            "BoundedSemaphore",  # from locks
+            "BaseProtocol",  # from protocols
+            "Protocol",  # from protocols
+            "DatagramProtocol",  # from protocols
+            "SubprocessProtocol",  # from protocols
+            "BufferedProtocol",  # from protocols
+            "run",  # from runners
+            "Queue",  # from queues
+            "PriorityQueue",  # from queues
+            "LifoQueue",  # from queues
+            "QueueFull",  # from queues
+            "QueueEmpty",  # from queues
+            "StreamReader",  # from streams
+            "StreamWriter",  # from streams
+            "StreamReaderProtocol",  # from streams
+            "open_connection",  # from streams
+            "start_server",  # from streams
+            "open_unix_connection",  # from streams
+            "start_unix_server",  # from streams
+            "create_subprocess_exec",  # from subprocess
+            "create_subprocess_shell",  # from subprocess
+            "Task",  # from tasks
+            "create_task",  # from tasks
+            "FIRST_COMPLETED",  # from tasks
+            "FIRST_EXCEPTION",  # from tasks
+            "ALL_COMPLETED",  # from tasks
+            "wait",  # from tasks
+            "wait_for",  # from tasks
+            "as_completed",  # from tasks
+            "sleep",  # from tasks
+            "gather",  # from tasks
+            "shield",  # from tasks
+            "ensure_future",  # from tasks
+            "run_coroutine_threadsafe",  # from tasks
+            "current_task",  # from tasks
+            "all_tasks",  # from tasks
+            "_register_task",  # from tasks
+            "_unregister_task",  # from tasks
+            "_enter_task",  # from tasks
+            "_leave_task",  # from tasks
+            "BaseTransport",  # from transports
+            "ReadTransport",  # from transports
+            "WriteTransport",  # from transports
+            "Transport",  # from transports
+            "DatagramTransport",  # from transports
+            "SubprocessTransport",  # from transports
+            "SelectorEventLoop",  # from unix_events
+            "AbstractChildWatcher",  # from unix_events
+            "SafeChildWatcher",  # from unix_events
+            "FastChildWatcher",  # from unix_events
+            "MultiLoopChildWatcher",  # from unix_events
+            "ThreadedChildWatcher",  # from unix_events
+            "DefaultEventLoopPolicy",  # from unix_events
+        )
+
+_T_co = TypeVar("_T_co", covariant=True)
 
 # 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_co]  # noqa: Y047
+    _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T_co]  # noqa: Y047
 else:
-    _AwaitableLike: TypeAlias = Generator[Any, None, _T] | Awaitable[_T]
-    _CoroutineLike: TypeAlias = Generator[Any, None, _T] | Coroutine[Any, Any, _T]
+    _AwaitableLike: TypeAlias = Generator[Any, None, _T_co] | Awaitable[_T_co]
+    _CoroutineLike: TypeAlias = Generator[Any, None, _T_co] | Coroutine[Any, Any, _T_co]
diff --git a/mypy/typeshed/stdlib/asyncio/base_events.pyi b/mypy/typeshed/stdlib/asyncio/base_events.pyi
index fd765fdb0614..9527e9d052aa 100644
--- a/mypy/typeshed/stdlib/asyncio/base_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/base_events.pyi
@@ -8,17 +8,20 @@ from asyncio.protocols import BaseProtocol
 from asyncio.tasks import Task
 from asyncio.transports import BaseTransport, DatagramTransport, ReadTransport, SubprocessTransport, Transport, WriteTransport
 from collections.abc import Callable, Iterable, Sequence
+from concurrent.futures import Executor, ThreadPoolExecutor
 from contextvars import Context
 from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
-from typing import IO, Any, TypeVar, overload
-from typing_extensions import Literal, TypeAlias
+from typing import IO, Any, Literal, TypeVar, overload
+from typing_extensions import TypeAlias, TypeVarTuple, Unpack
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.version_info >= (3, 9):
     __all__ = ("BaseEventLoop", "Server")
 else:
     __all__ = ("BaseEventLoop",)
 
 _T = TypeVar("_T")
+_Ts = TypeVarTuple("_Ts")
 _ProtocolT = TypeVar("_ProtocolT", bound=BaseProtocol)
 _Context: TypeAlias = dict[str, Any]
 _ExceptionHandler: TypeAlias = Callable[[AbstractEventLoop, _Context], object]
@@ -48,17 +51,16 @@ class Server(AbstractServer):
             ssl_handshake_timeout: float | None,
         ) -> None: ...
 
+    if sys.version_info >= (3, 13):
+        def close_clients(self) -> None: ...
+        def abort_clients(self) -> None: ...
+
     def get_loop(self) -> AbstractEventLoop: ...
     def is_serving(self) -> bool: ...
     async def start_serving(self) -> None: ...
     async def serve_forever(self) -> None: ...
-    if sys.version_info >= (3, 8):
-        @property
-        def sockets(self) -> tuple[socket, ...]: ...
-    else:
-        @property
-        def sockets(self) -> list[socket]: ...
-
+    @property
+    def sockets(self) -> tuple[socket, ...]: ...
     def close(self) -> None: ...
     async def wait_closed(self) -> None: ...
 
@@ -71,12 +73,14 @@ class BaseEventLoop(AbstractEventLoop):
     def close(self) -> None: ...
     async def shutdown_asyncgens(self) -> None: ...
     # Methods scheduling callbacks.  All these return Handles.
-    def call_soon(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
+    def call_soon(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
     def call_later(
-        self, delay: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+        self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
     ) -> TimerHandle: ...
     def call_at(
-        self, when: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+        self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
     ) -> TimerHandle: ...
     def time(self) -> float: ...
     # Future methods
@@ -84,17 +88,17 @@ class BaseEventLoop(AbstractEventLoop):
     # Tasks methods
     if sys.version_info >= (3, 11):
         def create_task(self, coro: _CoroutineLike[_T], *, name: object = None, context: Context | None = None) -> Task[_T]: ...
-    elif sys.version_info >= (3, 8):
-        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None) -> Task[_T]: ...
     else:
-        def create_task(self, coro: _CoroutineLike[_T]) -> Task[_T]: ...
+        def create_task(self, coro: _CoroutineLike[_T], *, name: object = None) -> Task[_T]: ...
 
     def set_task_factory(self, factory: _TaskFactory | None) -> None: ...
     def get_task_factory(self) -> _TaskFactory | None: ...
     # Methods for interacting with threads
-    def call_soon_threadsafe(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
-    def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Future[_T]: ...
-    def set_default_executor(self, executor: Any) -> None: ...
+    def call_soon_threadsafe(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
+    def run_in_executor(self, executor: Executor | None, func: Callable[[Unpack[_Ts]], _T], *args: Unpack[_Ts]) -> Future[_T]: ...
+    def set_default_executor(self, executor: ThreadPoolExecutor) -> None: ...  # type: ignore[override]
     # Network I/O methods returning Futures.
     async def getaddrinfo(
         self,
@@ -107,7 +111,7 @@ class BaseEventLoop(AbstractEventLoop):
         flags: int = 0,
     ) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
     async def getnameinfo(self, sockaddr: tuple[str, int] | tuple[str, int, int, int], flags: int = 0) -> tuple[str, str]: ...
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 12):
         @overload
         async def create_connection(
             self,
@@ -126,6 +130,7 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_shutdown_timeout: float | None = None,
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
+            all_errors: bool = False,
         ) -> tuple[Transport, _ProtocolT]: ...
         @overload
         async def create_connection(
@@ -145,8 +150,9 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_shutdown_timeout: float | None = None,
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
+            all_errors: bool = False,
         ) -> tuple[Transport, _ProtocolT]: ...
-    elif sys.version_info >= (3, 8):
+    elif sys.version_info >= (3, 11):
         @overload
         async def create_connection(
             self,
@@ -162,6 +168,7 @@ class BaseEventLoop(AbstractEventLoop):
             local_addr: tuple[str, int] | None = None,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
@@ -180,6 +187,7 @@ class BaseEventLoop(AbstractEventLoop):
             local_addr: None = None,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
@@ -199,6 +207,8 @@ class BaseEventLoop(AbstractEventLoop):
             local_addr: tuple[str, int] | None = None,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
         @overload
         async def create_connection(
@@ -215,8 +225,12 @@ class BaseEventLoop(AbstractEventLoop):
             local_addr: None = None,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
+            happy_eyeballs_delay: float | None = None,
+            interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-    if sys.version_info >= (3, 11):
+
+    if sys.version_info >= (3, 13):
+        # 3.13 added `keep_alive`.
         @overload
         async def create_server(
             self,
@@ -231,6 +245,7 @@ class BaseEventLoop(AbstractEventLoop):
             ssl: _SSLContext = None,
             reuse_address: bool | None = None,
             reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
@@ -249,30 +264,48 @@ class BaseEventLoop(AbstractEventLoop):
             ssl: _SSLContext = None,
             reuse_address: bool | None = None,
             reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
-        async def start_tls(
+    elif sys.version_info >= (3, 11):
+        @overload
+        async def create_server(
             self,
-            transport: BaseTransport,
-            protocol: BaseProtocol,
-            sslcontext: ssl.SSLContext,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
+            port: int = ...,
             *,
-            server_side: bool = False,
-            server_hostname: str | None = None,
+            family: int = ...,
+            flags: int = ...,
+            sock: None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> Transport: ...
-        async def connect_accepted_socket(
+            start_serving: bool = True,
+        ) -> Server: ...
+        @overload
+        async def create_server(
             self,
-            protocol_factory: Callable[[], _ProtocolT],
-            sock: socket,
+            protocol_factory: _ProtocolFactory,
+            host: None = None,
+            port: None = None,
             *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = 100,
             ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
+            start_serving: bool = True,
+        ) -> Server: ...
     else:
         @overload
         async def create_server(
@@ -308,6 +341,8 @@ class BaseEventLoop(AbstractEventLoop):
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
+
+    if sys.version_info >= (3, 11):
         async def start_tls(
             self,
             transport: BaseTransport,
@@ -317,7 +352,28 @@ class BaseEventLoop(AbstractEventLoop):
             server_side: bool = False,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> Transport: ...
+            ssl_shutdown_timeout: float | None = None,
+        ) -> Transport | None: ...
+        async def connect_accepted_socket(
+            self,
+            protocol_factory: Callable[[], _ProtocolT],
+            sock: socket,
+            *,
+            ssl: _SSLContext = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> tuple[Transport, _ProtocolT]: ...
+    else:
+        async def start_tls(
+            self,
+            transport: BaseTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+        ) -> Transport | None: ...
         async def connect_accepted_socket(
             self,
             protocol_factory: Callable[[], _ProtocolT],
@@ -382,7 +438,7 @@ class BaseEventLoop(AbstractEventLoop):
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
-        text: Literal[False, None] = None,
+        text: Literal[False] | None = None,
         **kwargs: Any,
     ) -> tuple[SubprocessTransport, _ProtocolT]: ...
     async def subprocess_exec(
@@ -398,11 +454,12 @@ class BaseEventLoop(AbstractEventLoop):
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
+        text: Literal[False] | None = None,
         **kwargs: Any,
     ) -> tuple[SubprocessTransport, _ProtocolT]: ...
-    def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     def remove_reader(self, fd: FileDescriptorLike) -> bool: ...
-    def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     def remove_writer(self, fd: FileDescriptorLike) -> bool: ...
     # The sock_* methods (and probably some others) are not actually implemented on
     # BaseEventLoop, only on subclasses. We list them here for now for convenience.
@@ -416,7 +473,7 @@ class BaseEventLoop(AbstractEventLoop):
         async def sock_recvfrom_into(self, sock: socket, buf: WriteableBuffer, nbytes: int = 0) -> tuple[int, _RetAddress]: ...
         async def sock_sendto(self, sock: socket, data: ReadableBuffer, address: _Address) -> int: ...
     # Signal handling.
-    def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_signal_handler(self, sig: int, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     def remove_signal_handler(self, sig: int) -> bool: ...
     # Error handlers.
     def set_exception_handler(self, handler: _ExceptionHandler | None) -> None: ...
@@ -426,5 +483,9 @@ class BaseEventLoop(AbstractEventLoop):
     # Debug flag management.
     def get_debug(self) -> bool: ...
     def set_debug(self, enabled: bool) -> None: ...
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 12):
+        async def shutdown_default_executor(self, timeout: float | None = None) -> None: ...
+    elif sys.version_info >= (3, 9):
         async def shutdown_default_executor(self) -> None: ...
+
+    def __del__(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/base_futures.pyi b/mypy/typeshed/stdlib/asyncio/base_futures.pyi
index c51174ef23cd..55d2fbdbdb62 100644
--- a/mypy/typeshed/stdlib/asyncio/base_futures.pyi
+++ b/mypy/typeshed/stdlib/asyncio/base_futures.pyi
@@ -1,7 +1,6 @@
 from collections.abc import Callable, Sequence
 from contextvars import Context
-from typing import Any
-from typing_extensions import Literal
+from typing import Any, Final
 
 from . import futures
 
@@ -12,9 +11,9 @@ __all__ = ()
 # That's why the import order is reversed.
 from .futures import isfuture as isfuture
 
-_PENDING: Literal["PENDING"]  # undocumented
-_CANCELLED: Literal["CANCELLED"]  # undocumented
-_FINISHED: Literal["FINISHED"]  # undocumented
+_PENDING: Final = "PENDING"  # undocumented
+_CANCELLED: Final = "CANCELLED"  # undocumented
+_FINISHED: Final = "FINISHED"  # undocumented
 
 def _format_callbacks(cb: Sequence[tuple[Callable[[futures.Future[Any]], None], Context]]) -> str: ...  # undocumented
 def _future_repr_info(future: futures.Future[Any]) -> list[str]: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/asyncio/base_subprocess.pyi b/mypy/typeshed/stdlib/asyncio/base_subprocess.pyi
index 8f262cd5c760..a5fe24e8768b 100644
--- a/mypy/typeshed/stdlib/asyncio/base_subprocess.pyi
+++ b/mypy/typeshed/stdlib/asyncio/base_subprocess.pyi
@@ -55,6 +55,7 @@ class BaseSubprocessTransport(transports.SubprocessTransport):
     async def _wait(self) -> int: ...  # undocumented
     def _try_finish(self) -> None: ...  # undocumented
     def _call_connection_lost(self, exc: BaseException | None) -> None: ...  # undocumented
+    def __del__(self) -> None: ...
 
 class WriteSubprocessPipeProto(protocols.BaseProtocol):  # undocumented
     def __init__(self, proc: BaseSubprocessTransport, fd: int) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/constants.pyi b/mypy/typeshed/stdlib/asyncio/constants.pyi
index af209fa9ee62..5c6456b0e9c0 100644
--- a/mypy/typeshed/stdlib/asyncio/constants.pyi
+++ b/mypy/typeshed/stdlib/asyncio/constants.pyi
@@ -1,18 +1,20 @@
 import enum
 import sys
-from typing_extensions import Literal
+from typing import Final
 
-LOG_THRESHOLD_FOR_CONNLOST_WRITES: Literal[5]
-ACCEPT_RETRY_DELAY: Literal[1]
-DEBUG_STACK_DEPTH: Literal[10]
+LOG_THRESHOLD_FOR_CONNLOST_WRITES: Final = 5
+ACCEPT_RETRY_DELAY: Final = 1
+DEBUG_STACK_DEPTH: Final = 10
 SSL_HANDSHAKE_TIMEOUT: float
-SENDFILE_FALLBACK_READBUFFER_SIZE: Literal[262144]
+SENDFILE_FALLBACK_READBUFFER_SIZE: Final = 262144
 if sys.version_info >= (3, 11):
     SSL_SHUTDOWN_TIMEOUT: float
-    FLOW_CONTROL_HIGH_WATER_SSL_READ: Literal[256]
-    FLOW_CONTROL_HIGH_WATER_SSL_WRITE: Literal[512]
+    FLOW_CONTROL_HIGH_WATER_SSL_READ: Final = 256
+    FLOW_CONTROL_HIGH_WATER_SSL_WRITE: Final = 512
+if sys.version_info >= (3, 12):
+    THREAD_JOIN_TIMEOUT: Final = 300
 
 class _SendfileMode(enum.Enum):
-    UNSUPPORTED: int
-    TRY_NATIVE: int
-    FALLBACK: int
+    UNSUPPORTED = 1
+    TRY_NATIVE = 2
+    FALLBACK = 3
diff --git a/mypy/typeshed/stdlib/asyncio/coroutines.pyi b/mypy/typeshed/stdlib/asyncio/coroutines.pyi
index 14fb627ae6fe..8ef30b3d3198 100644
--- a/mypy/typeshed/stdlib/asyncio/coroutines.pyi
+++ b/mypy/typeshed/stdlib/asyncio/coroutines.pyi
@@ -1,8 +1,9 @@
 import sys
 from collections.abc import Awaitable, Callable, Coroutine
 from typing import Any, TypeVar, overload
-from typing_extensions import ParamSpec, TypeGuard
+from typing_extensions import ParamSpec, TypeGuard, TypeIs
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.version_info >= (3, 11):
     __all__ = ("iscoroutinefunction", "iscoroutine")
 else:
@@ -23,6 +24,4 @@ def iscoroutinefunction(func: Callable[_P, Awaitable[_T]]) -> TypeGuard[Callable
 def iscoroutinefunction(func: Callable[_P, object]) -> TypeGuard[Callable[_P, Coroutine[Any, Any, Any]]]: ...
 @overload
 def iscoroutinefunction(func: object) -> TypeGuard[Callable[..., Coroutine[Any, Any, Any]]]: ...
-
-# Can actually be a generator-style coroutine on Python 3.7
-def iscoroutine(obj: object) -> TypeGuard[Coroutine[Any, Any, Any]]: ...
+def iscoroutine(obj: object) -> TypeIs[Coroutine[Any, Any, Any]]: ...
diff --git a/mypy/typeshed/stdlib/asyncio/events.pyi b/mypy/typeshed/stdlib/asyncio/events.pyi
index 11112bb2e87d..a9f7d24237a4 100644
--- a/mypy/typeshed/stdlib/asyncio/events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/events.pyi
@@ -1,12 +1,19 @@
 import ssl
 import sys
+from _asyncio import (
+    _get_running_loop as _get_running_loop,
+    _set_running_loop as _set_running_loop,
+    get_event_loop as get_event_loop,
+    get_running_loop as get_running_loop,
+)
 from _typeshed import FileDescriptorLike, ReadableBuffer, StrPath, Unused, WriteableBuffer
 from abc import ABCMeta, abstractmethod
-from collections.abc import Callable, Coroutine, Generator, Sequence
+from collections.abc import Callable, Sequence
+from concurrent.futures import Executor
 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 typing import IO, Any, Literal, Protocol, TypeVar, overload
+from typing_extensions import Self, TypeAlias, TypeVarTuple, Unpack, deprecated
 
 from . import _AwaitableLike, _CoroutineLike
 from .base_events import Server
@@ -16,7 +23,8 @@ from .tasks import Task
 from .transports import BaseTransport, DatagramTransport, ReadTransport, SubprocessTransport, Transport, WriteTransport
 from .unix_events import AbstractChildWatcher
 
-if sys.version_info >= (3, 8):
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.version_info >= (3, 14):
     __all__ = (
         "AbstractEventLoopPolicy",
         "AbstractEventLoop",
@@ -28,13 +36,10 @@ if sys.version_info >= (3, 8):
         "get_event_loop",
         "set_event_loop",
         "new_event_loop",
-        "get_child_watcher",
-        "set_child_watcher",
         "_set_running_loop",
         "get_running_loop",
         "_get_running_loop",
     )
-
 else:
     __all__ = (
         "AbstractEventLoopPolicy",
@@ -42,7 +47,6 @@ else:
         "AbstractServer",
         "Handle",
         "TimerHandle",
-        "SendfileNotAvailableError",
         "get_event_loop_policy",
         "set_event_loop_policy",
         "get_event_loop",
@@ -56,6 +60,7 @@ else:
     )
 
 _T = TypeVar("_T")
+_Ts = TypeVarTuple("_Ts")
 _ProtocolT = TypeVar("_ProtocolT", bound=BaseProtocol)
 _Context: TypeAlias = dict[str, Any]
 _ExceptionHandler: TypeAlias = Callable[[AbstractEventLoop, _Context], object]
@@ -63,9 +68,7 @@ _ProtocolFactory: TypeAlias = Callable[[], BaseProtocol]
 _SSLContext: TypeAlias = bool | None | ssl.SSLContext
 
 class _TaskFactory(Protocol):
-    def __call__(
-        self, __loop: AbstractEventLoop, __factory: Coroutine[Any, Any, _T] | Generator[Any, None, _T]
-    ) -> Future[_T]: ...
+    def __call__(self, loop: AbstractEventLoop, factory: _CoroutineLike[_T], /) -> Future[_T]: ...
 
 class Handle:
     _cancelled: bool
@@ -76,6 +79,8 @@ class Handle:
     def cancel(self) -> None: ...
     def _run(self) -> None: ...
     def cancelled(self) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def get_context(self) -> Context: ...
 
 class TimerHandle(Handle):
     def __init__(
@@ -86,6 +91,7 @@ class TimerHandle(Handle):
         loop: AbstractEventLoop,
         context: Context | None = None,
     ) -> None: ...
+    def __hash__(self) -> int: ...
     def when(self) -> float: ...
     def __lt__(self, other: TimerHandle) -> bool: ...
     def __le__(self, other: TimerHandle) -> bool: ...
@@ -96,6 +102,12 @@ class TimerHandle(Handle):
 class AbstractServer:
     @abstractmethod
     def close(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        @abstractmethod
+        def close_clients(self) -> None: ...
+        @abstractmethod
+        def abort_clients(self) -> None: ...
+
     async def __aenter__(self) -> Self: ...
     async def __aexit__(self, *exc: Unused) -> None: ...
     @abstractmethod
@@ -128,22 +140,24 @@ class AbstractEventLoop:
     # Methods scheduling callbacks.  All these return Handles.
     if sys.version_info >= (3, 9):  # "context" added in 3.9.10/3.10.2
         @abstractmethod
-        def call_soon(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
+        def call_soon(
+            self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+        ) -> Handle: ...
         @abstractmethod
         def call_later(
-            self, delay: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+            self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
         ) -> TimerHandle: ...
         @abstractmethod
         def call_at(
-            self, when: float, callback: Callable[..., object], *args: Any, context: Context | None = None
+            self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
         ) -> TimerHandle: ...
     else:
         @abstractmethod
-        def call_soon(self, callback: Callable[..., object], *args: Any) -> Handle: ...
+        def call_soon(self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> Handle: ...
         @abstractmethod
-        def call_later(self, delay: float, callback: Callable[..., object], *args: Any) -> TimerHandle: ...
+        def call_later(self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> TimerHandle: ...
         @abstractmethod
-        def call_at(self, when: float, callback: Callable[..., object], *args: Any) -> TimerHandle: ...
+        def call_at(self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> TimerHandle: ...
 
     @abstractmethod
     def time(self) -> float: ...
@@ -156,12 +170,9 @@ class AbstractEventLoop:
         def create_task(
             self, coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None
         ) -> Task[_T]: ...
-    elif sys.version_info >= (3, 8):
-        @abstractmethod
-        def create_task(self, coro: _CoroutineLike[_T], *, name: str | None = None) -> Task[_T]: ...
     else:
         @abstractmethod
-        def create_task(self, coro: _CoroutineLike[_T]) -> Task[_T]: ...
+        def create_task(self, coro: _CoroutineLike[_T], *, name: str | None = None) -> Task[_T]: ...
 
     @abstractmethod
     def set_task_factory(self, factory: _TaskFactory | None) -> None: ...
@@ -170,15 +181,17 @@ class AbstractEventLoop:
     # Methods for interacting with threads
     if sys.version_info >= (3, 9):  # "context" added in 3.9.10/3.10.2
         @abstractmethod
-        def call_soon_threadsafe(self, callback: Callable[..., object], *args: Any, context: Context | None = None) -> Handle: ...
+        def call_soon_threadsafe(
+            self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+        ) -> Handle: ...
     else:
         @abstractmethod
-        def call_soon_threadsafe(self, callback: Callable[..., object], *args: Any) -> Handle: ...
+        def call_soon_threadsafe(self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> Handle: ...
 
     @abstractmethod
-    def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Future[_T]: ...
+    def run_in_executor(self, executor: Executor | None, func: Callable[[Unpack[_Ts]], _T], *args: Unpack[_Ts]) -> Future[_T]: ...
     @abstractmethod
-    def set_default_executor(self, executor: Any) -> None: ...
+    def set_default_executor(self, executor: Executor) -> None: ...
     # Network I/O methods returning Futures.
     @abstractmethod
     async def getaddrinfo(
@@ -234,7 +247,7 @@ class AbstractEventLoop:
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-    elif sys.version_info >= (3, 8):
+    else:
         @overload
         @abstractmethod
         async def create_connection(
@@ -273,42 +286,50 @@ class AbstractEventLoop:
             happy_eyeballs_delay: float | None = None,
             interleave: int | None = None,
         ) -> tuple[Transport, _ProtocolT]: ...
-    else:
+
+    if sys.version_info >= (3, 13):
+        # 3.13 added `keep_alive`.
         @overload
         @abstractmethod
-        async def create_connection(
+        async def create_server(
             self,
-            protocol_factory: Callable[[], _ProtocolT],
-            host: str = ...,
+            protocol_factory: _ProtocolFactory,
+            host: str | Sequence[str] | None = None,
             port: int = ...,
             *,
-            ssl: _SSLContext = None,
-            family: int = 0,
-            proto: int = 0,
-            flags: int = 0,
+            family: int = ...,
+            flags: int = ...,
             sock: None = None,
-            local_addr: tuple[str, int] | None = None,
-            server_hostname: str | None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
         @overload
         @abstractmethod
-        async def create_connection(
+        async def create_server(
             self,
-            protocol_factory: Callable[[], _ProtocolT],
+            protocol_factory: _ProtocolFactory,
             host: None = None,
             port: None = None,
             *,
+            family: int = ...,
+            flags: int = ...,
+            sock: socket = ...,
+            backlog: int = 100,
             ssl: _SSLContext = None,
-            family: int = 0,
-            proto: int = 0,
-            flags: int = 0,
-            sock: socket,
-            local_addr: None = None,
-            server_hostname: str | None = None,
+            reuse_address: bool | None = None,
+            reuse_port: bool | None = None,
+            keep_alive: bool | None = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> tuple[Transport, _ProtocolT]: ...
-    if sys.version_info >= (3, 11):
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+    elif sys.version_info >= (3, 11):
         @overload
         @abstractmethod
         async def create_server(
@@ -347,30 +368,6 @@ class AbstractEventLoop:
             ssl_shutdown_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
-        @abstractmethod
-        async def start_tls(
-            self,
-            transport: WriteTransport,
-            protocol: BaseProtocol,
-            sslcontext: ssl.SSLContext,
-            *,
-            server_side: bool = False,
-            server_hostname: str | None = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-        ) -> Transport: ...
-        async def create_unix_server(
-            self,
-            protocol_factory: _ProtocolFactory,
-            path: StrPath | None = None,
-            *,
-            sock: socket | None = None,
-            backlog: int = 100,
-            ssl: _SSLContext = None,
-            ssl_handshake_timeout: float | None = None,
-            ssl_shutdown_timeout: float | None = None,
-            start_serving: bool = True,
-        ) -> Server: ...
     else:
         @overload
         @abstractmethod
@@ -408,6 +405,33 @@ class AbstractEventLoop:
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
+
+    if sys.version_info >= (3, 11):
+        @abstractmethod
+        async def start_tls(
+            self,
+            transport: WriteTransport,
+            protocol: BaseProtocol,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_side: bool = False,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> Transport | None: ...
+        async def create_unix_server(
+            self,
+            protocol_factory: _ProtocolFactory,
+            path: StrPath | None = None,
+            *,
+            sock: socket | None = None,
+            backlog: int = 100,
+            ssl: _SSLContext = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+            start_serving: bool = True,
+        ) -> Server: ...
+    else:
         @abstractmethod
         async def start_tls(
             self,
@@ -418,7 +442,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,
@@ -430,6 +454,7 @@ class AbstractEventLoop:
             ssl_handshake_timeout: float | None = None,
             start_serving: bool = True,
         ) -> Server: ...
+
     if sys.version_info >= (3, 11):
         async def connect_accepted_socket(
             self,
@@ -519,7 +544,7 @@ class AbstractEventLoop:
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
-        text: Literal[False, None] = ...,
+        text: Literal[False] | None = ...,
         **kwargs: Any,
     ) -> tuple[SubprocessTransport, _ProtocolT]: ...
     @abstractmethod
@@ -539,14 +564,13 @@ class AbstractEventLoop:
         **kwargs: Any,
     ) -> tuple[SubprocessTransport, _ProtocolT]: ...
     @abstractmethod
-    def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     @abstractmethod
     def remove_reader(self, fd: FileDescriptorLike) -> bool: ...
     @abstractmethod
-    def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ...
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[Unpack[_Ts]], Any], *args: Unpack[_Ts]) -> None: ...
     @abstractmethod
     def remove_writer(self, fd: FileDescriptorLike) -> bool: ...
-    # Completion based I/O methods returning Futures prior to 3.7
     @abstractmethod
     async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ...
     @abstractmethod
@@ -566,7 +590,7 @@ class AbstractEventLoop:
         async def sock_sendto(self, sock: socket, data: ReadableBuffer, address: _Address) -> int: ...
     # Signal handling.
     @abstractmethod
-    def add_signal_handler(self, sig: int, callback: Callable[..., object], *args: Any) -> None: ...
+    def add_signal_handler(self, sig: int, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> None: ...
     @abstractmethod
     def remove_signal_handler(self, sig: int) -> bool: ...
     # Error handlers.
@@ -595,10 +619,19 @@ class AbstractEventLoopPolicy:
     @abstractmethod
     def new_event_loop(self) -> AbstractEventLoop: ...
     # Child processes handling (Unix only).
-    @abstractmethod
-    def get_child_watcher(self) -> AbstractChildWatcher: ...
-    @abstractmethod
-    def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            @abstractmethod
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            @abstractmethod
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
+        else:
+            @abstractmethod
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            @abstractmethod
+            def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
 
 class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy, metaclass=ABCMeta):
     def get_event_loop(self) -> AbstractEventLoop: ...
@@ -607,14 +640,16 @@ class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy, metaclass=ABCMeta):
 
 def get_event_loop_policy() -> AbstractEventLoopPolicy: ...
 def set_event_loop_policy(policy: AbstractEventLoopPolicy | None) -> None: ...
-def get_event_loop() -> AbstractEventLoop: ...
 def set_event_loop(loop: AbstractEventLoop | None) -> None: ...
 def new_event_loop() -> AbstractEventLoop: ...
-def get_child_watcher() -> AbstractChildWatcher: ...
-def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
-def _set_running_loop(__loop: AbstractEventLoop | None) -> None: ...
-def _get_running_loop() -> AbstractEventLoop: ...
-def get_running_loop() -> AbstractEventLoop: ...
 
-if sys.version_info < (3, 8):
-    class SendfileNotAvailableError(RuntimeError): ...
+if sys.version_info < (3, 14):
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        def get_child_watcher() -> AbstractChildWatcher: ...
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+
+    else:
+        def get_child_watcher() -> AbstractChildWatcher: ...
+        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/exceptions.pyi b/mypy/typeshed/stdlib/asyncio/exceptions.pyi
index 075fbb805bb9..759838f45de4 100644
--- a/mypy/typeshed/stdlib/asyncio/exceptions.pyi
+++ b/mypy/typeshed/stdlib/asyncio/exceptions.pyi
@@ -1,5 +1,6 @@
 import sys
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.version_info >= (3, 11):
     __all__ = (
         "BrokenBarrierError",
@@ -21,7 +22,12 @@ else:
     )
 
 class CancelledError(BaseException): ...
-class TimeoutError(Exception): ...
+
+if sys.version_info >= (3, 11):
+    from builtins import TimeoutError as TimeoutError
+else:
+    class TimeoutError(Exception): ...
+
 class InvalidStateError(Exception): ...
 class SendfileNotAvailableError(RuntimeError): ...
 
diff --git a/mypy/typeshed/stdlib/asyncio/format_helpers.pyi b/mypy/typeshed/stdlib/asyncio/format_helpers.pyi
index 1c78dff3948a..41505b14cd08 100644
--- a/mypy/typeshed/stdlib/asyncio/format_helpers.pyi
+++ b/mypy/typeshed/stdlib/asyncio/format_helpers.pyi
@@ -1,4 +1,5 @@
 import functools
+import sys
 import traceback
 from collections.abc import Iterable
 from types import FrameType, FunctionType
@@ -14,7 +15,17 @@ _FuncType: TypeAlias = FunctionType | _HasWrapper | functools.partial[Any] | fun
 def _get_function_source(func: _FuncType) -> tuple[str, int]: ...
 @overload
 def _get_function_source(func: object) -> tuple[str, int] | None: ...
-def _format_callback_source(func: object, args: Iterable[Any]) -> str: ...
-def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any]) -> str: ...
-def _format_callback(func: object, args: Iterable[Any], kwargs: dict[str, Any], suffix: str = "") -> str: ...
+
+if sys.version_info >= (3, 13):
+    def _format_callback_source(func: object, args: Iterable[Any], *, debug: bool = False) -> str: ...
+    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any], *, debug: bool = False) -> str: ...
+    def _format_callback(
+        func: object, args: Iterable[Any], kwargs: dict[str, Any], *, debug: bool = False, suffix: str = ""
+    ) -> str: ...
+
+else:
+    def _format_callback_source(func: object, args: Iterable[Any]) -> str: ...
+    def _format_args_and_kwargs(args: Iterable[Any], kwargs: dict[str, Any]) -> str: ...
+    def _format_callback(func: object, args: Iterable[Any], kwargs: dict[str, Any], suffix: str = "") -> str: ...
+
 def extract_stack(f: FrameType | None = None, limit: int | None = None) -> traceback.StackSummary: ...
diff --git a/mypy/typeshed/stdlib/asyncio/futures.pyi b/mypy/typeshed/stdlib/asyncio/futures.pyi
index 79209f5ed4fb..cb2785012fb2 100644
--- a/mypy/typeshed/stdlib/asyncio/futures.pyi
+++ b/mypy/typeshed/stdlib/asyncio/futures.pyi
@@ -1,66 +1,17 @@
-import sys
-from collections.abc import Awaitable, Callable, Generator, Iterable
-from concurrent.futures._base import Error, Future as _ConcurrentFuture
+from _asyncio import Future as Future
+from concurrent.futures._base import Future as _ConcurrentFuture
 from typing import Any, TypeVar
-from typing_extensions import Literal, Self, TypeGuard
+from typing_extensions import TypeIs
 
 from .events import AbstractEventLoop
 
-if sys.version_info < (3, 8):
-    from concurrent.futures import CancelledError as CancelledError, TimeoutError as TimeoutError
-
-    class InvalidStateError(Error): ...
-
-from contextvars import Context
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-if sys.version_info >= (3, 8):
-    __all__ = ("Future", "wrap_future", "isfuture")
-else:
-    __all__ = ("CancelledError", "TimeoutError", "InvalidStateError", "Future", "wrap_future", "isfuture")
+# Keep asyncio.__all__ updated with any changes to __all__ here
+__all__ = ("Future", "wrap_future", "isfuture")
 
 _T = TypeVar("_T")
 
 # asyncio defines 'isfuture()' in base_futures.py and re-imports it in futures.py
 # but it leads to circular import error in pytype tool.
 # That's why the import order is reversed.
-def isfuture(obj: object) -> TypeGuard[Future[Any]]: ...
-
-class Future(Awaitable[_T], Iterable[_T]):
-    _state: str
-    @property
-    def _exception(self) -> BaseException: ...
-    _blocking: bool
-    @property
-    def _log_traceback(self) -> bool: ...
-    @_log_traceback.setter
-    def _log_traceback(self, val: Literal[False]) -> None: ...
-    _asyncio_future_blocking: bool  # is a part of duck-typing contract for `Future`
-    def __init__(self, *, loop: AbstractEventLoop | None = ...) -> None: ...
-    def __del__(self) -> None: ...
-    def get_loop(self) -> AbstractEventLoop: ...
-    @property
-    def _callbacks(self) -> list[tuple[Callable[[Self], Any], Context]]: ...
-    def add_done_callback(self, __fn: Callable[[Self], object], *, context: Context | None = None) -> None: ...
-    if sys.version_info >= (3, 9):
-        def cancel(self, msg: Any | None = None) -> bool: ...
-    else:
-        def cancel(self) -> bool: ...
-
-    def cancelled(self) -> bool: ...
-    def done(self) -> bool: ...
-    def result(self) -> _T: ...
-    def exception(self) -> BaseException | None: ...
-    def remove_done_callback(self, __fn: Callable[[Self], object]) -> int: ...
-    def set_result(self, __result: _T) -> None: ...
-    def set_exception(self, __exception: type | BaseException) -> None: ...
-    def __iter__(self) -> Generator[Any, None, _T]: ...
-    def __await__(self) -> Generator[Any, None, _T]: ...
-    @property
-    def _loop(self) -> AbstractEventLoop: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
+def isfuture(obj: object) -> TypeIs[Future[Any]]: ...
 def wrap_future(future: _ConcurrentFuture[_T] | Future[_T], *, loop: AbstractEventLoop | None = None) -> Future[_T]: ...
diff --git a/mypy/typeshed/stdlib/asyncio/locks.pyi b/mypy/typeshed/stdlib/asyncio/locks.pyi
index ab4e63ab59b1..4eef69dee5c3 100644
--- a/mypy/typeshed/stdlib/asyncio/locks.pyi
+++ b/mypy/typeshed/stdlib/asyncio/locks.pyi
@@ -4,15 +4,18 @@ from _typeshed import Unused
 from collections import deque
 from collections.abc import Callable, Generator
 from types import TracebackType
-from typing import Any, TypeVar
-from typing_extensions import Literal, Self
+from typing import Any, Literal, TypeVar
+from typing_extensions import Self
 
 from .events import AbstractEventLoop
 from .futures import Future
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 10):
     from .mixins import _LoopBoundMixin
+else:
+    _LoopBoundMixin = object
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.version_info >= (3, 11):
     __all__ = ("Lock", "Event", "Condition", "Semaphore", "BoundedSemaphore", "Barrier")
 else:
@@ -44,7 +47,8 @@ else:
             self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
         ) -> None: ...
 
-class Lock(_ContextManagerMixin):
+class Lock(_ContextManagerMixin, _LoopBoundMixin):
+    _waiters: deque[Future[Any]] | None
     if sys.version_info >= (3, 10):
         def __init__(self) -> None: ...
     else:
@@ -54,7 +58,8 @@ class Lock(_ContextManagerMixin):
     async def acquire(self) -> Literal[True]: ...
     def release(self) -> None: ...
 
-class Event:
+class Event(_LoopBoundMixin):
+    _waiters: deque[Future[Any]]
     if sys.version_info >= (3, 10):
         def __init__(self) -> None: ...
     else:
@@ -65,7 +70,8 @@ class Event:
     def clear(self) -> None: ...
     async def wait(self) -> Literal[True]: ...
 
-class Condition(_ContextManagerMixin):
+class Condition(_ContextManagerMixin, _LoopBoundMixin):
+    _waiters: deque[Future[Any]]
     if sys.version_info >= (3, 10):
         def __init__(self, lock: Lock | None = None) -> None: ...
     else:
@@ -79,9 +85,9 @@ class Condition(_ContextManagerMixin):
     def notify(self, n: int = 1) -> None: ...
     def notify_all(self) -> None: ...
 
-class Semaphore(_ContextManagerMixin):
+class Semaphore(_ContextManagerMixin, _LoopBoundMixin):
     _value: int
-    _waiters: deque[Future[Any]]
+    _waiters: deque[Future[Any]] | None
     if sys.version_info >= (3, 10):
         def __init__(self, value: int = 1) -> None: ...
     else:
@@ -96,10 +102,10 @@ class BoundedSemaphore(Semaphore): ...
 
 if sys.version_info >= (3, 11):
     class _BarrierState(enum.Enum):  # undocumented
-        FILLING: str
-        DRAINING: str
-        RESETTING: str
-        BROKEN: str
+        FILLING = "filling"
+        DRAINING = "draining"
+        RESETTING = "resetting"
+        BROKEN = "broken"
 
     class Barrier(_LoopBoundMixin):
         def __init__(self, parties: int) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/proactor_events.pyi b/mypy/typeshed/stdlib/asyncio/proactor_events.pyi
index 33fdf84ade4a..909d671df289 100644
--- a/mypy/typeshed/stdlib/asyncio/proactor_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/proactor_events.pyi
@@ -1,19 +1,12 @@
 import sys
 from collections.abc import Mapping
 from socket import socket
-from typing import Any, ClassVar, Protocol
-from typing_extensions import Literal
+from typing import Any, ClassVar, Literal
 
 from . import base_events, constants, events, futures, streams, transports
 
 __all__ = ("BaseProactorEventLoop",)
 
-if sys.version_info >= (3, 8):
-    class _WarnCallbackProtocol(Protocol):
-        def __call__(
-            self, message: str, category: type[Warning] | None = ..., stacklevel: int = ..., source: Any | None = ...
-        ) -> object: ...
-
 class _ProactorBasePipeTransport(transports._FlowControlMixin, transports.BaseTransport):
     def __init__(
         self,
@@ -24,10 +17,7 @@ class _ProactorBasePipeTransport(transports._FlowControlMixin, transports.BaseTr
         extra: Mapping[Any, Any] | None = None,
         server: events.AbstractServer | None = None,
     ) -> None: ...
-    if sys.version_info >= (3, 8):
-        def __del__(self, _warn: _WarnCallbackProtocol = ...) -> None: ...
-    else:
-        def __del__(self) -> None: ...
+    def __del__(self) -> None: ...
 
 class _ProactorReadPipeTransport(_ProactorBasePipeTransport, transports.ReadTransport):
     if sys.version_info >= (3, 10):
@@ -72,3 +62,4 @@ class _ProactorSocketTransport(_ProactorReadPipeTransport, _ProactorBaseWritePip
 
 class BaseProactorEventLoop(base_events.BaseEventLoop):
     def __init__(self, proactor: Any) -> None: ...
+    async def sock_recv(self, sock: socket, n: int) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/asyncio/protocols.pyi b/mypy/typeshed/stdlib/asyncio/protocols.pyi
index 5173b74ed5a0..5425336c49a8 100644
--- a/mypy/typeshed/stdlib/asyncio/protocols.pyi
+++ b/mypy/typeshed/stdlib/asyncio/protocols.pyi
@@ -2,6 +2,7 @@ from _typeshed import ReadableBuffer
 from asyncio import transports
 from typing import Any
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 __all__ = ("BaseProtocol", "Protocol", "DatagramProtocol", "SubprocessProtocol", "BufferedProtocol")
 
 class BaseProtocol:
diff --git a/mypy/typeshed/stdlib/asyncio/queues.pyi b/mypy/typeshed/stdlib/asyncio/queues.pyi
index f56a09524e71..d287fe779297 100644
--- a/mypy/typeshed/stdlib/asyncio/queues.pyi
+++ b/mypy/typeshed/stdlib/asyncio/queues.pyi
@@ -5,14 +5,29 @@ from typing import Any, Generic, TypeVar
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 
-__all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty")
+if sys.version_info >= (3, 10):
+    from .mixins import _LoopBoundMixin
+else:
+    _LoopBoundMixin = object
 
 class QueueEmpty(Exception): ...
 class QueueFull(Exception): ...
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.version_info >= (3, 13):
+    __all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty", "QueueShutDown")
+
+else:
+    __all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty")
+
 _T = TypeVar("_T")
 
-class Queue(Generic[_T]):
+if sys.version_info >= (3, 13):
+    class QueueShutDown(Exception): ...
+
+# If Generic[_T] is last and _LoopBoundMixin is object, pyright is unhappy.
+# We can remove the noqa pragma when dropping 3.9 support.
+class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
     if sys.version_info >= (3, 10):
         def __init__(self, maxsize: int = 0) -> None: ...
     else:
@@ -34,7 +49,9 @@ class Queue(Generic[_T]):
     async def join(self) -> None: ...
     def task_done(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, type: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, type: Any, /) -> GenericAlias: ...
+    if sys.version_info >= (3, 13):
+        def shutdown(self, immediate: bool = False) -> None: ...
 
 class PriorityQueue(Queue[_T]): ...
 class LifoQueue(Queue[_T]): ...
diff --git a/mypy/typeshed/stdlib/asyncio/runners.pyi b/mypy/typeshed/stdlib/asyncio/runners.pyi
index 847072b633ac..caf5e4996cf4 100644
--- a/mypy/typeshed/stdlib/asyncio/runners.pyi
+++ b/mypy/typeshed/stdlib/asyncio/runners.pyi
@@ -2,11 +2,12 @@ import sys
 from _typeshed import Unused
 from collections.abc import Callable, Coroutine
 from contextvars import Context
-from typing import Any, TypeVar
-from typing_extensions import Self, final
+from typing import Any, TypeVar, final
+from typing_extensions import Self
 
 from .events import AbstractEventLoop
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.version_info >= (3, 11):
     __all__ = ("Runner", "run")
 else:
@@ -28,8 +29,5 @@ if sys.version_info >= (3, 12):
         main: Coroutine[Any, Any, _T], *, debug: bool | None = ..., loop_factory: Callable[[], AbstractEventLoop] | None = ...
     ) -> _T: ...
 
-elif sys.version_info >= (3, 8):
-    def run(main: Coroutine[Any, Any, _T], *, debug: bool | None = None) -> _T: ...
-
 else:
-    def run(main: Coroutine[Any, Any, _T], *, debug: bool = False) -> _T: ...
+    def run(main: Coroutine[Any, Any, _T], *, debug: bool | None = None) -> _T: ...
diff --git a/mypy/typeshed/stdlib/asyncio/selector_events.pyi b/mypy/typeshed/stdlib/asyncio/selector_events.pyi
index 430f2dd405cd..18c5df033e2f 100644
--- a/mypy/typeshed/stdlib/asyncio/selector_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/selector_events.pyi
@@ -1,4 +1,5 @@
 import selectors
+from socket import socket
 
 from . import base_events
 
@@ -6,3 +7,4 @@ __all__ = ("BaseSelectorEventLoop",)
 
 class BaseSelectorEventLoop(base_events.BaseEventLoop):
     def __init__(self, selector: selectors.BaseSelector | None = None) -> None: ...
+    async def sock_recv(self, sock: socket, n: int) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/asyncio/sslproto.pyi b/mypy/typeshed/stdlib/asyncio/sslproto.pyi
index 09733e5f9a01..ab102f124c2e 100644
--- a/mypy/typeshed/stdlib/asyncio/sslproto.pyi
+++ b/mypy/typeshed/stdlib/asyncio/sslproto.pyi
@@ -3,8 +3,8 @@ import sys
 from collections import deque
 from collections.abc import Callable
 from enum import Enum
-from typing import Any, ClassVar
-from typing_extensions import Literal, TypeAlias
+from typing import Any, ClassVar, Final, Literal
+from typing_extensions import TypeAlias
 
 from . import constants, events, futures, protocols, transports
 
@@ -14,24 +14,25 @@ if sys.version_info >= (3, 11):
     SSLAgainErrors: tuple[type[ssl.SSLWantReadError], type[ssl.SSLSyscallError]]
 
     class SSLProtocolState(Enum):
-        UNWRAPPED: str
-        DO_HANDSHAKE: str
-        WRAPPED: str
-        FLUSHING: str
-        SHUTDOWN: str
+        UNWRAPPED = "UNWRAPPED"
+        DO_HANDSHAKE = "DO_HANDSHAKE"
+        WRAPPED = "WRAPPED"
+        FLUSHING = "FLUSHING"
+        SHUTDOWN = "SHUTDOWN"
 
     class AppProtocolState(Enum):
-        STATE_INIT: str
-        STATE_CON_MADE: str
-        STATE_EOF: str
-        STATE_CON_LOST: str
+        STATE_INIT = "STATE_INIT"
+        STATE_CON_MADE = "STATE_CON_MADE"
+        STATE_EOF = "STATE_EOF"
+        STATE_CON_LOST = "STATE_CON_LOST"
+
     def add_flowcontrol_defaults(high: int | None, low: int | None, kb: int) -> tuple[int, int]: ...
 
 else:
-    _UNWRAPPED: Literal["UNWRAPPED"]
-    _DO_HANDSHAKE: Literal["DO_HANDSHAKE"]
-    _WRAPPED: Literal["WRAPPED"]
-    _SHUTDOWN: Literal["SHUTDOWN"]
+    _UNWRAPPED: Final = "UNWRAPPED"
+    _DO_HANDSHAKE: Final = "DO_HANDSHAKE"
+    _WRAPPED: Final = "WRAPPED"
+    _SHUTDOWN: Final = "SHUTDOWN"
 
 if sys.version_info < (3, 11):
     class _SSLPipe:
@@ -75,7 +76,7 @@ class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport):
     def get_extra_info(self, name: str, default: Any | None = None) -> dict[str, Any]: ...
     @property
     def _protocol_paused(self) -> bool: ...
-    def write(self, data: bytes | bytearray | memoryview) -> None: ...
+    def write(self, data: bytes | bytearray | memoryview[Any]) -> None: ...  # any memoryview format or shape
     def can_write_eof(self) -> Literal[False]: ...
     if sys.version_info >= (3, 11):
         def get_write_buffer_limits(self) -> tuple[int, int]: ...
@@ -83,6 +84,8 @@ class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport):
         def set_read_buffer_limits(self, high: int | None = None, low: int | None = None) -> None: ...
         def get_read_buffer_size(self) -> int: ...
 
+    def __del__(self) -> None: ...
+
 if sys.version_info >= (3, 11):
     _SSLProtocolBase: TypeAlias = protocols.BufferedProtocol
 else:
@@ -153,9 +156,10 @@ class SSLProtocol(_SSLProtocolBase):
     def _check_handshake_timeout(self) -> None: ...
     def _on_handshake_complete(self, handshake_exc: BaseException | None) -> None: ...
     def _fatal_error(self, exc: BaseException, message: str = "Fatal error on transport") -> None: ...
-    def _abort(self) -> None: ...
     if sys.version_info >= (3, 11):
+        def _abort(self, exc: BaseException | None) -> None: ...
         def get_buffer(self, n: int) -> memoryview: ...
     else:
+        def _abort(self) -> None: ...
         def _finalize(self) -> None: ...
         def _process_write_backlog(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/streams.pyi b/mypy/typeshed/stdlib/asyncio/streams.pyi
index f30c57305d93..43df5ae2d0c8 100644
--- a/mypy/typeshed/stdlib/asyncio/streams.pyi
+++ b/mypy/typeshed/stdlib/asyncio/streams.pyi
@@ -1,61 +1,31 @@
 import ssl
 import sys
-from _typeshed import StrPath
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
-from typing import Any
-from typing_extensions import Self, SupportsIndex, TypeAlias
+from _typeshed import ReadableBuffer, StrPath
+from collections.abc import Awaitable, Callable, Iterable, Sequence, Sized
+from types import ModuleType
+from typing import Any, Protocol, SupportsIndex
+from typing_extensions import Self, TypeAlias
 
 from . import events, protocols, transports
 from .base_events import Server
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.platform == "win32":
-    if sys.version_info >= (3, 8):
-        __all__ = ("StreamReader", "StreamWriter", "StreamReaderProtocol", "open_connection", "start_server")
-    else:
-        __all__ = (
-            "StreamReader",
-            "StreamWriter",
-            "StreamReaderProtocol",
-            "open_connection",
-            "start_server",
-            "IncompleteReadError",
-            "LimitOverrunError",
-        )
+    __all__ = ("StreamReader", "StreamWriter", "StreamReaderProtocol", "open_connection", "start_server")
 else:
-    if sys.version_info >= (3, 8):
-        __all__ = (
-            "StreamReader",
-            "StreamWriter",
-            "StreamReaderProtocol",
-            "open_connection",
-            "start_server",
-            "open_unix_connection",
-            "start_unix_server",
-        )
-    else:
-        __all__ = (
-            "StreamReader",
-            "StreamWriter",
-            "StreamReaderProtocol",
-            "open_connection",
-            "start_server",
-            "IncompleteReadError",
-            "LimitOverrunError",
-            "open_unix_connection",
-            "start_unix_server",
-        )
+    __all__ = (
+        "StreamReader",
+        "StreamWriter",
+        "StreamReaderProtocol",
+        "open_connection",
+        "start_server",
+        "open_unix_connection",
+        "start_unix_server",
+    )
 
 _ClientConnectedCallback: TypeAlias = Callable[[StreamReader, StreamWriter], Awaitable[None] | None]
 
-if sys.version_info < (3, 8):
-    class IncompleteReadError(EOFError):
-        expected: int | None
-        partial: bytes
-        def __init__(self, partial: bytes, expected: int | None) -> None: ...
-
-    class LimitOverrunError(Exception):
-        consumed: int
-        def __init__(self, message: str, consumed: int) -> None: ...
+class _ReaduntilBuffer(ReadableBuffer, Sized, Protocol): ...
 
 if sys.version_info >= (3, 10):
     async def open_connection(
@@ -128,6 +98,7 @@ class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
         client_connected_cb: _ClientConnectedCallback | None = None,
         loop: events.AbstractEventLoop | None = None,
     ) -> None: ...
+    def __del__(self) -> None: ...
 
 class StreamWriter:
     def __init__(
@@ -148,12 +119,26 @@ class StreamWriter:
     async def wait_closed(self) -> None: ...
     def get_extra_info(self, name: str, default: Any = None) -> Any: ...
     async def drain(self) -> None: ...
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 12):
+        async def start_tls(
+            self,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
         async def start_tls(
             self, sslcontext: ssl.SSLContext, *, server_hostname: str | None = None, ssl_handshake_timeout: float | None = None
         ) -> None: ...
 
-class StreamReader(AsyncIterator[bytes]):
+    if sys.version_info >= (3, 13):
+        def __del__(self, warnings: ModuleType = ...) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __del__(self) -> None: ...
+
+class StreamReader:
     def __init__(self, limit: int = 65536, loop: events.AbstractEventLoop | None = None) -> None: ...
     def exception(self) -> Exception: ...
     def set_exception(self, exc: Exception) -> None: ...
@@ -162,8 +147,11 @@ class StreamReader(AsyncIterator[bytes]):
     def at_eof(self) -> bool: ...
     def feed_data(self, data: Iterable[SupportsIndex]) -> None: ...
     async def readline(self) -> bytes: ...
-    # Can be any buffer that supports len(); consider changing to a Protocol if PEP 688 is accepted
-    async def readuntil(self, separator: bytes | bytearray | memoryview = b"\n") -> bytes: ...
+    if sys.version_info >= (3, 13):
+        async def readuntil(self, separator: _ReaduntilBuffer | tuple[_ReaduntilBuffer, ...] = b"\n") -> bytes: ...
+    else:
+        async def readuntil(self, separator: _ReaduntilBuffer = b"\n") -> bytes: ...
+
     async def read(self, n: int = -1) -> bytes: ...
     async def readexactly(self, n: int) -> bytes: ...
     def __aiter__(self) -> Self: ...
diff --git a/mypy/typeshed/stdlib/asyncio/subprocess.pyi b/mypy/typeshed/stdlib/asyncio/subprocess.pyi
index b8877b360527..50d75391f36d 100644
--- a/mypy/typeshed/stdlib/asyncio/subprocess.pyi
+++ b/mypy/typeshed/stdlib/asyncio/subprocess.pyi
@@ -3,16 +3,11 @@ import sys
 from _typeshed import StrOrBytesPath
 from asyncio import events, protocols, streams, transports
 from collections.abc import Callable, Collection
-from typing import IO, Any
-from typing_extensions import Literal, TypeAlias
+from typing import IO, Any, Literal
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 __all__ = ("create_subprocess_exec", "create_subprocess_shell")
 
-if sys.version_info >= (3, 8):
-    _ExecArg: TypeAlias = StrOrBytesPath
-else:
-    _ExecArg: TypeAlias = str | bytes
-
 PIPE: int
 STDOUT: int
 DEVNULL: int
@@ -54,7 +49,7 @@ if sys.version_info >= (3, 11):
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
-        text: Literal[False, None] = None,
+        text: Literal[False] | None = None,
         # These parameters are taken by subprocess.Popen, which this ultimately delegates to
         executable: StrOrBytesPath | None = None,
         preexec_fn: Callable[[], Any] | None = None,
@@ -74,20 +69,20 @@ if sys.version_info >= (3, 11):
         pipesize: int = -1,
     ) -> Process: ...
     async def create_subprocess_exec(
-        program: _ExecArg,
-        *args: _ExecArg,
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
         stdin: int | IO[Any] | None = None,
         stdout: int | IO[Any] | None = None,
         stderr: int | IO[Any] | None = None,
         limit: int = 65536,
-        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
         universal_newlines: Literal[False] = False,
-        shell: Literal[True] = True,
+        shell: Literal[False] = False,
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
+        text: Literal[False] | None = None,
         # These parameters are taken by subprocess.Popen, which this ultimately delegates to
-        text: bool | None = None,
         executable: StrOrBytesPath | None = None,
         preexec_fn: Callable[[], Any] | None = None,
         close_fds: bool = True,
@@ -120,7 +115,7 @@ elif sys.version_info >= (3, 10):
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
-        text: Literal[False, None] = None,
+        text: Literal[False] | None = None,
         # These parameters are taken by subprocess.Popen, which this ultimately delegates to
         executable: StrOrBytesPath | None = None,
         preexec_fn: Callable[[], Any] | None = None,
@@ -139,20 +134,20 @@ elif sys.version_info >= (3, 10):
         pipesize: int = -1,
     ) -> Process: ...
     async def create_subprocess_exec(
-        program: _ExecArg,
-        *args: _ExecArg,
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
         stdin: int | IO[Any] | None = None,
         stdout: int | IO[Any] | None = None,
         stderr: int | IO[Any] | None = None,
         limit: int = 65536,
-        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
         universal_newlines: Literal[False] = False,
-        shell: Literal[True] = True,
+        shell: Literal[False] = False,
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
+        text: Literal[False] | None = None,
         # These parameters are taken by subprocess.Popen, which this ultimately delegates to
-        text: bool | None = None,
         executable: StrOrBytesPath | None = None,
         preexec_fn: Callable[[], Any] | None = None,
         close_fds: bool = True,
@@ -185,7 +180,7 @@ else:  # >= 3.9
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
-        text: Literal[False, None] = None,
+        text: Literal[False] | None = None,
         # These parameters are taken by subprocess.Popen, which this ultimately delegates to
         executable: StrOrBytesPath | None = None,
         preexec_fn: Callable[[], Any] | None = None,
@@ -203,21 +198,21 @@ else:  # >= 3.9
         umask: int = -1,
     ) -> Process: ...
     async def create_subprocess_exec(
-        program: _ExecArg,
-        *args: _ExecArg,
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
         stdin: int | IO[Any] | None = None,
         stdout: int | IO[Any] | None = None,
         stderr: int | IO[Any] | None = None,
         loop: events.AbstractEventLoop | None = None,
         limit: int = 65536,
-        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
         universal_newlines: Literal[False] = False,
-        shell: Literal[True] = True,
+        shell: Literal[False] = False,
         bufsize: Literal[0] = 0,
         encoding: None = None,
         errors: None = None,
+        text: Literal[False] | None = None,
         # These parameters are taken by subprocess.Popen, which this ultimately delegates to
-        text: bool | None = None,
         executable: StrOrBytesPath | None = None,
         preexec_fn: Callable[[], Any] | None = None,
         close_fds: bool = True,
diff --git a/mypy/typeshed/stdlib/asyncio/taskgroups.pyi b/mypy/typeshed/stdlib/asyncio/taskgroups.pyi
index 08ea8f66559c..30b7c9129f6f 100644
--- a/mypy/typeshed/stdlib/asyncio/taskgroups.pyi
+++ b/mypy/typeshed/stdlib/asyncio/taskgroups.pyi
@@ -1,18 +1,26 @@
-# This only exists in 3.11+. See VERSIONS.
-
+import sys
 from contextvars import Context
 from types import TracebackType
-from typing import TypeVar
+from typing import Any, TypeVar
 from typing_extensions import Self
 
 from . import _CoroutineLike
+from .events import AbstractEventLoop
 from .tasks import Task
 
-__all__ = ["TaskGroup"]
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.version_info >= (3, 12):
+    __all__ = ("TaskGroup",)
+else:
+    __all__ = ["TaskGroup"]
 
 _T = TypeVar("_T")
 
 class TaskGroup:
+    _loop: AbstractEventLoop | None
+    _tasks: set[Task[Any]]
+
     async def __aenter__(self) -> Self: ...
     async def __aexit__(self, et: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> None: ...
     def create_task(self, coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]: ...
+    def _on_task_done(self, task: Task[object]) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/tasks.pyi b/mypy/typeshed/stdlib/asyncio/tasks.pyi
index d8c101f281fc..f6ee109915e0 100644
--- a/mypy/typeshed/stdlib/asyncio/tasks.pyi
+++ b/mypy/typeshed/stdlib/asyncio/tasks.pyi
@@ -1,40 +1,70 @@
 import concurrent.futures
 import sys
-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
+from _asyncio import (
+    Task as Task,
+    _enter_task as _enter_task,
+    _leave_task as _leave_task,
+    _register_task as _register_task,
+    _unregister_task as _unregister_task,
+)
+from collections.abc import AsyncIterator, Awaitable, Coroutine, Generator, Iterable, Iterator
+from typing import Any, Literal, Protocol, TypeVar, overload
+from typing_extensions import TypeAlias
 
 from . import _CoroutineLike
 from .events import AbstractEventLoop
 from .futures import Future
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
 if sys.version_info >= (3, 11):
     from contextvars import Context
 
-__all__ = (
-    "Task",
-    "create_task",
-    "FIRST_COMPLETED",
-    "FIRST_EXCEPTION",
-    "ALL_COMPLETED",
-    "wait",
-    "wait_for",
-    "as_completed",
-    "sleep",
-    "gather",
-    "shield",
-    "ensure_future",
-    "run_coroutine_threadsafe",
-    "current_task",
-    "all_tasks",
-    "_register_task",
-    "_unregister_task",
-    "_enter_task",
-    "_leave_task",
-)
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.version_info >= (3, 12):
+    __all__ = (
+        "Task",
+        "create_task",
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "wait",
+        "wait_for",
+        "as_completed",
+        "sleep",
+        "gather",
+        "shield",
+        "ensure_future",
+        "run_coroutine_threadsafe",
+        "current_task",
+        "all_tasks",
+        "create_eager_task_factory",
+        "eager_task_factory",
+        "_register_task",
+        "_unregister_task",
+        "_enter_task",
+        "_leave_task",
+    )
+else:
+    __all__ = (
+        "Task",
+        "create_task",
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "wait",
+        "wait_for",
+        "as_completed",
+        "sleep",
+        "gather",
+        "shield",
+        "ensure_future",
+        "run_coroutine_threadsafe",
+        "current_task",
+        "all_tasks",
+        "_register_task",
+        "_unregister_task",
+        "_enter_task",
+        "_leave_task",
+    )
 
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
@@ -43,15 +73,25 @@ _T2 = TypeVar("_T2")
 _T3 = TypeVar("_T3")
 _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
+_T6 = TypeVar("_T6")
 _FT = TypeVar("_FT", bound=Future[Any])
-_FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
+if sys.version_info >= (3, 12):
+    _FutureLike: TypeAlias = Future[_T] | Awaitable[_T]
+else:
+    _FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
+
 _TaskYieldType: TypeAlias = Future[object] | None
 
 FIRST_COMPLETED = concurrent.futures.FIRST_COMPLETED
 FIRST_EXCEPTION = concurrent.futures.FIRST_EXCEPTION
 ALL_COMPLETED = concurrent.futures.ALL_COMPLETED
 
-if sys.version_info >= (3, 10):
+if sys.version_info >= (3, 13):
+    class _SyncAndAsyncIterator(Iterator[_T_co], AsyncIterator[_T_co], Protocol[_T_co]): ...
+
+    def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> _SyncAndAsyncIterator[Future[_T]]: ...
+
+elif sys.version_info >= (3, 10):
     def as_completed(fs: Iterable[_FutureLike[_T]], *, timeout: float | None = None) -> Iterator[Future[_T]]: ...
 
 else:
@@ -60,7 +100,7 @@ else:
     ) -> Iterator[Future[_T]]: ...
 
 @overload
-def ensure_future(coro_or_future: _FT, *, loop: AbstractEventLoop | None = None) -> _FT: ...  # type: ignore[misc]
+def ensure_future(coro_or_future: _FT, *, loop: AbstractEventLoop | None = None) -> _FT: ...  # type: ignore[overload-overlap]
 @overload
 def ensure_future(coro_or_future: Awaitable[_T], *, loop: AbstractEventLoop | None = None) -> Task[_T]: ...
 
@@ -69,173 +109,247 @@ def ensure_future(coro_or_future: Awaitable[_T], *, loop: AbstractEventLoop | No
 # zip() because typing does not support variadic type variables.  See
 # typing PR #1550 for discussion.
 #
-# The many type: ignores here are because the overloads overlap,
-# but having overlapping overloads is the only way to get acceptable type inference in all edge cases.
+# N.B. Having overlapping overloads is the only way to get acceptable type inference in all edge cases.
 if sys.version_info >= (3, 10):
     @overload
-    def gather(__coro_or_future1: _FutureLike[_T1], *, return_exceptions: Literal[False] = False) -> Future[tuple[_T1]]: ...  # type: ignore[misc]
+    def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: Literal[False] = False) -> Future[tuple[_T1]]: ...  # type: ignore[overload-overlap]
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1], __coro_or_future2: _FutureLike[_T2], *, return_exceptions: Literal[False] = False
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1], coro_or_future2: _FutureLike[_T2], /, *, return_exceptions: Literal[False] = False
     ) -> Future[tuple[_T1, _T2]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        /,
         *,
         return_exceptions: Literal[False] = False,
     ) -> Future[tuple[_T1, _T2, _T3]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        /,
         *,
         return_exceptions: Literal[False] = False,
     ) -> Future[tuple[_T1, _T2, _T3, _T4]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
-        __coro_or_future5: _FutureLike[_T5],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        coro_or_future5: _FutureLike[_T5],
+        /,
         *,
         return_exceptions: Literal[False] = False,
     ) -> Future[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
     @overload
-    def gather(__coro_or_future1: _FutureLike[_T1], *, return_exceptions: bool) -> Future[tuple[_T1 | BaseException]]: ...  # type: ignore[misc]
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        coro_or_future5: _FutureLike[_T5],
+        coro_or_future6: _FutureLike[_T6],
+        /,
+        *,
+        return_exceptions: Literal[False] = False,
+    ) -> Future[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
+    @overload
+    def gather(*coros_or_futures: _FutureLike[_T], return_exceptions: Literal[False] = False) -> Future[list[_T]]: ...  # type: ignore[overload-overlap]
+    @overload
+    def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: bool) -> Future[tuple[_T1 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1], __coro_or_future2: _FutureLike[_T2], *, return_exceptions: bool
+    def gather(
+        coro_or_future1: _FutureLike[_T1], coro_or_future2: _FutureLike[_T2], /, *, return_exceptions: bool
     ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
+    def gather(
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        /,
         *,
         return_exceptions: bool,
     ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
+    def gather(
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        /,
         *,
         return_exceptions: bool,
     ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
-        __coro_or_future5: _FutureLike[_T5],
+    def gather(
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        coro_or_future5: _FutureLike[_T5],
+        /,
         *,
         return_exceptions: bool,
     ) -> Future[
         tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException, _T5 | BaseException]
     ]: ...
     @overload
-    def gather(*coros_or_futures: _FutureLike[Any], return_exceptions: bool = False) -> Future[list[Any]]: ...
+    def gather(
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        coro_or_future5: _FutureLike[_T5],
+        coro_or_future6: _FutureLike[_T6],
+        /,
+        *,
+        return_exceptions: bool,
+    ) -> Future[
+        tuple[
+            _T1 | BaseException,
+            _T2 | BaseException,
+            _T3 | BaseException,
+            _T4 | BaseException,
+            _T5 | BaseException,
+            _T6 | BaseException,
+        ]
+    ]: ...
+    @overload
+    def gather(*coros_or_futures: _FutureLike[_T], return_exceptions: bool) -> Future[list[_T | BaseException]]: ...
 
 else:
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1], *, loop: AbstractEventLoop | None = None, return_exceptions: Literal[False] = False
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1], /, *, loop: AbstractEventLoop | None = None, return_exceptions: Literal[False] = False
     ) -> Future[tuple[_T1]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: Literal[False] = False,
     ) -> Future[tuple[_T1, _T2]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: Literal[False] = False,
     ) -> Future[tuple[_T1, _T2, _T3]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: Literal[False] = False,
     ) -> Future[tuple[_T1, _T2, _T3, _T4]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
-        __coro_or_future5: _FutureLike[_T5],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        coro_or_future5: _FutureLike[_T5],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: Literal[False] = False,
     ) -> Future[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1], *, loop: AbstractEventLoop | None = None, return_exceptions: bool
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        coro_or_future5: _FutureLike[_T5],
+        coro_or_future6: _FutureLike[_T6],
+        /,
+        *,
+        loop: AbstractEventLoop | None = None,
+        return_exceptions: Literal[False] = False,
+    ) -> Future[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
+    @overload
+    def gather(  # type: ignore[overload-overlap]
+        *coros_or_futures: _FutureLike[_T], loop: AbstractEventLoop | None = None, return_exceptions: Literal[False] = False
+    ) -> Future[list[_T]]: ...
+    @overload
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1], /, *, loop: AbstractEventLoop | None = None, return_exceptions: bool
     ) -> Future[tuple[_T1 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: bool,
     ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: bool,
     ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: bool,
     ) -> Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException]]: ...
     @overload
-    def gather(  # type: ignore[misc]
-        __coro_or_future1: _FutureLike[_T1],
-        __coro_or_future2: _FutureLike[_T2],
-        __coro_or_future3: _FutureLike[_T3],
-        __coro_or_future4: _FutureLike[_T4],
-        __coro_or_future5: _FutureLike[_T5],
+    def gather(  # type: ignore[overload-overlap]
+        coro_or_future1: _FutureLike[_T1],
+        coro_or_future2: _FutureLike[_T2],
+        coro_or_future3: _FutureLike[_T3],
+        coro_or_future4: _FutureLike[_T4],
+        coro_or_future5: _FutureLike[_T5],
+        coro_or_future6: _FutureLike[_T6],
+        /,
         *,
         loop: AbstractEventLoop | None = None,
         return_exceptions: bool,
     ) -> Future[
-        tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException, _T5 | BaseException]
+        tuple[
+            _T1 | BaseException,
+            _T2 | BaseException,
+            _T3 | BaseException,
+            _T4 | BaseException,
+            _T5 | BaseException,
+            _T6 | BaseException,
+        ]
     ]: ...
     @overload
     def gather(
-        *coros_or_futures: _FutureLike[Any], loop: AbstractEventLoop | None = None, return_exceptions: bool = False
-    ) -> Future[list[Any]]: ...
+        *coros_or_futures: _FutureLike[_T], loop: AbstractEventLoop | None = None, return_exceptions: bool
+    ) -> Future[list[_T | BaseException]]: ...
 
-def run_coroutine_threadsafe(coro: _FutureLike[_T], loop: AbstractEventLoop) -> concurrent.futures.Future[_T]: ...
+# unlike some asyncio apis, This does strict runtime checking of actually being a coroutine, not of any future-like.
+def run_coroutine_threadsafe(coro: Coroutine[Any, Any, _T], loop: AbstractEventLoop) -> concurrent.futures.Future[_T]: ...
 
 if sys.version_info >= (3, 10):
     def shield(arg: _FutureLike[_T]) -> Future[_T]: ...
@@ -243,12 +357,6 @@ if sys.version_info >= (3, 10):
     async def sleep(delay: float) -> None: ...
     @overload
     async def sleep(delay: float, result: _T) -> _T: ...
-    @overload
-    async def wait(fs: Iterable[_FT], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED") -> tuple[set[_FT], set[_FT]]: ...  # type: ignore[misc]
-    @overload
-    async def wait(
-        fs: Iterable[Awaitable[_T]], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
-    ) -> tuple[set[Task[_T]], set[Task[_T]]]: ...
     async def wait_for(fut: _FutureLike[_T], timeout: float | None) -> _T: ...
 
 else:
@@ -257,8 +365,31 @@ else:
     async def sleep(delay: float, *, loop: AbstractEventLoop | None = None) -> None: ...
     @overload
     async def sleep(delay: float, result: _T, *, loop: AbstractEventLoop | None = None) -> _T: ...
+    async def wait_for(fut: _FutureLike[_T], timeout: float | None, *, loop: AbstractEventLoop | None = None) -> _T: ...
+
+if sys.version_info >= (3, 11):
+    @overload
+    async def wait(
+        fs: Iterable[_FT], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> tuple[set[_FT], set[_FT]]: ...
+    @overload
+    async def wait(
+        fs: Iterable[Task[_T]], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> tuple[set[Task[_T]], set[Task[_T]]]: ...
+
+elif sys.version_info >= (3, 10):
+    @overload
+    async def wait(  # type: ignore[overload-overlap]
+        fs: Iterable[_FT], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> tuple[set[_FT], set[_FT]]: ...
     @overload
-    async def wait(  # type: ignore[misc]
+    async def wait(
+        fs: Iterable[Awaitable[_T]], *, timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> tuple[set[Task[_T]], set[Task[_T]]]: ...
+
+else:
+    @overload
+    async def wait(  # type: ignore[overload-overlap]
         fs: Iterable[_FT],
         *,
         loop: AbstractEventLoop | None = None,
@@ -273,55 +404,59 @@ else:
         timeout: float | None = None,
         return_when: str = "ALL_COMPLETED",
     ) -> 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]
+elif sys.version_info >= (3, 9):
+    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | 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,
-# and `asyncio.Task.set_result()` always raises.
-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: _TaskCompatibleCoro[_T_co], *, loop: AbstractEventLoop = ..., name: str | None = ...
-        ) -> None: ...
-    else:
-        def __init__(self, coro: _TaskCompatibleCoro[_T_co], *, loop: AbstractEventLoop = ...) -> None: ...
-    if sys.version_info >= (3, 8):
-        def get_coro(self) -> _TaskCompatibleCoro[_T_co]: ...
-        def get_name(self) -> str: ...
-        def set_name(self, __value: object) -> None: ...
-
-    def get_stack(self, *, limit: int | None = None) -> list[FrameType]: ...
-    def print_stack(self, *, limit: int | None = None, file: TextIO | None = None) -> None: ...
-    if sys.version_info >= (3, 11):
-        def cancelling(self) -> int: ...
-        def uncancel(self) -> int: ...
-    if sys.version_info < (3, 9):
-        @classmethod
-        def current_task(cls, loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
-        @classmethod
-        def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
 def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
 
 if sys.version_info >= (3, 11):
     def create_task(coro: _CoroutineLike[_T], *, name: str | None = None, context: Context | None = None) -> Task[_T]: ...
 
-elif sys.version_info >= (3, 8):
+else:
     def create_task(coro: _CoroutineLike[_T], *, name: str | None = None) -> Task[_T]: ...
 
+if sys.version_info >= (3, 12):
+    from _asyncio import current_task as current_task
 else:
-    def create_task(coro: _CoroutineLike[_T]) -> Task[_T]: ...
+    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
+
+if sys.version_info >= (3, 12):
+    _TaskT_co = TypeVar("_TaskT_co", bound=Task[Any], covariant=True)
 
-def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
-def _enter_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
-def _leave_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
-def _register_task(task: Task[Any]) -> None: ...
-def _unregister_task(task: Task[Any]) -> None: ...
+    class _CustomTaskConstructor(Protocol[_TaskT_co]):
+        def __call__(
+            self,
+            coro: _TaskCompatibleCoro[Any],
+            /,
+            *,
+            loop: AbstractEventLoop,
+            name: str | None,
+            context: Context | None,
+            eager_start: bool,
+        ) -> _TaskT_co: ...
+
+    class _EagerTaskFactoryType(Protocol[_TaskT_co]):
+        def __call__(
+            self,
+            loop: AbstractEventLoop,
+            coro: _TaskCompatibleCoro[Any],
+            *,
+            name: str | None = None,
+            context: Context | None = None,
+        ) -> _TaskT_co: ...
+
+    def create_eager_task_factory(
+        custom_task_constructor: _CustomTaskConstructor[_TaskT_co],
+    ) -> _EagerTaskFactoryType[_TaskT_co]: ...
+    def eager_task_factory(
+        loop: AbstractEventLoop | None,
+        coro: _TaskCompatibleCoro[_T_co],
+        *,
+        name: str | None = None,
+        context: Context | None = None,
+    ) -> Task[_T_co]: ...
diff --git a/mypy/typeshed/stdlib/asyncio/threads.pyi b/mypy/typeshed/stdlib/asyncio/threads.pyi
index 88c4fddcaa3f..00aae2ea814c 100644
--- a/mypy/typeshed/stdlib/asyncio/threads.pyi
+++ b/mypy/typeshed/stdlib/asyncio/threads.pyi
@@ -2,8 +2,9 @@ from collections.abc import Callable
 from typing import TypeVar
 from typing_extensions import ParamSpec
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 __all__ = ("to_thread",)
 _P = ParamSpec("_P")
 _R = TypeVar("_R")
 
-async def to_thread(__func: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+async def to_thread(func: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
diff --git a/mypy/typeshed/stdlib/asyncio/timeouts.pyi b/mypy/typeshed/stdlib/asyncio/timeouts.pyi
index 2d31b777b77d..668cccbfe8b1 100644
--- a/mypy/typeshed/stdlib/asyncio/timeouts.pyi
+++ b/mypy/typeshed/stdlib/asyncio/timeouts.pyi
@@ -1,6 +1,8 @@
 from types import TracebackType
-from typing_extensions import Self, final
+from typing import final
+from typing_extensions import Self
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 __all__ = ("Timeout", "timeout", "timeout_at")
 
 @final
diff --git a/mypy/typeshed/stdlib/asyncio/transports.pyi b/mypy/typeshed/stdlib/asyncio/transports.pyi
index 531f77672438..bce54897f18f 100644
--- a/mypy/typeshed/stdlib/asyncio/transports.pyi
+++ b/mypy/typeshed/stdlib/asyncio/transports.pyi
@@ -4,6 +4,7 @@ from collections.abc import Iterable, Mapping
 from socket import _Address
 from typing import Any
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 __all__ = ("BaseTransport", "ReadTransport", "WriteTransport", "Transport", "DatagramTransport", "SubprocessTransport")
 
 class BaseTransport:
@@ -23,8 +24,10 @@ class WriteTransport(BaseTransport):
     def set_write_buffer_limits(self, high: int | None = None, low: int | None = None) -> None: ...
     def get_write_buffer_size(self) -> int: ...
     def get_write_buffer_limits(self) -> tuple[int, int]: ...
-    def write(self, data: bytes | bytearray | memoryview) -> None: ...
-    def writelines(self, list_of_data: Iterable[bytes | bytearray | memoryview]) -> None: ...
+    def write(self, data: bytes | bytearray | memoryview[Any]) -> None: ...  # any memoryview format or shape
+    def writelines(
+        self, list_of_data: Iterable[bytes | bytearray | memoryview[Any]]
+    ) -> None: ...  # any memoryview format or shape
     def write_eof(self) -> None: ...
     def can_write_eof(self) -> bool: ...
     def abort(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/asyncio/trsock.pyi b/mypy/typeshed/stdlib/asyncio/trsock.pyi
index 742216a84ccd..e74cf6fd4e05 100644
--- a/mypy/typeshed/stdlib/asyncio/trsock.pyi
+++ b/mypy/typeshed/stdlib/asyncio/trsock.pyi
@@ -51,7 +51,7 @@ class TransportSocket:
         else:
             def ioctl(self, control: int, option: int | tuple[int, int, int] | bool) -> NoReturn: ...
 
-        def listen(self, __backlog: int = ...) -> None: ...
+        def listen(self, backlog: int = ..., /) -> None: ...
         def makefile(self) -> BinaryIO: ...
         def sendfile(self, file: BinaryIO, offset: int = ..., count: int | None = ...) -> int: ...
         def close(self) -> None: ...
@@ -66,11 +66,7 @@ class TransportSocket:
             ) -> NoReturn: ...
 
         def sendmsg(
-            self,
-            __buffers: Iterable[ReadableBuffer],
-            __ancdata: Iterable[_CMSG] = ...,
-            __flags: int = ...,
-            __address: _Address = ...,
+            self, buffers: Iterable[ReadableBuffer], ancdata: Iterable[_CMSG] = ..., flags: int = ..., address: _Address = ..., /
         ) -> int: ...
         @overload
         def sendto(self, data: ReadableBuffer, address: _Address) -> int: ...
@@ -87,9 +83,9 @@ class TransportSocket:
         def recv_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> int: ...
         def recvfrom_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> tuple[int, _RetAddress]: ...
         def recvmsg_into(
-            self, __buffers: Iterable[_WriteBuffer], __ancbufsize: int = ..., __flags: int = ...
+            self, buffers: Iterable[_WriteBuffer], ancbufsize: int = ..., flags: int = ..., /
         ) -> tuple[int, list[_CMSG], int, Any]: ...
-        def recvmsg(self, __bufsize: int, __ancbufsize: int = ..., __flags: int = ...) -> tuple[bytes, list[_CMSG], int, Any]: ...
+        def recvmsg(self, bufsize: int, ancbufsize: int = ..., flags: int = ..., /) -> tuple[bytes, list[_CMSG], int, Any]: ...
         def recvfrom(self, bufsize: int, flags: int = ...) -> tuple[bytes, _RetAddress]: ...
         def recv(self, bufsize: int, flags: int = ...) -> bytes: ...
         def __enter__(self) -> socket.socket: ...
diff --git a/mypy/typeshed/stdlib/asyncio/unix_events.pyi b/mypy/typeshed/stdlib/asyncio/unix_events.pyi
index e28d64b5287b..abf5d7ffd699 100644
--- a/mypy/typeshed/stdlib/asyncio/unix_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/unix_events.pyi
@@ -1,35 +1,24 @@
 import sys
 import types
+from _typeshed import StrPath
 from abc import ABCMeta, abstractmethod
 from collections.abc import Callable
-from typing import Any
-from typing_extensions import Literal, Self
+from socket import socket
+from typing import Literal
+from typing_extensions import Self, TypeVarTuple, Unpack, deprecated
 
+from .base_events import Server, _ProtocolFactory, _SSLContext
 from .events import AbstractEventLoop, BaseDefaultEventLoopPolicy
 from .selector_events import BaseSelectorEventLoop
 
-# This is also technically not available on Win,
-# but other parts of typeshed need this definition.
-# So, it is special cased.
-class AbstractChildWatcher:
-    @abstractmethod
-    def add_child_handler(self, pid: int, callback: Callable[..., object], *args: Any) -> None: ...
-    @abstractmethod
-    def remove_child_handler(self, pid: int) -> bool: ...
-    @abstractmethod
-    def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-    @abstractmethod
-    def close(self) -> None: ...
-    @abstractmethod
-    def __enter__(self) -> Self: ...
-    @abstractmethod
-    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None) -> None: ...
-    if sys.version_info >= (3, 8):
-        @abstractmethod
-        def is_active(self) -> bool: ...
+_Ts = TypeVarTuple("_Ts")
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.platform != "win32":
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 14):
+        __all__ = ("SelectorEventLoop", "DefaultEventLoopPolicy", "EventLoop")
+    elif sys.version_info >= (3, 13):
+        # Adds EventLoop
         __all__ = (
             "SelectorEventLoop",
             "AbstractChildWatcher",
@@ -39,69 +28,203 @@ if sys.platform != "win32":
             "MultiLoopChildWatcher",
             "ThreadedChildWatcher",
             "DefaultEventLoopPolicy",
+            "EventLoop",
         )
-    elif sys.version_info >= (3, 8):
+    elif sys.version_info >= (3, 9):
+        # adds PidfdChildWatcher
         __all__ = (
             "SelectorEventLoop",
             "AbstractChildWatcher",
             "SafeChildWatcher",
             "FastChildWatcher",
+            "PidfdChildWatcher",
             "MultiLoopChildWatcher",
             "ThreadedChildWatcher",
             "DefaultEventLoopPolicy",
         )
     else:
-        __all__ = ("SelectorEventLoop", "AbstractChildWatcher", "SafeChildWatcher", "FastChildWatcher", "DefaultEventLoopPolicy")
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
 
-    # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
-    # See discussion in #7412
-    class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
-        def close(self) -> None: ...
-        if sys.version_info >= (3, 8):
+# This is also technically not available on Win,
+# but other parts of typeshed need this definition.
+# So, it is special cased.
+if sys.version_info < (3, 14):
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
             def is_active(self) -> bool: ...
 
-        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+    else:
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
+
+if sys.platform != "win32":
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+            # See discussion in #7412
+            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+                def close(self) -> None: ...
+                def is_active(self) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class SafeChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
 
-    class SafeChildWatcher(BaseChildWatcher):
-        def __enter__(self) -> Self: ...
-        def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-        def add_child_handler(self, pid: int, callback: Callable[..., object], *args: Any) -> None: ...
-        def remove_child_handler(self, pid: int) -> bool: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
 
-    class FastChildWatcher(BaseChildWatcher):
-        def __enter__(self) -> Self: ...
-        def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-        def add_child_handler(self, pid: int, callback: Callable[..., object], *args: Any) -> None: ...
-        def remove_child_handler(self, pid: int) -> bool: ...
+        else:
+            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+            # See discussion in #7412
+            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+                def close(self) -> None: ...
+                def is_active(self) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-    class _UnixSelectorEventLoop(BaseSelectorEventLoop): ...
+            class SafeChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+    class _UnixSelectorEventLoop(BaseSelectorEventLoop):
+        if sys.version_info >= (3, 13):
+            async def create_unix_server(
+                self,
+                protocol_factory: _ProtocolFactory,
+                path: StrPath | None = None,
+                *,
+                sock: socket | None = None,
+                backlog: int = 100,
+                ssl: _SSLContext = None,
+                ssl_handshake_timeout: float | None = None,
+                ssl_shutdown_timeout: float | None = None,
+                start_serving: bool = True,
+                cleanup_socket: bool = True,
+            ) -> Server: ...
 
     class _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy):
-        def get_child_watcher(self) -> AbstractChildWatcher: ...
-        def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+        if sys.version_info < (3, 14):
+            if sys.version_info >= (3, 12):
+                @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+            else:
+                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+
     SelectorEventLoop = _UnixSelectorEventLoop
 
     DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
 
-    if sys.version_info >= (3, 8):
-        from typing import Protocol
+    if sys.version_info >= (3, 13):
+        EventLoop = SelectorEventLoop
 
-        class _Warn(Protocol):
-            def __call__(
-                self, message: str, category: type[Warning] | None = ..., stacklevel: int = ..., source: Any | None = ...
-            ) -> object: ...
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class MultiLoopChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-        class MultiLoopChildWatcher(AbstractChildWatcher):
-            def is_active(self) -> bool: ...
-            def close(self) -> None: ...
-            def __enter__(self) -> Self: ...
-            def __exit__(
-                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-            ) -> None: ...
-            def add_child_handler(self, pid: int, callback: Callable[..., object], *args: Any) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
-            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+        else:
+            class MultiLoopChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
+    if sys.version_info < (3, 14):
         class ThreadedChildWatcher(AbstractChildWatcher):
             def is_active(self) -> Literal[True]: ...
             def close(self) -> None: ...
@@ -109,19 +232,23 @@ if sys.platform != "win32":
             def __exit__(
                 self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
             ) -> None: ...
-            def __del__(self, _warn: _Warn = ...) -> None: ...
-            def add_child_handler(self, pid: int, callback: Callable[..., object], *args: Any) -> None: ...
+            def __del__(self) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
             def remove_child_handler(self, pid: int) -> bool: ...
             def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-    if sys.version_info >= (3, 9):
-        class PidfdChildWatcher(AbstractChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(
-                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-            ) -> None: ...
-            def is_active(self) -> bool: ...
-            def close(self) -> None: ...
-            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-            def add_child_handler(self, pid: int, callback: Callable[..., object], *args: Any) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+        if sys.version_info >= (3, 9):
+            class PidfdChildWatcher(AbstractChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
diff --git a/mypy/typeshed/stdlib/asyncio/windows_events.pyi b/mypy/typeshed/stdlib/asyncio/windows_events.pyi
index 2942a25c0ac4..2ffc2eccb228 100644
--- a/mypy/typeshed/stdlib/asyncio/windows_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/windows_events.pyi
@@ -1,26 +1,38 @@
 import socket
 import sys
-from _typeshed import Incomplete, WriteableBuffer
+from _typeshed import Incomplete, ReadableBuffer, WriteableBuffer
 from collections.abc import Callable
-from typing import IO, Any, ClassVar, NoReturn
-from typing_extensions import Literal
+from typing import IO, Any, ClassVar, Final, NoReturn
 
 from . import events, futures, proactor_events, selector_events, streams, windows_utils
 
+# Keep asyncio.__all__ updated with any changes to __all__ here
 if sys.platform == "win32":
-    __all__ = (
-        "SelectorEventLoop",
-        "ProactorEventLoop",
-        "IocpProactor",
-        "DefaultEventLoopPolicy",
-        "WindowsSelectorEventLoopPolicy",
-        "WindowsProactorEventLoopPolicy",
-    )
+    if sys.version_info >= (3, 13):
+        # 3.13 added `EventLoop`.
+        __all__ = (
+            "SelectorEventLoop",
+            "ProactorEventLoop",
+            "IocpProactor",
+            "DefaultEventLoopPolicy",
+            "WindowsSelectorEventLoopPolicy",
+            "WindowsProactorEventLoopPolicy",
+            "EventLoop",
+        )
+    else:
+        __all__ = (
+            "SelectorEventLoop",
+            "ProactorEventLoop",
+            "IocpProactor",
+            "DefaultEventLoopPolicy",
+            "WindowsSelectorEventLoopPolicy",
+            "WindowsProactorEventLoopPolicy",
+        )
 
-    NULL: Literal[0]
-    INFINITE: Literal[0xFFFFFFFF]
-    ERROR_CONNECTION_REFUSED: Literal[1225]
-    ERROR_CONNECTION_ABORTED: Literal[1236]
+    NULL: Final = 0
+    INFINITE: Final = 0xFFFFFFFF
+    ERROR_CONNECTION_REFUSED: Final = 1225
+    ERROR_CONNECTION_ABORTED: Final = 1236
     CONNECT_PIPE_INIT_DELAY: float
     CONNECT_PIPE_MAX_DELAY: float
 
@@ -48,6 +60,12 @@ if sys.platform == "win32":
         def select(self, timeout: int | None = None) -> list[futures.Future[Any]]: ...
         def recv(self, conn: socket.socket, nbytes: int, flags: int = 0) -> futures.Future[bytes]: ...
         def recv_into(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
+        def recvfrom(
+            self, conn: socket.socket, nbytes: int, flags: int = 0
+        ) -> futures.Future[tuple[bytes, socket._RetAddress]]: ...
+        def sendto(
+            self, conn: socket.socket, buf: ReadableBuffer, flags: int = 0, addr: socket._Address | None = None
+        ) -> futures.Future[int]: ...
         def send(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
         def accept(self, listener: socket.socket) -> futures.Future[Any]: ...
         def connect(
@@ -60,15 +78,24 @@ if sys.platform == "win32":
         async def connect_pipe(self, address: str) -> windows_utils.PipeHandle: ...
         def wait_for_handle(self, handle: windows_utils.PipeHandle, timeout: int | None = None) -> bool: ...
         def close(self) -> None: ...
+        if sys.version_info >= (3, 11):
+            def recvfrom_into(
+                self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
+            ) -> futures.Future[tuple[int, socket._RetAddress]]: ...
+
     SelectorEventLoop = _WindowsSelectorEventLoop
 
     class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[SelectorEventLoop]]
-        def get_child_watcher(self) -> NoReturn: ...
-        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+        if sys.version_info < (3, 14):
+            def get_child_watcher(self) -> NoReturn: ...
+            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
 
     class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[ProactorEventLoop]]
         def get_child_watcher(self) -> NoReturn: ...
         def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
     DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy
+    if sys.version_info >= (3, 13):
+        EventLoop = ProactorEventLoop
diff --git a/mypy/typeshed/stdlib/asyncio/windows_utils.pyi b/mypy/typeshed/stdlib/asyncio/windows_utils.pyi
index 9f88718b7b70..4fa014532376 100644
--- a/mypy/typeshed/stdlib/asyncio/windows_utils.pyi
+++ b/mypy/typeshed/stdlib/asyncio/windows_utils.pyi
@@ -2,28 +2,20 @@ import subprocess
 import sys
 from collections.abc import Callable
 from types import TracebackType
-from typing import Any, AnyStr, Protocol
-from typing_extensions import Literal, Self
+from typing import Any, AnyStr, Final
+from typing_extensions import Self
 
 if sys.platform == "win32":
     __all__ = ("pipe", "Popen", "PIPE", "PipeHandle")
 
-    class _WarnFunction(Protocol):
-        def __call__(
-            self, message: str, category: type[Warning] = ..., stacklevel: int = ..., source: PipeHandle = ...
-        ) -> object: ...
-    BUFSIZE: Literal[8192]
+    BUFSIZE: Final = 8192
     PIPE = subprocess.PIPE
     STDOUT = subprocess.STDOUT
     def pipe(*, duplex: bool = False, overlapped: tuple[bool, bool] = (True, True), bufsize: int = 8192) -> tuple[int, int]: ...
 
     class PipeHandle:
         def __init__(self, handle: int) -> None: ...
-        if sys.version_info >= (3, 8):
-            def __del__(self, _warn: _WarnFunction = ...) -> None: ...
-        else:
-            def __del__(self) -> None: ...
-
+        def __del__(self) -> None: ...
         def __enter__(self) -> Self: ...
         def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
         @property
diff --git a/mypy/typeshed/stdlib/asyncore.pyi b/mypy/typeshed/stdlib/asyncore.pyi
index 47c8e2207022..36d1862fdda7 100644
--- a/mypy/typeshed/stdlib/asyncore.pyi
+++ b/mypy/typeshed/stdlib/asyncore.pyi
@@ -83,6 +83,7 @@ if sys.platform != "win32":
         def write(self, data: bytes, flags: int = ...) -> int: ...
         def close(self) -> None: ...
         def fileno(self) -> int: ...
+        def __del__(self) -> None: ...
 
     class file_dispatcher(dispatcher):
         def __init__(self, fd: FileDescriptorLike, map: _MapType | None = None) -> None: ...
diff --git a/mypy/typeshed/stdlib/atexit.pyi b/mypy/typeshed/stdlib/atexit.pyi
index ea041d7b5e46..7f7b05ccc0a3 100644
--- a/mypy/typeshed/stdlib/atexit.pyi
+++ b/mypy/typeshed/stdlib/atexit.pyi
@@ -8,5 +8,5 @@ _P = ParamSpec("_P")
 def _clear() -> None: ...
 def _ncallbacks() -> int: ...
 def _run_exitfuncs() -> None: ...
-def register(func: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
-def unregister(func: Callable[..., object]) -> None: ...
+def register(func: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
+def unregister(func: Callable[..., object], /) -> None: ...
diff --git a/mypy/typeshed/stdlib/audioop.pyi b/mypy/typeshed/stdlib/audioop.pyi
index b5934516e40f..f3ce78ccb7fa 100644
--- a/mypy/typeshed/stdlib/audioop.pyi
+++ b/mypy/typeshed/stdlib/audioop.pyi
@@ -1,42 +1,43 @@
-from typing_extensions import TypeAlias
+from typing_extensions import Buffer, TypeAlias
 
 _AdpcmState: TypeAlias = tuple[int, int]
 _RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
 
 class error(Exception): ...
 
-def add(__fragment1: bytes, __fragment2: bytes, __width: int) -> bytes: ...
-def adpcm2lin(__fragment: bytes, __width: int, __state: _AdpcmState | None) -> tuple[bytes, _AdpcmState]: ...
-def alaw2lin(__fragment: bytes, __width: int) -> bytes: ...
-def avg(__fragment: bytes, __width: int) -> int: ...
-def avgpp(__fragment: bytes, __width: int) -> int: ...
-def bias(__fragment: bytes, __width: int, __bias: int) -> bytes: ...
-def byteswap(__fragment: bytes, __width: int) -> bytes: ...
-def cross(__fragment: bytes, __width: int) -> int: ...
-def findfactor(__fragment: bytes, __reference: bytes) -> float: ...
-def findfit(__fragment: bytes, __reference: bytes) -> tuple[int, float]: ...
-def findmax(__fragment: bytes, __length: int) -> int: ...
-def getsample(__fragment: bytes, __width: int, __index: int) -> int: ...
-def lin2adpcm(__fragment: bytes, __width: int, __state: _AdpcmState | None) -> tuple[bytes, _AdpcmState]: ...
-def lin2alaw(__fragment: bytes, __width: int) -> bytes: ...
-def lin2lin(__fragment: bytes, __width: int, __newwidth: int) -> bytes: ...
-def lin2ulaw(__fragment: bytes, __width: int) -> bytes: ...
-def max(__fragment: bytes, __width: int) -> int: ...
-def maxpp(__fragment: bytes, __width: int) -> int: ...
-def minmax(__fragment: bytes, __width: int) -> tuple[int, int]: ...
-def mul(__fragment: bytes, __width: int, __factor: float) -> bytes: ...
+def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes: ...
+def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+def alaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
+def avg(fragment: Buffer, width: int, /) -> int: ...
+def avgpp(fragment: Buffer, width: int, /) -> int: ...
+def bias(fragment: Buffer, width: int, bias: int, /) -> bytes: ...
+def byteswap(fragment: Buffer, width: int, /) -> bytes: ...
+def cross(fragment: Buffer, width: int, /) -> int: ...
+def findfactor(fragment: Buffer, reference: Buffer, /) -> float: ...
+def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]: ...
+def findmax(fragment: Buffer, length: int, /) -> int: ...
+def getsample(fragment: Buffer, width: int, index: int, /) -> int: ...
+def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]: ...
+def lin2alaw(fragment: Buffer, width: int, /) -> bytes: ...
+def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes: ...
+def lin2ulaw(fragment: Buffer, width: int, /) -> bytes: ...
+def max(fragment: Buffer, width: int, /) -> int: ...
+def maxpp(fragment: Buffer, width: int, /) -> int: ...
+def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]: ...
+def mul(fragment: Buffer, width: int, factor: float, /) -> bytes: ...
 def ratecv(
-    __fragment: bytes,
-    __width: int,
-    __nchannels: int,
-    __inrate: int,
-    __outrate: int,
-    __state: _RatecvState | None,
-    __weightA: int = 1,
-    __weightB: int = 0,
+    fragment: Buffer,
+    width: int,
+    nchannels: int,
+    inrate: int,
+    outrate: int,
+    state: _RatecvState | None,
+    weightA: int = 1,
+    weightB: int = 0,
+    /,
 ) -> tuple[bytes, _RatecvState]: ...
-def reverse(__fragment: bytes, __width: int) -> bytes: ...
-def rms(__fragment: bytes, __width: int) -> int: ...
-def tomono(__fragment: bytes, __width: int, __lfactor: float, __rfactor: float) -> bytes: ...
-def tostereo(__fragment: bytes, __width: int, __lfactor: float, __rfactor: float) -> bytes: ...
-def ulaw2lin(__fragment: bytes, __width: int) -> bytes: ...
+def reverse(fragment: Buffer, width: int, /) -> bytes: ...
+def rms(fragment: Buffer, width: int, /) -> int: ...
+def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes: ...
+def ulaw2lin(fragment: Buffer, width: int, /) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/base64.pyi b/mypy/typeshed/stdlib/base64.pyi
index 24830cbfba04..8be4cfe69de0 100644
--- a/mypy/typeshed/stdlib/base64.pyi
+++ b/mypy/typeshed/stdlib/base64.pyi
@@ -25,15 +25,17 @@ __all__ = [
 
 if sys.version_info >= (3, 10):
     __all__ += ["b32hexencode", "b32hexdecode"]
+if sys.version_info >= (3, 13):
+    __all__ += ["z85decode", "z85encode"]
 
 def b64encode(s: ReadableBuffer, altchars: ReadableBuffer | None = None) -> bytes: ...
-def b64decode(s: str | ReadableBuffer, altchars: ReadableBuffer | None = None, validate: bool = False) -> bytes: ...
+def b64decode(s: str | ReadableBuffer, altchars: str | ReadableBuffer | None = None, validate: bool = False) -> bytes: ...
 def standard_b64encode(s: ReadableBuffer) -> bytes: ...
 def standard_b64decode(s: str | ReadableBuffer) -> bytes: ...
 def urlsafe_b64encode(s: ReadableBuffer) -> bytes: ...
 def urlsafe_b64decode(s: str | ReadableBuffer) -> bytes: ...
 def b32encode(s: ReadableBuffer) -> bytes: ...
-def b32decode(s: str | ReadableBuffer, casefold: bool = False, map01: bytes | None = None) -> bytes: ...
+def b32decode(s: str | ReadableBuffer, casefold: bool = False, map01: str | ReadableBuffer | None = None) -> bytes: ...
 def b16encode(s: ReadableBuffer) -> bytes: ...
 def b16decode(s: str | ReadableBuffer, casefold: bool = False) -> bytes: ...
 
@@ -57,3 +59,7 @@ def decodebytes(s: ReadableBuffer) -> bytes: ...
 if sys.version_info < (3, 9):
     def encodestring(s: ReadableBuffer) -> bytes: ...
     def decodestring(s: ReadableBuffer) -> bytes: ...
+
+if sys.version_info >= (3, 13):
+    def z85encode(s: ReadableBuffer) -> bytes: ...
+    def z85decode(s: str | ReadableBuffer) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/bdb.pyi b/mypy/typeshed/stdlib/bdb.pyi
index 2a1fdddff7e9..2004874a52b2 100644
--- a/mypy/typeshed/stdlib/bdb.pyi
+++ b/mypy/typeshed/stdlib/bdb.pyi
@@ -1,16 +1,20 @@
 import sys
-from _typeshed import ExcInfo, TraceFunction
-from collections.abc import Callable, Iterable, Mapping
+from _typeshed import ExcInfo, TraceFunction, Unused
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from contextlib import contextmanager
 from types import CodeType, FrameType, TracebackType
-from typing import IO, Any, SupportsInt, TypeVar
-from typing_extensions import Literal, ParamSpec
+from typing import IO, Any, Final, SupportsInt, TypeVar
+from typing_extensions import ParamSpec
 
 __all__ = ["BdbQuit", "Bdb", "Breakpoint"]
 
 _T = TypeVar("_T")
 _P = ParamSpec("_P")
 
-GENERATOR_AND_COROUTINE_FLAGS: Literal[672]
+# A union of code-object flags at runtime.
+# The exact values of code-object flags are implementation details,
+# so we don't include the value of this constant in the stubs.
+GENERATOR_AND_COROUTINE_FLAGS: Final[int]
 
 class BdbQuit(Exception): ...
 
@@ -27,11 +31,18 @@ class Bdb:
     def __init__(self, skip: Iterable[str] | None = None) -> None: ...
     def canonic(self, filename: str) -> str: ...
     def reset(self) -> None: ...
+    if sys.version_info >= (3, 12):
+        @contextmanager
+        def set_enterframe(self, frame: FrameType) -> Iterator[None]: ...
+
     def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> TraceFunction: ...
     def dispatch_line(self, frame: FrameType) -> TraceFunction: ...
     def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
     def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
     def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
+    if sys.version_info >= (3, 13):
+        def dispatch_opcode(self, frame: FrameType, arg: Unused) -> Callable[[FrameType, str, Any], TraceFunction]: ...
+
     def is_skipped_module(self, module_name: str) -> bool: ...
     def stop_here(self, frame: FrameType) -> bool: ...
     def break_here(self, frame: FrameType) -> bool: ...
@@ -42,7 +53,13 @@ class Bdb:
     def user_return(self, frame: FrameType, return_value: Any) -> None: ...
     def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
     def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def user_opcode(self, frame: FrameType) -> None: ...  # undocumented
+
     def set_step(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def set_stepinstr(self) -> None: ...  # undocumented
+
     def set_next(self, frame: FrameType) -> None: ...
     def set_return(self, frame: FrameType) -> None: ...
     def set_trace(self, frame: FrameType | None = None) -> None: ...
@@ -50,24 +67,24 @@ class Bdb:
     def set_quit(self) -> None: ...
     def set_break(
         self, filename: str, lineno: int, temporary: bool = False, cond: str | None = None, funcname: str | None = None
-    ) -> None: ...
-    def clear_break(self, filename: str, lineno: int) -> None: ...
-    def clear_bpbynumber(self, arg: SupportsInt) -> None: ...
-    def clear_all_file_breaks(self, filename: str) -> None: ...
-    def clear_all_breaks(self) -> None: ...
+    ) -> str | None: ...
+    def clear_break(self, filename: str, lineno: int) -> str | None: ...
+    def clear_bpbynumber(self, arg: SupportsInt) -> str | None: ...
+    def clear_all_file_breaks(self, filename: str) -> str | None: ...
+    def clear_all_breaks(self) -> str | None: ...
     def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint: ...
     def get_break(self, filename: str, lineno: int) -> bool: ...
     def get_breaks(self, filename: str, lineno: int) -> list[Breakpoint]: ...
     def get_file_breaks(self, filename: str) -> list[Breakpoint]: ...
     def get_all_breaks(self) -> list[Breakpoint]: ...
     def get_stack(self, f: FrameType | None, t: TracebackType | None) -> tuple[list[tuple[FrameType, int]], int]: ...
-    def format_stack_entry(self, frame_lineno: int, lprefix: str = ": ") -> str: ...
+    def format_stack_entry(self, frame_lineno: tuple[FrameType, int], lprefix: str = ": ") -> str: ...
     def run(
         self, cmd: str | CodeType, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None
     ) -> None: ...
     def runeval(self, expr: str, globals: dict[str, Any] | None = None, locals: Mapping[str, Any] | None = None) -> None: ...
     def runctx(self, cmd: str | CodeType, globals: dict[str, Any] | None, locals: Mapping[str, Any] | None) -> None: ...
-    def runcall(self, __func: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
+    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> _T | None: ...
 
 class Breakpoint:
     next: int
diff --git a/mypy/typeshed/stdlib/binascii.pyi b/mypy/typeshed/stdlib/binascii.pyi
index 759b6c39399a..32e018c653cb 100644
--- a/mypy/typeshed/stdlib/binascii.pyi
+++ b/mypy/typeshed/stdlib/binascii.pyi
@@ -6,39 +6,31 @@ from typing_extensions import TypeAlias
 # or ASCII-only strings.
 _AsciiBuffer: TypeAlias = str | ReadableBuffer
 
-def a2b_uu(__data: _AsciiBuffer) -> bytes: ...
-def b2a_uu(__data: ReadableBuffer, *, backtick: bool = False) -> bytes: ...
+def a2b_uu(data: _AsciiBuffer, /) -> bytes: ...
+def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes: ...
 
 if sys.version_info >= (3, 11):
-    def a2b_base64(__data: _AsciiBuffer, *, strict_mode: bool = False) -> bytes: ...
+    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes: ...
 
 else:
-    def a2b_base64(__data: _AsciiBuffer) -> bytes: ...
+    def a2b_base64(data: _AsciiBuffer, /) -> bytes: ...
 
-def b2a_base64(__data: ReadableBuffer, *, newline: bool = True) -> bytes: ...
+def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes: ...
 def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes: ...
 def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes: ...
 
 if sys.version_info < (3, 11):
-    def a2b_hqx(__data: _AsciiBuffer) -> bytes: ...
-    def rledecode_hqx(__data: ReadableBuffer) -> bytes: ...
-    def rlecode_hqx(__data: ReadableBuffer) -> bytes: ...
-    def b2a_hqx(__data: ReadableBuffer) -> bytes: ...
-
-def crc_hqx(__data: ReadableBuffer, __crc: int) -> int: ...
-def crc32(__data: ReadableBuffer, __crc: int = 0) -> int: ...
-
-if sys.version_info >= (3, 8):
-    # sep must be str or bytes, not bytearray or any other buffer
-    def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
-    def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
-
-else:
-    def b2a_hex(__data: ReadableBuffer) -> bytes: ...
-    def hexlify(__data: ReadableBuffer) -> bytes: ...
-
-def a2b_hex(__hexstr: _AsciiBuffer) -> bytes: ...
-def unhexlify(__hexstr: _AsciiBuffer) -> bytes: ...
+    def a2b_hqx(data: _AsciiBuffer, /) -> bytes: ...
+    def rledecode_hqx(data: ReadableBuffer, /) -> bytes: ...
+    def rlecode_hqx(data: ReadableBuffer, /) -> bytes: ...
+    def b2a_hqx(data: ReadableBuffer, /) -> bytes: ...
+
+def crc_hqx(data: ReadableBuffer, crc: int, /) -> int: ...
+def crc32(data: ReadableBuffer, crc: int = 0, /) -> int: ...
+def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
+def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes: ...
+def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes: ...
+def unhexlify(hexstr: _AsciiBuffer, /) -> bytes: ...
 
 class Error(ValueError): ...
 class Incomplete(Exception): ...
diff --git a/mypy/typeshed/stdlib/binhex.pyi b/mypy/typeshed/stdlib/binhex.pyi
index 64ba9f6150b4..bdead928468f 100644
--- a/mypy/typeshed/stdlib/binhex.pyi
+++ b/mypy/typeshed/stdlib/binhex.pyi
@@ -1,14 +1,14 @@
 from _typeshed import SizedBuffer
-from typing import IO, Any
-from typing_extensions import Literal, TypeAlias
+from typing import IO, Any, Final
+from typing_extensions import TypeAlias
 
 __all__ = ["binhex", "hexbin", "Error"]
 
 class Error(Exception): ...
 
-REASONABLY_LARGE: Literal[32768]
-LINELEN: Literal[64]
-RUNCHAR: Literal[b"\x90"]
+REASONABLY_LARGE: Final = 32768
+LINELEN: Final = 64
+RUNCHAR: Final = b"\x90"
 
 class FInfo:
     Type: str
diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index 0676aba1277e..dc8ddb8fe7a8 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -1,10 +1,13 @@
 import _ast
+import _sitebuiltins
 import _typeshed
 import sys
 import types
 from _collections_abc import dict_items, dict_keys, dict_values
 from _typeshed import (
     AnyStr_co,
+    ConvertibleToFloat,
+    ConvertibleToInt,
     FileDescriptorOrPath,
     OpenBinaryMode,
     OpenBinaryModeReading,
@@ -16,6 +19,7 @@ from _typeshed import (
     SupportsAiter,
     SupportsAnext,
     SupportsDivMod,
+    SupportsFlush,
     SupportsIter,
     SupportsKeysAndGetItem,
     SupportsLenAndGetItem,
@@ -24,14 +28,14 @@ from _typeshed import (
     SupportsRDivMod,
     SupportsRichComparison,
     SupportsRichComparisonT,
-    SupportsTrunc,
     SupportsWrite,
 )
 from collections.abc import Awaitable, Callable, Iterable, Iterator, MutableSet, Reversible, Set as AbstractSet, Sized
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
-from types import CodeType, TracebackType, _Cell
+from types import CellType, CodeType, TracebackType
 
-# mypy crashes if any of {ByteString, Sequence, MutableSequence, Mapping, MutableMapping} are imported from collections.abc in builtins.pyi
+# mypy crashes if any of {ByteString, Sequence, MutableSequence, Mapping, MutableMapping}
+# are imported from collections.abc in builtins.pyi
 from typing import (  # noqa: Y022
     IO,
     Any,
@@ -41,24 +45,37 @@ from typing import (  # noqa: Y022
     Mapping,
     MutableMapping,
     MutableSequence,
-    NoReturn,
     Protocol,
     Sequence,
     SupportsAbs,
     SupportsBytes,
     SupportsComplex,
     SupportsFloat,
-    SupportsInt,
+    SupportsIndex,
     TypeVar,
+    final,
     overload,
     type_check_only,
 )
-from typing_extensions import Concatenate, Literal, ParamSpec, Self, SupportsIndex, TypeAlias, TypeGuard, final
+
+# we can't import `Literal` from typing or mypy crashes: see #11247
+from typing_extensions import (  # noqa: Y023
+    Concatenate,
+    Literal,
+    ParamSpec,
+    Self,
+    TypeAlias,
+    TypeGuard,
+    TypeIs,
+    TypeVarTuple,
+    deprecated,
+)
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 
 _T = TypeVar("_T")
+_I = TypeVar("_I", default=int)
 _T_co = TypeVar("_T_co", covariant=True)
 _T_contra = TypeVar("_T_contra", contravariant=True)
 _R_co = TypeVar("_R_co", covariant=True)
@@ -70,12 +87,20 @@ _T2 = TypeVar("_T2")
 _T3 = TypeVar("_T3")
 _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
-_SupportsNextT = TypeVar("_SupportsNextT", bound=SupportsNext[Any], covariant=True)
-_SupportsAnextT = TypeVar("_SupportsAnextT", bound=SupportsAnext[Any], covariant=True)
+_SupportsNextT_co = TypeVar("_SupportsNextT_co", bound=SupportsNext[Any], covariant=True)
+_SupportsAnextT_co = TypeVar("_SupportsAnextT_co", bound=SupportsAnext[Any], covariant=True)
 _AwaitableT = TypeVar("_AwaitableT", bound=Awaitable[Any])
 _AwaitableT_co = TypeVar("_AwaitableT_co", bound=Awaitable[Any], covariant=True)
 _P = ParamSpec("_P")
 
+# Type variables for slice
+_StartT_co = TypeVar("_StartT_co", covariant=True, default=Any)  # slice -> slice[Any, Any, Any]
+_StopT_co = TypeVar("_StopT_co", covariant=True, default=_StartT_co)  #  slice[A] -> slice[A, A, A]
+# NOTE: step could differ from start and stop, (e.g. datetime/timedelta)l
+#   the default (start|stop) is chosen to cater to the most common case of int/index slices.
+# FIXME: https://github.com/python/typing/issues/213 (replace step=start|stop with step=start&stop)
+_StepT_co = TypeVar("_StepT_co", covariant=True, default=_StartT_co | _StopT_co)  #  slice[A,B] -> slice[A, B, A|B]
+
 class object:
     __doc__: str | None
     __dict__: dict[str, Any]
@@ -83,45 +108,44 @@ class object:
     __annotations__: dict[str, Any]
     @property
     def __class__(self) -> type[Self]: ...
-    # Ignore errors about type mismatch between property getter and setter
     @__class__.setter
-    def __class__(self, __type: type[object]) -> None: ...  # noqa: F811
+    def __class__(self, type: type[Self], /) -> None: ...
     def __init__(self) -> None: ...
     def __new__(cls) -> Self: ...
     # N.B. `object.__setattr__` and `object.__delattr__` are heavily special-cased by type checkers.
     # Overriding them in subclasses has different semantics, even if the override has an identical signature.
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
-    def __delattr__(self, __name: str) -> None: ...
-    def __eq__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
+    def __delattr__(self, name: str, /) -> None: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
     def __str__(self) -> str: ...  # noqa: Y029
     def __repr__(self) -> str: ...  # noqa: Y029
     def __hash__(self) -> int: ...
-    def __format__(self, __format_spec: str) -> str: ...
-    def __getattribute__(self, __name: str) -> Any: ...
+    def __format__(self, format_spec: str, /) -> str: ...
+    def __getattribute__(self, name: str, /) -> Any: ...
     def __sizeof__(self) -> int: ...
     # return type of pickle methods is rather hard to express in the current type system
     # see #6661 and https://docs.python.org/3/library/pickle.html#object.__reduce__
     def __reduce__(self) -> str | tuple[Any, ...]: ...
-    if sys.version_info >= (3, 8):
-        def __reduce_ex__(self, __protocol: SupportsIndex) -> str | tuple[Any, ...]: ...
-    else:
-        def __reduce_ex__(self, __protocol: int) -> str | tuple[Any, ...]: ...
+    def __reduce_ex__(self, protocol: SupportsIndex, /) -> str | tuple[Any, ...]: ...
     if sys.version_info >= (3, 11):
         def __getstate__(self) -> object: ...
 
     def __dir__(self) -> Iterable[str]: ...
     def __init_subclass__(cls) -> None: ...
     @classmethod
-    def __subclasshook__(cls, __subclass: type) -> bool: ...
+    def __subclasshook__(cls, subclass: type, /) -> bool: ...
 
 class staticmethod(Generic[_P, _R_co]):
     @property
     def __func__(self) -> Callable[_P, _R_co]: ...
     @property
     def __isabstractmethod__(self) -> bool: ...
-    def __init__(self, __f: Callable[_P, _R_co]) -> None: ...
-    def __get__(self, __instance: _T, __owner: type[_T] | None = None) -> Callable[_P, _R_co]: ...
+    def __init__(self, f: Callable[_P, _R_co], /) -> None: ...
+    @overload
+    def __get__(self, instance: None, owner: type, /) -> Callable[_P, _R_co]: ...
+    @overload
+    def __get__(self, instance: _T, owner: type[_T] | None = None, /) -> Callable[_P, _R_co]: ...
     if sys.version_info >= (3, 10):
         __name__: str
         __qualname__: str
@@ -131,20 +155,24 @@ class staticmethod(Generic[_P, _R_co]):
 
 class classmethod(Generic[_T, _P, _R_co]):
     @property
-    def __func__(self) -> Callable[Concatenate[_T, _P], _R_co]: ...
+    def __func__(self) -> Callable[Concatenate[type[_T], _P], _R_co]: ...
     @property
     def __isabstractmethod__(self) -> bool: ...
-    def __init__(self, __f: Callable[Concatenate[_T, _P], _R_co]) -> None: ...
-    def __get__(self, __instance: _T, __owner: type[_T] | None = None) -> Callable[_P, _R_co]: ...
+    def __init__(self, f: Callable[Concatenate[type[_T], _P], _R_co], /) -> None: ...
+    @overload
+    def __get__(self, instance: _T, owner: type[_T] | None = None, /) -> Callable[_P, _R_co]: ...
+    @overload
+    def __get__(self, instance: None, owner: type[_T], /) -> Callable[_P, _R_co]: ...
     if sys.version_info >= (3, 10):
         __name__: str
         __qualname__: str
         @property
-        def __wrapped__(self) -> Callable[Concatenate[_T, _P], _R_co]: ...
+        def __wrapped__(self) -> Callable[Concatenate[type[_T], _P], _R_co]: ...
 
 class type:
+    # object.__base__ is None. Otherwise, it would be a type.
     @property
-    def __base__(self) -> type: ...
+    def __base__(self) -> type | None: ...
     __bases__: tuple[type, ...]
     @property
     def __basicsize__(self) -> int: ...
@@ -166,33 +194,35 @@ class type:
     @property
     def __weakrefoffset__(self) -> int: ...
     @overload
-    def __init__(self, __o: object) -> None: ...
+    def __init__(self, o: object, /) -> None: ...
     @overload
-    def __init__(self, __name: str, __bases: tuple[type, ...], __dict: dict[str, Any], **kwds: Any) -> None: ...
+    def __init__(self, name: str, bases: tuple[type, ...], dict: dict[str, Any], /, **kwds: Any) -> None: ...
     @overload
-    def __new__(cls, __o: object) -> type: ...
+    def __new__(cls, o: object, /) -> type: ...
     @overload
     def __new__(
-        cls: type[_typeshed.Self], __name: str, __bases: tuple[type, ...], __namespace: dict[str, Any], **kwds: Any
+        cls: type[_typeshed.Self], name: str, bases: tuple[type, ...], namespace: dict[str, Any], /, **kwds: Any
     ) -> _typeshed.Self: ...
     def __call__(self, *args: Any, **kwds: Any) -> Any: ...
     def __subclasses__(self: _typeshed.Self) -> list[_typeshed.Self]: ...
     # Note: the documentation doesn't specify what the return type is, the standard
     # implementation seems to be returning a list.
     def mro(self) -> list[type]: ...
-    def __instancecheck__(self, __instance: Any) -> bool: ...
-    def __subclasscheck__(self, __subclass: type) -> bool: ...
+    def __instancecheck__(self, instance: Any, /) -> bool: ...
+    def __subclasscheck__(self, subclass: type, /) -> bool: ...
     @classmethod
-    def __prepare__(metacls, __name: str, __bases: tuple[type, ...], **kwds: Any) -> Mapping[str, object]: ...
+    def __prepare__(metacls, name: str, bases: tuple[type, ...], /, **kwds: Any) -> MutableMapping[str, object]: ...
     if sys.version_info >= (3, 10):
-        def __or__(self, __value: Any) -> types.UnionType: ...
-        def __ror__(self, __value: Any) -> types.UnionType: ...
+        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
-    def __init__(self, __t: Any, __obj: Any) -> None: ...
+    def __init__(self, t: Any, obj: Any, /) -> None: ...
     @overload
-    def __init__(self, __t: Any) -> None: ...
+    def __init__(self, t: Any, /) -> None: ...
     @overload
     def __init__(self) -> None: ...
 
@@ -202,12 +232,10 @@ _LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026
 
 class int:
     @overload
-    def __new__(cls, __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> Self: ...
+    def __new__(cls, x: ConvertibleToInt = ..., /) -> Self: ...
     @overload
-    def __new__(cls, __x: str | bytes | bytearray, base: SupportsIndex) -> Self: ...
-    if sys.version_info >= (3, 8):
-        def as_integer_ratio(self) -> tuple[int, Literal[1]]: ...
-
+    def __new__(cls, x: str | bytes | bytearray, /, base: SupportsIndex) -> Self: ...
+    def as_integer_ratio(self) -> tuple[int, Literal[1]]: ...
     @property
     def real(self) -> int: ...
     @property
@@ -244,104 +272,108 @@ class int:
             signed: bool = False,
         ) -> Self: ...
 
-    def __add__(self, __value: int) -> int: ...
-    def __sub__(self, __value: int) -> int: ...
-    def __mul__(self, __value: int) -> int: ...
-    def __floordiv__(self, __value: int) -> int: ...
-    def __truediv__(self, __value: int) -> float: ...
-    def __mod__(self, __value: int) -> int: ...
-    def __divmod__(self, __value: int) -> tuple[int, int]: ...
-    def __radd__(self, __value: int) -> int: ...
-    def __rsub__(self, __value: int) -> int: ...
-    def __rmul__(self, __value: int) -> int: ...
-    def __rfloordiv__(self, __value: int) -> int: ...
-    def __rtruediv__(self, __value: int) -> float: ...
-    def __rmod__(self, __value: int) -> int: ...
-    def __rdivmod__(self, __value: int) -> tuple[int, int]: ...
-    @overload
-    def __pow__(self, __x: Literal[0]) -> Literal[1]: ...
-    @overload
-    def __pow__(self, __value: Literal[0], __mod: None) -> Literal[1]: ...
-    @overload
-    def __pow__(self, __value: _PositiveInteger, __mod: None = None) -> int: ...
-    @overload
-    def __pow__(self, __value: _NegativeInteger, __mod: None = None) -> float: ...
-    # positive x -> int; negative x -> float
+    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: ...
+    def __floordiv__(self, value: int, /) -> int: ...
+    def __truediv__(self, value: int, /) -> float: ...
+    def __mod__(self, value: int, /) -> int: ...
+    def __divmod__(self, value: int, /) -> tuple[int, int]: ...
+    def __radd__(self, value: int, /) -> int: ...
+    def __rsub__(self, value: int, /) -> int: ...
+    def __rmul__(self, value: int, /) -> int: ...
+    def __rfloordiv__(self, value: int, /) -> int: ...
+    def __rtruediv__(self, value: int, /) -> float: ...
+    def __rmod__(self, value: int, /) -> int: ...
+    def __rdivmod__(self, value: int, /) -> tuple[int, int]: ...
+    @overload
+    def __pow__(self, x: Literal[0], /) -> Literal[1]: ...
+    @overload
+    def __pow__(self, value: Literal[0], mod: None, /) -> Literal[1]: ...
+    @overload
+    def __pow__(self, value: _PositiveInteger, mod: None = None, /) -> int: ...
+    @overload
+    def __pow__(self, value: _NegativeInteger, mod: None = None, /) -> float: ...
+    # positive __value -> int; negative __value -> float
     # return type must be Any as `int | float` causes too many false-positive errors
     @overload
-    def __pow__(self, __value: int, __mod: None = None) -> Any: ...
-    @overload
-    def __pow__(self, __value: int, __mod: int) -> int: ...
-    def __rpow__(self, __value: int, __mod: int | None = None) -> Any: ...
-    def __and__(self, __value: int) -> int: ...
-    def __or__(self, __value: int) -> int: ...
-    def __xor__(self, __value: int) -> int: ...
-    def __lshift__(self, __value: int) -> int: ...
-    def __rshift__(self, __value: int) -> int: ...
-    def __rand__(self, __value: int) -> int: ...
-    def __ror__(self, __value: int) -> int: ...
-    def __rxor__(self, __value: int) -> int: ...
-    def __rlshift__(self, __value: int) -> int: ...
-    def __rrshift__(self, __value: int) -> int: ...
+    def __pow__(self, value: int, mod: None = None, /) -> Any: ...
+    @overload
+    def __pow__(self, value: int, mod: int, /) -> int: ...
+    def __rpow__(self, value: int, mod: int | None = None, /) -> Any: ...
+    def __and__(self, value: int, /) -> int: ...
+    def __or__(self, value: int, /) -> int: ...
+    def __xor__(self, value: int, /) -> int: ...
+    def __lshift__(self, value: int, /) -> int: ...
+    def __rshift__(self, value: int, /) -> int: ...
+    def __rand__(self, value: int, /) -> int: ...
+    def __ror__(self, value: int, /) -> int: ...
+    def __rxor__(self, value: int, /) -> int: ...
+    def __rlshift__(self, value: int, /) -> int: ...
+    def __rrshift__(self, value: int, /) -> int: ...
     def __neg__(self) -> int: ...
     def __pos__(self) -> int: ...
     def __invert__(self) -> int: ...
     def __trunc__(self) -> int: ...
     def __ceil__(self) -> int: ...
     def __floor__(self) -> int: ...
-    def __round__(self, __ndigits: SupportsIndex = ...) -> int: ...
+    def __round__(self, ndigits: SupportsIndex = ..., /) -> int: ...
     def __getnewargs__(self) -> tuple[int]: ...
-    def __eq__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
-    def __lt__(self, __value: int) -> bool: ...
-    def __le__(self, __value: int) -> bool: ...
-    def __gt__(self, __value: int) -> bool: ...
-    def __ge__(self, __value: int) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
+    def __lt__(self, value: int, /) -> bool: ...
+    def __le__(self, value: int, /) -> bool: ...
+    def __gt__(self, value: int, /) -> bool: ...
+    def __ge__(self, value: int, /) -> bool: ...
     def __float__(self) -> float: ...
     def __int__(self) -> int: ...
     def __abs__(self) -> int: ...
+    def __hash__(self) -> int: ...
     def __bool__(self) -> bool: ...
     def __index__(self) -> int: ...
 
 class float:
-    def __new__(cls, __x: SupportsFloat | SupportsIndex | str | ReadableBuffer = ...) -> Self: ...
+    def __new__(cls, x: ConvertibleToFloat = ..., /) -> Self: ...
     def as_integer_ratio(self) -> tuple[int, int]: ...
     def hex(self) -> str: ...
     def is_integer(self) -> bool: ...
     @classmethod
-    def fromhex(cls, __string: str) -> Self: ...
+    def fromhex(cls, string: str, /) -> Self: ...
     @property
     def real(self) -> float: ...
     @property
     def imag(self) -> float: ...
     def conjugate(self) -> float: ...
-    def __add__(self, __value: float) -> float: ...
-    def __sub__(self, __value: float) -> float: ...
-    def __mul__(self, __value: float) -> float: ...
-    def __floordiv__(self, __value: float) -> float: ...
-    def __truediv__(self, __value: float) -> float: ...
-    def __mod__(self, __value: float) -> float: ...
-    def __divmod__(self, __value: float) -> tuple[float, float]: ...
-    @overload
-    def __pow__(self, __value: int, __mod: None = None) -> float: ...
-    # positive x -> float; negative x -> complex
+    def __add__(self, value: float, /) -> float: ...
+    def __sub__(self, value: float, /) -> float: ...
+    def __mul__(self, value: float, /) -> float: ...
+    def __floordiv__(self, value: float, /) -> float: ...
+    def __truediv__(self, value: float, /) -> float: ...
+    def __mod__(self, value: float, /) -> float: ...
+    def __divmod__(self, value: float, /) -> tuple[float, float]: ...
+    @overload
+    def __pow__(self, value: int, mod: None = None, /) -> float: ...
+    # positive __value -> float; negative __value -> complex
     # return type must be Any as `float | complex` causes too many false-positive errors
     @overload
-    def __pow__(self, __value: float, __mod: None = None) -> Any: ...
-    def __radd__(self, __value: float) -> float: ...
-    def __rsub__(self, __value: float) -> float: ...
-    def __rmul__(self, __value: float) -> float: ...
-    def __rfloordiv__(self, __value: float) -> float: ...
-    def __rtruediv__(self, __value: float) -> float: ...
-    def __rmod__(self, __value: float) -> float: ...
-    def __rdivmod__(self, __value: float) -> tuple[float, float]: ...
+    def __pow__(self, value: float, mod: None = None, /) -> Any: ...
+    def __radd__(self, value: float, /) -> float: ...
+    def __rsub__(self, value: float, /) -> float: ...
+    def __rmul__(self, value: float, /) -> float: ...
+    def __rfloordiv__(self, value: float, /) -> float: ...
+    def __rtruediv__(self, value: float, /) -> float: ...
+    def __rmod__(self, value: float, /) -> float: ...
+    def __rdivmod__(self, value: float, /) -> tuple[float, float]: ...
     @overload
-    def __rpow__(self, __value: _PositiveInteger, __mod: None = None) -> float: ...
+    def __rpow__(self, value: _PositiveInteger, mod: None = None, /) -> float: ...
     @overload
-    def __rpow__(self, __value: _NegativeInteger, __mod: None = None) -> complex: ...
+    def __rpow__(self, value: _NegativeInteger, mod: None = None, /) -> complex: ...
     # Returning `complex` for the general case gives too many false-positive errors.
     @overload
-    def __rpow__(self, __value: float, __mod: None = None) -> Any: ...
+    def __rpow__(self, value: float, mod: None = None, /) -> Any: ...
     def __getnewargs__(self) -> tuple[float]: ...
     def __trunc__(self) -> int: ...
     if sys.version_info >= (3, 9):
@@ -349,68 +381,63 @@ class float:
         def __floor__(self) -> int: ...
 
     @overload
-    def __round__(self, __ndigits: None = None) -> int: ...
+    def __round__(self, ndigits: None = None, /) -> int: ...
     @overload
-    def __round__(self, __ndigits: SupportsIndex) -> float: ...
-    def __eq__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
-    def __lt__(self, __value: float) -> bool: ...
-    def __le__(self, __value: float) -> bool: ...
-    def __gt__(self, __value: float) -> bool: ...
-    def __ge__(self, __value: float) -> bool: ...
+    def __round__(self, ndigits: SupportsIndex, /) -> float: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
+    def __lt__(self, value: float, /) -> bool: ...
+    def __le__(self, value: float, /) -> bool: ...
+    def __gt__(self, value: float, /) -> bool: ...
+    def __ge__(self, value: float, /) -> bool: ...
     def __neg__(self) -> float: ...
     def __pos__(self) -> float: ...
     def __int__(self) -> int: ...
     def __float__(self) -> float: ...
     def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
     def __bool__(self) -> bool: ...
 
 class complex:
-    if sys.version_info >= (3, 8):
-        # Python doesn't currently accept SupportsComplex for the second argument
-        @overload
-        def __new__(
-            cls,
-            real: complex | SupportsComplex | SupportsFloat | SupportsIndex = ...,
-            imag: complex | SupportsFloat | SupportsIndex = ...,
-        ) -> Self: ...
-        @overload
-        def __new__(cls, real: str | SupportsComplex | SupportsFloat | SupportsIndex | complex) -> Self: ...
-    else:
-        @overload
-        def __new__(cls, real: complex | SupportsComplex | SupportsFloat = ..., imag: complex | SupportsFloat = ...) -> Self: ...
-        @overload
-        def __new__(cls, real: str | SupportsComplex | SupportsFloat | complex) -> Self: ...
-
+    # Python doesn't currently accept SupportsComplex for the second argument
+    @overload
+    def __new__(
+        cls,
+        real: complex | SupportsComplex | SupportsFloat | SupportsIndex = ...,
+        imag: complex | SupportsFloat | SupportsIndex = ...,
+    ) -> Self: ...
+    @overload
+    def __new__(cls, real: str | SupportsComplex | SupportsFloat | SupportsIndex | complex) -> Self: ...
     @property
     def real(self) -> float: ...
     @property
     def imag(self) -> float: ...
     def conjugate(self) -> complex: ...
-    def __add__(self, __value: complex) -> complex: ...
-    def __sub__(self, __value: complex) -> complex: ...
-    def __mul__(self, __value: complex) -> complex: ...
-    def __pow__(self, __value: complex, __mod: None = None) -> complex: ...
-    def __truediv__(self, __value: complex) -> complex: ...
-    def __radd__(self, __value: complex) -> complex: ...
-    def __rsub__(self, __value: complex) -> complex: ...
-    def __rmul__(self, __value: complex) -> complex: ...
-    def __rpow__(self, __value: complex, __mod: None = None) -> complex: ...
-    def __rtruediv__(self, __value: complex) -> complex: ...
-    def __eq__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
+    def __add__(self, value: complex, /) -> complex: ...
+    def __sub__(self, value: complex, /) -> complex: ...
+    def __mul__(self, value: complex, /) -> complex: ...
+    def __pow__(self, value: complex, mod: None = None, /) -> complex: ...
+    def __truediv__(self, value: complex, /) -> complex: ...
+    def __radd__(self, value: complex, /) -> complex: ...
+    def __rsub__(self, value: complex, /) -> complex: ...
+    def __rmul__(self, value: complex, /) -> complex: ...
+    def __rpow__(self, value: complex, mod: None = None, /) -> complex: ...
+    def __rtruediv__(self, value: complex, /) -> complex: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
     def __neg__(self) -> complex: ...
     def __pos__(self) -> complex: ...
     def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
     def __bool__(self) -> bool: ...
     if sys.version_info >= (3, 11):
         def __complex__(self) -> complex: ...
 
 class _FormatMapMapping(Protocol):
-    def __getitem__(self, __key: str) -> Any: ...
+    def __getitem__(self, key: str, /) -> Any: ...
 
 class _TranslateTable(Protocol):
-    def __getitem__(self, __key: int) -> str | int | None: ...
+    def __getitem__(self, key: int, /) -> str | int | None: ...
 
 class str(Sequence[str]):
     @overload
@@ -419,21 +446,17 @@ class str(Sequence[str]):
     def __new__(cls, object: ReadableBuffer, encoding: str = ..., errors: str = ...) -> Self: ...
     def capitalize(self) -> str: ...  # type: ignore[misc]
     def casefold(self) -> str: ...  # type: ignore[misc]
-    def center(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
-    def count(self, x: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
+    def center(self, width: SupportsIndex, fillchar: str = " ", /) -> str: ...  # type: ignore[misc]
+    def count(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int: ...
     def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
     def endswith(
-        self, __suffix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, suffix: str | tuple[str, ...], start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> bool: ...
-    if sys.version_info >= (3, 8):
-        def expandtabs(self, tabsize: SupportsIndex = 8) -> str: ...  # type: ignore[misc]
-    else:
-        def expandtabs(self, tabsize: int = 8) -> str: ...  # type: ignore[misc]
-
-    def find(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
+    def expandtabs(self, tabsize: SupportsIndex = 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: ...
-    def format_map(self, map: _FormatMapMapping) -> str: ...
-    def index(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
+    def format_map(self, mapping: _FormatMapMapping, /) -> str: ...
+    def index(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int: ...
     def isalnum(self) -> bool: ...
     def isalpha(self) -> bool: ...
     def isascii(self) -> bool: ...
@@ -446,93 +469,90 @@ class str(Sequence[str]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
-    def join(self, __iterable: Iterable[str]) -> str: ...  # type: ignore[misc]
-    def ljust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
+    def join(self, iterable: Iterable[str], /) -> str: ...  # type: ignore[misc]
+    def ljust(self, width: SupportsIndex, fillchar: str = " ", /) -> str: ...  # type: ignore[misc]
     def lower(self) -> str: ...  # type: ignore[misc]
-    def lstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
-    def partition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
-    def replace(self, __old: str, __new: str, __count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
+    def lstrip(self, chars: str | None = None, /) -> str: ...  # type: ignore[misc]
+    def partition(self, sep: str, /) -> tuple[str, str, str]: ...  # type: ignore[misc]
+    if sys.version_info >= (3, 13):
+        def replace(self, old: str, new: str, /, count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
+    else:
+        def replace(self, old: str, new: str, count: SupportsIndex = -1, /) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
-        def removeprefix(self, __prefix: str) -> str: ...  # type: ignore[misc]
-        def removesuffix(self, __suffix: str) -> str: ...  # type: ignore[misc]
+        def removeprefix(self, prefix: str, /) -> str: ...  # type: ignore[misc]
+        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: ...
-    def rjust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
-    def rpartition(self, __sep: str) -> tuple[str, 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: ...
+    def rjust(self, width: SupportsIndex, fillchar: str = " ", /) -> str: ...  # type: ignore[misc]
+    def rpartition(self, sep: str, /) -> tuple[str, str, str]: ...  # type: ignore[misc]
     def rsplit(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
-    def rstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    def rstrip(self, chars: str | None = None, /) -> str: ...  # type: ignore[misc]
     def split(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
     def splitlines(self, keepends: bool = False) -> list[str]: ...  # type: ignore[misc]
     def startswith(
-        self, __prefix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, prefix: str | tuple[str, ...], start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> bool: ...
-    def strip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    def strip(self, chars: str | None = None, /) -> str: ...  # type: ignore[misc]
     def swapcase(self) -> str: ...  # type: ignore[misc]
     def title(self) -> str: ...  # type: ignore[misc]
-    def translate(self, __table: _TranslateTable) -> str: ...
+    def translate(self, table: _TranslateTable, /) -> str: ...
     def upper(self) -> str: ...  # type: ignore[misc]
-    def zfill(self, __width: SupportsIndex) -> str: ...  # type: ignore[misc]
+    def zfill(self, width: SupportsIndex, /) -> str: ...  # type: ignore[misc]
     @staticmethod
     @overload
-    def maketrans(__x: dict[int, _T] | dict[str, _T] | dict[str | int, _T]) -> dict[int, _T]: ...
+    def maketrans(x: dict[int, _T] | dict[str, _T] | dict[str | int, _T], /) -> dict[int, _T]: ...
     @staticmethod
     @overload
-    def maketrans(__x: str, __y: str) -> dict[int, int]: ...
+    def maketrans(x: str, y: str, /) -> dict[int, int]: ...
     @staticmethod
     @overload
-    def maketrans(__x: str, __y: str, __z: str) -> dict[int, int | None]: ...
-    def __add__(self, __value: str) -> str: ...  # type: ignore[misc]
+    def maketrans(x: str, y: str, z: str, /) -> dict[int, int | None]: ...
+    def __add__(self, value: str, /) -> str: ...  # type: ignore[misc]
     # Incompatible with Sequence.__contains__
-    def __contains__(self, __key: str) -> bool: ...  # type: ignore[override]
-    def __eq__(self, __value: object) -> bool: ...
-    def __ge__(self, __value: str) -> bool: ...
-    def __getitem__(self, __key: SupportsIndex | slice) -> str: ...
-    def __gt__(self, __value: str) -> bool: ...
+    def __contains__(self, key: str, /) -> bool: ...  # type: ignore[override]
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ge__(self, value: str, /) -> bool: ...
+    def __getitem__(self, key: SupportsIndex | slice, /) -> str: ...
+    def __gt__(self, value: str, /) -> bool: ...
+    def __hash__(self) -> int: ...
     def __iter__(self) -> Iterator[str]: ...  # type: ignore[misc]
-    def __le__(self, __value: str) -> bool: ...
+    def __le__(self, value: str, /) -> bool: ...
     def __len__(self) -> int: ...
-    def __lt__(self, __value: str) -> bool: ...
-    def __mod__(self, __value: Any) -> str: ...
-    def __mul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
-    def __ne__(self, __value: object) -> bool: ...
-    def __rmul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
+    def __lt__(self, value: str, /) -> bool: ...
+    def __mod__(self, value: Any, /) -> str: ...
+    def __mul__(self, value: SupportsIndex, /) -> str: ...  # type: ignore[misc]
+    def __ne__(self, value: object, /) -> bool: ...
+    def __rmul__(self, value: SupportsIndex, /) -> str: ...  # type: ignore[misc]
     def __getnewargs__(self) -> tuple[str]: ...
 
 class bytes(Sequence[int]):
     @overload
-    def __new__(cls, __o: Iterable[SupportsIndex] | SupportsIndex | SupportsBytes | ReadableBuffer) -> Self: ...
+    def __new__(cls, o: Iterable[SupportsIndex] | SupportsIndex | SupportsBytes | ReadableBuffer, /) -> Self: ...
     @overload
-    def __new__(cls, __string: str, encoding: str, errors: str = ...) -> Self: ...
+    def __new__(cls, string: str, /, encoding: str, errors: str = ...) -> Self: ...
     @overload
     def __new__(cls) -> Self: ...
     def capitalize(self) -> bytes: ...
-    def center(self, __width: SupportsIndex, __fillchar: bytes = b" ") -> bytes: ...
+    def center(self, width: SupportsIndex, fillchar: bytes = b" ", /) -> bytes: ...
     def count(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
     def decode(self, encoding: str = "utf-8", errors: str = "strict") -> str: ...
     def endswith(
         self,
-        __suffix: ReadableBuffer | tuple[ReadableBuffer, ...],
-        __start: SupportsIndex | None = ...,
-        __end: SupportsIndex | None = ...,
+        suffix: ReadableBuffer | tuple[ReadableBuffer, ...],
+        start: SupportsIndex | None = ...,
+        end: SupportsIndex | None = ...,
+        /,
     ) -> bool: ...
-    if sys.version_info >= (3, 8):
-        def expandtabs(self, tabsize: SupportsIndex = 8) -> bytes: ...
-    else:
-        def expandtabs(self, tabsize: int = ...) -> bytes: ...
-
+    def expandtabs(self, tabsize: SupportsIndex = 8) -> bytes: ...
     def find(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
-    if sys.version_info >= (3, 8):
-        def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str: ...
-    else:
-        def hex(self) -> str: ...
-
+    def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str: ...
     def index(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
     def isalnum(self) -> bool: ...
     def isalpha(self) -> bool: ...
@@ -542,107 +562,102 @@ class bytes(Sequence[int]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
-    def join(self, __iterable_of_bytes: Iterable[ReadableBuffer]) -> bytes: ...
-    def ljust(self, __width: SupportsIndex, __fillchar: bytes | bytearray = b" ") -> bytes: ...
+    def join(self, iterable_of_bytes: Iterable[ReadableBuffer], /) -> bytes: ...
+    def ljust(self, width: SupportsIndex, fillchar: bytes | bytearray = b" ", /) -> bytes: ...
     def lower(self) -> bytes: ...
-    def lstrip(self, __bytes: ReadableBuffer | None = None) -> bytes: ...
-    def partition(self, __sep: ReadableBuffer) -> tuple[bytes, bytes, bytes]: ...
-    def replace(self, __old: ReadableBuffer, __new: ReadableBuffer, __count: SupportsIndex = -1) -> bytes: ...
+    def lstrip(self, bytes: ReadableBuffer | None = None, /) -> bytes: ...
+    def partition(self, sep: ReadableBuffer, /) -> tuple[bytes, bytes, bytes]: ...
+    def replace(self, old: ReadableBuffer, new: ReadableBuffer, count: SupportsIndex = -1, /) -> bytes: ...
     if sys.version_info >= (3, 9):
-        def removeprefix(self, __prefix: ReadableBuffer) -> bytes: ...
-        def removesuffix(self, __suffix: ReadableBuffer) -> bytes: ...
+        def removeprefix(self, prefix: ReadableBuffer, /) -> bytes: ...
+        def removesuffix(self, suffix: ReadableBuffer, /) -> bytes: ...
 
     def rfind(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
     def rindex(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
-    def rjust(self, __width: SupportsIndex, __fillchar: bytes | bytearray = b" ") -> bytes: ...
-    def rpartition(self, __sep: ReadableBuffer) -> tuple[bytes, bytes, bytes]: ...
+    def rjust(self, width: SupportsIndex, fillchar: bytes | bytearray = b" ", /) -> bytes: ...
+    def rpartition(self, sep: ReadableBuffer, /) -> tuple[bytes, bytes, bytes]: ...
     def rsplit(self, sep: ReadableBuffer | None = None, maxsplit: SupportsIndex = -1) -> list[bytes]: ...
-    def rstrip(self, __bytes: ReadableBuffer | None = None) -> bytes: ...
+    def rstrip(self, bytes: ReadableBuffer | None = None, /) -> bytes: ...
     def split(self, sep: ReadableBuffer | None = None, maxsplit: SupportsIndex = -1) -> list[bytes]: ...
     def splitlines(self, keepends: bool = False) -> list[bytes]: ...
     def startswith(
         self,
-        __prefix: ReadableBuffer | tuple[ReadableBuffer, ...],
-        __start: SupportsIndex | None = ...,
-        __end: SupportsIndex | None = ...,
+        prefix: ReadableBuffer | tuple[ReadableBuffer, ...],
+        start: SupportsIndex | None = ...,
+        end: SupportsIndex | None = ...,
+        /,
     ) -> bool: ...
-    def strip(self, __bytes: ReadableBuffer | None = None) -> bytes: ...
+    def strip(self, bytes: ReadableBuffer | None = None, /) -> bytes: ...
     def swapcase(self) -> bytes: ...
     def title(self) -> bytes: ...
-    def translate(self, __table: ReadableBuffer | None, delete: bytes = b"") -> bytes: ...
+    def translate(self, table: ReadableBuffer | None, /, delete: bytes = b"") -> bytes: ...
     def upper(self) -> bytes: ...
-    def zfill(self, __width: SupportsIndex) -> bytes: ...
+    def zfill(self, width: SupportsIndex, /) -> bytes: ...
     @classmethod
-    def fromhex(cls, __string: str) -> Self: ...
+    def fromhex(cls, string: str, /) -> Self: ...
     @staticmethod
-    def maketrans(__frm: ReadableBuffer, __to: ReadableBuffer) -> bytes: ...
+    def maketrans(frm: ReadableBuffer, to: ReadableBuffer, /) -> bytes: ...
     def __len__(self) -> int: ...
     def __iter__(self) -> Iterator[int]: ...
+    def __hash__(self) -> int: ...
     @overload
-    def __getitem__(self, __key: SupportsIndex) -> int: ...
+    def __getitem__(self, key: SupportsIndex, /) -> int: ...
     @overload
-    def __getitem__(self, __key: slice) -> bytes: ...
-    def __add__(self, __value: ReadableBuffer) -> bytes: ...
-    def __mul__(self, __value: SupportsIndex) -> bytes: ...
-    def __rmul__(self, __value: SupportsIndex) -> bytes: ...
-    def __mod__(self, __value: Any) -> bytes: ...
+    def __getitem__(self, key: slice, /) -> bytes: ...
+    def __add__(self, value: ReadableBuffer, /) -> bytes: ...
+    def __mul__(self, value: SupportsIndex, /) -> bytes: ...
+    def __rmul__(self, value: SupportsIndex, /) -> bytes: ...
+    def __mod__(self, value: Any, /) -> bytes: ...
     # Incompatible with Sequence.__contains__
-    def __contains__(self, __key: SupportsIndex | ReadableBuffer) -> bool: ...  # type: ignore[override]
-    def __eq__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
-    def __lt__(self, __value: bytes) -> bool: ...
-    def __le__(self, __value: bytes) -> bool: ...
-    def __gt__(self, __value: bytes) -> bool: ...
-    def __ge__(self, __value: bytes) -> bool: ...
+    def __contains__(self, key: SupportsIndex | ReadableBuffer, /) -> bool: ...  # type: ignore[override]
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
+    def __lt__(self, value: bytes, /) -> bool: ...
+    def __le__(self, value: bytes, /) -> bool: ...
+    def __gt__(self, value: bytes, /) -> bool: ...
+    def __ge__(self, value: bytes, /) -> bool: ...
     def __getnewargs__(self) -> tuple[bytes]: ...
     if sys.version_info >= (3, 11):
         def __bytes__(self) -> bytes: ...
 
-    def __buffer__(self, __flags: int) -> memoryview: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
 
 class bytearray(MutableSequence[int]):
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self, __ints: Iterable[SupportsIndex] | SupportsIndex | ReadableBuffer) -> None: ...
+    def __init__(self, ints: Iterable[SupportsIndex] | SupportsIndex | ReadableBuffer, /) -> None: ...
     @overload
-    def __init__(self, __string: str, encoding: str, errors: str = ...) -> None: ...
-    def append(self, __item: SupportsIndex) -> None: ...
+    def __init__(self, string: str, /, encoding: str, errors: str = ...) -> None: ...
+    def append(self, item: SupportsIndex, /) -> None: ...
     def capitalize(self) -> bytearray: ...
-    def center(self, __width: SupportsIndex, __fillchar: bytes = b" ") -> bytearray: ...
+    def center(self, width: SupportsIndex, fillchar: bytes = b" ", /) -> bytearray: ...
     def count(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
     def copy(self) -> bytearray: ...
     def decode(self, encoding: str = "utf-8", errors: str = "strict") -> str: ...
     def endswith(
         self,
-        __suffix: ReadableBuffer | tuple[ReadableBuffer, ...],
-        __start: SupportsIndex | None = ...,
-        __end: SupportsIndex | None = ...,
+        suffix: ReadableBuffer | tuple[ReadableBuffer, ...],
+        start: SupportsIndex | None = ...,
+        end: SupportsIndex | None = ...,
+        /,
     ) -> bool: ...
-    if sys.version_info >= (3, 8):
-        def expandtabs(self, tabsize: SupportsIndex = 8) -> bytearray: ...
-    else:
-        def expandtabs(self, tabsize: int = ...) -> bytearray: ...
-
-    def extend(self, __iterable_of_ints: Iterable[SupportsIndex]) -> None: ...
+    def expandtabs(self, tabsize: SupportsIndex = 8) -> bytearray: ...
+    def extend(self, iterable_of_ints: Iterable[SupportsIndex], /) -> None: ...
     def find(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
-    if sys.version_info >= (3, 8):
-        def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str: ...
-    else:
-        def hex(self) -> str: ...
-
+    def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str: ...
     def index(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
-    def insert(self, __index: SupportsIndex, __item: SupportsIndex) -> None: ...
+    def insert(self, index: SupportsIndex, item: SupportsIndex, /) -> None: ...
     def isalnum(self) -> bool: ...
     def isalpha(self) -> bool: ...
     def isascii(self) -> bool: ...
@@ -651,79 +666,84 @@ class bytearray(MutableSequence[int]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
-    def join(self, __iterable_of_bytes: Iterable[ReadableBuffer]) -> bytearray: ...
-    def ljust(self, __width: SupportsIndex, __fillchar: bytes | bytearray = b" ") -> bytearray: ...
+    def join(self, iterable_of_bytes: Iterable[ReadableBuffer], /) -> bytearray: ...
+    def ljust(self, width: SupportsIndex, fillchar: bytes | bytearray = b" ", /) -> bytearray: ...
     def lower(self) -> bytearray: ...
-    def lstrip(self, __bytes: ReadableBuffer | None = None) -> bytearray: ...
-    def partition(self, __sep: ReadableBuffer) -> tuple[bytearray, bytearray, bytearray]: ...
-    def pop(self, __index: int = -1) -> int: ...
-    def remove(self, __value: int) -> None: ...
+    def lstrip(self, bytes: ReadableBuffer | None = None, /) -> bytearray: ...
+    def partition(self, sep: ReadableBuffer, /) -> tuple[bytearray, bytearray, bytearray]: ...
+    def pop(self, index: int = -1, /) -> int: ...
+    def remove(self, value: int, /) -> None: ...
     if sys.version_info >= (3, 9):
-        def removeprefix(self, __prefix: ReadableBuffer) -> bytearray: ...
-        def removesuffix(self, __suffix: ReadableBuffer) -> bytearray: ...
+        def removeprefix(self, prefix: ReadableBuffer, /) -> bytearray: ...
+        def removesuffix(self, suffix: ReadableBuffer, /) -> bytearray: ...
 
-    def replace(self, __old: ReadableBuffer, __new: ReadableBuffer, __count: SupportsIndex = -1) -> bytearray: ...
+    def replace(self, old: ReadableBuffer, new: ReadableBuffer, count: SupportsIndex = -1, /) -> bytearray: ...
     def rfind(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
     def rindex(
-        self, __sub: ReadableBuffer | SupportsIndex, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
+        self, sub: ReadableBuffer | SupportsIndex, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /
     ) -> int: ...
-    def rjust(self, __width: SupportsIndex, __fillchar: bytes | bytearray = b" ") -> bytearray: ...
-    def rpartition(self, __sep: ReadableBuffer) -> tuple[bytearray, bytearray, bytearray]: ...
+    def rjust(self, width: SupportsIndex, fillchar: bytes | bytearray = b" ", /) -> bytearray: ...
+    def rpartition(self, sep: ReadableBuffer, /) -> tuple[bytearray, bytearray, bytearray]: ...
     def rsplit(self, sep: ReadableBuffer | None = None, maxsplit: SupportsIndex = -1) -> list[bytearray]: ...
-    def rstrip(self, __bytes: ReadableBuffer | None = None) -> bytearray: ...
+    def rstrip(self, bytes: ReadableBuffer | None = None, /) -> bytearray: ...
     def split(self, sep: ReadableBuffer | None = None, maxsplit: SupportsIndex = -1) -> list[bytearray]: ...
     def splitlines(self, keepends: bool = False) -> list[bytearray]: ...
     def startswith(
         self,
-        __prefix: ReadableBuffer | tuple[ReadableBuffer, ...],
-        __start: SupportsIndex | None = ...,
-        __end: SupportsIndex | None = ...,
+        prefix: ReadableBuffer | tuple[ReadableBuffer, ...],
+        start: SupportsIndex | None = ...,
+        end: SupportsIndex | None = ...,
+        /,
     ) -> bool: ...
-    def strip(self, __bytes: ReadableBuffer | None = None) -> bytearray: ...
+    def strip(self, bytes: ReadableBuffer | None = None, /) -> bytearray: ...
     def swapcase(self) -> bytearray: ...
     def title(self) -> bytearray: ...
-    def translate(self, __table: ReadableBuffer | None, delete: bytes = b"") -> bytearray: ...
+    def translate(self, table: ReadableBuffer | None, /, delete: bytes = b"") -> bytearray: ...
     def upper(self) -> bytearray: ...
-    def zfill(self, __width: SupportsIndex) -> bytearray: ...
+    def zfill(self, width: SupportsIndex, /) -> bytearray: ...
     @classmethod
-    def fromhex(cls, __string: str) -> Self: ...
+    def fromhex(cls, string: str, /) -> Self: ...
     @staticmethod
-    def maketrans(__frm: ReadableBuffer, __to: ReadableBuffer) -> bytes: ...
+    def maketrans(frm: ReadableBuffer, to: ReadableBuffer, /) -> bytes: ...
     def __len__(self) -> int: ...
     def __iter__(self) -> Iterator[int]: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
     @overload
-    def __getitem__(self, __key: SupportsIndex) -> int: ...
+    def __getitem__(self, key: SupportsIndex, /) -> int: ...
     @overload
-    def __getitem__(self, __key: slice) -> bytearray: ...
+    def __getitem__(self, key: slice, /) -> bytearray: ...
     @overload
-    def __setitem__(self, __key: SupportsIndex, __value: SupportsIndex) -> None: ...
+    def __setitem__(self, key: SupportsIndex, value: SupportsIndex, /) -> None: ...
     @overload
-    def __setitem__(self, __key: slice, __value: Iterable[SupportsIndex] | bytes) -> None: ...
-    def __delitem__(self, __key: SupportsIndex | slice) -> None: ...
-    def __add__(self, __value: ReadableBuffer) -> bytearray: ...
+    def __setitem__(self, key: slice, value: Iterable[SupportsIndex] | bytes, /) -> None: ...
+    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
+    def __add__(self, value: ReadableBuffer, /) -> bytearray: ...
     # The superclass wants us to accept Iterable[int], but that fails at runtime.
-    def __iadd__(self, __value: ReadableBuffer) -> Self: ...  # type: ignore[override]
-    def __mul__(self, __value: SupportsIndex) -> bytearray: ...
-    def __rmul__(self, __value: SupportsIndex) -> bytearray: ...
-    def __imul__(self, __value: SupportsIndex) -> Self: ...
-    def __mod__(self, __value: Any) -> bytes: ...
+    def __iadd__(self, value: ReadableBuffer, /) -> Self: ...  # type: ignore[override]
+    def __mul__(self, value: SupportsIndex, /) -> bytearray: ...
+    def __rmul__(self, value: SupportsIndex, /) -> bytearray: ...
+    def __imul__(self, value: SupportsIndex, /) -> Self: ...
+    def __mod__(self, value: Any, /) -> bytes: ...
     # Incompatible with Sequence.__contains__
-    def __contains__(self, __key: SupportsIndex | ReadableBuffer) -> bool: ...  # type: ignore[override]
-    def __eq__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
-    def __lt__(self, __value: ReadableBuffer) -> bool: ...
-    def __le__(self, __value: ReadableBuffer) -> bool: ...
-    def __gt__(self, __value: ReadableBuffer) -> bool: ...
-    def __ge__(self, __value: ReadableBuffer) -> bool: ...
+    def __contains__(self, key: SupportsIndex | ReadableBuffer, /) -> bool: ...  # type: ignore[override]
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
+    def __lt__(self, value: ReadableBuffer, /) -> bool: ...
+    def __le__(self, value: ReadableBuffer, /) -> bool: ...
+    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: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+
+_IntegerFormats: TypeAlias = Literal[
+    "b", "B", "@b", "@B", "h", "H", "@h", "@H", "i", "I", "@i", "@I", "l", "L", "@l", "@L", "q", "Q", "@q", "@Q", "P", "@P"
+]
 
 @final
-class memoryview(Sequence[int]):
+class memoryview(Sequence[_I]):
     @property
     def format(self) -> str: ...
     @property
@@ -748,120 +768,161 @@ class memoryview(Sequence[int]):
     def contiguous(self) -> bool: ...
     @property
     def nbytes(self) -> int: ...
-    def __init__(self, obj: ReadableBuffer) -> None: ...
+    def __new__(cls, obj: ReadableBuffer) -> Self: ...
     def __enter__(self) -> Self: ...
     def __exit__(
-        self, __exc_type: type[BaseException] | None, __exc_val: BaseException | None, __exc_tb: TracebackType | None
+        self,
+        exc_type: type[BaseException] | None,  # noqa: PYI036 # This is the module declaring BaseException
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+        /,
     ) -> None: ...
-    def cast(self, format: str, shape: list[int] | tuple[int, ...] = ...) -> memoryview: ...
     @overload
-    def __getitem__(self, __key: SupportsIndex) -> int: ...
+    def cast(self, format: Literal["c", "@c"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bytes]: ...
     @overload
-    def __getitem__(self, __key: slice) -> memoryview: ...
-    def __contains__(self, __x: object) -> bool: ...
-    def __iter__(self) -> Iterator[int]: ...
+    def cast(self, format: Literal["f", "@f", "d", "@d"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[float]: ...
+    @overload
+    def cast(self, format: Literal["?"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bool]: ...
+    @overload
+    def cast(self, format: _IntegerFormats, shape: list[int] | tuple[int, ...] = ...) -> memoryview: ...
+    @overload
+    def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> _I: ...
+    @overload
+    def __getitem__(self, key: slice, /) -> memoryview[_I]: ...
+    def __contains__(self, x: object, /) -> bool: ...
+    def __iter__(self) -> Iterator[_I]: ...
     def __len__(self) -> int: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
     @overload
-    def __setitem__(self, __key: slice, __value: ReadableBuffer) -> None: ...
+    def __setitem__(self, key: slice, value: ReadableBuffer, /) -> None: ...
     @overload
-    def __setitem__(self, __key: SupportsIndex, __value: SupportsIndex) -> None: ...
+    def __setitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], value: _I, /) -> None: ...
     if sys.version_info >= (3, 10):
         def tobytes(self, order: Literal["C", "F", "A"] | None = "C") -> bytes: ...
-    elif sys.version_info >= (3, 8):
-        def tobytes(self, order: Literal["C", "F", "A"] | None = None) -> bytes: ...
     else:
-        def tobytes(self) -> bytes: ...
+        def tobytes(self, order: Literal["C", "F", "A"] | None = None) -> bytes: ...
 
     def tolist(self) -> list[int]: ...
-    if sys.version_info >= (3, 8):
-        def toreadonly(self) -> memoryview: ...
-
+    def toreadonly(self) -> memoryview: ...
     def release(self) -> None: ...
-    if sys.version_info >= (3, 8):
-        def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str: ...
-    else:
-        def hex(self) -> str: ...
+    def hex(self, sep: str | bytes = ..., bytes_per_sep: SupportsIndex = ...) -> str: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
 
-    def __buffer__(self, __flags: int) -> memoryview: ...
-    def __release_buffer__(self, __buffer: memoryview) -> None: ...
+    # These are inherited from the Sequence ABC, but don't actually exist on memoryview.
+    # See https://github.com/python/cpython/issues/125420
+    index: ClassVar[None]  # type: ignore[assignment]
+    count: ClassVar[None]  # type: ignore[assignment]
 
 @final
 class bool(int):
-    def __new__(cls, __o: object = ...) -> Self: ...
+    def __new__(cls, o: object = ..., /) -> Self: ...
     # The following overloads could be represented more elegantly with a TypeVar("_B", bool, int),
     # however mypy has a bug regarding TypeVar constraints (https://github.com/python/mypy/issues/11880).
     @overload
-    def __and__(self, __value: bool) -> bool: ...
+    def __and__(self, value: bool, /) -> bool: ...
     @overload
-    def __and__(self, __value: int) -> int: ...
+    def __and__(self, value: int, /) -> int: ...
     @overload
-    def __or__(self, __value: bool) -> bool: ...
+    def __or__(self, value: bool, /) -> bool: ...
     @overload
-    def __or__(self, __value: int) -> int: ...
+    def __or__(self, value: int, /) -> int: ...
     @overload
-    def __xor__(self, __value: bool) -> bool: ...
+    def __xor__(self, value: bool, /) -> bool: ...
     @overload
-    def __xor__(self, __value: int) -> int: ...
+    def __xor__(self, value: int, /) -> int: ...
     @overload
-    def __rand__(self, __value: bool) -> bool: ...
+    def __rand__(self, value: bool, /) -> bool: ...
     @overload
-    def __rand__(self, __value: int) -> int: ...
+    def __rand__(self, value: int, /) -> int: ...
     @overload
-    def __ror__(self, __value: bool) -> bool: ...
+    def __ror__(self, value: bool, /) -> bool: ...
     @overload
-    def __ror__(self, __value: int) -> int: ...
+    def __ror__(self, value: int, /) -> int: ...
     @overload
-    def __rxor__(self, __value: bool) -> bool: ...
+    def __rxor__(self, value: bool, /) -> bool: ...
     @overload
-    def __rxor__(self, __value: int) -> int: ...
+    def __rxor__(self, value: int, /) -> int: ...
     def __getnewargs__(self) -> tuple[int]: ...
+    @deprecated("Will throw an error in Python 3.14. Use `not` for logical negation of bools instead.")
+    def __invert__(self) -> int: ...
 
 @final
-class slice:
+class slice(Generic[_StartT_co, _StopT_co, _StepT_co]):
     @property
-    def start(self) -> Any: ...
+    def start(self) -> _StartT_co: ...
     @property
-    def step(self) -> Any: ...
+    def step(self) -> _StepT_co: ...
     @property
-    def stop(self) -> Any: ...
+    def stop(self) -> _StopT_co: ...
+    # Note: __new__ overloads map `None` to `Any`, since users expect slice(x, None)
+    #  to be compatible with slice(None, x).
+    # generic slice --------------------------------------------------------------------
     @overload
-    def __init__(self, __stop: Any) -> None: ...
+    def __new__(cls, start: None, stop: None = None, step: None = None, /) -> slice[Any, Any, Any]: ...
+    # unary overloads ------------------------------------------------------------------
     @overload
-    def __init__(self, __start: Any, __stop: Any, __step: Any = ...) -> None: ...
-    __hash__: ClassVar[None]  # type: ignore[assignment]
-    def indices(self, __len: SupportsIndex) -> tuple[int, int, int]: ...
+    def __new__(cls, stop: _T2, /) -> slice[Any, _T2, Any]: ...
+    # binary overloads -----------------------------------------------------------------
+    @overload
+    def __new__(cls, start: _T1, stop: None, step: None = None, /) -> slice[_T1, Any, Any]: ...
+    @overload
+    def __new__(cls, start: None, stop: _T2, step: None = None, /) -> slice[Any, _T2, Any]: ...
+    @overload
+    def __new__(cls, start: _T1, stop: _T2, step: None = None, /) -> slice[_T1, _T2, Any]: ...
+    # ternary overloads ----------------------------------------------------------------
+    @overload
+    def __new__(cls, start: None, stop: None, step: _T3, /) -> slice[Any, Any, _T3]: ...
+    @overload
+    def __new__(cls, start: _T1, stop: None, step: _T3, /) -> slice[_T1, Any, _T3]: ...
+    @overload
+    def __new__(cls, start: None, stop: _T2, step: _T3, /) -> slice[Any, _T2, _T3]: ...
+    @overload
+    def __new__(cls, start: _T1, stop: _T2, step: _T3, /) -> slice[_T1, _T2, _T3]: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def __hash__(self) -> int: ...
+    else:
+        __hash__: ClassVar[None]  # type: ignore[assignment]
+
+    def indices(self, len: SupportsIndex, /) -> tuple[int, int, int]: ...
 
-class tuple(Sequence[_T_co], Generic[_T_co]):
-    def __new__(cls, __iterable: Iterable[_T_co] = ...) -> Self: ...
+class tuple(Sequence[_T_co]):
+    def __new__(cls, iterable: Iterable[_T_co] = ..., /) -> Self: ...
     def __len__(self) -> int: ...
-    def __contains__(self, __key: object) -> bool: ...
+    def __contains__(self, key: object, /) -> bool: ...
     @overload
-    def __getitem__(self, __key: SupportsIndex) -> _T_co: ...
+    def __getitem__(self, key: SupportsIndex, /) -> _T_co: ...
     @overload
-    def __getitem__(self, __key: slice) -> tuple[_T_co, ...]: ...
+    def __getitem__(self, key: slice, /) -> tuple[_T_co, ...]: ...
     def __iter__(self) -> Iterator[_T_co]: ...
-    def __lt__(self, __value: tuple[_T_co, ...]) -> bool: ...
-    def __le__(self, __value: tuple[_T_co, ...]) -> bool: ...
-    def __gt__(self, __value: tuple[_T_co, ...]) -> bool: ...
-    def __ge__(self, __value: tuple[_T_co, ...]) -> bool: ...
-    @overload
-    def __add__(self, __value: tuple[_T_co, ...]) -> tuple[_T_co, ...]: ...
-    @overload
-    def __add__(self, __value: tuple[_T, ...]) -> tuple[_T_co | _T, ...]: ...
-    def __mul__(self, __value: SupportsIndex) -> tuple[_T_co, ...]: ...
-    def __rmul__(self, __value: SupportsIndex) -> tuple[_T_co, ...]: ...
-    def count(self, __value: Any) -> int: ...
-    def index(self, __value: Any, __start: SupportsIndex = 0, __stop: SupportsIndex = sys.maxsize) -> int: ...
+    def __lt__(self, value: tuple[_T_co, ...], /) -> bool: ...
+    def __le__(self, value: tuple[_T_co, ...], /) -> bool: ...
+    def __gt__(self, value: tuple[_T_co, ...], /) -> bool: ...
+    def __ge__(self, value: tuple[_T_co, ...], /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __add__(self, value: tuple[_T_co, ...], /) -> tuple[_T_co, ...]: ...
+    @overload
+    def __add__(self, value: tuple[_T, ...], /) -> tuple[_T_co | _T, ...]: ...
+    def __mul__(self, value: SupportsIndex, /) -> tuple[_T_co, ...]: ...
+    def __rmul__(self, value: SupportsIndex, /) -> tuple[_T_co, ...]: ...
+    def count(self, value: Any, /) -> int: ...
+    def index(self, value: Any, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-# Doesn't exist at runtime, but deleting this breaks mypy. See #2999
+# Doesn't exist at runtime, but deleting this breaks mypy and pyright. See:
+# https://github.com/python/typeshed/issues/7580
+# https://github.com/python/mypy/issues/8240
 @final
 @type_check_only
 class function:
     # Make sure this class definition stays roughly in line with `types.FunctionType`
     @property
-    def __closure__(self) -> tuple[_Cell, ...] | None: ...
+    def __closure__(self) -> tuple[CellType, ...] | None: ...
     __code__: CodeType
     __defaults__: tuple[Any, ...] | None
     __dict__: dict[str, Any]
@@ -874,26 +935,28 @@ 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.
-    def __get__(self, __instance: object, __owner: type | None = None) -> Any: ...
+    def __get__(self, instance: object, owner: type | None = None, /) -> Any: ...
 
-class list(MutableSequence[_T], Generic[_T]):
+class list(MutableSequence[_T]):
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self, __iterable: Iterable[_T]) -> None: ...
+    def __init__(self, iterable: Iterable[_T], /) -> None: ...
     def copy(self) -> list[_T]: ...
-    def append(self, __object: _T) -> None: ...
-    def extend(self, __iterable: Iterable[_T]) -> None: ...
-    def pop(self, __index: SupportsIndex = -1) -> _T: ...
+    def append(self, object: _T, /) -> None: ...
+    def extend(self, iterable: Iterable[_T], /) -> None: ...
+    def pop(self, index: SupportsIndex = -1, /) -> _T: ...
     # Signature of `list.index` should be kept in line with `collections.UserList.index()`
     # and multiprocessing.managers.ListProxy.index()
-    def index(self, __value: _T, __start: SupportsIndex = 0, __stop: SupportsIndex = sys.maxsize) -> int: ...
-    def count(self, __value: _T) -> int: ...
-    def insert(self, __index: SupportsIndex, __object: _T) -> None: ...
-    def remove(self, __value: _T) -> None: ...
+    def index(self, value: _T, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int: ...
+    def count(self, value: _T, /) -> int: ...
+    def insert(self, index: SupportsIndex, object: _T, /) -> None: ...
+    def remove(self, value: _T, /) -> None: ...
     # Signature of `list.sort` should be kept inline with `collections.UserList.sort()`
     # and multiprocessing.managers.ListProxy.sort()
     #
@@ -907,166 +970,191 @@ class list(MutableSequence[_T], Generic[_T]):
     def __iter__(self) -> Iterator[_T]: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
     @overload
-    def __getitem__(self, __i: SupportsIndex) -> _T: ...
+    def __getitem__(self, i: SupportsIndex, /) -> _T: ...
     @overload
-    def __getitem__(self, __s: slice) -> list[_T]: ...
+    def __getitem__(self, s: slice, /) -> list[_T]: ...
     @overload
-    def __setitem__(self, __key: SupportsIndex, __value: _T) -> None: ...
+    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...
     @overload
-    def __setitem__(self, __key: slice, __value: Iterable[_T]) -> None: ...
-    def __delitem__(self, __key: SupportsIndex | slice) -> None: ...
+    def __setitem__(self, key: slice, value: Iterable[_T], /) -> None: ...
+    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
     # Overloading looks unnecessary, but is needed to work around complex mypy problems
     @overload
-    def __add__(self, __value: list[_T]) -> list[_T]: ...
+    def __add__(self, value: list[_T], /) -> list[_T]: ...
     @overload
-    def __add__(self, __value: list[_S]) -> list[_S | _T]: ...
-    def __iadd__(self, __value: Iterable[_T]) -> Self: ...  # type: ignore[misc]
-    def __mul__(self, __value: SupportsIndex) -> list[_T]: ...
-    def __rmul__(self, __value: SupportsIndex) -> list[_T]: ...
-    def __imul__(self, __value: SupportsIndex) -> Self: ...
-    def __contains__(self, __key: object) -> bool: ...
+    def __add__(self, value: list[_S], /) -> list[_S | _T]: ...
+    def __iadd__(self, value: Iterable[_T], /) -> Self: ...  # type: ignore[misc]
+    def __mul__(self, value: SupportsIndex, /) -> list[_T]: ...
+    def __rmul__(self, value: SupportsIndex, /) -> list[_T]: ...
+    def __imul__(self, value: SupportsIndex, /) -> Self: ...
+    def __contains__(self, key: object, /) -> bool: ...
     def __reversed__(self) -> Iterator[_T]: ...
-    def __gt__(self, __value: list[_T]) -> bool: ...
-    def __ge__(self, __value: list[_T]) -> bool: ...
-    def __lt__(self, __value: list[_T]) -> bool: ...
-    def __le__(self, __value: list[_T]) -> bool: ...
+    def __gt__(self, value: list[_T], /) -> bool: ...
+    def __ge__(self, value: list[_T], /) -> bool: ...
+    def __lt__(self, value: list[_T], /) -> bool: ...
+    def __le__(self, value: list[_T], /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
+class dict(MutableMapping[_KT, _VT]):
     # __init__ should be kept roughly in line with `collections.UserDict.__init__`, which has similar semantics
     # Also multiprocessing.managers.SyncManager.dict()
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self: dict[str, _VT], **kwargs: _VT) -> None: ...
+    def __init__(self: dict[str, _VT], **kwargs: _VT) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]  #11780
     @overload
-    def __init__(self, __map: SupportsKeysAndGetItem[_KT, _VT]) -> None: ...
+    def __init__(self, map: SupportsKeysAndGetItem[_KT, _VT], /) -> None: ...
     @overload
-    def __init__(self: dict[str, _VT], __map: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT) -> None: ...
+    def __init__(
+        self: dict[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        map: SupportsKeysAndGetItem[str, _VT],
+        /,
+        **kwargs: _VT,
+    ) -> None: ...
     @overload
-    def __init__(self, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ...
+    def __init__(self, iterable: Iterable[tuple[_KT, _VT]], /) -> None: ...
     @overload
-    def __init__(self: dict[str, _VT], __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT) -> None: ...
+    def __init__(
+        self: dict[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        iterable: Iterable[tuple[str, _VT]],
+        /,
+        **kwargs: _VT,
+    ) -> None: ...
     # Next two overloads are for dict(string.split(sep) for string in iterable)
     # Cannot be Iterable[Sequence[_T]] or otherwise dict(["foo", "bar", "baz"]) is not an error
     @overload
-    def __init__(self: dict[str, str], __iterable: Iterable[list[str]]) -> None: ...
+    def __init__(self: dict[str, str], iterable: Iterable[list[str]], /) -> None: ...
     @overload
-    def __init__(self: dict[bytes, bytes], __iterable: Iterable[list[bytes]]) -> None: ...
+    def __init__(self: dict[bytes, bytes], iterable: Iterable[list[bytes]], /) -> None: ...
     def __new__(cls, *args: Any, **kwargs: Any) -> Self: ...
     def copy(self) -> dict[_KT, _VT]: ...
     def keys(self) -> dict_keys[_KT, _VT]: ...
     def values(self) -> dict_values[_KT, _VT]: ...
     def items(self) -> dict_items[_KT, _VT]: ...
-    # Signature of `dict.fromkeys` should be kept identical to `fromkeys` methods of `OrderedDict`/`ChainMap`/`UserDict` in `collections`
+    # Signature of `dict.fromkeys` should be kept identical to
+    # `fromkeys` methods of `OrderedDict`/`ChainMap`/`UserDict` in `collections`
     # TODO: the true signature of `dict.fromkeys` is not expressible in the current type system.
     # See #3800 & https://github.com/python/typing/issues/548#issuecomment-683336963.
     @classmethod
     @overload
-    def fromkeys(cls, __iterable: Iterable[_T], __value: None = None) -> dict[_T, Any | None]: ...
+    def fromkeys(cls, iterable: Iterable[_T], value: None = None, /) -> dict[_T, Any | None]: ...
     @classmethod
     @overload
-    def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> dict[_T, _S]: ...
+    def fromkeys(cls, iterable: Iterable[_T], value: _S, /) -> dict[_T, _S]: ...
     # Positional-only in dict, but not in MutableMapping
+    @overload  # type: ignore[override]
+    def get(self, key: _KT, default: None = None, /) -> _VT | None: ...
     @overload
-    def get(self, __key: _KT) -> _VT | None: ...
+    def get(self, key: _KT, default: _VT, /) -> _VT: ...
     @overload
-    def get(self, __key: _KT, __default: _VT | _T) -> _VT | _T: ...
+    def get(self, key: _KT, default: _T, /) -> _VT | _T: ...
     @overload
-    def pop(self, __key: _KT) -> _VT: ...
+    def pop(self, key: _KT, /) -> _VT: ...
     @overload
-    def pop(self, __key: _KT, __default: _VT | _T) -> _VT | _T: ...
+    def pop(self, key: _KT, default: _VT, /) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _T, /) -> _VT | _T: ...
     def __len__(self) -> int: ...
-    def __getitem__(self, __key: _KT) -> _VT: ...
-    def __setitem__(self, __key: _KT, __value: _VT) -> None: ...
-    def __delitem__(self, __key: _KT) -> None: ...
+    def __getitem__(self, key: _KT, /) -> _VT: ...
+    def __setitem__(self, key: _KT, value: _VT, /) -> None: ...
+    def __delitem__(self, key: _KT, /) -> None: ...
     def __iter__(self) -> Iterator[_KT]: ...
-    if sys.version_info >= (3, 8):
-        def __reversed__(self) -> Iterator[_KT]: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __reversed__(self) -> Iterator[_KT]: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
-        def __or__(self, __value: Mapping[_T1, _T2]) -> dict[_KT | _T1, _VT | _T2]: ...
-        def __ror__(self, __value: Mapping[_T1, _T2]) -> dict[_KT | _T1, _VT | _T2]: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        @overload
+        def __or__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
+        @overload
+        def __or__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
+        @overload
+        def __ror__(self, value: dict[_KT, _VT], /) -> dict[_KT, _VT]: ...
+        @overload
+        def __ror__(self, value: dict[_T1, _T2], /) -> dict[_KT | _T1, _VT | _T2]: ...
         # dict.__ior__ should be kept roughly in line with MutableMapping.update()
         @overload  # type: ignore[misc]
-        def __ior__(self, __value: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
+        def __ior__(self, value: SupportsKeysAndGetItem[_KT, _VT], /) -> Self: ...
         @overload
-        def __ior__(self, __value: Iterable[tuple[_KT, _VT]]) -> Self: ...
+        def __ior__(self, value: Iterable[tuple[_KT, _VT]], /) -> Self: ...
 
-class set(MutableSet[_T], Generic[_T]):
+class set(MutableSet[_T]):
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self, __iterable: Iterable[_T]) -> None: ...
-    def add(self, __element: _T) -> None: ...
+    def __init__(self, iterable: Iterable[_T], /) -> None: ...
+    def add(self, element: _T, /) -> None: ...
     def copy(self) -> set[_T]: ...
     def difference(self, *s: Iterable[Any]) -> set[_T]: ...
     def difference_update(self, *s: Iterable[Any]) -> None: ...
-    def discard(self, __element: _T) -> None: ...
+    def discard(self, element: _T, /) -> None: ...
     def intersection(self, *s: Iterable[Any]) -> set[_T]: ...
     def intersection_update(self, *s: Iterable[Any]) -> None: ...
-    def isdisjoint(self, __s: Iterable[Any]) -> bool: ...
-    def issubset(self, __s: Iterable[Any]) -> bool: ...
-    def issuperset(self, __s: Iterable[Any]) -> bool: ...
-    def remove(self, __element: _T) -> None: ...
-    def symmetric_difference(self, __s: Iterable[_T]) -> set[_T]: ...
-    def symmetric_difference_update(self, __s: Iterable[_T]) -> None: ...
+    def isdisjoint(self, s: Iterable[Any], /) -> bool: ...
+    def issubset(self, s: Iterable[Any], /) -> bool: ...
+    def issuperset(self, s: Iterable[Any], /) -> bool: ...
+    def remove(self, element: _T, /) -> None: ...
+    def symmetric_difference(self, s: Iterable[_T], /) -> set[_T]: ...
+    def symmetric_difference_update(self, s: Iterable[_T], /) -> None: ...
     def union(self, *s: Iterable[_S]) -> set[_T | _S]: ...
     def update(self, *s: Iterable[_T]) -> None: ...
     def __len__(self) -> int: ...
-    def __contains__(self, __o: object) -> bool: ...
+    def __contains__(self, o: object, /) -> bool: ...
     def __iter__(self) -> Iterator[_T]: ...
-    def __and__(self, __value: AbstractSet[object]) -> set[_T]: ...
-    def __iand__(self, __value: AbstractSet[object]) -> Self: ...
-    def __or__(self, __value: AbstractSet[_S]) -> set[_T | _S]: ...
-    def __ior__(self, __value: AbstractSet[_T]) -> Self: ...  # type: ignore[override,misc]
-    def __sub__(self, __value: AbstractSet[_T | None]) -> set[_T]: ...
-    def __isub__(self, __value: AbstractSet[object]) -> Self: ...
-    def __xor__(self, __value: AbstractSet[_S]) -> set[_T | _S]: ...
-    def __ixor__(self, __value: AbstractSet[_T]) -> Self: ...  # type: ignore[override,misc]
-    def __le__(self, __value: AbstractSet[object]) -> bool: ...
-    def __lt__(self, __value: AbstractSet[object]) -> bool: ...
-    def __ge__(self, __value: AbstractSet[object]) -> bool: ...
-    def __gt__(self, __value: AbstractSet[object]) -> bool: ...
+    def __and__(self, value: AbstractSet[object], /) -> set[_T]: ...
+    def __iand__(self, value: AbstractSet[object], /) -> Self: ...
+    def __or__(self, value: AbstractSet[_S], /) -> set[_T | _S]: ...
+    def __ior__(self, value: AbstractSet[_T], /) -> Self: ...  # type: ignore[override,misc]
+    def __sub__(self, value: AbstractSet[_T | None], /) -> set[_T]: ...
+    def __isub__(self, value: AbstractSet[object], /) -> Self: ...
+    def __xor__(self, value: AbstractSet[_S], /) -> set[_T | _S]: ...
+    def __ixor__(self, value: AbstractSet[_T], /) -> Self: ...  # type: ignore[override,misc]
+    def __le__(self, value: AbstractSet[object], /) -> bool: ...
+    def __lt__(self, value: AbstractSet[object], /) -> bool: ...
+    def __ge__(self, value: AbstractSet[object], /) -> bool: ...
+    def __gt__(self, value: AbstractSet[object], /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class frozenset(AbstractSet[_T_co], Generic[_T_co]):
+class frozenset(AbstractSet[_T_co]):
     @overload
     def __new__(cls) -> Self: ...
     @overload
-    def __new__(cls, __iterable: Iterable[_T_co]) -> Self: ...
+    def __new__(cls, iterable: Iterable[_T_co], /) -> Self: ...
     def copy(self) -> frozenset[_T_co]: ...
     def difference(self, *s: Iterable[object]) -> frozenset[_T_co]: ...
     def intersection(self, *s: Iterable[object]) -> frozenset[_T_co]: ...
-    def isdisjoint(self, __s: Iterable[_T_co]) -> bool: ...
-    def issubset(self, __s: Iterable[object]) -> bool: ...
-    def issuperset(self, __s: Iterable[object]) -> bool: ...
-    def symmetric_difference(self, __s: Iterable[_T_co]) -> frozenset[_T_co]: ...
+    def isdisjoint(self, s: Iterable[_T_co], /) -> bool: ...
+    def issubset(self, s: Iterable[object], /) -> bool: ...
+    def issuperset(self, s: Iterable[object], /) -> bool: ...
+    def symmetric_difference(self, s: Iterable[_T_co], /) -> frozenset[_T_co]: ...
     def union(self, *s: Iterable[_S]) -> frozenset[_T_co | _S]: ...
     def __len__(self) -> int: ...
-    def __contains__(self, __o: object) -> bool: ...
+    def __contains__(self, o: object, /) -> bool: ...
     def __iter__(self) -> Iterator[_T_co]: ...
-    def __and__(self, __value: AbstractSet[_T_co]) -> frozenset[_T_co]: ...
-    def __or__(self, __value: AbstractSet[_S]) -> frozenset[_T_co | _S]: ...
-    def __sub__(self, __value: AbstractSet[_T_co]) -> frozenset[_T_co]: ...
-    def __xor__(self, __value: AbstractSet[_S]) -> frozenset[_T_co | _S]: ...
-    def __le__(self, __value: AbstractSet[object]) -> bool: ...
-    def __lt__(self, __value: AbstractSet[object]) -> bool: ...
-    def __ge__(self, __value: AbstractSet[object]) -> bool: ...
-    def __gt__(self, __value: AbstractSet[object]) -> bool: ...
+    def __and__(self, value: AbstractSet[_T_co], /) -> frozenset[_T_co]: ...
+    def __or__(self, value: AbstractSet[_S], /) -> frozenset[_T_co | _S]: ...
+    def __sub__(self, value: AbstractSet[_T_co], /) -> frozenset[_T_co]: ...
+    def __xor__(self, value: AbstractSet[_S], /) -> frozenset[_T_co | _S]: ...
+    def __le__(self, value: AbstractSet[object], /) -> bool: ...
+    def __lt__(self, value: AbstractSet[object], /) -> bool: ...
+    def __ge__(self, value: AbstractSet[object], /) -> bool: ...
+    def __gt__(self, value: AbstractSet[object], /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class enumerate(Iterator[tuple[int, _T]], Generic[_T]):
-    def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ...
+class enumerate(Iterator[tuple[int, _T]]):
+    def __new__(cls, iterable: Iterable[_T], start: int = 0) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> tuple[int, _T]: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @final
 class range(Sequence[int]):
@@ -1077,18 +1165,20 @@ class range(Sequence[int]):
     @property
     def step(self) -> int: ...
     @overload
-    def __init__(self, __stop: SupportsIndex) -> None: ...
+    def __new__(cls, stop: SupportsIndex, /) -> Self: ...
     @overload
-    def __init__(self, __start: SupportsIndex, __stop: SupportsIndex, __step: SupportsIndex = ...) -> None: ...
-    def count(self, __value: int) -> int: ...
-    def index(self, __value: int) -> int: ...  # type: ignore[override]
+    def __new__(cls, start: SupportsIndex, stop: SupportsIndex, step: SupportsIndex = ..., /) -> Self: ...
+    def count(self, value: int, /) -> int: ...
+    def index(self, value: int, /) -> int: ...  # type: ignore[override]
     def __len__(self) -> int: ...
-    def __contains__(self, __key: object) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __contains__(self, key: object, /) -> bool: ...
     def __iter__(self) -> Iterator[int]: ...
     @overload
-    def __getitem__(self, __key: SupportsIndex) -> int: ...
+    def __getitem__(self, key: SupportsIndex, /) -> int: ...
     @overload
-    def __getitem__(self, __key: slice) -> range: ...
+    def __getitem__(self, key: slice, /) -> range: ...
     def __reversed__(self) -> Iterator[int]: ...
 
 class property:
@@ -1096,6 +1186,9 @@ class property:
     fset: Callable[[Any, Any], None] | None
     fdel: Callable[[Any], None] | None
     __isabstractmethod__: bool
+    if sys.version_info >= (3, 13):
+        __name__: str
+
     def __init__(
         self,
         fget: Callable[[Any], Any] | None = ...,
@@ -1103,29 +1196,27 @@ class property:
         fdel: Callable[[Any], None] | None = ...,
         doc: str | None = ...,
     ) -> None: ...
-    def getter(self, __fget: Callable[[Any], Any]) -> property: ...
-    def setter(self, __fset: Callable[[Any, Any], None]) -> property: ...
-    def deleter(self, __fdel: Callable[[Any], None]) -> property: ...
-    def __get__(self, __instance: Any, __owner: type | None = None) -> Any: ...
-    def __set__(self, __instance: Any, __value: Any) -> None: ...
-    def __delete__(self, __instance: Any) -> None: ...
+    def getter(self, fget: Callable[[Any], Any], /) -> property: ...
+    def setter(self, fset: Callable[[Any, Any], None], /) -> property: ...
+    def deleter(self, fdel: Callable[[Any], None], /) -> property: ...
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
+    def __set__(self, instance: Any, value: Any, /) -> None: ...
+    def __delete__(self, instance: Any, /) -> None: ...
 
 @final
 class _NotImplementedType(Any):
-    # A little weird, but typing the __call__ as NotImplemented makes the error message
-    # for NotImplemented() much better
-    __call__: NotImplemented  # type: ignore[valid-type]  # pyright: ignore[reportGeneralTypeIssues]
+    __call__: None
 
 NotImplemented: _NotImplementedType
 
-def abs(__x: SupportsAbs[_T]) -> _T: ...
-def all(__iterable: Iterable[object]) -> bool: ...
-def any(__iterable: Iterable[object]) -> bool: ...
-def ascii(__obj: object) -> str: ...
-def bin(__number: int | SupportsIndex) -> str: ...
+def abs(x: SupportsAbs[_T], /) -> _T: ...
+def all(iterable: Iterable[object], /) -> bool: ...
+def any(iterable: Iterable[object], /) -> bool: ...
+def ascii(obj: object, /) -> str: ...
+def bin(number: int | SupportsIndex, /) -> str: ...
 def breakpoint(*args: Any, **kws: Any) -> None: ...
-def callable(__obj: object) -> TypeGuard[Callable[..., object]]: ...
-def chr(__i: int) -> str: ...
+def callable(obj: object, /) -> TypeIs[Callable[..., object]]: ...
+def chr(i: int | SupportsIndex, /) -> str: ...
 
 # We define this here instead of using os.PathLike to avoid import cycle issues.
 # See https://github.com/python/typeshed/pull/991#issuecomment-288160993
@@ -1133,7 +1224,7 @@ class _PathLike(Protocol[AnyStr_co]):
     def __fspath__(self) -> AnyStr_co: ...
 
 if sys.version_info >= (3, 10):
-    def aiter(__async_iterable: SupportsAiter[_SupportsAnextT]) -> _SupportsAnextT: ...
+    def aiter(async_iterable: SupportsAiter[_SupportsAnextT_co], /) -> _SupportsAnextT_co: ...
 
     class _SupportsSynchronousAnext(Protocol[_AwaitableT_co]):
         def __anext__(self) -> _AwaitableT_co: ...
@@ -1142,178 +1233,166 @@ if sys.version_info >= (3, 10):
     # `anext` is not, in fact, an async function. When default is not provided
     # `anext` is just a passthrough for `obj.__anext__`
     # See discussion in #7491 and pure-Python implementation of `anext` at https://github.com/python/cpython/blob/ea786a882b9ed4261eafabad6011bc7ef3b5bf94/Lib/test/test_asyncgen.py#L52-L80
-    def anext(__i: _SupportsSynchronousAnext[_AwaitableT]) -> _AwaitableT: ...
+    def anext(i: _SupportsSynchronousAnext[_AwaitableT], /) -> _AwaitableT: ...
     @overload
-    async def anext(__i: SupportsAnext[_T], default: _VT) -> _T | _VT: ...
+    async def anext(i: SupportsAnext[_T], default: _VT, /) -> _T | _VT: ...
 
 # compile() returns a CodeType, unless the flags argument includes PyCF_ONLY_AST (=1024),
 # in which case it returns ast.AST. We have overloads for flag 0 (the default) and for
 # explicitly passing PyCF_ONLY_AST. We fall back to Any for other values of flags.
-if sys.version_info >= (3, 8):
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        flags: Literal[0],
-        dont_inherit: bool = False,
-        optimize: int = -1,
-        *,
-        _feature_version: int = -1,
-    ) -> CodeType: ...
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        *,
-        dont_inherit: bool = False,
-        optimize: int = -1,
-        _feature_version: int = -1,
-    ) -> CodeType: ...
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        flags: Literal[1024],
-        dont_inherit: bool = False,
-        optimize: int = -1,
-        *,
-        _feature_version: int = -1,
-    ) -> _ast.AST: ...
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        flags: int,
-        dont_inherit: bool = False,
-        optimize: int = -1,
-        *,
-        _feature_version: int = -1,
-    ) -> Any: ...
+@overload
+def compile(
+    source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
+    filename: str | ReadableBuffer | _PathLike[Any],
+    mode: str,
+    flags: Literal[0],
+    dont_inherit: bool = False,
+    optimize: int = -1,
+    *,
+    _feature_version: int = -1,
+) -> CodeType: ...
+@overload
+def compile(
+    source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
+    filename: str | ReadableBuffer | _PathLike[Any],
+    mode: str,
+    *,
+    dont_inherit: bool = False,
+    optimize: int = -1,
+    _feature_version: int = -1,
+) -> CodeType: ...
+@overload
+def compile(
+    source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
+    filename: str | ReadableBuffer | _PathLike[Any],
+    mode: str,
+    flags: Literal[1024],
+    dont_inherit: bool = False,
+    optimize: int = -1,
+    *,
+    _feature_version: int = -1,
+) -> _ast.AST: ...
+@overload
+def compile(
+    source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
+    filename: str | ReadableBuffer | _PathLike[Any],
+    mode: str,
+    flags: int,
+    dont_inherit: bool = False,
+    optimize: int = -1,
+    *,
+    _feature_version: int = -1,
+) -> Any: ...
 
-else:
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        flags: Literal[0],
-        dont_inherit: bool = False,
-        optimize: int = -1,
-    ) -> CodeType: ...
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        *,
-        dont_inherit: bool = False,
-        optimize: int = -1,
-    ) -> CodeType: ...
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        flags: Literal[1024],
-        dont_inherit: bool = False,
-        optimize: int = -1,
-    ) -> _ast.AST: ...
-    @overload
-    def compile(
-        source: str | ReadableBuffer | _ast.Module | _ast.Expression | _ast.Interactive,
-        filename: str | ReadableBuffer | _PathLike[Any],
-        mode: str,
-        flags: int,
-        dont_inherit: bool = False,
-        optimize: int = -1,
-    ) -> Any: ...
+copyright: _sitebuiltins._Printer
+credits: _sitebuiltins._Printer
 
-def copyright() -> None: ...
-def credits() -> None: ...
-def delattr(__obj: object, __name: str) -> None: ...
-def dir(__o: object = ...) -> list[str]: ...
+def delattr(obj: object, name: str, /) -> None: ...
+def dir(o: object = ..., /) -> list[str]: ...
 @overload
-def divmod(__x: SupportsDivMod[_T_contra, _T_co], __y: _T_contra) -> _T_co: ...
+def divmod(x: SupportsDivMod[_T_contra, _T_co], y: _T_contra, /) -> _T_co: ...
 @overload
-def divmod(__x: _T_contra, __y: SupportsRDivMod[_T_contra, _T_co]) -> _T_co: ...
+def divmod(x: _T_contra, y: SupportsRDivMod[_T_contra, _T_co], /) -> _T_co: ...
 
 # The `globals` argument to `eval` has to be `dict[str, Any]` rather than `dict[str, object]` due to invariance.
 # (The `globals` argument has to be a "real dict", rather than any old mapping, unlike the `locals` argument.)
-def eval(
-    __source: str | ReadableBuffer | CodeType,
-    __globals: dict[str, Any] | None = None,
-    __locals: Mapping[str, object] | None = None,
-) -> Any: ...
+if sys.version_info >= (3, 13):
+    def eval(
+        source: str | ReadableBuffer | CodeType,
+        /,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+    ) -> Any: ...
+
+else:
+    def eval(
+        source: str | ReadableBuffer | CodeType,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+        /,
+    ) -> Any: ...
 
 # Comment above regarding `eval` applies to `exec` as well
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 13):
     def exec(
-        __source: str | ReadableBuffer | CodeType,
-        __globals: dict[str, Any] | None = None,
-        __locals: Mapping[str, object] | None = None,
+        source: str | ReadableBuffer | CodeType,
+        /,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
         *,
-        closure: tuple[_Cell, ...] | None = None,
+        closure: tuple[CellType, ...] | None = None,
+    ) -> None: ...
+
+elif sys.version_info >= (3, 11):
+    def exec(
+        source: str | ReadableBuffer | CodeType,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+        /,
+        *,
+        closure: tuple[CellType, ...] | None = None,
     ) -> None: ...
 
 else:
     def exec(
-        __source: str | ReadableBuffer | CodeType,
-        __globals: dict[str, Any] | None = None,
-        __locals: Mapping[str, object] | None = None,
+        source: str | ReadableBuffer | CodeType,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+        /,
     ) -> None: ...
 
-def exit(code: sys._ExitCode = None) -> NoReturn: ...
+exit: _sitebuiltins.Quitter
 
-class filter(Iterator[_T], Generic[_T]):
+class filter(Iterator[_T]):
     @overload
-    def __init__(self, __function: None, __iterable: Iterable[_T | None]) -> None: ...
+    def __new__(cls, function: None, iterable: Iterable[_T | None], /) -> Self: ...
     @overload
-    def __init__(self, __function: Callable[[_S], TypeGuard[_T]], __iterable: Iterable[_S]) -> None: ...
+    def __new__(cls, function: Callable[[_S], TypeGuard[_T]], iterable: Iterable[_S], /) -> Self: ...
     @overload
-    def __init__(self, __function: Callable[[_T], Any], __iterable: Iterable[_T]) -> None: ...
+    def __new__(cls, function: Callable[[_S], TypeIs[_T]], iterable: Iterable[_S], /) -> Self: ...
+    @overload
+    def __new__(cls, function: Callable[[_T], Any], iterable: Iterable[_T], /) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-def format(__value: object, __format_spec: str = "") -> str: ...
+def format(value: object, format_spec: str = "", /) -> str: ...
 @overload
-def getattr(__o: object, __name: str) -> Any: ...
+def getattr(o: object, name: str, /) -> Any: ...
 
 # While technically covered by the last overload, spelling out the types for None, bool
 # and basic containers help mypy out in some tricky situations involving type context
 # (aka bidirectional inference)
 @overload
-def getattr(__o: object, __name: str, __default: None) -> Any | None: ...
+def getattr(o: object, name: str, default: None, /) -> Any | None: ...
 @overload
-def getattr(__o: object, __name: str, __default: bool) -> Any | bool: ...
+def getattr(o: object, name: str, default: bool, /) -> Any | bool: ...
 @overload
-def getattr(__o: object, name: str, __default: list[Any]) -> Any | list[Any]: ...
+def getattr(o: object, name: str, default: list[Any], /) -> Any | list[Any]: ...
 @overload
-def getattr(__o: object, name: str, __default: dict[Any, Any]) -> Any | dict[Any, Any]: ...
+def getattr(o: object, name: str, default: dict[Any, Any], /) -> Any | dict[Any, Any]: ...
 @overload
-def getattr(__o: object, __name: str, __default: _T) -> Any | _T: ...
+def getattr(o: object, name: str, default: _T, /) -> Any | _T: ...
 def globals() -> dict[str, Any]: ...
-def hasattr(__obj: object, __name: str) -> bool: ...
-def hash(__obj: object) -> int: ...
-def help(request: object = ...) -> None: ...
-def hex(__number: int | SupportsIndex) -> str: ...
-def id(__obj: object) -> int: ...
-def input(__prompt: object = "") -> str: ...
+def hasattr(obj: object, name: str, /) -> bool: ...
+def hash(obj: object, /) -> int: ...
+
+help: _sitebuiltins._Helper
+
+def hex(number: int | SupportsIndex, /) -> str: ...
+def id(obj: object, /) -> int: ...
+def input(prompt: object = "", /) -> str: ...
 
 class _GetItemIterable(Protocol[_T_co]):
-    def __getitem__(self, __i: int) -> _T_co: ...
+    def __getitem__(self, i: int, /) -> _T_co: ...
 
 @overload
-def iter(__iterable: SupportsIter[_SupportsNextT]) -> _SupportsNextT: ...
+def iter(object: SupportsIter[_SupportsNextT_co], /) -> _SupportsNextT_co: ...
 @overload
-def iter(__iterable: _GetItemIterable[_T]) -> Iterator[_T]: ...
+def iter(object: _GetItemIterable[_T], /) -> Iterator[_T]: ...
 @overload
-def iter(__function: Callable[[], _T | None], __sentinel: None) -> Iterator[_T]: ...
+def iter(object: Callable[[], _T | None], sentinel: None, /) -> Iterator[_T]: ...
 @overload
-def iter(__function: Callable[[], _T], __sentinel: object) -> Iterator[_T]: ...
+def iter(object: Callable[[], _T], sentinel: object, /) -> Iterator[_T]: ...
 
 # Keep this alias in sync with unittest.case._ClassInfo
 if sys.version_info >= (3, 10):
@@ -1321,88 +1400,93 @@ if sys.version_info >= (3, 10):
 else:
     _ClassInfo: TypeAlias = type | tuple[_ClassInfo, ...]
 
-def isinstance(__obj: object, __class_or_tuple: _ClassInfo) -> bool: ...
-def issubclass(__cls: type, __class_or_tuple: _ClassInfo) -> bool: ...
-def len(__obj: Sized) -> int: ...
-def license() -> None: ...
+def isinstance(obj: object, class_or_tuple: _ClassInfo, /) -> bool: ...
+def issubclass(cls: type, class_or_tuple: _ClassInfo, /) -> bool: ...
+def len(obj: Sized, /) -> int: ...
+
+license: _sitebuiltins._Printer
+
 def locals() -> dict[str, Any]: ...
 
-class map(Iterator[_S], Generic[_S]):
+class map(Iterator[_S]):
     @overload
-    def __init__(self, __func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> None: ...
+    def __new__(cls, func: Callable[[_T1], _S], iterable: Iterable[_T1], /) -> Self: ...
     @overload
-    def __init__(self, __func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> None: ...
+    def __new__(cls, func: Callable[[_T1, _T2], _S], iterable: Iterable[_T1], iter2: Iterable[_T2], /) -> Self: ...
     @overload
-    def __init__(
-        self, __func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]
-    ) -> None: ...
+    def __new__(
+        cls, func: Callable[[_T1, _T2, _T3], _S], iterable: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /
+    ) -> Self: ...
     @overload
-    def __init__(
-        self,
-        __func: Callable[[_T1, _T2, _T3, _T4], _S],
-        __iter1: Iterable[_T1],
-        __iter2: Iterable[_T2],
-        __iter3: Iterable[_T3],
-        __iter4: Iterable[_T4],
-    ) -> None: ...
+    def __new__(
+        cls,
+        func: Callable[[_T1, _T2, _T3, _T4], _S],
+        iterable: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        /,
+    ) -> Self: ...
     @overload
-    def __init__(
-        self,
-        __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
-        __iter1: Iterable[_T1],
-        __iter2: Iterable[_T2],
-        __iter3: Iterable[_T3],
-        __iter4: Iterable[_T4],
-        __iter5: Iterable[_T5],
-    ) -> None: ...
+    def __new__(
+        cls,
+        func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
+        iterable: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        /,
+    ) -> Self: ...
     @overload
-    def __init__(
-        self,
-        __func: Callable[..., _S],
-        __iter1: Iterable[Any],
-        __iter2: Iterable[Any],
-        __iter3: Iterable[Any],
-        __iter4: Iterable[Any],
-        __iter5: Iterable[Any],
-        __iter6: Iterable[Any],
+    def __new__(
+        cls,
+        func: Callable[..., _S],
+        iterable: Iterable[Any],
+        iter2: Iterable[Any],
+        iter3: Iterable[Any],
+        iter4: Iterable[Any],
+        iter5: Iterable[Any],
+        iter6: Iterable[Any],
+        /,
         *iterables: Iterable[Any],
-    ) -> None: ...
+    ) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _S: ...
 
 @overload
 def max(
-    __arg1: SupportsRichComparisonT, __arg2: SupportsRichComparisonT, *_args: SupportsRichComparisonT, key: None = None
+    arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, key: None = None
 ) -> SupportsRichComparisonT: ...
 @overload
-def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
+def max(arg1: _T, arg2: _T, /, *_args: _T, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
 @overload
-def max(__iterable: Iterable[SupportsRichComparisonT], *, key: None = None) -> SupportsRichComparisonT: ...
+def max(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT: ...
 @overload
-def max(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
+def max(iterable: Iterable[_T], /, *, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
 @overload
-def max(__iterable: Iterable[SupportsRichComparisonT], *, key: None = None, default: _T) -> SupportsRichComparisonT | _T: ...
+def max(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T: ...
 @overload
-def max(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ...
+def max(iterable: Iterable[_T1], /, *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ...
 @overload
 def min(
-    __arg1: SupportsRichComparisonT, __arg2: SupportsRichComparisonT, *_args: SupportsRichComparisonT, key: None = None
+    arg1: SupportsRichComparisonT, arg2: SupportsRichComparisonT, /, *_args: SupportsRichComparisonT, key: None = None
 ) -> SupportsRichComparisonT: ...
 @overload
-def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
+def min(arg1: _T, arg2: _T, /, *_args: _T, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
 @overload
-def min(__iterable: Iterable[SupportsRichComparisonT], *, key: None = None) -> SupportsRichComparisonT: ...
+def min(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None) -> SupportsRichComparisonT: ...
 @overload
-def min(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
+def min(iterable: Iterable[_T], /, *, key: Callable[[_T], SupportsRichComparison]) -> _T: ...
 @overload
-def min(__iterable: Iterable[SupportsRichComparisonT], *, key: None = None, default: _T) -> SupportsRichComparisonT | _T: ...
+def min(iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, default: _T) -> SupportsRichComparisonT | _T: ...
 @overload
-def min(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ...
+def min(iterable: Iterable[_T1], /, *, key: Callable[[_T1], SupportsRichComparison], default: _T2) -> _T1 | _T2: ...
 @overload
-def next(__i: SupportsNext[_T]) -> _T: ...
+def next(i: SupportsNext[_T], /) -> _T: ...
 @overload
-def next(__i: SupportsNext[_T], __default: _VT) -> _T | _VT: ...
-def oct(__number: int | SupportsIndex) -> str: ...
+def next(i: SupportsNext[_T], default: _VT, /) -> _T | _VT: ...
+def oct(number: int | SupportsIndex, /) -> str: ...
 
 _Opener: TypeAlias = Callable[[str, int], int]
 
@@ -1492,10 +1576,9 @@ def open(
     closefd: bool = True,
     opener: _Opener | None = None,
 ) -> IO[Any]: ...
-def ord(__c: str | bytes | bytearray) -> int: ...
+def ord(c: str | bytes | bytearray, /) -> int: ...
 
-class _SupportsWriteAndFlush(SupportsWrite[_T_contra], Protocol[_T_contra]):
-    def flush(self) -> None: ...
+class _SupportsWriteAndFlush(SupportsWrite[_T_contra], SupportsFlush, Protocol[_T_contra]): ...
 
 @overload
 def print(
@@ -1510,105 +1593,74 @@ def print(
     *values: object, sep: str | None = " ", end: str | None = "\n", file: _SupportsWriteAndFlush[str] | None = None, flush: bool
 ) -> None: ...
 
-_E = TypeVar("_E", contravariant=True)
-_M = TypeVar("_M", contravariant=True)
+_E_contra = TypeVar("_E_contra", contravariant=True)
+_M_contra = TypeVar("_M_contra", contravariant=True)
 
-class _SupportsPow2(Protocol[_E, _T_co]):
-    def __pow__(self, __other: _E) -> _T_co: ...
+class _SupportsPow2(Protocol[_E_contra, _T_co]):
+    def __pow__(self, other: _E_contra, /) -> _T_co: ...
 
-class _SupportsPow3NoneOnly(Protocol[_E, _T_co]):
-    def __pow__(self, __other: _E, __modulo: None = None) -> _T_co: ...
+class _SupportsPow3NoneOnly(Protocol[_E_contra, _T_co]):
+    def __pow__(self, other: _E_contra, modulo: None = None, /) -> _T_co: ...
 
-class _SupportsPow3(Protocol[_E, _M, _T_co]):
-    def __pow__(self, __other: _E, __modulo: _M) -> _T_co: ...
+class _SupportsPow3(Protocol[_E_contra, _M_contra, _T_co]):
+    def __pow__(self, other: _E_contra, modulo: _M_contra, /) -> _T_co: ...
 
 _SupportsSomeKindOfPow = (  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
     _SupportsPow2[Any, Any] | _SupportsPow3NoneOnly[Any, Any] | _SupportsPow3[Any, Any, Any]
 )
 
-if sys.version_info >= (3, 8):
-    # TODO: `pow(int, int, Literal[0])` fails at runtime,
-    # but adding a `NoReturn` overload isn't a good solution for expressing that (see #8566).
-    @overload
-    def pow(base: int, exp: int, mod: int) -> int: ...
-    @overload
-    def pow(base: int, exp: Literal[0], mod: None = None) -> Literal[1]: ...
-    @overload
-    def pow(base: int, exp: _PositiveInteger, mod: None = None) -> int: ...
-    @overload
-    def pow(base: int, exp: _NegativeInteger, mod: None = None) -> float: ...
-    # int base & positive-int exp -> int; int base & negative-int exp -> float
-    # return type must be Any as `int | float` causes too many false-positive errors
-    @overload
-    def pow(base: int, exp: int, mod: None = None) -> Any: ...
-    @overload
-    def pow(base: _PositiveInteger, exp: float, mod: None = None) -> float: ...
-    @overload
-    def pow(base: _NegativeInteger, exp: float, mod: None = None) -> complex: ...
-    @overload
-    def pow(base: float, exp: int, mod: None = None) -> float: ...
-    # float base & float exp could return float or complex
-    # return type must be Any (same as complex base, complex exp),
-    # as `float | complex` causes too many false-positive errors
-    @overload
-    def pow(base: float, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> Any: ...
-    @overload
-    def pow(base: complex, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> complex: ...
-    @overload
-    def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
-    @overload
-    def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
-    @overload
-    def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ...
-    @overload
-    def pow(base: _SupportsSomeKindOfPow, exp: float, mod: None = None) -> Any: ...
-    @overload
-    def pow(base: _SupportsSomeKindOfPow, exp: complex, mod: None = None) -> complex: ...
+# TODO: `pow(int, int, Literal[0])` fails at runtime,
+# but adding a `NoReturn` overload isn't a good solution for expressing that (see #8566).
+@overload
+def pow(base: int, exp: int, mod: int) -> int: ...
+@overload
+def pow(base: int, exp: Literal[0], mod: None = None) -> Literal[1]: ...
+@overload
+def pow(base: int, exp: _PositiveInteger, mod: None = None) -> int: ...
+@overload
+def pow(base: int, exp: _NegativeInteger, mod: None = None) -> float: ...
 
-else:
-    @overload
-    def pow(__x: int, __y: int, __z: int) -> int: ...
-    @overload
-    def pow(__x: int, __y: Literal[0], __z: None = None) -> Literal[1]: ...
-    @overload
-    def pow(__x: int, __y: _PositiveInteger, __z: None = None) -> int: ...
-    @overload
-    def pow(__x: int, __y: _NegativeInteger, __z: None = None) -> float: ...
-    @overload
-    def pow(__x: int, __y: int, __z: None = None) -> Any: ...
-    @overload
-    def pow(__x: _PositiveInteger, __y: float, __z: None = None) -> float: ...
-    @overload
-    def pow(__x: _NegativeInteger, __y: float, __z: None = None) -> complex: ...
-    @overload
-    def pow(__x: float, __y: int, __z: None = None) -> float: ...
-    @overload
-    def pow(__x: float, __y: complex | _SupportsSomeKindOfPow, __z: None = None) -> Any: ...
-    @overload
-    def pow(__x: complex, __y: complex | _SupportsSomeKindOfPow, __z: None = None) -> complex: ...
-    @overload
-    def pow(__x: _SupportsPow2[_E, _T_co], __y: _E, __z: None = None) -> _T_co: ...
-    @overload
-    def pow(__x: _SupportsPow3NoneOnly[_E, _T_co], __y: _E, __z: None = None) -> _T_co: ...
-    @overload
-    def pow(__x: _SupportsPow3[_E, _M, _T_co], __y: _E, __z: _M) -> _T_co: ...
-    @overload
-    def pow(__x: _SupportsSomeKindOfPow, __y: float, __z: None = None) -> Any: ...
-    @overload
-    def pow(__x: _SupportsSomeKindOfPow, __y: complex, __z: None = None) -> complex: ...
+# int base & positive-int exp -> int; int base & negative-int exp -> float
+# return type must be Any as `int | float` causes too many false-positive errors
+@overload
+def pow(base: int, exp: int, mod: None = None) -> Any: ...
+@overload
+def pow(base: _PositiveInteger, exp: float, mod: None = None) -> float: ...
+@overload
+def pow(base: _NegativeInteger, exp: float, mod: None = None) -> complex: ...
+@overload
+def pow(base: float, exp: int, mod: None = None) -> float: ...
 
-def quit(code: sys._ExitCode = None) -> NoReturn: ...
+# float base & float exp could return float or complex
+# return type must be Any (same as complex base, complex exp),
+# as `float | complex` causes too many false-positive errors
+@overload
+def pow(base: float, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> Any: ...
+@overload
+def pow(base: complex, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> complex: ...
+@overload
+def pow(base: _SupportsPow2[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
+@overload
+def pow(base: _SupportsPow3NoneOnly[_E_contra, _T_co], exp: _E_contra, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
+@overload
+def pow(base: _SupportsPow3[_E_contra, _M_contra, _T_co], exp: _E_contra, mod: _M_contra) -> _T_co: ...
+@overload
+def pow(base: _SupportsSomeKindOfPow, exp: float, mod: None = None) -> Any: ...
+@overload
+def pow(base: _SupportsSomeKindOfPow, exp: complex, mod: None = None) -> complex: ...
+
+quit: _sitebuiltins.Quitter
 
-class reversed(Iterator[_T], Generic[_T]):
+class reversed(Iterator[_T]):
     @overload
-    def __init__(self, __sequence: Reversible[_T]) -> None: ...
+    def __new__(cls, sequence: Reversible[_T], /) -> Iterator[_T]: ...  # type: ignore[misc]
     @overload
-    def __init__(self, __sequence: SupportsLenAndGetItem[_T]) -> None: ...
+    def __new__(cls, sequence: SupportsLenAndGetItem[_T], /) -> Iterator[_T]: ...  # type: ignore[misc]
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
     def __length_hint__(self) -> int: ...
 
-def repr(__obj: object) -> str: ...
+def repr(obj: object, /) -> str: ...
 
 # See https://github.com/python/typeshed/pull/9141
 # and https://github.com/python/typeshed/pull/9151
@@ -1618,7 +1670,7 @@ class _SupportsRound1(Protocol[_T_co]):
     def __round__(self) -> _T_co: ...
 
 class _SupportsRound2(Protocol[_T_co]):
-    def __round__(self, __ndigits: int) -> _T_co: ...
+    def __round__(self, ndigits: int, /) -> _T_co: ...
 
 @overload
 def round(number: _SupportsRound1[_T], ndigits: None = None) -> _T: ...
@@ -1627,13 +1679,13 @@ def round(number: _SupportsRound2[_T], ndigits: SupportsIndex) -> _T: ...
 
 # See https://github.com/python/typeshed/pull/6292#discussion_r748875189
 # for why arg 3 of `setattr` should be annotated with `Any` and not `object`
-def setattr(__obj: object, __name: str, __value: Any) -> None: ...
+def setattr(obj: object, name: str, value: Any, /) -> None: ...
 @overload
 def sorted(
-    __iterable: Iterable[SupportsRichComparisonT], *, key: None = None, reverse: bool = False
+    iterable: Iterable[SupportsRichComparisonT], /, *, key: None = None, reverse: bool = False
 ) -> list[SupportsRichComparisonT]: ...
 @overload
-def sorted(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsRichComparison], reverse: bool = False) -> list[_T]: ...
+def sorted(iterable: Iterable[_T], /, *, key: Callable[[_T], SupportsRichComparison], reverse: bool = False) -> list[_T]: ...
 
 _AddableT1 = TypeVar("_AddableT1", bound=SupportsAdd[Any, Any])
 _AddableT2 = TypeVar("_AddableT2", bound=SupportsAdd[Any, Any])
@@ -1646,105 +1698,88 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
 # However, we can't express that in the stub for `sum()`
 # without creating many false-positive errors (see #7578).
 # 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]
-
-else:
-    @overload
-    def sum(__iterable: Iterable[bool], __start: int = 0) -> int: ...  # type: ignore[misc]
-
 @overload
-def sum(__iterable: Iterable[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ...
-
-if sys.version_info >= (3, 8):
-    @overload
-    def sum(__iterable: Iterable[_AddableT1], start: _AddableT2) -> _AddableT1 | _AddableT2: ...
-
-else:
-    @overload
-    def sum(__iterable: Iterable[_AddableT1], __start: _AddableT2) -> _AddableT1 | _AddableT2: ...
+def sum(iterable: Iterable[bool], /, start: int = 0) -> int: ...
+@overload
+def sum(iterable: Iterable[_SupportsSumNoDefaultT], /) -> _SupportsSumNoDefaultT | Literal[0]: ...
+@overload
+def sum(iterable: Iterable[_AddableT1], /, start: _AddableT2) -> _AddableT1 | _AddableT2: ...
 
 # The argument to `vars()` has to have a `__dict__` attribute, so the second overload can't be annotated with `object`
 # (A "SupportsDunderDict" protocol doesn't work)
-# Use a type: ignore to make complaints about overlapping overloads go away
 @overload
-def vars(__object: type) -> types.MappingProxyType[str, Any]: ...  # type: ignore[misc]
+def vars(object: type, /) -> types.MappingProxyType[str, Any]: ...
 @overload
-def vars(__object: Any = ...) -> dict[str, Any]: ...
+def vars(object: Any = ..., /) -> dict[str, Any]: ...
 
-class zip(Iterator[_T_co], Generic[_T_co]):
+class zip(Iterator[_T_co]):
     if sys.version_info >= (3, 10):
         @overload
-        def __new__(cls, __iter1: Iterable[_T1], *, strict: bool = ...) -> zip[tuple[_T1]]: ...
+        def __new__(cls, *, strict: bool = ...) -> zip[Any]: ...
+        @overload
+        def __new__(cls, iter1: Iterable[_T1], /, *, strict: bool = ...) -> zip[tuple[_T1]]: ...
         @overload
-        def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], *, strict: bool = ...) -> zip[tuple[_T1, _T2]]: ...
+        def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /, *, strict: bool = ...) -> zip[tuple[_T1, _T2]]: ...
         @overload
         def __new__(
-            cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], *, strict: bool = ...
+            cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /, *, strict: bool = ...
         ) -> zip[tuple[_T1, _T2, _T3]]: ...
         @overload
         def __new__(
-            cls,
-            __iter1: Iterable[_T1],
-            __iter2: Iterable[_T2],
-            __iter3: Iterable[_T3],
-            __iter4: Iterable[_T4],
-            *,
-            strict: bool = ...,
+            cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /, *, strict: bool = ...
         ) -> zip[tuple[_T1, _T2, _T3, _T4]]: ...
         @overload
         def __new__(
             cls,
-            __iter1: Iterable[_T1],
-            __iter2: Iterable[_T2],
-            __iter3: Iterable[_T3],
-            __iter4: Iterable[_T4],
-            __iter5: Iterable[_T5],
+            iter1: Iterable[_T1],
+            iter2: Iterable[_T2],
+            iter3: Iterable[_T3],
+            iter4: Iterable[_T4],
+            iter5: Iterable[_T5],
+            /,
             *,
             strict: bool = ...,
         ) -> zip[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
         @overload
         def __new__(
             cls,
-            __iter1: Iterable[Any],
-            __iter2: Iterable[Any],
-            __iter3: Iterable[Any],
-            __iter4: Iterable[Any],
-            __iter5: Iterable[Any],
-            __iter6: Iterable[Any],
+            iter1: Iterable[Any],
+            iter2: Iterable[Any],
+            iter3: Iterable[Any],
+            iter4: Iterable[Any],
+            iter5: Iterable[Any],
+            iter6: Iterable[Any],
+            /,
             *iterables: Iterable[Any],
             strict: bool = ...,
         ) -> zip[tuple[Any, ...]]: ...
     else:
         @overload
-        def __new__(cls, __iter1: Iterable[_T1]) -> zip[tuple[_T1]]: ...
+        def __new__(cls) -> zip[Any]: ...
+        @overload
+        def __new__(cls, iter1: Iterable[_T1], /) -> zip[tuple[_T1]]: ...
         @overload
-        def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> zip[tuple[_T1, _T2]]: ...
+        def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> zip[tuple[_T1, _T2]]: ...
         @overload
-        def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> zip[tuple[_T1, _T2, _T3]]: ...
+        def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /) -> zip[tuple[_T1, _T2, _T3]]: ...
         @overload
         def __new__(
-            cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4]
+            cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
         ) -> zip[tuple[_T1, _T2, _T3, _T4]]: ...
         @overload
         def __new__(
-            cls,
-            __iter1: Iterable[_T1],
-            __iter2: Iterable[_T2],
-            __iter3: Iterable[_T3],
-            __iter4: Iterable[_T4],
-            __iter5: Iterable[_T5],
+            cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
         ) -> zip[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
         @overload
         def __new__(
             cls,
-            __iter1: Iterable[Any],
-            __iter2: Iterable[Any],
-            __iter3: Iterable[Any],
-            __iter4: Iterable[Any],
-            __iter5: Iterable[Any],
-            __iter6: Iterable[Any],
+            iter1: Iterable[Any],
+            iter2: Iterable[Any],
+            iter3: Iterable[Any],
+            iter4: Iterable[Any],
+            iter5: Iterable[Any],
+            iter6: Iterable[Any],
+            /,
             *iterables: Iterable[Any],
         ) -> zip[tuple[Any, ...]]: ...
 
@@ -1760,15 +1795,25 @@ def __import__(
     fromlist: Sequence[str] = (),
     level: int = 0,
 ) -> types.ModuleType: ...
-def __build_class__(__func: Callable[[], _Cell | Any], __name: str, *bases: Any, metaclass: Any = ..., **kwds: Any) -> Any: ...
+def __build_class__(func: Callable[[], CellType | Any], name: str, /, *bases: Any, metaclass: Any = ..., **kwds: Any) -> Any: ...
 
-# Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
-# not exposed anywhere under that name, we make it private here.
-@final
-@type_check_only
-class ellipsis: ...
+if sys.version_info >= (3, 10):
+    from types import EllipsisType
+
+    # Backwards compatibility hack for folks who relied on the ellipsis type
+    # existing in typeshed in Python 3.9 and earlier.
+    ellipsis = EllipsisType
+
+    Ellipsis: EllipsisType
+
+else:
+    # Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
+    # not exposed anywhere under that name, we make it private here.
+    @final
+    @type_check_only
+    class ellipsis: ...
 
-Ellipsis: ellipsis
+    Ellipsis: ellipsis
 
 class BaseException:
     args: tuple[Any, ...]
@@ -1777,12 +1822,13 @@ class BaseException:
     __suppress_context__: bool
     __traceback__: TracebackType | None
     def __init__(self, *args: object) -> None: ...
-    def __setstate__(self, __state: dict[str, Any] | None) -> None: ...
-    def with_traceback(self, __tb: TracebackType | None) -> Self: ...
+    def __new__(cls, *args: Any, **kwds: Any) -> Self: ...
+    def __setstate__(self, state: dict[str, Any] | None, /) -> None: ...
+    def with_traceback(self, tb: TracebackType | None, /) -> Self: ...
     if sys.version_info >= (3, 11):
         # only present after add_note() is called
         __notes__: list[str]
-        def add_note(self, __note: str) -> None: ...
+        def add_note(self, note: str, /) -> None: ...
 
 class GeneratorExit(BaseException): ...
 class KeyboardInterrupt(BaseException): ...
@@ -1796,8 +1842,8 @@ class StopIteration(Exception):
     value: Any
 
 class OSError(Exception):
-    errno: int
-    strerror: str
+    errno: int | None
+    strerror: str | None
     # filename, filename2 are actually str | bytes | None
     filename: Any
     filename2: Any
@@ -1826,30 +1872,50 @@ 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): ...
 
 class NameError(Exception):
     if sys.version_info >= (3, 10):
+        def __init__(self, *args: object, name: str | None = ...) -> None: ...
         name: str
 
 class ReferenceError(Exception): ...
 class RuntimeError(Exception): ...
-
-class StopAsyncIteration(Exception):
-    value: Any
+class StopAsyncIteration(Exception): ...
 
 class SyntaxError(Exception):
     msg: str
+    filename: str | None
     lineno: int | None
     offset: int | None
     text: str | None
-    filename: str | None
+    # Errors are displayed differently if this attribute exists on the exception.
+    # The value is always None.
+    print_file_and_line: None
     if sys.version_info >= (3, 10):
         end_lineno: int | None
         end_offset: int | None
 
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, msg: object, /) -> None: ...
+    # Second argument is the tuple (filename, lineno, offset, text)
+    @overload
+    def __init__(self, msg: str, info: tuple[str | None, int | None, int | None, str | None], /) -> None: ...
+    if sys.version_info >= (3, 10):
+        # end_lineno and end_offset must both be provided if one is.
+        @overload
+        def __init__(
+            self, msg: str, info: tuple[str | None, int | None, int | None, str | None, int | None, int | None], /
+        ) -> None: ...
+    # If you provide more than two arguments, it still creates the SyntaxError, but
+    # the arguments from the info tuple are not parsed. This form is omitted.
+
 class SystemError(Exception): ...
 class TypeError(Exception): ...
 class ValueError(Exception): ...
@@ -1890,7 +1956,7 @@ class UnicodeDecodeError(UnicodeError):
     start: int
     end: int
     reason: str
-    def __init__(self, __encoding: str, __object: ReadableBuffer, __start: int, __end: int, __reason: str) -> None: ...
+    def __init__(self, encoding: str, object: ReadableBuffer, start: int, end: int, reason: str, /) -> None: ...
 
 class UnicodeEncodeError(UnicodeError):
     encoding: str
@@ -1898,7 +1964,7 @@ class UnicodeEncodeError(UnicodeError):
     start: int
     end: int
     reason: str
-    def __init__(self, __encoding: str, __object: str, __start: int, __end: int, __reason: str) -> None: ...
+    def __init__(self, encoding: str, object: str, start: int, end: int, reason: str, /) -> None: ...
 
 class UnicodeTranslateError(UnicodeError):
     encoding: None
@@ -1906,7 +1972,7 @@ class UnicodeTranslateError(UnicodeError):
     start: int
     end: int
     reason: str
-    def __init__(self, __object: str, __start: int, __end: int, __reason: str) -> None: ...
+    def __init__(self, object: str, start: int, end: int, reason: str, /) -> None: ...
 
 class Warning(Exception): ...
 class UserWarning(Warning): ...
@@ -1924,67 +1990,70 @@ if sys.version_info >= (3, 10):
     class EncodingWarning(Warning): ...
 
 if sys.version_info >= (3, 11):
-    _BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True)
+    _BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True, default=BaseException)
     _BaseExceptionT = TypeVar("_BaseExceptionT", bound=BaseException)
-    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True)
+    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True, default=Exception)
     _ExceptionT = TypeVar("_ExceptionT", bound=Exception)
 
     # See `check_exception_group.py` for use-cases and comments.
     class BaseExceptionGroup(BaseException, Generic[_BaseExceptionT_co]):
-        def __new__(cls, __message: str, __exceptions: Sequence[_BaseExceptionT_co]) -> Self: ...
-        def __init__(self, __message: str, __exceptions: Sequence[_BaseExceptionT_co]) -> None: ...
+        def __new__(cls, message: str, exceptions: Sequence[_BaseExceptionT_co], /) -> Self: ...
+        def __init__(self, message: str, exceptions: Sequence[_BaseExceptionT_co], /) -> None: ...
         @property
         def message(self) -> str: ...
         @property
         def exceptions(self) -> tuple[_BaseExceptionT_co | BaseExceptionGroup[_BaseExceptionT_co], ...]: ...
         @overload
         def subgroup(
-            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+            self, condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...], /
         ) -> ExceptionGroup[_ExceptionT] | None: ...
         @overload
         def subgroup(
-            self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
+            self, condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...], /
         ) -> BaseExceptionGroup[_BaseExceptionT] | None: ...
         @overload
         def subgroup(
-            self, __condition: Callable[[_BaseExceptionT_co | Self], bool]
+            self, condition: Callable[[_BaseExceptionT_co | Self], bool], /
         ) -> BaseExceptionGroup[_BaseExceptionT_co] | None: ...
         @overload
         def split(
-            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+            self, condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...], /
         ) -> tuple[ExceptionGroup[_ExceptionT] | None, BaseExceptionGroup[_BaseExceptionT_co] | None]: ...
         @overload
         def split(
-            self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
+            self, condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...], /
         ) -> tuple[BaseExceptionGroup[_BaseExceptionT] | None, BaseExceptionGroup[_BaseExceptionT_co] | None]: ...
         @overload
         def split(
-            self, __condition: Callable[[_BaseExceptionT_co | Self], bool]
+            self, condition: Callable[[_BaseExceptionT_co | Self], bool], /
         ) -> tuple[BaseExceptionGroup[_BaseExceptionT_co] | None, BaseExceptionGroup[_BaseExceptionT_co] | None]: ...
         # In reality it is `NonEmptySequence`:
         @overload
-        def derive(self, __excs: Sequence[_ExceptionT]) -> ExceptionGroup[_ExceptionT]: ...
+        def derive(self, excs: Sequence[_ExceptionT], /) -> ExceptionGroup[_ExceptionT]: ...
         @overload
-        def derive(self, __excs: Sequence[_BaseExceptionT]) -> BaseExceptionGroup[_BaseExceptionT]: ...
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def derive(self, excs: Sequence[_BaseExceptionT], /) -> BaseExceptionGroup[_BaseExceptionT]: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
     class ExceptionGroup(BaseExceptionGroup[_ExceptionT_co], Exception):
-        def __new__(cls, __message: str, __exceptions: Sequence[_ExceptionT_co]) -> Self: ...
-        def __init__(self, __message: str, __exceptions: Sequence[_ExceptionT_co]) -> None: ...
+        def __new__(cls, message: str, exceptions: Sequence[_ExceptionT_co], /) -> Self: ...
+        def __init__(self, message: str, exceptions: Sequence[_ExceptionT_co], /) -> None: ...
         @property
         def exceptions(self) -> tuple[_ExceptionT_co | ExceptionGroup[_ExceptionT_co], ...]: ...
         # We accept a narrower type, but that's OK.
         @overload  # type: ignore[override]
         def subgroup(
-            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+            self, condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...], /
         ) -> ExceptionGroup[_ExceptionT] | None: ...
         @overload
-        def subgroup(self, __condition: Callable[[_ExceptionT_co | Self], bool]) -> ExceptionGroup[_ExceptionT_co] | None: ...
+        def subgroup(self, condition: Callable[[_ExceptionT_co | Self], bool], /) -> ExceptionGroup[_ExceptionT_co] | None: ...
         @overload  # type: ignore[override]
         def split(
-            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
+            self, condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...], /
         ) -> tuple[ExceptionGroup[_ExceptionT] | None, ExceptionGroup[_ExceptionT_co] | None]: ...
         @overload
         def split(
-            self, __condition: Callable[[_ExceptionT_co | Self], bool]
+            self, condition: Callable[[_ExceptionT_co | Self], bool], /
         ) -> tuple[ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None]: ...
+
+if sys.version_info >= (3, 13):
+    class PythonFinalizationError(RuntimeError): ...
diff --git a/mypy/typeshed/stdlib/bz2.pyi b/mypy/typeshed/stdlib/bz2.pyi
index 9ad80ee6f731..2f869f9697f4 100644
--- a/mypy/typeshed/stdlib/bz2.pyi
+++ b/mypy/typeshed/stdlib/bz2.pyi
@@ -1,10 +1,11 @@
 import _compression
 import sys
+from _bz2 import BZ2Compressor as BZ2Compressor, BZ2Decompressor as BZ2Decompressor
 from _compression import BaseStream
 from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
 from collections.abc import Iterable
-from typing import IO, Any, Protocol, TextIO, overload
-from typing_extensions import Literal, Self, SupportsIndex, TypeAlias, final
+from typing import IO, Any, Literal, Protocol, SupportsIndex, TextIO, overload
+from typing_extensions import Self, TypeAlias
 
 __all__ = ["BZ2File", "BZ2Compressor", "BZ2Decompressor", "open", "compress", "decompress"]
 
@@ -14,7 +15,7 @@ __all__ = ["BZ2File", "BZ2Compressor", "BZ2Decompressor", "open", "compress", "d
 class _ReadableFileobj(_compression._Reader, Protocol): ...
 
 class _WritableFileobj(Protocol):
-    def write(self, __b: bytes) -> object: ...
+    def write(self, b: bytes, /) -> object: ...
     # The following attributes and methods are optional:
     # def fileno(self) -> int: ...
     # def close(self) -> object: ...
@@ -125,22 +126,7 @@ class BZ2File(BaseStream, IO[bytes]):
     def readline(self, size: SupportsIndex = -1) -> bytes: ...  # type: ignore[override]
     def readinto(self, b: WriteableBuffer) -> int: ...
     def readlines(self, size: SupportsIndex = -1) -> list[bytes]: ...
+    def peek(self, n: int = 0) -> bytes: ...
     def seek(self, offset: int, whence: int = 0) -> int: ...
     def write(self, data: ReadableBuffer) -> int: ...
     def writelines(self, seq: Iterable[ReadableBuffer]) -> None: ...
-
-@final
-class BZ2Compressor:
-    def __init__(self, compresslevel: int = ...) -> None: ...
-    def compress(self, __data: ReadableBuffer) -> bytes: ...
-    def flush(self) -> bytes: ...
-
-@final
-class BZ2Decompressor:
-    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
-    @property
-    def eof(self) -> bool: ...
-    @property
-    def needs_input(self) -> bool: ...
-    @property
-    def unused_data(self) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/cProfile.pyi b/mypy/typeshed/stdlib/cProfile.pyi
index 8945b21427ab..e921584d4390 100644
--- a/mypy/typeshed/stdlib/cProfile.pyi
+++ b/mypy/typeshed/stdlib/cProfile.pyi
@@ -1,6 +1,6 @@
-import sys
+import _lsprof
 from _typeshed import StrOrBytesPath, Unused
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from types import CodeType
 from typing import Any, TypeVar
 from typing_extensions import ParamSpec, Self, TypeAlias
@@ -9,29 +9,23 @@ __all__ = ["run", "runctx", "Profile"]
 
 def run(statement: str, filename: str | None = None, sort: str | int = -1) -> None: ...
 def runctx(
-    statement: str, globals: dict[str, Any], locals: dict[str, Any], filename: str | None = None, sort: str | int = -1
+    statement: str, globals: dict[str, Any], locals: Mapping[str, Any], filename: str | None = None, sort: str | int = -1
 ) -> None: ...
 
 _T = TypeVar("_T")
 _P = ParamSpec("_P")
 _Label: TypeAlias = tuple[str, int, str]
 
-class Profile:
+class Profile(_lsprof.Profiler):
     stats: dict[_Label, tuple[int, int, int, int, dict[_Label, tuple[int, int, int, int]]]]  # undocumented
-    def __init__(
-        self, timer: Callable[[], float] = ..., timeunit: float = ..., subcalls: bool = ..., builtins: bool = ...
-    ) -> None: ...
-    def enable(self) -> None: ...
-    def disable(self) -> None: ...
     def print_stats(self, sort: str | int = -1) -> None: ...
     def dump_stats(self, file: StrOrBytesPath) -> None: ...
     def create_stats(self) -> None: ...
     def snapshot_stats(self) -> None: ...
     def run(self, cmd: str) -> Self: ...
-    def runctx(self, cmd: str, globals: dict[str, Any], locals: dict[str, Any]) -> Self: ...
-    def runcall(self, __func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs) -> _T: ...
-    if sys.version_info >= (3, 8):
-        def __enter__(self) -> Self: ...
-        def __exit__(self, *exc_info: Unused) -> None: ...
+    def runctx(self, cmd: str, globals: dict[str, Any], locals: Mapping[str, Any]) -> Self: ...
+    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kw: _P.kwargs) -> _T: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *exc_info: Unused) -> None: ...
 
 def label(code: str | CodeType) -> _Label: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/calendar.pyi b/mypy/typeshed/stdlib/calendar.pyi
index 255a12d3348a..cabf3b881c30 100644
--- a/mypy/typeshed/stdlib/calendar.pyi
+++ b/mypy/typeshed/stdlib/calendar.pyi
@@ -1,10 +1,11 @@
 import datetime
+import enum
 import sys
 from _typeshed import Unused
 from collections.abc import Iterable, Sequence
 from time import struct_time
-from typing import ClassVar
-from typing_extensions import Literal, TypeAlias
+from typing import ClassVar, Final
+from typing_extensions import TypeAlias
 
 __all__ = [
     "IllegalMonthError",
@@ -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]
 
@@ -61,9 +79,9 @@ class Calendar:
     def monthdatescalendar(self, year: int, month: int) -> list[list[datetime.date]]: ...
     def monthdays2calendar(self, year: int, month: int) -> list[list[tuple[int, int]]]: ...
     def monthdayscalendar(self, year: int, month: int) -> list[list[int]]: ...
-    def yeardatescalendar(self, year: int, width: int = 3) -> list[list[int]]: ...
-    def yeardays2calendar(self, year: int, width: int = 3) -> list[list[tuple[int, int]]]: ...
-    def yeardayscalendar(self, year: int, width: int = 3) -> list[list[int]]: ...
+    def yeardatescalendar(self, year: int, width: int = 3) -> list[list[list[list[datetime.date]]]]: ...
+    def yeardays2calendar(self, year: int, width: int = 3) -> list[list[list[list[tuple[int, int]]]]]: ...
+    def yeardayscalendar(self, year: int, width: int = 3) -> list[list[list[list[int]]]]: ...
     def itermonthdays3(self, year: int, month: int) -> Iterable[tuple[int, int, int]]: ...
     def itermonthdays4(self, year: int, month: int) -> Iterable[tuple[int, int, int, int]]: ...
 
@@ -106,7 +124,7 @@ class HTMLCalendar(Calendar):
     def formatyear(self, theyear: int, width: int = 3) -> str: ...
     def formatyearpage(
         self, theyear: int, width: int = 3, css: str | None = "calendar.css", encoding: str | None = None
-    ) -> str: ...
+    ) -> bytes: ...
 
 class different_locale:
     def __init__(self, locale: _LocaleType) -> None: ...
@@ -134,12 +152,57 @@ 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]
-
-EPOCH: Literal[1970]
+if sys.version_info >= (3, 12):
+    class Month(enum.IntEnum):
+        JANUARY = 1
+        FEBRUARY = 2
+        MARCH = 3
+        APRIL = 4
+        MAY = 5
+        JUNE = 6
+        JULY = 7
+        AUGUST = 8
+        SEPTEMBER = 9
+        OCTOBER = 10
+        NOVEMBER = 11
+        DECEMBER = 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 = 0
+        TUESDAY = 1
+        WEDNESDAY = 2
+        THURSDAY = 3
+        FRIDAY = 4
+        SATURDAY = 5
+        SUNDAY = 6
+
+    MONDAY = Day.MONDAY
+    TUESDAY = Day.TUESDAY
+    WEDNESDAY = Day.WEDNESDAY
+    THURSDAY = Day.THURSDAY
+    FRIDAY = Day.FRIDAY
+    SATURDAY = Day.SATURDAY
+    SUNDAY = Day.SUNDAY
+else:
+    MONDAY: Final = 0
+    TUESDAY: Final = 1
+    WEDNESDAY: Final = 2
+    THURSDAY: Final = 3
+    FRIDAY: Final = 4
+    SATURDAY: Final = 5
+    SUNDAY: Final = 6
+
+EPOCH: Final = 1970
diff --git a/mypy/typeshed/stdlib/cgi.pyi b/mypy/typeshed/stdlib/cgi.pyi
index a2acfa92d463..3a2e2a91b241 100644
--- a/mypy/typeshed/stdlib/cgi.pyi
+++ b/mypy/typeshed/stdlib/cgi.pyi
@@ -1,5 +1,4 @@
-import sys
-from _typeshed import SupportsGetItem, SupportsItemAccess, Unused
+from _typeshed import SupportsContainsAndGetItem, SupportsGetItem, SupportsItemAccess, Unused
 from builtins import list as _list, type as _type
 from collections.abc import Iterable, Iterator, Mapping
 from email.message import Message
@@ -22,9 +21,6 @@ __all__ = [
     "print_environ_usage",
 ]
 
-if sys.version_info < (3, 8):
-    __all__ += ["parse_qs", "parse_qsl", "escape"]
-
 def parse(
     fp: IO[Any] | None = None,
     environ: SupportsItemAccess[str, str] = ...,
@@ -32,17 +28,12 @@ def parse(
     strict_parsing: bool = ...,
     separator: str = "&",
 ) -> dict[str, list[str]]: ...
-
-if sys.version_info < (3, 8):
-    def parse_qs(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> dict[str, list[str]]: ...
-    def parse_qsl(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> list[tuple[str, str]]: ...
-
 def parse_multipart(
     fp: IO[Any], pdict: SupportsGetItem[str, bytes], encoding: str = "utf-8", errors: str = "replace", separator: str = "&"
 ) -> dict[str, list[Any]]: ...
 
 class _Environ(Protocol):
-    def __getitem__(self, __k: str) -> str: ...
+    def __getitem__(self, k: str, /) -> str: ...
     def keys(self) -> Iterable[str]: ...
 
 def parse_header(line: str) -> tuple[str, dict[str, str]]: ...
@@ -52,9 +43,6 @@ def print_form(form: dict[str, Any]) -> None: ...
 def print_directory() -> None: ...
 def print_environ_usage() -> None: ...
 
-if sys.version_info < (3, 8):
-    def escape(s: str, quote: bool | None = None) -> str: ...
-
 class MiniFieldStorage:
     # The first five "Any" attributes here are always None, but mypy doesn't support that
     filename: Any
@@ -97,7 +85,7 @@ class FieldStorage:
         fp: IO[Any] | None = None,
         headers: Mapping[str, str] | Message | None = None,
         outerboundary: bytes = b"",
-        environ: SupportsGetItem[str, str] = ...,
+        environ: SupportsContainsAndGetItem[str, str] = ...,
         keep_blank_values: int = 0,
         strict_parsing: int = 0,
         limit: int | None = None,
@@ -117,7 +105,8 @@ class FieldStorage:
     def __contains__(self, key: str) -> bool: ...
     def __len__(self) -> int: ...
     def __bool__(self) -> bool: ...
-    # In Python 3 it returns bytes or str IO depending on an internal flag
+    def __del__(self) -> None: ...
+    # Returns bytes or str IO depending on an internal flag
     def make_file(self) -> IO[Any]: ...
 
 def print_exception(
diff --git a/mypy/typeshed/stdlib/cgitb.pyi b/mypy/typeshed/stdlib/cgitb.pyi
index 4c315bf6ca39..565725801159 100644
--- a/mypy/typeshed/stdlib/cgitb.pyi
+++ b/mypy/typeshed/stdlib/cgitb.pyi
@@ -1,8 +1,7 @@
 from _typeshed import OptExcInfo, StrOrBytesPath
 from collections.abc import Callable
 from types import FrameType, TracebackType
-from typing import IO, Any
-from typing_extensions import Final
+from typing import IO, Any, Final
 
 __UNDEF__: Final[object]  # undocumented sentinel
 
diff --git a/mypy/typeshed/stdlib/cmath.pyi b/mypy/typeshed/stdlib/cmath.pyi
index 0a85600e99b7..a08addcf5438 100644
--- a/mypy/typeshed/stdlib/cmath.pyi
+++ b/mypy/typeshed/stdlib/cmath.pyi
@@ -1,43 +1,36 @@
-import sys
-from typing import SupportsComplex, SupportsFloat
+from typing import Final, SupportsComplex, SupportsFloat, SupportsIndex
 from typing_extensions import TypeAlias
 
-if sys.version_info >= (3, 8):
-    from typing import SupportsIndex
+e: Final[float]
+pi: Final[float]
+inf: Final[float]
+infj: Final[complex]
+nan: Final[float]
+nanj: Final[complex]
+tau: Final[float]
 
-e: float
-pi: float
-inf: float
-infj: complex
-nan: float
-nanj: complex
-tau: float
+_C: TypeAlias = SupportsFloat | SupportsComplex | SupportsIndex | complex
 
-if sys.version_info >= (3, 8):
-    _C: TypeAlias = SupportsFloat | SupportsComplex | SupportsIndex | complex
-else:
-    _C: TypeAlias = SupportsFloat | SupportsComplex | complex
-
-def acos(__z: _C) -> complex: ...
-def acosh(__z: _C) -> complex: ...
-def asin(__z: _C) -> complex: ...
-def asinh(__z: _C) -> complex: ...
-def atan(__z: _C) -> complex: ...
-def atanh(__z: _C) -> complex: ...
-def cos(__z: _C) -> complex: ...
-def cosh(__z: _C) -> complex: ...
-def exp(__z: _C) -> complex: ...
+def acos(z: _C, /) -> complex: ...
+def acosh(z: _C, /) -> complex: ...
+def asin(z: _C, /) -> complex: ...
+def asinh(z: _C, /) -> complex: ...
+def atan(z: _C, /) -> complex: ...
+def atanh(z: _C, /) -> complex: ...
+def cos(z: _C, /) -> complex: ...
+def cosh(z: _C, /) -> complex: ...
+def exp(z: _C, /) -> complex: ...
 def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = 1e-09, abs_tol: SupportsFloat = 0.0) -> bool: ...
-def isinf(__z: _C) -> bool: ...
-def isnan(__z: _C) -> bool: ...
-def log(__x: _C, __y_obj: _C = ...) -> complex: ...
-def log10(__z: _C) -> complex: ...
-def phase(__z: _C) -> float: ...
-def polar(__z: _C) -> tuple[float, float]: ...
-def rect(__r: float, __phi: float) -> complex: ...
-def sin(__z: _C) -> complex: ...
-def sinh(__z: _C) -> complex: ...
-def sqrt(__z: _C) -> complex: ...
-def tan(__z: _C) -> complex: ...
-def tanh(__z: _C) -> complex: ...
-def isfinite(__z: _C) -> bool: ...
+def isinf(z: _C, /) -> bool: ...
+def isnan(z: _C, /) -> bool: ...
+def log(x: _C, base: _C = ..., /) -> complex: ...
+def log10(z: _C, /) -> complex: ...
+def phase(z: _C, /) -> float: ...
+def polar(z: _C, /) -> tuple[float, float]: ...
+def rect(r: float, phi: float, /) -> complex: ...
+def sin(z: _C, /) -> complex: ...
+def sinh(z: _C, /) -> complex: ...
+def sqrt(z: _C, /) -> complex: ...
+def tan(z: _C, /) -> complex: ...
+def tanh(z: _C, /) -> complex: ...
+def isfinite(z: _C, /) -> bool: ...
diff --git a/mypy/typeshed/stdlib/cmd.pyi b/mypy/typeshed/stdlib/cmd.pyi
index b658a873410b..6e84133572bf 100644
--- a/mypy/typeshed/stdlib/cmd.pyi
+++ b/mypy/typeshed/stdlib/cmd.pyi
@@ -1,11 +1,11 @@
 from collections.abc import Callable
-from typing import IO, Any
-from typing_extensions import Literal
+from typing import IO, Any, Final
+from typing_extensions import LiteralString
 
 __all__ = ["Cmd"]
 
-PROMPT: Literal["(Cmd) "]
-IDENTCHARS: str  # Too big to be `Literal`
+PROMPT: Final = "(Cmd) "
+IDENTCHARS: Final[LiteralString]  # Too big to be `Literal`
 
 class Cmd:
     prompt: str
diff --git a/mypy/typeshed/stdlib/code.pyi b/mypy/typeshed/stdlib/code.pyi
index 4715bd866ddc..54971f3ae93c 100644
--- a/mypy/typeshed/stdlib/code.pyi
+++ b/mypy/typeshed/stdlib/code.pyi
@@ -1,3 +1,4 @@
+import sys
 from codeop import CommandCompiler
 from collections.abc import Callable, Mapping
 from types import CodeType
@@ -11,23 +12,45 @@ class InteractiveInterpreter:
     def __init__(self, locals: Mapping[str, Any] | None = None) -> None: ...
     def runsource(self, source: str, filename: str = "<input>", symbol: str = "single") -> bool: ...
     def runcode(self, code: CodeType) -> None: ...
-    def showsyntaxerror(self, filename: str | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def showsyntaxerror(self, filename: str | None = None, *, source: str = "") -> None: ...
+    else:
+        def showsyntaxerror(self, filename: str | None = None) -> None: ...
+
     def showtraceback(self) -> None: ...
     def write(self, data: str) -> None: ...
 
 class InteractiveConsole(InteractiveInterpreter):
     buffer: list[str]  # undocumented
     filename: str  # undocumented
-    def __init__(self, locals: Mapping[str, Any] | None = None, filename: str = "<console>") -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, locals: Mapping[str, Any] | None = None, filename: str = "<console>", *, local_exit: bool = False
+        ) -> None: ...
+        def push(self, line: str, filename: str | None = None) -> bool: ...
+    else:
+        def __init__(self, locals: Mapping[str, Any] | None = None, filename: str = "<console>") -> None: ...
+        def push(self, line: str) -> bool: ...
+
     def interact(self, banner: str | None = None, exitmsg: str | None = None) -> None: ...
-    def push(self, line: str) -> bool: ...
     def resetbuffer(self) -> None: ...
     def raw_input(self, prompt: str = "") -> str: ...
 
-def interact(
-    banner: str | None = None,
-    readfunc: Callable[[str], str] | None = None,
-    local: Mapping[str, Any] | None = None,
-    exitmsg: str | None = None,
-) -> None: ...
+if sys.version_info >= (3, 13):
+    def interact(
+        banner: str | None = None,
+        readfunc: Callable[[str], str] | None = None,
+        local: Mapping[str, Any] | None = None,
+        exitmsg: str | None = None,
+        local_exit: bool = False,
+    ) -> None: ...
+
+else:
+    def interact(
+        banner: str | None = None,
+        readfunc: Callable[[str], str] | None = None,
+        local: Mapping[str, Any] | None = None,
+        exitmsg: str | None = None,
+    ) -> None: ...
+
 def compile_command(source: str, filename: str = "<input>", symbol: str = "single") -> CodeType | None: ...
diff --git a/mypy/typeshed/stdlib/codecs.pyi b/mypy/typeshed/stdlib/codecs.pyi
index 3f6d2d3d16b7..579d09c66a1b 100644
--- a/mypy/typeshed/stdlib/codecs.pyi
+++ b/mypy/typeshed/stdlib/codecs.pyi
@@ -1,11 +1,10 @@
-import sys
 import types
 from _codecs import *
 from _typeshed import ReadableBuffer
 from abc import abstractmethod
 from collections.abc import Callable, Generator, Iterable
-from typing import Any, BinaryIO, Protocol, TextIO
-from typing_extensions import Literal, Self
+from typing import Any, BinaryIO, ClassVar, Final, Literal, Protocol, TextIO, overload
+from typing_extensions import Self, TypeAlias
 
 __all__ = [
     "register",
@@ -54,19 +53,34 @@ __all__ = [
     "lookup_error",
 ]
 
-BOM32_BE: Literal[b"\xfe\xff"]
-BOM32_LE: Literal[b"\xff\xfe"]
-BOM64_BE: Literal[b"\x00\x00\xfe\xff"]
-BOM64_LE: Literal[b"\xff\xfe\x00\x00"]
+BOM32_BE: Final = b"\xfe\xff"
+BOM32_LE: Final = b"\xff\xfe"
+BOM64_BE: Final = b"\x00\x00\xfe\xff"
+BOM64_LE: Final = b"\xff\xfe\x00\x00"
+
+_BufferedEncoding: TypeAlias = Literal[
+    "idna",
+    "raw-unicode-escape",
+    "unicode-escape",
+    "utf-16",
+    "utf-16-be",
+    "utf-16-le",
+    "utf-32",
+    "utf-32-be",
+    "utf-32-le",
+    "utf-7",
+    "utf-8",
+    "utf-8-sig",
+]
 
 class _WritableStream(Protocol):
-    def write(self, __data: bytes) -> object: ...
-    def seek(self, __offset: int, __whence: int) -> object: ...
+    def write(self, data: bytes, /) -> object: ...
+    def seek(self, offset: int, whence: int, /) -> object: ...
     def close(self) -> object: ...
 
 class _ReadableStream(Protocol):
-    def read(self, __size: int = ...) -> bytes: ...
-    def seek(self, __offset: int, __whence: int) -> object: ...
+    def read(self, size: int = ..., /) -> bytes: ...
+    def seek(self, offset: int, whence: int, /) -> object: ...
     def close(self) -> object: ...
 
 class _Stream(_WritableStream, _ReadableStream, Protocol): ...
@@ -78,16 +92,16 @@ class _Stream(_WritableStream, _ReadableStream, Protocol): ...
 # They were much more common in Python 2 than in Python 3.
 
 class _Encoder(Protocol):
-    def __call__(self, input: str, errors: str = ...) -> tuple[bytes, int]: ...  # signature of Codec().encode
+    def __call__(self, input: str, errors: str = ..., /) -> tuple[bytes, int]: ...  # signature of Codec().encode
 
 class _Decoder(Protocol):
-    def __call__(self, input: bytes, errors: str = ...) -> tuple[str, int]: ...  # signature of Codec().decode
+    def __call__(self, input: ReadableBuffer, errors: str = ..., /) -> tuple[str, int]: ...  # signature of Codec().decode
 
 class _StreamReader(Protocol):
-    def __call__(self, stream: _ReadableStream, errors: str = ...) -> StreamReader: ...
+    def __call__(self, stream: _ReadableStream, errors: str = ..., /) -> StreamReader: ...
 
 class _StreamWriter(Protocol):
-    def __call__(self, stream: _WritableStream, errors: str = ...) -> StreamWriter: ...
+    def __call__(self, stream: _WritableStream, errors: str = ..., /) -> StreamWriter: ...
 
 class _IncrementalEncoder(Protocol):
     def __call__(self, errors: str = ...) -> IncrementalEncoder: ...
@@ -95,7 +109,11 @@ class _IncrementalEncoder(Protocol):
 class _IncrementalDecoder(Protocol):
     def __call__(self, errors: str = ...) -> IncrementalDecoder: ...
 
+class _BufferedIncrementalDecoder(Protocol):
+    def __call__(self, errors: str = ...) -> BufferedIncrementalDecoder: ...
+
 class CodecInfo(tuple[_Encoder, _Decoder, _StreamReader, _StreamWriter]):
+    _is_text_encoding: bool
     @property
     def encode(self) -> _Encoder: ...
     @property
@@ -125,41 +143,36 @@ class CodecInfo(tuple[_Encoder, _Decoder, _StreamReader, _StreamWriter]):
 def getencoder(encoding: str) -> _Encoder: ...
 def getdecoder(encoding: str) -> _Decoder: ...
 def getincrementalencoder(encoding: str) -> _IncrementalEncoder: ...
+@overload
+def getincrementaldecoder(encoding: _BufferedEncoding) -> _BufferedIncrementalDecoder: ...
+@overload
 def getincrementaldecoder(encoding: str) -> _IncrementalDecoder: ...
 def getreader(encoding: str) -> _StreamReader: ...
 def getwriter(encoding: str) -> _StreamWriter: ...
-
-if sys.version_info >= (3, 8):
-    def open(
-        filename: str, mode: str = "r", encoding: str | None = None, errors: str = "strict", buffering: int = -1
-    ) -> StreamReaderWriter: ...
-
-else:
-    def open(
-        filename: str, mode: str = "r", encoding: str | None = None, errors: str = "strict", buffering: int = 1
-    ) -> StreamReaderWriter: ...
-
+def open(
+    filename: str, mode: str = "r", encoding: str | None = None, errors: str = "strict", buffering: int = -1
+) -> StreamReaderWriter: ...
 def EncodedFile(file: _Stream, data_encoding: str, file_encoding: str | None = None, errors: str = "strict") -> StreamRecoder: ...
 def iterencode(iterator: Iterable[str], encoding: str, errors: str = "strict") -> Generator[bytes, None, None]: ...
 def iterdecode(iterator: Iterable[bytes], encoding: str, errors: str = "strict") -> Generator[str, None, None]: ...
 
-BOM: Literal[b"\xff\xfe", b"\xfe\xff"]  # depends on `sys.byteorder`
-BOM_BE: Literal[b"\xfe\xff"]
-BOM_LE: Literal[b"\xff\xfe"]
-BOM_UTF8: Literal[b"\xef\xbb\xbf"]
-BOM_UTF16: Literal[b"\xff\xfe", b"\xfe\xff"]  # depends on `sys.byteorder`
-BOM_UTF16_BE: Literal[b"\xfe\xff"]
-BOM_UTF16_LE: Literal[b"\xff\xfe"]
-BOM_UTF32: Literal[b"\xff\xfe\x00\x00", b"\x00\x00\xfe\xff"]  # depends on `sys.byteorder`
-BOM_UTF32_BE: Literal[b"\x00\x00\xfe\xff"]
-BOM_UTF32_LE: Literal[b"\xff\xfe\x00\x00"]
+BOM: Final[Literal[b"\xff\xfe", b"\xfe\xff"]]  # depends on `sys.byteorder`
+BOM_BE: Final = b"\xfe\xff"
+BOM_LE: Final = b"\xff\xfe"
+BOM_UTF8: Final = b"\xef\xbb\xbf"
+BOM_UTF16: Final[Literal[b"\xff\xfe", b"\xfe\xff"]]  # depends on `sys.byteorder`
+BOM_UTF16_BE: Final = b"\xfe\xff"
+BOM_UTF16_LE: Final = b"\xff\xfe"
+BOM_UTF32: Final[Literal[b"\xff\xfe\x00\x00", b"\x00\x00\xfe\xff"]]  # depends on `sys.byteorder`
+BOM_UTF32_BE: Final = b"\x00\x00\xfe\xff"
+BOM_UTF32_LE: Final = b"\xff\xfe\x00\x00"
 
-def strict_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def replace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def ignore_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def xmlcharrefreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def backslashreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def namereplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+def strict_errors(exception: UnicodeError, /) -> tuple[str | bytes, int]: ...
+def replace_errors(exception: UnicodeError, /) -> tuple[str | bytes, int]: ...
+def ignore_errors(exception: UnicodeError, /) -> tuple[str | bytes, int]: ...
+def xmlcharrefreplace_errors(exception: UnicodeError, /) -> tuple[str | bytes, int]: ...
+def backslashreplace_errors(exception: UnicodeError, /) -> tuple[str | bytes, int]: ...
+def namereplace_errors(exception: UnicodeError, /) -> tuple[str | bytes, int]: ...
 
 class Codec:
     # These are sort of @abstractmethod but sort of not.
@@ -210,23 +223,27 @@ class StreamWriter(Codec):
     def write(self, object: str) -> None: ...
     def writelines(self, list: Iterable[str]) -> None: ...
     def reset(self) -> None: ...
+    def seek(self, offset: int, whence: int = 0) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, type: type[BaseException] | None, value: BaseException | None, tb: types.TracebackType | None) -> None: ...
-    def __getattr__(self, name: str, getattr: Callable[[str], Any] = ...) -> Any: ...
+    def __getattr__(self, name: str, getattr: Callable[[Any, str], Any] = ...) -> Any: ...
 
 class StreamReader(Codec):
     stream: _ReadableStream
     errors: str
+    # This is set to str, but some subclasses set to bytes instead.
+    charbuffertype: ClassVar[type] = ...
     def __init__(self, stream: _ReadableStream, errors: str = "strict") -> None: ...
     def read(self, size: int = -1, chars: int = -1, firstline: bool = False) -> str: ...
     def readline(self, size: int | None = None, keepends: bool = True) -> str: ...
     def readlines(self, sizehint: int | None = None, keepends: bool = True) -> list[str]: ...
     def reset(self) -> None: ...
+    def seek(self, offset: int, whence: int = 0) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, type: type[BaseException] | None, value: BaseException | None, tb: types.TracebackType | None) -> None: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> str: ...
-    def __getattr__(self, name: str, getattr: Callable[[str], Any] = ...) -> Any: ...
+    def __getattr__(self, name: str, getattr: Callable[[Any, str], Any] = ...) -> Any: ...
 
 # Doesn't actually inherit from TextIO, but wraps a BinaryIO to provide text reading and writing
 # and delegates attributes to the underlying binary stream with __getattr__.
@@ -258,6 +275,8 @@ class StreamReaderWriter(TextIO):
     def writable(self) -> bool: ...
 
 class StreamRecoder(BinaryIO):
+    data_encoding: str
+    file_encoding: str
     def __init__(
         self,
         stream: _Stream,
diff --git a/mypy/typeshed/stdlib/codeop.pyi b/mypy/typeshed/stdlib/codeop.pyi
index 6a51b7786384..cfe52e9b35de 100644
--- a/mypy/typeshed/stdlib/codeop.pyi
+++ b/mypy/typeshed/stdlib/codeop.pyi
@@ -1,3 +1,4 @@
+import sys
 from types import CodeType
 
 __all__ = ["compile_command", "Compile", "CommandCompiler"]
@@ -6,7 +7,10 @@ def compile_command(source: str, filename: str = "<input>", symbol: str = "singl
 
 class Compile:
     flags: int
-    def __call__(self, source: str, filename: str, symbol: str) -> CodeType: ...
+    if sys.version_info >= (3, 13):
+        def __call__(self, source: str, filename: str, symbol: str, flags: int = 0) -> CodeType: ...
+    else:
+        def __call__(self, source: str, filename: str, symbol: str) -> CodeType: ...
 
 class CommandCompiler:
     compiler: Compile
diff --git a/mypy/typeshed/stdlib/collections/__init__.pyi b/mypy/typeshed/stdlib/collections/__init__.pyi
index d5ca17c749eb..0f99b5c3c67e 100644
--- a/mypy/typeshed/stdlib/collections/__init__.pyi
+++ b/mypy/typeshed/stdlib/collections/__init__.pyi
@@ -1,8 +1,8 @@
 import sys
 from _collections_abc import dict_items, dict_keys, dict_values
-from _typeshed import SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
-from typing import Any, Generic, NoReturn, TypeVar, overload
-from typing_extensions import Self, SupportsIndex, final
+from _typeshed import SupportsItems, SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
+from typing import Any, ClassVar, Generic, NoReturn, SupportsIndex, TypeVar, final, overload
+from typing_extensions import Self
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -17,7 +17,6 @@ if sys.version_info >= (3, 10):
         Mapping,
         MutableMapping,
         MutableSequence,
-        Reversible,
         Sequence,
         ValuesView,
     )
@@ -45,25 +44,37 @@ def namedtuple(
     defaults: Iterable[Any] | None = None,
 ) -> type[tuple[Any, ...]]: ...
 
-class UserDict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
+class UserDict(MutableMapping[_KT, _VT]):
     data: dict[_KT, _VT]
     # __init__ should be kept roughly in line with `dict.__init__`, which has the same semantics
     @overload
-    def __init__(self, __dict: None = None) -> None: ...
+    def __init__(self, dict: None = None, /) -> None: ...
     @overload
-    def __init__(self: UserDict[str, _VT], __dict: None = None, **kwargs: _VT) -> None: ...
+    def __init__(
+        self: UserDict[str, _VT], dict: None = None, /, **kwargs: _VT  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+    ) -> None: ...
     @overload
-    def __init__(self, __dict: SupportsKeysAndGetItem[_KT, _VT]) -> None: ...
+    def __init__(self, dict: SupportsKeysAndGetItem[_KT, _VT], /) -> None: ...
     @overload
-    def __init__(self: UserDict[str, _VT], __dict: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT) -> None: ...
+    def __init__(
+        self: UserDict[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        dict: SupportsKeysAndGetItem[str, _VT],
+        /,
+        **kwargs: _VT,
+    ) -> None: ...
     @overload
-    def __init__(self, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ...
+    def __init__(self, iterable: Iterable[tuple[_KT, _VT]], /) -> None: ...
     @overload
-    def __init__(self: UserDict[str, _VT], __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT) -> None: ...
+    def __init__(
+        self: UserDict[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        iterable: Iterable[tuple[str, _VT]],
+        /,
+        **kwargs: _VT,
+    ) -> None: ...
     @overload
-    def __init__(self: UserDict[str, str], __iterable: Iterable[list[str]]) -> None: ...
+    def __init__(self: UserDict[str, str], iterable: Iterable[list[str]], /) -> None: ...
     @overload
-    def __init__(self: UserDict[bytes, bytes], __iterable: Iterable[list[bytes]]) -> None: ...
+    def __init__(self: UserDict[bytes, bytes], iterable: Iterable[list[bytes]], /) -> None: ...
     def __len__(self) -> int: ...
     def __getitem__(self, key: _KT) -> _VT: ...
     def __setitem__(self, key: _KT, item: _VT) -> None: ...
@@ -83,13 +94,24 @@ class UserDict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
     @overload
     def fromkeys(cls, iterable: Iterable[_T], value: _S) -> UserDict[_T, _S]: ...
     if sys.version_info >= (3, 9):
+        @overload
+        def __or__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
+        @overload
         def __or__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
-        def __ror__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...  # type: ignore[misc]
+        @overload
+        def __ror__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
+        @overload
+        def __ror__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
         # UserDict.__ior__ should be kept roughly in line with MutableMapping.update()
         @overload  # type: ignore[misc]
         def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
         @overload
         def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...
+    if sys.version_info >= (3, 12):
+        @overload
+        def get(self, key: _KT, default: None = None) -> _VT | None: ...
+        @overload
+        def get(self, key: _KT, default: _T) -> _VT | _T: ...
 
 class UserList(MutableSequence[_T]):
     data: list[_T]
@@ -97,6 +119,7 @@ class UserList(MutableSequence[_T]):
     def __init__(self, initlist: None = None) -> None: ...
     @overload
     def __init__(self, initlist: Iterable[_T]) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __lt__(self, other: list[_T] | UserList[_T]) -> bool: ...
     def __le__(self, other: list[_T] | UserList[_T]) -> bool: ...
     def __gt__(self, other: list[_T] | UserList[_T]) -> bool: ...
@@ -126,8 +149,10 @@ class UserList(MutableSequence[_T]):
     def copy(self) -> Self: ...
     def __copy__(self) -> Self: ...
     def count(self, item: _T) -> int: ...
-    # All arguments are passed to `list.index` at runtime, so the signature should be kept in line with `list.index`.
-    def index(self, item: _T, __start: SupportsIndex = 0, __stop: SupportsIndex = sys.maxsize) -> int: ...
+    # The runtime signature is "item, *args", and the arguments are then passed
+    # to `list.index`. In order to give more precise types, we pretend that the
+    # `item` argument is positional-only.
+    def index(self, item: _T, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int: ...
     # All arguments are passed to `list.sort` at runtime, so the signature should be kept in line with `list.sort`.
     @overload
     def sort(self: UserList[SupportsRichComparisonT], *, key: None = None, reverse: bool = False) -> None: ...
@@ -147,6 +172,7 @@ class UserString(Sequence[UserString]):
     def __gt__(self, string: str | UserString) -> bool: ...
     def __ge__(self, string: str | UserString) -> bool: ...
     def __eq__(self, string: object) -> bool: ...
+    def __hash__(self) -> int: ...
     def __contains__(self, char: object) -> bool: ...
     def __len__(self) -> int: ...
     def __getitem__(self, index: SupportsIndex | slice) -> Self: ...
@@ -157,20 +183,12 @@ class UserString(Sequence[UserString]):
     def __mul__(self, n: int) -> Self: ...
     def __rmul__(self, n: int) -> Self: ...
     def __mod__(self, args: Any) -> Self: ...
-    if sys.version_info >= (3, 8):
-        def __rmod__(self, template: object) -> Self: ...
-    else:
-        def __rmod__(self, format: Any) -> Self: ...
-
+    def __rmod__(self, template: object) -> Self: ...
     def capitalize(self) -> Self: ...
     def casefold(self) -> Self: ...
     def center(self, width: int, *args: Any) -> Self: ...
     def count(self, sub: str | UserString, start: int = 0, end: int = sys.maxsize) -> int: ...
-    if sys.version_info >= (3, 8):
-        def encode(self: UserString, encoding: str | None = "utf-8", errors: str | None = "strict") -> bytes: ...
-    else:
-        def encode(self, encoding: str | None = None, errors: str | None = None) -> Self: ...
-
+    def encode(self: UserString, encoding: str | None = "utf-8", errors: str | None = "strict") -> bytes: ...
     def endswith(self, suffix: str | tuple[str, ...], start: int | None = 0, end: int | None = sys.maxsize) -> bool: ...
     def expandtabs(self, tabsize: int = 8) -> Self: ...
     def find(self, sub: str | UserString, start: int = 0, end: int = sys.maxsize) -> int: ...
@@ -196,8 +214,8 @@ class UserString(Sequence[UserString]):
     maketrans = str.maketrans
     def partition(self, sep: str) -> tuple[str, str, str]: ...
     if sys.version_info >= (3, 9):
-        def removeprefix(self, __prefix: str | UserString) -> Self: ...
-        def removesuffix(self, __suffix: str | UserString) -> Self: ...
+        def removeprefix(self, prefix: str | UserString, /) -> Self: ...
+        def removesuffix(self, suffix: str | UserString, /) -> Self: ...
 
     def replace(self, old: str | UserString, new: str | UserString, maxsplit: int = -1) -> Self: ...
     def rfind(self, sub: str | UserString, start: int = 0, end: int = sys.maxsize) -> int: ...
@@ -216,64 +234,66 @@ class UserString(Sequence[UserString]):
     def upper(self) -> Self: ...
     def zfill(self, width: int) -> Self: ...
 
-class deque(MutableSequence[_T], Generic[_T]):
+class deque(MutableSequence[_T]):
     @property
     def maxlen(self) -> int | None: ...
     @overload
     def __init__(self, *, maxlen: int | None = None) -> None: ...
     @overload
     def __init__(self, iterable: Iterable[_T], maxlen: int | None = None) -> None: ...
-    def append(self, __x: _T) -> None: ...
-    def appendleft(self, __x: _T) -> None: ...
+    def append(self, x: _T, /) -> None: ...
+    def appendleft(self, x: _T, /) -> None: ...
     def copy(self) -> Self: ...
-    def count(self, __x: _T) -> int: ...
-    def extend(self, __iterable: Iterable[_T]) -> None: ...
-    def extendleft(self, __iterable: Iterable[_T]) -> None: ...
-    def insert(self, __i: int, __x: _T) -> None: ...
-    def index(self, __x: _T, __start: int = 0, __stop: int = ...) -> int: ...
+    def count(self, x: _T, /) -> int: ...
+    def extend(self, iterable: Iterable[_T], /) -> None: ...
+    def extendleft(self, iterable: Iterable[_T], /) -> None: ...
+    def insert(self, i: int, x: _T, /) -> None: ...
+    def index(self, x: _T, start: int = 0, stop: int = ..., /) -> int: ...
     def pop(self) -> _T: ...  # type: ignore[override]
     def popleft(self) -> _T: ...
-    def remove(self, __value: _T) -> None: ...
-    def rotate(self, __n: int = 1) -> None: ...
+    def remove(self, value: _T, /) -> None: ...
+    def rotate(self, n: int = 1, /) -> None: ...
     def __copy__(self) -> Self: ...
     def __len__(self) -> int: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     # These methods of deque don't take slices, unlike MutableSequence, hence the type: ignores
-    def __getitem__(self, __key: SupportsIndex) -> _T: ...  # type: ignore[override]
-    def __setitem__(self, __key: SupportsIndex, __value: _T) -> None: ...  # type: ignore[override]
-    def __delitem__(self, __key: SupportsIndex) -> None: ...  # type: ignore[override]
-    def __contains__(self, __key: object) -> bool: ...
+    def __getitem__(self, key: SupportsIndex, /) -> _T: ...  # type: ignore[override]
+    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...  # type: ignore[override]
+    def __delitem__(self, key: SupportsIndex, /) -> None: ...  # type: ignore[override]
+    def __contains__(self, key: object, /) -> bool: ...
     def __reduce__(self) -> tuple[type[Self], tuple[()], None, Iterator[_T]]: ...
-    def __iadd__(self, __value: Iterable[_T]) -> Self: ...
-    def __add__(self, __value: Self) -> Self: ...
-    def __mul__(self, __value: int) -> Self: ...
-    def __imul__(self, __value: int) -> Self: ...
-    def __lt__(self, __value: deque[_T]) -> bool: ...
-    def __le__(self, __value: deque[_T]) -> bool: ...
-    def __gt__(self, __value: deque[_T]) -> bool: ...
-    def __ge__(self, __value: deque[_T]) -> bool: ...
+    def __iadd__(self, value: Iterable[_T], /) -> Self: ...
+    def __add__(self, value: Self, /) -> Self: ...
+    def __mul__(self, value: int, /) -> Self: ...
+    def __imul__(self, value: int, /) -> Self: ...
+    def __lt__(self, value: deque[_T], /) -> bool: ...
+    def __le__(self, value: deque[_T], /) -> bool: ...
+    def __gt__(self, value: deque[_T], /) -> bool: ...
+    def __ge__(self, value: deque[_T], /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Counter(dict[_T, int], Generic[_T]):
     @overload
-    def __init__(self, __iterable: None = None) -> None: ...
+    def __init__(self, iterable: None = None, /) -> None: ...
     @overload
-    def __init__(self: Counter[str], __iterable: None = None, **kwargs: int) -> None: ...
+    def __init__(self: Counter[str], iterable: None = None, /, **kwargs: int) -> None: ...
     @overload
-    def __init__(self, __mapping: SupportsKeysAndGetItem[_T, int]) -> None: ...
+    def __init__(self, mapping: SupportsKeysAndGetItem[_T, int], /) -> None: ...
     @overload
-    def __init__(self, __iterable: Iterable[_T]) -> None: ...
+    def __init__(self, iterable: Iterable[_T], /) -> None: ...
     def copy(self) -> Self: ...
     def elements(self) -> Iterator[_T]: ...
     def most_common(self, n: int | None = None) -> list[tuple[_T, int]]: ...
     @classmethod
     def fromkeys(cls, iterable: Any, v: int | None = None) -> NoReturn: ...  # type: ignore[override]
     @overload
-    def subtract(self, __iterable: None = None) -> None: ...
+    def subtract(self, iterable: None = None, /) -> None: ...
     @overload
-    def subtract(self, __mapping: Mapping[_T, int]) -> None: ...
+    def subtract(self, mapping: Mapping[_T, int], /) -> None: ...
     @overload
-    def subtract(self, __iterable: Iterable[_T]) -> None: ...
+    def subtract(self, iterable: Iterable[_T], /) -> None: ...
     # Unlike dict.update(), use Mapping instead of SupportsKeysAndGetItem for the first overload
     # (source code does an `isinstance(other, Mapping)` check)
     #
@@ -281,11 +301,11 @@ class Counter(dict[_T, int], Generic[_T]):
     # (if it were `Iterable[_T] | Iterable[tuple[_T, int]]`,
     # the tuples would be added as keys, breaking type safety)
     @overload  # type: ignore[override]
-    def update(self, __m: Mapping[_T, int], **kwargs: int) -> None: ...
+    def update(self, m: Mapping[_T, int], /, **kwargs: int) -> None: ...
     @overload
-    def update(self, __iterable: Iterable[_T], **kwargs: int) -> None: ...
+    def update(self, iterable: Iterable[_T], /, **kwargs: int) -> None: ...
     @overload
-    def update(self, __iterable: None = None, **kwargs: int) -> None: ...
+    def update(self, iterable: None = None, /, **kwargs: int) -> None: ...
     def __missing__(self, key: _T) -> int: ...
     def __delitem__(self, elem: object) -> None: ...
     if sys.version_info >= (3, 10):
@@ -299,10 +319,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: ...
@@ -312,13 +332,13 @@ class Counter(dict[_T, int], Generic[_T]):
 
 # The pure-Python implementations of the "views" classes
 # These are exposed at runtime in `collections/__init__.py`
-class _OrderedDictKeysView(KeysView[_KT_co], Reversible[_KT_co]):
+class _OrderedDictKeysView(KeysView[_KT_co]):
     def __reversed__(self) -> Iterator[_KT_co]: ...
 
-class _OrderedDictItemsView(ItemsView[_KT_co, _VT_co], Reversible[tuple[_KT_co, _VT_co]]):
+class _OrderedDictItemsView(ItemsView[_KT_co, _VT_co]):
     def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...
 
-class _OrderedDictValuesView(ValuesView[_VT_co], Reversible[_VT_co]):
+class _OrderedDictValuesView(ValuesView[_VT_co]):
     def __reversed__(self) -> Iterator[_VT_co]: ...
 
 # The C implementations of the "views" classes
@@ -326,18 +346,18 @@ class _OrderedDictValuesView(ValuesView[_VT_co], Reversible[_VT_co]):
 # but they are not exposed anywhere)
 # pyright doesn't have a specific error code for subclassing error!
 @final
-class _odict_keys(dict_keys[_KT_co, _VT_co], Reversible[_KT_co]):  # type: ignore[misc]  # pyright: ignore
+class _odict_keys(dict_keys[_KT_co, _VT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     def __reversed__(self) -> Iterator[_KT_co]: ...
 
 @final
-class _odict_items(dict_items[_KT_co, _VT_co], Reversible[tuple[_KT_co, _VT_co]]):  # type: ignore[misc]  # pyright: ignore
+class _odict_items(dict_items[_KT_co, _VT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...
 
 @final
-class _odict_values(dict_values[_KT_co, _VT_co], Reversible[_VT_co], Generic[_KT_co, _VT_co]):  # type: ignore[misc]  # pyright: ignore
+class _odict_values(dict_values[_KT_co, _VT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     def __reversed__(self) -> Iterator[_VT_co]: ...
 
-class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
+class OrderedDict(dict[_KT, _VT]):
     def popitem(self, last: bool = True) -> tuple[_KT, _VT]: ...
     def move_to_end(self, key: _KT, last: bool = True) -> None: ...
     def copy(self) -> Self: ...
@@ -359,40 +379,73 @@ class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
     def setdefault(self: OrderedDict[_KT, _T | None], key: _KT, default: None = None) -> _T | None: ...
     @overload
     def setdefault(self, key: _KT, default: _VT) -> _VT: ...
+    # Same as dict.pop, but accepts keyword arguments
+    @overload
+    def pop(self, key: _KT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _T) -> _VT | _T: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    if sys.version_info >= (3, 9):
+        @overload
+        def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
+        @overload
+        def __or__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...
+        @overload
+        def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
+        @overload
+        def __ror__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...  # type: ignore[misc]
 
-class defaultdict(dict[_KT, _VT], Generic[_KT, _VT]):
+class defaultdict(dict[_KT, _VT]):
     default_factory: Callable[[], _VT] | None
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self: defaultdict[str, _VT], **kwargs: _VT) -> None: ...
+    def __init__(self: defaultdict[str, _VT], **kwargs: _VT) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]  #11780
     @overload
-    def __init__(self, __default_factory: Callable[[], _VT] | None) -> None: ...
+    def __init__(self, default_factory: Callable[[], _VT] | None, /) -> None: ...
     @overload
-    def __init__(self: defaultdict[str, _VT], __default_factory: Callable[[], _VT] | None, **kwargs: _VT) -> None: ...
+    def __init__(
+        self: defaultdict[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        default_factory: Callable[[], _VT] | None,
+        /,
+        **kwargs: _VT,
+    ) -> None: ...
     @overload
-    def __init__(self, __default_factory: Callable[[], _VT] | None, __map: SupportsKeysAndGetItem[_KT, _VT]) -> None: ...
+    def __init__(self, default_factory: Callable[[], _VT] | None, map: SupportsKeysAndGetItem[_KT, _VT], /) -> None: ...
     @overload
     def __init__(
-        self: defaultdict[str, _VT],
-        __default_factory: Callable[[], _VT] | None,
-        __map: SupportsKeysAndGetItem[str, _VT],
+        self: defaultdict[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        default_factory: Callable[[], _VT] | None,
+        map: SupportsKeysAndGetItem[str, _VT],
+        /,
         **kwargs: _VT,
     ) -> None: ...
     @overload
-    def __init__(self, __default_factory: Callable[[], _VT] | None, __iterable: Iterable[tuple[_KT, _VT]]) -> None: ...
+    def __init__(self, default_factory: Callable[[], _VT] | None, iterable: Iterable[tuple[_KT, _VT]], /) -> None: ...
     @overload
     def __init__(
-        self: defaultdict[str, _VT],
-        __default_factory: Callable[[], _VT] | None,
-        __iterable: Iterable[tuple[str, _VT]],
+        self: defaultdict[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        default_factory: Callable[[], _VT] | None,
+        iterable: Iterable[tuple[str, _VT]],
+        /,
         **kwargs: _VT,
     ) -> None: ...
-    def __missing__(self, __key: _KT) -> _VT: ...
+    def __missing__(self, key: _KT, /) -> _VT: ...
     def __copy__(self) -> Self: ...
     def copy(self) -> Self: ...
+    if sys.version_info >= (3, 9):
+        @overload
+        def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
+        @overload
+        def __or__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ...
+        @overload
+        def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
+        @overload
+        def __ror__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ...  # type: ignore[misc]
 
-class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
+class ChainMap(MutableMapping[_KT, _VT]):
     maps: list[MutableMapping[_KT, _VT]]
     def __init__(self, *maps: MutableMapping[_KT, _VT]) -> None: ...
     def new_child(self, m: MutableMapping[_KT, _VT] | None = None) -> Self: ...
@@ -404,6 +457,10 @@ class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
     def __iter__(self) -> Iterator[_KT]: ...
     def __len__(self) -> int: ...
     def __contains__(self, key: object) -> bool: ...
+    @overload
+    def get(self, key: _KT, default: None = None) -> _VT | None: ...
+    @overload
+    def get(self, key: _KT, default: _T) -> _VT | _T: ...
     def __missing__(self, key: _KT) -> _VT: ...  # undocumented
     def __bool__(self) -> bool: ...
     # Keep ChainMap.setdefault in line with MutableMapping.setdefault, modulo positional-only differences.
@@ -414,18 +471,31 @@ class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
     @overload
     def pop(self, key: _KT) -> _VT: ...
     @overload
-    def pop(self, key: _KT, default: _VT | _T) -> _VT | _T: ...
+    def pop(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _T) -> _VT | _T: ...
     def copy(self) -> Self: ...
     __copy__ = copy
-    # All arguments to `fromkeys` are passed to `dict.fromkeys` at runtime, so the signature should be kept in line with `dict.fromkeys`.
+    # All arguments to `fromkeys` are passed to `dict.fromkeys` at runtime,
+    # so the signature should be kept in line with `dict.fromkeys`.
+    @classmethod
+    @overload
+    def fromkeys(cls, iterable: Iterable[_T]) -> ChainMap[_T, Any | None]: ...
     @classmethod
     @overload
-    def fromkeys(cls, iterable: Iterable[_T], __value: None = None) -> ChainMap[_T, Any | None]: ...
+    # Special-case None: the user probably wants to add non-None values later.
+    def fromkeys(cls, iterable: Iterable[_T], value: None, /) -> ChainMap[_T, Any | None]: ...
     @classmethod
     @overload
-    def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> ChainMap[_T, _S]: ...
+    def fromkeys(cls, iterable: Iterable[_T], value: _S, /) -> ChainMap[_T, _S]: ...
     if sys.version_info >= (3, 9):
+        @overload
+        def __or__(self, other: Mapping[_KT, _VT]) -> Self: ...
+        @overload
         def __or__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
+        @overload
+        def __ror__(self, other: Mapping[_KT, _VT]) -> Self: ...
+        @overload
         def __ror__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
         # ChainMap.__ior__ should be kept roughly in line with MutableMapping.update()
         @overload  # type: ignore[misc]
diff --git a/mypy/typeshed/stdlib/compileall.pyi b/mypy/typeshed/stdlib/compileall.pyi
index 7520c2f5b676..f35c584cedfb 100644
--- a/mypy/typeshed/stdlib/compileall.pyi
+++ b/mypy/typeshed/stdlib/compileall.pyi
@@ -6,7 +6,7 @@ from typing import Any, Protocol
 __all__ = ["compile_dir", "compile_file", "compile_path"]
 
 class _SupportsSearch(Protocol):
-    def search(self, string: str) -> Any: ...
+    def search(self, string: str, /) -> Any: ...
 
 if sys.version_info >= (3, 10):
     def compile_dir(
@@ -25,7 +25,7 @@ if sys.version_info >= (3, 10):
         prependdir: StrPath | None = None,
         limit_sl_dest: StrPath | None = None,
         hardlink_dupes: bool = False,
-    ) -> int: ...
+    ) -> bool: ...
     def compile_file(
         fullname: StrPath,
         ddir: StrPath | None = None,
@@ -40,7 +40,7 @@ if sys.version_info >= (3, 10):
         prependdir: StrPath | None = None,
         limit_sl_dest: StrPath | None = None,
         hardlink_dupes: bool = False,
-    ) -> int: ...
+    ) -> bool: ...
 
 elif sys.version_info >= (3, 9):
     def compile_dir(
@@ -59,7 +59,7 @@ elif sys.version_info >= (3, 9):
         prependdir: StrPath | None = None,
         limit_sl_dest: StrPath | None = None,
         hardlink_dupes: bool = False,
-    ) -> int: ...
+    ) -> bool: ...
     def compile_file(
         fullname: StrPath,
         ddir: StrPath | None = None,
@@ -74,7 +74,7 @@ elif sys.version_info >= (3, 9):
         prependdir: StrPath | None = None,
         limit_sl_dest: StrPath | None = None,
         hardlink_dupes: bool = False,
-    ) -> int: ...
+    ) -> bool: ...
 
 else:
     def compile_dir(
@@ -88,7 +88,7 @@ else:
         optimize: int = -1,
         workers: int = 1,
         invalidation_mode: PycInvalidationMode | None = None,
-    ) -> int: ...
+    ) -> bool: ...
     def compile_file(
         fullname: StrPath,
         ddir: StrPath | None = None,
@@ -98,7 +98,7 @@ else:
         legacy: bool = False,
         optimize: int = -1,
         invalidation_mode: PycInvalidationMode | None = None,
-    ) -> int: ...
+    ) -> bool: ...
 
 def compile_path(
     skip_curdir: bool = ...,
@@ -108,4 +108,4 @@ def compile_path(
     legacy: bool = False,
     optimize: int = -1,
     invalidation_mode: PycInvalidationMode | None = None,
-) -> int: ...
+) -> bool: ...
diff --git a/mypy/typeshed/stdlib/concurrent/futures/__init__.pyi b/mypy/typeshed/stdlib/concurrent/futures/__init__.pyi
index ff2e72bbf4fb..68fd0bc5acb4 100644
--- a/mypy/typeshed/stdlib/concurrent/futures/__init__.pyi
+++ b/mypy/typeshed/stdlib/concurrent/futures/__init__.pyi
@@ -8,6 +8,7 @@ from ._base import (
     CancelledError as CancelledError,
     Executor as Executor,
     Future as Future,
+    InvalidStateError as InvalidStateError,
     TimeoutError as TimeoutError,
     as_completed as as_completed,
     wait as wait,
@@ -15,22 +16,36 @@ from ._base import (
 from .process import ProcessPoolExecutor as ProcessPoolExecutor
 from .thread import ThreadPoolExecutor as ThreadPoolExecutor
 
-if sys.version_info >= (3, 8):
-    from ._base import InvalidStateError as InvalidStateError
-
-__all__ = (
-    "FIRST_COMPLETED",
-    "FIRST_EXCEPTION",
-    "ALL_COMPLETED",
-    "CancelledError",
-    "TimeoutError",
-    "BrokenExecutor",
-    "Future",
-    "Executor",
-    "wait",
-    "as_completed",
-    "ProcessPoolExecutor",
-    "ThreadPoolExecutor",
-)
+if sys.version_info >= (3, 13):
+    __all__ = (
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "CancelledError",
+        "TimeoutError",
+        "InvalidStateError",
+        "BrokenExecutor",
+        "Future",
+        "Executor",
+        "wait",
+        "as_completed",
+        "ProcessPoolExecutor",
+        "ThreadPoolExecutor",
+    )
+else:
+    __all__ = (
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "CancelledError",
+        "TimeoutError",
+        "BrokenExecutor",
+        "Future",
+        "Executor",
+        "wait",
+        "as_completed",
+        "ProcessPoolExecutor",
+        "ThreadPoolExecutor",
+    )
 
 def __dir__() -> tuple[str, ...]: ...
diff --git a/mypy/typeshed/stdlib/concurrent/futures/_base.pyi b/mypy/typeshed/stdlib/concurrent/futures/_base.pyi
index eb5ca4e2dd35..0c019457902b 100644
--- a/mypy/typeshed/stdlib/concurrent/futures/_base.pyi
+++ b/mypy/typeshed/stdlib/concurrent/futures/_base.pyi
@@ -1,40 +1,48 @@
 import sys
 import threading
 from _typeshed import Unused
-from collections.abc import Callable, Iterable, Iterator
+from collections.abc import Callable, Collection, Iterable, Iterator
 from logging import Logger
 from types import TracebackType
-from typing import Any, Generic, NamedTuple, TypeVar
-from typing_extensions import Literal, ParamSpec, Self
+from typing import Any, Final, Generic, NamedTuple, Protocol, TypeVar
+from typing_extensions import ParamSpec, Self
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 
-FIRST_COMPLETED: Literal["FIRST_COMPLETED"]
-FIRST_EXCEPTION: Literal["FIRST_EXCEPTION"]
-ALL_COMPLETED: Literal["ALL_COMPLETED"]
-PENDING: Literal["PENDING"]
-RUNNING: Literal["RUNNING"]
-CANCELLED: Literal["CANCELLED"]
-CANCELLED_AND_NOTIFIED: Literal["CANCELLED_AND_NOTIFIED"]
-FINISHED: Literal["FINISHED"]
+FIRST_COMPLETED: Final = "FIRST_COMPLETED"
+FIRST_EXCEPTION: Final = "FIRST_EXCEPTION"
+ALL_COMPLETED: Final = "ALL_COMPLETED"
+PENDING: Final = "PENDING"
+RUNNING: Final = "RUNNING"
+CANCELLED: Final = "CANCELLED"
+CANCELLED_AND_NOTIFIED: Final = "CANCELLED_AND_NOTIFIED"
+FINISHED: Final = "FINISHED"
 _FUTURE_STATES: list[str]
 _STATE_TO_DESCRIPTION_MAP: dict[str, str]
 LOGGER: Logger
 
 class Error(Exception): ...
 class CancelledError(Error): ...
-class TimeoutError(Error): ...
 
-if sys.version_info >= (3, 8):
-    class InvalidStateError(Error): ...
+if sys.version_info >= (3, 11):
+    from builtins import TimeoutError as TimeoutError
+else:
+    class TimeoutError(Error): ...
 
+class InvalidStateError(Error): ...
 class BrokenExecutor(RuntimeError): ...
 
 _T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
 _P = ParamSpec("_P")
 
 class Future(Generic[_T]):
+    _condition: threading.Condition
+    _state: str
+    _result: _T | None
+    _exception: BaseException | None
+    _waiters: list[_Waiter]
     def cancel(self) -> bool: ...
     def cancelled(self) -> bool: ...
     def running(self) -> bool: ...
@@ -46,11 +54,11 @@ class Future(Generic[_T]):
     def exception(self, timeout: float | None = None) -> BaseException | None: ...
     def set_exception(self, exception: BaseException | None) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Executor:
     if sys.version_info >= (3, 9):
-        def submit(self, __fn: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> Future[_T]: ...
+        def submit(self, fn: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Future[_T]: ...
     else:
         def submit(self, fn: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> Future[_T]: ...
 
@@ -67,15 +75,31 @@ class Executor:
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> bool | None: ...
 
-def as_completed(fs: Iterable[Future[_T]], timeout: float | None = None) -> Iterator[Future[_T]]: ...
+class _AsCompletedFuture(Protocol[_T_co]):
+    # as_completed only mutates non-generic aspects of passed Futures and does not do any nominal
+    # checks. Therefore, we can use a Protocol here to allow as_completed to act covariantly.
+    # See the tests for concurrent.futures
+    _condition: threading.Condition
+    _state: str
+    _waiters: list[_Waiter]
+    # Not used by as_completed, but needed to propagate the generic type
+    def result(self, timeout: float | None = None) -> _T_co: ...
+
+def as_completed(fs: Iterable[_AsCompletedFuture[_T]], timeout: float | None = None) -> Iterator[Future[_T]]: ...
 
 class DoneAndNotDoneFutures(NamedTuple, Generic[_T]):
     done: set[Future[_T]]
     not_done: set[Future[_T]]
 
-def wait(
-    fs: Iterable[Future[_T]], timeout: float | None = None, return_when: str = "ALL_COMPLETED"
-) -> DoneAndNotDoneFutures[_T]: ...
+if sys.version_info >= (3, 9):
+    def wait(
+        fs: Iterable[Future[_T]], timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> DoneAndNotDoneFutures[_T]: ...
+
+else:
+    def wait(
+        fs: Collection[Future[_T]], timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+    ) -> DoneAndNotDoneFutures[_T]: ...
 
 class _Waiter:
     event: threading.Event
diff --git a/mypy/typeshed/stdlib/concurrent/futures/process.pyi b/mypy/typeshed/stdlib/concurrent/futures/process.pyi
index 000e7a43503a..97dc261be7ed 100644
--- a/mypy/typeshed/stdlib/concurrent/futures/process.pyi
+++ b/mypy/typeshed/stdlib/concurrent/futures/process.pyi
@@ -5,20 +5,23 @@ from multiprocessing.context import BaseContext, Process
 from multiprocessing.queues import Queue, SimpleQueue
 from threading import Lock, Semaphore, Thread
 from types import TracebackType
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import TypeVarTuple, Unpack
 from weakref import ref
 
 from ._base import BrokenExecutor, Executor, Future
 
 _T = TypeVar("_T")
+_Ts = TypeVarTuple("_Ts")
 
 _threads_wakeups: MutableMapping[Any, Any]
 _global_shutdown: bool
 
 class _ThreadWakeup:
     _closed: bool
-    _reader: Connection
-    _writer: Connection
+    # Any: Unused send and recv methods
+    _reader: Connection[Any, Any]
+    _writer: Connection[Any, Any]
     def close(self) -> None: ...
     def wakeup(self) -> None: ...
     def clear(self) -> None: ...
@@ -69,9 +72,19 @@ class _CallItem:
 
 class _SafeQueue(Queue[Future[Any]]):
     pending_work_items: dict[int, _WorkItem[Any]]
-    shutdown_lock: Lock
+    if sys.version_info < (3, 12):
+        shutdown_lock: Lock
     thread_wakeup: _ThreadWakeup
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            max_size: int | None = 0,
+            *,
+            ctx: BaseContext,
+            pending_work_items: dict[int, _WorkItem[Any]],
+            thread_wakeup: _ThreadWakeup,
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
         def __init__(
             self,
             max_size: int | None = 0,
@@ -109,8 +122,8 @@ if sys.version_info >= (3, 11):
     def _process_worker(
         call_queue: Queue[_CallItem],
         result_queue: SimpleQueue[_ResultItem],
-        initializer: Callable[..., object] | None,
-        initargs: tuple[Any, ...],
+        initializer: Callable[[Unpack[_Ts]], object] | None,
+        initargs: tuple[Unpack[_Ts]],
         max_tasks: int | None = None,
     ) -> None: ...
 
@@ -118,8 +131,8 @@ else:
     def _process_worker(
         call_queue: Queue[_CallItem],
         result_queue: SimpleQueue[_ResultItem],
-        initializer: Callable[..., object] | None,
-        initargs: tuple[Any, ...],
+        initializer: Callable[[Unpack[_Ts]], object] | None,
+        initargs: tuple[Unpack[_Ts]],
     ) -> None: ...
 
 if sys.version_info >= (3, 9):
@@ -169,22 +182,61 @@ class ProcessPoolExecutor(Executor):
     _result_queue: SimpleQueue[Any]
     _work_ids: Queue[Any]
     if sys.version_info >= (3, 11):
+        @overload
         def __init__(
             self,
             max_workers: int | None = None,
             mp_context: BaseContext | None = None,
-            initializer: Callable[..., object] | None = None,
-            initargs: tuple[Any, ...] = (),
+            initializer: Callable[[], object] | None = None,
+            initargs: tuple[()] = (),
+            *,
+            max_tasks_per_child: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None = None,
+            mp_context: BaseContext | None = None,
+            *,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
+            max_tasks_per_child: int | None = None,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None,
+            mp_context: BaseContext | None,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
             *,
             max_tasks_per_child: int | None = None,
         ) -> None: ...
     else:
+        @overload
         def __init__(
             self,
             max_workers: int | None = None,
             mp_context: BaseContext | None = None,
-            initializer: Callable[..., object] | None = None,
-            initargs: tuple[Any, ...] = (),
+            initializer: Callable[[], object] | None = None,
+            initargs: tuple[()] = (),
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None = None,
+            mp_context: BaseContext | None = None,
+            *,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            max_workers: int | None,
+            mp_context: BaseContext | None,
+            initializer: Callable[[Unpack[_Ts]], object],
+            initargs: tuple[Unpack[_Ts]],
         ) -> None: ...
     if sys.version_info >= (3, 9):
         def _start_executor_manager_thread(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/concurrent/futures/thread.pyi b/mypy/typeshed/stdlib/concurrent/futures/thread.pyi
index 0b00d524aa3d..d1b7858eae02 100644
--- a/mypy/typeshed/stdlib/concurrent/futures/thread.pyi
+++ b/mypy/typeshed/stdlib/concurrent/futures/thread.pyi
@@ -2,11 +2,14 @@ import queue
 import sys
 from collections.abc import Callable, Iterable, Mapping, Set as AbstractSet
 from threading import Lock, Semaphore, Thread
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import TypeVarTuple, Unpack
 from weakref import ref
 
 from ._base import BrokenExecutor, Executor, Future
 
+_Ts = TypeVarTuple("_Ts")
+
 _threads_queues: Mapping[Any, Any]
 _shutdown: bool
 _global_shutdown_lock: Lock
@@ -26,13 +29,13 @@ class _WorkItem(Generic[_S]):
     def __init__(self, future: Future[_S], fn: Callable[..., _S], args: Iterable[Any], kwargs: Mapping[str, Any]) -> None: ...
     def run(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def _worker(
     executor_reference: ref[Any],
     work_queue: queue.SimpleQueue[Any],
-    initializer: Callable[..., object],
-    initargs: tuple[Any, ...],
+    initializer: Callable[[Unpack[_Ts]], object],
+    initargs: tuple[Unpack[_Ts]],
 ) -> None: ...
 
 class BrokenThreadPool(BrokenExecutor): ...
@@ -48,12 +51,30 @@ class ThreadPoolExecutor(Executor):
     _initializer: Callable[..., None] | None
     _initargs: tuple[Any, ...]
     _work_queue: queue.SimpleQueue[_WorkItem[Any]]
+    @overload
     def __init__(
         self,
         max_workers: int | None = None,
         thread_name_prefix: str = "",
-        initializer: Callable[..., object] | None = None,
-        initargs: tuple[Any, ...] = (),
+        initializer: Callable[[], object] | None = None,
+        initargs: tuple[()] = (),
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        max_workers: int | None = None,
+        thread_name_prefix: str = "",
+        *,
+        initializer: Callable[[Unpack[_Ts]], object],
+        initargs: tuple[Unpack[_Ts]],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        max_workers: int | None,
+        thread_name_prefix: str,
+        initializer: Callable[[Unpack[_Ts]], object],
+        initargs: tuple[Unpack[_Ts]],
     ) -> None: ...
     def _adjust_thread_count(self) -> None: ...
     def _initializer_failed(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/configparser.pyi b/mypy/typeshed/stdlib/configparser.pyi
index 6f9f788310d1..8996c85d9a53 100644
--- a/mypy/typeshed/stdlib/configparser.pyi
+++ b/mypy/typeshed/stdlib/configparser.pyi
@@ -1,35 +1,94 @@
 import sys
-from _typeshed import StrOrBytesPath, SupportsWrite
+from _typeshed import MaybeNone, StrOrBytesPath, SupportsWrite
 from collections.abc import Callable, ItemsView, Iterable, Iterator, Mapping, MutableMapping, Sequence
 from re import Pattern
-from typing import Any, ClassVar, TypeVar, overload
-from typing_extensions import Literal, TypeAlias
+from typing import Any, ClassVar, Final, Literal, TypeVar, overload
+from typing_extensions import TypeAlias
 
-__all__ = [
-    "NoSectionError",
-    "DuplicateOptionError",
-    "DuplicateSectionError",
-    "NoOptionError",
-    "InterpolationError",
-    "InterpolationDepthError",
-    "InterpolationMissingOptionError",
-    "InterpolationSyntaxError",
-    "ParsingError",
-    "MissingSectionHeaderError",
-    "ConfigParser",
-    "RawConfigParser",
-    "Interpolation",
-    "BasicInterpolation",
-    "ExtendedInterpolation",
-    "LegacyInterpolation",
-    "SectionProxy",
-    "ConverterMapping",
-    "DEFAULTSECT",
-    "MAX_INTERPOLATION_DEPTH",
-]
+if sys.version_info >= (3, 13):
+    __all__ = (
+        "NoSectionError",
+        "DuplicateOptionError",
+        "DuplicateSectionError",
+        "NoOptionError",
+        "InterpolationError",
+        "InterpolationDepthError",
+        "InterpolationMissingOptionError",
+        "InterpolationSyntaxError",
+        "ParsingError",
+        "MissingSectionHeaderError",
+        "ConfigParser",
+        "RawConfigParser",
+        "Interpolation",
+        "BasicInterpolation",
+        "ExtendedInterpolation",
+        "SectionProxy",
+        "ConverterMapping",
+        "DEFAULTSECT",
+        "MAX_INTERPOLATION_DEPTH",
+        "UNNAMED_SECTION",
+        "MultilineContinuationError",
+    )
+elif sys.version_info >= (3, 12):
+    __all__ = (
+        "NoSectionError",
+        "DuplicateOptionError",
+        "DuplicateSectionError",
+        "NoOptionError",
+        "InterpolationError",
+        "InterpolationDepthError",
+        "InterpolationMissingOptionError",
+        "InterpolationSyntaxError",
+        "ParsingError",
+        "MissingSectionHeaderError",
+        "ConfigParser",
+        "RawConfigParser",
+        "Interpolation",
+        "BasicInterpolation",
+        "ExtendedInterpolation",
+        "LegacyInterpolation",
+        "SectionProxy",
+        "ConverterMapping",
+        "DEFAULTSECT",
+        "MAX_INTERPOLATION_DEPTH",
+    )
+else:
+    __all__ = [
+        "NoSectionError",
+        "DuplicateOptionError",
+        "DuplicateSectionError",
+        "NoOptionError",
+        "InterpolationError",
+        "InterpolationDepthError",
+        "InterpolationMissingOptionError",
+        "InterpolationSyntaxError",
+        "ParsingError",
+        "MissingSectionHeaderError",
+        "ConfigParser",
+        "SafeConfigParser",
+        "RawConfigParser",
+        "Interpolation",
+        "BasicInterpolation",
+        "ExtendedInterpolation",
+        "LegacyInterpolation",
+        "SectionProxy",
+        "ConverterMapping",
+        "DEFAULTSECT",
+        "MAX_INTERPOLATION_DEPTH",
+    ]
 
-if sys.version_info < (3, 12):
-    __all__ += ["SafeConfigParser"]
+if sys.version_info >= (3, 13):
+    class _UNNAMED_SECTION: ...
+    UNNAMED_SECTION: _UNNAMED_SECTION
+
+    _SectionName: TypeAlias = str | _UNNAMED_SECTION
+    # A list of sections can only include an unnamed section if the parser was initialized with
+    # allow_unnamed_section=True. Any prevents users from having to use explicit
+    # type checks if allow_unnamed_section is False (the default).
+    _SectionNameList: TypeAlias = list[Any]
+else:
+    _SectionName: TypeAlias = str
+    _SectionNameList: TypeAlias = list[str]
 
 _Section: TypeAlias = Mapping[str, str]
 _Parser: TypeAlias = MutableMapping[str, _Section]
@@ -37,20 +96,21 @@ _ConverterCallback: TypeAlias = Callable[[str], Any]
 _ConvertersMap: TypeAlias = dict[str, _ConverterCallback]
 _T = TypeVar("_T")
 
-DEFAULTSECT: Literal["DEFAULT"]
-MAX_INTERPOLATION_DEPTH: Literal[10]
+DEFAULTSECT: Final = "DEFAULT"
+MAX_INTERPOLATION_DEPTH: Final = 10
 
 class Interpolation:
-    def before_get(self, parser: _Parser, section: str, option: str, value: str, defaults: _Section) -> str: ...
-    def before_set(self, parser: _Parser, section: str, option: str, value: str) -> str: ...
-    def before_read(self, parser: _Parser, section: str, option: str, value: str) -> str: ...
-    def before_write(self, parser: _Parser, section: str, option: str, value: str) -> str: ...
+    def before_get(self, parser: _Parser, section: _SectionName, option: str, value: str, defaults: _Section) -> str: ...
+    def before_set(self, parser: _Parser, section: _SectionName, option: str, value: str) -> str: ...
+    def before_read(self, parser: _Parser, section: _SectionName, option: str, value: str) -> str: ...
+    def before_write(self, parser: _Parser, section: _SectionName, option: str, value: str) -> str: ...
 
 class BasicInterpolation(Interpolation): ...
 class ExtendedInterpolation(Interpolation): ...
 
-class LegacyInterpolation(Interpolation):
-    def before_get(self, parser: _Parser, section: str, option: str, value: str, vars: _Section) -> str: ...
+if sys.version_info < (3, 13):
+    class LegacyInterpolation(Interpolation):
+        def before_get(self, parser: _Parser, section: _SectionName, option: str, value: str, vars: _Section) -> str: ...
 
 class RawConfigParser(_Parser):
     _SECT_TMPL: ClassVar[str]  # undocumented
@@ -64,54 +124,108 @@ class RawConfigParser(_Parser):
 
     BOOLEAN_STATES: ClassVar[Mapping[str, bool]]  # undocumented
     default_section: str
-    @overload
-    def __init__(
-        self,
-        defaults: Mapping[str, str | None] | None = None,
-        dict_type: type[Mapping[str, str]] = ...,
-        *,
-        allow_no_value: Literal[True],
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        defaults: Mapping[str, str | None] | None,
-        dict_type: type[Mapping[str, str]],
-        allow_no_value: Literal[True],
-        *,
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        defaults: _Section | None = None,
-        dict_type: type[Mapping[str, str]] = ...,
-        allow_no_value: bool = False,
-        *,
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            *,
+            allow_no_value: Literal[True],
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+            allow_unnamed_section: bool = False,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None,
+            dict_type: type[Mapping[str, str]],
+            allow_no_value: Literal[True],
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+            allow_unnamed_section: bool = False,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: _Section | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            allow_no_value: bool = False,
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+            allow_unnamed_section: bool = False,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            *,
+            allow_no_value: Literal[True],
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None,
+            dict_type: type[Mapping[str, str]],
+            allow_no_value: Literal[True],
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: _Section | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            allow_no_value: bool = False,
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+        ) -> None: ...
+
     def __len__(self) -> int: ...
     def __getitem__(self, key: str) -> SectionProxy: ...
     def __setitem__(self, key: str, value: _Section) -> None: ...
@@ -119,39 +233,40 @@ class RawConfigParser(_Parser):
     def __iter__(self) -> Iterator[str]: ...
     def __contains__(self, key: object) -> bool: ...
     def defaults(self) -> _Section: ...
-    def sections(self) -> list[str]: ...
-    def add_section(self, section: str) -> None: ...
-    def has_section(self, section: str) -> bool: ...
-    def options(self, section: str) -> list[str]: ...
-    def has_option(self, section: str, option: str) -> bool: ...
+    def sections(self) -> _SectionNameList: ...
+    def add_section(self, section: _SectionName) -> None: ...
+    def has_section(self, section: _SectionName) -> bool: ...
+    def options(self, section: _SectionName) -> list[str]: ...
+    def has_option(self, section: _SectionName, option: str) -> bool: ...
     def read(self, filenames: StrOrBytesPath | Iterable[StrOrBytesPath], encoding: str | None = None) -> list[str]: ...
     def read_file(self, f: Iterable[str], source: str | None = None) -> None: ...
     def read_string(self, string: str, source: str = "<string>") -> None: ...
     def read_dict(self, dictionary: Mapping[str, Mapping[str, Any]], source: str = "<dict>") -> None: ...
-    def readfp(self, fp: Iterable[str], filename: str | None = None) -> None: ...
+    if sys.version_info < (3, 12):
+        def readfp(self, fp: Iterable[str], filename: str | None = None) -> None: ...
     # These get* methods are partially applied (with the same names) in
     # SectionProxy; the stubs should be kept updated together
     @overload
-    def getint(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> int: ...
+    def getint(self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None) -> int: ...
     @overload
     def getint(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
+        self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
     ) -> int | _T: ...
     @overload
-    def getfloat(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> float: ...
+    def getfloat(self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None) -> float: ...
     @overload
     def getfloat(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
+        self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
     ) -> float | _T: ...
     @overload
-    def getboolean(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> bool: ...
+    def getboolean(self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None) -> bool: ...
     @overload
     def getboolean(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
+        self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
     ) -> bool | _T: ...
     def _get_conv(
         self,
-        section: str,
+        section: _SectionName,
         option: str,
         conv: Callable[[str], _T],
         *,
@@ -161,27 +276,31 @@ class RawConfigParser(_Parser):
     ) -> _T: ...
     # This is incompatible with MutableMapping so we ignore the type
     @overload  # type: ignore[override]
-    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> str | Any: ...
+    def get(self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None) -> str | MaybeNone: ...
     @overload
     def get(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T
-    ) -> str | _T | Any: ...
+        self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T
+    ) -> str | _T | MaybeNone: ...
     @overload
     def items(self, *, raw: bool = False, vars: _Section | None = None) -> ItemsView[str, SectionProxy]: ...
     @overload
-    def items(self, section: str, raw: bool = False, vars: _Section | None = None) -> list[tuple[str, str]]: ...
-    def set(self, section: str, option: str, value: str | None = None) -> None: ...
+    def items(self, section: _SectionName, raw: bool = False, vars: _Section | None = None) -> list[tuple[str, str]]: ...
+    def set(self, section: _SectionName, option: str, value: str | None = None) -> None: ...
     def write(self, fp: SupportsWrite[str], space_around_delimiters: bool = True) -> None: ...
-    def remove_option(self, section: str, option: str) -> bool: ...
-    def remove_section(self, section: str) -> bool: ...
+    def remove_option(self, section: _SectionName, option: str) -> bool: ...
+    def remove_section(self, section: _SectionName) -> bool: ...
     def optionxform(self, optionstr: str) -> str: ...
+    @property
+    def converters(self) -> ConverterMapping: ...
 
 class ConfigParser(RawConfigParser):
     # This is incompatible with MutableMapping so we ignore the type
     @overload  # type: ignore[override]
-    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> str: ...
+    def get(self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None) -> str: ...
     @overload
-    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T) -> str | _T: ...
+    def get(
+        self, section: _SectionName, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T
+    ) -> str | _T: ...
 
 if sys.version_info < (3, 12):
     class SafeConfigParser(ConfigParser): ...  # deprecated alias
@@ -198,28 +317,41 @@ class SectionProxy(MutableMapping[str, str]):
     def parser(self) -> RawConfigParser: ...
     @property
     def name(self) -> str: ...
-    def get(  # type: ignore[override]
+    # This is incompatible with MutableMapping so we ignore the type
+    @overload  # type: ignore[override]
+    def get(
         self,
         option: str,
-        fallback: str | None = None,
+        fallback: None = None,
         *,
         raw: bool = False,
         vars: _Section | None = None,
         _impl: Any | None = None,
-        **kwargs: Any,
-    ) -> str | Any: ...  # can be None in RawConfigParser's sections
+        **kwargs: Any,  # passed to the underlying parser's get() method
+    ) -> str | None: ...
+    @overload
+    def get(
+        self,
+        option: str,
+        fallback: _T,
+        *,
+        raw: bool = False,
+        vars: _Section | None = None,
+        _impl: Any | None = None,
+        **kwargs: Any,  # passed to the underlying parser's get() method
+    ) -> str | _T: ...
     # These are partially-applied version of the methods with the same names in
     # RawConfigParser; the stubs should be kept updated together
     @overload
-    def getint(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> int: ...
+    def getint(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> int | None: ...
     @overload
     def getint(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> int | _T: ...
     @overload
-    def getfloat(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> float: ...
+    def getfloat(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> float | None: ...
     @overload
     def getfloat(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> float | _T: ...
     @overload
-    def getboolean(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> bool: ...
+    def getboolean(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> bool | None: ...
     @overload
     def getboolean(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> bool | _T: ...
     # SectionProxy can have arbitrary attributes when custom converters are used
@@ -239,48 +371,61 @@ class Error(Exception):
     def __init__(self, msg: str = "") -> None: ...
 
 class NoSectionError(Error):
-    section: str
-    def __init__(self, section: str) -> None: ...
+    section: _SectionName
+    def __init__(self, section: _SectionName) -> None: ...
 
 class DuplicateSectionError(Error):
-    section: str
+    section: _SectionName
     source: str | None
     lineno: int | None
-    def __init__(self, section: str, source: str | None = None, lineno: int | None = None) -> None: ...
+    def __init__(self, section: _SectionName, source: str | None = None, lineno: int | None = None) -> None: ...
 
 class DuplicateOptionError(Error):
-    section: str
+    section: _SectionName
     option: str
     source: str | None
     lineno: int | None
-    def __init__(self, section: str, option: str, source: str | None = None, lineno: int | None = None) -> None: ...
+    def __init__(self, section: _SectionName, option: str, source: str | None = None, lineno: int | None = None) -> None: ...
 
 class NoOptionError(Error):
-    section: str
+    section: _SectionName
     option: str
-    def __init__(self, option: str, section: str) -> None: ...
+    def __init__(self, option: str, section: _SectionName) -> None: ...
 
 class InterpolationError(Error):
-    section: str
+    section: _SectionName
     option: str
-    def __init__(self, option: str, section: str, msg: str) -> None: ...
+    def __init__(self, option: str, section: _SectionName, msg: str) -> None: ...
 
 class InterpolationDepthError(InterpolationError):
-    def __init__(self, option: str, section: str, rawval: object) -> None: ...
+    def __init__(self, option: str, section: _SectionName, rawval: object) -> None: ...
 
 class InterpolationMissingOptionError(InterpolationError):
     reference: str
-    def __init__(self, option: str, section: str, rawval: object, reference: str) -> None: ...
+    def __init__(self, option: str, section: _SectionName, rawval: object, reference: str) -> None: ...
 
 class InterpolationSyntaxError(InterpolationError): ...
 
 class ParsingError(Error):
     source: str
     errors: list[tuple[int, str]]
-    def __init__(self, source: str | None = None, filename: str | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(self, source: str, *args: object) -> None: ...
+        def combine(self, others: Iterable[ParsingError]) -> ParsingError: ...
+    elif sys.version_info >= (3, 12):
+        def __init__(self, source: str) -> None: ...
+    else:
+        def __init__(self, source: str | None = None, filename: str | None = None) -> None: ...
+
     def append(self, lineno: int, line: str) -> None: ...
 
 class MissingSectionHeaderError(ParsingError):
     lineno: int
     line: str
     def __init__(self, filename: str, lineno: int, line: str) -> None: ...
+
+if sys.version_info >= (3, 13):
+    class MultilineContinuationError(ParsingError):
+        lineno: int
+        line: str
+        def __init__(self, filename: str, lineno: int, line: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/contextlib.pyi b/mypy/typeshed/stdlib/contextlib.pyi
index dc2101dc01f7..08ac5a28b8b8 100644
--- a/mypy/typeshed/stdlib/contextlib.pyi
+++ b/mypy/typeshed/stdlib/contextlib.pyi
@@ -1,7 +1,7 @@
 import abc
 import sys
 from _typeshed import FileDescriptorOrPath, Unused
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable, Generator, Iterator
 from types import TracebackType
 from typing import IO, Any, Generic, Protocol, TypeVar, overload, runtime_checkable
@@ -31,39 +31,56 @@ if sys.version_info >= (3, 11):
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
 _T_io = TypeVar("_T_io", bound=IO[str] | None)
+_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound=bool | None, default=bool | None)
 _F = TypeVar("_F", bound=Callable[..., Any])
+_G_co = TypeVar("_G_co", bound=Generator[Any, Any, Any] | AsyncGenerator[Any, Any], covariant=True)
 _P = ParamSpec("_P")
 
+_SendT_contra = TypeVar("_SendT_contra", contravariant=True, default=None)
+_ReturnT_co = TypeVar("_ReturnT_co", covariant=True, default=None)
+
 _ExitFunc: TypeAlias = Callable[[type[BaseException] | None, BaseException | None, TracebackType | None], bool | None]
-_CM_EF = TypeVar("_CM_EF", bound=AbstractContextManager[Any] | _ExitFunc)
+_CM_EF = TypeVar("_CM_EF", bound=AbstractContextManager[Any, Any] | _ExitFunc)
 
+# mypy and pyright object to this being both ABC and Protocol.
+# At runtime it inherits from ABC and is not a Protocol, but it is on the
+# allowlist for use as a Protocol.
 @runtime_checkable
-class AbstractContextManager(Protocol[_T_co]):
+class AbstractContextManager(ABC, Protocol[_T_co, _ExitT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     def __enter__(self) -> _T_co: ...
     @abstractmethod
     def __exit__(
-        self, __exc_type: type[BaseException] | None, __exc_value: BaseException | None, __traceback: TracebackType | None
-    ) -> bool | None: ...
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
+    ) -> _ExitT_co: ...
 
+# mypy and pyright object to this being both ABC and Protocol.
+# At runtime it inherits from ABC and is not a Protocol, but it is on the
+# allowlist for use as a Protocol.
 @runtime_checkable
-class AbstractAsyncContextManager(Protocol[_T_co]):
+class AbstractAsyncContextManager(ABC, Protocol[_T_co, _ExitT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     async def __aenter__(self) -> _T_co: ...
     @abstractmethod
     async def __aexit__(
-        self, __exc_type: type[BaseException] | None, __exc_value: BaseException | None, __traceback: TracebackType | None
-    ) -> bool | None: ...
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
+    ) -> _ExitT_co: ...
 
 class ContextDecorator:
+    def _recreate_cm(self) -> Self: ...
     def __call__(self, func: _F) -> _F: ...
 
-class _GeneratorContextManager(AbstractContextManager[_T_co], ContextDecorator, Generic[_T_co]):
-    # __init__ and all instance attributes are actually inherited from _GeneratorContextManagerBase
-    # _GeneratorContextManagerBase is more trouble than it's worth to include in the stub; see #6676
-    def __init__(self, func: Callable[..., Iterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
-    gen: Generator[_T_co, Any, Any]
-    func: Callable[..., Generator[_T_co, Any, Any]]
+class _GeneratorContextManagerBase(Generic[_G_co]):
+    # Ideally this would use ParamSpec, but that requires (*args, **kwargs), which this isn't. see #6676
+    def __init__(self, func: Callable[..., _G_co], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
+    gen: _G_co
+    func: Callable[..., _G_co]
     args: tuple[Any, ...]
     kwds: dict[str, Any]
+
+class _GeneratorContextManager(
+    _GeneratorContextManagerBase[Generator[_T_co, _SendT_contra, _ReturnT_co]],
+    AbstractContextManager[_T_co, bool | None],
+    ContextDecorator,
+):
     if sys.version_info >= (3, 9):
         def __exit__(
             self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
@@ -79,27 +96,22 @@ if sys.version_info >= (3, 10):
     _AF = TypeVar("_AF", bound=Callable[..., Awaitable[Any]])
 
     class AsyncContextDecorator:
+        def _recreate_cm(self) -> Self: ...
         def __call__(self, func: _AF) -> _AF: ...
 
-    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co], AsyncContextDecorator, Generic[_T_co]):
-        # __init__ and these attributes are actually defined in the base class _GeneratorContextManagerBase,
-        # which is more trouble than it's worth to include in the stub (see #6676)
-        def __init__(self, func: Callable[..., AsyncIterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
-        gen: AsyncGenerator[_T_co, Any]
-        func: Callable[..., AsyncGenerator[_T_co, Any]]
-        args: tuple[Any, ...]
-        kwds: dict[str, Any]
+    class _AsyncGeneratorContextManager(
+        _GeneratorContextManagerBase[AsyncGenerator[_T_co, _SendT_contra]],
+        AbstractAsyncContextManager[_T_co, bool | None],
+        AsyncContextDecorator,
+    ):
         async def __aexit__(
             self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
         ) -> bool | None: ...
 
 else:
-    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co], Generic[_T_co]):
-        def __init__(self, func: Callable[..., AsyncIterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
-        gen: AsyncGenerator[_T_co, Any]
-        func: Callable[..., AsyncGenerator[_T_co, Any]]
-        args: tuple[Any, ...]
-        kwds: dict[str, Any]
+    class _AsyncGeneratorContextManager(
+        _GeneratorContextManagerBase[AsyncGenerator[_T_co, _SendT_contra]], AbstractAsyncContextManager[_T_co, bool | None]
+    ):
         async def __aexit__(
             self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
         ) -> bool | None: ...
@@ -111,26 +123,27 @@ class _SupportsClose(Protocol):
 
 _SupportsCloseT = TypeVar("_SupportsCloseT", bound=_SupportsClose)
 
-class closing(AbstractContextManager[_SupportsCloseT]):
+class closing(AbstractContextManager[_SupportsCloseT, None]):
     def __init__(self, thing: _SupportsCloseT) -> None: ...
     def __exit__(self, *exc_info: Unused) -> None: ...
 
 if sys.version_info >= (3, 10):
     class _SupportsAclose(Protocol):
         def aclose(self) -> Awaitable[object]: ...
+
     _SupportsAcloseT = TypeVar("_SupportsAcloseT", bound=_SupportsAclose)
 
-    class aclosing(AbstractAsyncContextManager[_SupportsAcloseT]):
+    class aclosing(AbstractAsyncContextManager[_SupportsAcloseT, None]):
         def __init__(self, thing: _SupportsAcloseT) -> None: ...
         async def __aexit__(self, *exc_info: Unused) -> None: ...
 
-class suppress(AbstractContextManager[None]):
+class suppress(AbstractContextManager[None, bool]):
     def __init__(self, *exceptions: type[BaseException]) -> None: ...
     def __exit__(
         self, exctype: type[BaseException] | None, excinst: BaseException | None, exctb: TracebackType | None
     ) -> bool: ...
 
-class _RedirectStream(AbstractContextManager[_T_io]):
+class _RedirectStream(AbstractContextManager[_T_io, None]):
     def __init__(self, new_target: _T_io) -> None: ...
     def __exit__(
         self, exctype: type[BaseException] | None, excinst: BaseException | None, exctb: TracebackType | None
@@ -139,68 +152,66 @@ class _RedirectStream(AbstractContextManager[_T_io]):
 class redirect_stdout(_RedirectStream[_T_io]): ...
 class redirect_stderr(_RedirectStream[_T_io]): ...
 
-# In reality this is a subclass of `AbstractContextManager`;
-# see #7961 for why we don't do that in the stub
-class ExitStack(metaclass=abc.ABCMeta):
-    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
+class _BaseExitStack(Generic[_ExitT_co]):
+    def enter_context(self, cm: AbstractContextManager[_T, _ExitT_co]) -> _T: ...
     def push(self, exit: _CM_EF) -> _CM_EF: ...
-    def callback(self, __callback: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs) -> Callable[_P, _T]: ...
+    def callback(self, callback: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> Callable[_P, _T]: ...
     def pop_all(self) -> Self: ...
+
+# In reality this is a subclass of `AbstractContextManager`;
+# see #7961 for why we don't do that in the stub
+class ExitStack(_BaseExitStack[_ExitT_co], metaclass=abc.ABCMeta):
     def close(self) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(
-        self, __exc_type: type[BaseException] | None, __exc_value: BaseException | None, __traceback: TracebackType | None
-    ) -> bool: ...
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
+    ) -> _ExitT_co: ...
 
 _ExitCoroFunc: TypeAlias = Callable[
     [type[BaseException] | None, BaseException | None, TracebackType | None], Awaitable[bool | None]
 ]
-_ACM_EF = TypeVar("_ACM_EF", bound=AbstractAsyncContextManager[Any] | _ExitCoroFunc)
+_ACM_EF = TypeVar("_ACM_EF", bound=AbstractAsyncContextManager[Any, Any] | _ExitCoroFunc)
 
 # In reality this is a subclass of `AbstractAsyncContextManager`;
 # see #7961 for why we don't do that in the stub
-class AsyncExitStack(metaclass=abc.ABCMeta):
-    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
-    async def enter_async_context(self, cm: AbstractAsyncContextManager[_T]) -> _T: ...
-    def push(self, exit: _CM_EF) -> _CM_EF: ...
+class AsyncExitStack(_BaseExitStack[_ExitT_co], metaclass=abc.ABCMeta):
+    async def enter_async_context(self, cm: AbstractAsyncContextManager[_T, _ExitT_co]) -> _T: ...
     def push_async_exit(self, exit: _ACM_EF) -> _ACM_EF: ...
-    def callback(self, __callback: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs) -> Callable[_P, _T]: ...
     def push_async_callback(
-        self, __callback: Callable[_P, Awaitable[_T]], *args: _P.args, **kwds: _P.kwargs
+        self, callback: Callable[_P, Awaitable[_T]], /, *args: _P.args, **kwds: _P.kwargs
     ) -> Callable[_P, Awaitable[_T]]: ...
-    def pop_all(self) -> Self: ...
     async def aclose(self) -> None: ...
     async def __aenter__(self) -> Self: ...
     async def __aexit__(
-        self, __exc_type: type[BaseException] | None, __exc_value: BaseException | None, __traceback: TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
     ) -> bool: ...
 
 if sys.version_info >= (3, 10):
-    class nullcontext(AbstractContextManager[_T], AbstractAsyncContextManager[_T]):
+    class nullcontext(AbstractContextManager[_T, None], AbstractAsyncContextManager[_T, None]):
         enter_result: _T
         @overload
         def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
         @overload
-        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...
+        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]  #11780
         def __enter__(self) -> _T: ...
         def __exit__(self, *exctype: Unused) -> None: ...
         async def __aenter__(self) -> _T: ...
         async def __aexit__(self, *exctype: Unused) -> None: ...
 
 else:
-    class nullcontext(AbstractContextManager[_T]):
+    class nullcontext(AbstractContextManager[_T, None]):
         enter_result: _T
         @overload
         def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
         @overload
-        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...
+        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]  #11780
         def __enter__(self) -> _T: ...
         def __exit__(self, *exctype: Unused) -> None: ...
 
 if sys.version_info >= (3, 11):
     _T_fd_or_any_path = TypeVar("_T_fd_or_any_path", bound=FileDescriptorOrPath)
 
-    class chdir(AbstractContextManager[None], Generic[_T_fd_or_any_path]):
+    class chdir(AbstractContextManager[None, None], Generic[_T_fd_or_any_path]):
         path: _T_fd_or_any_path
         def __init__(self, path: _T_fd_or_any_path) -> None: ...
         def __enter__(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/contextvars.pyi b/mypy/typeshed/stdlib/contextvars.pyi
index ef6e2700e667..22dc33006e9d 100644
--- a/mypy/typeshed/stdlib/contextvars.pyi
+++ b/mypy/typeshed/stdlib/contextvars.pyi
@@ -1,62 +1,3 @@
-import sys
-from collections.abc import Callable, Iterator, Mapping
-from typing import Any, ClassVar, Generic, TypeVar, overload
-from typing_extensions import ParamSpec, final
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
+from _contextvars import Context as Context, ContextVar as ContextVar, Token as Token, copy_context as copy_context
 
 __all__ = ("Context", "ContextVar", "Token", "copy_context")
-
-_T = TypeVar("_T")
-_D = TypeVar("_D")
-_P = ParamSpec("_P")
-
-@final
-class ContextVar(Generic[_T]):
-    @overload
-    def __init__(self, name: str) -> None: ...
-    @overload
-    def __init__(self, name: str, *, default: _T) -> None: ...
-    @property
-    def name(self) -> str: ...
-    @overload
-    def get(self) -> _T: ...
-    if sys.version_info >= (3, 8):
-        @overload
-        def get(self, default: _D | _T) -> _D | _T: ...
-    else:
-        @overload
-        def get(self, __default: _D | _T) -> _D | _T: ...
-
-    def set(self, __value: _T) -> Token[_T]: ...
-    def reset(self, __token: Token[_T]) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-@final
-class Token(Generic[_T]):
-    @property
-    def var(self) -> ContextVar[_T]: ...
-    @property
-    def old_value(self) -> Any: ...  # returns either _T or MISSING, but that's hard to express
-    MISSING: ClassVar[object]
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-def copy_context() -> Context: ...
-
-# It doesn't make sense to make this generic, because for most Contexts each ContextVar will have
-# a different value.
-@final
-class Context(Mapping[ContextVar[Any], Any]):
-    def __init__(self) -> None: ...
-    @overload
-    def get(self, __key: ContextVar[_T]) -> _T | None: ...
-    @overload
-    def get(self, __key: ContextVar[_T], __default: _D) -> _T | _D: ...
-    def run(self, callable: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> _T: ...
-    def copy(self) -> Context: ...
-    def __getitem__(self, __key: ContextVar[_T]) -> _T: ...
-    def __iter__(self) -> Iterator[ContextVar[Any]]: ...
-    def __len__(self) -> int: ...
diff --git a/mypy/typeshed/stdlib/copy.pyi b/mypy/typeshed/stdlib/copy.pyi
index 8a2dcc508e5d..2cceec6a2250 100644
--- a/mypy/typeshed/stdlib/copy.pyi
+++ b/mypy/typeshed/stdlib/copy.pyi
@@ -1,8 +1,15 @@
-from typing import Any, TypeVar
+import sys
+from typing import Any, Protocol, TypeVar
+from typing_extensions import Self
 
 __all__ = ["Error", "copy", "deepcopy"]
 
 _T = TypeVar("_T")
+_SR = TypeVar("_SR", bound=_SupportsReplace)
+
+class _SupportsReplace(Protocol):
+    # In reality doesn't support args, but there's no other great way to express this.
+    def __replace__(self, *args: Any, **kwargs: Any) -> Self: ...
 
 # None in CPython but non-None in Jython
 PyStringMap: Any
@@ -11,6 +18,10 @@ PyStringMap: Any
 def deepcopy(x: _T, memo: dict[int, Any] | None = None, _nil: Any = []) -> _T: ...
 def copy(x: _T) -> _T: ...
 
+if sys.version_info >= (3, 13):
+    __all__ += ["replace"]
+    def replace(obj: _SR, /, **changes: Any) -> _SR: ...
+
 class Error(Exception): ...
 
 error = Error
diff --git a/mypy/typeshed/stdlib/crypt.pyi b/mypy/typeshed/stdlib/crypt.pyi
index 1ad0a384eae7..bd22b5f8daba 100644
--- a/mypy/typeshed/stdlib/crypt.pyi
+++ b/mypy/typeshed/stdlib/crypt.pyi
@@ -1,12 +1,20 @@
 import sys
+from typing import Final, NamedTuple, type_check_only
 
 if sys.platform != "win32":
-    class _Method: ...
-    METHOD_CRYPT: _Method
-    METHOD_MD5: _Method
-    METHOD_SHA256: _Method
-    METHOD_SHA512: _Method
-    METHOD_BLOWFISH: _Method
+    @type_check_only
+    class _MethodBase(NamedTuple):
+        name: str
+        ident: str | None
+        salt_chars: int
+        total_size: int
+
+    class _Method(_MethodBase): ...
+    METHOD_CRYPT: Final[_Method]
+    METHOD_MD5: Final[_Method]
+    METHOD_SHA256: Final[_Method]
+    METHOD_SHA512: Final[_Method]
+    METHOD_BLOWFISH: Final[_Method]
     methods: list[_Method]
     def mksalt(method: _Method | None = None, *, rounds: int | None = None) -> str: ...
     def crypt(word: str, salt: str | _Method | None = None) -> str: ...
diff --git a/mypy/typeshed/stdlib/csv.pyi b/mypy/typeshed/stdlib/csv.pyi
index 59f2e7a3c96b..ef93129d6546 100644
--- a/mypy/typeshed/stdlib/csv.pyi
+++ b/mypy/typeshed/stdlib/csv.pyi
@@ -1,18 +1,13 @@
 import sys
-
-# actually csv.Dialect is a different class to _csv.Dialect at runtime, but for typing purposes, they're identical
 from _csv import (
     QUOTE_ALL as QUOTE_ALL,
     QUOTE_MINIMAL as QUOTE_MINIMAL,
     QUOTE_NONE as QUOTE_NONE,
     QUOTE_NONNUMERIC as QUOTE_NONNUMERIC,
-    Dialect as Dialect,
     Error as Error,
     __version__ as __version__,
     _DialectLike,
     _QuotingType,
-    _reader,
-    _writer,
     field_size_limit as field_size_limit,
     get_dialect as get_dialect,
     list_dialects as list_dialects,
@@ -21,15 +16,18 @@ from _csv import (
     unregister_dialect as unregister_dialect,
     writer as writer,
 )
-from _typeshed import SupportsWrite
-from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
-from typing import Any, Generic, TypeVar, overload
-from typing_extensions import Literal, Self
 
-if sys.version_info >= (3, 8):
-    from builtins import dict as _DictReadMapping
+if sys.version_info >= (3, 12):
+    from _csv import QUOTE_NOTNULL as QUOTE_NOTNULL, QUOTE_STRINGS as QUOTE_STRINGS
+if sys.version_info >= (3, 10):
+    from _csv import Reader, Writer
 else:
-    from collections import OrderedDict as _DictReadMapping
+    from _csv import _reader as Reader, _writer as Writer
+
+from _typeshed import SupportsWrite
+from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
+from typing import Any, Generic, Literal, TypeVar, overload
+from typing_extensions import Self
 
 if sys.version_info >= (3, 12):
     from types import GenericAlias
@@ -41,7 +39,6 @@ __all__ = [
     "QUOTE_NONE",
     "Error",
     "Dialect",
-    "__doc__",
     "excel",
     "excel_tab",
     "field_size_limit",
@@ -52,23 +49,37 @@ __all__ = [
     "list_dialects",
     "Sniffer",
     "unregister_dialect",
-    "__version__",
     "DictReader",
     "DictWriter",
     "unix_dialect",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["QUOTE_STRINGS", "QUOTE_NOTNULL"]
+if sys.version_info < (3, 13):
+    __all__ += ["__doc__", "__version__"]
 
 _T = TypeVar("_T")
 
+class Dialect:
+    delimiter: str
+    quotechar: str | None
+    escapechar: str | None
+    doublequote: bool
+    skipinitialspace: bool
+    lineterminator: str
+    quoting: _QuotingType
+    strict: bool
+    def __init__(self) -> None: ...
+
 class excel(Dialect): ...
 class excel_tab(excel): ...
 class unix_dialect(Dialect): ...
 
-class DictReader(Generic[_T], Iterator[_DictReadMapping[_T | Any, str | Any]]):
+class DictReader(Iterator[dict[_T | Any, str | Any]], Generic[_T]):
     fieldnames: Sequence[_T] | None
-    restkey: str | None
-    restval: str | None
-    reader: _reader
+    restkey: _T | None
+    restval: str | Any | None
+    reader: Reader
     dialect: _DialectLike
     line_num: int
     @overload
@@ -76,8 +87,8 @@ class DictReader(Generic[_T], Iterator[_DictReadMapping[_T | Any, str | Any]]):
         self,
         f: Iterable[str],
         fieldnames: Sequence[_T],
-        restkey: str | None = None,
-        restval: str | None = None,
+        restkey: _T | None = None,
+        restval: str | Any | None = None,
         dialect: _DialectLike = "excel",
         *,
         delimiter: str = ",",
@@ -108,15 +119,15 @@ class DictReader(Generic[_T], Iterator[_DictReadMapping[_T | Any, str | Any]]):
         strict: bool = False,
     ) -> None: ...
     def __iter__(self) -> Self: ...
-    def __next__(self) -> _DictReadMapping[_T | Any, str | Any]: ...
+    def __next__(self) -> dict[_T | Any, str | Any]: ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class DictWriter(Generic[_T]):
     fieldnames: Collection[_T]
     restval: Any | None
     extrasaction: Literal["raise", "ignore"]
-    writer: _writer
+    writer: Writer
     def __init__(
         self,
         f: SupportsWrite[str],
@@ -134,15 +145,11 @@ class DictWriter(Generic[_T]):
         quoting: _QuotingType = 0,
         strict: bool = False,
     ) -> None: ...
-    if sys.version_info >= (3, 8):
-        def writeheader(self) -> Any: ...
-    else:
-        def writeheader(self) -> None: ...
-
+    def writeheader(self) -> Any: ...
     def writerow(self, rowdict: Mapping[_T, Any]) -> Any: ...
     def writerows(self, rowdicts: Iterable[Mapping[_T, Any]]) -> None: ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Sniffer:
     preferred: list[str]
diff --git a/mypy/typeshed/stdlib/ctypes/__init__.pyi b/mypy/typeshed/stdlib/ctypes/__init__.pyi
index 7a185a5b523e..4f44975d657f 100644
--- a/mypy/typeshed/stdlib/ctypes/__init__.pyi
+++ b/mypy/typeshed/stdlib/ctypes/__init__.pyi
@@ -3,7 +3,6 @@ from _ctypes import (
     POINTER as POINTER,
     RTLD_GLOBAL as RTLD_GLOBAL,
     RTLD_LOCAL as RTLD_LOCAL,
-    ArgumentError as ArgumentError,
     Array as Array,
     CFuncPtr as _CFuncPtr,
     Structure as Structure,
@@ -11,13 +10,11 @@ from _ctypes import (
     _CanCastTo as _CanCastTo,
     _CArgObject as _CArgObject,
     _CData as _CData,
-    _CDataMeta as _CDataMeta,
+    _CDataType as _CDataType,
     _CField as _CField,
     _Pointer as _Pointer,
     _PointerLike as _PointerLike,
     _SimpleCData as _SimpleCData,
-    _StructUnionBase as _StructUnionBase,
-    _StructUnionMeta as _StructUnionMeta,
     addressof as addressof,
     alignment as alignment,
     byref as byref,
@@ -27,46 +24,60 @@ from _ctypes import (
     set_errno as set_errno,
     sizeof as sizeof,
 )
-from typing import Any, ClassVar, Generic, TypeVar
-from typing_extensions import TypeAlias
+from _typeshed import StrPath
+from ctypes._endian import BigEndianStructure as BigEndianStructure, LittleEndianStructure as LittleEndianStructure
+from typing import Any, ClassVar, Generic, TypeVar, type_check_only
+from typing_extensions import Self, TypeAlias, deprecated
 
 if sys.platform == "win32":
     from _ctypes import FormatError as FormatError, get_last_error as get_last_error, set_last_error as set_last_error
 
+if sys.version_info >= (3, 11):
+    from ctypes._endian import BigEndianUnion as BigEndianUnion, LittleEndianUnion as LittleEndianUnion
+
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 
 _T = TypeVar("_T")
 _DLLT = TypeVar("_DLLT", bound=CDLL)
+_CT = TypeVar("_CT", bound=_CData)
 
 DEFAULT_MODE: int
 
+class ArgumentError(Exception): ...
+
+# defined within CDLL.__init__
+# Runtime name is ctypes.CDLL.__init__.<locals>._FuncPtr
+@type_check_only
+class _CDLLFuncPointer(_CFuncPtr):
+    _flags_: ClassVar[int]
+    _restype_: ClassVar[type[_CDataType]]
+
+# Not a real class; _CDLLFuncPointer with a __name__ set on it.
+@type_check_only
+class _NamedFuncPointer(_CDLLFuncPointer):
+    __name__: str
+
+if sys.version_info >= (3, 12):
+    _NameTypes: TypeAlias = StrPath | None
+else:
+    _NameTypes: TypeAlias = str | None
+
 class CDLL:
     _func_flags_: ClassVar[int]
-    _func_restype_: ClassVar[_CData]
+    _func_restype_: ClassVar[type[_CDataType]]
     _name: str
     _handle: int
-    _FuncPtr: type[_FuncPointer]
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            name: str | None,
-            mode: int = ...,
-            handle: int | None = None,
-            use_errno: bool = False,
-            use_last_error: bool = False,
-            winmode: int | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            name: str | None,
-            mode: int = ...,
-            handle: int | None = None,
-            use_errno: bool = False,
-            use_last_error: bool = False,
-        ) -> None: ...
-
+    _FuncPtr: type[_CDLLFuncPointer]
+    def __init__(
+        self,
+        name: _NameTypes,
+        mode: int = ...,
+        handle: int | None = None,
+        use_errno: bool = False,
+        use_last_error: bool = False,
+        winmode: int | None = None,
+    ) -> None: ...
     def __getattr__(self, name: str) -> _NamedFuncPointer: ...
     def __getitem__(self, name_or_ordinal: str) -> _NamedFuncPointer: ...
 
@@ -82,7 +93,7 @@ class LibraryLoader(Generic[_DLLT]):
     def __getitem__(self, name: str) -> _DLLT: ...
     def LoadLibrary(self, name: str) -> _DLLT: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 cdll: LibraryLoader[CDLL]
 if sys.platform == "win32":
@@ -91,21 +102,36 @@ if sys.platform == "win32":
 pydll: LibraryLoader[PyDLL]
 pythonapi: PyDLL
 
-class _FuncPointer(_CFuncPtr): ...
+# Class definition within CFUNCTYPE / WINFUNCTYPE / PYFUNCTYPE
+# Names at runtime are
+# ctypes.CFUNCTYPE.<locals>.CFunctionType
+# ctypes.WINFUNCTYPE.<locals>.WinFunctionType
+# ctypes.PYFUNCTYPE.<locals>.CFunctionType
+@type_check_only
+class _CFunctionType(_CFuncPtr):
+    _argtypes_: ClassVar[list[type[_CData | _CDataType]]]
+    _restype_: ClassVar[type[_CData | _CDataType] | None]
+    _flags_: ClassVar[int]
 
-class _NamedFuncPointer(_FuncPointer):
-    __name__: str
+# Alias for either function pointer type
+_FuncPointer: TypeAlias = _CDLLFuncPointer | _CFunctionType  # noqa: Y047  # not used here
 
 def CFUNCTYPE(
-    restype: type[_CData] | None, *argtypes: type[_CData], use_errno: bool = ..., use_last_error: bool = ...
-) -> type[_FuncPointer]: ...
+    restype: type[_CData | _CDataType] | None,
+    *argtypes: type[_CData | _CDataType],
+    use_errno: bool = False,
+    use_last_error: bool = False,
+) -> type[_CFunctionType]: ...
 
 if sys.platform == "win32":
     def WINFUNCTYPE(
-        restype: type[_CData] | None, *argtypes: type[_CData], use_errno: bool = ..., use_last_error: bool = ...
-    ) -> type[_FuncPointer]: ...
+        restype: type[_CData | _CDataType] | None,
+        *argtypes: type[_CData | _CDataType],
+        use_errno: bool = False,
+        use_last_error: bool = False,
+    ) -> type[_CFunctionType]: ...
 
-def PYFUNCTYPE(restype: type[_CData] | None, *argtypes: type[_CData]) -> type[_FuncPointer]: ...
+def PYFUNCTYPE(restype: type[_CData | _CDataType] | None, *argtypes: type[_CData | _CDataType]) -> type[_CFunctionType]: ...
 
 # Any type that can be implicitly converted to c_void_p when passed as a C function argument.
 # (bytes is not included here, see below.)
@@ -118,26 +144,52 @@ _CVoidConstPLike: TypeAlias = _CVoidPLike | bytes
 
 _CastT = TypeVar("_CastT", bound=_CanCastTo)
 
-def cast(obj: _CData | _CArgObject | int, typ: type[_CastT]) -> _CastT: ...
+def cast(obj: _CData | _CDataType | _CArgObject | int, typ: type[_CastT]) -> _CastT: ...
 def create_string_buffer(init: int | bytes, size: int | None = None) -> Array[c_char]: ...
 
 c_buffer = create_string_buffer
 
 def create_unicode_buffer(init: int | str, size: int | None = None) -> Array[c_wchar]: ...
+@deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
+def SetPointerType(
+    pointer: type[_Pointer[Any]], cls: Any  # noqa: F811  # Redefinition of unused `pointer` from line 22
+) -> None: ...
+def ARRAY(typ: _CT, len: int) -> Array[_CT]: ...  # Soft Deprecated, no plans to remove
 
 if sys.platform == "win32":
     def DllCanUnloadNow() -> int: ...
     def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ...  # TODO not documented
-    def GetLastError() -> int: ...
 
-def memmove(dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> int: ...
-def memset(dst: _CVoidPLike, c: int, count: int) -> int: ...
-def string_at(address: _CVoidConstPLike, size: int = -1) -> bytes: ...
+    # Actually just an instance of _NamedFuncPointer (aka _CDLLFuncPointer),
+    # but we want to set a more specific __call__
+    @type_check_only
+    class _GetLastErrorFunctionType(_NamedFuncPointer):
+        def __call__(self) -> int: ...
+
+    GetLastError: _GetLastErrorFunctionType
+
+# Actually just an instance of _CFunctionType, but we want to set a more
+# specific __call__.
+@type_check_only
+class _MemmoveFunctionType(_CFunctionType):
+    def __call__(self, dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> int: ...
+
+memmove: _MemmoveFunctionType
+
+# Actually just an instance of _CFunctionType, but we want to set a more
+# specific __call__.
+@type_check_only
+class _MemsetFunctionType(_CFunctionType):
+    def __call__(self, dst: _CVoidPLike, c: int, count: int) -> int: ...
+
+memset: _MemsetFunctionType
+
+def string_at(ptr: _CVoidConstPLike, size: int = -1) -> bytes: ...
 
 if sys.platform == "win32":
     def WinError(code: int | None = None, descr: str | None = None) -> OSError: ...
 
-def wstring_at(address: _CVoidConstPLike, size: int = -1) -> str: ...
+def wstring_at(ptr: _CVoidConstPLike, size: int = -1) -> str: ...
 
 class c_byte(_SimpleCData[int]): ...
 
@@ -146,34 +198,50 @@ class c_char(_SimpleCData[bytes]):
 
 class c_char_p(_PointerLike, _SimpleCData[bytes | None]):
     def __init__(self, value: int | bytes | None = ...) -> None: ...
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
 
 class c_double(_SimpleCData[float]): ...
-class c_longdouble(_SimpleCData[float]): ...
+class c_longdouble(_SimpleCData[float]): ...  # can be an alias for c_double
 class c_float(_SimpleCData[float]): ...
-class c_int(_SimpleCData[int]): ...
-class c_int8(_SimpleCData[int]): ...
-class c_int16(_SimpleCData[int]): ...
-class c_int32(_SimpleCData[int]): ...
-class c_int64(_SimpleCData[int]): ...
+class c_int(_SimpleCData[int]): ...  # can be an alias for c_long
 class c_long(_SimpleCData[int]): ...
-class c_longlong(_SimpleCData[int]): ...
+class c_longlong(_SimpleCData[int]): ...  # can be an alias for c_long
 class c_short(_SimpleCData[int]): ...
-class c_size_t(_SimpleCData[int]): ...
-class c_ssize_t(_SimpleCData[int]): ...
+class c_size_t(_SimpleCData[int]): ...  # alias for c_uint, c_ulong, or c_ulonglong
+class c_ssize_t(_SimpleCData[int]): ...  # alias for c_int, c_long, or c_longlong
 class c_ubyte(_SimpleCData[int]): ...
-class c_uint(_SimpleCData[int]): ...
-class c_uint8(_SimpleCData[int]): ...
-class c_uint16(_SimpleCData[int]): ...
-class c_uint32(_SimpleCData[int]): ...
-class c_uint64(_SimpleCData[int]): ...
+class c_uint(_SimpleCData[int]): ...  # can be an alias for c_ulong
 class c_ulong(_SimpleCData[int]): ...
-class c_ulonglong(_SimpleCData[int]): ...
+class c_ulonglong(_SimpleCData[int]): ...  # can be an alias for c_ulong
 class c_ushort(_SimpleCData[int]): ...
-class c_void_p(_PointerLike, _SimpleCData[int | None]): ...
+
+class c_void_p(_PointerLike, _SimpleCData[int | None]):
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
+
+c_voidp = c_void_p  # backwards compatibility (to a bug)
+
 class c_wchar(_SimpleCData[str]): ...
 
+c_int8 = c_byte
+
+# these are actually dynamic aliases for c_short, c_int, c_long, or c_longlong
+class c_int16(_SimpleCData[int]): ...
+class c_int32(_SimpleCData[int]): ...
+class c_int64(_SimpleCData[int]): ...
+
+c_uint8 = c_ubyte
+
+# these are actually dynamic aliases for c_ushort, c_uint, c_ulong, or c_ulonglong
+class c_uint16(_SimpleCData[int]): ...
+class c_uint32(_SimpleCData[int]): ...
+class c_uint64(_SimpleCData[int]): ...
+
 class c_wchar_p(_PointerLike, _SimpleCData[str | None]):
     def __init__(self, value: int | str | None = ...) -> None: ...
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
 
 class c_bool(_SimpleCData[bool]):
     def __init__(self, value: bool = ...) -> None: ...
@@ -181,6 +249,15 @@ class c_bool(_SimpleCData[bool]):
 if sys.platform == "win32":
     class HRESULT(_SimpleCData[int]): ...  # TODO undocumented
 
+if sys.version_info >= (3, 12):
+    # At runtime, this is an alias for either c_int32 or c_int64,
+    # which are themselves an alias for one of c_short, c_int, c_long, or c_longlong
+    # This covers all our bases.
+    c_time_t: type[c_int32 | c_int64 | c_short | c_int | c_long | c_longlong]
+
 class py_object(_CanCastTo, _SimpleCData[_T]): ...
-class BigEndianStructure(Structure): ...
-class LittleEndianStructure(Structure): ...
+
+if sys.version_info >= (3, 14):
+    class c_float_complex(_SimpleCData[complex]): ...
+    class c_double_complex(_SimpleCData[complex]): ...
+    class c_longdouble_complex(_SimpleCData[complex]): ...
diff --git a/mypy/typeshed/stdlib/ctypes/_endian.pyi b/mypy/typeshed/stdlib/ctypes/_endian.pyi
new file mode 100644
index 000000000000..144f5ba5dd40
--- /dev/null
+++ b/mypy/typeshed/stdlib/ctypes/_endian.pyi
@@ -0,0 +1,12 @@
+import sys
+from ctypes import Structure, Union
+
+# At runtime, the native endianness is an alias for Structure,
+# while the other is a subclass with a metaclass added in.
+class BigEndianStructure(Structure): ...
+class LittleEndianStructure(Structure): ...
+
+# Same thing for these: one is an alias of Union at runtime
+if sys.version_info >= (3, 11):
+    class BigEndianUnion(Union): ...
+    class LittleEndianUnion(Union): ...
diff --git a/mypy/typeshed/stdlib/ctypes/macholib/__init__.pyi b/mypy/typeshed/stdlib/ctypes/macholib/__init__.pyi
new file mode 100644
index 000000000000..bda5b5a7f4cc
--- /dev/null
+++ b/mypy/typeshed/stdlib/ctypes/macholib/__init__.pyi
@@ -0,0 +1 @@
+__version__: str
diff --git a/mypy/typeshed/stdlib/ctypes/macholib/dyld.pyi b/mypy/typeshed/stdlib/ctypes/macholib/dyld.pyi
new file mode 100644
index 000000000000..c7e94daa2149
--- /dev/null
+++ b/mypy/typeshed/stdlib/ctypes/macholib/dyld.pyi
@@ -0,0 +1,8 @@
+from collections.abc import Mapping
+from ctypes.macholib.dylib import dylib_info as dylib_info
+from ctypes.macholib.framework import framework_info as framework_info
+
+__all__ = ["dyld_find", "framework_find", "framework_info", "dylib_info"]
+
+def dyld_find(name: str, executable_path: str | None = None, env: Mapping[str, str] | None = None) -> str: ...
+def framework_find(fn: str, executable_path: str | None = None, env: Mapping[str, str] | None = None) -> str: ...
diff --git a/mypy/typeshed/stdlib/ctypes/macholib/dylib.pyi b/mypy/typeshed/stdlib/ctypes/macholib/dylib.pyi
new file mode 100644
index 000000000000..95945edfd155
--- /dev/null
+++ b/mypy/typeshed/stdlib/ctypes/macholib/dylib.pyi
@@ -0,0 +1,14 @@
+from typing import TypedDict, type_check_only
+
+__all__ = ["dylib_info"]
+
+# Actual result is produced by re.match.groupdict()
+@type_check_only
+class _DylibInfo(TypedDict):
+    location: str
+    name: str
+    shortname: str
+    version: str | None
+    suffix: str | None
+
+def dylib_info(filename: str) -> _DylibInfo | None: ...
diff --git a/mypy/typeshed/stdlib/ctypes/macholib/framework.pyi b/mypy/typeshed/stdlib/ctypes/macholib/framework.pyi
new file mode 100644
index 000000000000..e92bf3700e84
--- /dev/null
+++ b/mypy/typeshed/stdlib/ctypes/macholib/framework.pyi
@@ -0,0 +1,14 @@
+from typing import TypedDict, type_check_only
+
+__all__ = ["framework_info"]
+
+# Actual result is produced by re.match.groupdict()
+@type_check_only
+class _FrameworkInfo(TypedDict):
+    location: str
+    name: str
+    shortname: str
+    version: str | None
+    suffix: str | None
+
+def framework_info(filename: str) -> _FrameworkInfo | None: ...
diff --git a/mypy/typeshed/stdlib/ctypes/util.pyi b/mypy/typeshed/stdlib/ctypes/util.pyi
index c0274f5e539b..316f7a2b3e2f 100644
--- a/mypy/typeshed/stdlib/ctypes/util.pyi
+++ b/mypy/typeshed/stdlib/ctypes/util.pyi
@@ -4,3 +4,5 @@ def find_library(name: str) -> str | None: ...
 
 if sys.platform == "win32":
     def find_msvcrt() -> str | None: ...
+
+def test() -> None: ...
diff --git a/mypy/typeshed/stdlib/ctypes/wintypes.pyi b/mypy/typeshed/stdlib/ctypes/wintypes.pyi
index 3bd27934750a..e938d8f22957 100644
--- a/mypy/typeshed/stdlib/ctypes/wintypes.pyi
+++ b/mypy/typeshed/stdlib/ctypes/wintypes.pyi
@@ -1,3 +1,4 @@
+from _ctypes import _CArgObject, _CField
 from ctypes import (
     Array,
     Structure,
@@ -20,7 +21,8 @@ from ctypes import (
     c_wchar,
     c_wchar_p,
 )
-from typing_extensions import TypeAlias
+from typing import Any, TypeVar
+from typing_extensions import Self, TypeAlias
 
 BYTE = c_byte
 WORD = c_ushort
@@ -101,39 +103,42 @@ HWND = HANDLE
 SC_HANDLE = HANDLE
 SERVICE_STATUS_HANDLE = HANDLE
 
+_CIntLikeT = TypeVar("_CIntLikeT", bound=_SimpleCData[int])
+_CIntLikeField: TypeAlias = _CField[_CIntLikeT, int, _CIntLikeT | int]
+
 class RECT(Structure):
-    left: LONG
-    top: LONG
-    right: LONG
-    bottom: LONG
+    left: _CIntLikeField[LONG]
+    top: _CIntLikeField[LONG]
+    right: _CIntLikeField[LONG]
+    bottom: _CIntLikeField[LONG]
 
 RECTL = RECT
 _RECTL = RECT
 tagRECT = RECT
 
 class _SMALL_RECT(Structure):
-    Left: SHORT
-    Top: SHORT
-    Right: SHORT
-    Bottom: SHORT
+    Left: _CIntLikeField[SHORT]
+    Top: _CIntLikeField[SHORT]
+    Right: _CIntLikeField[SHORT]
+    Bottom: _CIntLikeField[SHORT]
 
 SMALL_RECT = _SMALL_RECT
 
 class _COORD(Structure):
-    X: SHORT
-    Y: SHORT
+    X: _CIntLikeField[SHORT]
+    Y: _CIntLikeField[SHORT]
 
 class POINT(Structure):
-    x: LONG
-    y: LONG
+    x: _CIntLikeField[LONG]
+    y: _CIntLikeField[LONG]
 
 POINTL = POINT
 _POINTL = POINT
 tagPOINT = POINT
 
 class SIZE(Structure):
-    cx: LONG
-    cy: LONG
+    cx: _CIntLikeField[LONG]
+    cy: _CIntLikeField[LONG]
 
 SIZEL = SIZE
 tagSIZE = SIZE
@@ -141,95 +146,159 @@ tagSIZE = SIZE
 def RGB(red: int, green: int, blue: int) -> int: ...
 
 class FILETIME(Structure):
-    dwLowDateTime: DWORD
-    dwHighDateTime: DWORD
+    dwLowDateTime: _CIntLikeField[DWORD]
+    dwHighDateTime: _CIntLikeField[DWORD]
 
 _FILETIME = FILETIME
 
 class MSG(Structure):
-    hWnd: HWND
-    message: UINT
-    wParam: WPARAM
-    lParam: LPARAM
-    time: DWORD
-    pt: POINT
+    hWnd: _CField[HWND, int | None, HWND | int | None]
+    message: _CIntLikeField[UINT]
+    wParam: _CIntLikeField[WPARAM]
+    lParam: _CIntLikeField[LPARAM]
+    time: _CIntLikeField[DWORD]
+    pt: _CField[POINT, POINT, POINT]
 
 tagMSG = MSG
 MAX_PATH: int
 
 class WIN32_FIND_DATAA(Structure):
-    dwFileAttributes: DWORD
-    ftCreationTime: FILETIME
-    ftLastAccessTime: FILETIME
-    ftLastWriteTime: FILETIME
-    nFileSizeHigh: DWORD
-    nFileSizeLow: DWORD
-    dwReserved0: DWORD
-    dwReserved1: DWORD
-    cFileName: Array[CHAR]
-    cAlternateFileName: Array[CHAR]
+    dwFileAttributes: _CIntLikeField[DWORD]
+    ftCreationTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastAccessTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastWriteTime: _CField[FILETIME, FILETIME, FILETIME]
+    nFileSizeHigh: _CIntLikeField[DWORD]
+    nFileSizeLow: _CIntLikeField[DWORD]
+    dwReserved0: _CIntLikeField[DWORD]
+    dwReserved1: _CIntLikeField[DWORD]
+    cFileName: _CField[Array[CHAR], bytes, bytes]
+    cAlternateFileName: _CField[Array[CHAR], bytes, bytes]
 
 class WIN32_FIND_DATAW(Structure):
-    dwFileAttributes: DWORD
-    ftCreationTime: FILETIME
-    ftLastAccessTime: FILETIME
-    ftLastWriteTime: FILETIME
-    nFileSizeHigh: DWORD
-    nFileSizeLow: DWORD
-    dwReserved0: DWORD
-    dwReserved1: DWORD
-    cFileName: Array[WCHAR]
-    cAlternateFileName: Array[WCHAR]
-
-# These pointer type definitions use _Pointer[...] instead of POINTER(...), to allow them
-# to be used in type annotations.
-PBOOL: TypeAlias = _Pointer[BOOL]
-LPBOOL: TypeAlias = _Pointer[BOOL]
-PBOOLEAN: TypeAlias = _Pointer[BOOLEAN]
-PBYTE: TypeAlias = _Pointer[BYTE]
-LPBYTE: TypeAlias = _Pointer[BYTE]
-PCHAR: TypeAlias = _Pointer[CHAR]
-LPCOLORREF: TypeAlias = _Pointer[COLORREF]
-PDWORD: TypeAlias = _Pointer[DWORD]
-LPDWORD: TypeAlias = _Pointer[DWORD]
-PFILETIME: TypeAlias = _Pointer[FILETIME]
-LPFILETIME: TypeAlias = _Pointer[FILETIME]
-PFLOAT: TypeAlias = _Pointer[FLOAT]
-PHANDLE: TypeAlias = _Pointer[HANDLE]
-LPHANDLE: TypeAlias = _Pointer[HANDLE]
-PHKEY: TypeAlias = _Pointer[HKEY]
-LPHKL: TypeAlias = _Pointer[HKL]
-PINT: TypeAlias = _Pointer[INT]
-LPINT: TypeAlias = _Pointer[INT]
-PLARGE_INTEGER: TypeAlias = _Pointer[LARGE_INTEGER]
-PLCID: TypeAlias = _Pointer[LCID]
-PLONG: TypeAlias = _Pointer[LONG]
-LPLONG: TypeAlias = _Pointer[LONG]
-PMSG: TypeAlias = _Pointer[MSG]
-LPMSG: TypeAlias = _Pointer[MSG]
-PPOINT: TypeAlias = _Pointer[POINT]
-LPPOINT: TypeAlias = _Pointer[POINT]
-PPOINTL: TypeAlias = _Pointer[POINTL]
-PRECT: TypeAlias = _Pointer[RECT]
-LPRECT: TypeAlias = _Pointer[RECT]
-PRECTL: TypeAlias = _Pointer[RECTL]
-LPRECTL: TypeAlias = _Pointer[RECTL]
-LPSC_HANDLE: TypeAlias = _Pointer[SC_HANDLE]
-PSHORT: TypeAlias = _Pointer[SHORT]
-PSIZE: TypeAlias = _Pointer[SIZE]
-LPSIZE: TypeAlias = _Pointer[SIZE]
-PSIZEL: TypeAlias = _Pointer[SIZEL]
-LPSIZEL: TypeAlias = _Pointer[SIZEL]
-PSMALL_RECT: TypeAlias = _Pointer[SMALL_RECT]
-PUINT: TypeAlias = _Pointer[UINT]
-LPUINT: TypeAlias = _Pointer[UINT]
-PULARGE_INTEGER: TypeAlias = _Pointer[ULARGE_INTEGER]
-PULONG: TypeAlias = _Pointer[ULONG]
-PUSHORT: TypeAlias = _Pointer[USHORT]
-PWCHAR: TypeAlias = _Pointer[WCHAR]
-PWIN32_FIND_DATAA: TypeAlias = _Pointer[WIN32_FIND_DATAA]
-LPWIN32_FIND_DATAA: TypeAlias = _Pointer[WIN32_FIND_DATAA]
-PWIN32_FIND_DATAW: TypeAlias = _Pointer[WIN32_FIND_DATAW]
-LPWIN32_FIND_DATAW: TypeAlias = _Pointer[WIN32_FIND_DATAW]
-PWORD: TypeAlias = _Pointer[WORD]
-LPWORD: TypeAlias = _Pointer[WORD]
+    dwFileAttributes: _CIntLikeField[DWORD]
+    ftCreationTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastAccessTime: _CField[FILETIME, FILETIME, FILETIME]
+    ftLastWriteTime: _CField[FILETIME, FILETIME, FILETIME]
+    nFileSizeHigh: _CIntLikeField[DWORD]
+    nFileSizeLow: _CIntLikeField[DWORD]
+    dwReserved0: _CIntLikeField[DWORD]
+    dwReserved1: _CIntLikeField[DWORD]
+    cFileName: _CField[Array[WCHAR], str, str]
+    cAlternateFileName: _CField[Array[WCHAR], str, str]
+
+# These are all defined with the POINTER() function, which keeps a cache and will
+# return a previously created class if it can. The self-reported __name__
+# of these classes is f"LP_{typ.__name__}", where typ is the original class
+# passed in to the POINTER() function.
+
+# LP_c_short
+class PSHORT(_Pointer[SHORT]): ...
+
+# LP_c_ushort
+class PUSHORT(_Pointer[USHORT]): ...
+
+PWORD = PUSHORT
+LPWORD = PUSHORT
+
+# LP_c_long
+class PLONG(_Pointer[LONG]): ...
+
+LPLONG = PLONG
+PBOOL = PLONG
+LPBOOL = PLONG
+
+# LP_c_ulong
+class PULONG(_Pointer[ULONG]): ...
+
+PDWORD = PULONG
+LPDWORD = PDWORD
+LPCOLORREF = PDWORD
+PLCID = PDWORD
+
+# LP_c_int (or LP_c_long if int and long have the same size)
+class PINT(_Pointer[INT]): ...
+
+LPINT = PINT
+
+# LP_c_uint (or LP_c_ulong if int and long have the same size)
+class PUINT(_Pointer[UINT]): ...
+
+LPUINT = PUINT
+
+# LP_c_float
+class PFLOAT(_Pointer[FLOAT]): ...
+
+# LP_c_longlong (or LP_c_long if long and long long have the same size)
+class PLARGE_INTEGER(_Pointer[LARGE_INTEGER]): ...
+
+# LP_c_ulonglong (or LP_c_ulong if long and long long have the same size)
+class PULARGE_INTEGER(_Pointer[ULARGE_INTEGER]): ...
+
+# LP_c_byte types
+class PBYTE(_Pointer[BYTE]): ...
+
+LPBYTE = PBYTE
+PBOOLEAN = PBYTE
+
+# LP_c_char
+class PCHAR(_Pointer[CHAR]):
+    # this is inherited from ctypes.c_char_p, kind of.
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
+
+# LP_c_wchar
+class PWCHAR(_Pointer[WCHAR]):
+    # inherited from ctypes.c_wchar_p, kind of
+    @classmethod
+    def from_param(cls, value: Any, /) -> Self | _CArgObject: ...
+
+# LP_c_void_p
+class PHANDLE(_Pointer[HANDLE]): ...
+
+LPHANDLE = PHANDLE
+PHKEY = PHANDLE
+LPHKL = PHANDLE
+LPSC_HANDLE = PHANDLE
+
+# LP_FILETIME
+class PFILETIME(_Pointer[FILETIME]): ...
+
+LPFILETIME = PFILETIME
+
+# LP_MSG
+class PMSG(_Pointer[MSG]): ...
+
+LPMSG = PMSG
+
+# LP_POINT
+class PPOINT(_Pointer[POINT]): ...
+
+LPPOINT = PPOINT
+PPOINTL = PPOINT
+
+# LP_RECT
+class PRECT(_Pointer[RECT]): ...
+
+LPRECT = PRECT
+PRECTL = PRECT
+LPRECTL = PRECT
+
+# LP_SIZE
+class PSIZE(_Pointer[SIZE]): ...
+
+LPSIZE = PSIZE
+PSIZEL = PSIZE
+LPSIZEL = PSIZE
+
+# LP__SMALL_RECT
+class PSMALL_RECT(_Pointer[SMALL_RECT]): ...
+
+# LP_WIN32_FIND_DATAA
+class PWIN32_FIND_DATAA(_Pointer[WIN32_FIND_DATAA]): ...
+
+LPWIN32_FIND_DATAA = PWIN32_FIND_DATAA
+
+# LP_WIN32_FIND_DATAW
+class PWIN32_FIND_DATAW(_Pointer[WIN32_FIND_DATAW]): ...
+
+LPWIN32_FIND_DATAW = PWIN32_FIND_DATAW
diff --git a/mypy/typeshed/stdlib/curses/__init__.pyi b/mypy/typeshed/stdlib/curses/__init__.pyi
index db44fa6a6be7..edc64a00cd39 100644
--- a/mypy/typeshed/stdlib/curses/__init__.pyi
+++ b/mypy/typeshed/stdlib/curses/__init__.pyi
@@ -1,21 +1,45 @@
 import sys
+from _curses import *
+from _curses import window as window
+from _typeshed import structseq
 from collections.abc import Callable
-from typing import TypeVar
+from typing import Final, TypeVar, final, type_check_only
 from typing_extensions import Concatenate, ParamSpec
 
-if sys.platform != "win32":
-    from _curses import *
-    from _curses import _CursesWindow as _CursesWindow
+# NOTE: The _curses module is ordinarily only available on Unix, but the
+# windows-curses package makes it available on Windows as well with the same
+# contents.
 
-    _T = TypeVar("_T")
-    _P = ParamSpec("_P")
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
 
-    # available after calling `curses.initscr()`
-    LINES: int
-    COLS: int
+# available after calling `curses.initscr()`
+LINES: int
+COLS: int
 
-    # available after calling `curses.start_color()`
-    COLORS: int
-    COLOR_PAIRS: int
+# available after calling `curses.start_color()`
+COLORS: int
+COLOR_PAIRS: int
 
-    def wrapper(__func: Callable[Concatenate[_CursesWindow, _P], _T], *arg: _P.args, **kwds: _P.kwargs) -> _T: ...
+def wrapper(func: Callable[Concatenate[window, _P], _T], /, *arg: _P.args, **kwds: _P.kwargs) -> _T: ...
+
+# typeshed used the name _CursesWindow for the underlying C class before
+# it was mapped to the name 'window' in 3.8.
+# Kept here as a legacy alias in case any third-party code is relying on it.
+_CursesWindow = window
+
+# At runtime this class is unexposed and calls itself curses.ncurses_version.
+# That name would conflict with the actual curses.ncurses_version, which is
+# an instance of this class.
+@final
+@type_check_only
+class _ncurses_version(structseq[int], tuple[int, int, int]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("major", "minor", "patch")
+
+    @property
+    def major(self) -> int: ...
+    @property
+    def minor(self) -> int: ...
+    @property
+    def patch(self) -> int: ...
diff --git a/mypy/typeshed/stdlib/curses/ascii.pyi b/mypy/typeshed/stdlib/curses/ascii.pyi
index 25de8f605bda..66efbe36a7df 100644
--- a/mypy/typeshed/stdlib/curses/ascii.pyi
+++ b/mypy/typeshed/stdlib/curses/ascii.pyi
@@ -1,63 +1,62 @@
-import sys
 from typing import TypeVar
 
-if sys.platform != "win32":
-    _CharT = TypeVar("_CharT", str, int)
+_CharT = TypeVar("_CharT", str, int)
 
-    NUL: int
-    SOH: int
-    STX: int
-    ETX: int
-    EOT: int
-    ENQ: int
-    ACK: int
-    BEL: int
-    BS: int
-    TAB: int
-    HT: int
-    LF: int
-    NL: int
-    VT: int
-    FF: int
-    CR: int
-    SO: int
-    SI: int
-    DLE: int
-    DC1: int
-    DC2: int
-    DC3: int
-    DC4: int
-    NAK: int
-    SYN: int
-    ETB: int
-    CAN: int
-    EM: int
-    SUB: int
-    ESC: int
-    FS: int
-    GS: int
-    RS: int
-    US: int
-    SP: int
-    DEL: int
+NUL: int
+SOH: int
+STX: int
+ETX: int
+EOT: int
+ENQ: int
+ACK: int
+BEL: int
+BS: int
+TAB: int
+HT: int
+LF: int
+NL: int
+VT: int
+FF: int
+CR: int
+SO: int
+SI: int
+DLE: int
+DC1: int
+DC2: int
+DC3: int
+DC4: int
+NAK: int
+SYN: int
+ETB: int
+CAN: int
+EM: int
+SUB: int
+ESC: int
+FS: int
+GS: int
+RS: int
+US: int
+SP: int
+DEL: int
 
-    controlnames: list[int]
-    def isalnum(c: str | int) -> bool: ...
-    def isalpha(c: str | int) -> bool: ...
-    def isascii(c: str | int) -> bool: ...
-    def isblank(c: str | int) -> bool: ...
-    def iscntrl(c: str | int) -> bool: ...
-    def isdigit(c: str | int) -> bool: ...
-    def isgraph(c: str | int) -> bool: ...
-    def islower(c: str | int) -> bool: ...
-    def isprint(c: str | int) -> bool: ...
-    def ispunct(c: str | int) -> bool: ...
-    def isspace(c: str | int) -> bool: ...
-    def isupper(c: str | int) -> bool: ...
-    def isxdigit(c: str | int) -> bool: ...
-    def isctrl(c: str | int) -> bool: ...
-    def ismeta(c: str | int) -> bool: ...
-    def ascii(c: _CharT) -> _CharT: ...
-    def ctrl(c: _CharT) -> _CharT: ...
-    def alt(c: _CharT) -> _CharT: ...
-    def unctrl(c: str | int) -> str: ...
+controlnames: list[int]
+
+def isalnum(c: str | int) -> bool: ...
+def isalpha(c: str | int) -> bool: ...
+def isascii(c: str | int) -> bool: ...
+def isblank(c: str | int) -> bool: ...
+def iscntrl(c: str | int) -> bool: ...
+def isdigit(c: str | int) -> bool: ...
+def isgraph(c: str | int) -> bool: ...
+def islower(c: str | int) -> bool: ...
+def isprint(c: str | int) -> bool: ...
+def ispunct(c: str | int) -> bool: ...
+def isspace(c: str | int) -> bool: ...
+def isupper(c: str | int) -> bool: ...
+def isxdigit(c: str | int) -> bool: ...
+def isctrl(c: str | int) -> bool: ...
+def ismeta(c: str | int) -> bool: ...
+def ascii(c: _CharT) -> _CharT: ...
+def ctrl(c: _CharT) -> _CharT: ...
+def alt(c: _CharT) -> _CharT: ...
+def unctrl(c: str | int) -> str: ...
diff --git a/mypy/typeshed/stdlib/curses/has_key.pyi b/mypy/typeshed/stdlib/curses/has_key.pyi
index ff728aedf84b..3811060b916a 100644
--- a/mypy/typeshed/stdlib/curses/has_key.pyi
+++ b/mypy/typeshed/stdlib/curses/has_key.pyi
@@ -1,4 +1 @@
-import sys
-
-if sys.platform != "win32":
-    def has_key(ch: int | str) -> bool: ...
+def has_key(ch: int | str) -> bool: ...
diff --git a/mypy/typeshed/stdlib/curses/panel.pyi b/mypy/typeshed/stdlib/curses/panel.pyi
index 30803791f039..861559d38bc5 100644
--- a/mypy/typeshed/stdlib/curses/panel.pyi
+++ b/mypy/typeshed/stdlib/curses/panel.pyi
@@ -1,25 +1 @@
-import sys
-
-if sys.platform != "win32":
-    from _curses import _CursesWindow
-
-    version: str
-
-    class _Curses_Panel:  # type is <class '_curses_panel.curses panel'> (note the space in the class name)
-        def above(self) -> _Curses_Panel: ...
-        def below(self) -> _Curses_Panel: ...
-        def bottom(self) -> None: ...
-        def hidden(self) -> bool: ...
-        def hide(self) -> None: ...
-        def move(self, y: int, x: int) -> None: ...
-        def replace(self, win: _CursesWindow) -> None: ...
-        def set_userptr(self, obj: object) -> None: ...
-        def show(self) -> None: ...
-        def top(self) -> None: ...
-        def userptr(self) -> object: ...
-        def window(self) -> _CursesWindow: ...
-
-    def bottom_panel() -> _Curses_Panel: ...
-    def new_panel(__win: _CursesWindow) -> _Curses_Panel: ...
-    def top_panel() -> _Curses_Panel: ...
-    def update_panels() -> _Curses_Panel: ...
+from _curses_panel import *
diff --git a/mypy/typeshed/stdlib/curses/textpad.pyi b/mypy/typeshed/stdlib/curses/textpad.pyi
index 4d28b4dfbcdc..48ef67c9d85f 100644
--- a/mypy/typeshed/stdlib/curses/textpad.pyi
+++ b/mypy/typeshed/stdlib/curses/textpad.pyi
@@ -1,13 +1,11 @@
-import sys
+from _curses import window
 from collections.abc import Callable
 
-if sys.platform != "win32":
-    from _curses import _CursesWindow
-    def rectangle(win: _CursesWindow, uly: int, ulx: int, lry: int, lrx: int) -> None: ...
+def rectangle(win: window, uly: int, ulx: int, lry: int, lrx: int) -> None: ...
 
-    class Textbox:
-        stripspaces: bool
-        def __init__(self, win: _CursesWindow, insert_mode: bool = False) -> None: ...
-        def edit(self, validate: Callable[[int], int] | None = None) -> str: ...
-        def do_command(self, ch: str | int) -> None: ...
-        def gather(self) -> str: ...
+class Textbox:
+    stripspaces: bool
+    def __init__(self, win: window, insert_mode: bool = False) -> None: ...
+    def edit(self, validate: Callable[[int], int] | None = None) -> str: ...
+    def do_command(self, ch: str | int) -> None: ...
+    def gather(self) -> str: ...
diff --git a/mypy/typeshed/stdlib/dataclasses.pyi b/mypy/typeshed/stdlib/dataclasses.pyi
index 13cffcd70c0e..3d89b830352b 100644
--- a/mypy/typeshed/stdlib/dataclasses.pyi
+++ b/mypy/typeshed/stdlib/dataclasses.pyi
@@ -4,8 +4,8 @@ import types
 from _typeshed import DataclassInstance
 from builtins import type as Type  # alias to avoid name clashes with fields named "type"
 from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Generic, Protocol, TypeVar, overload
-from typing_extensions import Literal, TypeAlias, TypeGuard
+from typing import Any, Generic, Literal, Protocol, TypeVar, overload
+from typing_extensions import Never, TypeAlias, TypeIs
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -54,19 +54,10 @@ def asdict(obj: DataclassInstance, *, dict_factory: Callable[[list[tuple[str, An
 def astuple(obj: DataclassInstance) -> tuple[Any, ...]: ...
 @overload
 def astuple(obj: DataclassInstance, *, tuple_factory: Callable[[list[Any]], _T]) -> _T: ...
-
-if sys.version_info >= (3, 8):
-    # cls argument is now positional-only
-    @overload
-    def dataclass(__cls: None) -> Callable[[type[_T]], type[_T]]: ...
-    @overload
-    def dataclass(__cls: type[_T]) -> type[_T]: ...
-
-else:
-    @overload
-    def dataclass(_cls: None) -> Callable[[type[_T]], type[_T]]: ...
-    @overload
-    def dataclass(_cls: type[_T]) -> type[_T]: ...
+@overload
+def dataclass(cls: None, /) -> Callable[[type[_T]], type[_T]]: ...
+@overload
+def dataclass(cls: type[_T], /) -> type[_T]: ...
 
 if sys.version_info >= (3, 11):
     @overload
@@ -117,7 +108,7 @@ class _DefaultFactory(Protocol[_T_co]):
 
 class Field(Generic[_T]):
     name: str
-    type: Type[_T]
+    type: Type[_T] | str | Any
     default: _T | Literal[_MISSING_TYPE.MISSING]
     default_factory: _DefaultFactory[_T] | Literal[_MISSING_TYPE.MISSING]
     repr: bool
@@ -152,7 +143,7 @@ class Field(Generic[_T]):
 
     def __set_name__(self, owner: Type[Any], name: str) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # NOTE: Actual return type is 'Field[_T]', but we want to help type checkers
 # to understand the magic that happens at runtime.
@@ -161,33 +152,37 @@ if sys.version_info >= (3, 10):
     def field(
         *,
         default: _T,
+        default_factory: Literal[_MISSING_TYPE.MISSING] = ...,
         init: bool = True,
         repr: bool = True,
         hash: bool | None = None,
         compare: bool = True,
         metadata: Mapping[Any, Any] | None = None,
-        kw_only: bool = ...,
+        kw_only: bool | Literal[_MISSING_TYPE.MISSING] = ...,
     ) -> _T: ...
     @overload
     def field(
         *,
+        default: Literal[_MISSING_TYPE.MISSING] = ...,
         default_factory: Callable[[], _T],
         init: bool = True,
         repr: bool = True,
         hash: bool | None = None,
         compare: bool = True,
         metadata: Mapping[Any, Any] | None = None,
-        kw_only: bool = ...,
+        kw_only: bool | Literal[_MISSING_TYPE.MISSING] = ...,
     ) -> _T: ...
     @overload
     def field(
         *,
+        default: Literal[_MISSING_TYPE.MISSING] = ...,
+        default_factory: Literal[_MISSING_TYPE.MISSING] = ...,
         init: bool = True,
         repr: bool = True,
         hash: bool | None = None,
         compare: bool = True,
         metadata: Mapping[Any, Any] | None = None,
-        kw_only: bool = ...,
+        kw_only: bool | Literal[_MISSING_TYPE.MISSING] = ...,
     ) -> Any: ...
 
 else:
@@ -195,6 +190,7 @@ else:
     def field(
         *,
         default: _T,
+        default_factory: Literal[_MISSING_TYPE.MISSING] = ...,
         init: bool = True,
         repr: bool = True,
         hash: bool | None = None,
@@ -204,6 +200,7 @@ else:
     @overload
     def field(
         *,
+        default: Literal[_MISSING_TYPE.MISSING] = ...,
         default_factory: Callable[[], _T],
         init: bool = True,
         repr: bool = True,
@@ -214,6 +211,8 @@ else:
     @overload
     def field(
         *,
+        default: Literal[_MISSING_TYPE.MISSING] = ...,
+        default_factory: Literal[_MISSING_TYPE.MISSING] = ...,
         init: bool = True,
         repr: bool = True,
         hash: bool | None = None,
@@ -222,12 +221,14 @@ else:
     ) -> Any: ...
 
 def fields(class_or_instance: DataclassInstance | type[DataclassInstance]) -> tuple[Field[Any], ...]: ...
+
+# HACK: `obj: Never` typing matches if object argument is using `Any` type.
 @overload
-def is_dataclass(obj: DataclassInstance) -> Literal[True]: ...
+def is_dataclass(obj: Never) -> TypeIs[DataclassInstance | type[DataclassInstance]]: ...  # type: ignore[narrowed-type-not-subtype]  # pyright: ignore[reportGeneralTypeIssues]
 @overload
-def is_dataclass(obj: type) -> TypeGuard[type[DataclassInstance]]: ...
+def is_dataclass(obj: type) -> TypeIs[type[DataclassInstance]]: ...
 @overload
-def is_dataclass(obj: object) -> TypeGuard[DataclassInstance | type[DataclassInstance]]: ...
+def is_dataclass(obj: object) -> TypeIs[DataclassInstance | type[DataclassInstance]]: ...
 
 class FrozenInstanceError(AttributeError): ...
 
@@ -236,21 +237,22 @@ if sys.version_info >= (3, 9):
 else:
     class _InitVarMeta(type):
         # Not used, instead `InitVar.__class_getitem__` is called.
-        def __getitem__(self, params: Any) -> InitVar[Any]: ...
+        # pyright (not unreasonably) thinks this is an invalid use of InitVar.
+        def __getitem__(self, params: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]
 
 class InitVar(Generic[_T], metaclass=_InitVarMeta):
     type: Type[_T]
     def __init__(self, type: Type[_T]) -> None: ...
     if sys.version_info >= (3, 9):
         @overload
-        def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...
+        def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...  # pyright: ignore[reportInvalidTypeForm]
         @overload
-        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...
+        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]
 
 if sys.version_info >= (3, 12):
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,
@@ -270,7 +272,7 @@ if sys.version_info >= (3, 12):
 elif sys.version_info >= (3, 11):
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,
@@ -289,7 +291,7 @@ elif sys.version_info >= (3, 11):
 elif sys.version_info >= (3, 10):
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,
@@ -307,7 +309,7 @@ elif sys.version_info >= (3, 10):
 else:
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,
@@ -319,4 +321,4 @@ else:
         frozen: bool = False,
     ) -> type: ...
 
-def replace(__obj: _DataclassT, **changes: Any) -> _DataclassT: ...
+def replace(obj: _DataclassT, /, **changes: Any) -> _DataclassT: ...
diff --git a/mypy/typeshed/stdlib/datetime.pyi b/mypy/typeshed/stdlib/datetime.pyi
index 2bb2264c97b1..4907bf4607c8 100644
--- a/mypy/typeshed/stdlib/datetime.pyi
+++ b/mypy/typeshed/stdlib/datetime.pyi
@@ -1,27 +1,25 @@
 import sys
 from abc import abstractmethod
 from time import struct_time
-from typing import ClassVar, NamedTuple, NoReturn, TypeVar, overload
-from typing_extensions import Literal, Self, SupportsIndex, TypeAlias, final
+from typing import ClassVar, Final, NoReturn, SupportsIndex, final, overload, type_check_only
+from typing_extensions import CapsuleType, Self, TypeAlias, deprecated
 
 if sys.version_info >= (3, 11):
     __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo", "MINYEAR", "MAXYEAR", "UTC")
 elif sys.version_info >= (3, 9):
     __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo", "MINYEAR", "MAXYEAR")
 
-_D = TypeVar("_D", bound=date)
-
-MINYEAR: Literal[1]
-MAXYEAR: Literal[9999]
+MINYEAR: Final = 1
+MAXYEAR: Final = 9999
 
 class tzinfo:
     @abstractmethod
-    def tzname(self, __dt: datetime | None) -> str | None: ...
+    def tzname(self, dt: datetime | None, /) -> str | None: ...
     @abstractmethod
-    def utcoffset(self, __dt: datetime | None) -> timedelta | None: ...
+    def utcoffset(self, dt: datetime | None, /) -> timedelta | None: ...
     @abstractmethod
-    def dst(self, __dt: datetime | None) -> timedelta | None: ...
-    def fromutc(self, __dt: datetime) -> datetime: ...
+    def dst(self, dt: datetime | None, /) -> timedelta | None: ...
+    def fromutc(self, dt: datetime, /) -> datetime: ...
 
 # Alias required to avoid name conflicts with date(time).tzinfo.
 _TzInfo: TypeAlias = tzinfo
@@ -31,19 +29,28 @@ class timezone(tzinfo):
     utc: ClassVar[timezone]
     min: ClassVar[timezone]
     max: ClassVar[timezone]
-    def __init__(self, offset: timedelta, name: str = ...) -> None: ...
-    def tzname(self, __dt: datetime | None) -> str: ...
-    def utcoffset(self, __dt: datetime | None) -> timedelta: ...
-    def dst(self, __dt: datetime | None) -> None: ...
+    def __new__(cls, offset: timedelta, name: str = ...) -> Self: ...
+    def tzname(self, dt: datetime | None, /) -> str: ...
+    def utcoffset(self, dt: datetime | None, /) -> timedelta: ...
+    def dst(self, dt: datetime | None, /) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, value: object, /) -> bool: ...
 
 if sys.version_info >= (3, 11):
     UTC: timezone
 
 if sys.version_info >= (3, 9):
-    class _IsoCalendarDate(NamedTuple):
-        year: int
-        week: int
-        weekday: int
+    # This class calls itself datetime.IsoCalendarDate. It's neither
+    # NamedTuple nor structseq.
+    @final
+    @type_check_only
+    class _IsoCalendarDate(tuple[int, int, int]):
+        @property
+        def year(self) -> int: ...
+        @property
+        def week(self) -> int: ...
+        @property
+        def weekday(self) -> int: ...
 
 class date:
     min: ClassVar[date]
@@ -51,17 +58,15 @@ class date:
     resolution: ClassVar[timedelta]
     def __new__(cls, year: SupportsIndex, month: SupportsIndex, day: SupportsIndex) -> Self: ...
     @classmethod
-    def fromtimestamp(cls, __timestamp: float) -> Self: ...
+    def fromtimestamp(cls, timestamp: float, /) -> Self: ...
     @classmethod
     def today(cls) -> Self: ...
     @classmethod
-    def fromordinal(cls, __n: int) -> Self: ...
+    def fromordinal(cls, n: int, /) -> Self: ...
     @classmethod
-    def fromisoformat(cls, __date_string: str) -> Self: ...
-    if sys.version_info >= (3, 8):
-        @classmethod
-        def fromisocalendar(cls, year: int, week: int, day: int) -> Self: ...
-
+    def fromisoformat(cls, date_string: str, /) -> Self: ...
+    @classmethod
+    def fromisocalendar(cls, year: int, week: int, day: int) -> Self: ...
     @property
     def year(self) -> int: ...
     @property
@@ -75,37 +80,30 @@ class date:
     if sys.version_info >= (3, 12):
         def strftime(self, format: str) -> str: ...
     else:
-        def strftime(self, __format: str) -> str: ...
+        def strftime(self, format: str, /) -> str: ...
 
-    def __format__(self, __fmt: str) -> str: ...
+    def __format__(self, fmt: str, /) -> str: ...
     def isoformat(self) -> str: ...
     def timetuple(self) -> struct_time: ...
     def toordinal(self) -> int: ...
-    def replace(self, year: SupportsIndex = ..., month: SupportsIndex = ..., day: SupportsIndex = ...) -> Self: ...
-    def __le__(self, __value: date) -> bool: ...
-    def __lt__(self, __value: date) -> bool: ...
-    def __ge__(self, __value: date) -> bool: ...
-    def __gt__(self, __value: date) -> bool: ...
-    if sys.version_info >= (3, 8):
-        def __add__(self, __value: timedelta) -> Self: ...
-        def __radd__(self, __value: timedelta) -> Self: ...
-        @overload
-        def __sub__(self, __value: timedelta) -> Self: ...
-        @overload
-        def __sub__(self, __value: datetime) -> NoReturn: ...
-        @overload
-        def __sub__(self: _D, __value: _D) -> timedelta: ...
-    else:
-        # Prior to Python 3.8, arithmetic operations always returned `date`, even in subclasses
-        def __add__(self, __value: timedelta) -> date: ...
-        def __radd__(self, __value: timedelta) -> date: ...
-        @overload
-        def __sub__(self, __value: timedelta) -> date: ...
-        @overload
-        def __sub__(self, __value: datetime) -> NoReturn: ...
-        @overload
-        def __sub__(self, __value: date) -> timedelta: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, /, *, year: SupportsIndex = ..., month: SupportsIndex = ..., day: SupportsIndex = ...) -> Self: ...
 
+    def replace(self, year: SupportsIndex = ..., month: SupportsIndex = ..., day: SupportsIndex = ...) -> Self: ...
+    def __le__(self, value: date, /) -> bool: ...
+    def __lt__(self, value: date, /) -> bool: ...
+    def __ge__(self, value: date, /) -> bool: ...
+    def __gt__(self, value: date, /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __add__(self, value: timedelta, /) -> Self: ...
+    def __radd__(self, value: timedelta, /) -> Self: ...
+    @overload
+    def __sub__(self, value: datetime, /) -> NoReturn: ...
+    @overload
+    def __sub__(self, value: Self, /) -> timedelta: ...
+    @overload
+    def __sub__(self, value: timedelta, /) -> Self: ...
+    def __hash__(self) -> int: ...
     def weekday(self) -> int: ...
     def isoweekday(self) -> int: ...
     if sys.version_info >= (3, 9):
@@ -139,25 +137,40 @@ class time:
     def tzinfo(self) -> _TzInfo | None: ...
     @property
     def fold(self) -> int: ...
-    def __le__(self, __value: time) -> bool: ...
-    def __lt__(self, __value: time) -> bool: ...
-    def __ge__(self, __value: time) -> bool: ...
-    def __gt__(self, __value: time) -> bool: ...
+    def __le__(self, value: time, /) -> bool: ...
+    def __lt__(self, value: time, /) -> bool: ...
+    def __ge__(self, value: time, /) -> bool: ...
+    def __gt__(self, value: time, /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
     def isoformat(self, timespec: str = ...) -> str: ...
     @classmethod
-    def fromisoformat(cls, __time_string: str) -> Self: ...
+    def fromisoformat(cls, time_string: str, /) -> Self: ...
     # On <3.12, the name of the parameter in the pure-Python implementation
     # didn't match the name in the C implementation,
     # meaning it is only *safe* to pass it as a keyword argument on 3.12+
     if sys.version_info >= (3, 12):
         def strftime(self, format: str) -> str: ...
     else:
-        def strftime(self, __format: str) -> str: ...
+        def strftime(self, format: str, /) -> str: ...
 
-    def __format__(self, __fmt: str) -> str: ...
+    def __format__(self, fmt: str, /) -> str: ...
     def utcoffset(self) -> timedelta | None: ...
     def tzname(self) -> str | None: ...
     def dst(self) -> timedelta | None: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(
+            self,
+            /,
+            *,
+            hour: SupportsIndex = ...,
+            minute: SupportsIndex = ...,
+            second: SupportsIndex = ...,
+            microsecond: SupportsIndex = ...,
+            tzinfo: _TzInfo | None = ...,
+            fold: int = ...,
+        ) -> Self: ...
+
     def replace(
         self,
         hour: SupportsIndex = ...,
@@ -193,30 +206,32 @@ class timedelta:
     @property
     def microseconds(self) -> int: ...
     def total_seconds(self) -> float: ...
-    def __add__(self, __value: timedelta) -> timedelta: ...
-    def __radd__(self, __value: timedelta) -> timedelta: ...
-    def __sub__(self, __value: timedelta) -> timedelta: ...
-    def __rsub__(self, __value: timedelta) -> timedelta: ...
+    def __add__(self, value: timedelta, /) -> timedelta: ...
+    def __radd__(self, value: timedelta, /) -> timedelta: ...
+    def __sub__(self, value: timedelta, /) -> timedelta: ...
+    def __rsub__(self, value: timedelta, /) -> timedelta: ...
     def __neg__(self) -> timedelta: ...
     def __pos__(self) -> timedelta: ...
     def __abs__(self) -> timedelta: ...
-    def __mul__(self, __value: float) -> timedelta: ...
-    def __rmul__(self, __value: float) -> timedelta: ...
+    def __mul__(self, value: float, /) -> timedelta: ...
+    def __rmul__(self, value: float, /) -> timedelta: ...
     @overload
-    def __floordiv__(self, __value: timedelta) -> int: ...
+    def __floordiv__(self, value: timedelta, /) -> int: ...
     @overload
-    def __floordiv__(self, __value: int) -> timedelta: ...
+    def __floordiv__(self, value: int, /) -> timedelta: ...
     @overload
-    def __truediv__(self, __value: timedelta) -> float: ...
+    def __truediv__(self, value: timedelta, /) -> float: ...
     @overload
-    def __truediv__(self, __value: float) -> timedelta: ...
-    def __mod__(self, __value: timedelta) -> timedelta: ...
-    def __divmod__(self, __value: timedelta) -> tuple[int, timedelta]: ...
-    def __le__(self, __value: timedelta) -> bool: ...
-    def __lt__(self, __value: timedelta) -> bool: ...
-    def __ge__(self, __value: timedelta) -> bool: ...
-    def __gt__(self, __value: timedelta) -> bool: ...
+    def __truediv__(self, value: float, /) -> timedelta: ...
+    def __mod__(self, value: timedelta, /) -> timedelta: ...
+    def __divmod__(self, value: timedelta, /) -> tuple[int, timedelta]: ...
+    def __le__(self, value: timedelta, /) -> bool: ...
+    def __lt__(self, value: timedelta, /) -> bool: ...
+    def __ge__(self, value: timedelta, /) -> bool: ...
+    def __gt__(self, value: timedelta, /) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
     def __bool__(self) -> bool: ...
+    def __hash__(self) -> int: ...
 
 class datetime(date):
     min: ClassVar[datetime]
@@ -254,22 +269,15 @@ class datetime(date):
         def fromtimestamp(cls, timestamp: float, tz: _TzInfo | None = ...) -> Self: ...
     else:
         @classmethod
-        def fromtimestamp(cls, __timestamp: float, tz: _TzInfo | None = ...) -> Self: ...
+        def fromtimestamp(cls, timestamp: float, /, tz: _TzInfo | None = ...) -> Self: ...
 
     @classmethod
-    def utcfromtimestamp(cls, __t: float) -> Self: ...
-    if sys.version_info >= (3, 8):
-        @classmethod
-        def now(cls, tz: _TzInfo | None = None) -> Self: ...
-    else:
-        @overload
-        @classmethod
-        def now(cls, tz: None = None) -> Self: ...
-        @overload
-        @classmethod
-        def now(cls, tz: _TzInfo) -> datetime: ...
-
+    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .fromtimestamp(datetime.timezone.utc)")
+    def utcfromtimestamp(cls, t: float, /) -> Self: ...
+    @classmethod
+    def now(cls, tz: _TzInfo | None = None) -> Self: ...
     @classmethod
+    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .now(datetime.timezone.utc)")
     def utcnow(cls) -> Self: ...
     @classmethod
     def combine(cls, date: _Date, time: _Time, tzinfo: _TzInfo | None = ...) -> Self: ...
@@ -278,6 +286,22 @@ class datetime(date):
     def date(self) -> _Date: ...
     def time(self) -> _Time: ...
     def timetz(self) -> _Time: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(
+            self,
+            /,
+            *,
+            year: SupportsIndex = ...,
+            month: SupportsIndex = ...,
+            day: SupportsIndex = ...,
+            hour: SupportsIndex = ...,
+            minute: SupportsIndex = ...,
+            second: SupportsIndex = ...,
+            microsecond: SupportsIndex = ...,
+            tzinfo: _TzInfo | None = ...,
+            fold: int = ...,
+        ) -> Self: ...
+
     def replace(
         self,
         year: SupportsIndex = ...,
@@ -291,31 +315,22 @@ class datetime(date):
         *,
         fold: int = ...,
     ) -> Self: ...
-    if sys.version_info >= (3, 8):
-        def astimezone(self, tz: _TzInfo | None = ...) -> Self: ...
-    else:
-        def astimezone(self, tz: _TzInfo | None = ...) -> datetime: ...
-
+    def astimezone(self, tz: _TzInfo | None = ...) -> Self: ...
     def isoformat(self, sep: str = ..., timespec: str = ...) -> str: ...
     @classmethod
-    def strptime(cls, __date_string: str, __format: str) -> Self: ...
+    def strptime(cls, date_string: str, format: str, /) -> Self: ...
     def utcoffset(self) -> timedelta | None: ...
     def tzname(self) -> str | None: ...
     def dst(self) -> timedelta | None: ...
-    def __le__(self, __value: datetime) -> bool: ...  # type: ignore[override]
-    def __lt__(self, __value: datetime) -> bool: ...  # type: ignore[override]
-    def __ge__(self, __value: datetime) -> bool: ...  # type: ignore[override]
-    def __gt__(self, __value: datetime) -> bool: ...  # type: ignore[override]
-    if sys.version_info >= (3, 8):
-        @overload  # type: ignore[override]
-        def __sub__(self, __value: timedelta) -> Self: ...
-        @overload
-        def __sub__(self: _D, __value: _D) -> timedelta: ...
-    else:
-        # Prior to Python 3.8, arithmetic operations always returned `datetime`, even in subclasses
-        def __add__(self, __value: timedelta) -> datetime: ...
-        def __radd__(self, __value: timedelta) -> datetime: ...
-        @overload  # type: ignore[override]
-        def __sub__(self, __value: datetime) -> timedelta: ...
-        @overload
-        def __sub__(self, __value: timedelta) -> datetime: ...
+    def __le__(self, value: datetime, /) -> bool: ...  # type: ignore[override]
+    def __lt__(self, value: datetime, /) -> bool: ...  # type: ignore[override]
+    def __ge__(self, value: datetime, /) -> bool: ...  # type: ignore[override]
+    def __gt__(self, value: datetime, /) -> bool: ...  # type: ignore[override]
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
+    @overload  # type: ignore[override]
+    def __sub__(self, value: Self, /) -> timedelta: ...
+    @overload
+    def __sub__(self, value: timedelta, /) -> Self: ...
+
+datetime_CAPI: CapsuleType
diff --git a/mypy/typeshed/stdlib/dbm/__init__.pyi b/mypy/typeshed/stdlib/dbm/__init__.pyi
index 0068d67b6ad1..7f344060f9ab 100644
--- a/mypy/typeshed/stdlib/dbm/__init__.pyi
+++ b/mypy/typeshed/stdlib/dbm/__init__.pyi
@@ -1,6 +1,9 @@
+import sys
+from _typeshed import StrOrBytesPath
 from collections.abc import Iterator, MutableMapping
 from types import TracebackType
-from typing_extensions import Literal, Self, TypeAlias
+from typing import Literal, type_check_only
+from typing_extensions import Self, TypeAlias
 
 __all__ = ["open", "whichdb", "error"]
 
@@ -86,9 +89,16 @@ class _Database(MutableMapping[_KeyType, bytes]):
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
 
+# This class is not exposed. It calls itself dbm.error.
+@type_check_only
 class _error(Exception): ...
 
 error: tuple[type[_error], type[OSError]]
 
-def whichdb(filename: str) -> str: ...
-def open(file: str, flag: _TFlags = "r", mode: int = 0o666) -> _Database: ...
+if sys.version_info >= (3, 11):
+    def whichdb(filename: StrOrBytesPath) -> str | None: ...
+    def open(file: StrOrBytesPath, flag: _TFlags = "r", mode: int = 0o666) -> _Database: ...
+
+else:
+    def whichdb(filename: str) -> str | None: ...
+    def open(file: str, flag: _TFlags = "r", mode: int = 0o666) -> _Database: ...
diff --git a/mypy/typeshed/stdlib/dbm/dumb.pyi b/mypy/typeshed/stdlib/dbm/dumb.pyi
index 1fc68cf71f9d..1c0b7756f292 100644
--- a/mypy/typeshed/stdlib/dbm/dumb.pyi
+++ b/mypy/typeshed/stdlib/dbm/dumb.pyi
@@ -1,3 +1,5 @@
+import sys
+from _typeshed import StrOrBytesPath
 from collections.abc import Iterator, MutableMapping
 from types import TracebackType
 from typing_extensions import Self, TypeAlias
@@ -28,4 +30,8 @@ class _Database(MutableMapping[_KeyType, bytes]):
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
 
-def open(file: str, flag: str = "c", mode: int = 0o666) -> _Database: ...
+if sys.version_info >= (3, 11):
+    def open(file: StrOrBytesPath, flag: str = "c", mode: int = 0o666) -> _Database: ...
+
+else:
+    def open(file: str, flag: str = "c", mode: int = 0o666) -> _Database: ...
diff --git a/mypy/typeshed/stdlib/dbm/gnu.pyi b/mypy/typeshed/stdlib/dbm/gnu.pyi
index 3dc66a30c370..2dac3d12b0ca 100644
--- a/mypy/typeshed/stdlib/dbm/gnu.pyi
+++ b/mypy/typeshed/stdlib/dbm/gnu.pyi
@@ -1,40 +1 @@
-import sys
-from _typeshed import ReadOnlyBuffer
-from types import TracebackType
-from typing import TypeVar, overload
-from typing_extensions import Self, TypeAlias
-
-if sys.platform != "win32":
-    _T = TypeVar("_T")
-    _KeyType: TypeAlias = str | ReadOnlyBuffer
-    _ValueType: TypeAlias = str | ReadOnlyBuffer
-
-    open_flags: str
-
-    class error(OSError): ...
-    # Actual typename gdbm, not exposed by the implementation
-    class _gdbm:
-        def firstkey(self) -> bytes | None: ...
-        def nextkey(self, key: _KeyType) -> bytes | None: ...
-        def reorganize(self) -> None: ...
-        def sync(self) -> None: ...
-        def close(self) -> None: ...
-        def __getitem__(self, item: _KeyType) -> bytes: ...
-        def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
-        def __delitem__(self, key: _KeyType) -> None: ...
-        def __contains__(self, key: _KeyType) -> bool: ...
-        def __len__(self) -> int: ...
-        def __enter__(self) -> Self: ...
-        def __exit__(
-            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-        ) -> None: ...
-        @overload
-        def get(self, k: _KeyType) -> bytes | None: ...
-        @overload
-        def get(self, k: _KeyType, default: _T) -> bytes | _T: ...
-        def keys(self) -> list[bytes]: ...
-        def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
-        # Don't exist at runtime
-        __new__: None  # type: ignore[assignment]
-        __init__: None  # type: ignore[assignment]
-    def open(__filename: str, __flags: str = "r", __mode: int = 0o666) -> _gdbm: ...
+from _gdbm import *
diff --git a/mypy/typeshed/stdlib/dbm/ndbm.pyi b/mypy/typeshed/stdlib/dbm/ndbm.pyi
index 1106fb2a8e7e..66c943ab640b 100644
--- a/mypy/typeshed/stdlib/dbm/ndbm.pyi
+++ b/mypy/typeshed/stdlib/dbm/ndbm.pyi
@@ -1,36 +1 @@
-import sys
-from _typeshed import ReadOnlyBuffer
-from types import TracebackType
-from typing import TypeVar, overload
-from typing_extensions import Self, TypeAlias
-
-if sys.platform != "win32":
-    _T = TypeVar("_T")
-    _KeyType: TypeAlias = str | ReadOnlyBuffer
-    _ValueType: TypeAlias = str | ReadOnlyBuffer
-
-    class error(OSError): ...
-    library: str
-
-    # Actual typename dbm, not exposed by the implementation
-    class _dbm:
-        def close(self) -> None: ...
-        def __getitem__(self, item: _KeyType) -> bytes: ...
-        def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
-        def __delitem__(self, key: _KeyType) -> None: ...
-        def __len__(self) -> int: ...
-        def __del__(self) -> None: ...
-        def __enter__(self) -> Self: ...
-        def __exit__(
-            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-        ) -> None: ...
-        @overload
-        def get(self, k: _KeyType) -> bytes | None: ...
-        @overload
-        def get(self, k: _KeyType, default: _T) -> bytes | _T: ...
-        def keys(self) -> list[bytes]: ...
-        def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ...
-        # Don't exist at runtime
-        __new__: None  # type: ignore[assignment]
-        __init__: None  # type: ignore[assignment]
-    def open(__filename: str, __flags: str = "r", __mode: int = 0o666) -> _dbm: ...
+from _dbm import *
diff --git a/mypy/typeshed/stdlib/dbm/sqlite3.pyi b/mypy/typeshed/stdlib/dbm/sqlite3.pyi
new file mode 100644
index 000000000000..446a0cf155fa
--- /dev/null
+++ b/mypy/typeshed/stdlib/dbm/sqlite3.pyi
@@ -0,0 +1,29 @@
+from _typeshed import ReadableBuffer, StrOrBytesPath, Unused
+from collections.abc import Generator, MutableMapping
+from typing import Final, Literal
+from typing_extensions import LiteralString, Self, TypeAlias
+
+BUILD_TABLE: Final[LiteralString]
+GET_SIZE: Final[LiteralString]
+LOOKUP_KEY: Final[LiteralString]
+STORE_KV: Final[LiteralString]
+DELETE_KEY: Final[LiteralString]
+ITER_KEYS: Final[LiteralString]
+
+_SqliteData: TypeAlias = str | ReadableBuffer | int | float
+
+class error(OSError): ...
+
+class _Database(MutableMapping[bytes, bytes]):
+    def __init__(self, path: StrOrBytesPath, /, *, flag: Literal["r", "w", "c", "n"], mode: int) -> None: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: _SqliteData) -> bytes: ...
+    def __setitem__(self, key: _SqliteData, value: _SqliteData) -> None: ...
+    def __delitem__(self, key: _SqliteData) -> None: ...
+    def __iter__(self) -> Generator[bytes]: ...
+    def close(self) -> None: ...
+    def keys(self) -> list[bytes]: ...  # type: ignore[override]
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+
+def open(filename: StrOrBytesPath, /, flag: Literal["r", "w,", "c", "n"] = "r", mode: int = 0o666) -> _Database: ...
diff --git a/mypy/typeshed/stdlib/decimal.pyi b/mypy/typeshed/stdlib/decimal.pyi
index 35fc4405f11b..4ded21e0b017 100644
--- a/mypy/typeshed/stdlib/decimal.pyi
+++ b/mypy/typeshed/stdlib/decimal.pyi
@@ -1,2 +1,264 @@
-from _decimal import *
-from _decimal import __libmpdec_version__ as __libmpdec_version__, __version__ as __version__
+import numbers
+from _decimal import (
+    HAVE_CONTEXTVAR as HAVE_CONTEXTVAR,
+    HAVE_THREADS as HAVE_THREADS,
+    MAX_EMAX as MAX_EMAX,
+    MAX_PREC as MAX_PREC,
+    MIN_EMIN as MIN_EMIN,
+    MIN_ETINY as MIN_ETINY,
+    ROUND_05UP as ROUND_05UP,
+    ROUND_CEILING as ROUND_CEILING,
+    ROUND_DOWN as ROUND_DOWN,
+    ROUND_FLOOR as ROUND_FLOOR,
+    ROUND_HALF_DOWN as ROUND_HALF_DOWN,
+    ROUND_HALF_EVEN as ROUND_HALF_EVEN,
+    ROUND_HALF_UP as ROUND_HALF_UP,
+    ROUND_UP as ROUND_UP,
+    BasicContext as BasicContext,
+    DefaultContext as DefaultContext,
+    ExtendedContext as ExtendedContext,
+    __libmpdec_version__ as __libmpdec_version__,
+    __version__ as __version__,
+    getcontext as getcontext,
+    localcontext as localcontext,
+    setcontext as setcontext,
+)
+from collections.abc import Container, Sequence
+from types import TracebackType
+from typing import Any, ClassVar, Literal, NamedTuple, final, overload, type_check_only
+from typing_extensions import Self, TypeAlias
+
+_Decimal: TypeAlias = Decimal | int
+_DecimalNew: TypeAlias = Decimal | float | str | tuple[int, Sequence[int], int]
+_ComparableNum: TypeAlias = Decimal | float | numbers.Rational
+_TrapType: TypeAlias = type[DecimalException]
+
+# At runtime, these classes are implemented in C as part of "_decimal".
+# However, they consider themselves to live in "decimal", so we'll put them here.
+
+# This type isn't exposed at runtime. It calls itself decimal.ContextManager
+@final
+@type_check_only
+class _ContextManager:
+    def __init__(self, new_context: Context) -> None: ...
+    def __enter__(self) -> Context: ...
+    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+
+class DecimalTuple(NamedTuple):
+    sign: int
+    digits: tuple[int, ...]
+    exponent: int | Literal["n", "N", "F"]
+
+class DecimalException(ArithmeticError): ...
+class Clamped(DecimalException): ...
+class InvalidOperation(DecimalException): ...
+class ConversionSyntax(InvalidOperation): ...
+class DivisionByZero(DecimalException, ZeroDivisionError): ...
+class DivisionImpossible(InvalidOperation): ...
+class DivisionUndefined(InvalidOperation, ZeroDivisionError): ...
+class Inexact(DecimalException): ...
+class InvalidContext(InvalidOperation): ...
+class Rounded(DecimalException): ...
+class Subnormal(DecimalException): ...
+class Overflow(Inexact, Rounded): ...
+class Underflow(Inexact, Rounded, Subnormal): ...
+class FloatOperation(DecimalException, TypeError): ...
+
+class Decimal:
+    def __new__(cls, value: _DecimalNew = "0", context: Context | None = None) -> Self: ...
+    @classmethod
+    def from_float(cls, f: float, /) -> Self: ...
+    def __bool__(self) -> bool: ...
+    def compare(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def __hash__(self) -> int: ...
+    def as_tuple(self) -> DecimalTuple: ...
+    def as_integer_ratio(self) -> tuple[int, int]: ...
+    def to_eng_string(self, context: Context | None = None) -> str: ...
+    def __abs__(self) -> Decimal: ...
+    def __add__(self, value: _Decimal, /) -> Decimal: ...
+    def __divmod__(self, value: _Decimal, /) -> tuple[Decimal, Decimal]: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __floordiv__(self, value: _Decimal, /) -> Decimal: ...
+    def __ge__(self, value: _ComparableNum, /) -> bool: ...
+    def __gt__(self, value: _ComparableNum, /) -> bool: ...
+    def __le__(self, value: _ComparableNum, /) -> bool: ...
+    def __lt__(self, value: _ComparableNum, /) -> bool: ...
+    def __mod__(self, value: _Decimal, /) -> Decimal: ...
+    def __mul__(self, value: _Decimal, /) -> Decimal: ...
+    def __neg__(self) -> Decimal: ...
+    def __pos__(self) -> Decimal: ...
+    def __pow__(self, value: _Decimal, mod: _Decimal | None = None, /) -> Decimal: ...
+    def __radd__(self, value: _Decimal, /) -> Decimal: ...
+    def __rdivmod__(self, value: _Decimal, /) -> tuple[Decimal, Decimal]: ...
+    def __rfloordiv__(self, value: _Decimal, /) -> Decimal: ...
+    def __rmod__(self, value: _Decimal, /) -> Decimal: ...
+    def __rmul__(self, value: _Decimal, /) -> Decimal: ...
+    def __rsub__(self, value: _Decimal, /) -> Decimal: ...
+    def __rtruediv__(self, value: _Decimal, /) -> Decimal: ...
+    def __sub__(self, value: _Decimal, /) -> Decimal: ...
+    def __truediv__(self, value: _Decimal, /) -> Decimal: ...
+    def remainder_near(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+    def __trunc__(self) -> int: ...
+    @property
+    def real(self) -> Decimal: ...
+    @property
+    def imag(self) -> Decimal: ...
+    def conjugate(self) -> Decimal: ...
+    def __complex__(self) -> complex: ...
+    @overload
+    def __round__(self) -> int: ...
+    @overload
+    def __round__(self, ndigits: int, /) -> Decimal: ...
+    def __floor__(self) -> int: ...
+    def __ceil__(self) -> int: ...
+    def fma(self, other: _Decimal, third: _Decimal, context: Context | None = None) -> Decimal: ...
+    def __rpow__(self, value: _Decimal, mod: Context | None = None, /) -> Decimal: ...
+    def normalize(self, context: Context | None = None) -> Decimal: ...
+    def quantize(self, exp: _Decimal, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
+    def same_quantum(self, other: _Decimal, context: Context | None = None) -> bool: ...
+    def to_integral_exact(self, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
+    def to_integral_value(self, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
+    def to_integral(self, rounding: str | None = None, context: Context | None = None) -> Decimal: ...
+    def sqrt(self, context: Context | None = None) -> Decimal: ...
+    def max(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def min(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def adjusted(self) -> int: ...
+    def canonical(self) -> Decimal: ...
+    def compare_signal(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def compare_total(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def compare_total_mag(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def copy_abs(self) -> Decimal: ...
+    def copy_negate(self) -> Decimal: ...
+    def copy_sign(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def exp(self, context: Context | None = None) -> Decimal: ...
+    def is_canonical(self) -> bool: ...
+    def is_finite(self) -> bool: ...
+    def is_infinite(self) -> bool: ...
+    def is_nan(self) -> bool: ...
+    def is_normal(self, context: Context | None = None) -> bool: ...
+    def is_qnan(self) -> bool: ...
+    def is_signed(self) -> bool: ...
+    def is_snan(self) -> bool: ...
+    def is_subnormal(self, context: Context | None = None) -> bool: ...
+    def is_zero(self) -> bool: ...
+    def ln(self, context: Context | None = None) -> Decimal: ...
+    def log10(self, context: Context | None = None) -> Decimal: ...
+    def logb(self, context: Context | None = None) -> Decimal: ...
+    def logical_and(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def logical_invert(self, context: Context | None = None) -> Decimal: ...
+    def logical_or(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def logical_xor(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def max_mag(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def min_mag(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def next_minus(self, context: Context | None = None) -> Decimal: ...
+    def next_plus(self, context: Context | None = None) -> Decimal: ...
+    def next_toward(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def number_class(self, context: Context | None = None) -> str: ...
+    def radix(self) -> Decimal: ...
+    def rotate(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def scaleb(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def shift(self, other: _Decimal, context: Context | None = None) -> Decimal: ...
+    def __reduce__(self) -> tuple[type[Self], tuple[str]]: ...
+    def __copy__(self) -> Self: ...
+    def __deepcopy__(self, memo: Any, /) -> Self: ...
+    def __format__(self, specifier: str, context: Context | None = None, /) -> str: ...
+
+class Context:
+    # TODO: Context doesn't allow you to delete *any* attributes from instances of the class at runtime,
+    # even settable attributes like `prec` and `rounding`,
+    # but that's inexpressible in the stub.
+    # Type checkers either ignore it or misinterpret it
+    # if you add a `def __delattr__(self, name: str, /) -> NoReturn` method to the stub
+    prec: int
+    rounding: str
+    Emin: int
+    Emax: int
+    capitals: int
+    clamp: int
+    traps: dict[_TrapType, bool]
+    flags: dict[_TrapType, bool]
+    def __init__(
+        self,
+        prec: int | None = None,
+        rounding: str | None = None,
+        Emin: int | None = None,
+        Emax: int | None = None,
+        capitals: int | None = None,
+        clamp: int | None = None,
+        flags: dict[_TrapType, bool] | Container[_TrapType] | None = None,
+        traps: dict[_TrapType, bool] | Container[_TrapType] | None = None,
+    ) -> None: ...
+    def __reduce__(self) -> tuple[type[Self], tuple[Any, ...]]: ...
+    def clear_flags(self) -> None: ...
+    def clear_traps(self) -> None: ...
+    def copy(self) -> Context: ...
+    def __copy__(self) -> Context: ...
+    # see https://github.com/python/cpython/issues/94107
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    def Etiny(self) -> int: ...
+    def Etop(self) -> int: ...
+    def create_decimal(self, num: _DecimalNew = "0", /) -> Decimal: ...
+    def create_decimal_from_float(self, f: float, /) -> Decimal: ...
+    def abs(self, x: _Decimal, /) -> Decimal: ...
+    def add(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def canonical(self, x: Decimal, /) -> Decimal: ...
+    def compare(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def compare_signal(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def compare_total(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def compare_total_mag(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def copy_abs(self, x: _Decimal, /) -> Decimal: ...
+    def copy_decimal(self, x: _Decimal, /) -> Decimal: ...
+    def copy_negate(self, x: _Decimal, /) -> Decimal: ...
+    def copy_sign(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def divide(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def divide_int(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def divmod(self, x: _Decimal, y: _Decimal, /) -> tuple[Decimal, Decimal]: ...
+    def exp(self, x: _Decimal, /) -> Decimal: ...
+    def fma(self, x: _Decimal, y: _Decimal, z: _Decimal, /) -> Decimal: ...
+    def is_canonical(self, x: _Decimal, /) -> bool: ...
+    def is_finite(self, x: _Decimal, /) -> bool: ...
+    def is_infinite(self, x: _Decimal, /) -> bool: ...
+    def is_nan(self, x: _Decimal, /) -> bool: ...
+    def is_normal(self, x: _Decimal, /) -> bool: ...
+    def is_qnan(self, x: _Decimal, /) -> bool: ...
+    def is_signed(self, x: _Decimal, /) -> bool: ...
+    def is_snan(self, x: _Decimal, /) -> bool: ...
+    def is_subnormal(self, x: _Decimal, /) -> bool: ...
+    def is_zero(self, x: _Decimal, /) -> bool: ...
+    def ln(self, x: _Decimal, /) -> Decimal: ...
+    def log10(self, x: _Decimal, /) -> Decimal: ...
+    def logb(self, x: _Decimal, /) -> Decimal: ...
+    def logical_and(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def logical_invert(self, x: _Decimal, /) -> Decimal: ...
+    def logical_or(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def logical_xor(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def max(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def max_mag(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def min(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def min_mag(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def minus(self, x: _Decimal, /) -> Decimal: ...
+    def multiply(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def next_minus(self, x: _Decimal, /) -> Decimal: ...
+    def next_plus(self, x: _Decimal, /) -> Decimal: ...
+    def next_toward(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def normalize(self, x: _Decimal, /) -> Decimal: ...
+    def number_class(self, x: _Decimal, /) -> str: ...
+    def plus(self, x: _Decimal, /) -> Decimal: ...
+    def power(self, a: _Decimal, b: _Decimal, modulo: _Decimal | None = None) -> Decimal: ...
+    def quantize(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def radix(self) -> Decimal: ...
+    def remainder(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def remainder_near(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def rotate(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def same_quantum(self, x: _Decimal, y: _Decimal, /) -> bool: ...
+    def scaleb(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def shift(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def sqrt(self, x: _Decimal, /) -> Decimal: ...
+    def subtract(self, x: _Decimal, y: _Decimal, /) -> Decimal: ...
+    def to_eng_string(self, x: _Decimal, /) -> str: ...
+    def to_sci_string(self, x: _Decimal, /) -> str: ...
+    def to_integral_exact(self, x: _Decimal, /) -> Decimal: ...
+    def to_integral_value(self, x: _Decimal, /) -> Decimal: ...
+    def to_integral(self, x: _Decimal, /) -> Decimal: ...
diff --git a/mypy/typeshed/stdlib/difflib.pyi b/mypy/typeshed/stdlib/difflib.pyi
index 894ebaaeca98..50154d785c2f 100644
--- a/mypy/typeshed/stdlib/difflib.pyi
+++ b/mypy/typeshed/stdlib/difflib.pyi
@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Callable, Iterable, Iterator, Sequence
-from typing import Any, AnyStr, Generic, NamedTuple, TypeVar, overload
+from typing import Any, AnyStr, Generic, Literal, NamedTuple, TypeVar, overload
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -49,13 +49,13 @@ class SequenceMatcher(Generic[_T]):
         def find_longest_match(self, alo: int, ahi: int, blo: int, bhi: int) -> Match: ...
 
     def get_matching_blocks(self) -> list[Match]: ...
-    def get_opcodes(self) -> list[tuple[str, int, int, int, int]]: ...
+    def get_opcodes(self) -> list[tuple[Literal["replace", "delete", "insert", "equal"], int, int, int, int]]: ...
     def get_grouped_opcodes(self, n: int = 3) -> Iterable[list[tuple[str, int, int, int, int]]]: ...
     def ratio(self) -> float: ...
     def quick_ratio(self) -> float: ...
     def real_quick_ratio(self) -> float: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @overload
 def get_close_matches(word: AnyStr, possibilities: Iterable[AnyStr], n: int = 3, cutoff: float = 0.6) -> list[AnyStr]: ...
diff --git a/mypy/typeshed/stdlib/dis.pyi b/mypy/typeshed/stdlib/dis.pyi
index d153771e676b..cb69eac89c92 100644
--- a/mypy/typeshed/stdlib/dis.pyi
+++ b/mypy/typeshed/stdlib/dis.pyi
@@ -29,9 +29,15 @@ __all__ = [
     "opmap",
     "HAVE_ARGUMENT",
     "EXTENDED_ARG",
-    "hasnargs",
     "stack_effect",
 ]
+if sys.version_info >= (3, 13):
+    __all__ += ["hasjump"]
+
+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)
@@ -44,8 +50,23 @@ if sys.version_info >= (3, 11):
         col_offset: int | None = None
         end_col_offset: int | None = None
 
-if sys.version_info >= (3, 11):
-    class Instruction(NamedTuple):
+if sys.version_info >= (3, 13):
+    class _Instruction(NamedTuple):
+        opname: str
+        opcode: int
+        arg: int | None
+        argval: Any
+        argrepr: str
+        offset: int
+        start_offset: int
+        starts_line: bool
+        line_number: int | None
+        label: int | None = None
+        positions: Positions | None = None
+        cache_info: list[tuple[str, int, Any]] | None = None
+
+elif sys.version_info >= (3, 11):
+    class _Instruction(NamedTuple):
         opname: str
         opcode: int
         arg: int | None
@@ -57,7 +78,7 @@ if sys.version_info >= (3, 11):
         positions: Positions | None = None
 
 else:
-    class Instruction(NamedTuple):
+    class _Instruction(NamedTuple):
         opname: str
         opcode: int
         arg: int | None
@@ -67,10 +88,42 @@ else:
         starts_line: int | None
         is_jump_target: bool
 
+class Instruction(_Instruction):
+    if sys.version_info < (3, 13):
+        def _disassemble(self, lineno_width: int = 3, mark_as_current: bool = False, offset_width: int = 4) -> str: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def oparg(self) -> int: ...
+        @property
+        def baseopcode(self) -> int: ...
+        @property
+        def baseopname(self) -> str: ...
+        @property
+        def cache_offset(self) -> int: ...
+        @property
+        def end_offset(self) -> int: ...
+        @property
+        def jump_target(self) -> int: ...
+        @property
+        def is_jump_target(self) -> bool: ...
+
 class Bytecode:
     codeobj: types.CodeType
     first_line: int
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 13):
+        show_offsets: bool
+        # 3.13 added `show_offsets`
+        def __init__(
+            self,
+            x: _HaveCodeType | str,
+            *,
+            first_line: int | None = None,
+            current_offset: int | None = None,
+            show_caches: bool = False,
+            adaptive: bool = False,
+            show_offsets: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
         def __init__(
             self,
             x: _HaveCodeType | str,
@@ -80,12 +133,15 @@ class Bytecode:
             show_caches: bool = False,
             adaptive: bool = False,
         ) -> None: ...
-        @classmethod
-        def from_traceback(cls, tb: types.TracebackType, *, show_caches: bool = False, adaptive: bool = False) -> Self: ...
     else:
         def __init__(
             self, x: _HaveCodeType | str, *, first_line: int | None = None, current_offset: int | None = None
         ) -> None: ...
+
+    if sys.version_info >= (3, 11):
+        @classmethod
+        def from_traceback(cls, tb: types.TracebackType, *, show_caches: bool = False, adaptive: bool = False) -> Self: ...
+    else:
         @classmethod
         def from_traceback(cls, tb: types.TracebackType) -> Self: ...
 
@@ -100,7 +156,8 @@ def findlinestarts(code: _HaveCodeType) -> Iterator[tuple[int, int]]: ...
 def pretty_flags(flags: int) -> str: ...
 def code_info(x: _HaveCodeType | str) -> str: ...
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 13):
+    # 3.13 added `show_offsets`
     def dis(
         x: _HaveCodeType | str | bytes | bytearray | None = None,
         *,
@@ -108,20 +165,43 @@ if sys.version_info >= (3, 11):
         depth: int | None = None,
         show_caches: bool = False,
         adaptive: bool = False,
+        show_offsets: bool = False,
     ) -> None: ...
+    def disassemble(
+        co: _HaveCodeType,
+        lasti: int = -1,
+        *,
+        file: IO[str] | None = None,
+        show_caches: bool = False,
+        adaptive: bool = False,
+        show_offsets: bool = False,
+    ) -> None: ...
+    def distb(
+        tb: types.TracebackType | None = None,
+        *,
+        file: IO[str] | None = None,
+        show_caches: bool = False,
+        adaptive: bool = False,
+        show_offsets: bool = False,
+    ) -> None: ...
+    # 3.13 made `show_cache` `None` by default
+    def get_instructions(
+        x: _HaveCodeType, *, first_line: int | None = None, show_caches: bool | None = None, adaptive: bool = False
+    ) -> Iterator[Instruction]: ...
 
-else:
+elif sys.version_info >= (3, 11):
+    # 3.11 added `show_caches` and `adaptive`
     def dis(
-        x: _HaveCodeType | str | bytes | bytearray | None = None, *, file: IO[str] | None = None, depth: int | None = None
+        x: _HaveCodeType | str | bytes | bytearray | None = None,
+        *,
+        file: IO[str] | None = None,
+        depth: int | None = None,
+        show_caches: bool = False,
+        adaptive: bool = False,
     ) -> None: ...
-
-if sys.version_info >= (3, 11):
     def disassemble(
         co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
     ) -> None: ...
-    def disco(
-        co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
-    ) -> None: ...
     def distb(
         tb: types.TracebackType | None = None, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
     ) -> None: ...
@@ -130,9 +210,13 @@ if sys.version_info >= (3, 11):
     ) -> Iterator[Instruction]: ...
 
 else:
+    def dis(
+        x: _HaveCodeType | str | bytes | bytearray | None = None, *, file: IO[str] | None = None, depth: int | None = None
+    ) -> None: ...
     def disassemble(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
-    def disco(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
     def distb(tb: types.TracebackType | None = None, *, file: IO[str] | None = None) -> None: ...
     def get_instructions(x: _HaveCodeType, *, first_line: int | None = None) -> Iterator[Instruction]: ...
 
 def show_code(co: _HaveCodeType, *, file: IO[str] | None = None) -> None: ...
+
+disco = disassemble
diff --git a/mypy/typeshed/stdlib/distutils/__init__.pyi b/mypy/typeshed/stdlib/distutils/__init__.pyi
index e69de29bb2d1..328a5b783441 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/distutils/_msvccompiler.pyi b/mypy/typeshed/stdlib/distutils/_msvccompiler.pyi
new file mode 100644
index 000000000000..bba9373b72db
--- /dev/null
+++ b/mypy/typeshed/stdlib/distutils/_msvccompiler.pyi
@@ -0,0 +1,13 @@
+from _typeshed import Incomplete
+from distutils.ccompiler import CCompiler
+from typing import ClassVar, Final
+
+PLAT_SPEC_TO_RUNTIME: Final[dict[str, str]]
+PLAT_TO_VCVARS: Final[dict[str, str]]
+
+class MSVCCompiler(CCompiler):
+    compiler_type: ClassVar[str]
+    executables: ClassVar[dict[Incomplete, Incomplete]]
+    res_extension: ClassVar[str]
+    initialized: bool
+    def initialize(self, plat_name: str | None = None) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/archive_util.pyi b/mypy/typeshed/stdlib/distutils/archive_util.pyi
index a8947ce35c60..16684ff06956 100644
--- a/mypy/typeshed/stdlib/distutils/archive_util.pyi
+++ b/mypy/typeshed/stdlib/distutils/archive_util.pyi
@@ -1,20 +1,35 @@
+from _typeshed import StrOrBytesPath, StrPath
+from typing import Literal, overload
+
+@overload
 def make_archive(
     base_name: str,
     format: str,
-    root_dir: str | None = None,
+    root_dir: StrOrBytesPath | None = None,
     base_dir: str | None = None,
-    verbose: int = 0,
-    dry_run: int = 0,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str: ...
+@overload
+def make_archive(
+    base_name: StrPath,
+    format: str,
+    root_dir: StrOrBytesPath,
+    base_dir: str | None = None,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
     owner: str | None = None,
     group: str | None = None,
 ) -> str: ...
 def make_tarball(
     base_name: str,
-    base_dir: str,
+    base_dir: StrPath,
     compress: str | None = "gzip",
-    verbose: int = 0,
-    dry_run: int = 0,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
     owner: str | None = None,
     group: str | None = None,
 ) -> str: ...
-def make_zipfile(base_name: str, base_dir: str, verbose: int = 0, dry_run: int = 0) -> str: ...
+def make_zipfile(base_name: str, base_dir: str, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0) -> str: ...
diff --git a/mypy/typeshed/stdlib/distutils/ccompiler.pyi b/mypy/typeshed/stdlib/distutils/ccompiler.pyi
index e7277aa3f9c4..5bff209807ee 100644
--- a/mypy/typeshed/stdlib/distutils/ccompiler.pyi
+++ b/mypy/typeshed/stdlib/distutils/ccompiler.pyi
@@ -1,8 +1,11 @@
-from collections.abc import Callable
-from typing import Any
-from typing_extensions import TypeAlias
+from _typeshed import BytesPath, StrPath, Unused
+from collections.abc import Callable, Iterable, Sequence
+from distutils.file_util import _BytesPathT, _StrPathT
+from typing import Literal, overload
+from typing_extensions import TypeAlias, TypeVarTuple, Unpack
 
 _Macro: TypeAlias = tuple[str] | tuple[str, str | None]
+_Ts = TypeVarTuple("_Ts")
 
 def gen_lib_options(
     compiler: CCompiler, library_dirs: list[str], runtime_library_dirs: list[str], libraries: list[str]
@@ -10,7 +13,11 @@ def gen_lib_options(
 def gen_preprocess_options(macros: list[_Macro], include_dirs: list[str]) -> list[str]: ...
 def get_default_compiler(osname: str | None = None, platform: str | None = None) -> str: ...
 def new_compiler(
-    plat: str | None = None, compiler: str | None = None, verbose: int = 0, dry_run: int = 0, force: int = 0
+    plat: str | None = None,
+    compiler: str | None = None,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
+    force: bool | Literal[0, 1] = 0,
 ) -> CCompiler: ...
 def show_compilers() -> None: ...
 
@@ -25,7 +32,9 @@ class CCompiler:
     library_dirs: list[str]
     runtime_library_dirs: list[str]
     objects: list[str]
-    def __init__(self, verbose: int = 0, dry_run: int = 0, force: int = 0) -> None: ...
+    def __init__(
+        self, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0, force: bool | Literal[0, 1] = 0
+    ) -> None: ...
     def add_include_dir(self, dir: str) -> None: ...
     def set_include_dirs(self, dirs: list[str]) -> None: ...
     def add_library(self, libname: str) -> None: ...
@@ -39,7 +48,7 @@ class CCompiler:
     def add_link_object(self, object: str) -> None: ...
     def set_link_objects(self, objects: list[str]) -> None: ...
     def detect_language(self, sources: str | list[str]) -> str | None: ...
-    def find_library_file(self, dirs: list[str], lib: str, debug: bool = ...) -> str | None: ...
+    def find_library_file(self, dirs: list[str], lib: str, debug: bool | Literal[0, 1] = 0) -> str | None: ...
     def has_function(
         self,
         funcname: str,
@@ -54,11 +63,11 @@ class CCompiler:
     def set_executables(self, **args: str) -> None: ...
     def compile(
         self,
-        sources: list[str],
+        sources: Sequence[StrPath],
         output_dir: str | None = None,
-        macros: _Macro | None = None,
+        macros: list[_Macro] | None = None,
         include_dirs: list[str] | None = None,
-        debug: bool = ...,
+        debug: bool | Literal[0, 1] = 0,
         extra_preargs: list[str] | None = None,
         extra_postargs: list[str] | None = None,
         depends: list[str] | None = None,
@@ -68,7 +77,7 @@ class CCompiler:
         objects: list[str],
         output_libname: str,
         output_dir: str | None = None,
-        debug: bool = ...,
+        debug: bool | Literal[0, 1] = 0,
         target_lang: str | None = None,
     ) -> None: ...
     def link(
@@ -81,7 +90,7 @@ class CCompiler:
         library_dirs: list[str] | None = None,
         runtime_library_dirs: list[str] | None = None,
         export_symbols: list[str] | None = None,
-        debug: bool = ...,
+        debug: bool | Literal[0, 1] = 0,
         extra_preargs: list[str] | None = None,
         extra_postargs: list[str] | None = None,
         build_temp: str | None = None,
@@ -95,7 +104,7 @@ class CCompiler:
         libraries: list[str] | None = None,
         library_dirs: list[str] | None = None,
         runtime_library_dirs: list[str] | None = None,
-        debug: bool = ...,
+        debug: bool | Literal[0, 1] = 0,
         extra_preargs: list[str] | None = None,
         extra_postargs: list[str] | None = None,
         target_lang: str | None = None,
@@ -109,7 +118,7 @@ class CCompiler:
         library_dirs: list[str] | None = None,
         runtime_library_dirs: list[str] | None = None,
         export_symbols: list[str] | None = None,
-        debug: bool = ...,
+        debug: bool | Literal[0, 1] = 0,
         extra_preargs: list[str] | None = None,
         extra_postargs: list[str] | None = None,
         build_temp: str | None = None,
@@ -124,7 +133,7 @@ class CCompiler:
         library_dirs: list[str] | None = None,
         runtime_library_dirs: list[str] | None = None,
         export_symbols: list[str] | None = None,
-        debug: bool = ...,
+        debug: bool | Literal[0, 1] = 0,
         extra_preargs: list[str] | None = None,
         extra_postargs: list[str] | None = None,
         build_temp: str | None = None,
@@ -139,14 +148,29 @@ class CCompiler:
         extra_preargs: list[str] | None = None,
         extra_postargs: list[str] | None = None,
     ) -> None: ...
-    def executable_filename(self, basename: str, strip_dir: int = 0, output_dir: str = "") -> str: ...
-    def library_filename(self, libname: str, lib_type: str = "static", strip_dir: int = 0, output_dir: str = "") -> str: ...
-    def object_filenames(self, source_filenames: list[str], strip_dir: int = 0, output_dir: str = "") -> list[str]: ...
-    def shared_object_filename(self, basename: str, strip_dir: int = 0, output_dir: str = "") -> str: ...
-    def execute(self, func: Callable[..., object], args: tuple[Any, ...], msg: str | None = None, level: int = 1) -> None: ...
-    def spawn(self, cmd: list[str]) -> None: ...
+    @overload
+    def executable_filename(self, basename: str, strip_dir: Literal[0, False] = 0, output_dir: StrPath = "") -> str: ...
+    @overload
+    def executable_filename(self, basename: StrPath, strip_dir: Literal[1, True], output_dir: StrPath = "") -> str: ...
+    def library_filename(
+        self, libname: str, lib_type: str = "static", strip_dir: bool | Literal[0, 1] = 0, output_dir: StrPath = ""
+    ) -> str: ...
+    def object_filenames(
+        self, source_filenames: Iterable[StrPath], strip_dir: bool | Literal[0, 1] = 0, output_dir: StrPath | None = ""
+    ) -> list[str]: ...
+    @overload
+    def shared_object_filename(self, basename: str, strip_dir: Literal[0, False] = 0, output_dir: StrPath = "") -> str: ...
+    @overload
+    def shared_object_filename(self, basename: StrPath, strip_dir: Literal[1, True], output_dir: StrPath = "") -> str: ...
+    def execute(
+        self, func: Callable[[Unpack[_Ts]], Unused], args: tuple[Unpack[_Ts]], msg: str | None = None, level: int = 1
+    ) -> None: ...
+    def spawn(self, cmd: Iterable[str]) -> None: ...
     def mkpath(self, name: str, mode: int = 0o777) -> None: ...
-    def move_file(self, src: str, dst: str) -> str: ...
+    @overload
+    def move_file(self, src: StrPath, dst: _StrPathT) -> _StrPathT | str: ...
+    @overload
+    def move_file(self, src: BytesPath, dst: _BytesPathT) -> _BytesPathT | bytes: ...
     def announce(self, msg: str, level: int = 1) -> None: ...
     def warn(self, msg: str) -> None: ...
     def debug_print(self, msg: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/cmd.pyi b/mypy/typeshed/stdlib/distutils/cmd.pyi
index 61fce37b80bc..a4e77ddf1388 100644
--- a/mypy/typeshed/stdlib/distutils/cmd.pyi
+++ b/mypy/typeshed/stdlib/distutils/cmd.pyi
@@ -1,12 +1,39 @@
-from _typeshed import Incomplete
+from _typeshed import BytesPath, Incomplete, StrOrBytesPath, StrPath, Unused
 from abc import abstractmethod
 from collections.abc import Callable, Iterable
+from distutils.command.bdist import bdist
+from distutils.command.bdist_dumb import bdist_dumb
+from distutils.command.bdist_rpm import bdist_rpm
+from distutils.command.build import build
+from distutils.command.build_clib import build_clib
+from distutils.command.build_ext import build_ext
+from distutils.command.build_py import build_py
+from distutils.command.build_scripts import build_scripts
+from distutils.command.check import check
+from distutils.command.clean import clean
+from distutils.command.config import config
+from distutils.command.install import install
+from distutils.command.install_data import install_data
+from distutils.command.install_egg_info import install_egg_info
+from distutils.command.install_headers import install_headers
+from distutils.command.install_lib import install_lib
+from distutils.command.install_scripts import install_scripts
+from distutils.command.register import register
+from distutils.command.sdist import sdist
+from distutils.command.upload import upload
 from distutils.dist import Distribution
-from typing import Any
+from distutils.file_util import _BytesPathT, _StrPathT
+from typing import Any, ClassVar, Literal, TypeVar, overload
+from typing_extensions import TypeVarTuple, Unpack
+
+_CommandT = TypeVar("_CommandT", bound=Command)
+_Ts = TypeVarTuple("_Ts")
 
 class Command:
+    dry_run: bool | Literal[0, 1]  # Exposed from __getattr_. Same as Distribution.dry_run
     distribution: Distribution
-    sub_commands: list[tuple[str, Callable[[Command], bool] | None]]
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
     def __init__(self, dist: Distribution) -> None: ...
     @abstractmethod
     def initialize_options(self) -> None: ...
@@ -17,37 +44,173 @@ class Command:
     def announce(self, msg: str, level: int = 1) -> None: ...
     def debug_print(self, msg: str) -> None: ...
     def ensure_string(self, option: str, default: str | None = None) -> None: ...
-    def ensure_string_list(self, option: str | list[str]) -> None: ...
+    def ensure_string_list(self, option: str) -> None: ...
     def ensure_filename(self, option: str) -> None: ...
     def ensure_dirname(self, option: str) -> None: ...
     def get_command_name(self) -> str: ...
     def set_undefined_options(self, src_cmd: str, *option_pairs: tuple[str, str]) -> None: ...
-    def get_finalized_command(self, command: str, create: int = 1) -> Command: ...
-    def reinitialize_command(self, command: Command | str, reinit_subcommands: int = 0) -> Command: ...
+    # NOTE: This list comes directly from the distutils/command folder. Minus bdist_msi and bdist_wininst.
+    @overload
+    def get_finalized_command(self, command: Literal["bdist"], create: bool | Literal[0, 1] = 1) -> bdist: ...
+    @overload
+    def get_finalized_command(self, command: Literal["bdist_dumb"], create: bool | Literal[0, 1] = 1) -> bdist_dumb: ...
+    @overload
+    def get_finalized_command(self, command: Literal["bdist_rpm"], create: bool | Literal[0, 1] = 1) -> bdist_rpm: ...
+    @overload
+    def get_finalized_command(self, command: Literal["build"], create: bool | Literal[0, 1] = 1) -> build: ...
+    @overload
+    def get_finalized_command(self, command: Literal["build_clib"], create: bool | Literal[0, 1] = 1) -> build_clib: ...
+    @overload
+    def get_finalized_command(self, command: Literal["build_ext"], create: bool | Literal[0, 1] = 1) -> build_ext: ...
+    @overload
+    def get_finalized_command(self, command: Literal["build_py"], create: bool | Literal[0, 1] = 1) -> build_py: ...
+    @overload
+    def get_finalized_command(self, command: Literal["build_scripts"], create: bool | Literal[0, 1] = 1) -> build_scripts: ...
+    @overload
+    def get_finalized_command(self, command: Literal["check"], create: bool | Literal[0, 1] = 1) -> check: ...
+    @overload
+    def get_finalized_command(self, command: Literal["clean"], create: bool | Literal[0, 1] = 1) -> clean: ...
+    @overload
+    def get_finalized_command(self, command: Literal["config"], create: bool | Literal[0, 1] = 1) -> config: ...
+    @overload
+    def get_finalized_command(self, command: Literal["install"], create: bool | Literal[0, 1] = 1) -> install: ...
+    @overload
+    def get_finalized_command(self, command: Literal["install_data"], create: bool | Literal[0, 1] = 1) -> install_data: ...
+    @overload
+    def get_finalized_command(
+        self, command: Literal["install_egg_info"], create: bool | Literal[0, 1] = 1
+    ) -> install_egg_info: ...
+    @overload
+    def get_finalized_command(self, command: Literal["install_headers"], create: bool | Literal[0, 1] = 1) -> install_headers: ...
+    @overload
+    def get_finalized_command(self, command: Literal["install_lib"], create: bool | Literal[0, 1] = 1) -> install_lib: ...
+    @overload
+    def get_finalized_command(self, command: Literal["install_scripts"], create: bool | Literal[0, 1] = 1) -> install_scripts: ...
+    @overload
+    def get_finalized_command(self, command: Literal["register"], create: bool | Literal[0, 1] = 1) -> register: ...
+    @overload
+    def get_finalized_command(self, command: Literal["sdist"], create: bool | Literal[0, 1] = 1) -> sdist: ...
+    @overload
+    def get_finalized_command(self, command: Literal["upload"], create: bool | Literal[0, 1] = 1) -> upload: ...
+    @overload
+    def get_finalized_command(self, command: str, create: bool | Literal[0, 1] = 1) -> Command: ...
+    @overload
+    def reinitialize_command(self, command: Literal["bdist"], reinit_subcommands: bool | Literal[0, 1] = 0) -> bdist: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["bdist_dumb"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> bdist_dumb: ...
+    @overload
+    def reinitialize_command(self, command: Literal["bdist_rpm"], reinit_subcommands: bool | Literal[0, 1] = 0) -> bdist_rpm: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build"], reinit_subcommands: bool | Literal[0, 1] = 0) -> build: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["build_clib"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> build_clib: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build_ext"], reinit_subcommands: bool | Literal[0, 1] = 0) -> build_ext: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build_py"], reinit_subcommands: bool | Literal[0, 1] = 0) -> build_py: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["build_scripts"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> build_scripts: ...
+    @overload
+    def reinitialize_command(self, command: Literal["check"], reinit_subcommands: bool | Literal[0, 1] = 0) -> check: ...
+    @overload
+    def reinitialize_command(self, command: Literal["clean"], reinit_subcommands: bool | Literal[0, 1] = 0) -> clean: ...
+    @overload
+    def reinitialize_command(self, command: Literal["config"], reinit_subcommands: bool | Literal[0, 1] = 0) -> config: ...
+    @overload
+    def reinitialize_command(self, command: Literal["install"], reinit_subcommands: bool | Literal[0, 1] = 0) -> install: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["install_data"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> install_data: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["install_egg_info"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> install_egg_info: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["install_headers"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> install_headers: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["install_lib"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> install_lib: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["install_scripts"], reinit_subcommands: bool | Literal[0, 1] = 0
+    ) -> install_scripts: ...
+    @overload
+    def reinitialize_command(self, command: Literal["register"], reinit_subcommands: bool | Literal[0, 1] = 0) -> register: ...
+    @overload
+    def reinitialize_command(self, command: Literal["sdist"], reinit_subcommands: bool | Literal[0, 1] = 0) -> sdist: ...
+    @overload
+    def reinitialize_command(self, command: Literal["upload"], reinit_subcommands: bool | Literal[0, 1] = 0) -> upload: ...
+    @overload
+    def reinitialize_command(self, command: str, reinit_subcommands: bool | Literal[0, 1] = 0) -> Command: ...
+    @overload
+    def reinitialize_command(self, command: _CommandT, reinit_subcommands: bool | Literal[0, 1] = 0) -> _CommandT: ...
     def run_command(self, command: str) -> None: ...
     def get_sub_commands(self) -> list[str]: ...
     def warn(self, msg: str) -> None: ...
-    def execute(self, func: Callable[..., object], args: Iterable[Any], msg: str | None = None, level: int = 1) -> None: ...
+    def execute(
+        self, func: Callable[[Unpack[_Ts]], Unused], args: tuple[Unpack[_Ts]], msg: str | None = None, level: int = 1
+    ) -> None: ...
     def mkpath(self, name: str, mode: int = 0o777) -> None: ...
+    @overload
+    def copy_file(
+        self,
+        infile: StrPath,
+        outfile: _StrPathT,
+        preserve_mode: bool | Literal[0, 1] = 1,
+        preserve_times: bool | Literal[0, 1] = 1,
+        link: str | None = None,
+        level: Unused = 1,
+    ) -> tuple[_StrPathT | str, bool]: ...
+    @overload
     def copy_file(
-        self, infile: str, outfile: str, preserve_mode: int = 1, preserve_times: int = 1, link: str | None = None, level: Any = 1
-    ) -> tuple[str, bool]: ...  # level is not used
+        self,
+        infile: BytesPath,
+        outfile: _BytesPathT,
+        preserve_mode: bool | Literal[0, 1] = 1,
+        preserve_times: bool | Literal[0, 1] = 1,
+        link: str | None = None,
+        level: Unused = 1,
+    ) -> tuple[_BytesPathT | bytes, bool]: ...
     def copy_tree(
         self,
-        infile: str,
+        infile: StrPath,
         outfile: str,
-        preserve_mode: int = 1,
-        preserve_times: int = 1,
-        preserve_symlinks: int = 0,
-        level: Any = 1,
-    ) -> list[str]: ...  # level is not used
-    def move_file(self, src: str, dst: str, level: Any = 1) -> str: ...  # level is not used
-    def spawn(self, cmd: Iterable[str], search_path: int = 1, level: Any = 1) -> None: ...  # level is not used
+        preserve_mode: bool | Literal[0, 1] = 1,
+        preserve_times: bool | Literal[0, 1] = 1,
+        preserve_symlinks: bool | Literal[0, 1] = 0,
+        level: Unused = 1,
+    ) -> list[str]: ...
+    @overload
+    def move_file(self, src: StrPath, dst: _StrPathT, level: Unused = 1) -> _StrPathT | str: ...
+    @overload
+    def move_file(self, src: BytesPath, dst: _BytesPathT, level: Unused = 1) -> _BytesPathT | bytes: ...
+    def spawn(self, cmd: Iterable[str], search_path: bool | Literal[0, 1] = 1, level: Unused = 1) -> None: ...
+    @overload
     def make_archive(
         self,
         base_name: str,
         format: str,
-        root_dir: str | None = None,
+        root_dir: StrOrBytesPath | None = None,
+        base_dir: str | None = None,
+        owner: str | None = None,
+        group: str | None = None,
+    ) -> str: ...
+    @overload
+    def make_archive(
+        self,
+        base_name: StrPath,
+        format: str,
+        root_dir: StrOrBytesPath,
         base_dir: str | None = None,
         owner: str | None = None,
         group: str | None = None,
@@ -55,12 +218,12 @@ class Command:
     def make_file(
         self,
         infiles: str | list[str] | tuple[str, ...],
-        outfile: str,
-        func: Callable[..., object],
-        args: list[Any],
+        outfile: StrOrBytesPath,
+        func: Callable[[Unpack[_Ts]], Unused],
+        args: tuple[Unpack[_Ts]],
         exec_msg: str | None = None,
         skip_msg: str | None = None,
-        level: Any = 1,
-    ) -> None: ...  # level is not used
+        level: Unused = 1,
+    ) -> None: ...
     def ensure_finalized(self) -> None: ...
     def dump_options(self, header: Incomplete | None = None, indent: str = "") -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/__init__.pyi b/mypy/typeshed/stdlib/distutils/command/__init__.pyi
index e69de29bb2d1..4d7372858af3 100644
--- a/mypy/typeshed/stdlib/distutils/command/__init__.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/__init__.pyi
@@ -0,0 +1,48 @@
+import sys
+
+from . import (
+    bdist,
+    bdist_dumb,
+    bdist_rpm,
+    build,
+    build_clib,
+    build_ext,
+    build_py,
+    build_scripts,
+    check,
+    clean,
+    install,
+    install_data,
+    install_headers,
+    install_lib,
+    install_scripts,
+    register,
+    sdist,
+    upload,
+)
+
+__all__ = [
+    "build",
+    "build_py",
+    "build_ext",
+    "build_clib",
+    "build_scripts",
+    "clean",
+    "install",
+    "install_lib",
+    "install_headers",
+    "install_scripts",
+    "install_data",
+    "sdist",
+    "register",
+    "bdist",
+    "bdist_dumb",
+    "bdist_rpm",
+    "check",
+    "upload",
+]
+
+if sys.version_info < (3, 10):
+    from . import bdist_wininst
+
+    __all__ += ["bdist_wininst"]
diff --git a/mypy/typeshed/stdlib/distutils/command/bdist.pyi b/mypy/typeshed/stdlib/distutils/command/bdist.pyi
index e1f141d3a40f..6f996207077e 100644
--- a/mypy/typeshed/stdlib/distutils/command/bdist.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/bdist.pyi
@@ -1,4 +1,6 @@
-from typing import Any
+from _typeshed import Incomplete, Unused
+from collections.abc import Callable
+from typing import ClassVar
 
 from ..cmd import Command
 
@@ -6,20 +8,20 @@ def show_formats() -> None: ...
 
 class bdist(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    help_options: Any
-    no_format_option: Any
-    default_format: Any
-    format_commands: Any
-    format_command: Any
-    bdist_base: Any
-    plat_name: Any
-    formats: Any
-    dist_dir: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], Unused]]]]
+    no_format_option: ClassVar[tuple[str, ...]]
+    default_format: ClassVar[dict[str, str]]
+    format_commands: ClassVar[list[str]]
+    format_command: ClassVar[dict[str, tuple[str, str]]]
+    bdist_base: Incomplete
+    plat_name: Incomplete
+    formats: Incomplete
+    dist_dir: Incomplete
     skip_build: int
-    group: Any
-    owner: Any
+    group: Incomplete
+    owner: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/bdist_dumb.pyi b/mypy/typeshed/stdlib/distutils/command/bdist_dumb.pyi
index 74cca4d13cd0..297a0c39ed43 100644
--- a/mypy/typeshed/stdlib/distutils/command/bdist_dumb.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/bdist_dumb.pyi
@@ -1,21 +1,22 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 
 class bdist_dumb(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    default_format: Any
-    bdist_dir: Any
-    plat_name: Any
-    format: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    default_format: ClassVar[dict[str, str]]
+    bdist_dir: Incomplete
+    plat_name: Incomplete
+    format: Incomplete
     keep_temp: int
-    dist_dir: Any
-    skip_build: Any
+    dist_dir: Incomplete
+    skip_build: Incomplete
     relative: int
-    owner: Any
-    group: Any
+    owner: Incomplete
+    group: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/bdist_msi.pyi b/mypy/typeshed/stdlib/distutils/command/bdist_msi.pyi
index fa98e86d592a..baeee7d3eccb 100644
--- a/mypy/typeshed/stdlib/distutils/command/bdist_msi.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/bdist_msi.pyi
@@ -1,42 +1,43 @@
 import sys
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar, Literal
 
 from ..cmd import Command
 
 if sys.platform == "win32":
-    from msilib import Dialog
+    from msilib import Control, Dialog
 
     class PyDialog(Dialog):
         def __init__(self, *args, **kw) -> None: ...
         def title(self, title) -> None: ...
-        def back(self, title, next, name: str = "Back", active: int = 1): ...
-        def cancel(self, title, next, name: str = "Cancel", active: int = 1): ...
-        def next(self, title, next, name: str = "Next", active: int = 1): ...
-        def xbutton(self, name, title, next, xpos): ...
+        def back(self, title, next, name: str = "Back", active: bool | Literal[0, 1] = 1) -> Control: ...
+        def cancel(self, title, next, name: str = "Cancel", active: bool | Literal[0, 1] = 1) -> Control: ...
+        def next(self, title, next, name: str = "Next", active: bool | Literal[0, 1] = 1) -> Control: ...
+        def xbutton(self, name, title, next, xpos) -> Control: ...
 
     class bdist_msi(Command):
         description: str
-        user_options: Any
-        boolean_options: Any
-        all_versions: Any
+        user_options: ClassVar[list[tuple[str, str | None, str]]]
+        boolean_options: ClassVar[list[str]]
+        all_versions: Incomplete
         other_version: str
         if sys.version_info >= (3, 9):
             def __init__(self, *args, **kw) -> None: ...
-        bdist_dir: Any
-        plat_name: Any
+        bdist_dir: Incomplete
+        plat_name: Incomplete
         keep_temp: int
         no_target_compile: int
         no_target_optimize: int
-        target_version: Any
-        dist_dir: Any
-        skip_build: Any
-        install_script: Any
-        pre_install_script: Any
-        versions: Any
+        target_version: Incomplete
+        dist_dir: Incomplete
+        skip_build: Incomplete
+        install_script: Incomplete
+        pre_install_script: Incomplete
+        versions: Incomplete
         def initialize_options(self) -> None: ...
-        install_script_key: Any
+        install_script_key: Incomplete
         def finalize_options(self) -> None: ...
-        db: Any
+        db: Incomplete
         def run(self) -> None: ...
         def add_files(self) -> None: ...
         def add_find_python(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/bdist_rpm.pyi b/mypy/typeshed/stdlib/distutils/command/bdist_rpm.pyi
index 76691310b599..83b4161094c5 100644
--- a/mypy/typeshed/stdlib/distutils/command/bdist_rpm.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/bdist_rpm.pyi
@@ -1,50 +1,51 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 
 class bdist_rpm(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    negative_opt: Any
-    bdist_base: Any
-    rpm_base: Any
-    dist_dir: Any
-    python: Any
-    fix_python: Any
-    spec_only: Any
-    binary_only: Any
-    source_only: Any
-    use_bzip2: Any
-    distribution_name: Any
-    group: Any
-    release: Any
-    serial: Any
-    vendor: Any
-    packager: Any
-    doc_files: Any
-    changelog: Any
-    icon: Any
-    prep_script: Any
-    build_script: Any
-    install_script: Any
-    clean_script: Any
-    verify_script: Any
-    pre_install: Any
-    post_install: Any
-    pre_uninstall: Any
-    post_uninstall: Any
-    prep: Any
-    provides: Any
-    requires: Any
-    conflicts: Any
-    build_requires: Any
-    obsoletes: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    negative_opt: ClassVar[dict[str, str]]
+    bdist_base: Incomplete
+    rpm_base: Incomplete
+    dist_dir: Incomplete
+    python: Incomplete
+    fix_python: Incomplete
+    spec_only: Incomplete
+    binary_only: Incomplete
+    source_only: Incomplete
+    use_bzip2: Incomplete
+    distribution_name: Incomplete
+    group: Incomplete
+    release: Incomplete
+    serial: Incomplete
+    vendor: Incomplete
+    packager: Incomplete
+    doc_files: Incomplete
+    changelog: Incomplete
+    icon: Incomplete
+    prep_script: Incomplete
+    build_script: Incomplete
+    install_script: Incomplete
+    clean_script: Incomplete
+    verify_script: Incomplete
+    pre_install: Incomplete
+    post_install: Incomplete
+    pre_uninstall: Incomplete
+    post_uninstall: Incomplete
+    prep: Incomplete
+    provides: Incomplete
+    requires: Incomplete
+    conflicts: Incomplete
+    build_requires: Incomplete
+    obsoletes: Incomplete
     keep_temp: int
     use_rpm_opt_flags: int
     rpm3_mode: int
     no_autoreq: int
-    force_arch: Any
+    force_arch: Incomplete
     quiet: int
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/bdist_wininst.pyi b/mypy/typeshed/stdlib/distutils/command/bdist_wininst.pyi
index 8491d3126200..cf333bc5400d 100644
--- a/mypy/typeshed/stdlib/distutils/command/bdist_wininst.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/bdist_wininst.pyi
@@ -1,10 +1,10 @@
 from _typeshed import StrOrBytesPath
 from distutils.cmd import Command
-from typing import Any, ClassVar
+from typing import ClassVar
 
 class bdist_wininst(Command):
     description: ClassVar[str]
-    user_options: ClassVar[list[tuple[Any, ...]]]
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
     boolean_options: ClassVar[list[str]]
 
     def initialize_options(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/build.pyi b/mypy/typeshed/stdlib/distutils/command/build.pyi
index cf3c8a562ff3..3ec0c9614d62 100644
--- a/mypy/typeshed/stdlib/distutils/command/build.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/build.pyi
@@ -1,4 +1,6 @@
-from typing import Any
+from _typeshed import Incomplete, Unused
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from ..cmd import Command
 
@@ -6,21 +8,21 @@ def show_compilers() -> None: ...
 
 class build(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    help_options: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], Unused]]]]
     build_base: str
-    build_purelib: Any
-    build_platlib: Any
-    build_lib: Any
-    build_temp: Any
-    build_scripts: Any
-    compiler: Any
-    plat_name: Any
-    debug: Any
+    build_purelib: Incomplete
+    build_platlib: Incomplete
+    build_lib: Incomplete
+    build_temp: Incomplete
+    build_scripts: Incomplete
+    compiler: Incomplete
+    plat_name: Incomplete
+    debug: Incomplete
     force: int
-    executable: Any
-    parallel: Any
+    executable: Incomplete
+    parallel: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
@@ -28,4 +30,5 @@ class build(Command):
     def has_c_libraries(self): ...
     def has_ext_modules(self): ...
     def has_scripts(self): ...
-    sub_commands: Any
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
diff --git a/mypy/typeshed/stdlib/distutils/command/build_clib.pyi b/mypy/typeshed/stdlib/distutils/command/build_clib.pyi
index 32ab182b30d0..69cfbe7120d8 100644
--- a/mypy/typeshed/stdlib/distutils/command/build_clib.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/build_clib.pyi
@@ -1,4 +1,6 @@
-from typing import Any
+from _typeshed import Incomplete, Unused
+from collections.abc import Callable
+from typing import ClassVar
 
 from ..cmd import Command
 
@@ -6,18 +8,18 @@ def show_compilers() -> None: ...
 
 class build_clib(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    help_options: Any
-    build_clib: Any
-    build_temp: Any
-    libraries: Any
-    include_dirs: Any
-    define: Any
-    undef: Any
-    debug: Any
+    user_options: ClassVar[list[tuple[str, str, str]]]
+    boolean_options: ClassVar[list[str]]
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], Unused]]]]
+    build_clib: Incomplete
+    build_temp: Incomplete
+    libraries: Incomplete
+    include_dirs: Incomplete
+    define: Incomplete
+    undef: Incomplete
+    debug: Incomplete
     force: int
-    compiler: Any
+    compiler: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/build_ext.pyi b/mypy/typeshed/stdlib/distutils/command/build_ext.pyi
index 5eb541fb9101..c5a9b5d508f0 100644
--- a/mypy/typeshed/stdlib/distutils/command/build_ext.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/build_ext.pyi
@@ -1,38 +1,40 @@
-from typing import Any
+from _typeshed import Incomplete, Unused
+from collections.abc import Callable
+from typing import ClassVar
 
 from ..cmd import Command
 
-extension_name_re: Any
+extension_name_re: Incomplete
 
 def show_compilers() -> None: ...
 
 class build_ext(Command):
     description: str
-    sep_by: Any
-    user_options: Any
-    boolean_options: Any
-    help_options: Any
-    extensions: Any
-    build_lib: Any
-    plat_name: Any
-    build_temp: Any
+    sep_by: Incomplete
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], Unused]]]]
+    extensions: Incomplete
+    build_lib: Incomplete
+    plat_name: Incomplete
+    build_temp: Incomplete
     inplace: int
-    package: Any
-    include_dirs: Any
-    define: Any
-    undef: Any
-    libraries: Any
-    library_dirs: Any
-    rpath: Any
-    link_objects: Any
-    debug: Any
-    force: Any
-    compiler: Any
-    swig: Any
-    swig_cpp: Any
-    swig_opts: Any
-    user: Any
-    parallel: Any
+    package: Incomplete
+    include_dirs: Incomplete
+    define: Incomplete
+    undef: Incomplete
+    libraries: Incomplete
+    library_dirs: Incomplete
+    rpath: Incomplete
+    link_objects: Incomplete
+    debug: Incomplete
+    force: Incomplete
+    compiler: Incomplete
+    swig: Incomplete
+    swig_cpp: Incomplete
+    swig_opts: Incomplete
+    user: Incomplete
+    parallel: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/build_py.pyi b/mypy/typeshed/stdlib/distutils/command/build_py.pyi
index ca4e4ed7e797..23ed230bb2d8 100644
--- a/mypy/typeshed/stdlib/distutils/command/build_py.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/build_py.pyi
@@ -1,24 +1,25 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar, Literal
 
 from ..cmd import Command
 from ..util import Mixin2to3 as Mixin2to3
 
 class build_py(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    negative_opt: Any
-    build_lib: Any
-    py_modules: Any
-    package: Any
-    package_data: Any
-    package_dir: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    negative_opt: ClassVar[dict[str, str]]
+    build_lib: Incomplete
+    py_modules: Incomplete
+    package: Incomplete
+    package_data: Incomplete
+    package_dir: Incomplete
     compile: int
     optimize: int
-    force: Any
+    force: Incomplete
     def initialize_options(self) -> None: ...
-    packages: Any
-    data_files: Any
+    packages: Incomplete
+    data_files: Incomplete
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
     def get_data_files(self): ...
@@ -32,13 +33,13 @@ class build_py(Command):
     def find_all_modules(self): ...
     def get_source_files(self): ...
     def get_module_outfile(self, build_dir, package, module): ...
-    def get_outputs(self, include_bytecode: int = 1): ...
+    def get_outputs(self, include_bytecode: bool | Literal[0, 1] = 1) -> list[str]: ...
     def build_module(self, module, module_file, package): ...
     def build_modules(self) -> None: ...
     def build_packages(self) -> None: ...
     def byte_compile(self, files) -> None: ...
 
 class build_py_2to3(build_py, Mixin2to3):
-    updated_files: Any
+    updated_files: Incomplete
     def run(self) -> None: ...
     def build_module(self, module, module_file, package): ...
diff --git a/mypy/typeshed/stdlib/distutils/command/build_scripts.pyi b/mypy/typeshed/stdlib/distutils/command/build_scripts.pyi
index 42135eceafef..8372919bbd53 100644
--- a/mypy/typeshed/stdlib/distutils/command/build_scripts.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/build_scripts.pyi
@@ -1,19 +1,20 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 from ..util import Mixin2to3 as Mixin2to3
 
-first_line_re: Any
+first_line_re: Incomplete
 
 class build_scripts(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    build_dir: Any
-    scripts: Any
-    force: Any
-    executable: Any
-    outfiles: Any
+    user_options: ClassVar[list[tuple[str, str, str]]]
+    boolean_options: ClassVar[list[str]]
+    build_dir: Incomplete
+    scripts: Incomplete
+    force: Incomplete
+    executable: Incomplete
+    outfiles: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def get_source_files(self): ...
diff --git a/mypy/typeshed/stdlib/distutils/command/check.pyi b/mypy/typeshed/stdlib/distutils/command/check.pyi
index 9cbcc6c87f21..2c807fd2c439 100644
--- a/mypy/typeshed/stdlib/distutils/command/check.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/check.pyi
@@ -1,4 +1,5 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import Any, ClassVar, Final, Literal
 from typing_extensions import TypeAlias
 
 from ..cmd import Command
@@ -9,25 +10,25 @@ _Reporter: TypeAlias = Any  # really docutils.utils.Reporter
 # Depends on a third-party stub. Since distutils is deprecated anyway,
 # it's easier to just suppress the "any subclassing" error.
 class SilentReporter(_Reporter):
-    messages: Any
+    messages: Incomplete
     def __init__(
         self,
         source,
         report_level,
         halt_level,
-        stream: Any | None = ...,
-        debug: int = ...,
+        stream: Incomplete | None = ...,
+        debug: bool | Literal[0, 1] = 0,
         encoding: str = ...,
         error_handler: str = ...,
     ) -> None: ...
     def system_message(self, level, message, *children, **kwargs): ...
 
-HAS_DOCUTILS: bool
+HAS_DOCUTILS: Final[bool]
 
 class check(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
+    user_options: ClassVar[list[tuple[str, str, str]]]
+    boolean_options: ClassVar[list[str]]
     restructuredtext: int
     metadata: int
     strict: int
diff --git a/mypy/typeshed/stdlib/distutils/command/clean.pyi b/mypy/typeshed/stdlib/distutils/command/clean.pyi
index 99560aa8a716..0f3768d6dcf4 100644
--- a/mypy/typeshed/stdlib/distutils/command/clean.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/clean.pyi
@@ -1,17 +1,18 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 
 class clean(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    build_base: Any
-    build_lib: Any
-    build_temp: Any
-    build_scripts: Any
-    bdist_base: Any
-    all: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    build_base: Incomplete
+    build_lib: Incomplete
+    build_temp: Incomplete
+    build_scripts: Incomplete
+    bdist_base: Incomplete
+    all: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/config.pyi b/mypy/typeshed/stdlib/distutils/command/config.pyi
index 7077c9a4c158..562ff3a5271f 100644
--- a/mypy/typeshed/stdlib/distutils/command/config.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/config.pyi
@@ -1,16 +1,17 @@
+from _typeshed import Incomplete, StrOrBytesPath
 from collections.abc import Sequence
 from re import Pattern
-from typing import Any
+from typing import ClassVar, Final, Literal
 
 from ..ccompiler import CCompiler
 from ..cmd import Command
 
-LANG_EXT: dict[str, str]
+LANG_EXT: Final[dict[str, str]]
 
 class config(Command):
     description: str
     # Tuple is full name, short name, description
-    user_options: Sequence[tuple[str, str | None, str]]
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
     compiler: str | CCompiler
     cc: str | None
     include_dirs: Sequence[str] | None
@@ -65,8 +66,8 @@ class config(Command):
         include_dirs: Sequence[str] | None = None,
         libraries: Sequence[str] | None = None,
         library_dirs: Sequence[str] | None = None,
-        decl: int = 0,
-        call: int = 0,
+        decl: bool | Literal[0, 1] = 0,
+        call: bool | Literal[0, 1] = 0,
     ) -> bool: ...
     def check_lib(
         self,
@@ -80,4 +81,4 @@ class config(Command):
         self, header: str, include_dirs: Sequence[str] | None = None, library_dirs: Sequence[str] | None = None, lang: str = "c"
     ) -> bool: ...
 
-def dump_file(filename: str, head: Any | None = None) -> None: ...
+def dump_file(filename: StrOrBytesPath, head: Incomplete | None = None) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/install.pyi b/mypy/typeshed/stdlib/distutils/command/install.pyi
index 661d256e6f07..1714e01a2c28 100644
--- a/mypy/typeshed/stdlib/distutils/command/install.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/install.pyi
@@ -1,44 +1,51 @@
-from typing import Any
+import sys
+from _typeshed import Incomplete
+from collections.abc import Callable
+from typing import Any, ClassVar, Final, Literal
 
 from ..cmd import Command
 
-HAS_USER_SITE: bool
-SCHEME_KEYS: tuple[str, ...]
-INSTALL_SCHEMES: dict[str, dict[Any, Any]]
+HAS_USER_SITE: Final[bool]
+
+SCHEME_KEYS: Final[tuple[Literal["purelib"], Literal["platlib"], Literal["headers"], Literal["scripts"], Literal["data"]]]
+INSTALL_SCHEMES: Final[dict[str, dict[str, str]]]
+
+if sys.version_info < (3, 10):
+    WINDOWS_SCHEME: Final[dict[str, str]]
 
 class install(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    negative_opt: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    negative_opt: ClassVar[dict[str, str]]
     prefix: str | None
-    exec_prefix: Any
+    exec_prefix: Incomplete
     home: str | None
     user: bool
-    install_base: Any
-    install_platbase: Any
+    install_base: Incomplete
+    install_platbase: Incomplete
     root: str | None
-    install_purelib: Any
-    install_platlib: Any
-    install_headers: Any
+    install_purelib: Incomplete
+    install_platlib: Incomplete
+    install_headers: Incomplete
     install_lib: str | None
-    install_scripts: Any
-    install_data: Any
-    install_userbase: Any
-    install_usersite: Any
-    compile: Any
-    optimize: Any
-    extra_path: Any
+    install_scripts: Incomplete
+    install_data: Incomplete
+    install_userbase: Incomplete
+    install_usersite: Incomplete
+    compile: Incomplete
+    optimize: Incomplete
+    extra_path: Incomplete
     install_path_file: int
     force: int
     skip_build: int
     warn_dir: int
-    build_base: Any
-    build_lib: Any
-    record: Any
+    build_base: Incomplete
+    build_lib: Incomplete
+    record: Incomplete
     def initialize_options(self) -> None: ...
-    config_vars: Any
-    install_libbase: Any
+    config_vars: Incomplete
+    install_libbase: Incomplete
     def finalize_options(self) -> None: ...
     def dump_dirs(self, msg) -> None: ...
     def finalize_unix(self) -> None: ...
@@ -47,8 +54,8 @@ class install(Command):
     def expand_basedirs(self) -> None: ...
     def expand_dirs(self) -> None: ...
     def convert_paths(self, *names) -> None: ...
-    path_file: Any
-    extra_dirs: Any
+    path_file: Incomplete
+    extra_dirs: Incomplete
     def handle_extra_path(self) -> None: ...
     def change_roots(self, *names) -> None: ...
     def create_home_path(self) -> None: ...
@@ -60,4 +67,5 @@ class install(Command):
     def has_headers(self): ...
     def has_scripts(self): ...
     def has_data(self): ...
-    sub_commands: Any
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
diff --git a/mypy/typeshed/stdlib/distutils/command/install_data.pyi b/mypy/typeshed/stdlib/distutils/command/install_data.pyi
index 6cc9b528ac9d..609de62b04b5 100644
--- a/mypy/typeshed/stdlib/distutils/command/install_data.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/install_data.pyi
@@ -1,16 +1,17 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 
 class install_data(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    install_dir: Any
-    outfiles: Any
-    root: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    install_dir: Incomplete
+    outfiles: Incomplete
+    root: Incomplete
     force: int
-    data_files: Any
+    data_files: Incomplete
     warn_dir: int
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/install_egg_info.pyi b/mypy/typeshed/stdlib/distutils/command/install_egg_info.pyi
index 776eafc1de09..75bb906ce582 100644
--- a/mypy/typeshed/stdlib/distutils/command/install_egg_info.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/install_egg_info.pyi
@@ -1,14 +1,15 @@
-from typing import Any, ClassVar
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 
 class install_egg_info(Command):
     description: ClassVar[str]
-    user_options: ClassVar[list[tuple[str, str | None, str]]]
-    install_dir: Any
+    user_options: ClassVar[list[tuple[str, str, str]]]
+    install_dir: Incomplete
     def initialize_options(self) -> None: ...
-    target: Any
-    outputs: Any
+    target: Incomplete
+    outputs: Incomplete
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
     def get_outputs(self) -> list[str]: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/install_headers.pyi b/mypy/typeshed/stdlib/distutils/command/install_headers.pyi
index 795bd1cf8356..3caad8a07dca 100644
--- a/mypy/typeshed/stdlib/distutils/command/install_headers.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/install_headers.pyi
@@ -1,14 +1,15 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 
 class install_headers(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    install_dir: Any
+    user_options: ClassVar[list[tuple[str, str, str]]]
+    boolean_options: ClassVar[list[str]]
+    install_dir: Incomplete
     force: int
-    outfiles: Any
+    outfiles: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/install_lib.pyi b/mypy/typeshed/stdlib/distutils/command/install_lib.pyi
index a6a5e4e73f4c..a537e254904a 100644
--- a/mypy/typeshed/stdlib/distutils/command/install_lib.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/install_lib.pyi
@@ -1,20 +1,21 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar, Final
 
 from ..cmd import Command
 
-PYTHON_SOURCE_EXTENSION: str
+PYTHON_SOURCE_EXTENSION: Final = ".py"
 
 class install_lib(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    negative_opt: Any
-    install_dir: Any
-    build_dir: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    negative_opt: ClassVar[dict[str, str]]
+    install_dir: Incomplete
+    build_dir: Incomplete
     force: int
-    compile: Any
-    optimize: Any
-    skip_build: Any
+    compile: Incomplete
+    optimize: Incomplete
+    skip_build: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/install_scripts.pyi b/mypy/typeshed/stdlib/distutils/command/install_scripts.pyi
index 92728a16a747..658594f32e43 100644
--- a/mypy/typeshed/stdlib/distutils/command/install_scripts.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/install_scripts.pyi
@@ -1,18 +1,19 @@
-from typing import Any
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..cmd import Command
 
 class install_scripts(Command):
     description: str
-    user_options: Any
-    boolean_options: Any
-    install_dir: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    install_dir: Incomplete
     force: int
-    build_dir: Any
-    skip_build: Any
+    build_dir: Incomplete
+    skip_build: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
-    outfiles: Any
+    outfiles: Incomplete
     def run(self) -> None: ...
     def get_inputs(self): ...
     def get_outputs(self): ...
diff --git a/mypy/typeshed/stdlib/distutils/command/register.pyi b/mypy/typeshed/stdlib/distutils/command/register.pyi
index f88b94113ff4..cf98e178a9ba 100644
--- a/mypy/typeshed/stdlib/distutils/command/register.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/register.pyi
@@ -1,10 +1,13 @@
-from typing import Any
+from _typeshed import Incomplete
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from ..config import PyPIRCCommand
 
 class register(PyPIRCCommand):
     description: str
-    sub_commands: Any
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
     list_classifiers: int
     strict: int
     def initialize_options(self) -> None: ...
@@ -15,4 +18,4 @@ class register(PyPIRCCommand):
     def verify_metadata(self) -> None: ...
     def send_metadata(self) -> None: ...
     def build_post_data(self, action): ...
-    def post_to_server(self, data, auth: Any | None = None): ...
+    def post_to_server(self, data, auth: Incomplete | None = None): ...
diff --git a/mypy/typeshed/stdlib/distutils/command/sdist.pyi b/mypy/typeshed/stdlib/distutils/command/sdist.pyi
index 636c4a351d19..48a140714dda 100644
--- a/mypy/typeshed/stdlib/distutils/command/sdist.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/sdist.pyi
@@ -1,4 +1,6 @@
-from typing import Any
+from _typeshed import Incomplete, Unused
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from ..cmd import Command
 
@@ -7,28 +9,29 @@ def show_formats() -> None: ...
 class sdist(Command):
     description: str
     def checking_metadata(self): ...
-    user_options: Any
-    boolean_options: Any
-    help_options: Any
-    negative_opt: Any
-    sub_commands: Any
-    READMES: Any
-    template: Any
-    manifest: Any
+    user_options: ClassVar[list[tuple[str, str | None, str]]]
+    boolean_options: ClassVar[list[str]]
+    help_options: ClassVar[list[tuple[str, str | None, str, Callable[[], Unused]]]]
+    negative_opt: ClassVar[dict[str, str]]
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
+    READMES: ClassVar[tuple[str, ...]]
+    template: Incomplete
+    manifest: Incomplete
     use_defaults: int
     prune: int
     manifest_only: int
     force_manifest: int
-    formats: Any
+    formats: Incomplete
     keep_temp: int
-    dist_dir: Any
-    archive_files: Any
+    dist_dir: Incomplete
+    archive_files: Incomplete
     metadata_check: int
-    owner: Any
-    group: Any
+    owner: Incomplete
+    group: Incomplete
     def initialize_options(self) -> None: ...
     def finalize_options(self) -> None: ...
-    filelist: Any
+    filelist: Incomplete
     def run(self) -> None: ...
     def check_metadata(self) -> None: ...
     def get_file_list(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/command/upload.pyi b/mypy/typeshed/stdlib/distutils/command/upload.pyi
index e6b77825c5f5..afcfbaf48677 100644
--- a/mypy/typeshed/stdlib/distutils/command/upload.pyi
+++ b/mypy/typeshed/stdlib/distutils/command/upload.pyi
@@ -1,4 +1,5 @@
-from typing import Any, ClassVar
+from _typeshed import Incomplete
+from typing import ClassVar
 
 from ..config import PyPIRCCommand
 
@@ -8,10 +9,10 @@ class upload(PyPIRCCommand):
     password: str
     show_response: int
     sign: bool
-    identity: Any
+    identity: Incomplete
     def initialize_options(self) -> None: ...
-    repository: Any
-    realm: Any
+    repository: Incomplete
+    realm: Incomplete
     def finalize_options(self) -> None: ...
     def run(self) -> None: ...
     def upload_file(self, command: str, pyversion: str, filename: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/core.pyi b/mypy/typeshed/stdlib/distutils/core.pyi
index 7b0bdd1b35bd..174f24991351 100644
--- a/mypy/typeshed/stdlib/distutils/core.pyi
+++ b/mypy/typeshed/stdlib/distutils/core.pyi
@@ -1,11 +1,11 @@
-from _typeshed import StrOrBytesPath
+from _typeshed import Incomplete, StrOrBytesPath
 from collections.abc import Mapping
 from distutils.cmd import Command as Command
 from distutils.dist import Distribution as Distribution
 from distutils.extension import Extension as Extension
-from typing import Any
+from typing import Any, Final, Literal
 
-USAGE: str
+USAGE: Final[str]
 
 def gen_usage(script_name: StrOrBytesPath) -> str: ...
 
@@ -32,7 +32,7 @@ def setup(
     distclass: type[Distribution] = ...,
     script_name: str = ...,
     script_args: list[str] = ...,
-    options: Mapping[str, Any] = ...,
+    options: Mapping[str, Incomplete] = ...,
     license: str = ...,
     keywords: list[str] | str = ...,
     platforms: list[str] | str = ...,
@@ -43,15 +43,16 @@ def setup(
     provides: list[str] = ...,
     requires: list[str] = ...,
     command_packages: list[str] = ...,
-    command_options: Mapping[str, Mapping[str, tuple[Any, Any]]] = ...,
+    command_options: Mapping[str, Mapping[str, tuple[Incomplete, Incomplete]]] = ...,
     package_data: Mapping[str, list[str]] = ...,
-    include_package_data: bool = ...,
+    include_package_data: bool | Literal[0, 1] = ...,
     libraries: list[str] = ...,
     headers: list[str] = ...,
     ext_package: str = ...,
     include_dirs: list[str] = ...,
     password: str = ...,
     fullname: str = ...,
+    # Custom Distributions could accept more params
     **attrs: Any,
-) -> None: ...
+) -> Distribution: ...
 def run_setup(script_name: str, script_args: list[str] | None = None, stop_after: str = "run") -> Distribution: ...
diff --git a/mypy/typeshed/stdlib/distutils/cygwinccompiler.pyi b/mypy/typeshed/stdlib/distutils/cygwinccompiler.pyi
index a990c3e28f36..80924d63e471 100644
--- a/mypy/typeshed/stdlib/distutils/cygwinccompiler.pyi
+++ b/mypy/typeshed/stdlib/distutils/cygwinccompiler.pyi
@@ -1,20 +1,20 @@
 from distutils.unixccompiler import UnixCCompiler
 from distutils.version import LooseVersion
 from re import Pattern
-from typing_extensions import Literal
+from typing import Final, Literal
 
 def get_msvcr() -> list[str] | None: ...
 
 class CygwinCCompiler(UnixCCompiler): ...
 class Mingw32CCompiler(CygwinCCompiler): ...
 
-CONFIG_H_OK: str
-CONFIG_H_NOTOK: str
-CONFIG_H_UNCERTAIN: str
+CONFIG_H_OK: Final = "ok"
+CONFIG_H_NOTOK: Final = "not ok"
+CONFIG_H_UNCERTAIN: Final = "uncertain"
 
 def check_config_h() -> tuple[Literal["ok", "not ok", "uncertain"], str]: ...
 
-RE_VERSION: Pattern[bytes]
+RE_VERSION: Final[Pattern[bytes]]
 
 def get_versions() -> tuple[LooseVersion | None, ...]: ...
 def is_cygwingcc() -> bool: ...
diff --git a/mypy/typeshed/stdlib/distutils/debug.pyi b/mypy/typeshed/stdlib/distutils/debug.pyi
index 11f28a8bc8ae..30095883b064 100644
--- a/mypy/typeshed/stdlib/distutils/debug.pyi
+++ b/mypy/typeshed/stdlib/distutils/debug.pyi
@@ -1 +1,3 @@
-DEBUG: bool | None
+from typing import Final
+
+DEBUG: Final[str | None]
diff --git a/mypy/typeshed/stdlib/distutils/dep_util.pyi b/mypy/typeshed/stdlib/distutils/dep_util.pyi
index 096ce19d4859..058377accabc 100644
--- a/mypy/typeshed/stdlib/distutils/dep_util.pyi
+++ b/mypy/typeshed/stdlib/distutils/dep_util.pyi
@@ -1,3 +1,14 @@
-def newer(source: str, target: str) -> bool: ...
-def newer_pairwise(sources: list[str], targets: list[str]) -> list[tuple[str, str]]: ...
-def newer_group(sources: list[str], target: str, missing: str = "error") -> bool: ...
+from _typeshed import StrOrBytesPath, SupportsLenAndGetItem
+from collections.abc import Iterable
+from typing import Literal, TypeVar
+
+_SourcesT = TypeVar("_SourcesT", bound=StrOrBytesPath)
+_TargetsT = TypeVar("_TargetsT", bound=StrOrBytesPath)
+
+def newer(source: StrOrBytesPath, target: StrOrBytesPath) -> bool | Literal[1]: ...
+def newer_pairwise(
+    sources: SupportsLenAndGetItem[_SourcesT], targets: SupportsLenAndGetItem[_TargetsT]
+) -> tuple[list[_SourcesT], list[_TargetsT]]: ...
+def newer_group(
+    sources: Iterable[StrOrBytesPath], target: StrOrBytesPath, missing: Literal["error", "ignore", "newer"] = "error"
+) -> Literal[0, 1]: ...
diff --git a/mypy/typeshed/stdlib/distutils/dir_util.pyi b/mypy/typeshed/stdlib/distutils/dir_util.pyi
index 2324a2d50caa..23e2c3bc28b9 100644
--- a/mypy/typeshed/stdlib/distutils/dir_util.pyi
+++ b/mypy/typeshed/stdlib/distutils/dir_util.pyi
@@ -1,13 +1,23 @@
-def mkpath(name: str, mode: int = 0o777, verbose: int = 1, dry_run: int = 0) -> list[str]: ...
-def create_tree(base_dir: str, files: list[str], mode: int = 0o777, verbose: int = 1, dry_run: int = 0) -> None: ...
+from _typeshed import StrOrBytesPath, StrPath
+from collections.abc import Iterable
+from typing import Literal
+
+def mkpath(name: str, mode: int = 0o777, verbose: bool | Literal[0, 1] = 1, dry_run: bool | Literal[0, 1] = 0) -> list[str]: ...
+def create_tree(
+    base_dir: StrPath,
+    files: Iterable[StrPath],
+    mode: int = 0o777,
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
+) -> None: ...
 def copy_tree(
-    src: str,
+    src: StrPath,
     dst: str,
-    preserve_mode: int = 1,
-    preserve_times: int = 1,
-    preserve_symlinks: int = 0,
-    update: int = 0,
-    verbose: int = 1,
-    dry_run: int = 0,
+    preserve_mode: bool | Literal[0, 1] = 1,
+    preserve_times: bool | Literal[0, 1] = 1,
+    preserve_symlinks: bool | Literal[0, 1] = 0,
+    update: bool | Literal[0, 1] = 0,
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
 ) -> list[str]: ...
-def remove_tree(directory: str, verbose: int = 1, dry_run: int = 0) -> None: ...
+def remove_tree(directory: StrOrBytesPath, verbose: bool | Literal[0, 1] = 1, dry_run: bool | Literal[0, 1] = 0) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/dist.pyi b/mypy/typeshed/stdlib/distutils/dist.pyi
index b296b11f73ba..09f2b456d263 100644
--- a/mypy/typeshed/stdlib/distutils/dist.pyi
+++ b/mypy/typeshed/stdlib/distutils/dist.pyi
@@ -1,8 +1,28 @@
-from _typeshed import FileDescriptorOrPath, Incomplete, SupportsWrite
-from collections.abc import Iterable, Mapping
+from _typeshed import Incomplete, StrOrBytesPath, StrPath, SupportsWrite
+from collections.abc import Iterable, MutableMapping
 from distutils.cmd import Command
+from distutils.command.bdist import bdist
+from distutils.command.bdist_dumb import bdist_dumb
+from distutils.command.bdist_rpm import bdist_rpm
+from distutils.command.build import build
+from distutils.command.build_clib import build_clib
+from distutils.command.build_ext import build_ext
+from distutils.command.build_py import build_py
+from distutils.command.build_scripts import build_scripts
+from distutils.command.check import check
+from distutils.command.clean import clean
+from distutils.command.config import config
+from distutils.command.install import install
+from distutils.command.install_data import install_data
+from distutils.command.install_egg_info import install_egg_info
+from distutils.command.install_headers import install_headers
+from distutils.command.install_lib import install_lib
+from distutils.command.install_scripts import install_scripts
+from distutils.command.register import register
+from distutils.command.sdist import sdist
+from distutils.command.upload import upload
 from re import Pattern
-from typing import IO, Any, ClassVar, TypeVar, overload
+from typing import IO, ClassVar, Literal, TypeVar, overload
 from typing_extensions import TypeAlias
 
 command_re: Pattern[str]
@@ -11,7 +31,7 @@ _OptionsList: TypeAlias = list[tuple[str, str | None, str, int] | tuple[str, str
 _CommandT = TypeVar("_CommandT", bound=Command)
 
 class DistributionMetadata:
-    def __init__(self, path: FileDescriptorOrPath | None = None) -> None: ...
+    def __init__(self, path: StrOrBytesPath | None = None) -> None: ...
     name: str | None
     version: str | None
     author: str | None
@@ -30,7 +50,7 @@ class DistributionMetadata:
     requires: list[str] | None
     obsoletes: list[str] | None
     def read_pkg_file(self, file: IO[str]) -> None: ...
-    def write_pkg_info(self, base_dir: str) -> None: ...
+    def write_pkg_info(self, base_dir: StrPath) -> None: ...
     def write_pkg_file(self, file: SupportsWrite[str]) -> None: ...
     def get_name(self) -> str: ...
     def get_version(self) -> str: ...
@@ -60,18 +80,17 @@ class DistributionMetadata:
 class Distribution:
     cmdclass: dict[str, type[Command]]
     metadata: DistributionMetadata
-    def __init__(self, attrs: Mapping[str, Any] | None = None) -> None: ...
+    def __init__(self, attrs: MutableMapping[str, Incomplete] | None = None) -> None: ...
     def get_option_dict(self, command: str) -> dict[str, tuple[str, str]]: ...
     def parse_config_files(self, filenames: Iterable[str] | None = None) -> None: ...
-    def get_command_obj(self, command: str, create: bool = True) -> Command | None: ...
     global_options: ClassVar[_OptionsList]
     common_usage: ClassVar[str]
     display_options: ClassVar[_OptionsList]
     display_option_names: ClassVar[list[str]]
     negative_opt: ClassVar[dict[str, str]]
-    verbose: int
-    dry_run: int
-    help: int
+    verbose: bool | Literal[0, 1]
+    dry_run: bool | Literal[0, 1]
+    help: bool | Literal[0, 1]
     command_packages: list[str] | None
     script_name: str | None
     script_args: list[str] | None
@@ -105,8 +124,137 @@ class Distribution:
     def print_commands(self) -> None: ...
     def get_command_list(self): ...
     def get_command_packages(self): ...
+    # NOTE: This list comes directly from the distutils/command folder. Minus bdist_msi and bdist_wininst.
+    @overload
+    def get_command_obj(self, command: Literal["bdist"], create: Literal[1, True] = 1) -> bdist: ...
+    @overload
+    def get_command_obj(self, command: Literal["bdist_dumb"], create: Literal[1, True] = 1) -> bdist_dumb: ...
+    @overload
+    def get_command_obj(self, command: Literal["bdist_rpm"], create: Literal[1, True] = 1) -> bdist_rpm: ...
+    @overload
+    def get_command_obj(self, command: Literal["build"], create: Literal[1, True] = 1) -> build: ...
+    @overload
+    def get_command_obj(self, command: Literal["build_clib"], create: Literal[1, True] = 1) -> build_clib: ...
+    @overload
+    def get_command_obj(self, command: Literal["build_ext"], create: Literal[1, True] = 1) -> build_ext: ...
+    @overload
+    def get_command_obj(self, command: Literal["build_py"], create: Literal[1, True] = 1) -> build_py: ...
+    @overload
+    def get_command_obj(self, command: Literal["build_scripts"], create: Literal[1, True] = 1) -> build_scripts: ...
+    @overload
+    def get_command_obj(self, command: Literal["check"], create: Literal[1, True] = 1) -> check: ...
+    @overload
+    def get_command_obj(self, command: Literal["clean"], create: Literal[1, True] = 1) -> clean: ...
+    @overload
+    def get_command_obj(self, command: Literal["config"], create: Literal[1, True] = 1) -> config: ...
+    @overload
+    def get_command_obj(self, command: Literal["install"], create: Literal[1, True] = 1) -> install: ...
+    @overload
+    def get_command_obj(self, command: Literal["install_data"], create: Literal[1, True] = 1) -> install_data: ...
+    @overload
+    def get_command_obj(self, command: Literal["install_egg_info"], create: Literal[1, True] = 1) -> install_egg_info: ...
+    @overload
+    def get_command_obj(self, command: Literal["install_headers"], create: Literal[1, True] = 1) -> install_headers: ...
+    @overload
+    def get_command_obj(self, command: Literal["install_lib"], create: Literal[1, True] = 1) -> install_lib: ...
+    @overload
+    def get_command_obj(self, command: Literal["install_scripts"], create: Literal[1, True] = 1) -> install_scripts: ...
+    @overload
+    def get_command_obj(self, command: Literal["register"], create: Literal[1, True] = 1) -> register: ...
+    @overload
+    def get_command_obj(self, command: Literal["sdist"], create: Literal[1, True] = 1) -> sdist: ...
+    @overload
+    def get_command_obj(self, command: Literal["upload"], create: Literal[1, True] = 1) -> upload: ...
+    @overload
+    def get_command_obj(self, command: str, create: Literal[1, True] = 1) -> Command: ...
+    # Not replicating the overloads for "Command | None", user may use "isinstance"
+    @overload
+    def get_command_obj(self, command: str, create: Literal[0, False]) -> Command | None: ...
+    @overload
+    def get_command_class(self, command: Literal["bdist"]) -> type[bdist]: ...
+    @overload
+    def get_command_class(self, command: Literal["bdist_dumb"]) -> type[bdist_dumb]: ...
+    @overload
+    def get_command_class(self, command: Literal["bdist_rpm"]) -> type[bdist_rpm]: ...
+    @overload
+    def get_command_class(self, command: Literal["build"]) -> type[build]: ...
+    @overload
+    def get_command_class(self, command: Literal["build_clib"]) -> type[build_clib]: ...
+    @overload
+    def get_command_class(self, command: Literal["build_ext"]) -> type[build_ext]: ...
+    @overload
+    def get_command_class(self, command: Literal["build_py"]) -> type[build_py]: ...
+    @overload
+    def get_command_class(self, command: Literal["build_scripts"]) -> type[build_scripts]: ...
+    @overload
+    def get_command_class(self, command: Literal["check"]) -> type[check]: ...
+    @overload
+    def get_command_class(self, command: Literal["clean"]) -> type[clean]: ...
+    @overload
+    def get_command_class(self, command: Literal["config"]) -> type[config]: ...
+    @overload
+    def get_command_class(self, command: Literal["install"]) -> type[install]: ...
+    @overload
+    def get_command_class(self, command: Literal["install_data"]) -> type[install_data]: ...
+    @overload
+    def get_command_class(self, command: Literal["install_egg_info"]) -> type[install_egg_info]: ...
+    @overload
+    def get_command_class(self, command: Literal["install_headers"]) -> type[install_headers]: ...
+    @overload
+    def get_command_class(self, command: Literal["install_lib"]) -> type[install_lib]: ...
+    @overload
+    def get_command_class(self, command: Literal["install_scripts"]) -> type[install_scripts]: ...
+    @overload
+    def get_command_class(self, command: Literal["register"]) -> type[register]: ...
+    @overload
+    def get_command_class(self, command: Literal["sdist"]) -> type[sdist]: ...
+    @overload
+    def get_command_class(self, command: Literal["upload"]) -> type[upload]: ...
+    @overload
     def get_command_class(self, command: str) -> type[Command]: ...
     @overload
+    def reinitialize_command(self, command: Literal["bdist"], reinit_subcommands: bool = False) -> bdist: ...
+    @overload
+    def reinitialize_command(self, command: Literal["bdist_dumb"], reinit_subcommands: bool = False) -> bdist_dumb: ...
+    @overload
+    def reinitialize_command(self, command: Literal["bdist_rpm"], reinit_subcommands: bool = False) -> bdist_rpm: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build"], reinit_subcommands: bool = False) -> build: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build_clib"], reinit_subcommands: bool = False) -> build_clib: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build_ext"], reinit_subcommands: bool = False) -> build_ext: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build_py"], reinit_subcommands: bool = False) -> build_py: ...
+    @overload
+    def reinitialize_command(self, command: Literal["build_scripts"], reinit_subcommands: bool = False) -> build_scripts: ...
+    @overload
+    def reinitialize_command(self, command: Literal["check"], reinit_subcommands: bool = False) -> check: ...
+    @overload
+    def reinitialize_command(self, command: Literal["clean"], reinit_subcommands: bool = False) -> clean: ...
+    @overload
+    def reinitialize_command(self, command: Literal["config"], reinit_subcommands: bool = False) -> config: ...
+    @overload
+    def reinitialize_command(self, command: Literal["install"], reinit_subcommands: bool = False) -> install: ...
+    @overload
+    def reinitialize_command(self, command: Literal["install_data"], reinit_subcommands: bool = False) -> install_data: ...
+    @overload
+    def reinitialize_command(
+        self, command: Literal["install_egg_info"], reinit_subcommands: bool = False
+    ) -> install_egg_info: ...
+    @overload
+    def reinitialize_command(self, command: Literal["install_headers"], reinit_subcommands: bool = False) -> install_headers: ...
+    @overload
+    def reinitialize_command(self, command: Literal["install_lib"], reinit_subcommands: bool = False) -> install_lib: ...
+    @overload
+    def reinitialize_command(self, command: Literal["install_scripts"], reinit_subcommands: bool = False) -> install_scripts: ...
+    @overload
+    def reinitialize_command(self, command: Literal["register"], reinit_subcommands: bool = False) -> register: ...
+    @overload
+    def reinitialize_command(self, command: Literal["sdist"], reinit_subcommands: bool = False) -> sdist: ...
+    @overload
+    def reinitialize_command(self, command: Literal["upload"], reinit_subcommands: bool = False) -> upload: ...
+    @overload
     def reinitialize_command(self, command: str, reinit_subcommands: bool = False) -> Command: ...
     @overload
     def reinitialize_command(self, command: _CommandT, reinit_subcommands: bool = False) -> _CommandT: ...
@@ -122,7 +270,7 @@ class Distribution:
     def has_data_files(self) -> bool: ...
     def is_pure(self) -> bool: ...
 
-    # Getter methods generated in __init__
+    # Default getter methods generated in __init__ from self.metadata._METHOD_BASENAMES
     def get_name(self) -> str: ...
     def get_version(self) -> str: ...
     def get_fullname(self) -> str: ...
@@ -144,3 +292,26 @@ class Distribution:
     def get_requires(self) -> list[str]: ...
     def get_provides(self) -> list[str]: ...
     def get_obsoletes(self) -> list[str]: ...
+
+    # Default attributes generated in __init__ from self.display_option_names
+    help_commands: bool | Literal[0]
+    name: str | Literal[0]
+    version: str | Literal[0]
+    fullname: str | Literal[0]
+    author: str | Literal[0]
+    author_email: str | Literal[0]
+    maintainer: str | Literal[0]
+    maintainer_email: str | Literal[0]
+    contact: str | Literal[0]
+    contact_email: str | Literal[0]
+    url: str | Literal[0]
+    license: str | Literal[0]
+    licence: str | Literal[0]
+    description: str | Literal[0]
+    long_description: str | Literal[0]
+    platforms: str | list[str] | Literal[0]
+    classifiers: str | list[str] | Literal[0]
+    keywords: str | list[str] | Literal[0]
+    provides: list[str] | Literal[0]
+    requires: list[str] | Literal[0]
+    obsoletes: list[str] | Literal[0]
diff --git a/mypy/typeshed/stdlib/distutils/fancy_getopt.pyi b/mypy/typeshed/stdlib/distutils/fancy_getopt.pyi
index f9916d4511b2..e66d8cc9f2c5 100644
--- a/mypy/typeshed/stdlib/distutils/fancy_getopt.pyi
+++ b/mypy/typeshed/stdlib/distutils/fancy_getopt.pyi
@@ -1,31 +1,41 @@
 from collections.abc import Iterable, Mapping
+from getopt import _SliceableT, _StrSequenceT_co
 from re import Pattern
-from typing import Any, overload
+from typing import Any, Final, overload
 from typing_extensions import TypeAlias
 
 _Option: TypeAlias = tuple[str, str | None, str]
-_GR: TypeAlias = tuple[list[str], OptionDummy]
 
-longopt_pat: str
-longopt_re: Pattern[str]
-neg_alias_re: Pattern[str]
-longopt_xlate: dict[int, int]
+longopt_pat: Final = r"[a-zA-Z](?:[a-zA-Z0-9-]*)"
+longopt_re: Final[Pattern[str]]
+neg_alias_re: Final[Pattern[str]]
+longopt_xlate: Final[dict[int, int]]
 
 class FancyGetopt:
     def __init__(self, option_table: list[_Option] | None = None) -> None: ...
     # TODO kinda wrong, `getopt(object=object())` is invalid
     @overload
-    def getopt(self, args: list[str] | None = None) -> _GR: ...
+    def getopt(
+        self, args: _SliceableT[_StrSequenceT_co] | None = None, object: None = None
+    ) -> tuple[_StrSequenceT_co, OptionDummy]: ...
     @overload
-    def getopt(self, args: list[str] | None, object: Any) -> list[str]: ...
+    def getopt(
+        self, args: _SliceableT[_StrSequenceT_co] | None, object: Any
+    ) -> _StrSequenceT_co: ...  # object is an arbitrary non-slotted object
     def get_option_order(self) -> list[tuple[str, str]]: ...
     def generate_help(self, header: str | None = None) -> list[str]: ...
 
+# Same note as FancyGetopt.getopt
+@overload
 def fancy_getopt(
-    options: list[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: list[str] | None
-) -> list[str] | _GR: ...
+    options: list[_Option], negative_opt: Mapping[_Option, _Option], object: None, args: _SliceableT[_StrSequenceT_co] | None
+) -> tuple[_StrSequenceT_co, OptionDummy]: ...
+@overload
+def fancy_getopt(
+    options: list[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: _SliceableT[_StrSequenceT_co] | None
+) -> _StrSequenceT_co: ...
 
-WS_TRANS: dict[int, str]
+WS_TRANS: Final[dict[int, str]]
 
 def wrap_text(text: str, width: int) -> list[str]: ...
 def translate_longopt(opt: str) -> str: ...
diff --git a/mypy/typeshed/stdlib/distutils/file_util.pyi b/mypy/typeshed/stdlib/distutils/file_util.pyi
index a97dfca60007..873d23ea7e50 100644
--- a/mypy/typeshed/stdlib/distutils/file_util.pyi
+++ b/mypy/typeshed/stdlib/distutils/file_util.pyi
@@ -1,14 +1,38 @@
-from collections.abc import Sequence
+from _typeshed import BytesPath, StrOrBytesPath, StrPath
+from collections.abc import Iterable
+from typing import Literal, TypeVar, overload
 
+_StrPathT = TypeVar("_StrPathT", bound=StrPath)
+_BytesPathT = TypeVar("_BytesPathT", bound=BytesPath)
+
+@overload
+def copy_file(
+    src: StrPath,
+    dst: _StrPathT,
+    preserve_mode: bool | Literal[0, 1] = 1,
+    preserve_times: bool | Literal[0, 1] = 1,
+    update: bool | Literal[0, 1] = 0,
+    link: str | None = None,
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
+) -> tuple[_StrPathT | str, bool]: ...
+@overload
 def copy_file(
-    src: str,
-    dst: str,
-    preserve_mode: bool = ...,
-    preserve_times: bool = ...,
-    update: bool = ...,
+    src: BytesPath,
+    dst: _BytesPathT,
+    preserve_mode: bool | Literal[0, 1] = 1,
+    preserve_times: bool | Literal[0, 1] = 1,
+    update: bool | Literal[0, 1] = 0,
     link: str | None = None,
-    verbose: bool = ...,
-    dry_run: bool = ...,
-) -> tuple[str, str]: ...
-def move_file(src: str, dst: str, verbose: bool = ..., dry_run: bool = ...) -> str: ...
-def write_file(filename: str, contents: Sequence[str]) -> None: ...
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
+) -> tuple[_BytesPathT | bytes, bool]: ...
+@overload
+def move_file(
+    src: StrPath, dst: _StrPathT, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0
+) -> _StrPathT | str: ...
+@overload
+def move_file(
+    src: BytesPath, dst: _BytesPathT, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0
+) -> _BytesPathT | bytes: ...
+def write_file(filename: StrOrBytesPath, contents: Iterable[str]) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/filelist.pyi b/mypy/typeshed/stdlib/distutils/filelist.pyi
index bea48ac16ac5..607a78a1fbac 100644
--- a/mypy/typeshed/stdlib/distutils/filelist.pyi
+++ b/mypy/typeshed/stdlib/distutils/filelist.pyi
@@ -1,7 +1,6 @@
 from collections.abc import Iterable
 from re import Pattern
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 # class is entirely undocumented
 class FileList:
@@ -24,7 +23,11 @@ class FileList:
     def include_pattern(self, pattern: str | Pattern[str], *, is_regex: Literal[True, 1]) -> bool: ...
     @overload
     def include_pattern(
-        self, pattern: str | Pattern[str], anchor: bool | Literal[0, 1] = 1, prefix: str | None = None, is_regex: int = 0
+        self,
+        pattern: str | Pattern[str],
+        anchor: bool | Literal[0, 1] = 1,
+        prefix: str | None = None,
+        is_regex: bool | Literal[0, 1] = 0,
     ) -> bool: ...
     @overload
     def exclude_pattern(
@@ -34,7 +37,11 @@ class FileList:
     def exclude_pattern(self, pattern: str | Pattern[str], *, is_regex: Literal[True, 1]) -> bool: ...
     @overload
     def exclude_pattern(
-        self, pattern: str | Pattern[str], anchor: bool | Literal[0, 1] = 1, prefix: str | None = None, is_regex: int = 0
+        self,
+        pattern: str | Pattern[str],
+        anchor: bool | Literal[0, 1] = 1,
+        prefix: str | None = None,
+        is_regex: bool | Literal[0, 1] = 0,
     ) -> bool: ...
 
 def findall(dir: str = ".") -> list[str]: ...
@@ -47,5 +54,5 @@ def translate_pattern(
 def translate_pattern(pattern: str | Pattern[str], *, is_regex: Literal[True, 1]) -> Pattern[str]: ...
 @overload
 def translate_pattern(
-    pattern: str | Pattern[str], anchor: bool | Literal[0, 1] = 1, prefix: str | None = None, is_regex: int = 0
+    pattern: str | Pattern[str], anchor: bool | Literal[0, 1] = 1, prefix: str | None = None, is_regex: bool | Literal[0, 1] = 0
 ) -> Pattern[str]: ...
diff --git a/mypy/typeshed/stdlib/distutils/log.pyi b/mypy/typeshed/stdlib/distutils/log.pyi
index 14ed8d8aefa8..7246dd6be0cd 100644
--- a/mypy/typeshed/stdlib/distutils/log.pyi
+++ b/mypy/typeshed/stdlib/distutils/log.pyi
@@ -1,13 +1,14 @@
-from typing import Any
+from typing import Any, Final
 
-DEBUG: int
-INFO: int
-WARN: int
-ERROR: int
-FATAL: int
+DEBUG: Final = 1
+INFO: Final = 2
+WARN: Final = 3
+ERROR: Final = 4
+FATAL: Final = 5
 
 class Log:
     def __init__(self, threshold: int = 3) -> None: ...
+    # Arbitrary msg args' type depends on the format method
     def log(self, level: int, msg: str, *args: Any) -> None: ...
     def debug(self, msg: str, *args: Any) -> None: ...
     def info(self, msg: str, *args: Any) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/spawn.pyi b/mypy/typeshed/stdlib/distutils/spawn.pyi
index a8a2c4140b2d..ae07a49504fe 100644
--- a/mypy/typeshed/stdlib/distutils/spawn.pyi
+++ b/mypy/typeshed/stdlib/distutils/spawn.pyi
@@ -1,2 +1,10 @@
-def spawn(cmd: list[str], search_path: bool = ..., verbose: bool = ..., dry_run: bool = ...) -> None: ...
+from collections.abc import Iterable
+from typing import Literal
+
+def spawn(
+    cmd: Iterable[str],
+    search_path: bool | Literal[0, 1] = 1,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
+) -> None: ...
 def find_executable(executable: str, path: str | None = None) -> str | None: ...
diff --git a/mypy/typeshed/stdlib/distutils/sysconfig.pyi b/mypy/typeshed/stdlib/distutils/sysconfig.pyi
index 464cfb639c6d..4a9c45eb562a 100644
--- a/mypy/typeshed/stdlib/distutils/sysconfig.pyi
+++ b/mypy/typeshed/stdlib/distutils/sysconfig.pyi
@@ -1,21 +1,32 @@
 import sys
 from collections.abc import Mapping
 from distutils.ccompiler import CCompiler
+from typing import Final, Literal, overload
+from typing_extensions import deprecated
 
-PREFIX: str
-EXEC_PREFIX: str
-BASE_PREFIX: str
-BASE_EXEC_PREFIX: str
-project_base: str
-python_build: bool
+PREFIX: Final[str]
+EXEC_PREFIX: Final[str]
+BASE_PREFIX: Final[str]
+BASE_EXEC_PREFIX: Final[str]
+project_base: Final[str]
+python_build: Final[bool]
 
 def expand_makefile_vars(s: str, vars: Mapping[str, str]) -> str: ...
+@overload
+@deprecated("SO is deprecated, use EXT_SUFFIX. Support is removed in Python 3.11")
+def get_config_var(name: Literal["SO"]) -> int | str | None: ...
+@overload
 def get_config_var(name: str) -> int | str | None: ...
-def get_config_vars(*args: str) -> Mapping[str, int | str]: ...
+@overload
+def get_config_vars() -> dict[str, str | int]: ...
+@overload
+def get_config_vars(arg: str, /, *args: str) -> list[str | int]: ...
 def get_config_h_filename() -> str: ...
 def get_makefile_filename() -> str: ...
-def get_python_inc(plat_specific: bool = ..., prefix: str | None = None) -> str: ...
-def get_python_lib(plat_specific: bool = ..., standard_lib: bool = ..., prefix: str | None = None) -> str: ...
+def get_python_inc(plat_specific: bool | Literal[0, 1] = 0, prefix: str | None = None) -> str: ...
+def get_python_lib(
+    plat_specific: bool | Literal[0, 1] = 0, standard_lib: bool | Literal[0, 1] = 0, prefix: str | None = None
+) -> str: ...
 def customize_compiler(compiler: CCompiler) -> None: ...
 
 if sys.version_info < (3, 10):
diff --git a/mypy/typeshed/stdlib/distutils/text_file.pyi b/mypy/typeshed/stdlib/distutils/text_file.pyi
index 4a6cf1db77c6..54951af7e55d 100644
--- a/mypy/typeshed/stdlib/distutils/text_file.pyi
+++ b/mypy/typeshed/stdlib/distutils/text_file.pyi
@@ -1,4 +1,4 @@
-from typing import IO
+from typing import IO, Literal
 
 class TextFile:
     def __init__(
@@ -6,12 +6,12 @@ class TextFile:
         filename: str | None = None,
         file: IO[str] | None = None,
         *,
-        strip_comments: bool = ...,
-        lstrip_ws: bool = ...,
-        rstrip_ws: bool = ...,
-        skip_blanks: bool = ...,
-        join_lines: bool = ...,
-        collapse_join: bool = ...,
+        strip_comments: bool | Literal[0, 1] = ...,
+        lstrip_ws: bool | Literal[0, 1] = ...,
+        rstrip_ws: bool | Literal[0, 1] = ...,
+        skip_blanks: bool | Literal[0, 1] = ...,
+        join_lines: bool | Literal[0, 1] = ...,
+        collapse_join: bool | Literal[0, 1] = ...,
     ) -> None: ...
     def open(self, filename: str) -> None: ...
     def close(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/distutils/util.pyi b/mypy/typeshed/stdlib/distutils/util.pyi
index 83b03747fda6..0e1bb4165d99 100644
--- a/mypy/typeshed/stdlib/distutils/util.pyi
+++ b/mypy/typeshed/stdlib/distutils/util.pyi
@@ -1,30 +1,33 @@
-import sys
 from _typeshed import StrPath, Unused
 from collections.abc import Callable, Container, Iterable, Mapping
-from typing import Any
-from typing_extensions import Literal
+from typing import Any, Literal
+from typing_extensions import TypeVarTuple, Unpack
 
-if sys.version_info >= (3, 8):
-    def get_host_platform() -> str: ...
+_Ts = TypeVarTuple("_Ts")
 
+def get_host_platform() -> str: ...
 def get_platform() -> str: ...
 def convert_path(pathname: str) -> str: ...
-def change_root(new_root: str, pathname: str) -> str: ...
+def change_root(new_root: StrPath, pathname: StrPath) -> str: ...
 def check_environ() -> None: ...
 def subst_vars(s: str, local_vars: Mapping[str, str]) -> None: ...
 def split_quoted(s: str) -> list[str]: ...
 def execute(
-    func: Callable[..., object], args: tuple[Any, ...], msg: str | None = None, verbose: bool = ..., dry_run: bool = ...
+    func: Callable[[Unpack[_Ts]], Unused],
+    args: tuple[Unpack[_Ts]],
+    msg: str | None = None,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
 ) -> None: ...
 def strtobool(val: str) -> Literal[0, 1]: ...
 def byte_compile(
     py_files: list[str],
     optimize: int = 0,
-    force: bool = ...,
+    force: bool | Literal[0, 1] = 0,
     prefix: str | None = None,
     base_dir: str | None = None,
-    verbose: bool = ...,
-    dry_run: bool = ...,
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
     direct: bool | None = None,
 ) -> None: ...
 def rfc822_escape(header: str) -> str: ...
diff --git a/mypy/typeshed/stdlib/doctest.pyi b/mypy/typeshed/stdlib/doctest.pyi
index 88d066fdc23c..562b5a5bdac9 100644
--- a/mypy/typeshed/stdlib/doctest.pyi
+++ b/mypy/typeshed/stdlib/doctest.pyi
@@ -1,9 +1,10 @@
+import sys
 import types
 import unittest
 from _typeshed import ExcInfo
 from collections.abc import Callable
-from typing import Any, NamedTuple
-from typing_extensions import TypeAlias
+from typing import Any, NamedTuple, type_check_only
+from typing_extensions import Self, TypeAlias
 
 __all__ = [
     "register_optionflag",
@@ -41,9 +42,20 @@ __all__ = [
     "debug",
 ]
 
-class TestResults(NamedTuple):
-    failed: int
-    attempted: int
+if sys.version_info >= (3, 13):
+    @type_check_only
+    class _TestResultsBase(NamedTuple):
+        failed: int
+        attempted: int
+
+    class TestResults(_TestResultsBase):
+        def __new__(cls, failed: int, attempted: int, *, skipped: int = 0) -> Self: ...
+        skipped: int
+
+else:
+    class TestResults(NamedTuple):
+        failed: int
+        attempted: int
 
 OPTIONFLAGS_BY_NAME: dict[str, int]
 
@@ -85,6 +97,7 @@ class Example:
         indent: int = 0,
         options: dict[int, bool] | None = None,
     ) -> None: ...
+    def __hash__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...
 
 class DocTest:
@@ -103,6 +116,7 @@ class DocTest:
         lineno: int | None,
         docstring: str | None,
     ) -> None: ...
+    def __hash__(self) -> int: ...
     def __lt__(self, other: DocTest) -> bool: ...
     def __eq__(self, other: object) -> bool: ...
 
@@ -132,6 +146,8 @@ class DocTestRunner:
     original_optionflags: int
     tries: int
     failures: int
+    if sys.version_info >= (3, 13):
+        skips: int
     test: DocTest
     def __init__(self, checker: OutputChecker | None = None, verbose: bool | None = None, optionflags: int = 0) -> None: ...
     def report_start(self, out: _Out, test: DocTest, example: Example) -> None: ...
@@ -204,12 +220,13 @@ class DocTestCase(unittest.TestCase):
         self,
         test: DocTest,
         optionflags: int = 0,
-        setUp: Callable[[DocTest], Any] | None = None,
-        tearDown: Callable[[DocTest], Any] | None = None,
+        setUp: Callable[[DocTest], object] | None = None,
+        tearDown: Callable[[DocTest], object] | None = None,
         checker: OutputChecker | None = None,
     ) -> None: ...
     def runTest(self) -> None: ...
     def format_failure(self, err: str) -> str: ...
+    def __hash__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...
 
 class SkipDocTestCase(DocTestCase):
diff --git a/mypy/typeshed/stdlib/email/__init__.pyi b/mypy/typeshed/stdlib/email/__init__.pyi
index fca302f5f1a7..628ffb2b793a 100644
--- a/mypy/typeshed/stdlib/email/__init__.pyi
+++ b/mypy/typeshed/stdlib/email/__init__.pyi
@@ -1,29 +1,59 @@
 from collections.abc import Callable
 from email.message import Message
-from email.policy import Policy
-from typing import IO
+from email.policy import Policy, _MessageT
+from typing import IO, overload
 from typing_extensions import TypeAlias
 
+# At runtime, listing submodules in __all__ without them being imported is
+# valid, and causes them to be included in a star import. See #6523
+
+__all__ = [  # noqa: F822  # Undefined names in __all__
+    "base64mime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "charset",  # pyright: ignore[reportUnsupportedDunderAll]
+    "encoders",  # pyright: ignore[reportUnsupportedDunderAll]
+    "errors",  # pyright: ignore[reportUnsupportedDunderAll]
+    "feedparser",  # pyright: ignore[reportUnsupportedDunderAll]
+    "generator",  # pyright: ignore[reportUnsupportedDunderAll]
+    "header",  # pyright: ignore[reportUnsupportedDunderAll]
+    "iterators",  # pyright: ignore[reportUnsupportedDunderAll]
+    "message",  # pyright: ignore[reportUnsupportedDunderAll]
+    "message_from_file",
+    "message_from_binary_file",
+    "message_from_string",
+    "message_from_bytes",
+    "mime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "parser",  # pyright: ignore[reportUnsupportedDunderAll]
+    "quoprimime",  # pyright: ignore[reportUnsupportedDunderAll]
+    "utils",  # pyright: ignore[reportUnsupportedDunderAll]
+]
+
 # Definitions imported by multiple submodules in typeshed
 _ParamType: TypeAlias = str | tuple[str | None, str | None, str]  # noqa: Y047
 _ParamsType: TypeAlias = str | None | tuple[str, str | None, str]  # noqa: Y047
 
-def message_from_string(s: str, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
-def message_from_bytes(s: bytes | bytearray, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
-def message_from_file(fp: IO[str], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
-def message_from_binary_file(fp: IO[bytes], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ...
-
-# Names in __all__ with no definition:
-#   base64mime
-#   charset
-#   encoders
-#   errors
-#   feedparser
-#   generator
-#   header
-#   iterators
-#   message
-#   mime
-#   parser
-#   quoprimime
-#   utils
+@overload
+def message_from_string(s: str) -> Message: ...
+@overload
+def message_from_string(s: str, _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_string(s: str, _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]) -> _MessageT: ...
+@overload
+def message_from_bytes(s: bytes | bytearray) -> Message: ...
+@overload
+def message_from_bytes(s: bytes | bytearray, _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_bytes(
+    s: bytes | bytearray, _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]
+) -> _MessageT: ...
+@overload
+def message_from_file(fp: IO[str]) -> Message: ...
+@overload
+def message_from_file(fp: IO[str], _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_file(fp: IO[str], _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]) -> _MessageT: ...
+@overload
+def message_from_binary_file(fp: IO[bytes]) -> Message: ...
+@overload
+def message_from_binary_file(fp: IO[bytes], _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def message_from_binary_file(fp: IO[bytes], _class: Callable[[], _MessageT] = ..., *, policy: Policy[_MessageT]) -> _MessageT: ...
diff --git a/mypy/typeshed/stdlib/email/_header_value_parser.pyi b/mypy/typeshed/stdlib/email/_header_value_parser.pyi
index 97008140ec5d..a4c2d8b1a92e 100644
--- a/mypy/typeshed/stdlib/email/_header_value_parser.pyi
+++ b/mypy/typeshed/stdlib/email/_header_value_parser.pyi
@@ -3,8 +3,8 @@ from collections.abc import Iterable, Iterator
 from email.errors import HeaderParseError, MessageDefect
 from email.policy import Policy
 from re import Pattern
-from typing import Any
-from typing_extensions import Final, Self
+from typing import Any, Final
+from typing_extensions import Self
 
 WSP: Final[set[str]]
 CFWS_LEADER: Final[set[str]]
@@ -17,6 +17,13 @@ TOKEN_ENDS: Final[set[str]]
 ASPECIALS: Final[set[str]]
 ATTRIBUTE_ENDS: Final[set[str]]
 EXTENDED_ATTRIBUTE_ENDS: Final[set[str]]
+# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+NLSET: Final[set[str]]
+# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+SPECIALSNL: Final[set[str]]
+
+if sys.version_info >= (3, 12):
+    def make_quoted_pairs(value: Any) -> str: ...
 
 def quote_string(value: Any) -> str: ...
 
@@ -195,10 +202,9 @@ class DotAtomText(TokenList):
     token_type: str
     as_ew_allowed: bool
 
-if sys.version_info >= (3, 8):
-    class NoFoldLiteral(TokenList):
-        token_type: str
-        as_ew_allowed: bool
+class NoFoldLiteral(TokenList):
+    token_type: str
+    as_ew_allowed: bool
 
 class AddrSpec(TokenList):
     token_type: str
@@ -296,17 +302,16 @@ class HeaderLabel(TokenList):
     token_type: str
     as_ew_allowed: bool
 
-if sys.version_info >= (3, 8):
-    class MsgID(TokenList):
-        token_type: str
-        as_ew_allowed: bool
-        def fold(self, policy: Policy) -> str: ...
+class MsgID(TokenList):
+    token_type: str
+    as_ew_allowed: bool
+    def fold(self, policy: Policy) -> str: ...
 
-    class MessageID(MsgID):
-        token_type: str
+class MessageID(MsgID):
+    token_type: str
 
-    class InvalidMessageID(MessageID):
-        token_type: str
+class InvalidMessageID(MessageID):
+    token_type: str
 
 class Header(TokenList):
     token_type: str
@@ -375,12 +380,9 @@ def get_group_list(value: str) -> tuple[GroupList, str]: ...
 def get_group(value: str) -> tuple[Group, str]: ...
 def get_address(value: str) -> tuple[Address, str]: ...
 def get_address_list(value: str) -> tuple[AddressList, str]: ...
-
-if sys.version_info >= (3, 8):
-    def get_no_fold_literal(value: str) -> tuple[NoFoldLiteral, str]: ...
-    def get_msg_id(value: str) -> tuple[MsgID, str]: ...
-    def parse_message_id(value: str) -> MessageID: ...
-
+def get_no_fold_literal(value: str) -> tuple[NoFoldLiteral, str]: ...
+def get_msg_id(value: str) -> tuple[MsgID, str]: ...
+def parse_message_id(value: str) -> MessageID: ...
 def parse_mime_version(value: str) -> MIMEVersion: ...
 def get_invalid_parameter(value: str) -> tuple[InvalidParameter, str]: ...
 def get_ttext(value: str) -> tuple[ValueTerminal, str]: ...
diff --git a/mypy/typeshed/stdlib/email/_policybase.pyi b/mypy/typeshed/stdlib/email/_policybase.pyi
new file mode 100644
index 000000000000..f5dbbd96da14
--- /dev/null
+++ b/mypy/typeshed/stdlib/email/_policybase.pyi
@@ -0,0 +1,77 @@
+from abc import ABCMeta, abstractmethod
+from email.errors import MessageDefect
+from email.header import Header
+from email.message import Message
+from typing import Generic, Protocol, TypeVar, type_check_only
+from typing_extensions import Self
+
+__all__ = ["Policy", "Compat32", "compat32"]
+
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
+
+@type_check_only
+class _MessageFactory(Protocol[_MessageT]):
+    def __call__(self, policy: Policy[_MessageT]) -> _MessageT: ...
+
+# Policy below is the only known direct subclass of _PolicyBase. We therefore
+# assume that the __init__ arguments and attributes of _PolicyBase are
+# the same as those of Policy.
+class _PolicyBase(Generic[_MessageT]):
+    max_line_length: int | None
+    linesep: str
+    cte_type: str
+    raise_on_defect: bool
+    mangle_from_: bool
+    message_factory: _MessageFactory[_MessageT] | None
+    # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+    verify_generated_headers: bool
+
+    def __init__(
+        self,
+        *,
+        max_line_length: int | None = 78,
+        linesep: str = "\n",
+        cte_type: str = "8bit",
+        raise_on_defect: bool = False,
+        mangle_from_: bool = ...,  # default depends on sub-class
+        message_factory: _MessageFactory[_MessageT] | None = None,
+        # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+        verify_generated_headers: bool = True,
+    ) -> None: ...
+    def clone(
+        self,
+        *,
+        max_line_length: int | None = ...,
+        linesep: str = ...,
+        cte_type: str = ...,
+        raise_on_defect: bool = ...,
+        mangle_from_: bool = ...,
+        message_factory: _MessageFactory[_MessageT] | None = ...,
+        # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+        verify_generated_headers: bool = ...,
+    ) -> Self: ...
+    def __add__(self, other: Policy) -> Self: ...
+
+class Policy(_PolicyBase[_MessageT], metaclass=ABCMeta):
+    def handle_defect(self, obj: _MessageT, defect: MessageDefect) -> None: ...
+    def register_defect(self, obj: _MessageT, defect: MessageDefect) -> None: ...
+    def header_max_count(self, name: str) -> int | None: ...
+    @abstractmethod
+    def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
+    @abstractmethod
+    def header_store_parse(self, name: str, value: str) -> tuple[str, str]: ...
+    @abstractmethod
+    def header_fetch_parse(self, name: str, value: str) -> str: ...
+    @abstractmethod
+    def fold(self, name: str, value: str) -> str: ...
+    @abstractmethod
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+class Compat32(Policy[_MessageT]):
+    def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
+    def header_store_parse(self, name: str, value: str) -> tuple[str, str]: ...
+    def header_fetch_parse(self, name: str, value: str) -> str | Header: ...  # type: ignore[override]
+    def fold(self, name: str, value: str) -> str: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+compat32: Compat32[Message]
diff --git a/mypy/typeshed/stdlib/email/charset.pyi b/mypy/typeshed/stdlib/email/charset.pyi
index e612847c75b6..683daa468cf3 100644
--- a/mypy/typeshed/stdlib/email/charset.pyi
+++ b/mypy/typeshed/stdlib/email/charset.pyi
@@ -1,10 +1,12 @@
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
+from email.message import Message
+from typing import ClassVar, Final, overload
 
 __all__ = ["Charset", "add_alias", "add_charset", "add_codec"]
 
-QP: int  # undocumented
-BASE64: int  # undocumented
-SHORTEST: int  # undocumented
+QP: Final[int]  # undocumented
+BASE64: Final[int]  # undocumented
+SHORTEST: Final[int]  # undocumented
 
 class Charset:
     input_charset: str
@@ -14,13 +16,17 @@ class Charset:
     input_codec: str | None
     output_codec: str | None
     def __init__(self, input_charset: str = "us-ascii") -> None: ...
-    def get_body_encoding(self) -> str: ...
+    def get_body_encoding(self) -> str | Callable[[Message], None]: ...
     def get_output_charset(self) -> str | None: ...
     def header_encode(self, string: str) -> str: ...
-    def header_encode_lines(self, string: str, maxlengths: Iterator[int]) -> list[str]: ...
-    def body_encode(self, string: str) -> str: ...
+    def header_encode_lines(self, string: str, maxlengths: Iterator[int]) -> list[str | None]: ...
+    @overload
+    def body_encode(self, string: None) -> None: ...
+    @overload
+    def body_encode(self, string: str | bytes) -> str: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, other: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
 
 def add_charset(
     charset: str, header_enc: int | None = None, body_enc: int | None = None, output_charset: str | None = None
diff --git a/mypy/typeshed/stdlib/email/errors.pyi b/mypy/typeshed/stdlib/email/errors.pyi
index c54f1560c9ae..f105576c5ee4 100644
--- a/mypy/typeshed/stdlib/email/errors.pyi
+++ b/mypy/typeshed/stdlib/email/errors.pyi
@@ -7,6 +7,9 @@ class BoundaryError(MessageParseError): ...
 class MultipartConversionError(MessageError, TypeError): ...
 class CharsetError(MessageError): ...
 
+# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+class HeaderWriteError(MessageError): ...
+
 class MessageDefect(ValueError):
     def __init__(self, line: str | None = None) -> None: ...
 
diff --git a/mypy/typeshed/stdlib/email/feedparser.pyi b/mypy/typeshed/stdlib/email/feedparser.pyi
index 4b7f73b9c015..8c268ca1ae18 100644
--- a/mypy/typeshed/stdlib/email/feedparser.pyi
+++ b/mypy/typeshed/stdlib/email/feedparser.pyi
@@ -5,20 +5,19 @@ from typing import Generic, TypeVar, overload
 
 __all__ = ["FeedParser", "BytesFeedParser"]
 
-_MessageT = TypeVar("_MessageT", bound=Message)
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
 
 class FeedParser(Generic[_MessageT]):
     @overload
-    def __init__(self: FeedParser[Message], _factory: None = None, *, policy: Policy = ...) -> None: ...
+    def __init__(self: FeedParser[Message], _factory: None = None, *, policy: Policy[Message] = ...) -> None: ...
     @overload
-    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
+    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
     def feed(self, data: str) -> None: ...
     def close(self) -> _MessageT: ...
 
-class BytesFeedParser(Generic[_MessageT]):
+class BytesFeedParser(FeedParser[_MessageT]):
     @overload
-    def __init__(self: BytesFeedParser[Message], _factory: None = None, *, policy: Policy = ...) -> None: ...
+    def __init__(self: BytesFeedParser[Message], _factory: None = None, *, policy: Policy[Message] = ...) -> None: ...
     @overload
-    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy = ...) -> None: ...
-    def feed(self, data: bytes | bytearray) -> None: ...
-    def close(self) -> _MessageT: ...
+    def __init__(self, _factory: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
+    def feed(self, data: bytes | bytearray) -> None: ...  # type: ignore[override]
diff --git a/mypy/typeshed/stdlib/email/generator.pyi b/mypy/typeshed/stdlib/email/generator.pyi
index 8362dd9c4ff6..dfa0604a20a9 100644
--- a/mypy/typeshed/stdlib/email/generator.pyi
+++ b/mypy/typeshed/stdlib/email/generator.pyi
@@ -1,36 +1,71 @@
 from _typeshed import SupportsWrite
 from email.message import Message
 from email.policy import Policy
+from typing import Any, Generic, TypeVar, overload
+from typing_extensions import Self
 
 __all__ = ["Generator", "DecodedGenerator", "BytesGenerator"]
 
-class Generator:
-    def clone(self, fp: SupportsWrite[str]) -> Generator: ...
-    def write(self, s: str) -> None: ...
+# By default, generators do not have a message policy.
+_MessageT = TypeVar("_MessageT", bound=Message, default=Any)
+
+class Generator(Generic[_MessageT]):
+    maxheaderlen: int | None
+    policy: Policy[_MessageT] | None
+    @overload
+    def __init__(
+        self: Generator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
     def __init__(
         self,
         outfp: SupportsWrite[str],
         mangle_from_: bool | None = None,
         maxheaderlen: int | None = None,
         *,
-        policy: Policy | None = None,
+        policy: Policy[_MessageT],
     ) -> 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: ...
+    def flatten(self, msg: _MessageT, unixfrom: bool = False, linesep: str | None = None) -> None: ...
+    def clone(self, fp: SupportsWrite[str]) -> Self: ...
+
+class BytesGenerator(Generator[_MessageT]):
+    @overload
+    def __init__(
+        self: BytesGenerator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[bytes],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
     def __init__(
         self,
         outfp: SupportsWrite[bytes],
         mangle_from_: bool | None = None,
         maxheaderlen: int | None = None,
         *,
-        policy: Policy | None = None,
+        policy: Policy[_MessageT],
     ) -> None: ...
-    def flatten(self, msg: Message, unixfrom: bool = False, linesep: str | None = None) -> None: ...
 
-class DecodedGenerator(Generator):
+class DecodedGenerator(Generator[_MessageT]):
+    @overload
+    def __init__(
+        self: DecodedGenerator[Any],  # The Policy of the message is used.
+        outfp: SupportsWrite[str],
+        mangle_from_: bool | None = None,
+        maxheaderlen: int | None = None,
+        fmt: str | None = None,
+        *,
+        policy: None = None,
+    ) -> None: ...
+    @overload
     def __init__(
         self,
         outfp: SupportsWrite[str],
@@ -38,5 +73,5 @@ class DecodedGenerator(Generator):
         maxheaderlen: int | None = None,
         fmt: str | None = None,
         *,
-        policy: Policy | None = None,
+        policy: Policy[_MessageT],
     ) -> None: ...
diff --git a/mypy/typeshed/stdlib/email/header.pyi b/mypy/typeshed/stdlib/email/header.pyi
index fc9d73331bae..a26bbb516e09 100644
--- a/mypy/typeshed/stdlib/email/header.pyi
+++ b/mypy/typeshed/stdlib/email/header.pyi
@@ -1,6 +1,6 @@
 from collections.abc import Iterable
 from email.charset import Charset
-from typing import Any
+from typing import Any, ClassVar
 
 __all__ = ["Header", "decode_header", "make_header"]
 
@@ -16,8 +16,9 @@ class Header:
     ) -> None: ...
     def append(self, s: bytes | bytearray | str, charset: Charset | str | None = None, errors: str = "strict") -> None: ...
     def encode(self, splitchars: str = ";, \t", maxlinelen: int | None = None, linesep: str = "\n") -> str: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, other: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
 
 # decode_header() either returns list[tuple[str, None]] if the header
 # contains no encoded parts, or list[tuple[bytes, str | None]] if the header
diff --git a/mypy/typeshed/stdlib/email/headerregistry.pyi b/mypy/typeshed/stdlib/email/headerregistry.pyi
index e158e89818f7..dc641c8c952b 100644
--- a/mypy/typeshed/stdlib/email/headerregistry.pyi
+++ b/mypy/typeshed/stdlib/email/headerregistry.pyi
@@ -1,4 +1,3 @@
-import sys
 import types
 from collections.abc import Iterable, Mapping
 from datetime import datetime as _datetime
@@ -7,14 +6,15 @@ from email._header_value_parser import (
     ContentDisposition,
     ContentTransferEncoding,
     ContentType,
+    MessageID,
     MIMEVersion,
     TokenList,
     UnstructuredTokenList,
 )
 from email.errors import MessageDefect
 from email.policy import Policy
-from typing import Any, ClassVar, Protocol
-from typing_extensions import Literal, Self
+from typing import Any, ClassVar, Literal, Protocol
+from typing_extensions import Self
 
 class BaseHeader(str):
     # max_count is actually more of an abstract ClassVar (not defined on the base class, but expected to be defined in subclasses)
@@ -130,22 +130,19 @@ class ContentTransferEncodingHeader:
     @staticmethod
     def value_parser(value: str) -> ContentTransferEncoding: ...
 
-if sys.version_info >= (3, 8):
-    from email._header_value_parser import MessageID
-
-    class MessageIDHeader:
-        max_count: ClassVar[Literal[1]]
-        @classmethod
-        def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
-        @staticmethod
-        def value_parser(value: str) -> MessageID: ...
+class MessageIDHeader:
+    max_count: ClassVar[Literal[1]]
+    @classmethod
+    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+    @staticmethod
+    def value_parser(value: str) -> MessageID: ...
 
 class _HeaderParser(Protocol):
     max_count: ClassVar[Literal[1] | None]
     @staticmethod
-    def value_parser(value: str) -> TokenList: ...
+    def value_parser(value: str, /) -> TokenList: ...
     @classmethod
-    def parse(cls, value: str, kwds: dict[str, Any]) -> None: ...
+    def parse(cls, value: str, kwds: dict[str, Any], /) -> None: ...
 
 class HeaderRegistry:
     registry: dict[str, type[_HeaderParser]]
@@ -170,6 +167,7 @@ class Address:
     def __init__(
         self, display_name: str = "", username: str | None = "", domain: str | None = "", addr_spec: str | None = None
     ) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, other: object) -> bool: ...
 
 class Group:
@@ -178,4 +176,5 @@ class Group:
     @property
     def addresses(self) -> tuple[Address, ...]: ...
     def __init__(self, display_name: str | None = None, addresses: Iterable[Address] | None = None) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, other: object) -> bool: ...
diff --git a/mypy/typeshed/stdlib/email/message.pyi b/mypy/typeshed/stdlib/email/message.pyi
index 18852f4d3bb2..ebad05a1cf7b 100644
--- a/mypy/typeshed/stdlib/email/message.pyi
+++ b/mypy/typeshed/stdlib/email/message.pyi
@@ -1,52 +1,97 @@
+from _typeshed import MaybeNone
 from collections.abc import Generator, Iterator, Sequence
 from email import _ParamsType, _ParamType
 from email.charset import Charset
 from email.contentmanager import ContentManager
 from email.errors import MessageDefect
 from email.policy import Policy
-from typing import Any, TypeVar, overload
+from typing import Any, Generic, Literal, Protocol, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
 __all__ = ["Message", "EmailMessage"]
 
 _T = TypeVar("_T")
+# Type returned by Policy.header_fetch_parse, often str or Header.
+_HeaderT = TypeVar("_HeaderT", default=str)
+_HeaderParamT = TypeVar("_HeaderParamT", default=str)
+# Represents headers constructed by HeaderRegistry. Those are sub-classes
+# of BaseHeader and another header type.
+_HeaderRegistryT = TypeVar("_HeaderRegistryT", default=Any)
+_HeaderRegistryParamT = TypeVar("_HeaderRegistryParamT", default=Any)
 
-_PayloadType: TypeAlias = list[Message] | str | bytes | bytearray
+_PayloadType: TypeAlias = Message | str
+_EncodedPayloadType: TypeAlias = Message | bytes
+_MultipartPayloadType: TypeAlias = list[_PayloadType]
 _CharsetType: TypeAlias = Charset | str | None
-_HeaderType: TypeAlias = Any
 
-class Message:
-    policy: Policy  # undocumented
+class _SupportsEncodeToPayload(Protocol):
+    def encode(self, encoding: str, /) -> _PayloadType | _MultipartPayloadType | _SupportsDecodeToPayload: ...
+
+class _SupportsDecodeToPayload(Protocol):
+    def decode(self, encoding: str, errors: str, /) -> _PayloadType | _MultipartPayloadType: ...
+
+class Message(Generic[_HeaderT, _HeaderParamT]):
+    # The policy attributes and arguments in this class and its subclasses
+    # would ideally use Policy[Self], but this is not possible.
+    policy: Policy[Any]  # undocumented
     preamble: str | None
     epilogue: str | None
     defects: list[MessageDefect]
+    def __init__(self, policy: Policy[Any] = ...) -> None: ...
     def is_multipart(self) -> bool: ...
     def set_unixfrom(self, unixfrom: str) -> None: ...
     def get_unixfrom(self) -> str | None: ...
-    def attach(self, payload: Message) -> None: ...
-    def get_payload(self, i: int | None = None, decode: bool = False) -> Any: ...  # returns _PayloadType | None
-    def set_payload(self, payload: _PayloadType, charset: _CharsetType = None) -> None: ...
+    def attach(self, payload: _PayloadType) -> None: ...
+    # `i: int` without a multipart payload results in an error
+    # `| MaybeNone` acts like `| Any`: can be None for cleared or unset payload, but annoying to check
+    @overload  # multipart
+    def get_payload(self, i: int, decode: Literal[True]) -> None: ...
+    @overload  # multipart
+    def get_payload(self, i: int, decode: Literal[False] = False) -> _PayloadType | MaybeNone: ...
+    @overload  # either
+    def get_payload(self, i: None = None, decode: Literal[False] = False) -> _PayloadType | _MultipartPayloadType | MaybeNone: ...
+    @overload  # not multipart
+    def get_payload(self, i: None = None, *, decode: Literal[True]) -> _EncodedPayloadType | MaybeNone: ...
+    @overload  # not multipart, IDEM but w/o kwarg
+    def get_payload(self, i: None, decode: Literal[True]) -> _EncodedPayloadType | MaybeNone: ...
+    # If `charset=None` and payload supports both `encode` AND `decode`,
+    # then an invalid payload could be passed, but this is unlikely
+    # Not[_SupportsEncodeToPayload]
+    @overload
+    def set_payload(
+        self, payload: _SupportsDecodeToPayload | _PayloadType | _MultipartPayloadType, charset: None = None
+    ) -> None: ...
+    @overload
+    def set_payload(
+        self,
+        payload: _SupportsEncodeToPayload | _SupportsDecodeToPayload | _PayloadType | _MultipartPayloadType,
+        charset: Charset | str,
+    ) -> None: ...
     def set_charset(self, charset: _CharsetType) -> None: ...
     def get_charset(self) -> _CharsetType: ...
     def __len__(self) -> int: ...
     def __contains__(self, name: str) -> bool: ...
     def __iter__(self) -> Iterator[str]: ...
-    def __getitem__(self, name: str) -> _HeaderType: ...
-    def __setitem__(self, name: str, val: _HeaderType) -> None: ...
+    # Same as `get` with `failobj=None`, but with the expectation that it won't return None in most scenarios
+    # This is important for protocols using __getitem__, like SupportsKeysAndGetItem
+    # Morally, the return type should be `AnyOf[_HeaderType, None]`,
+    # so using "the Any trick" instead.
+    def __getitem__(self, name: str) -> _HeaderT | MaybeNone: ...
+    def __setitem__(self, name: str, val: _HeaderParamT) -> None: ...
     def __delitem__(self, name: str) -> None: ...
     def keys(self) -> list[str]: ...
-    def values(self) -> list[_HeaderType]: ...
-    def items(self) -> list[tuple[str, _HeaderType]]: ...
+    def values(self) -> list[_HeaderT]: ...
+    def items(self) -> list[tuple[str, _HeaderT]]: ...
     @overload
-    def get(self, name: str, failobj: None = None) -> _HeaderType | None: ...
+    def get(self, name: str, failobj: None = None) -> _HeaderT | None: ...
     @overload
-    def get(self, name: str, failobj: _T) -> _HeaderType | _T: ...
+    def get(self, name: str, failobj: _T) -> _HeaderT | _T: ...
     @overload
-    def get_all(self, name: str, failobj: None = None) -> list[_HeaderType] | None: ...
+    def get_all(self, name: str, failobj: None = None) -> list[_HeaderT] | None: ...
     @overload
-    def get_all(self, name: str, failobj: _T) -> list[_HeaderType] | _T: ...
+    def get_all(self, name: str, failobj: _T) -> list[_HeaderT] | _T: ...
     def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ...
-    def replace_header(self, _name: str, _value: _HeaderType) -> None: ...
+    def replace_header(self, _name: str, _value: _HeaderParamT) -> None: ...
     def get_content_type(self) -> str: ...
     def get_content_maintype(self) -> str: ...
     def get_content_subtype(self) -> str: ...
@@ -85,8 +130,8 @@ class Message:
     def get_charsets(self, failobj: _T) -> list[str | _T]: ...
     def walk(self) -> Generator[Self, None, None]: ...
     def get_content_disposition(self) -> str | None: ...
-    def as_string(self, unixfrom: bool = False, maxheaderlen: int = 0, policy: Policy | None = None) -> str: ...
-    def as_bytes(self, unixfrom: bool = False, policy: Policy | None = None) -> bytes: ...
+    def as_string(self, unixfrom: bool = False, maxheaderlen: int = 0, policy: Policy[Any] | None = None) -> str: ...
+    def as_bytes(self, unixfrom: bool = False, policy: Policy[Any] | None = None) -> bytes: ...
     def __bytes__(self) -> bytes: ...
     def set_param(
         self,
@@ -98,16 +143,19 @@ class Message:
         language: str = "",
         replace: bool = False,
     ) -> None: ...
-    def __init__(self, policy: Policy = ...) -> None: ...
     # The following two methods are undocumented, but a source code comment states that they are public API
-    def set_raw(self, name: str, value: _HeaderType) -> None: ...
-    def raw_items(self) -> Iterator[tuple[str, _HeaderType]]: ...
+    def set_raw(self, name: str, value: _HeaderParamT) -> None: ...
+    def raw_items(self) -> Iterator[tuple[str, _HeaderT]]: ...
 
-class MIMEPart(Message):
-    def __init__(self, policy: Policy | None = None) -> None: ...
-    def get_body(self, preferencelist: Sequence[str] = ("related", "html", "plain")) -> Message | None: ...
-    def iter_attachments(self) -> Iterator[Message]: ...
-    def iter_parts(self) -> Iterator[Message]: ...
+class MIMEPart(Message[_HeaderRegistryT, _HeaderRegistryParamT]):
+    def __init__(self, policy: Policy[Any] | None = None) -> None: ...
+    def get_body(self, preferencelist: Sequence[str] = ("related", "html", "plain")) -> MIMEPart[_HeaderRegistryT] | None: ...
+    def attach(self, payload: Self) -> None: ...  # type: ignore[override]
+    # The attachments are created via type(self) in the attach method. It's theoretically
+    # possible to sneak other attachment types into a MIMEPart instance, but could cause
+    # cause unforseen consequences.
+    def iter_attachments(self) -> Iterator[Self]: ...
+    def iter_parts(self) -> Iterator[MIMEPart[_HeaderRegistryT]]: ...
     def get_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> Any: ...
     def set_content(self, *args: Any, content_manager: ContentManager | None = None, **kw: Any) -> None: ...
     def make_related(self, boundary: str | None = None) -> None: ...
@@ -118,7 +166,7 @@ class MIMEPart(Message):
     def add_attachment(self, *args: Any, content_manager: ContentManager | None = ..., **kw: Any) -> None: ...
     def clear(self) -> None: ...
     def clear_content(self) -> None: ...
-    def as_string(self, unixfrom: bool = False, maxheaderlen: int | None = None, policy: Policy | None = None) -> str: ...
+    def as_string(self, unixfrom: bool = False, maxheaderlen: int | None = None, policy: Policy[Any] | None = None) -> str: ...
     def is_attachment(self) -> bool: ...
 
 class EmailMessage(MIMEPart): ...
diff --git a/mypy/typeshed/stdlib/email/mime/message.pyi b/mypy/typeshed/stdlib/email/mime/message.pyi
index 23cf58619ad9..2a5f46296150 100644
--- a/mypy/typeshed/stdlib/email/mime/message.pyi
+++ b/mypy/typeshed/stdlib/email/mime/message.pyi
@@ -1,8 +1,7 @@
-from email.message import Message
 from email.mime.nonmultipart import MIMENonMultipart
-from email.policy import Policy
+from email.policy import Policy, _MessageT
 
 __all__ = ["MIMEMessage"]
 
 class MIMEMessage(MIMENonMultipart):
-    def __init__(self, _msg: Message, _subtype: str = "rfc822", *, policy: Policy | None = None) -> None: ...
+    def __init__(self, _msg: _MessageT, _subtype: str = "rfc822", *, policy: Policy[_MessageT] | None = None) -> None: ...
diff --git a/mypy/typeshed/stdlib/email/mime/multipart.pyi b/mypy/typeshed/stdlib/email/mime/multipart.pyi
index 6163810ed94a..1c229f7436a8 100644
--- a/mypy/typeshed/stdlib/email/mime/multipart.pyi
+++ b/mypy/typeshed/stdlib/email/mime/multipart.pyi
@@ -1,8 +1,7 @@
 from collections.abc import Sequence
 from email import _ParamsType
-from email.message import Message
 from email.mime.base import MIMEBase
-from email.policy import Policy
+from email.policy import Policy, _MessageT
 
 __all__ = ["MIMEMultipart"]
 
@@ -11,8 +10,8 @@ class MIMEMultipart(MIMEBase):
         self,
         _subtype: str = "mixed",
         boundary: str | None = None,
-        _subparts: Sequence[Message] | None = None,
+        _subparts: Sequence[_MessageT] | None = None,
         *,
-        policy: Policy | None = None,
+        policy: Policy[_MessageT] | None = None,
         **_params: _ParamsType,
     ) -> None: ...
diff --git a/mypy/typeshed/stdlib/email/parser.pyi b/mypy/typeshed/stdlib/email/parser.pyi
index 28b6aca856ca..a1a57b4eef4b 100644
--- a/mypy/typeshed/stdlib/email/parser.pyi
+++ b/mypy/typeshed/stdlib/email/parser.pyi
@@ -3,24 +3,36 @@ from collections.abc import Callable
 from email.feedparser import BytesFeedParser as BytesFeedParser, FeedParser as FeedParser
 from email.message import Message
 from email.policy import Policy
-from typing import IO
+from io import _WrappedBuffer
+from typing import Generic, TypeVar, overload
 
 __all__ = ["Parser", "HeaderParser", "BytesParser", "BytesHeaderParser", "FeedParser", "BytesFeedParser"]
 
-class Parser:
-    def __init__(self, _class: Callable[[], Message] | None = None, *, policy: Policy = ...) -> None: ...
-    def parse(self, fp: SupportsRead[str], headersonly: bool = False) -> Message: ...
-    def parsestr(self, text: str, headersonly: bool = False) -> Message: ...
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
 
-class HeaderParser(Parser):
-    def parse(self, fp: SupportsRead[str], headersonly: bool = True) -> Message: ...
-    def parsestr(self, text: str, headersonly: bool = True) -> Message: ...
+class Parser(Generic[_MessageT]):
+    @overload
+    def __init__(self: Parser[Message[str, str]], _class: None = None, *, policy: Policy[Message[str, str]] = ...) -> None: ...
+    @overload
+    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
+    def parse(self, fp: SupportsRead[str], headersonly: bool = False) -> _MessageT: ...
+    def parsestr(self, text: str, headersonly: bool = False) -> _MessageT: ...
 
-class BytesParser:
-    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
-    def parse(self, fp: IO[bytes], headersonly: bool = False) -> Message: ...
-    def parsebytes(self, text: bytes | bytearray, headersonly: bool = False) -> Message: ...
+class HeaderParser(Parser[_MessageT]):
+    def parse(self, fp: SupportsRead[str], headersonly: bool = True) -> _MessageT: ...
+    def parsestr(self, text: str, headersonly: bool = True) -> _MessageT: ...
 
-class BytesHeaderParser(BytesParser):
-    def parse(self, fp: IO[bytes], headersonly: bool = True) -> Message: ...
-    def parsebytes(self, text: bytes | bytearray, headersonly: bool = True) -> Message: ...
+class BytesParser(Generic[_MessageT]):
+    parser: Parser[_MessageT]
+    @overload
+    def __init__(
+        self: BytesParser[Message[str, str]], _class: None = None, *, policy: Policy[Message[str, str]] = ...
+    ) -> None: ...
+    @overload
+    def __init__(self, _class: Callable[[], _MessageT], *, policy: Policy[_MessageT] = ...) -> None: ...
+    def parse(self, fp: _WrappedBuffer, headersonly: bool = False) -> _MessageT: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = False) -> _MessageT: ...
+
+class BytesHeaderParser(BytesParser[_MessageT]):
+    def parse(self, fp: _WrappedBuffer, headersonly: bool = True) -> _MessageT: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = True) -> _MessageT: ...
diff --git a/mypy/typeshed/stdlib/email/policy.pyi b/mypy/typeshed/stdlib/email/policy.pyi
index 4df3c1e48b07..5b145bcf2318 100644
--- a/mypy/typeshed/stdlib/email/policy.pyi
+++ b/mypy/typeshed/stdlib/email/policy.pyi
@@ -1,59 +1,37 @@
-from abc import ABCMeta, abstractmethod
 from collections.abc import Callable
+from email._policybase import Compat32 as Compat32, Policy as Policy, _MessageFactory, compat32 as compat32
 from email.contentmanager import ContentManager
-from email.errors import MessageDefect
-from email.header import Header
-from email.message import Message
-from typing import Any
+from email.message import EmailMessage, Message
+from typing import Any, TypeVar, overload
+from typing_extensions import Self
 
 __all__ = ["Compat32", "compat32", "Policy", "EmailPolicy", "default", "strict", "SMTP", "HTTP"]
 
-class Policy(metaclass=ABCMeta):
-    max_line_length: int | None
-    linesep: str
-    cte_type: str
-    raise_on_defect: bool
-    mangle_from_: bool
-    message_factory: Callable[[Policy], Message] | None
+_MessageT = TypeVar("_MessageT", bound=Message, default=Message)
+
+class EmailPolicy(Policy[_MessageT]):
+    utf8: bool
+    refold_source: str
+    header_factory: Callable[[str, Any], Any]
+    content_manager: ContentManager
+    @overload
     def __init__(
-        self,
+        self: EmailPolicy[EmailMessage],
         *,
         max_line_length: int | None = ...,
         linesep: str = ...,
         cte_type: str = ...,
         raise_on_defect: bool = ...,
         mangle_from_: bool = ...,
-        message_factory: Callable[[Policy], Message] | None = ...,
+        message_factory: None = None,
+        # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+        verify_generated_headers: bool = ...,
+        utf8: bool = ...,
+        refold_source: str = ...,
+        header_factory: Callable[[str, str], str] = ...,
+        content_manager: ContentManager = ...,
     ) -> None: ...
-    def clone(self, **kw: Any) -> Policy: ...
-    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: ...
-    @abstractmethod
-    def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
-    @abstractmethod
-    def header_store_parse(self, name: str, value: str) -> tuple[str, str]: ...
-    @abstractmethod
-    def header_fetch_parse(self, name: str, value: str) -> str: ...
-    @abstractmethod
-    def fold(self, name: str, value: str) -> str: ...
-    @abstractmethod
-    def fold_binary(self, name: str, value: str) -> bytes: ...
-
-class Compat32(Policy):
-    def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
-    def header_store_parse(self, name: str, value: str) -> tuple[str, str]: ...
-    def header_fetch_parse(self, name: str, value: str) -> str | Header: ...  # type: ignore[override]
-    def fold(self, name: str, value: str) -> str: ...
-    def fold_binary(self, name: str, value: str) -> bytes: ...
-
-compat32: Compat32
-
-class EmailPolicy(Policy):
-    utf8: bool
-    refold_source: str
-    header_factory: Callable[[str, str], str]
-    content_manager: ContentManager
+    @overload
     def __init__(
         self,
         *,
@@ -62,20 +40,38 @@ class EmailPolicy(Policy):
         cte_type: str = ...,
         raise_on_defect: bool = ...,
         mangle_from_: bool = ...,
-        message_factory: Callable[[Policy], Message] | None = ...,
+        message_factory: _MessageFactory[_MessageT] | None = ...,
+        # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+        verify_generated_headers: bool = ...,
         utf8: bool = ...,
         refold_source: str = ...,
         header_factory: Callable[[str, str], str] = ...,
         content_manager: ContentManager = ...,
     ) -> None: ...
     def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
-    def header_store_parse(self, name: str, value: str) -> tuple[str, str]: ...
-    def header_fetch_parse(self, name: str, value: str) -> str: ...
-    def fold(self, name: str, value: str) -> str: ...
+    def header_store_parse(self, name: str, value: Any) -> tuple[str, Any]: ...
+    def header_fetch_parse(self, name: str, value: str) -> Any: ...
+    def fold(self, name: str, value: str) -> Any: ...
     def fold_binary(self, name: str, value: str) -> bytes: ...
+    def clone(
+        self,
+        *,
+        max_line_length: int | None = ...,
+        linesep: str = ...,
+        cte_type: str = ...,
+        raise_on_defect: bool = ...,
+        mangle_from_: bool = ...,
+        message_factory: _MessageFactory[_MessageT] | None = ...,
+        # Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+        verify_generated_headers: bool = ...,
+        utf8: bool = ...,
+        refold_source: str = ...,
+        header_factory: Callable[[str, str], str] = ...,
+        content_manager: ContentManager = ...,
+    ) -> Self: ...
 
-default: EmailPolicy
-SMTP: EmailPolicy
-SMTPUTF8: EmailPolicy
-HTTP: EmailPolicy
-strict: EmailPolicy
+default: EmailPolicy[EmailMessage]
+SMTP: EmailPolicy[EmailMessage]
+SMTPUTF8: EmailPolicy[EmailMessage]
+HTTP: EmailPolicy[EmailMessage]
+strict: EmailPolicy[EmailMessage]
diff --git a/mypy/typeshed/stdlib/email/utils.pyi b/mypy/typeshed/stdlib/email/utils.pyi
index 090ddf9e31bc..dc3eecb5ef7f 100644
--- a/mypy/typeshed/stdlib/email/utils.pyi
+++ b/mypy/typeshed/stdlib/email/utils.pyi
@@ -1,9 +1,11 @@
 import datetime
 import sys
+from _typeshed import Unused
+from collections.abc import Iterable
 from email import _ParamType
 from email.charset import Charset
 from typing import overload
-from typing_extensions import TypeAlias
+from typing_extensions import TypeAlias, deprecated
 
 __all__ = [
     "collapse_rfc2231_value",
@@ -27,9 +29,13 @@ _PDTZ: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int | None
 
 def quote(str: str) -> str: ...
 def unquote(str: str) -> str: ...
-def parseaddr(addr: str | None) -> tuple[str, str]: ...
+
+# `strict` parameter added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+def parseaddr(addr: str | list[str], *, strict: bool = True) -> tuple[str, str]: ...
 def formataddr(pair: tuple[str | None, str], charset: str | Charset = "utf-8") -> str: ...
-def getaddresses(fieldvalues: list[str]) -> list[tuple[str, str]]: ...
+
+# `strict` parameter added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+def getaddresses(fieldvalues: Iterable[str], *, strict: bool = True) -> list[tuple[str, str]]: ...
 @overload
 def parsedate(data: None) -> None: ...
 @overload
@@ -51,9 +57,22 @@ 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, 14):
+    def localtime(dt: datetime.datetime | None = None) -> datetime.datetime: ...
+
+elif sys.version_info >= (3, 12):
+    @overload
+    def localtime(dt: datetime.datetime | None = None) -> datetime.datetime: ...
+    @overload
+    @deprecated("The `isdst` parameter does nothing and will be removed in Python 3.14.")
+    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 decode_rfc2231(s: str) -> tuple[str | None, str | None, str]: ...  # May return list[str]. See issue #10431 for details.
 def encode_rfc2231(s: str, charset: str | None = None, language: str | None = None) -> str: ...
 def collapse_rfc2231_value(value: _ParamType, errors: str = "replace", fallback_charset: str = "us-ascii") -> str: ...
 def decode_params(params: list[tuple[str, str]]) -> list[tuple[str, _ParamType]]: ...
diff --git a/mypy/typeshed/stdlib/encodings/aliases.pyi b/mypy/typeshed/stdlib/encodings/aliases.pyi
new file mode 100644
index 000000000000..079af85d51ee
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/aliases.pyi
@@ -0,0 +1 @@
+aliases: dict[str, str]
diff --git a/mypy/typeshed/stdlib/encodings/ascii.pyi b/mypy/typeshed/stdlib/encodings/ascii.pyi
new file mode 100644
index 000000000000..a85585af32ed
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/ascii.pyi
@@ -0,0 +1,30 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.ascii_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.ascii_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+# Note: encode being a decode function and decode being an encode function is accurate to runtime.
+class StreamConverter(StreamWriter, StreamReader):  # type: ignore[misc]  # incompatible methods in base classes
+    # At runtime, this is codecs.ascii_decode
+    @staticmethod
+    def encode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...  # type: ignore[override]
+    # At runtime, this is codecs.ascii_encode
+    @staticmethod
+    def decode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/base64_codec.pyi b/mypy/typeshed/stdlib/encodings/base64_codec.pyi
new file mode 100644
index 000000000000..0c4f1cb1fe59
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/base64_codec.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def base64_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def base64_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/big5.pyi b/mypy/typeshed/stdlib/encodings/big5.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/big5.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/big5hkscs.pyi b/mypy/typeshed/stdlib/encodings/big5hkscs.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/big5hkscs.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/bz2_codec.pyi b/mypy/typeshed/stdlib/encodings/bz2_codec.pyi
new file mode 100644
index 000000000000..468346a93da9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/bz2_codec.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def bz2_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def bz2_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/charmap.pyi b/mypy/typeshed/stdlib/encodings/charmap.pyi
new file mode 100644
index 000000000000..a971a15860b5
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/charmap.pyi
@@ -0,0 +1,33 @@
+import codecs
+from _codecs import _CharMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.charmap_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, mapping: _CharMap | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.charmap_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, mapping: _CharMap | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    mapping: _CharMap | None
+    def __init__(self, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    mapping: _CharMap | None
+    def __init__(self, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    mapping: _CharMap | None
+    def __init__(self, stream: codecs._WritableStream, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class StreamReader(Codec, codecs.StreamReader):
+    mapping: _CharMap | None
+    def __init__(self, stream: codecs._ReadableStream, errors: str = "strict", mapping: _CharMap | None = None) -> None: ...
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/cp037.pyi b/mypy/typeshed/stdlib/encodings/cp037.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp037.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1006.pyi b/mypy/typeshed/stdlib/encodings/cp1006.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1006.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1026.pyi b/mypy/typeshed/stdlib/encodings/cp1026.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1026.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1125.pyi b/mypy/typeshed/stdlib/encodings/cp1125.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1125.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp1140.pyi b/mypy/typeshed/stdlib/encodings/cp1140.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1140.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1250.pyi b/mypy/typeshed/stdlib/encodings/cp1250.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1250.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1251.pyi b/mypy/typeshed/stdlib/encodings/cp1251.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1251.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1252.pyi b/mypy/typeshed/stdlib/encodings/cp1252.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1252.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1253.pyi b/mypy/typeshed/stdlib/encodings/cp1253.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1253.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1254.pyi b/mypy/typeshed/stdlib/encodings/cp1254.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1254.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1255.pyi b/mypy/typeshed/stdlib/encodings/cp1255.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1255.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1256.pyi b/mypy/typeshed/stdlib/encodings/cp1256.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1256.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1257.pyi b/mypy/typeshed/stdlib/encodings/cp1257.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1257.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp1258.pyi b/mypy/typeshed/stdlib/encodings/cp1258.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp1258.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp273.pyi b/mypy/typeshed/stdlib/encodings/cp273.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp273.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp424.pyi b/mypy/typeshed/stdlib/encodings/cp424.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp424.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp437.pyi b/mypy/typeshed/stdlib/encodings/cp437.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp437.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp500.pyi b/mypy/typeshed/stdlib/encodings/cp500.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp500.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp720.pyi b/mypy/typeshed/stdlib/encodings/cp720.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp720.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp737.pyi b/mypy/typeshed/stdlib/encodings/cp737.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp737.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp775.pyi b/mypy/typeshed/stdlib/encodings/cp775.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp775.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp850.pyi b/mypy/typeshed/stdlib/encodings/cp850.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp850.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp852.pyi b/mypy/typeshed/stdlib/encodings/cp852.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp852.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp855.pyi b/mypy/typeshed/stdlib/encodings/cp855.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp855.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp856.pyi b/mypy/typeshed/stdlib/encodings/cp856.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp856.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp857.pyi b/mypy/typeshed/stdlib/encodings/cp857.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp857.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp858.pyi b/mypy/typeshed/stdlib/encodings/cp858.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp858.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp860.pyi b/mypy/typeshed/stdlib/encodings/cp860.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp860.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp861.pyi b/mypy/typeshed/stdlib/encodings/cp861.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp861.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp862.pyi b/mypy/typeshed/stdlib/encodings/cp862.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp862.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp863.pyi b/mypy/typeshed/stdlib/encodings/cp863.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp863.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp864.pyi b/mypy/typeshed/stdlib/encodings/cp864.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp864.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp865.pyi b/mypy/typeshed/stdlib/encodings/cp865.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp865.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp866.pyi b/mypy/typeshed/stdlib/encodings/cp866.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp866.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp869.pyi b/mypy/typeshed/stdlib/encodings/cp869.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp869.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/cp874.pyi b/mypy/typeshed/stdlib/encodings/cp874.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp874.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp875.pyi b/mypy/typeshed/stdlib/encodings/cp875.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp875.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/cp932.pyi b/mypy/typeshed/stdlib/encodings/cp932.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp932.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/cp949.pyi b/mypy/typeshed/stdlib/encodings/cp949.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp949.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/cp950.pyi b/mypy/typeshed/stdlib/encodings/cp950.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/cp950.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/euc_jis_2004.pyi b/mypy/typeshed/stdlib/encodings/euc_jis_2004.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/euc_jis_2004.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/euc_jisx0213.pyi b/mypy/typeshed/stdlib/encodings/euc_jisx0213.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/euc_jisx0213.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/euc_jp.pyi b/mypy/typeshed/stdlib/encodings/euc_jp.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/euc_jp.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/euc_kr.pyi b/mypy/typeshed/stdlib/encodings/euc_kr.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/euc_kr.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/gb18030.pyi b/mypy/typeshed/stdlib/encodings/gb18030.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/gb18030.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/gb2312.pyi b/mypy/typeshed/stdlib/encodings/gb2312.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/gb2312.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/gbk.pyi b/mypy/typeshed/stdlib/encodings/gbk.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/gbk.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/hex_codec.pyi b/mypy/typeshed/stdlib/encodings/hex_codec.pyi
new file mode 100644
index 000000000000..3fd4fe38898a
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/hex_codec.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def hex_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def hex_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/hp_roman8.pyi b/mypy/typeshed/stdlib/encodings/hp_roman8.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/hp_roman8.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/hz.pyi b/mypy/typeshed/stdlib/encodings/hz.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/hz.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/idna.pyi b/mypy/typeshed/stdlib/encodings/idna.pyi
new file mode 100644
index 000000000000..3e2c8baf1cb2
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/idna.pyi
@@ -0,0 +1,26 @@
+import codecs
+import re
+from _typeshed import ReadableBuffer
+
+dots: re.Pattern[str]
+ace_prefix: bytes
+sace_prefix: str
+
+def nameprep(label: str) -> str: ...
+def ToASCII(label: str) -> bytes: ...
+def ToUnicode(label: bytes | str) -> str: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: ReadableBuffer | str, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    def _buffer_encode(self, input: str, errors: str, final: bool) -> tuple[bytes, int]: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input: ReadableBuffer | str, errors: str, final: bool) -> tuple[str, int]: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso2022_jp.pyi b/mypy/typeshed/stdlib/encodings/iso2022_jp.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso2022_jp.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso2022_jp_1.pyi b/mypy/typeshed/stdlib/encodings/iso2022_jp_1.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso2022_jp_1.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso2022_jp_2.pyi b/mypy/typeshed/stdlib/encodings/iso2022_jp_2.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso2022_jp_2.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso2022_jp_2004.pyi b/mypy/typeshed/stdlib/encodings/iso2022_jp_2004.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso2022_jp_2004.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso2022_jp_3.pyi b/mypy/typeshed/stdlib/encodings/iso2022_jp_3.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso2022_jp_3.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso2022_jp_ext.pyi b/mypy/typeshed/stdlib/encodings/iso2022_jp_ext.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso2022_jp_ext.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso2022_kr.pyi b/mypy/typeshed/stdlib/encodings/iso2022_kr.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso2022_kr.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_1.pyi b/mypy/typeshed/stdlib/encodings/iso8859_1.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_1.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_10.pyi b/mypy/typeshed/stdlib/encodings/iso8859_10.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_10.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_11.pyi b/mypy/typeshed/stdlib/encodings/iso8859_11.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_11.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_13.pyi b/mypy/typeshed/stdlib/encodings/iso8859_13.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_13.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_14.pyi b/mypy/typeshed/stdlib/encodings/iso8859_14.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_14.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_15.pyi b/mypy/typeshed/stdlib/encodings/iso8859_15.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_15.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_16.pyi b/mypy/typeshed/stdlib/encodings/iso8859_16.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_16.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_2.pyi b/mypy/typeshed/stdlib/encodings/iso8859_2.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_2.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_3.pyi b/mypy/typeshed/stdlib/encodings/iso8859_3.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_3.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_4.pyi b/mypy/typeshed/stdlib/encodings/iso8859_4.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_4.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_5.pyi b/mypy/typeshed/stdlib/encodings/iso8859_5.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_5.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_6.pyi b/mypy/typeshed/stdlib/encodings/iso8859_6.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_6.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_7.pyi b/mypy/typeshed/stdlib/encodings/iso8859_7.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_7.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_8.pyi b/mypy/typeshed/stdlib/encodings/iso8859_8.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_8.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/iso8859_9.pyi b/mypy/typeshed/stdlib/encodings/iso8859_9.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/iso8859_9.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/johab.pyi b/mypy/typeshed/stdlib/encodings/johab.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/johab.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/koi8_r.pyi b/mypy/typeshed/stdlib/encodings/koi8_r.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/koi8_r.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/koi8_t.pyi b/mypy/typeshed/stdlib/encodings/koi8_t.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/koi8_t.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/koi8_u.pyi b/mypy/typeshed/stdlib/encodings/koi8_u.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/koi8_u.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/kz1048.pyi b/mypy/typeshed/stdlib/encodings/kz1048.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/kz1048.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/latin_1.pyi b/mypy/typeshed/stdlib/encodings/latin_1.pyi
new file mode 100644
index 000000000000..3b06773eac03
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/latin_1.pyi
@@ -0,0 +1,30 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.latin_1_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.latin_1_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+# Note: encode being a decode function and decode being an encode function is accurate to runtime.
+class StreamConverter(StreamWriter, StreamReader):  # type: ignore[misc]  # incompatible methods in base classes
+    # At runtime, this is codecs.latin_1_decode
+    @staticmethod
+    def encode(data: ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...  # type: ignore[override]
+    # At runtime, this is codecs.latin_1_encode
+    @staticmethod
+    def decode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/mac_arabic.pyi b/mypy/typeshed/stdlib/encodings/mac_arabic.pyi
new file mode 100644
index 000000000000..42781b489298
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_arabic.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_map: dict[int, int | None]
+decoding_table: str
+encoding_map: dict[int, int]
diff --git a/mypy/typeshed/stdlib/encodings/mac_centeuro.pyi b/mypy/typeshed/stdlib/encodings/mac_centeuro.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_centeuro.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_croatian.pyi b/mypy/typeshed/stdlib/encodings/mac_croatian.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_croatian.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_cyrillic.pyi b/mypy/typeshed/stdlib/encodings/mac_cyrillic.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_cyrillic.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_farsi.pyi b/mypy/typeshed/stdlib/encodings/mac_farsi.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_farsi.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_greek.pyi b/mypy/typeshed/stdlib/encodings/mac_greek.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_greek.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_iceland.pyi b/mypy/typeshed/stdlib/encodings/mac_iceland.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_iceland.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_latin2.pyi b/mypy/typeshed/stdlib/encodings/mac_latin2.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_latin2.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_roman.pyi b/mypy/typeshed/stdlib/encodings/mac_roman.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_roman.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_romanian.pyi b/mypy/typeshed/stdlib/encodings/mac_romanian.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_romanian.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mac_turkish.pyi b/mypy/typeshed/stdlib/encodings/mac_turkish.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mac_turkish.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/mbcs.pyi b/mypy/typeshed/stdlib/encodings/mbcs.pyi
new file mode 100644
index 000000000000..2c2917d63f6d
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/mbcs.pyi
@@ -0,0 +1,28 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+if sys.platform == "win32":
+    encode = codecs.mbcs_encode
+
+    def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+    class IncrementalEncoder(codecs.IncrementalEncoder):
+        def encode(self, input: str, final: bool = False) -> bytes: ...
+
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        # At runtime, this is codecs.mbcs_decode
+        @staticmethod
+        def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    class StreamWriter(codecs.StreamWriter):
+        # At runtime, this is codecs.mbcs_encode
+        @staticmethod
+        def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+    class StreamReader(codecs.StreamReader):
+        # At runtime, this is codecs.mbcs_decode
+        @staticmethod
+        def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/oem.pyi b/mypy/typeshed/stdlib/encodings/oem.pyi
new file mode 100644
index 000000000000..376c12c445f4
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/oem.pyi
@@ -0,0 +1,28 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+if sys.platform == "win32":
+    encode = codecs.oem_encode
+
+    def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+    class IncrementalEncoder(codecs.IncrementalEncoder):
+        def encode(self, input: str, final: bool = False) -> bytes: ...
+
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        # At runtime, this is codecs.oem_decode
+        @staticmethod
+        def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    class StreamWriter(codecs.StreamWriter):
+        # At runtime, this is codecs.oem_encode
+        @staticmethod
+        def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+    class StreamReader(codecs.StreamReader):
+        # At runtime, this is codecs.oem_decode
+        @staticmethod
+        def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+    def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/palmos.pyi b/mypy/typeshed/stdlib/encodings/palmos.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/palmos.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/ptcp154.pyi b/mypy/typeshed/stdlib/encodings/ptcp154.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/ptcp154.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/punycode.pyi b/mypy/typeshed/stdlib/encodings/punycode.pyi
new file mode 100644
index 000000000000..eb99e667b416
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/punycode.pyi
@@ -0,0 +1,33 @@
+import codecs
+from typing import Literal
+
+def segregate(str: str) -> tuple[bytes, list[int]]: ...
+def selective_len(str: str, max: int) -> int: ...
+def selective_find(str: str, char: str, index: int, pos: int) -> tuple[int, int]: ...
+def insertion_unsort(str: str, extended: list[int]) -> list[int]: ...
+def T(j: int, bias: int) -> int: ...
+
+digits: Literal[b"abcdefghijklmnopqrstuvwxyz0123456789"]
+
+def generate_generalized_integer(N: int, bias: int) -> bytes: ...
+def adapt(delta: int, first: bool, numchars: int) -> int: ...
+def generate_integers(baselen: int, deltas: list[int]) -> bytes: ...
+def punycode_encode(text: str) -> bytes: ...
+def decode_generalized_number(extended: bytes, extpos: int, bias: int, errors: str) -> tuple[int, int | None]: ...
+def insertion_sort(base: str, extended: bytes, errors: str) -> str: ...
+def punycode_decode(text: memoryview | bytes | bytearray | str, errors: str) -> str: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: memoryview | bytes | bytearray | str, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: memoryview | bytes | bytearray | str, final: bool = False) -> str: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/quopri_codec.pyi b/mypy/typeshed/stdlib/encodings/quopri_codec.pyi
new file mode 100644
index 000000000000..e9deadd8d463
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/quopri_codec.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def quopri_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def quopri_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/raw_unicode_escape.pyi b/mypy/typeshed/stdlib/encodings/raw_unicode_escape.pyi
new file mode 100644
index 000000000000..74abb4623fab
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/raw_unicode_escape.pyi
@@ -0,0 +1,34 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.raw_unicode_escape_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.raw_unicode_escape_decode
+    if sys.version_info >= (3, 9):
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
+    else:
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 9):
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
+
+else:
+    class IncrementalDecoder(codecs.IncrementalDecoder):
+        def decode(self, input: str | ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    if sys.version_info >= (3, 9):
+        def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/rot_13.pyi b/mypy/typeshed/stdlib/encodings/rot_13.pyi
new file mode 100644
index 000000000000..8d71bc957594
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/rot_13.pyi
@@ -0,0 +1,23 @@
+import codecs
+from _typeshed import SupportsRead, SupportsWrite
+
+# This codec is string to string.
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+    def decode(self, input: str, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> str: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: str, final: bool = False) -> str: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+rot13_map: dict[int, int]
+
+def rot13(infile: SupportsRead[str], outfile: SupportsWrite[str]) -> None: ...
diff --git a/mypy/typeshed/stdlib/encodings/shift_jis.pyi b/mypy/typeshed/stdlib/encodings/shift_jis.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/shift_jis.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/shift_jis_2004.pyi b/mypy/typeshed/stdlib/encodings/shift_jis_2004.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/shift_jis_2004.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/shift_jisx0213.pyi b/mypy/typeshed/stdlib/encodings/shift_jisx0213.pyi
new file mode 100644
index 000000000000..d613026a5a86
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/shift_jisx0213.pyi
@@ -0,0 +1,23 @@
+import _multibytecodec as mbc
+import codecs
+from typing import ClassVar
+
+codec: mbc._MultibyteCodec
+
+class Codec(codecs.Codec):
+    encode = codec.encode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+    decode = codec.decode  # type: ignore[assignment]  # pyright: ignore[reportAssignmentType]
+
+class IncrementalEncoder(mbc.MultibyteIncrementalEncoder, codecs.IncrementalEncoder):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class IncrementalDecoder(mbc.MultibyteIncrementalDecoder, codecs.IncrementalDecoder):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamReader(Codec, mbc.MultibyteStreamReader, codecs.StreamReader):  # type: ignore[misc]
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+class StreamWriter(Codec, mbc.MultibyteStreamWriter, codecs.StreamWriter):
+    codec: ClassVar[mbc._MultibyteCodec] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/tis_620.pyi b/mypy/typeshed/stdlib/encodings/tis_620.pyi
new file mode 100644
index 000000000000..f62195662ce9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/tis_620.pyi
@@ -0,0 +1,21 @@
+import codecs
+from _codecs import _EncodingMap
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
+
+decoding_table: str
+encoding_table: _EncodingMap
diff --git a/mypy/typeshed/stdlib/encodings/undefined.pyi b/mypy/typeshed/stdlib/encodings/undefined.pyi
new file mode 100644
index 000000000000..4775dac752f2
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/undefined.pyi
@@ -0,0 +1,20 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+# These return types are just to match the base types. In reality, these always
+# raise an error.
+
+class Codec(codecs.Codec):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+class StreamReader(Codec, codecs.StreamReader): ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/unicode_escape.pyi b/mypy/typeshed/stdlib/encodings/unicode_escape.pyi
new file mode 100644
index 000000000000..1e942f57916e
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/unicode_escape.pyi
@@ -0,0 +1,34 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+
+class Codec(codecs.Codec):
+    # At runtime, this is codecs.unicode_escape_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+    # At runtime, this is codecs.unicode_escape_decode
+    if sys.version_info >= (3, 9):
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
+    else:
+        @staticmethod
+        def decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+if sys.version_info >= (3, 9):
+    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+        def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
+
+else:
+    class IncrementalDecoder(codecs.IncrementalDecoder):
+        def decode(self, input: str | ReadableBuffer, final: bool = False) -> str: ...
+
+class StreamWriter(Codec, codecs.StreamWriter): ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    if sys.version_info >= (3, 9):
+        def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_16.pyi b/mypy/typeshed/stdlib/encodings/utf_16.pyi
new file mode 100644
index 000000000000..3b712cde420a
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/utf_16.pyi
@@ -0,0 +1,20 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_16_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input: ReadableBuffer, errors: str, final: bool) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_16_be.pyi b/mypy/typeshed/stdlib/encodings/utf_16_be.pyi
new file mode 100644
index 000000000000..cc7d1534fc69
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/utf_16_be.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_16_be_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_16_be_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_16_be_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_16_be_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_16_le.pyi b/mypy/typeshed/stdlib/encodings/utf_16_le.pyi
new file mode 100644
index 000000000000..ba103eb088e3
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/utf_16_le.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_16_le_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_16_le_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_16_le_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_16_le_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_32.pyi b/mypy/typeshed/stdlib/encodings/utf_32.pyi
new file mode 100644
index 000000000000..c925be712c72
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/utf_32.pyi
@@ -0,0 +1,20 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_32_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input: ReadableBuffer, errors: str, final: bool) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_32_be.pyi b/mypy/typeshed/stdlib/encodings/utf_32_be.pyi
new file mode 100644
index 000000000000..9d28f5199c50
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/utf_32_be.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_32_be_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_32_be_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_32_be_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_32_be_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_32_le.pyi b/mypy/typeshed/stdlib/encodings/utf_32_le.pyi
new file mode 100644
index 000000000000..5be14a91a3e6
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/utf_32_le.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_32_le_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_32_le_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_32_le_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_32_le_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_7.pyi b/mypy/typeshed/stdlib/encodings/utf_7.pyi
new file mode 100644
index 000000000000..dc1162f34c28
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/utf_7.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+encode = codecs.utf_7_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_7_decode
+    @staticmethod
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_7_encode
+    @staticmethod
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_7_decode
+    @staticmethod
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/utf_8.pyi b/mypy/typeshed/stdlib/encodings/utf_8.pyi
index 0de51026f9f5..918712d80473 100644
--- a/mypy/typeshed/stdlib/encodings/utf_8.pyi
+++ b/mypy/typeshed/stdlib/encodings/utf_8.pyi
@@ -1,21 +1,26 @@
 import codecs
 from _typeshed import ReadableBuffer
 
+encode = codecs.utf_8_encode
+
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
 class IncrementalEncoder(codecs.IncrementalEncoder):
     def encode(self, input: str, final: bool = False) -> bytes: ...
 
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    # At runtime, this is codecs.utf_8_decode
     @staticmethod
-    def _buffer_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
+    def _buffer_decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
 
 class StreamWriter(codecs.StreamWriter):
+    # At runtime, this is codecs.utf_8_encode
     @staticmethod
-    def encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+    def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
 
 class StreamReader(codecs.StreamReader):
+    # At runtime, this is codecs.utf_8_decode
     @staticmethod
-    def decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
+    def decode(data: ReadableBuffer, errors: str | None = None, final: bool = False, /) -> tuple[str, int]: ...
 
 def getregentry() -> codecs.CodecInfo: ...
-def encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
-def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
diff --git a/mypy/typeshed/stdlib/encodings/uu_codec.pyi b/mypy/typeshed/stdlib/encodings/uu_codec.pyi
new file mode 100644
index 000000000000..e32ba8ac0a1a
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/uu_codec.pyi
@@ -0,0 +1,28 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def uu_encode(
+    input: ReadableBuffer, errors: str = "strict", filename: str = "<data>", mode: int = 0o666
+) -> tuple[bytes, int]: ...
+def uu_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/encodings/zlib_codec.pyi b/mypy/typeshed/stdlib/encodings/zlib_codec.pyi
new file mode 100644
index 000000000000..0f13d0e810e9
--- /dev/null
+++ b/mypy/typeshed/stdlib/encodings/zlib_codec.pyi
@@ -0,0 +1,26 @@
+import codecs
+from _typeshed import ReadableBuffer
+from typing import ClassVar
+
+# This codec is bytes to bytes.
+
+def zlib_encode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+def zlib_decode(input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...
+
+class Codec(codecs.Codec):
+    def encode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+    def decode(self, input: ReadableBuffer, errors: str = "strict") -> tuple[bytes, int]: ...  # type: ignore[override]
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.IncrementalDecoder):
+    def decode(self, input: ReadableBuffer, final: bool = False) -> bytes: ...  # type: ignore[override]
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    charbuffertype: ClassVar[type] = ...
+
+class StreamReader(Codec, codecs.StreamReader):
+    charbuffertype: ClassVar[type] = ...
+
+def getregentry() -> codecs.CodecInfo: ...
diff --git a/mypy/typeshed/stdlib/enum.pyi b/mypy/typeshed/stdlib/enum.pyi
index 383c336ed2c7..4a6287a712af 100644
--- a/mypy/typeshed/stdlib/enum.pyi
+++ b/mypy/typeshed/stdlib/enum.pyi
@@ -2,11 +2,10 @@ import _typeshed
 import sys
 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 typing import Any, Generic, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from typing import Any, Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
 __all__ = ["EnumMeta", "Enum", "IntEnum", "Flag", "IntFlag", "auto", "unique"]
 
@@ -32,8 +31,13 @@ if sys.version_info >= (3, 11):
         "nonmember",
         "property",
         "verify",
+        "pickle_by_enum_name",
+        "pickle_by_global_name",
     ]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["EnumDict"]
+
 _EnumMemberT = TypeVar("_EnumMemberT")
 _EnumerationT = TypeVar("_EnumerationT", bound=type[Enum])
 
@@ -60,7 +64,11 @@ if sys.version_info >= (3, 11):
         def __init__(self, value: _EnumMemberT) -> None: ...
 
 class _EnumDict(dict[str, Any]):
-    def __init__(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(self, cls_name: str | None = None) -> None: ...
+    else:
+        def __init__(self) -> None: ...
+
     def __setitem__(self, key: str, value: Any) -> None: ...
     if sys.version_info >= (3, 11):
         # See comment above `typing.MutableMapping.update`
@@ -72,13 +80,15 @@ class _EnumDict(dict[str, Any]):
         def update(self, members: SupportsKeysAndGetItem[str, Any], **more_members: Any) -> None: ...
         @overload
         def update(self, members: Iterable[tuple[str, Any]], **more_members: Any) -> None: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def member_names(self) -> list[str]: ...
+
+if sys.version_info >= (3, 13):
+    EnumDict = _EnumDict
 
-# Note: EnumMeta actually subclasses type directly, not ABCMeta.
-# This is a temporary workaround to allow multiple creation of enums with builtins
-# such as str as mixins, which due to the handling of ABCs of builtin types, cause
-# spurious inconsistent metaclass structure. See #1595.
 # Structurally: Iterable[T], Reversible[T], Container[T] where T is the enum itself
-class EnumMeta(ABCMeta):
+class EnumMeta(type):
     if sys.version_info >= (3, 11):
         def __new__(
             metacls: type[_typeshed.Self],
@@ -121,10 +131,12 @@ class EnumMeta(ABCMeta):
     def __len__(self) -> int: ...
     def __bool__(self) -> Literal[True]: ...
     def __dir__(self) -> list[str]: ...
-    # Simple value lookup
+
+    # Overload 1: Value lookup on an already existing enum class (simple case)
     @overload
     def __call__(cls: type[_EnumMemberT], value: Any, names: None = None) -> _EnumMemberT: ...
-    # Functional Enum API
+
+    # Overload 2: Functional API for constructing new enum classes.
     if sys.version_info >= (3, 11):
         @overload
         def __call__(
@@ -150,6 +162,18 @@ class EnumMeta(ABCMeta):
             type: type | None = None,
             start: int = 1,
         ) -> type[Enum]: ...
+
+    # Overload 3 (py312+ only): Value lookup on an already existing enum class (complex case)
+    #
+    # >>> class Foo(enum.Enum):
+    # ...     X = 1, 2, 3
+    # >>> Foo(1, 2, 3)
+    # <Foo.X: (1, 2, 3)>
+    #
+    if sys.version_info >= (3, 12):
+        @overload
+        def __call__(cls: type[_EnumMemberT], value: Any, *values: Any) -> _EnumMemberT: ...
+
     _member_names_: list[str]  # undocumented
     _member_map_: dict[str, Enum]  # undocumented
     _value2member_map_: dict[Any, Enum]  # undocumented
@@ -162,6 +186,8 @@ if sys.version_info >= (3, 11):
         def __set_name__(self, ownerclass: type[Enum], name: str) -> None: ...
         name: str
         clsname: str
+        member: Enum | None
+
     _magic_enum_attr = property
 else:
     _magic_enum_attr = types.DynamicClassAttribute
@@ -187,8 +213,15 @@ class Enum(metaclass=EnumMeta):
     # and in practice using `object` here has the same effect as using `Any`.
     def __new__(cls, value: object) -> Self: ...
     def __dir__(self) -> list[str]: ...
+    def __hash__(self) -> int: ...
     def __format__(self, format_spec: str) -> str: ...
     def __reduce_ex__(self, proto: Unused) -> tuple[Any, ...]: ...
+    if sys.version_info >= (3, 11):
+        def __copy__(self) -> Self: ...
+        def __deepcopy__(self, memo: Any) -> Self: ...
+    if sys.version_info >= (3, 12):
+        @classmethod
+        def __signature__(cls) -> str: ...
 
 if sys.version_info >= (3, 11):
     class ReprEnum(Enum): ...
@@ -234,11 +267,14 @@ 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
-        NAMED_FLAGS: str
-        UNIQUE: str
+        CONTINUOUS = "no skipped integer values"
+        NAMED_FLAGS = "multi-flag aliases may not contain unnamed flags"
+        UNIQUE = "one name per value"
+
     CONTINUOUS = EnumCheck.CONTINUOUS
     NAMED_FLAGS = EnumCheck.NAMED_FLAGS
     UNIQUE = EnumCheck.UNIQUE
@@ -248,10 +284,11 @@ if sys.version_info >= (3, 11):
         def __call__(self, enumeration: _EnumerationT) -> _EnumerationT: ...
 
     class FlagBoundary(StrEnum):
-        STRICT: str
-        CONFORM: str
-        EJECT: str
-        KEEP: str
+        STRICT = "strict"
+        CONFORM = "conform"
+        EJECT = "eject"
+        KEEP = "keep"
+
     STRICT = FlagBoundary.STRICT
     CONFORM = FlagBoundary.CONFORM
     EJECT = FlagBoundary.EJECT
@@ -283,9 +320,24 @@ else:
         __rand__ = __and__
         __rxor__ = __xor__
 
-# subclassing IntFlag so it picks up all implemented base functions, best modeling behavior of enum.auto()
-class auto(IntFlag):
+class auto:
     _value_: Any
     @_magic_enum_attr
     def value(self) -> Any: ...
     def __new__(cls) -> Self: ...
+
+    # These don't exist, but auto is basically immediately replaced with
+    # either an int or a str depending on the type of the enum. StrEnum's auto
+    # shouldn't have these, but they're needed for int versions of auto (mostly the __or__).
+    # Ideally type checkers would special case auto enough to handle this,
+    # but until then this is a slightly inaccurate helping hand.
+    def __or__(self, other: int | Self) -> Self: ...
+    def __and__(self, other: int | Self) -> Self: ...
+    def __xor__(self, other: int | Self) -> Self: ...
+    __ror__ = __or__
+    __rand__ = __and__
+    __rxor__ = __xor__
+
+if sys.version_info >= (3, 11):
+    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/errno.pyi b/mypy/typeshed/stdlib/errno.pyi
index 28874d44ff5f..84d2b44a6a61 100644
--- a/mypy/typeshed/stdlib/errno.pyi
+++ b/mypy/typeshed/stdlib/errno.pyi
@@ -91,9 +91,15 @@ ECANCELED: int  # undocumented
 ENOTRECOVERABLE: int  # undocumented
 EOWNERDEAD: int  # undocumented
 
+if sys.platform == "sunos5" or sys.platform == "solaris":  # noqa: Y008
+    ELOCKUNMAPPED: int
+    ENOTACTIVE: int
+
 if sys.platform != "win32":
     ENOTBLK: int
     EMULTIHOP: int
+
+if sys.platform == "darwin":
     # All of the below are undocumented
     EAUTH: int
     EBADARCH: int
@@ -112,9 +118,8 @@ if sys.platform != "win32":
     EPWROFF: int
     ERPCMISMATCH: int
     ESHLIBVERS: int
-
-    if sys.platform != "darwin" or sys.version_info >= (3, 11):
-        EQFULL: int  # undocumented
+    if sys.version_info >= (3, 11):
+        EQFULL: int
 
 if sys.platform != "darwin":
     EDEADLOCK: int
@@ -164,9 +169,6 @@ if sys.platform != "win32" and sys.platform != "darwin":
     ENOKEY: int
     ENOMEDIUM: int
     ERFKILL: int
-    EL: int
-    ELOCKUNMAPPED: int
-    ENOTACTIVE: int
 
 if sys.platform == "win32":
     # All of these are undocumented
diff --git a/mypy/typeshed/stdlib/faulthandler.pyi b/mypy/typeshed/stdlib/faulthandler.pyi
index 7b42b8ec8444..320a8b6fad15 100644
--- a/mypy/typeshed/stdlib/faulthandler.pyi
+++ b/mypy/typeshed/stdlib/faulthandler.pyi
@@ -10,4 +10,4 @@ def is_enabled() -> bool: ...
 
 if sys.platform != "win32":
     def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None: ...
-    def unregister(signum: int) -> None: ...
+    def unregister(signum: int, /) -> None: ...
diff --git a/mypy/typeshed/stdlib/fcntl.pyi b/mypy/typeshed/stdlib/fcntl.pyi
index 01443083f48d..71078b3b4579 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 Buffer, Literal
+from typing import Any, Final, Literal, overload
+from typing_extensions import Buffer
 
 if sys.platform != "win32":
     FASYNC: int
@@ -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,23 +33,21 @@ 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
-            F_GET_SEALS: int
-            F_SEAL_GROW: int
-            F_SEAL_SEAL: int
-            F_SEAL_SHRINK: int
-            F_SEAL_WRITE: int
+        F_ADD_SEALS: int
+        F_GET_SEALS: int
+        F_SEAL_GROW: int
+        F_SEAL_SEAL: int
+        F_SEAL_SHRINK: int
+        F_SEAL_WRITE: int
         if sys.version_info >= (3, 9):
-            F_OFD_GETLK: int
-            F_OFD_SETLK: int
-            F_OFD_SETLKW: int
+            F_OFD_GETLK: Final[int]
+            F_OFD_SETLK: Final[int]
+            F_OFD_SETLKW: Final[int]
+
         if sys.version_info >= (3, 10):
             F_GETPIPE_SZ: int
             F_SETPIPE_SZ: int
@@ -69,8 +70,10 @@ if sys.platform != "win32":
         LOCK_RW: int
         LOCK_WRITE: int
 
-    # These are highly problematic, they might be present or not, depends on the specific OS.
     if sys.platform == "linux":
+        # Constants for the POSIX STREAMS interface. Present in glibc until 2.29 (released February 2019).
+        # Never implemented on BSD, and considered "obsolescent" starting in POSIX 2008.
+        # Probably still used on Solaris.
         I_ATMARK: int
         I_CANPUT: int
         I_CKBAND: int
@@ -100,23 +103,58 @@ if sys.platform != "win32":
         I_STR: int
         I_SWROPT: int
         I_UNLINK: int
+
+    if sys.version_info >= (3, 12) and sys.platform == "linux":
+        FICLONE: int
+        FICLONERANGE: int
+
+    if sys.version_info >= (3, 13) and sys.platform == "linux":
+        F_OWNER_TID: Final = 0
+        F_OWNER_PID: Final = 1
+        F_OWNER_PGRP: Final = 2
+        F_SETOWN_EX: Final = 15
+        F_GETOWN_EX: Final = 16
+        F_SEAL_FUTURE_WRITE: Final = 16
+        F_GET_RW_HINT: Final = 1035
+        F_SET_RW_HINT: Final = 1036
+        F_GET_FILE_RW_HINT: Final = 1037
+        F_SET_FILE_RW_HINT: Final = 1038
+        RWH_WRITE_LIFE_NOT_SET: Final = 0
+        RWH_WRITE_LIFE_NONE: Final = 1
+        RWH_WRITE_LIFE_SHORT: Final = 2
+        RWH_WRITE_LIFE_MEDIUM: Final = 3
+        RWH_WRITE_LIFE_LONG: Final = 4
+        RWH_WRITE_LIFE_EXTREME: Final = 5
+
+    if sys.version_info >= (3, 11) and sys.platform == "darwin":
+        F_OFD_SETLK: Final = 90
+        F_OFD_SETLKW: Final = 91
+        F_OFD_GETLK: Final = 92
+
+    if sys.version_info >= (3, 13) and sys.platform != "linux":
+        # OSx and NetBSD
+        F_GETNOSIGPIPE: Final[int]
+        F_SETNOSIGPIPE: Final[int]
+        # OSx and FreeBSD
+        F_RDAHEAD: Final[int]
+
     @overload
-    def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: int = 0) -> int: ...
+    def fcntl(fd: FileDescriptorLike, cmd: int, arg: int = 0, /) -> int: ...
     @overload
-    def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: str | ReadOnlyBuffer) -> bytes: ...
+    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: ...
+    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: bytes, __mutate_flag: bool = True) -> bytes: ...
+    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: ...
+    def ioctl(fd: FileDescriptorLike, request: int, arg: WriteableBuffer, mutate_flag: Literal[False], /) -> bytes: ...
     @overload
-    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: ...
+    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/filecmp.pyi b/mypy/typeshed/stdlib/filecmp.pyi
index 008d7a44e6c4..cb7b94596077 100644
--- a/mypy/typeshed/stdlib/filecmp.pyi
+++ b/mypy/typeshed/stdlib/filecmp.pyi
@@ -1,8 +1,7 @@
 import sys
 from _typeshed import GenericPath, StrOrBytesPath
 from collections.abc import Callable, Iterable, Sequence
-from typing import Any, AnyStr, Generic
-from typing_extensions import Literal
+from typing import Any, AnyStr, Final, Generic, Literal
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -10,7 +9,7 @@ if sys.version_info >= (3, 9):
 __all__ = ["clear_cache", "cmp", "dircmp", "cmpfiles", "DEFAULT_IGNORES"]
 
 DEFAULT_IGNORES: list[str]
-BUFSIZE: Literal[8192]
+BUFSIZE: Final = 8192
 
 def cmp(f1: StrOrBytesPath, f2: StrOrBytesPath, shallow: bool | Literal[0, 1] = True) -> bool: ...
 def cmpfiles(
@@ -18,13 +17,24 @@ def cmpfiles(
 ) -> tuple[list[AnyStr], list[AnyStr], list[AnyStr]]: ...
 
 class dircmp(Generic[AnyStr]):
-    def __init__(
-        self,
-        a: GenericPath[AnyStr],
-        b: GenericPath[AnyStr],
-        ignore: Sequence[AnyStr] | None = None,
-        hide: Sequence[AnyStr] | None = None,
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            a: GenericPath[AnyStr],
+            b: GenericPath[AnyStr],
+            ignore: Sequence[AnyStr] | None = None,
+            hide: Sequence[AnyStr] | None = None,
+            *,
+            shallow: bool = True,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            a: GenericPath[AnyStr],
+            b: GenericPath[AnyStr],
+            ignore: Sequence[AnyStr] | None = None,
+            hide: Sequence[AnyStr] | None = None,
+        ) -> None: ...
     left: AnyStr
     right: AnyStr
     hide: Sequence[AnyStr]
@@ -53,6 +63,6 @@ class dircmp(Generic[AnyStr]):
     def phase4(self) -> None: ...
     def phase4_closure(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def clear_cache() -> None: ...
diff --git a/mypy/typeshed/stdlib/fileinput.pyi b/mypy/typeshed/stdlib/fileinput.pyi
index e9f3713b4eaf..1e6aa78e2607 100644
--- a/mypy/typeshed/stdlib/fileinput.pyi
+++ b/mypy/typeshed/stdlib/fileinput.pyi
@@ -2,8 +2,8 @@ import sys
 from _typeshed import AnyStr_co, StrOrBytesPath
 from collections.abc import Callable, Iterable, Iterator
 from types import TracebackType
-from typing import IO, Any, AnyStr, Generic, Protocol, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, AnyStr, Literal, Protocol, overload
+from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -68,7 +68,7 @@ if sys.version_info >= (3, 10):
         errors: str | None = None,
     ) -> FileInput[Any]: ...
 
-elif sys.version_info >= (3, 8):
+else:
     # bufsize is dropped and mode and openhook become keyword-only
     @overload
     def input(
@@ -98,57 +98,6 @@ elif sys.version_info >= (3, 8):
         openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
     ) -> FileInput[Any]: ...
 
-else:
-    @overload
-    def input(
-        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
-        inplace: bool = False,
-        backup: str = "",
-        bufsize: int = 0,
-        mode: _TextMode = "r",
-        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
-    ) -> FileInput[str]: ...
-    # Because mode isn't keyword-only here yet, we need two overloads each for
-    # the bytes case and the fallback case.
-    @overload
-    def input(
-        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
-        inplace: bool = False,
-        backup: str = "",
-        bufsize: int = 0,
-        *,
-        mode: Literal["rb"],
-        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
-    ) -> FileInput[bytes]: ...
-    @overload
-    def input(
-        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None,
-        inplace: bool,
-        backup: str,
-        bufsize: int,
-        mode: Literal["rb"],
-        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
-    ) -> FileInput[bytes]: ...
-    @overload
-    def input(
-        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
-        inplace: bool = False,
-        backup: str = "",
-        bufsize: int = 0,
-        *,
-        mode: str,
-        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
-    ) -> FileInput[Any]: ...
-    @overload
-    def input(
-        files: StrOrBytesPath | Iterable[StrOrBytesPath] | None,
-        inplace: bool,
-        backup: str,
-        bufsize: int,
-        mode: str,
-        openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
-    ) -> FileInput[Any]: ...
-
 def close() -> None: ...
 def nextfile() -> None: ...
 def filename() -> str: ...
@@ -158,7 +107,7 @@ def fileno() -> int: ...
 def isfirstline() -> bool: ...
 def isstdin() -> bool: ...
 
-class FileInput(Iterator[AnyStr], Generic[AnyStr]):
+class FileInput(Iterator[AnyStr]):
     if sys.version_info >= (3, 10):
         # encoding and errors are added
         @overload
@@ -198,7 +147,7 @@ class FileInput(Iterator[AnyStr], Generic[AnyStr]):
             errors: str | None = None,
         ) -> None: ...
 
-    elif sys.version_info >= (3, 8):
+    else:
         # bufsize is dropped and mode and openhook become keyword-only
         @overload
         def __init__(
@@ -231,62 +180,6 @@ class FileInput(Iterator[AnyStr], Generic[AnyStr]):
             openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
         ) -> None: ...
 
-    else:
-        @overload
-        def __init__(
-            self: FileInput[str],
-            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
-            inplace: bool = False,
-            backup: str = "",
-            bufsize: int = 0,
-            mode: _TextMode = "r",
-            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[str]] | None = None,
-        ) -> None: ...
-        # Because mode isn't keyword-only here yet, we need two overloads each for
-        # the bytes case and the fallback case.
-        @overload
-        def __init__(
-            self: FileInput[bytes],
-            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
-            inplace: bool = False,
-            backup: str = "",
-            bufsize: int = 0,
-            *,
-            mode: Literal["rb"],
-            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: FileInput[bytes],
-            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None,
-            inplace: bool,
-            backup: str,
-            bufsize: int,
-            mode: Literal["rb"],
-            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[bytes]] | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: FileInput[Any],
-            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None = None,
-            inplace: bool = False,
-            backup: str = "",
-            bufsize: int = 0,
-            *,
-            mode: str,
-            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: FileInput[Any],
-            files: StrOrBytesPath | Iterable[StrOrBytesPath] | None,
-            inplace: bool,
-            backup: str,
-            bufsize: int,
-            mode: str,
-            openhook: Callable[[StrOrBytesPath, str], _HasReadlineAndFileno[Any]] | None = None,
-        ) -> None: ...
-
     def __del__(self) -> None: ...
     def close(self) -> None: ...
     def __enter__(self) -> Self: ...
@@ -307,7 +200,7 @@ class FileInput(Iterator[AnyStr], Generic[AnyStr]):
     def isfirstline(self) -> bool: ...
     def isstdin(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 10):
     def hook_compressed(
diff --git a/mypy/typeshed/stdlib/fractions.pyi b/mypy/typeshed/stdlib/fractions.pyi
index 7ec8addeb136..aaa3a22087fc 100644
--- a/mypy/typeshed/stdlib/fractions.pyi
+++ b/mypy/typeshed/stdlib/fractions.pyi
@@ -2,8 +2,8 @@ import sys
 from collections.abc import Callable
 from decimal import Decimal
 from numbers import Integral, Rational, Real
-from typing import Any, overload
-from typing_extensions import Literal, Self, SupportsIndex, TypeAlias
+from typing import Any, Literal, Protocol, SupportsIndex, overload
+from typing_extensions import Self, TypeAlias
 
 _ComparableNum: TypeAlias = int | float | Decimal | Real
 
@@ -20,18 +20,25 @@ else:
     @overload
     def gcd(a: Integral, b: Integral) -> Integral: ...
 
+class _ConvertibleToIntegerRatio(Protocol):
+    def as_integer_ratio(self) -> tuple[int | Rational, int | Rational]: ...
+
 class Fraction(Rational):
     @overload
     def __new__(cls, numerator: int | Rational = 0, denominator: int | Rational | None = None) -> Self: ...
     @overload
-    def __new__(cls, __value: float | Decimal | str) -> Self: ...
+    def __new__(cls, numerator: float | Decimal | str) -> Self: ...
+
+    if sys.version_info >= (3, 14):
+        @overload
+        def __new__(cls, numerator: _ConvertibleToIntegerRatio) -> Self: ...
+
     @classmethod
     def from_float(cls, f: float) -> Self: ...
     @classmethod
     def from_decimal(cls, dec: Decimal) -> Self: ...
     def limit_denominator(self, max_denominator: int = 1000000) -> Fraction: ...
-    if sys.version_info >= (3, 8):
-        def as_integer_ratio(self) -> tuple[int, int]: ...
+    def as_integer_ratio(self) -> tuple[int, int]: ...
     if sys.version_info >= (3, 12):
         def is_integer(self) -> bool: ...
 
@@ -103,25 +110,14 @@ class Fraction(Rational):
     def __rmod__(b, a: int | Fraction) -> Fraction: ...
     @overload
     def __rmod__(b, a: float) -> float: ...
-    if sys.version_info >= (3, 8):
-        @overload
-        def __divmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
-        @overload
-        def __divmod__(a, b: float) -> tuple[float, Fraction]: ...
-        @overload
-        def __rdivmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
-        @overload
-        def __rdivmod__(a, b: float) -> tuple[float, Fraction]: ...
-    else:
-        @overload
-        def __divmod__(self, other: int | Fraction) -> tuple[int, Fraction]: ...
-        @overload
-        def __divmod__(self, other: float) -> tuple[float, Fraction]: ...
-        @overload
-        def __rdivmod__(self, other: int | Fraction) -> tuple[int, Fraction]: ...
-        @overload
-        def __rdivmod__(self, other: float) -> tuple[float, Fraction]: ...
-
+    @overload
+    def __divmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
+    @overload
+    def __divmod__(a, b: float) -> tuple[float, Fraction]: ...
+    @overload
+    def __rdivmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
+    @overload
+    def __rdivmod__(a, b: float) -> tuple[float, Fraction]: ...
     @overload
     def __pow__(a, b: int) -> Fraction: ...
     @overload
@@ -142,7 +138,7 @@ class Fraction(Rational):
     def __round__(self, ndigits: None = None) -> int: ...
     @overload
     def __round__(self, ndigits: int) -> Fraction: ...
-    def __hash__(self) -> int: ...
+    def __hash__(self) -> int: ...  # type: ignore[override]
     def __eq__(a, b: object) -> bool: ...
     def __lt__(a, b: _ComparableNum) -> bool: ...
     def __gt__(a, b: _ComparableNum) -> bool: ...
diff --git a/mypy/typeshed/stdlib/ftplib.pyi b/mypy/typeshed/stdlib/ftplib.pyi
index 36a213d48680..3693d7c52a26 100644
--- a/mypy/typeshed/stdlib/ftplib.pyi
+++ b/mypy/typeshed/stdlib/ftplib.pyi
@@ -4,16 +4,16 @@ from collections.abc import Callable, Iterable, Iterator
 from socket import socket
 from ssl import SSLContext
 from types import TracebackType
-from typing import Any, TextIO
-from typing_extensions import Literal, Self
+from typing import Any, Final, Literal, TextIO
+from typing_extensions import Self
 
 __all__ = ["FTP", "error_reply", "error_temp", "error_perm", "error_proto", "all_errors", "FTP_TLS"]
 
-MSG_OOB: Literal[1]
-FTP_PORT: Literal[21]
-MAXLINE: Literal[8192]
-CRLF: Literal["\r\n"]
-B_CRLF: Literal[b"\r\n"]
+MSG_OOB: Final = 1
+FTP_PORT: Final = 21
+MAXLINE: Final = 8192
+CRLF: Final = "\r\n"
+B_CRLF: Final = b"\r\n"
 
 class Error(Exception): ...
 class error_reply(Error): ...
@@ -31,7 +31,7 @@ class FTP:
     sock: socket | None
     welcome: str | None
     passiveserver: int
-    timeout: int
+    timeout: float | None
     af: int
     lastresp: str
     file: TextIO | None
@@ -48,7 +48,7 @@ class FTP:
             user: str = "",
             passwd: str = "",
             acct: str = "",
-            timeout: float = ...,
+            timeout: float | None = ...,
             source_address: tuple[str, int] | None = None,
             *,
             encoding: str = "utf-8",
@@ -60,7 +60,7 @@ class FTP:
             user: str = "",
             passwd: str = "",
             acct: str = "",
-            timeout: float = ...,
+            timeout: float | None = ...,
             source_address: tuple[str, int] | None = None,
         ) -> None: ...
 
@@ -86,8 +86,8 @@ class FTP:
     def makeport(self) -> socket: ...
     def makepasv(self) -> tuple[str, int]: ...
     def login(self, user: str = "", passwd: str = "", acct: str = "") -> str: ...
-    # In practice, `rest` rest can actually be anything whose str() is an integer sequence, so to make it simple we allow integers.
-    def ntransfercmd(self, cmd: str, rest: int | str | None = None) -> tuple[socket, int]: ...
+    # In practice, `rest` can actually be anything whose str() is an integer sequence, so to make it simple we allow integers
+    def ntransfercmd(self, cmd: str, rest: int | str | None = None) -> tuple[socket, int | None]: ...
     def transfercmd(self, cmd: str, rest: int | str | None = None) -> socket: ...
     def retrbinary(
         self, cmd: str, callback: Callable[[bytes], object], blocksize: int = 8192, rest: int | str | None = None
@@ -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 | None = ...,
+            source_address: tuple[str, int] | None = None,
+            encoding: str = "utf-8",
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
         def __init__(
             self,
             host: str = "",
@@ -128,7 +141,7 @@ class FTP_TLS(FTP):
             keyfile: str | None = None,
             certfile: str | None = None,
             context: SSLContext | None = None,
-            timeout: float = ...,
+            timeout: float | None = ...,
             source_address: tuple[str, int] | None = None,
             *,
             encoding: str = "utf-8",
@@ -143,7 +156,7 @@ class FTP_TLS(FTP):
             keyfile: str | None = None,
             certfile: str | None = None,
             context: SSLContext | None = None,
-            timeout: float = ...,
+            timeout: float | None = ...,
             source_address: tuple[str, int] | None = None,
         ) -> None: ...
     ssl_version: int
diff --git a/mypy/typeshed/stdlib/functools.pyi b/mypy/typeshed/stdlib/functools.pyi
index d01fd8ce55cb..f786167e322d 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 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 _typeshed import SupportsAllComparisons, SupportsItems
+from collections.abc import Callable, Hashable, Iterable, Sized
+from typing import Any, Generic, Literal, NamedTuple, TypedDict, TypeVar, final, overload
+from typing_extensions import ParamSpec, Self, TypeAlias
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -20,23 +20,25 @@ __all__ = [
     "partial",
     "partialmethod",
     "singledispatch",
+    "cached_property",
+    "singledispatchmethod",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["cached_property", "singledispatchmethod"]
-
 if sys.version_info >= (3, 9):
     __all__ += ["cache"]
 
-_AnyCallable: TypeAlias = Callable[..., object]
-
 _T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
 _S = TypeVar("_S")
+_PWrapped = ParamSpec("_PWrapped")
+_RWrapped = TypeVar("_RWrapped")
+_PWrapper = ParamSpec("_PWrapper")
+_RWrapper = TypeVar("_RWrapper")
 
 @overload
-def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ...
+def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T, /) -> _T: ...
 @overload
-def reduce(function: Callable[[_T, _T], _T], sequence: Iterable[_T]) -> _T: ...
+def reduce(function: Callable[[_T, _T], _T], sequence: Iterable[_T], /) -> _T: ...
 
 class _CacheInfo(NamedTuple):
     hits: int
@@ -59,33 +61,64 @@ class _lru_cache_wrapper(Generic[_T]):
         def cache_parameters(self) -> _CacheParameters: ...
 
     def __copy__(self) -> _lru_cache_wrapper[_T]: ...
-    def __deepcopy__(self, __memo: Any) -> _lru_cache_wrapper[_T]: ...
-
-if sys.version_info >= (3, 8):
-    @overload
-    def lru_cache(maxsize: int | None = 128, typed: bool = False) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ...
-    @overload
-    def lru_cache(maxsize: Callable[..., _T], typed: bool = False) -> _lru_cache_wrapper[_T]: ...
+    def __deepcopy__(self, memo: Any, /) -> _lru_cache_wrapper[_T]: ...
 
+@overload
+def lru_cache(maxsize: int | None = 128, typed: bool = False) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ...
+@overload
+def lru_cache(maxsize: Callable[..., _T], typed: bool = False) -> _lru_cache_wrapper[_T]: ...
+
+if sys.version_info >= (3, 12):
+    WRAPPER_ASSIGNMENTS: tuple[
+        Literal["__module__"],
+        Literal["__name__"],
+        Literal["__qualname__"],
+        Literal["__doc__"],
+        Literal["__annotations__"],
+        Literal["__type_params__"],
+    ]
 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__"]
-]
+    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, _RWrapper]):
+    __wrapped__: Callable[_PWrapped, _RWrapped]
+    def __call__(self, *args: _PWrapper.args, **kwargs: _PWrapper.kwargs) -> _RWrapper: ...
+    # 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, _RWrapper]) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWrapper]: ...
+
+if sys.version_info >= (3, 12):
+    def update_wrapper(
+        wrapper: Callable[_PWrapper, _RWrapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWrapper]: ...
+    def wraps(
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+
+else:
+    def update_wrapper(
+        wrapper: Callable[_PWrapper, _RWrapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWrapper]: ...
+    def wraps(
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Iterable[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]: ...
 
@@ -96,10 +129,10 @@ class partial(Generic[_T]):
     def args(self) -> tuple[Any, ...]: ...
     @property
     def keywords(self) -> dict[str, Any]: ...
-    def __new__(cls, __func: Callable[..., _T], *args: Any, **kwargs: Any) -> Self: ...
-    def __call__(__self, *args: Any, **kwargs: Any) -> _T: ...
+    def __new__(cls, func: Callable[..., _T], /, *args: Any, **kwargs: Any) -> Self: ...
+    def __call__(self, /, *args: Any, **kwargs: Any) -> _T: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # With protocols, this could change into a generic protocol that defines __get__ and returns _T
 _Descriptor: TypeAlias = Any
@@ -109,18 +142,19 @@ class partialmethod(Generic[_T]):
     args: tuple[Any, ...]
     keywords: dict[str, Any]
     @overload
-    def __init__(self, __func: Callable[..., _T], *args: Any, **keywords: Any) -> None: ...
+    def __init__(self, func: Callable[..., _T], /, *args: Any, **keywords: Any) -> None: ...
     @overload
-    def __init__(self, __func: _Descriptor, *args: Any, **keywords: Any) -> None: ...
-    if sys.version_info >= (3, 8):
-        def __get__(self, obj: Any, cls: type[Any] | None = None) -> Callable[..., _T]: ...
-    else:
-        def __get__(self, obj: Any, cls: type[Any] | None) -> Callable[..., _T]: ...
-
+    def __init__(self, func: _Descriptor, /, *args: Any, **keywords: Any) -> None: ...
+    def __get__(self, obj: Any, cls: type[Any] | None = None) -> Callable[..., _T]: ...
     @property
     def __isabstractmethod__(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+if sys.version_info >= (3, 11):
+    _RegType: TypeAlias = type[Any] | types.UnionType
+else:
+    _RegType: TypeAlias = type[Any]
 
 class _SingleDispatchCallable(Generic[_T]):
     registry: types.MappingProxyType[Any, Callable[..., _T]]
@@ -128,50 +162,49 @@ class _SingleDispatchCallable(Generic[_T]):
     # @fun.register(complex)
     # def _(arg, verbose=False): ...
     @overload
-    def register(self, cls: type[Any], func: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
+    def register(self, cls: _RegType, func: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
     # @fun.register
     # def _(arg: int, verbose=False):
     @overload
     def register(self, cls: Callable[..., _T], func: None = None) -> Callable[..., _T]: ...
     # fun.register(int, lambda x: x)
     @overload
-    def register(self, cls: type[Any], func: Callable[..., _T]) -> Callable[..., _T]: ...
+    def register(self, cls: _RegType, func: Callable[..., _T]) -> Callable[..., _T]: ...
     def _clear_cache(self) -> None: ...
-    def __call__(__self, *args: Any, **kwargs: Any) -> _T: ...
+    def __call__(self, /, *args: Any, **kwargs: Any) -> _T: ...
 
 def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ...
 
-if sys.version_info >= (3, 8):
-    class singledispatchmethod(Generic[_T]):
-        dispatcher: _SingleDispatchCallable[_T]
-        func: Callable[..., _T]
-        def __init__(self, func: Callable[..., _T]) -> None: ...
-        @property
-        def __isabstractmethod__(self) -> bool: ...
-        @overload
-        def register(self, cls: type[Any], method: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
-        @overload
-        def register(self, cls: Callable[..., _T], method: None = None) -> Callable[..., _T]: ...
-        @overload
-        def register(self, cls: type[Any], method: Callable[..., _T]) -> Callable[..., _T]: ...
-        def __get__(self, obj: _S, cls: type[_S] | None = None) -> Callable[..., _T]: ...
-
-    class cached_property(Generic[_T]):
-        func: Callable[[Any], _T]
-        attrname: str | None
-        def __init__(self, func: Callable[[Any], _T]) -> None: ...
-        @overload
-        def __get__(self, instance: None, owner: type[Any] | None = None) -> Self: ...
-        @overload
-        def __get__(self, instance: object, owner: type[Any] | None = None) -> _T: ...
-        def __set_name__(self, owner: type[Any], name: str) -> None: ...
-        # __set__ is not defined at runtime, but @cached_property is designed to be settable
-        def __set__(self, instance: object, value: _T) -> None: ...
-        if sys.version_info >= (3, 9):
-            def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+class singledispatchmethod(Generic[_T]):
+    dispatcher: _SingleDispatchCallable[_T]
+    func: Callable[..., _T]
+    def __init__(self, func: Callable[..., _T]) -> None: ...
+    @property
+    def __isabstractmethod__(self) -> bool: ...
+    @overload
+    def register(self, cls: _RegType, method: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
+    @overload
+    def register(self, cls: Callable[..., _T], method: None = None) -> Callable[..., _T]: ...
+    @overload
+    def register(self, cls: _RegType, method: Callable[..., _T]) -> Callable[..., _T]: ...
+    def __get__(self, obj: _S, cls: type[_S] | None = None) -> Callable[..., _T]: ...
+
+class cached_property(Generic[_T_co]):
+    func: Callable[[Any], _T_co]
+    attrname: str | None
+    def __init__(self, func: Callable[[Any], _T_co]) -> None: ...
+    @overload
+    def __get__(self, instance: None, owner: type[Any] | None = None) -> Self: ...
+    @overload
+    def __get__(self, instance: object, owner: type[Any] | None = None) -> _T_co: ...
+    def __set_name__(self, owner: type[Any], name: str) -> None: ...
+    # __set__ is not defined at runtime, but @cached_property is designed to be settable
+    def __set__(self, instance: object, value: _T_co) -> None: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 9):
-    def cache(__user_function: Callable[..., _T]) -> _lru_cache_wrapper[_T]: ...
+    def cache(user_function: Callable[..., _T], /) -> _lru_cache_wrapper[_T]: ...
 
 def _make_key(
     args: tuple[Hashable, ...],
diff --git a/mypy/typeshed/stdlib/gc.pyi b/mypy/typeshed/stdlib/gc.pyi
index 27cee726ba09..9d34e0d6213a 100644
--- a/mypy/typeshed/stdlib/gc.pyi
+++ b/mypy/typeshed/stdlib/gc.pyi
@@ -1,13 +1,13 @@
 import sys
 from collections.abc import Callable
-from typing import Any
-from typing_extensions import Literal, TypeAlias
+from typing import Any, Final, Literal
+from typing_extensions import TypeAlias
 
-DEBUG_COLLECTABLE: Literal[2]
-DEBUG_LEAK: Literal[38]
-DEBUG_SAVEALL: Literal[32]
-DEBUG_STATS: Literal[1]
-DEBUG_UNCOLLECTABLE: Literal[4]
+DEBUG_COLLECTABLE: Final = 2
+DEBUG_LEAK: Final = 38
+DEBUG_SAVEALL: Final = 32
+DEBUG_STATS: Final = 1
+DEBUG_UNCOLLECTABLE: Final = 4
 
 _CallbackType: TypeAlias = Callable[[Literal["start", "stop"], dict[str, int]], object]
 
@@ -19,13 +19,7 @@ def disable() -> None: ...
 def enable() -> None: ...
 def get_count() -> tuple[int, int, int]: ...
 def get_debug() -> int: ...
-
-if sys.version_info >= (3, 8):
-    def get_objects(generation: int | None = None) -> list[Any]: ...
-
-else:
-    def get_objects() -> list[Any]: ...
-
+def get_objects(generation: int | None = None) -> list[Any]: ...
 def freeze() -> None: ...
 def unfreeze() -> None: ...
 def get_freeze_count() -> int: ...
@@ -33,11 +27,11 @@ def get_referents(*objs: Any) -> list[Any]: ...
 def get_referrers(*objs: Any) -> list[Any]: ...
 def get_stats() -> list[dict[str, Any]]: ...
 def get_threshold() -> tuple[int, int, int]: ...
-def is_tracked(__obj: Any) -> bool: ...
+def is_tracked(obj: Any, /) -> bool: ...
 
 if sys.version_info >= (3, 9):
-    def is_finalized(__obj: Any) -> bool: ...
+    def is_finalized(obj: Any, /) -> bool: ...
 
 def isenabled() -> bool: ...
-def set_debug(__flags: int) -> None: ...
-def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None: ...
+def set_debug(flags: int, /) -> None: ...
+def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ..., /) -> None: ...
diff --git a/mypy/typeshed/stdlib/genericpath.pyi b/mypy/typeshed/stdlib/genericpath.pyi
index 46426b63c852..9d87c48fd520 100644
--- a/mypy/typeshed/stdlib/genericpath.pyi
+++ b/mypy/typeshed/stdlib/genericpath.pyi
@@ -1,8 +1,9 @@
 import os
-from _typeshed import BytesPath, FileDescriptorOrPath, StrPath, SupportsRichComparisonT
+import sys
+from _typeshed import BytesPath, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRichComparisonT
 from collections.abc import Sequence
-from typing import overload
-from typing_extensions import Literal, LiteralString
+from typing import Literal, overload
+from typing_extensions import LiteralString
 
 __all__ = [
     "commonprefix",
@@ -17,6 +18,10 @@ __all__ = [
     "sameopenfile",
     "samestat",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["islink"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isjunction", "isdevdrive", "lexists"]
 
 # All overloads can return empty string. Ideally, Literal[""] would be a valid
 # Iterable[T], so that list[T] | Literal[""] could be used as a return
@@ -36,6 +41,9 @@ def getsize(filename: FileDescriptorOrPath) -> int: ...
 def isfile(path: FileDescriptorOrPath) -> bool: ...
 def isdir(s: FileDescriptorOrPath) -> bool: ...
 
+if sys.version_info >= (3, 12):
+    def islink(path: StrOrBytesPath) -> bool: ...
+
 # These return float if os.stat_float_times() == True,
 # but int is a subclass of float.
 def getatime(filename: FileDescriptorOrPath) -> float: ...
@@ -44,3 +52,8 @@ def getctime(filename: FileDescriptorOrPath) -> float: ...
 def samefile(f1: FileDescriptorOrPath, f2: FileDescriptorOrPath) -> bool: ...
 def sameopenfile(fp1: int, fp2: int) -> bool: ...
 def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ...
+
+if sys.version_info >= (3, 13):
+    def isjunction(path: StrOrBytesPath) -> bool: ...
+    def isdevdrive(path: StrOrBytesPath) -> bool: ...
+    def lexists(path: StrOrBytesPath) -> bool: ...
diff --git a/mypy/typeshed/stdlib/getopt.pyi b/mypy/typeshed/stdlib/getopt.pyi
index bc9d4da4796b..c15db8122cfc 100644
--- a/mypy/typeshed/stdlib/getopt.pyi
+++ b/mypy/typeshed/stdlib/getopt.pyi
@@ -1,7 +1,23 @@
+from collections.abc import Iterable, Sequence
+from typing import Protocol, TypeVar, overload, type_check_only
+
+_StrSequenceT_co = TypeVar("_StrSequenceT_co", covariant=True, bound=Sequence[str])
+
+@type_check_only
+class _SliceableT(Protocol[_StrSequenceT_co]):
+    @overload
+    def __getitem__(self, key: int, /) -> str: ...
+    @overload
+    def __getitem__(self, key: slice, /) -> _StrSequenceT_co: ...
+
 __all__ = ["GetoptError", "error", "getopt", "gnu_getopt"]
 
-def getopt(args: list[str], shortopts: str, longopts: list[str] = []) -> tuple[list[tuple[str, str]], list[str]]: ...
-def gnu_getopt(args: list[str], shortopts: str, longopts: list[str] = []) -> tuple[list[tuple[str, str]], list[str]]: ...
+def getopt(
+    args: _SliceableT[_StrSequenceT_co], shortopts: str, longopts: Iterable[str] | str = []
+) -> tuple[list[tuple[str, str]], _StrSequenceT_co]: ...
+def gnu_getopt(
+    args: Sequence[str], shortopts: str, longopts: Iterable[str] | str = []
+) -> tuple[list[tuple[str, str]], list[str]]: ...
 
 class GetoptError(Exception):
     msg: str
diff --git a/mypy/typeshed/stdlib/gettext.pyi b/mypy/typeshed/stdlib/gettext.pyi
index 57e81120b8ca..d8fd92a00e13 100644
--- a/mypy/typeshed/stdlib/gettext.pyi
+++ b/mypy/typeshed/stdlib/gettext.pyi
@@ -2,8 +2,7 @@ import io
 import sys
 from _typeshed import StrPath
 from collections.abc import Callable, Container, Iterable, Sequence
-from typing import Any, Protocol, TypeVar, overload
-from typing_extensions import Final, Literal
+from typing import Any, Final, Literal, Protocol, TypeVar, overload
 
 __all__ = [
     "NullTranslations",
@@ -18,14 +17,15 @@ __all__ = [
     "dngettext",
     "gettext",
     "ngettext",
+    "dnpgettext",
+    "dpgettext",
+    "npgettext",
+    "pgettext",
 ]
 
 if sys.version_info < (3, 11):
     __all__ += ["bind_textdomain_codeset", "ldgettext", "ldngettext", "lgettext", "lngettext"]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["dnpgettext", "dpgettext", "npgettext", "pgettext"]
-
 class _TranslationsReader(Protocol):
     def read(self) -> bytes: ...
     # optional:
@@ -37,10 +37,8 @@ class NullTranslations:
     def add_fallback(self, fallback: NullTranslations) -> None: ...
     def gettext(self, message: str) -> str: ...
     def ngettext(self, msgid1: str, msgid2: str, n: int) -> str: ...
-    if sys.version_info >= (3, 8):
-        def pgettext(self, context: str, message: str) -> str: ...
-        def npgettext(self, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
-
+    def pgettext(self, context: str, message: str) -> str: ...
+    def npgettext(self, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
     def info(self) -> dict[str, str]: ...
     def charset(self) -> str | None: ...
     if sys.version_info < (3, 11):
@@ -156,12 +154,10 @@ def dgettext(domain: str, message: str) -> str: ...
 def dngettext(domain: str, msgid1: str, msgid2: str, n: int) -> str: ...
 def gettext(message: str) -> str: ...
 def ngettext(msgid1: str, msgid2: str, n: int) -> str: ...
-
-if sys.version_info >= (3, 8):
-    def pgettext(context: str, message: str) -> str: ...
-    def dpgettext(domain: str, context: str, message: str) -> str: ...
-    def npgettext(context: str, msgid1: str, msgid2: str, n: int) -> str: ...
-    def dnpgettext(domain: str, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
+def pgettext(context: str, message: str) -> str: ...
+def dpgettext(domain: str, context: str, message: str) -> str: ...
+def npgettext(context: str, msgid1: str, msgid2: str, n: int) -> str: ...
+def dnpgettext(domain: str, context: str, msgid1: str, msgid2: str, n: int) -> str: ...
 
 if sys.version_info < (3, 11):
     def lgettext(message: str) -> str: ...
@@ -171,3 +167,5 @@ if sys.version_info < (3, 11):
     def bind_textdomain_codeset(domain: str, codeset: str | None = None) -> str: ...
 
 Catalog = translation
+
+def c2py(plural: str) -> Callable[[int], int]: ...
diff --git a/mypy/typeshed/stdlib/glob.pyi b/mypy/typeshed/stdlib/glob.pyi
index 914ccc12ef1e..03cb5418e256 100644
--- a/mypy/typeshed/stdlib/glob.pyi
+++ b/mypy/typeshed/stdlib/glob.pyi
@@ -1,10 +1,13 @@
 import sys
 from _typeshed import StrOrBytesPath
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from typing import AnyStr
 
 __all__ = ["escape", "glob", "iglob"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["translate"]
+
 def glob0(dirname: AnyStr, pattern: AnyStr) -> list[AnyStr]: ...
 def glob1(dirname: AnyStr, pattern: AnyStr) -> list[AnyStr]: ...
 
@@ -40,3 +43,8 @@ else:
 
 def escape(pathname: AnyStr) -> AnyStr: ...
 def has_magic(s: str | bytes) -> bool: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def translate(
+        pat: str, *, recursive: bool = False, include_hidden: bool = False, seps: Sequence[str] | None = None
+    ) -> str: ...
diff --git a/mypy/typeshed/stdlib/graphlib.pyi b/mypy/typeshed/stdlib/graphlib.pyi
index c02d447ad501..1ca8cbe12b08 100644
--- a/mypy/typeshed/stdlib/graphlib.pyi
+++ b/mypy/typeshed/stdlib/graphlib.pyi
@@ -23,6 +23,6 @@ class TopologicalSorter(Generic[_T]):
     def get_ready(self) -> tuple[_T, ...]: ...
     def static_order(self) -> Iterable[_T]: ...
     if sys.version_info >= (3, 11):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class CycleError(ValueError): ...
diff --git a/mypy/typeshed/stdlib/grp.pyi b/mypy/typeshed/stdlib/grp.pyi
index 4b66b84b6389..965ecece2a56 100644
--- a/mypy/typeshed/stdlib/grp.pyi
+++ b/mypy/typeshed/stdlib/grp.pyi
@@ -1,13 +1,13 @@
 import sys
 from _typeshed import structseq
-from typing import Any
-from typing_extensions import Final, final
+from typing import Any, Final, final
 
 if sys.platform != "win32":
     @final
     class struct_group(structseq[Any], tuple[str, str | None, int, list[str]]):
         if sys.version_info >= (3, 10):
             __match_args__: Final = ("gr_name", "gr_passwd", "gr_gid", "gr_mem")
+
         @property
         def gr_name(self) -> str: ...
         @property
diff --git a/mypy/typeshed/stdlib/gzip.pyi b/mypy/typeshed/stdlib/gzip.pyi
index 1ec8b4b8ca7c..b7fb40fbd82e 100644
--- a/mypy/typeshed/stdlib/gzip.pyi
+++ b/mypy/typeshed/stdlib/gzip.pyi
@@ -2,38 +2,35 @@ import _compression
 import sys
 import zlib
 from _typeshed import ReadableBuffer, SizedBuffer, StrOrBytesPath
-from io import FileIO
-from typing import Protocol, TextIO, overload
-from typing_extensions import Literal, TypeAlias
+from io import FileIO, TextIOWrapper
+from typing import Final, Literal, Protocol, overload
+from typing_extensions import TypeAlias
 
-if sys.version_info >= (3, 8):
-    __all__ = ["BadGzipFile", "GzipFile", "open", "compress", "decompress"]
-else:
-    __all__ = ["GzipFile", "open", "compress", "decompress"]
+__all__ = ["BadGzipFile", "GzipFile", "open", "compress", "decompress"]
 
 _ReadBinaryMode: TypeAlias = Literal["r", "rb"]
 _WriteBinaryMode: TypeAlias = Literal["a", "ab", "w", "wb", "x", "xb"]
 _OpenTextMode: TypeAlias = Literal["rt", "at", "wt", "xt"]
 
-READ: Literal[1]  # undocumented
-WRITE: Literal[2]  # undocumented
+READ: Final[object]  # undocumented
+WRITE: Final[object]  # undocumented
 
-FTEXT: int  # actually Literal[1] # undocumented
-FHCRC: int  # actually Literal[2] # undocumented
-FEXTRA: int  # actually Literal[4] # undocumented
-FNAME: int  # actually Literal[8] # undocumented
-FCOMMENT: int  # actually Literal[16] # undocumented
+FTEXT: Final[int]  # actually Literal[1] # undocumented
+FHCRC: Final[int]  # actually Literal[2] # undocumented
+FEXTRA: Final[int]  # actually Literal[4] # undocumented
+FNAME: Final[int]  # actually Literal[8] # undocumented
+FCOMMENT: Final[int]  # actually Literal[16] # undocumented
 
 class _ReadableFileobj(Protocol):
-    def read(self, __n: int) -> bytes: ...
-    def seek(self, __n: int) -> object: ...
+    def read(self, n: int, /) -> bytes: ...
+    def seek(self, n: int, /) -> object: ...
     # The following attributes and methods are optional:
     # name: str
     # mode: str
     # def fileno() -> int: ...
 
 class _WritableFileobj(Protocol):
-    def write(self, __b: bytes) -> object: ...
+    def write(self, b: bytes, /) -> object: ...
     def flush(self) -> object: ...
     # The following attributes and methods are optional:
     # name: str
@@ -60,13 +57,13 @@ def open(
 ) -> GzipFile: ...
 @overload
 def open(
-    filename: StrOrBytesPath,
+    filename: StrOrBytesPath | _ReadableFileobj | _WritableFileobj,
     mode: _OpenTextMode,
     compresslevel: int = 9,
     encoding: str | None = None,
     errors: str | None = None,
     newline: str | None = None,
-) -> TextIO: ...
+) -> TextIOWrapper: ...
 @overload
 def open(
     filename: StrOrBytesPath | _ReadableFileobj | _WritableFileobj,
@@ -75,7 +72,7 @@ def open(
     encoding: str | None = None,
     errors: str | None = None,
     newline: str | None = None,
-) -> GzipFile | TextIO: ...
+) -> GzipFile | TextIOWrapper: ...
 
 class _PaddedFile:
     file: _ReadableFileobj
@@ -85,12 +82,11 @@ class _PaddedFile:
     def seek(self, off: int) -> int: ...
     def seekable(self) -> bool: ...
 
-if sys.version_info >= (3, 8):
-    class BadGzipFile(OSError): ...
+class BadGzipFile(OSError): ...
 
 class GzipFile(_compression.BaseStream):
     myfileobj: FileIO | None
-    mode: Literal[1, 2]
+    mode: object
     name: str
     compress: zlib._Compress
     fileobj: _ReadableFileobj | _WritableFileobj
@@ -139,8 +135,10 @@ class GzipFile(_compression.BaseStream):
         fileobj: _ReadableFileobj | _WritableFileobj | None = None,
         mtime: float | None = None,
     ) -> None: ...
-    @property
-    def filename(self) -> str: ...
+    if sys.version_info < (3, 12):
+        @property
+        def filename(self) -> str: ...
+
     @property
     def mtime(self) -> int | None: ...
     crc: int
@@ -158,10 +156,5 @@ class GzipFile(_compression.BaseStream):
 class _GzipReader(_compression.DecompressReader):
     def __init__(self, fp: _ReadableFileobj) -> None: ...
 
-if sys.version_info >= (3, 8):
-    def compress(data: SizedBuffer, compresslevel: int = 9, *, mtime: float | None = None) -> bytes: ...
-
-else:
-    def compress(data: SizedBuffer, compresslevel: int = 9) -> bytes: ...
-
+def compress(data: SizedBuffer, compresslevel: int = 9, *, mtime: float | None = None) -> bytes: ...
 def decompress(data: ReadableBuffer) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/hashlib.pyi b/mypy/typeshed/stdlib/hashlib.pyi
index 18b1ab549764..84666a7fa725 100644
--- a/mypy/typeshed/stdlib/hashlib.pyi
+++ b/mypy/typeshed/stdlib/hashlib.pyi
@@ -1,8 +1,20 @@
 import sys
+from _blake2 import blake2b as blake2b, blake2s as blake2s
+from _hashlib import (
+    HASH,
+    _HashObject,
+    openssl_md5 as md5,
+    openssl_sha1 as sha1,
+    openssl_sha224 as sha224,
+    openssl_sha256 as sha256,
+    openssl_sha384 as sha384,
+    openssl_sha512 as sha512,
+    pbkdf2_hmac as pbkdf2_hmac,
+    scrypt as scrypt,
+)
 from _typeshed import ReadableBuffer
 from collections.abc import Callable, Set as AbstractSet
-from typing import Protocol
-from typing_extensions import Self, final
+from typing import Protocol, type_check_only
 
 if sys.version_info >= (3, 11):
     __all__ = (
@@ -48,134 +60,46 @@ else:
         "pbkdf2_hmac",
     )
 
-class _Hash:
-    @property
-    def digest_size(self) -> int: ...
-    @property
-    def block_size(self) -> int: ...
-    @property
-    def name(self) -> str: ...
-    def __init__(self, data: ReadableBuffer = ...) -> None: ...
-    def copy(self) -> Self: ...
-    def digest(self) -> bytes: ...
-    def hexdigest(self) -> str: ...
-    def update(self, __data: ReadableBuffer) -> None: ...
-
 if sys.version_info >= (3, 9):
-    def new(name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...) -> _Hash: ...
-    def md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
-    def sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
-    def sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
-    def sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
-    def sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
-    def sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
-
-elif sys.version_info >= (3, 8):
-    def new(name: str, data: ReadableBuffer = b"") -> _Hash: ...
-    def md5(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha1(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha224(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha256(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha384(string: ReadableBuffer = b"") -> _Hash: ...
-    def sha512(string: ReadableBuffer = b"") -> _Hash: ...
+    def new(name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...) -> HASH: ...
+    from _hashlib import (
+        openssl_sha3_224 as sha3_224,
+        openssl_sha3_256 as sha3_256,
+        openssl_sha3_384 as sha3_384,
+        openssl_sha3_512 as sha3_512,
+        openssl_shake_128 as shake_128,
+        openssl_shake_256 as shake_256,
+    )
 
 else:
-    def new(name: str, data: ReadableBuffer = b"") -> _Hash: ...
-    def md5(__string: ReadableBuffer = ...) -> _Hash: ...
-    def sha1(__string: ReadableBuffer = ...) -> _Hash: ...
-    def sha224(__string: ReadableBuffer = ...) -> _Hash: ...
-    def sha256(__string: ReadableBuffer = ...) -> _Hash: ...
-    def sha384(__string: ReadableBuffer = ...) -> _Hash: ...
-    def sha512(__string: ReadableBuffer = ...) -> _Hash: ...
+    @type_check_only
+    class _VarLenHash(HASH):
+        def digest(self, length: int) -> bytes: ...  # type: ignore[override]
+        def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
+
+    def new(name: str, data: ReadableBuffer = b"") -> HASH: ...
+    # At runtime these aren't functions but classes imported from _sha3
+    def sha3_224(string: ReadableBuffer = b"") -> HASH: ...
+    def sha3_256(string: ReadableBuffer = b"") -> HASH: ...
+    def sha3_384(string: ReadableBuffer = b"") -> HASH: ...
+    def sha3_512(string: ReadableBuffer = b"") -> HASH: ...
+    def shake_128(string: ReadableBuffer = b"") -> _VarLenHash: ...
+    def shake_256(string: ReadableBuffer = b"") -> _VarLenHash: ...
 
 algorithms_guaranteed: AbstractSet[str]
 algorithms_available: AbstractSet[str]
 
-def pbkdf2_hmac(
-    hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: int | None = None
-) -> bytes: ...
-
-class _VarLenHash:
-    digest_size: int
-    block_size: int
-    name: str
-    def __init__(self, data: ReadableBuffer = ...) -> None: ...
-    def copy(self) -> _VarLenHash: ...
-    def digest(self, __length: int) -> bytes: ...
-    def hexdigest(self, __length: int) -> str: ...
-    def update(self, __data: ReadableBuffer) -> None: ...
-
-sha3_224 = _Hash
-sha3_256 = _Hash
-sha3_384 = _Hash
-sha3_512 = _Hash
-shake_128 = _VarLenHash
-shake_256 = _VarLenHash
-
-def scrypt(
-    password: ReadableBuffer,
-    *,
-    salt: ReadableBuffer | None = None,
-    n: int | None = None,
-    r: int | None = None,
-    p: int | None = None,
-    maxmem: int = 0,
-    dklen: int = 64,
-) -> bytes: ...
-@final
-class _BlakeHash(_Hash):
-    MAX_DIGEST_SIZE: int
-    MAX_KEY_SIZE: int
-    PERSON_SIZE: int
-    SALT_SIZE: int
-
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self,
-            __data: ReadableBuffer = ...,
-            *,
-            digest_size: int = ...,
-            key: ReadableBuffer = ...,
-            salt: ReadableBuffer = ...,
-            person: ReadableBuffer = ...,
-            fanout: int = ...,
-            depth: int = ...,
-            leaf_size: int = ...,
-            node_offset: int = ...,
-            node_depth: int = ...,
-            inner_size: int = ...,
-            last_node: bool = ...,
-            usedforsecurity: bool = ...,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            __data: ReadableBuffer = ...,
-            *,
-            digest_size: int = ...,
-            key: ReadableBuffer = ...,
-            salt: ReadableBuffer = ...,
-            person: ReadableBuffer = ...,
-            fanout: int = ...,
-            depth: int = ...,
-            leaf_size: int = ...,
-            node_offset: int = ...,
-            node_depth: int = ...,
-            inner_size: int = ...,
-            last_node: bool = ...,
-        ) -> None: ...
-
-blake2b = _BlakeHash
-blake2s = _BlakeHash
-
 if sys.version_info >= (3, 11):
     class _BytesIOLike(Protocol):
         def getbuffer(self) -> ReadableBuffer: ...
 
     class _FileDigestFileObj(Protocol):
-        def readinto(self, __buf: bytearray) -> int: ...
+        def readinto(self, buf: bytearray, /) -> int: ...
         def readable(self) -> bool: ...
 
     def file_digest(
-        __fileobj: _BytesIOLike | _FileDigestFileObj, __digest: str | Callable[[], _Hash], *, _bufsize: int = 262144
-    ) -> _Hash: ...
+        fileobj: _BytesIOLike | _FileDigestFileObj, digest: str | Callable[[], _HashObject], /, *, _bufsize: int = 262144
+    ) -> HASH: ...
+
+# Legacy typing-only alias
+_Hash = HASH
diff --git a/mypy/typeshed/stdlib/heapq.pyi b/mypy/typeshed/stdlib/heapq.pyi
index 3f4f274b9769..220c41f303fb 100644
--- a/mypy/typeshed/stdlib/heapq.pyi
+++ b/mypy/typeshed/stdlib/heapq.pyi
@@ -1,8 +1,7 @@
 from _heapq import *
 from _typeshed import SupportsRichComparison
-from collections.abc import Callable, Iterable
-from typing import Any, TypeVar
-from typing_extensions import Final
+from collections.abc import Callable, Generator, Iterable
+from typing import Any, Final, TypeVar
 
 __all__ = ["heappush", "heappop", "heapify", "heapreplace", "merge", "nlargest", "nsmallest", "heappushpop"]
 
@@ -12,7 +11,7 @@ __about__: Final[str]
 
 def merge(
     *iterables: Iterable[_S], key: Callable[[_S], SupportsRichComparison] | None = None, reverse: bool = False
-) -> Iterable[_S]: ...
+) -> Generator[_S]: ...
 def nlargest(n: int, iterable: Iterable[_S], key: Callable[[_S], SupportsRichComparison] | None = None) -> list[_S]: ...
 def nsmallest(n: int, iterable: Iterable[_S], key: Callable[[_S], SupportsRichComparison] | None = None) -> list[_S]: ...
-def _heapify_max(__heap: list[Any]) -> None: ...  # undocumented
+def _heapify_max(heap: list[Any], /) -> None: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/hmac.pyi b/mypy/typeshed/stdlib/hmac.pyi
index 9ff99a5a05d5..dfb574c177cd 100644
--- a/mypy/typeshed/stdlib/hmac.pyi
+++ b/mypy/typeshed/stdlib/hmac.pyi
@@ -1,49 +1,42 @@
 import sys
+from _hashlib import _HashObject
 from _typeshed import ReadableBuffer, SizedBuffer
 from collections.abc import Callable
 from types import ModuleType
-from typing import Any, AnyStr, overload
+from typing import AnyStr, overload
 from typing_extensions import TypeAlias
 
-# TODO more precise type for object of hashlib
-_Hash: TypeAlias = Any
-_DigestMod: TypeAlias = str | Callable[[], _Hash] | ModuleType
+_DigestMod: TypeAlias = str | Callable[[], _HashObject] | ModuleType
 
 trans_5C: bytes
 trans_36: bytes
 
 digest_size: None
 
-if sys.version_info >= (3, 8):
-    # In reality digestmod has a default value, but the function always throws an error
-    # if the argument is not given, so we pretend it is a required argument.
-    @overload
-    def new(key: bytes | bytearray, msg: ReadableBuffer | None, digestmod: _DigestMod) -> HMAC: ...
-    @overload
-    def new(key: bytes | bytearray, *, digestmod: _DigestMod) -> HMAC: ...
-
-else:
-    def new(key: bytes | bytearray, msg: ReadableBuffer | None = None, digestmod: _DigestMod | None = None) -> HMAC: ...
+# In reality digestmod has a default value, but the function always throws an error
+# if the argument is not given, so we pretend it is a required argument.
+@overload
+def new(key: bytes | bytearray, msg: ReadableBuffer | None, digestmod: _DigestMod) -> HMAC: ...
+@overload
+def new(key: bytes | bytearray, *, digestmod: _DigestMod) -> HMAC: ...
 
 class HMAC:
     digest_size: int
     block_size: int
     @property
     def name(self) -> str: ...
-    if sys.version_info >= (3, 8):
-        def __init__(self, key: bytes | bytearray, msg: ReadableBuffer | None = None, digestmod: _DigestMod = "") -> None: ...
-    else:
-        def __init__(
-            self, key: bytes | bytearray, msg: ReadableBuffer | None = None, digestmod: _DigestMod | None = None
-        ) -> None: ...
-
+    def __init__(self, key: bytes | bytearray, msg: ReadableBuffer | None = None, digestmod: _DigestMod = "") -> None: ...
     def update(self, msg: ReadableBuffer) -> None: ...
     def digest(self) -> bytes: ...
     def hexdigest(self) -> str: ...
     def copy(self) -> HMAC: ...
 
-@overload
-def compare_digest(__a: ReadableBuffer, __b: ReadableBuffer) -> bool: ...
-@overload
-def compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ...
 def digest(key: SizedBuffer, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
+
+if sys.version_info >= (3, 9):
+    from _hashlib import compare_digest as compare_digest
+else:
+    @overload
+    def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
+    @overload
+    def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
diff --git a/mypy/typeshed/stdlib/http/__init__.pyi b/mypy/typeshed/stdlib/http/__init__.pyi
index d4b44f2eb99b..ef413a349125 100644
--- a/mypy/typeshed/stdlib/http/__init__.pyi
+++ b/mypy/typeshed/stdlib/http/__init__.pyi
@@ -1,6 +1,5 @@
 import sys
 from enum import IntEnum
-from typing_extensions import Literal
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -15,81 +14,108 @@ class HTTPStatus(IntEnum):
     def phrase(self) -> str: ...
     @property
     def description(self) -> str: ...
-    CONTINUE: int
-    SWITCHING_PROTOCOLS: int
-    PROCESSING: int
-    OK: int
-    CREATED: int
-    ACCEPTED: int
-    NON_AUTHORITATIVE_INFORMATION: int
-    NO_CONTENT: int
-    RESET_CONTENT: int
-    PARTIAL_CONTENT: int
-    MULTI_STATUS: int
-    ALREADY_REPORTED: int
-    IM_USED: int
-    MULTIPLE_CHOICES: int
-    MOVED_PERMANENTLY: int
-    FOUND: int
-    SEE_OTHER: int
-    NOT_MODIFIED: int
-    USE_PROXY: int
-    TEMPORARY_REDIRECT: int
-    PERMANENT_REDIRECT: int
-    BAD_REQUEST: int
-    UNAUTHORIZED: int
-    PAYMENT_REQUIRED: int
-    FORBIDDEN: int
-    NOT_FOUND: int
-    METHOD_NOT_ALLOWED: int
-    NOT_ACCEPTABLE: int
-    PROXY_AUTHENTICATION_REQUIRED: int
-    REQUEST_TIMEOUT: int
-    CONFLICT: int
-    GONE: int
-    LENGTH_REQUIRED: int
-    PRECONDITION_FAILED: int
-    REQUEST_ENTITY_TOO_LARGE: int
-    REQUEST_URI_TOO_LONG: int
-    UNSUPPORTED_MEDIA_TYPE: int
-    REQUESTED_RANGE_NOT_SATISFIABLE: int
-    EXPECTATION_FAILED: int
-    UNPROCESSABLE_ENTITY: int
-    LOCKED: int
-    FAILED_DEPENDENCY: int
-    UPGRADE_REQUIRED: int
-    PRECONDITION_REQUIRED: int
-    TOO_MANY_REQUESTS: int
-    REQUEST_HEADER_FIELDS_TOO_LARGE: int
-    INTERNAL_SERVER_ERROR: int
-    NOT_IMPLEMENTED: int
-    BAD_GATEWAY: int
-    SERVICE_UNAVAILABLE: int
-    GATEWAY_TIMEOUT: int
-    HTTP_VERSION_NOT_SUPPORTED: int
-    VARIANT_ALSO_NEGOTIATES: int
-    INSUFFICIENT_STORAGE: int
-    LOOP_DETECTED: int
-    NOT_EXTENDED: int
-    NETWORK_AUTHENTICATION_REQUIRED: int
-    MISDIRECTED_REQUEST: int
-    if sys.version_info >= (3, 8):
-        UNAVAILABLE_FOR_LEGAL_REASONS: int
+
+    # Keep these synced with the global constants in http/client.pyi.
+    CONTINUE = 100
+    SWITCHING_PROTOCOLS = 101
+    PROCESSING = 102
     if sys.version_info >= (3, 9):
-        EARLY_HINTS: Literal[103]
-        IM_A_TEAPOT: Literal[418]
-        TOO_EARLY: Literal[425]
+        EARLY_HINTS = 103
+
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NON_AUTHORITATIVE_INFORMATION = 203
+    NO_CONTENT = 204
+    RESET_CONTENT = 205
+    PARTIAL_CONTENT = 206
+    MULTI_STATUS = 207
+    ALREADY_REPORTED = 208
+    IM_USED = 226
+
+    MULTIPLE_CHOICES = 300
+    MOVED_PERMANENTLY = 301
+    FOUND = 302
+    SEE_OTHER = 303
+    NOT_MODIFIED = 304
+    USE_PROXY = 305
+    TEMPORARY_REDIRECT = 307
+    PERMANENT_REDIRECT = 308
+
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    PAYMENT_REQUIRED = 402
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    CONFLICT = 409
+    GONE = 410
+    LENGTH_REQUIRED = 411
+    PRECONDITION_FAILED = 412
+    if sys.version_info >= (3, 13):
+        CONTENT_TOO_LARGE = 413
+    REQUEST_ENTITY_TOO_LARGE = 413
+    if sys.version_info >= (3, 13):
+        URI_TOO_LONG = 414
+    REQUEST_URI_TOO_LONG = 414
+    UNSUPPORTED_MEDIA_TYPE = 415
+    if sys.version_info >= (3, 13):
+        RANGE_NOT_SATISFIABLE = 416
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416
+    EXPECTATION_FAILED = 417
+    if sys.version_info >= (3, 9):
+        IM_A_TEAPOT = 418
+    MISDIRECTED_REQUEST = 421
+    if sys.version_info >= (3, 13):
+        UNPROCESSABLE_CONTENT = 422
+    UNPROCESSABLE_ENTITY = 422
+    LOCKED = 423
+    FAILED_DEPENDENCY = 424
+    if sys.version_info >= (3, 9):
+        TOO_EARLY = 425
+    UPGRADE_REQUIRED = 426
+    PRECONDITION_REQUIRED = 428
+    TOO_MANY_REQUESTS = 429
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451
+
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    VARIANT_ALSO_NEGOTIATES = 506
+    INSUFFICIENT_STORAGE = 507
+    LOOP_DETECTED = 508
+    NOT_EXTENDED = 510
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+
+    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):
         @property
         def description(self) -> str: ...
-        CONNECT: str
-        DELETE: str
-        GET: str
-        HEAD: str
-        OPTIONS: str
-        PATCH: str
-        POST: str
-        PUT: str
-        TRACE: str
+        CONNECT = "CONNECT"
+        DELETE = "DELETE"
+        GET = "GET"
+        HEAD = "HEAD"
+        OPTIONS = "OPTIONS"
+        PATCH = "PATCH"
+        POST = "POST"
+        PUT = "PUT"
+        TRACE = "TRACE"
diff --git a/mypy/typeshed/stdlib/http/client.pyi b/mypy/typeshed/stdlib/http/client.pyi
index 9c7c0c1c4a12..cd2fc4f5a652 100644
--- a/mypy/typeshed/stdlib/http/client.pyi
+++ b/mypy/typeshed/stdlib/http/client.pyi
@@ -1,11 +1,12 @@
 import email.message
 import io
 import ssl
+import sys
 import types
-from _typeshed import ReadableBuffer, SupportsRead, WriteableBuffer
+from _typeshed import MaybeNone, ReadableBuffer, SupportsRead, SupportsReadline, WriteableBuffer
 from collections.abc import Callable, Iterable, Iterator, Mapping
 from socket import socket
-from typing import Any, BinaryIO, TypeVar, overload
+from typing import BinaryIO, Literal, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
 __all__ = [
@@ -32,74 +33,101 @@ __all__ = [
 
 _DataType: TypeAlias = SupportsRead[bytes] | Iterable[ReadableBuffer] | ReadableBuffer
 _T = TypeVar("_T")
+_MessageT = TypeVar("_MessageT", bound=email.message.Message)
+_HeaderValue: TypeAlias = ReadableBuffer | str | int
 
 HTTP_PORT: int
 HTTPS_PORT: int
 
-CONTINUE: int
-SWITCHING_PROTOCOLS: int
-PROCESSING: int
-
-OK: int
-CREATED: int
-ACCEPTED: int
-NON_AUTHORITATIVE_INFORMATION: int
-NO_CONTENT: int
-RESET_CONTENT: int
-PARTIAL_CONTENT: int
-MULTI_STATUS: int
-IM_USED: int
-
-MULTIPLE_CHOICES: int
-MOVED_PERMANENTLY: int
-FOUND: int
-SEE_OTHER: int
-NOT_MODIFIED: int
-USE_PROXY: int
-TEMPORARY_REDIRECT: int
-
-BAD_REQUEST: int
-UNAUTHORIZED: int
-PAYMENT_REQUIRED: int
-FORBIDDEN: int
-NOT_FOUND: int
-METHOD_NOT_ALLOWED: int
-NOT_ACCEPTABLE: int
-PROXY_AUTHENTICATION_REQUIRED: int
-REQUEST_TIMEOUT: int
-CONFLICT: int
-GONE: int
-LENGTH_REQUIRED: int
-PRECONDITION_FAILED: int
-REQUEST_ENTITY_TOO_LARGE: int
-REQUEST_URI_TOO_LONG: int
-UNSUPPORTED_MEDIA_TYPE: int
-REQUESTED_RANGE_NOT_SATISFIABLE: int
-EXPECTATION_FAILED: int
-UNPROCESSABLE_ENTITY: int
-LOCKED: int
-FAILED_DEPENDENCY: int
-UPGRADE_REQUIRED: int
-PRECONDITION_REQUIRED: int
-TOO_MANY_REQUESTS: int
-REQUEST_HEADER_FIELDS_TOO_LARGE: int
-
-INTERNAL_SERVER_ERROR: int
-NOT_IMPLEMENTED: int
-BAD_GATEWAY: int
-SERVICE_UNAVAILABLE: int
-GATEWAY_TIMEOUT: int
-HTTP_VERSION_NOT_SUPPORTED: int
-INSUFFICIENT_STORAGE: int
-NOT_EXTENDED: int
-NETWORK_AUTHENTICATION_REQUIRED: int
+# Keep these global constants in sync with http.HTTPStatus (http/__init__.pyi).
+# They are present for backward compatibility reasons.
+CONTINUE: Literal[100]
+SWITCHING_PROTOCOLS: Literal[101]
+PROCESSING: Literal[102]
+if sys.version_info >= (3, 9):
+    EARLY_HINTS: Literal[103]
+
+OK: Literal[200]
+CREATED: Literal[201]
+ACCEPTED: Literal[202]
+NON_AUTHORITATIVE_INFORMATION: Literal[203]
+NO_CONTENT: Literal[204]
+RESET_CONTENT: Literal[205]
+PARTIAL_CONTENT: Literal[206]
+MULTI_STATUS: Literal[207]
+ALREADY_REPORTED: Literal[208]
+IM_USED: Literal[226]
+
+MULTIPLE_CHOICES: Literal[300]
+MOVED_PERMANENTLY: Literal[301]
+FOUND: Literal[302]
+SEE_OTHER: Literal[303]
+NOT_MODIFIED: Literal[304]
+USE_PROXY: Literal[305]
+TEMPORARY_REDIRECT: Literal[307]
+PERMANENT_REDIRECT: Literal[308]
+
+BAD_REQUEST: Literal[400]
+UNAUTHORIZED: Literal[401]
+PAYMENT_REQUIRED: Literal[402]
+FORBIDDEN: Literal[403]
+NOT_FOUND: Literal[404]
+METHOD_NOT_ALLOWED: Literal[405]
+NOT_ACCEPTABLE: Literal[406]
+PROXY_AUTHENTICATION_REQUIRED: Literal[407]
+REQUEST_TIMEOUT: Literal[408]
+CONFLICT: Literal[409]
+GONE: Literal[410]
+LENGTH_REQUIRED: Literal[411]
+PRECONDITION_FAILED: Literal[412]
+if sys.version_info >= (3, 13):
+    CONTENT_TOO_LARGE: Literal[413]
+REQUEST_ENTITY_TOO_LARGE: Literal[413]
+if sys.version_info >= (3, 13):
+    URI_TOO_LONG: Literal[414]
+REQUEST_URI_TOO_LONG: Literal[414]
+UNSUPPORTED_MEDIA_TYPE: Literal[415]
+if sys.version_info >= (3, 13):
+    RANGE_NOT_SATISFIABLE: Literal[416]
+REQUESTED_RANGE_NOT_SATISFIABLE: Literal[416]
+EXPECTATION_FAILED: Literal[417]
+if sys.version_info >= (3, 9):
+    IM_A_TEAPOT: Literal[418]
+MISDIRECTED_REQUEST: Literal[421]
+if sys.version_info >= (3, 13):
+    UNPROCESSABLE_CONTENT: Literal[422]
+UNPROCESSABLE_ENTITY: Literal[422]
+LOCKED: Literal[423]
+FAILED_DEPENDENCY: Literal[424]
+if sys.version_info >= (3, 9):
+    TOO_EARLY: Literal[425]
+UPGRADE_REQUIRED: Literal[426]
+PRECONDITION_REQUIRED: Literal[428]
+TOO_MANY_REQUESTS: Literal[429]
+REQUEST_HEADER_FIELDS_TOO_LARGE: Literal[431]
+UNAVAILABLE_FOR_LEGAL_REASONS: Literal[451]
+
+INTERNAL_SERVER_ERROR: Literal[500]
+NOT_IMPLEMENTED: Literal[501]
+BAD_GATEWAY: Literal[502]
+SERVICE_UNAVAILABLE: Literal[503]
+GATEWAY_TIMEOUT: Literal[504]
+HTTP_VERSION_NOT_SUPPORTED: Literal[505]
+VARIANT_ALSO_NEGOTIATES: Literal[506]
+INSUFFICIENT_STORAGE: Literal[507]
+LOOP_DETECTED: Literal[508]
+NOT_EXTENDED: Literal[510]
+NETWORK_AUTHENTICATION_REQUIRED: Literal[511]
 
 responses: dict[int, str]
 
-class HTTPMessage(email.message.Message):
+class HTTPMessage(email.message.Message[str, str]):
     def getallmatchingheaders(self, name: str) -> list[str]: ...  # undocumented
 
-def parse_headers(fp: io.BufferedIOBase, _class: Callable[[], email.message.Message] = ...) -> HTTPMessage: ...
+@overload
+def parse_headers(fp: SupportsReadline[bytes], _class: Callable[[], _MessageT]) -> _MessageT: ...
+@overload
+def parse_headers(fp: SupportsReadline[bytes]) -> HTTPMessage: ...
 
 class HTTPResponse(io.BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible method definitions in the base classes
     msg: HTTPMessage
@@ -114,6 +142,10 @@ class HTTPResponse(io.BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incomp
     chunk_left: int | None
     length: int | None
     will_close: bool
+    # url is set on instances of the class in urllib.request.AbstractHTTPHandler.do_open
+    # to match urllib.response.addinfourl's interface.
+    # It's not set in HTTPResponse.__init__ or any other method on the class
+    url: str
     def __init__(self, sock: socket, debuglevel: int = 0, method: str | None = None, url: str | None = None) -> None: ...
     def peek(self, n: int = -1) -> bytes: ...
     def read(self, amt: int | None = None) -> bytes: ...
@@ -144,7 +176,7 @@ class HTTPConnection:
     timeout: float | None
     host: str
     port: int
-    sock: socket | Any  # can be `None` if `.connect()` was not called
+    sock: socket | MaybeNone  # can be `None` if `.connect()` was not called
     def __init__(
         self,
         host: str,
@@ -158,36 +190,51 @@ class HTTPConnection:
         method: str,
         url: str,
         body: _DataType | str | None = None,
-        headers: Mapping[str, str] = {},
+        headers: Mapping[str, _HeaderValue] = {},
         *,
         encode_chunked: bool = False,
     ) -> None: ...
     def getresponse(self) -> HTTPResponse: ...
     def set_debuglevel(self, level: int) -> None: ...
+    if sys.version_info >= (3, 12):
+        def get_proxy_response_headers(self) -> HTTPMessage | None: ...
+
     def set_tunnel(self, host: str, port: int | None = None, headers: Mapping[str, str] | None = None) -> None: ...
     def connect(self) -> None: ...
     def close(self) -> None: ...
     def putrequest(self, method: str, url: str, skip_host: bool = False, skip_accept_encoding: bool = False) -> None: ...
-    def putheader(self, header: str, *argument: str) -> None: ...
+    def putheader(self, header: str | bytes, *values: _HeaderValue) -> None: ...
     def endheaders(self, message_body: _DataType | None = None, *, encode_chunked: bool = False) -> None: ...
     def send(self, data: _DataType | str) -> None: ...
 
 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: ...
+    sock: ssl.SSLSocket | MaybeNone
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            host: str,
+            port: int | 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/http/cookiejar.pyi b/mypy/typeshed/stdlib/http/cookiejar.pyi
index 482cbca1d88a..31e1d3fc8378 100644
--- a/mypy/typeshed/stdlib/http/cookiejar.pyi
+++ b/mypy/typeshed/stdlib/http/cookiejar.pyi
@@ -1,6 +1,6 @@
 import sys
 from _typeshed import StrPath
-from collections.abc import Iterable, Iterator, Sequence
+from collections.abc import Iterator, Sequence
 from http.client import HTTPResponse
 from re import Pattern
 from typing import ClassVar, TypeVar, overload
@@ -21,7 +21,7 @@ _T = TypeVar("_T")
 
 class LoadError(OSError): ...
 
-class CookieJar(Iterable[Cookie]):
+class CookieJar:
     non_word_re: ClassVar[Pattern[str]]  # undocumented
     quote_re: ClassVar[Pattern[str]]  # undocumented
     strict_domain_re: ClassVar[Pattern[str]]  # undocumented
@@ -42,15 +42,9 @@ class CookieJar(Iterable[Cookie]):
     def __len__(self) -> int: ...
 
 class FileCookieJar(CookieJar):
-    filename: str
+    filename: str | None
     delayload: bool
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self, filename: StrPath | None = None, delayload: bool = False, policy: CookiePolicy | None = None
-        ) -> None: ...
-    else:
-        def __init__(self, filename: str | None = None, delayload: bool = False, policy: CookiePolicy | None = None) -> None: ...
-
+    def __init__(self, filename: StrPath | None = None, delayload: bool = False, policy: CookiePolicy | None = None) -> None: ...
     def save(self, filename: str | None = None, ignore_discard: bool = False, ignore_expires: bool = False) -> None: ...
     def load(self, filename: str | None = None, ignore_discard: bool = False, ignore_expires: bool = False) -> None: ...
     def revert(self, filename: str | None = None, ignore_discard: bool = False, ignore_expires: bool = False) -> None: ...
@@ -84,40 +78,22 @@ class DefaultCookiePolicy(CookiePolicy):
     DomainRFC2965Match: ClassVar[int]
     DomainLiberal: ClassVar[int]
     DomainStrict: ClassVar[int]
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            blocked_domains: Sequence[str] | None = None,
-            allowed_domains: Sequence[str] | None = None,
-            netscape: bool = True,
-            rfc2965: bool = False,
-            rfc2109_as_netscape: bool | None = None,
-            hide_cookie2: bool = False,
-            strict_domain: bool = False,
-            strict_rfc2965_unverifiable: bool = True,
-            strict_ns_unverifiable: bool = False,
-            strict_ns_domain: int = 0,
-            strict_ns_set_initial_dollar: bool = False,
-            strict_ns_set_path: bool = False,
-            secure_protocols: Sequence[str] = ("https", "wss"),
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            blocked_domains: Sequence[str] | None = None,
-            allowed_domains: Sequence[str] | None = None,
-            netscape: bool = True,
-            rfc2965: bool = False,
-            rfc2109_as_netscape: bool | None = None,
-            hide_cookie2: bool = False,
-            strict_domain: bool = False,
-            strict_rfc2965_unverifiable: bool = True,
-            strict_ns_unverifiable: bool = False,
-            strict_ns_domain: int = 0,
-            strict_ns_set_initial_dollar: bool = False,
-            strict_ns_set_path: bool = False,
-        ) -> None: ...
-
+    def __init__(
+        self,
+        blocked_domains: Sequence[str] | None = None,
+        allowed_domains: Sequence[str] | None = None,
+        netscape: bool = True,
+        rfc2965: bool = False,
+        rfc2109_as_netscape: bool | None = None,
+        hide_cookie2: bool = False,
+        strict_domain: bool = False,
+        strict_rfc2965_unverifiable: bool = True,
+        strict_ns_unverifiable: bool = False,
+        strict_ns_domain: int = 0,
+        strict_ns_set_initial_dollar: bool = False,
+        strict_ns_set_path: bool = False,
+        secure_protocols: Sequence[str] = ("https", "wss"),
+    ) -> None: ...
     def blocked_domains(self) -> tuple[str, ...]: ...
     def set_blocked_domains(self, blocked_domains: Sequence[str]) -> None: ...
     def is_blocked(self, domain: str) -> bool: ...
diff --git a/mypy/typeshed/stdlib/http/cookies.pyi b/mypy/typeshed/stdlib/http/cookies.pyi
index e24ef9cbdd2e..c4af5256b5d8 100644
--- a/mypy/typeshed/stdlib/http/cookies.pyi
+++ b/mypy/typeshed/stdlib/http/cookies.pyi
@@ -45,16 +45,16 @@ class Morsel(dict[str, Any], Generic[_T]):
     def __eq__(self, morsel: object) -> bool: ...
     def __setitem__(self, K: str, V: Any) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class BaseCookie(dict[str, Morsel[_T]], Generic[_T]):
     def __init__(self, input: _DataType | None = None) -> None: ...
-    def value_decode(self, val: str) -> _T: ...
-    def value_encode(self, val: _T) -> str: ...
+    def value_decode(self, val: str) -> tuple[_T, str]: ...
+    def value_encode(self, val: _T) -> tuple[_T, str]: ...
     def output(self, attrs: list[str] | None = None, header: str = "Set-Cookie:", sep: str = "\r\n") -> str: ...
     __str__ = output
     def js_output(self, attrs: list[str] | None = None) -> str: ...
     def load(self, rawdata: _DataType) -> None: ...
     def __setitem__(self, key: str, value: str | Morsel[_T]) -> None: ...
 
-class SimpleCookie(BaseCookie[_T], Generic[_T]): ...
+class SimpleCookie(BaseCookie[str]): ...
diff --git a/mypy/typeshed/stdlib/http/server.pyi b/mypy/typeshed/stdlib/http/server.pyi
index c9700f70e791..1a6fde6000d9 100644
--- a/mypy/typeshed/stdlib/http/server.pyi
+++ b/mypy/typeshed/stdlib/http/server.pyi
@@ -6,6 +6,7 @@ import sys
 from _typeshed import StrPath, SupportsRead, SupportsWrite
 from collections.abc import Mapping, Sequence
 from typing import Any, AnyStr, BinaryIO, ClassVar
+from typing_extensions import deprecated
 
 __all__ = ["HTTPServer", "ThreadingHTTPServer", "BaseHTTPRequestHandler", "SimpleHTTPRequestHandler", "CGIHTTPRequestHandler"]
 
@@ -45,7 +46,7 @@ class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
     def log_error(self, format: str, *args: Any) -> None: ...
     def log_message(self, format: str, *args: Any) -> None: ...
     def version_string(self) -> str: ...
-    def date_time_string(self, timestamp: int | None = None) -> str: ...
+    def date_time_string(self, timestamp: float | None = None) -> str: ...
     def log_date_time_string(self) -> str: ...
     def address_string(self) -> str: ...
     def parse_request(self) -> bool: ...  # undocumented
@@ -54,13 +55,14 @@ class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     extensions_map: dict[str, str]
     if sys.version_info >= (3, 12):
         index_pages: ClassVar[tuple[str, ...]]
+    directory: str
     def __init__(
         self,
         request: socketserver._RequestType,
         client_address: _socket._RetAddress,
         server: socketserver.BaseServer,
         *,
-        directory: str | None = None,
+        directory: StrPath | None = None,
     ) -> None: ...
     def do_GET(self) -> None: ...
     def do_HEAD(self) -> None: ...
@@ -71,7 +73,7 @@ class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     def guess_type(self, path: StrPath) -> str: ...  # undocumented
 
 def executable(path: StrPath) -> bool: ...  # undocumented
-
+@deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
 class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
     cgi_directories: list[str]
     have_fork: bool  # undocumented
diff --git a/mypy/typeshed/stdlib/imaplib.pyi b/mypy/typeshed/stdlib/imaplib.pyi
index 7781559c3888..6a4d8b2e720a 100644
--- a/mypy/typeshed/stdlib/imaplib.pyi
+++ b/mypy/typeshed/stdlib/imaplib.pyi
@@ -9,8 +9,8 @@ from re import Pattern
 from socket import socket as _socket
 from ssl import SSLContext, SSLSocket
 from types import TracebackType
-from typing import IO, Any, SupportsAbs, SupportsInt
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, Literal, SupportsAbs, SupportsInt
+from typing_extensions import Self, TypeAlias
 
 __all__ = ["IMAP4", "IMAP4_stream", "Internaldate2tuple", "Int2AP", "ParseFlags", "Time2Internaldate", "IMAP4_SSL"]
 
@@ -108,9 +108,14 @@ class IMAP4:
     def print_log(self) -> None: ...
 
 class IMAP4_SSL(IMAP4):
-    keyfile: str
-    certfile: str
-    if sys.version_info >= (3, 9):
+    if sys.version_info < (3, 12):
+        keyfile: str
+        certfile: str
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self, host: str = "", port: int = 993, *, ssl_context: SSLContext | None = None, timeout: float | None = None
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
         def __init__(
             self,
             host: str = "",
diff --git a/mypy/typeshed/stdlib/imghdr.pyi b/mypy/typeshed/stdlib/imghdr.pyi
index ed3647f20fc5..6e1b858b8f32 100644
--- a/mypy/typeshed/stdlib/imghdr.pyi
+++ b/mypy/typeshed/stdlib/imghdr.pyi
@@ -6,8 +6,8 @@ __all__ = ["what"]
 
 class _ReadableBinary(Protocol):
     def tell(self) -> int: ...
-    def read(self, size: int) -> bytes: ...
-    def seek(self, offset: int) -> Any: ...
+    def read(self, size: int, /) -> bytes: ...
+    def seek(self, offset: int, /) -> Any: ...
 
 @overload
 def what(file: StrPath | _ReadableBinary, h: None = None) -> str | None: ...
diff --git a/mypy/typeshed/stdlib/imp.pyi b/mypy/typeshed/stdlib/imp.pyi
index 3f2920de9c2b..ee5a0cd7bc72 100644
--- a/mypy/typeshed/stdlib/imp.pyi
+++ b/mypy/typeshed/stdlib/imp.pyi
@@ -45,7 +45,7 @@ class _FileLike(Protocol):
     def read(self) -> str | bytes: ...
     def close(self) -> Any: ...
     def __enter__(self) -> Any: ...
-    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> Any: ...
+    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, /) -> Any: ...
 
 # PathLike doesn't work for the pathname argument here
 def load_source(name: str, pathname: str, file: _FileLike | None = None) -> types.ModuleType: ...
diff --git a/mypy/typeshed/stdlib/importlib/__init__.pyi b/mypy/typeshed/stdlib/importlib/__init__.pyi
index 8d73319f8c3d..cab81512e92f 100644
--- a/mypy/typeshed/stdlib/importlib/__init__.pyi
+++ b/mypy/typeshed/stdlib/importlib/__init__.pyi
@@ -1,20 +1,15 @@
-from collections.abc import Mapping, Sequence
+import sys
+from importlib._bootstrap import __import__ as __import__
 from importlib.abc import Loader
 from types import ModuleType
 
 __all__ = ["__import__", "import_module", "invalidate_caches", "reload"]
 
-# Signature of `builtins.__import__` should be kept identical to `importlib.__import__`
-def __import__(
-    name: str,
-    globals: Mapping[str, object] | None = None,
-    locals: Mapping[str, object] | None = None,
-    fromlist: Sequence[str] = (),
-    level: int = 0,
-) -> ModuleType: ...
-
 # `importlib.import_module` return type should be kept the same as `builtins.__import__`
 def import_module(name: str, package: str | None = None) -> ModuleType: ...
-def find_loader(name: str, path: str | None = None) -> Loader | None: ...
+
+if sys.version_info < (3, 12):
+    def find_loader(name: str, path: str | None = None) -> Loader | None: ...
+
 def invalidate_caches() -> None: ...
 def reload(module: ModuleType) -> ModuleType: ...
diff --git a/mypy/typeshed/stdlib/importlib/_abc.pyi b/mypy/typeshed/stdlib/importlib/_abc.pyi
new file mode 100644
index 000000000000..1a21b9a72cd8
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/_abc.pyi
@@ -0,0 +1,15 @@
+import sys
+import types
+from abc import ABCMeta
+from importlib.machinery import ModuleSpec
+
+if sys.version_info >= (3, 10):
+    class Loader(metaclass=ABCMeta):
+        def load_module(self, fullname: str) -> types.ModuleType: ...
+        if sys.version_info < (3, 12):
+            def module_repr(self, module: types.ModuleType) -> str: ...
+
+        def create_module(self, spec: ModuleSpec) -> types.ModuleType | None: ...
+        # Not defined on the actual class for backwards-compatibility reasons,
+        # but expected in new code.
+        def exec_module(self, module: types.ModuleType) -> None: ...
diff --git a/mypy/typeshed/stdlib/importlib/_bootstrap.pyi b/mypy/typeshed/stdlib/importlib/_bootstrap.pyi
new file mode 100644
index 000000000000..02427ff42062
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/_bootstrap.pyi
@@ -0,0 +1,2 @@
+from _frozen_importlib import *
+from _frozen_importlib import __import__ as __import__, _init_module_attrs as _init_module_attrs
diff --git a/mypy/typeshed/stdlib/importlib/_bootstrap_external.pyi b/mypy/typeshed/stdlib/importlib/_bootstrap_external.pyi
new file mode 100644
index 000000000000..6210ce7083af
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/_bootstrap_external.pyi
@@ -0,0 +1,2 @@
+from _frozen_importlib_external import *
+from _frozen_importlib_external import _NamespaceLoader as _NamespaceLoader
diff --git a/mypy/typeshed/stdlib/importlib/abc.pyi b/mypy/typeshed/stdlib/importlib/abc.pyi
index 4bf46104ba6d..588377d7d871 100644
--- a/mypy/typeshed/stdlib/importlib/abc.pyi
+++ b/mypy/typeshed/stdlib/importlib/abc.pyi
@@ -1,26 +1,17 @@
 import _ast
 import sys
 import types
-from _typeshed import (
-    OpenBinaryMode,
-    OpenBinaryModeReading,
-    OpenBinaryModeUpdating,
-    OpenBinaryModeWriting,
-    OpenTextMode,
-    ReadableBuffer,
-    StrPath,
-)
+from _typeshed import ReadableBuffer, StrPath
 from abc import ABCMeta, abstractmethod
 from collections.abc import Iterator, Mapping, Sequence
+from importlib import _bootstrap_external
 from importlib.machinery import ModuleSpec
-from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
-from typing import IO, Any, BinaryIO, NoReturn, Protocol, overload, runtime_checkable
-from typing_extensions import Literal
+from io import BufferedReader
+from typing import IO, Any, Literal, Protocol, overload, runtime_checkable
 
 if sys.version_info >= (3, 11):
     __all__ = [
         "Loader",
-        "Finder",
         "MetaPathFinder",
         "PathEntryFinder",
         "ResourceLoader",
@@ -28,20 +19,24 @@ if sys.version_info >= (3, 11):
         "ExecutionLoader",
         "FileLoader",
         "SourceLoader",
-        "ResourceReader",
-        "Traversable",
-        "TraversableResources",
     ]
 
-class Finder(metaclass=ABCMeta): ...
+    if sys.version_info < (3, 12):
+        __all__ += ["Finder", "ResourceReader", "Traversable", "TraversableResources"]
 
-class Loader(metaclass=ABCMeta):
-    def load_module(self, fullname: str) -> types.ModuleType: ...
-    def module_repr(self, module: types.ModuleType) -> str: ...
-    def create_module(self, spec: ModuleSpec) -> types.ModuleType | None: ...
-    # Not defined on the actual class for backwards-compatibility reasons,
-    # but expected in new code.
-    def exec_module(self, module: types.ModuleType) -> None: ...
+if sys.version_info >= (3, 10):
+    from importlib._abc import Loader as Loader
+else:
+    class Loader(metaclass=ABCMeta):
+        def load_module(self, fullname: str) -> types.ModuleType: ...
+        def module_repr(self, module: types.ModuleType) -> str: ...
+        def create_module(self, spec: ModuleSpec) -> types.ModuleType | None: ...
+        # Not defined on the actual class for backwards-compatibility reasons,
+        # but expected in new code.
+        def exec_module(self, module: types.ModuleType) -> None: ...
+
+if sys.version_info < (3, 12):
+    class Finder(metaclass=ABCMeta): ...
 
 class ResourceLoader(Loader):
     @abstractmethod
@@ -62,29 +57,52 @@ class ExecutionLoader(InspectLoader):
     @abstractmethod
     def get_filename(self, fullname: str) -> str: ...
 
-class SourceLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
+class SourceLoader(_bootstrap_external.SourceLoader, ResourceLoader, ExecutionLoader, metaclass=ABCMeta):  # type: ignore[misc]  # incompatible definitions of source_to_code in the base classes
     def path_mtime(self, path: str) -> float: ...
     def set_data(self, path: str, data: bytes) -> None: ...
     def get_source(self, fullname: str) -> str | None: ...
     def path_stats(self, path: str) -> Mapping[str, Any]: ...
 
-# Please keep in sync with sys._MetaPathFinder
-class MetaPathFinder(Finder):
-    def find_module(self, fullname: str, path: Sequence[str] | None) -> Loader | None: ...
-    def invalidate_caches(self) -> None: ...
-    # Not defined on the actual class, but expected to exist.
-    def find_spec(
-        self, fullname: str, path: Sequence[str] | None, target: types.ModuleType | None = ...
-    ) -> ModuleSpec | None: ...
-
-class PathEntryFinder(Finder):
-    def find_module(self, fullname: str) -> Loader | None: ...
-    def find_loader(self, fullname: str) -> tuple[Loader | None, Sequence[str]]: ...
-    def invalidate_caches(self) -> None: ...
-    # Not defined on the actual class, but expected to exist.
-    def find_spec(self, fullname: str, target: types.ModuleType | None = ...) -> ModuleSpec | None: ...
-
-class FileLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
+# The base classes differ starting in 3.10:
+if sys.version_info >= (3, 10):
+    # Please keep in sync with _typeshed.importlib.MetaPathFinderProtocol
+    class MetaPathFinder(metaclass=ABCMeta):
+        if sys.version_info < (3, 12):
+            def find_module(self, fullname: str, path: Sequence[str] | None) -> Loader | None: ...
+
+        def invalidate_caches(self) -> None: ...
+        # Not defined on the actual class, but expected to exist.
+        def find_spec(
+            self, fullname: str, path: Sequence[str] | None, target: types.ModuleType | None = ..., /
+        ) -> ModuleSpec | None: ...
+
+    class PathEntryFinder(metaclass=ABCMeta):
+        if sys.version_info < (3, 12):
+            def find_module(self, fullname: str) -> Loader | None: ...
+            def find_loader(self, fullname: str) -> tuple[Loader | None, Sequence[str]]: ...
+
+        def invalidate_caches(self) -> None: ...
+        # Not defined on the actual class, but expected to exist.
+        def find_spec(self, fullname: str, target: types.ModuleType | None = ...) -> ModuleSpec | None: ...
+
+else:
+    # Please keep in sync with _typeshed.importlib.MetaPathFinderProtocol
+    class MetaPathFinder(Finder):
+        def find_module(self, fullname: str, path: Sequence[str] | None) -> Loader | None: ...
+        def invalidate_caches(self) -> None: ...
+        # Not defined on the actual class, but expected to exist.
+        def find_spec(
+            self, fullname: str, path: Sequence[str] | None, target: types.ModuleType | None = ..., /
+        ) -> ModuleSpec | None: ...
+
+    class PathEntryFinder(Finder):
+        def find_module(self, fullname: str) -> Loader | None: ...
+        def find_loader(self, fullname: str) -> tuple[Loader | None, Sequence[str]]: ...
+        def invalidate_caches(self) -> None: ...
+        # Not defined on the actual class, but expected to exist.
+        def find_spec(self, fullname: str, target: types.ModuleType | None = ...) -> ModuleSpec | None: ...
+
+class FileLoader(_bootstrap_external.FileLoader, ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
     name: str
     path: str
     def __init__(self, fullname: str, path: str) -> None: ...
@@ -121,72 +139,26 @@ if sys.version_info >= (3, 9):
             def joinpath(self, *descendants: str) -> Traversable: ...
         else:
             @abstractmethod
-            def joinpath(self, child: str) -> Traversable: ...
-        # The .open method comes from pathlib.pyi and should be kept in sync.
-        @overload
-        @abstractmethod
-        def open(
-            self,
-            mode: OpenTextMode = "r",
-            buffering: int = ...,
-            encoding: str | None = ...,
-            errors: str | None = ...,
-            newline: str | None = ...,
-        ) -> TextIOWrapper: ...
-        # Unbuffered binary mode: returns a FileIO
-        @overload
-        @abstractmethod
-        def open(
-            self, mode: OpenBinaryMode, buffering: Literal[0], encoding: None = None, errors: None = None, newline: None = None
-        ) -> FileIO: ...
-        # Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter
-        @overload
-        @abstractmethod
-        def open(
-            self,
-            mode: OpenBinaryModeUpdating,
-            buffering: Literal[-1, 1] = ...,
-            encoding: None = None,
-            errors: None = None,
-            newline: None = None,
-        ) -> BufferedRandom: ...
-        @overload
-        @abstractmethod
-        def open(
-            self,
-            mode: OpenBinaryModeWriting,
-            buffering: Literal[-1, 1] = ...,
-            encoding: None = None,
-            errors: None = None,
-            newline: None = None,
-        ) -> BufferedWriter: ...
-        @overload
-        @abstractmethod
-        def open(
-            self,
-            mode: OpenBinaryModeReading,
-            buffering: Literal[-1, 1] = ...,
-            encoding: None = None,
-            errors: None = None,
-            newline: None = None,
-        ) -> BufferedReader: ...
-        # Buffering cannot be determined: fall back to BinaryIO
+            def joinpath(self, child: str, /) -> Traversable: ...
+
+        # The documentation and runtime protocol allows *args, **kwargs arguments,
+        # but this would mean that all implementers would have to support them,
+        # which is not the case.
         @overload
         @abstractmethod
-        def open(
-            self, mode: OpenBinaryMode, buffering: int = ..., encoding: None = None, errors: None = None, newline: None = None
-        ) -> BinaryIO: ...
-        # Fallback if mode is not specified
+        def open(self, mode: Literal["r"] = "r", *, encoding: str | None = None, errors: str | None = None) -> IO[str]: ...
         @overload
         @abstractmethod
-        def open(
-            self, mode: str, buffering: int = ..., encoding: str | None = ..., errors: str | None = ..., newline: str | None = ...
-        ) -> IO[Any]: ...
+        def open(self, mode: Literal["rb"]) -> IO[bytes]: ...
         @property
         @abstractmethod
         def name(self) -> str: ...
-        @abstractmethod
-        def __truediv__(self, child: str) -> Traversable: ...
+        if sys.version_info >= (3, 10):
+            def __truediv__(self, child: str, /) -> Traversable: ...
+        else:
+            @abstractmethod
+            def __truediv__(self, child: str, /) -> Traversable: ...
+
         @abstractmethod
         def read_bytes(self) -> bytes: ...
         @abstractmethod
@@ -196,6 +168,6 @@ if sys.version_info >= (3, 9):
         @abstractmethod
         def files(self) -> Traversable: ...
         def open_resource(self, resource: str) -> BufferedReader: ...
-        def resource_path(self, resource: Any) -> NoReturn: ...
+        def resource_path(self, resource: Any) -> str: ...
         def is_resource(self, path: str) -> bool: ...
         def contents(self) -> Iterator[str]: ...
diff --git a/mypy/typeshed/stdlib/importlib/machinery.pyi b/mypy/typeshed/stdlib/importlib/machinery.pyi
index 5aaefce87e3a..bb1a6f93d0e0 100644
--- a/mypy/typeshed/stdlib/importlib/machinery.pyi
+++ b/mypy/typeshed/stdlib/importlib/machinery.pyi
@@ -1,150 +1,20 @@
-import importlib.abc
 import sys
-import types
-from _typeshed import ReadableBuffer
-from collections.abc import Callable, Iterable, Sequence
-from typing import Any
-
-if sys.version_info >= (3, 8):
-    from importlib.metadata import DistributionFinder, PathDistribution
-
-class ModuleSpec:
-    def __init__(
-        self,
-        name: str,
-        loader: importlib.abc.Loader | None,
-        *,
-        origin: str | None = None,
-        loader_state: Any = None,
-        is_package: bool | None = None,
-    ) -> None: ...
-    name: str
-    loader: importlib.abc.Loader | None
-    origin: str | None
-    submodule_search_locations: list[str] | None
-    loader_state: Any
-    cached: str | None
-    @property
-    def parent(self) -> str | None: ...
-    has_location: bool
-    def __eq__(self, other: object) -> bool: ...
-
-class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
-    # MetaPathFinder
-    @classmethod
-    def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-    # InspectLoader
-    @classmethod
-    def is_package(cls, fullname: str) -> bool: ...
-    @classmethod
-    def load_module(cls, fullname: str) -> types.ModuleType: ...
-    @classmethod
-    def get_code(cls, fullname: str) -> None: ...
-    @classmethod
-    def get_source(cls, fullname: str) -> None: ...
-    # Loader
-    @staticmethod
-    def module_repr(module: types.ModuleType) -> str: ...
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
-        @staticmethod
-        def exec_module(module: types.ModuleType) -> None: ...
-    else:
-        @classmethod
-        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
-        @classmethod
-        def exec_module(cls, module: types.ModuleType) -> None: ...
-
-class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
-    # MetaPathFinder
-    @classmethod
-    def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-    # InspectLoader
-    @classmethod
-    def is_package(cls, fullname: str) -> bool: ...
-    @classmethod
-    def load_module(cls, fullname: str) -> types.ModuleType: ...
-    @classmethod
-    def get_code(cls, fullname: str) -> None: ...
-    @classmethod
-    def get_source(cls, fullname: str) -> None: ...
-    # Loader
-    @staticmethod
-    def module_repr(m: types.ModuleType) -> str: ...
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
-    else:
-        @classmethod
-        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
-
-    @staticmethod
-    def exec_module(module: types.ModuleType) -> None: ...
-
-class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
-    @classmethod
-    def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-
-class PathFinder:
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def invalidate_caches() -> None: ...
-    else:
-        @classmethod
-        def invalidate_caches(cls) -> None: ...
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def find_distributions(context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
-    elif sys.version_info >= (3, 8):
-        @classmethod
-        def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
-
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-    @classmethod
-    def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-
-SOURCE_SUFFIXES: list[str]
-DEBUG_BYTECODE_SUFFIXES: list[str]
-OPTIMIZED_BYTECODE_SUFFIXES: list[str]
-BYTECODE_SUFFIXES: list[str]
-EXTENSION_SUFFIXES: list[str]
+from importlib._bootstrap import BuiltinImporter as BuiltinImporter, FrozenImporter as FrozenImporter, ModuleSpec as ModuleSpec
+from importlib._bootstrap_external import (
+    BYTECODE_SUFFIXES as BYTECODE_SUFFIXES,
+    DEBUG_BYTECODE_SUFFIXES as DEBUG_BYTECODE_SUFFIXES,
+    EXTENSION_SUFFIXES as EXTENSION_SUFFIXES,
+    OPTIMIZED_BYTECODE_SUFFIXES as OPTIMIZED_BYTECODE_SUFFIXES,
+    SOURCE_SUFFIXES as SOURCE_SUFFIXES,
+    ExtensionFileLoader as ExtensionFileLoader,
+    FileFinder as FileFinder,
+    PathFinder as PathFinder,
+    SourceFileLoader as SourceFileLoader,
+    SourcelessFileLoader as SourcelessFileLoader,
+    WindowsRegistryFinder as WindowsRegistryFinder,
+)
+
+if sys.version_info >= (3, 11):
+    from importlib._bootstrap_external import NamespaceLoader as NamespaceLoader
 
 def all_suffixes() -> list[str]: ...
-
-class FileFinder(importlib.abc.PathEntryFinder):
-    path: str
-    def __init__(self, path: str, *loader_details: tuple[type[importlib.abc.Loader], list[str]]) -> None: ...
-    @classmethod
-    def path_hook(
-        cls, *loader_details: tuple[type[importlib.abc.Loader], list[str]]
-    ) -> Callable[[str], importlib.abc.PathEntryFinder]: ...
-
-class SourceFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader):
-    def set_data(self, path: str, data: ReadableBuffer, *, _mode: int = 0o666) -> None: ...
-
-class SourcelessFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader): ...
-
-class ExtensionFileLoader(importlib.abc.ExecutionLoader):
-    def __init__(self, name: str, path: str) -> None: ...
-    def get_filename(self, name: str | None = None) -> str: ...
-    def get_source(self, fullname: str) -> None: ...
-    def create_module(self, spec: ModuleSpec) -> types.ModuleType: ...
-    def exec_module(self, module: types.ModuleType) -> None: ...
-    def get_code(self, fullname: str) -> None: ...
-    def __eq__(self, other: object) -> bool: ...
diff --git a/mypy/typeshed/stdlib/importlib/metadata/__init__.pyi b/mypy/typeshed/stdlib/importlib/metadata/__init__.pyi
index 083453cd3c9a..8ab7a0c4a9e8 100644
--- a/mypy/typeshed/stdlib/importlib/metadata/__init__.pyi
+++ b/mypy/typeshed/stdlib/importlib/metadata/__init__.pyi
@@ -1,15 +1,21 @@
 import abc
 import pathlib
 import sys
+import types
+from _collections_abc import dict_keys, dict_values
 from _typeshed import StrPath
-from collections.abc import Iterable, Mapping
+from collections.abc import Iterable, Iterator, Mapping
 from email.message import Message
 from importlib.abc import MetaPathFinder
 from os import PathLike
 from pathlib import Path
 from re import Pattern
-from typing import Any, ClassVar, NamedTuple, overload
-from typing_extensions import Self
+from typing import Any, ClassVar, Generic, NamedTuple, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+_T = TypeVar("_T")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
 
 __all__ = [
     "Distribution",
@@ -28,21 +34,38 @@ if sys.version_info >= (3, 10):
     __all__ += ["PackageMetadata", "packages_distributions"]
 
 if sys.version_info >= (3, 10):
-    from importlib.metadata._meta import PackageMetadata as PackageMetadata
+    from importlib.metadata._meta import PackageMetadata as PackageMetadata, SimplePath
     def packages_distributions() -> Mapping[str, list[str]]: ...
 
+    _SimplePath: TypeAlias = SimplePath
+
+else:
+    _SimplePath: TypeAlias = Path
+
 class PackageNotFoundError(ModuleNotFoundError):
     @property
     def name(self) -> str: ...  # type: ignore[override]
 
-class _EntryPointBase(NamedTuple):
-    name: str
-    value: str
-    group: str
+if sys.version_info >= (3, 13):
+    _EntryPointBase = object
+elif sys.version_info >= (3, 11):
+    class DeprecatedTuple:
+        def __getitem__(self, item: int) -> str: ...
+
+    _EntryPointBase = DeprecatedTuple
+else:
+    class _EntryPointBase(NamedTuple):
+        name: str
+        value: str
+        group: str
 
 class EntryPoint(_EntryPointBase):
     pattern: ClassVar[Pattern[str]]
     if sys.version_info >= (3, 11):
+        name: str
+        value: str
+        group: str
+
         def __init__(self, name: str, value: str, group: str) -> None: ...
 
     def load(self) -> Any: ...  # Callable[[], Any] or an importable module
@@ -66,8 +89,35 @@ class EntryPoint(_EntryPointBase):
             extras: list[str] = ...,
         ) -> bool: ...  # undocumented
 
-if sys.version_info >= (3, 10):
-    class EntryPoints(list[EntryPoint]):  # use as list is deprecated since 3.10
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def __lt__(self, other: object) -> bool: ...
+    if sys.version_info < (3, 12):
+        def __iter__(self) -> Iterator[Any]: ...  # result of iter((str, Self)), really
+
+if sys.version_info >= (3, 12):
+    class EntryPoints(tuple[EntryPoint, ...]):
+        def __getitem__(self, name: str) -> EntryPoint: ...  # type: ignore[override]
+        def select(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> EntryPoints: ...
+        @property
+        def names(self) -> set[str]: ...
+        @property
+        def groups(self) -> set[str]: ...
+
+elif sys.version_info >= (3, 10):
+    class DeprecatedList(list[_T]): ...
+
+    class EntryPoints(DeprecatedList[EntryPoint]):  # use as list is deprecated since 3.10
         # int argument is deprecated since 3.10
         def __getitem__(self, name: int | str) -> EntryPoint: ...  # type: ignore[override]
         def select(
@@ -85,7 +135,19 @@ if sys.version_info >= (3, 10):
         @property
         def groups(self) -> set[str]: ...
 
-    class SelectableGroups(dict[str, EntryPoints]):  # use as dict is deprecated since 3.10
+if sys.version_info >= (3, 10) and sys.version_info < (3, 12):
+    class Deprecated(Generic[_KT, _VT]):
+        def __getitem__(self, name: _KT) -> _VT: ...
+        @overload
+        def get(self, name: _KT, default: None = None) -> _VT | None: ...
+        @overload
+        def get(self, name: _KT, default: _T) -> _VT | _T: ...
+        def __iter__(self) -> Iterator[_KT]: ...
+        def __contains__(self, *args: object) -> bool: ...
+        def keys(self) -> dict_keys[_KT, _VT]: ...
+        def values(self) -> dict_values[_KT, _VT]: ...
+
+    class SelectableGroups(Deprecated[str, EntryPoints], dict[str, EntryPoints]):  # use as dict is deprecated since 3.10
         @classmethod
         def load(cls, eps: Iterable[EntryPoint]) -> Self: ...
         @property
@@ -93,7 +155,7 @@ if sys.version_info >= (3, 10):
         @property
         def names(self) -> set[str]: ...
         @overload
-        def select(self) -> Self: ...  # type: ignore[misc]
+        def select(self) -> Self: ...
         @overload
         def select(
             self,
@@ -120,11 +182,17 @@ class FileHash:
     value: str
     def __init__(self, spec: str) -> None: ...
 
-class Distribution:
+if sys.version_info >= (3, 12):
+    class DeprecatedNonAbstract: ...
+    _distribution_parent = DeprecatedNonAbstract
+else:
+    _distribution_parent = object
+
+class Distribution(_distribution_parent):
     @abc.abstractmethod
     def read_text(self, filename: str) -> str | None: ...
     @abc.abstractmethod
-    def locate_file(self, path: StrPath) -> PathLike[str]: ...
+    def locate_file(self, path: StrPath) -> _SimplePath: ...
     @classmethod
     def from_name(cls, name: str) -> Distribution: ...
     @overload
@@ -158,6 +226,9 @@ class Distribution:
     if sys.version_info >= (3, 10):
         @property
         def name(self) -> str: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def origin(self) -> types.SimpleNamespace: ...
 
 class DistributionFinder(MetaPathFinder):
     class Context:
@@ -172,14 +243,18 @@ class DistributionFinder(MetaPathFinder):
 class MetadataPathFinder(DistributionFinder):
     @classmethod
     def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
-    if sys.version_info >= (3, 10):
-        # Yes, this is an instance method that has argumend named "cls"
+    if sys.version_info >= (3, 11):
+        @classmethod
+        def invalidate_caches(cls) -> None: ...
+    elif sys.version_info >= (3, 10):
+        # Yes, this is an instance method that has a parameter named "cls"
         def invalidate_caches(cls) -> None: ...
 
 class PathDistribution(Distribution):
-    def __init__(self, path: Path) -> None: ...
-    def read_text(self, filename: StrPath) -> str: ...
-    def locate_file(self, path: StrPath) -> PathLike[str]: ...
+    _path: _SimplePath
+    def __init__(self, path: _SimplePath) -> None: ...
+    def read_text(self, filename: StrPath) -> str | None: ...
+    def locate_file(self, path: StrPath) -> _SimplePath: ...
 
 def distribution(distribution_name: str) -> Distribution: ...
 @overload
@@ -191,15 +266,24 @@ def distributions(
 
 if sys.version_info >= (3, 10):
     def metadata(distribution_name: str) -> PackageMetadata: ...
+
+else:
+    def metadata(distribution_name: str) -> Message: ...
+
+if sys.version_info >= (3, 12):
+    def entry_points(
+        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
+    ) -> EntryPoints: ...
+
+elif sys.version_info >= (3, 10):
     @overload
-    def entry_points() -> SelectableGroups: ...  # type: ignore[misc]
+    def entry_points() -> SelectableGroups: ...
     @overload
     def entry_points(
         *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
     ) -> EntryPoints: ...
 
 else:
-    def metadata(distribution_name: str) -> Message: ...
     def entry_points() -> dict[str, list[EntryPoint]]: ...
 
 def version(distribution_name: str) -> str: ...
diff --git a/mypy/typeshed/stdlib/importlib/metadata/_meta.pyi b/mypy/typeshed/stdlib/importlib/metadata/_meta.pyi
index e3504fe4036a..9f791dab254f 100644
--- a/mypy/typeshed/stdlib/importlib/metadata/_meta.pyi
+++ b/mypy/typeshed/stdlib/importlib/metadata/_meta.pyi
@@ -1,22 +1,63 @@
+import sys
+from _typeshed import StrPath
 from collections.abc import Iterator
-from typing import Any, Protocol, TypeVar
+from os import PathLike
+from typing import Any, Protocol, overload
+from typing_extensions import TypeVar
 
 _T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True, default=Any)
 
 class PackageMetadata(Protocol):
     def __len__(self) -> int: ...
     def __contains__(self, item: str) -> bool: ...
     def __getitem__(self, key: str) -> str: ...
     def __iter__(self) -> Iterator[str]: ...
-    def get_all(self, name: str, failobj: _T = ...) -> list[Any] | _T: ...
     @property
     def json(self) -> dict[str, str | list[str]]: ...
+    @overload
+    def get_all(self, name: str, failobj: None = None) -> list[Any] | None: ...
+    @overload
+    def get_all(self, name: str, failobj: _T) -> list[Any] | _T: ...
+    if sys.version_info >= (3, 12):
+        @overload
+        def get(self, name: str, failobj: None = None) -> str | None: ...
+        @overload
+        def get(self, name: str, failobj: _T) -> _T | str: ...
 
-class SimplePath(Protocol):
-    def joinpath(self) -> SimplePath: ...
-    def parent(self) -> SimplePath: ...
-    def read_text(self) -> str: ...
-    # There was a bug in `SimplePath` definition in cpython, see #8451
-    #  Strictly speaking `__div__` was defined in 3.10, not __truediv__,
-    # but it should have always been `__truediv__`.
-    def __truediv__(self) -> SimplePath: ...
+if sys.version_info >= (3, 13):
+    class SimplePath(Protocol):
+        def joinpath(self, other: StrPath, /) -> SimplePath: ...
+        def __truediv__(self, other: StrPath, /) -> SimplePath: ...
+        # Incorrect at runtime
+        @property
+        def parent(self) -> PathLike[str]: ...
+        def read_text(self, encoding: str | None = None) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        def exists(self) -> bool: ...
+
+elif sys.version_info >= (3, 12):
+    class SimplePath(Protocol[_T_co]):
+        # At runtime this is defined as taking `str | _T`, but that causes trouble.
+        # See #11436.
+        def joinpath(self, other: str, /) -> _T_co: ...
+        @property
+        def parent(self) -> _T_co: ...
+        def read_text(self) -> str: ...
+        # As with joinpath(), this is annotated as taking `str | _T` at runtime.
+        def __truediv__(self, other: str, /) -> _T_co: ...
+
+else:
+    class SimplePath(Protocol):
+        # Actually takes only self at runtime, but that's clearly wrong
+        def joinpath(self, other: Any, /) -> SimplePath: ...
+        # Not defined as a property at runtime, but it should be
+        @property
+        def parent(self) -> Any: ...
+        def read_text(self) -> str: ...
+        # There was a bug in `SimplePath` definition in cpython, see #8451
+        #  Strictly speaking `__div__` was defined in 3.10, not __truediv__,
+        # but it should have always been `__truediv__`.
+        # Also, the runtime defines this method as taking no arguments,
+        # which is obviously wrong.
+        def __truediv__(self, other: Any, /) -> SimplePath: ...
diff --git a/mypy/typeshed/stdlib/importlib/metadata/diagnose.pyi b/mypy/typeshed/stdlib/importlib/metadata/diagnose.pyi
new file mode 100644
index 000000000000..565872fd976f
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/metadata/diagnose.pyi
@@ -0,0 +1,2 @@
+def inspect(path: str) -> None: ...
+def run() -> None: ...
diff --git a/mypy/typeshed/stdlib/importlib/readers.pyi b/mypy/typeshed/stdlib/importlib/readers.pyi
new file mode 100644
index 000000000000..4a6c73921535
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/readers.pyi
@@ -0,0 +1,72 @@
+# On py311+, things are actually defined in importlib.resources.readers,
+# and re-exported here,
+# but doing it this way leads to less code duplication for us
+
+import pathlib
+import sys
+import zipfile
+from _typeshed import StrPath
+from collections.abc import Iterable, Iterator
+from io import BufferedReader
+from typing import Literal, NoReturn, TypeVar
+from typing_extensions import Never
+
+if sys.version_info >= (3, 10):
+    from importlib._bootstrap_external import FileLoader
+    from zipimport import zipimporter
+
+if sys.version_info >= (3, 11):
+    from importlib.resources import abc
+else:
+    from importlib import abc
+
+if sys.version_info >= (3, 10):
+    if sys.version_info >= (3, 11):
+        __all__ = ["FileReader", "ZipReader", "MultiplexedPath", "NamespaceReader"]
+
+    if sys.version_info < (3, 11):
+        _T = TypeVar("_T")
+
+        def remove_duplicates(items: Iterable[_T]) -> Iterator[_T]: ...
+
+    class FileReader(abc.TraversableResources):
+        path: pathlib.Path
+        def __init__(self, loader: FileLoader) -> None: ...
+        def resource_path(self, resource: StrPath) -> str: ...
+        def files(self) -> pathlib.Path: ...
+
+    class ZipReader(abc.TraversableResources):
+        prefix: str
+        archive: str
+        def __init__(self, loader: zipimporter, module: str) -> None: ...
+        def open_resource(self, resource: str) -> BufferedReader: ...
+        def is_resource(self, path: StrPath) -> bool: ...
+        def files(self) -> zipfile.Path: ...
+
+    class MultiplexedPath(abc.Traversable):
+        def __init__(self, *paths: abc.Traversable) -> None: ...
+        def iterdir(self) -> Iterator[abc.Traversable]: ...
+        def read_bytes(self) -> NoReturn: ...
+        def read_text(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+        def is_dir(self) -> Literal[True]: ...
+        def is_file(self) -> Literal[False]: ...
+
+        if sys.version_info >= (3, 12):
+            def joinpath(self, *descendants: str) -> abc.Traversable: ...
+        elif sys.version_info >= (3, 11):
+            def joinpath(self, child: str) -> abc.Traversable: ...  # type: ignore[override]
+        else:
+            def joinpath(self, child: str) -> abc.Traversable: ...
+
+        if sys.version_info < (3, 12):
+            __truediv__ = joinpath
+
+        def open(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+        @property
+        def name(self) -> str: ...
+
+    class NamespaceReader(abc.TraversableResources):
+        path: MultiplexedPath
+        def __init__(self, namespace_path: Iterable[str]) -> None: ...
+        def resource_path(self, resource: str) -> str: ...
+        def files(self) -> MultiplexedPath: ...
diff --git a/mypy/typeshed/stdlib/importlib/resources/__init__.pyi b/mypy/typeshed/stdlib/importlib/resources/__init__.pyi
index ba3d9b087754..a30e6cdce5c6 100644
--- a/mypy/typeshed/stdlib/importlib/resources/__init__.pyi
+++ b/mypy/typeshed/stdlib/importlib/resources/__init__.pyi
@@ -4,10 +4,18 @@ from collections.abc import Iterator
 from contextlib import AbstractContextManager
 from pathlib import Path
 from types import ModuleType
-from typing import Any, BinaryIO, TextIO
+from typing import Any, BinaryIO, Literal, TextIO
 from typing_extensions import TypeAlias
 
-__all__ = ["Package", "Resource", "contents", "is_resource", "open_binary", "open_text", "path", "read_binary", "read_text"]
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import Package as Package
+else:
+    Package: TypeAlias = str | ModuleType
+
+if sys.version_info >= (3, 9):
+    from importlib.abc import Traversable
+
+__all__ = ["Package", "contents", "is_resource", "open_binary", "open_text", "path", "read_binary", "read_text"]
 
 if sys.version_info >= (3, 9):
     __all__ += ["as_file", "files"]
@@ -15,25 +23,48 @@ if sys.version_info >= (3, 9):
 if sys.version_info >= (3, 10):
     __all__ += ["ResourceReader"]
 
-Package: TypeAlias = str | ModuleType
+if sys.version_info < (3, 13):
+    __all__ += ["Resource"]
 
-if sys.version_info >= (3, 11):
+if sys.version_info < (3, 11):
+    Resource: TypeAlias = str | os.PathLike[Any]
+elif sys.version_info < (3, 13):
     Resource: TypeAlias = str
+
+if sys.version_info >= (3, 13):
+    from importlib.resources._common import Anchor as Anchor
+
+    __all__ += ["Anchor"]
+
+    from importlib.resources._functional import (
+        contents as contents,
+        is_resource as is_resource,
+        open_binary as open_binary,
+        open_text as open_text,
+        path as path,
+        read_binary as read_binary,
+        read_text as read_text,
+    )
+
 else:
-    Resource: TypeAlias = str | os.PathLike[Any]
+    def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
+    def open_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> TextIO: ...
+    def read_binary(package: Package, resource: Resource) -> bytes: ...
+    def read_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> str: ...
+    def path(package: Package, resource: Resource) -> AbstractContextManager[Path, Literal[False]]: ...
+    def is_resource(package: Package, name: str) -> bool: ...
+    def contents(package: Package) -> Iterator[str]: ...
 
-def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
-def open_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> TextIO: ...
-def read_binary(package: Package, resource: Resource) -> bytes: ...
-def read_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> str: ...
-def path(package: Package, resource: Resource) -> AbstractContextManager[Path]: ...
-def is_resource(package: Package, name: str) -> bool: ...
-def contents(package: Package) -> Iterator[str]: ...
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import as_file as as_file
+elif sys.version_info >= (3, 9):
+    def as_file(path: Traversable) -> AbstractContextManager[Path, Literal[False]]: ...
 
-if sys.version_info >= (3, 9):
-    from importlib.abc import Traversable
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import files as files
+
+elif sys.version_info >= (3, 9):
     def files(package: Package) -> Traversable: ...
-    def as_file(path: Traversable) -> AbstractContextManager[Path]: ...
 
 if sys.version_info >= (3, 10):
     from importlib.abc import ResourceReader as ResourceReader
diff --git a/mypy/typeshed/stdlib/importlib/resources/_common.pyi b/mypy/typeshed/stdlib/importlib/resources/_common.pyi
new file mode 100644
index 000000000000..d6a9436544dc
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/resources/_common.pyi
@@ -0,0 +1,42 @@
+import sys
+
+# Even though this file is 3.11+ only, Pyright will complain in stubtest for older versions.
+if sys.version_info >= (3, 11):
+    import types
+    from collections.abc import Callable
+    from contextlib import AbstractContextManager
+    from importlib.abc import ResourceReader, Traversable
+    from pathlib import Path
+    from typing import Literal, overload
+    from typing_extensions import TypeAlias, deprecated
+
+    Package: TypeAlias = str | types.ModuleType
+
+    if sys.version_info >= (3, 12):
+        Anchor: TypeAlias = Package
+
+        def package_to_anchor(
+            func: Callable[[Anchor | None], Traversable],
+        ) -> Callable[[Anchor | None, Anchor | None], Traversable]: ...
+        @overload
+        def files(anchor: Anchor | None = None) -> Traversable: ...
+        @overload
+        @deprecated("First parameter to files is renamed to 'anchor'")
+        def files(package: Anchor | None = None) -> Traversable: ...
+
+    else:
+        def files(package: Package) -> Traversable: ...
+
+    def get_resource_reader(package: types.ModuleType) -> ResourceReader | None: ...
+
+    if sys.version_info >= (3, 12):
+        def resolve(cand: Anchor | None) -> types.ModuleType: ...
+
+    else:
+        def resolve(cand: Package) -> types.ModuleType: ...
+
+    if sys.version_info < (3, 12):
+        def get_package(package: Package) -> types.ModuleType: ...
+
+    def from_package(package: types.ModuleType) -> Traversable: ...
+    def as_file(path: Traversable) -> AbstractContextManager[Path, Literal[False]]: ...
diff --git a/mypy/typeshed/stdlib/importlib/resources/_functional.pyi b/mypy/typeshed/stdlib/importlib/resources/_functional.pyi
new file mode 100644
index 000000000000..50f3405f9a00
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/resources/_functional.pyi
@@ -0,0 +1,30 @@
+import sys
+
+# Even though this file is 3.13+ only, Pyright will complain in stubtest for older versions.
+if sys.version_info >= (3, 13):
+    from _typeshed import StrPath
+    from collections.abc import Iterator
+    from contextlib import AbstractContextManager
+    from importlib.resources._common import Anchor
+    from io import TextIOWrapper
+    from pathlib import Path
+    from typing import BinaryIO, Literal, overload
+    from typing_extensions import Unpack
+
+    def open_binary(anchor: Anchor, *path_names: StrPath) -> BinaryIO: ...
+    @overload
+    def open_text(
+        anchor: Anchor, *path_names: Unpack[tuple[StrPath]], encoding: str | None = "utf-8", errors: str | None = "strict"
+    ) -> TextIOWrapper: ...
+    @overload
+    def open_text(anchor: Anchor, *path_names: StrPath, encoding: str | None, errors: str | None = "strict") -> TextIOWrapper: ...
+    def read_binary(anchor: Anchor, *path_names: StrPath) -> bytes: ...
+    @overload
+    def read_text(
+        anchor: Anchor, *path_names: Unpack[tuple[StrPath]], encoding: str | None = "utf-8", errors: str | None = "strict"
+    ) -> str: ...
+    @overload
+    def read_text(anchor: Anchor, *path_names: StrPath, encoding: str | None, errors: str | None = "strict") -> str: ...
+    def path(anchor: Anchor, *path_names: StrPath) -> AbstractContextManager[Path, Literal[False]]: ...
+    def is_resource(anchor: Anchor, *path_names: StrPath) -> bool: ...
+    def contents(anchor: Anchor, *path_names: StrPath) -> Iterator[str]: ...
diff --git a/mypy/typeshed/stdlib/importlib/resources/abc.pyi b/mypy/typeshed/stdlib/importlib/resources/abc.pyi
index a36c952d01ac..ad80605f7c71 100644
--- a/mypy/typeshed/stdlib/importlib/resources/abc.pyi
+++ b/mypy/typeshed/stdlib/importlib/resources/abc.pyi
@@ -10,3 +10,5 @@ if sys.version_info >= (3, 11):
         Traversable as Traversable,
         TraversableResources as TraversableResources,
     )
+
+    __all__ = ["ResourceReader", "Traversable", "TraversableResources"]
diff --git a/mypy/typeshed/stdlib/importlib/resources/readers.pyi b/mypy/typeshed/stdlib/importlib/resources/readers.pyi
new file mode 100644
index 000000000000..0ab21fd29114
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/resources/readers.pyi
@@ -0,0 +1,14 @@
+# On py311+, things are actually defined here
+# and re-exported from importlib.readers,
+# but doing it this way leads to less code duplication for us
+
+import sys
+from collections.abc import Iterable, Iterator
+from typing import TypeVar
+
+if sys.version_info >= (3, 11):
+    from importlib.readers import *
+
+    _T = TypeVar("_T")
+
+    def remove_duplicates(items: Iterable[_T]) -> Iterator[_T]: ...
diff --git a/mypy/typeshed/stdlib/importlib/resources/simple.pyi b/mypy/typeshed/stdlib/importlib/resources/simple.pyi
new file mode 100644
index 000000000000..c4c758111c2d
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/resources/simple.pyi
@@ -0,0 +1,56 @@
+import abc
+import sys
+from collections.abc import Iterator
+from io import TextIOWrapper
+from typing import IO, Any, BinaryIO, Literal, NoReturn, overload
+from typing_extensions import Never
+
+if sys.version_info >= (3, 11):
+    from .abc import Traversable, TraversableResources
+
+    class SimpleReader(abc.ABC):
+        @property
+        @abc.abstractmethod
+        def package(self) -> str: ...
+        @abc.abstractmethod
+        def children(self) -> list[SimpleReader]: ...
+        @abc.abstractmethod
+        def resources(self) -> list[str]: ...
+        @abc.abstractmethod
+        def open_binary(self, resource: str) -> BinaryIO: ...
+        @property
+        def name(self) -> str: ...
+
+    class ResourceHandle(Traversable, metaclass=abc.ABCMeta):
+        parent: ResourceContainer
+        def __init__(self, parent: ResourceContainer, name: str) -> None: ...
+        def is_file(self) -> Literal[True]: ...
+        def is_dir(self) -> Literal[False]: ...
+        @overload
+        def open(
+            self,
+            mode: Literal["r"] = "r",
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+            line_buffering: bool = False,
+            write_through: bool = False,
+        ) -> TextIOWrapper: ...
+        @overload
+        def open(self, mode: Literal["rb"]) -> BinaryIO: ...
+        @overload
+        def open(self, mode: str) -> IO[Any]: ...
+        def joinpath(self, name: Never) -> NoReturn: ...  # type: ignore[override]
+
+    class ResourceContainer(Traversable, metaclass=abc.ABCMeta):
+        reader: SimpleReader
+        def __init__(self, reader: SimpleReader) -> None: ...
+        def is_dir(self) -> Literal[True]: ...
+        def is_file(self) -> Literal[False]: ...
+        def iterdir(self) -> Iterator[ResourceHandle | ResourceContainer]: ...
+        def open(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+        if sys.version_info < (3, 12):
+            def joinpath(self, *descendants: str) -> Traversable: ...
+
+    class TraversableReader(TraversableResources, SimpleReader, metaclass=abc.ABCMeta):
+        def files(self) -> ResourceContainer: ...
diff --git a/mypy/typeshed/stdlib/importlib/simple.pyi b/mypy/typeshed/stdlib/importlib/simple.pyi
new file mode 100644
index 000000000000..58d8c6617082
--- /dev/null
+++ b/mypy/typeshed/stdlib/importlib/simple.pyi
@@ -0,0 +1,11 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from .resources.simple import (
+        ResourceContainer as ResourceContainer,
+        ResourceHandle as ResourceHandle,
+        SimpleReader as SimpleReader,
+        TraversableReader as TraversableReader,
+    )
+
+    __all__ = ["SimpleReader", "ResourceHandle", "ResourceContainer", "TraversableReader"]
diff --git a/mypy/typeshed/stdlib/importlib/util.pyi b/mypy/typeshed/stdlib/importlib/util.pyi
index f988eb270a26..cc1c98ae4d0e 100644
--- a/mypy/typeshed/stdlib/importlib/util.pyi
+++ b/mypy/typeshed/stdlib/importlib/util.pyi
@@ -1,35 +1,28 @@
 import importlib.abc
 import importlib.machinery
+import sys
 import types
-from _typeshed import ReadableBuffer, StrOrBytesPath
+from _typeshed import ReadableBuffer
 from collections.abc import Callable
-from typing import Any
+from importlib._bootstrap import module_from_spec as module_from_spec, spec_from_loader as spec_from_loader
+from importlib._bootstrap_external import (
+    MAGIC_NUMBER as MAGIC_NUMBER,
+    cache_from_source as cache_from_source,
+    decode_source as decode_source,
+    source_from_cache as source_from_cache,
+    spec_from_file_location as spec_from_file_location,
+)
 from typing_extensions import ParamSpec
 
 _P = ParamSpec("_P")
 
-def module_for_loader(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
-def set_loader(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
-def set_package(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
-def resolve_name(name: str, package: str | None) -> str: ...
-
-MAGIC_NUMBER: bytes
+if sys.version_info < (3, 12):
+    def module_for_loader(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
+    def set_loader(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
+    def set_package(fxn: Callable[_P, types.ModuleType]) -> Callable[_P, types.ModuleType]: ...
 
-def cache_from_source(path: str, debug_override: bool | None = None, *, optimization: Any | None = None) -> str: ...
-def source_from_cache(path: str) -> str: ...
-def decode_source(source_bytes: ReadableBuffer) -> str: ...
+def resolve_name(name: str, package: str | None) -> str: ...
 def find_spec(name: str, package: str | None = None) -> importlib.machinery.ModuleSpec | None: ...
-def spec_from_loader(
-    name: str, loader: importlib.abc.Loader | None, *, origin: str | None = None, is_package: bool | None = None
-) -> importlib.machinery.ModuleSpec | None: ...
-def spec_from_file_location(
-    name: str,
-    location: StrOrBytesPath | None = None,
-    *,
-    loader: importlib.abc.Loader | None = None,
-    submodule_search_locations: list[str] | None = ...,
-) -> importlib.machinery.ModuleSpec | None: ...
-def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ...
 
 class LazyLoader(importlib.abc.Loader):
     def __init__(self, loader: importlib.abc.Loader) -> None: ...
@@ -37,4 +30,4 @@ class LazyLoader(importlib.abc.Loader):
     def factory(cls, loader: importlib.abc.Loader) -> Callable[..., LazyLoader]: ...
     def exec_module(self, module: types.ModuleType) -> None: ...
 
-def source_hash(source_bytes: ReadableBuffer) -> int: ...
+def source_hash(source_bytes: ReadableBuffer) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/inspect.pyi b/mypy/typeshed/stdlib/inspect.pyi
index 2d004a8e6b57..5bebe9bf4482 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 (
@@ -24,8 +25,8 @@ from types import (
     TracebackType,
     WrapperDescriptorType,
 )
-from typing import Any, ClassVar, NamedTuple, Protocol, TypeVar, overload
-from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypeGuard
+from typing import Any, ClassVar, Final, Literal, NamedTuple, Protocol, TypeVar, overload
+from typing_extensions import ParamSpec, Self, TypeAlias, TypeGuard, TypeIs
 
 if sys.version_info >= (3, 11):
     __all__ = [
@@ -127,10 +128,23 @@ 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")
-_T_cont = TypeVar("_T_cont", contravariant=True)
-_V_cont = TypeVar("_V_cont", contravariant=True)
+_F = TypeVar("_F", bound=Callable[..., Any])
+_T_contra = TypeVar("_T_contra", contravariant=True)
+_V_contra = TypeVar("_V_contra", contravariant=True)
 
 #
 # Types and members
@@ -147,112 +161,91 @@ class BlockFinder:
     last: int
     def tokeneater(self, type: int, token: str, srowcol: tuple[int, int], erowcol: tuple[int, int], line: str) -> None: ...
 
-CO_OPTIMIZED: Literal[1]
-CO_NEWLOCALS: Literal[2]
-CO_VARARGS: Literal[4]
-CO_VARKEYWORDS: Literal[8]
-CO_NESTED: Literal[16]
-CO_GENERATOR: Literal[32]
-CO_NOFREE: Literal[64]
-CO_COROUTINE: Literal[128]
-CO_ITERABLE_COROUTINE: Literal[256]
-CO_ASYNC_GENERATOR: Literal[512]
-TPFLAGS_IS_ABSTRACT: Literal[1048576]
+CO_OPTIMIZED: Final = 1
+CO_NEWLOCALS: Final = 2
+CO_VARARGS: Final = 4
+CO_VARKEYWORDS: Final = 8
+CO_NESTED: Final = 16
+CO_GENERATOR: Final = 32
+CO_NOFREE: Final = 64
+CO_COROUTINE: Final = 128
+CO_ITERABLE_COROUTINE: Final = 256
+CO_ASYNC_GENERATOR: Final = 512
+TPFLAGS_IS_ABSTRACT: Final = 1048576
 
 modulesbyfile: dict[str, Any]
 
 _GetMembersPredicateTypeGuard: TypeAlias = Callable[[Any], TypeGuard[_T]]
+_GetMembersPredicateTypeIs: TypeAlias = Callable[[Any], TypeIs[_T]]
 _GetMembersPredicate: TypeAlias = Callable[[Any], bool]
-_GetMembersReturnTypeGuard: TypeAlias = list[tuple[str, _T]]
-_GetMembersReturn: TypeAlias = list[tuple[str, Any]]
+_GetMembersReturn: TypeAlias = list[tuple[str, _T]]
 
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
+def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
+@overload
+def getmembers(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
+def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
 
 if sys.version_info >= (3, 11):
     @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
-    @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
-
-def getmodulename(path: str) -> 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, 8):
-    @overload
-    def isgeneratorfunction(obj: Callable[..., Generator[Any, Any, Any]]) -> bool: ...
-    @overload
-    def isgeneratorfunction(obj: Callable[_P, Any]) -> TypeGuard[Callable[_P, GeneratorType[Any, Any, Any]]]: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
     @overload
-    def isgeneratorfunction(obj: object) -> TypeGuard[Callable[..., GeneratorType[Any, Any, Any]]]: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
     @overload
-    def iscoroutinefunction(obj: Callable[..., Coroutine[Any, Any, Any]]) -> bool: ...
-    @overload
-    def iscoroutinefunction(obj: Callable[_P, Awaitable[_T]]) -> TypeGuard[Callable[_P, CoroutineType[Any, Any, _T]]]: ...
-    @overload
-    def iscoroutinefunction(obj: Callable[_P, object]) -> TypeGuard[Callable[_P, CoroutineType[Any, Any, Any]]]: ...
-    @overload
-    def iscoroutinefunction(obj: object) -> TypeGuard[Callable[..., CoroutineType[Any, Any, Any]]]: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
 
-else:
-    @overload
-    def isgeneratorfunction(object: Callable[..., Generator[Any, Any, Any]]) -> bool: ...
-    @overload
-    def isgeneratorfunction(object: Callable[_P, Any]) -> TypeGuard[Callable[_P, GeneratorType[Any, Any, Any]]]: ...
-    @overload
-    def isgeneratorfunction(object: object) -> TypeGuard[Callable[..., GeneratorType[Any, Any, Any]]]: ...
-    @overload
-    def iscoroutinefunction(object: Callable[..., Coroutine[Any, Any, Any]]) -> bool: ...
-    @overload
-    def iscoroutinefunction(object: Callable[_P, Awaitable[_T]]) -> TypeGuard[Callable[_P, CoroutineType[Any, Any, _T]]]: ...
-    @overload
-    def iscoroutinefunction(object: Callable[_P, Any]) -> TypeGuard[Callable[_P, CoroutineType[Any, Any, Any]]]: ...
-    @overload
-    def iscoroutinefunction(object: object) -> TypeGuard[Callable[..., CoroutineType[Any, Any, Any]]]: ...
-
-def isgenerator(object: object) -> TypeGuard[GeneratorType[Any, Any, Any]]: ...
-def iscoroutine(object: object) -> TypeGuard[CoroutineType[Any, Any, Any]]: ...
-def isawaitable(object: object) -> TypeGuard[Awaitable[Any]]: ...
+def getmodulename(path: StrPath) -> str | None: ...
+def ismodule(object: object) -> TypeIs[ModuleType]: ...
+def isclass(object: object) -> TypeIs[type[Any]]: ...
+def ismethod(object: object) -> TypeIs[MethodType]: ...
+def isfunction(object: object) -> TypeIs[FunctionType]: ...
 
-if sys.version_info >= (3, 8):
-    @overload
-    def isasyncgenfunction(obj: Callable[..., AsyncGenerator[Any, Any]]) -> bool: ...
-    @overload
-    def isasyncgenfunction(obj: Callable[_P, Any]) -> TypeGuard[Callable[_P, AsyncGeneratorType[Any, Any]]]: ...
-    @overload
-    def isasyncgenfunction(obj: object) -> TypeGuard[Callable[..., AsyncGeneratorType[Any, Any]]]: ...
+if sys.version_info >= (3, 12):
+    def markcoroutinefunction(func: _F) -> _F: ...
 
-else:
-    @overload
-    def isasyncgenfunction(object: Callable[..., AsyncGenerator[Any, Any]]) -> bool: ...
-    @overload
-    def isasyncgenfunction(object: Callable[_P, Any]) -> TypeGuard[Callable[_P, AsyncGeneratorType[Any, Any]]]: ...
-    @overload
-    def isasyncgenfunction(object: object) -> TypeGuard[Callable[..., AsyncGeneratorType[Any, Any]]]: ...
+@overload
+def isgeneratorfunction(obj: Callable[..., Generator[Any, Any, Any]]) -> bool: ...
+@overload
+def isgeneratorfunction(obj: Callable[_P, Any]) -> TypeGuard[Callable[_P, GeneratorType[Any, Any, Any]]]: ...
+@overload
+def isgeneratorfunction(obj: object) -> TypeGuard[Callable[..., GeneratorType[Any, Any, Any]]]: ...
+@overload
+def iscoroutinefunction(obj: Callable[..., Coroutine[Any, Any, Any]]) -> bool: ...
+@overload
+def iscoroutinefunction(obj: Callable[_P, Awaitable[_T]]) -> TypeGuard[Callable[_P, CoroutineType[Any, Any, _T]]]: ...
+@overload
+def iscoroutinefunction(obj: Callable[_P, object]) -> TypeGuard[Callable[_P, CoroutineType[Any, Any, Any]]]: ...
+@overload
+def iscoroutinefunction(obj: object) -> TypeGuard[Callable[..., CoroutineType[Any, Any, Any]]]: ...
+def isgenerator(object: object) -> TypeIs[GeneratorType[Any, Any, Any]]: ...
+def iscoroutine(object: object) -> TypeIs[CoroutineType[Any, Any, Any]]: ...
+def isawaitable(object: object) -> TypeIs[Awaitable[Any]]: ...
+@overload
+def isasyncgenfunction(obj: Callable[..., AsyncGenerator[Any, Any]]) -> bool: ...
+@overload
+def isasyncgenfunction(obj: Callable[_P, Any]) -> TypeGuard[Callable[_P, AsyncGeneratorType[Any, Any]]]: ...
+@overload
+def isasyncgenfunction(obj: object) -> TypeGuard[Callable[..., AsyncGeneratorType[Any, Any]]]: ...
 
-class _SupportsSet(Protocol[_T_cont, _V_cont]):
-    def __set__(self, __instance: _T_cont, __value: _V_cont) -> None: ...
+class _SupportsSet(Protocol[_T_contra, _V_contra]):
+    def __set__(self, instance: _T_contra, value: _V_contra, /) -> None: ...
 
-class _SupportsDelete(Protocol[_T_cont]):
-    def __delete__(self, __instance: _T_cont) -> None: ...
+class _SupportsDelete(Protocol[_T_contra]):
+    def __delete__(self, instance: _T_contra, /) -> None: ...
 
-def isasyncgen(object: object) -> TypeGuard[AsyncGeneratorType[Any, Any]]: ...
-def istraceback(object: object) -> TypeGuard[TracebackType]: ...
-def isframe(object: object) -> TypeGuard[FrameType]: ...
-def iscode(object: object) -> TypeGuard[CodeType]: ...
-def isbuiltin(object: object) -> TypeGuard[BuiltinFunctionType]: ...
+def isasyncgen(object: object) -> TypeIs[AsyncGeneratorType[Any, Any]]: ...
+def istraceback(object: object) -> TypeIs[TracebackType]: ...
+def isframe(object: object) -> TypeIs[FrameType]: ...
+def iscode(object: object) -> TypeIs[CodeType]: ...
+def isbuiltin(object: object) -> TypeIs[BuiltinFunctionType]: ...
 
 if sys.version_info >= (3, 11):
-    def ismethodwrapper(object: object) -> TypeGuard[MethodWrapperType]: ...
+    def ismethodwrapper(object: object) -> TypeIs[MethodWrapperType]: ...
 
 def isroutine(
     object: object,
-) -> TypeGuard[
+) -> TypeIs[
     FunctionType
     | LambdaType
     | MethodType
@@ -262,11 +255,11 @@ def isroutine(
     | MethodDescriptorType
     | ClassMethodDescriptorType
 ]: ...
-def ismethoddescriptor(object: object) -> TypeGuard[MethodDescriptorType]: ...
-def ismemberdescriptor(object: object) -> TypeGuard[MemberDescriptorType]: ...
+def ismethoddescriptor(object: object) -> TypeIs[MethodDescriptorType]: ...
+def ismemberdescriptor(object: object) -> TypeIs[MemberDescriptorType]: ...
 def isabstract(object: object) -> bool: ...
-def isgetsetdescriptor(object: object) -> TypeGuard[GetSetDescriptorType]: ...
-def isdatadescriptor(object: object) -> TypeGuard[_SupportsSet[Any, Any] | _SupportsDelete[Any]]: ...
+def isgetsetdescriptor(object: object) -> TypeIs[GetSetDescriptorType]: ...
+def isdatadescriptor(object: object) -> TypeIs[_SupportsSet[Any, Any] | _SupportsDelete[Any]]: ...
 
 #
 # Retrieving source code
@@ -277,6 +270,14 @@ _SourceObjectType: TypeAlias = (
 
 def findsource(object: _SourceObjectType) -> tuple[list[str], int]: ...
 def getabsfile(object: _SourceObjectType, _filename: str | None = None) -> str: ...
+
+# Special-case the two most common input types here
+# to avoid the annoyingly vague `Sequence[str]` return type
+@overload
+def getblock(lines: list[str]) -> list[str]: ...
+@overload
+def getblock(lines: tuple[str, ...]) -> tuple[str, ...]: ...
+@overload
 def getblock(lines: Sequence[str]) -> Sequence[str]: ...
 def getdoc(object: object) -> str | None: ...
 def getcomments(object: object) -> str | None: ...
@@ -321,6 +322,7 @@ class Signature:
     def bind(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
     def bind_partial(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
     def replace(self, *, parameters: Sequence[Parameter] | type[_void] | None = ..., return_annotation: Any = ...) -> Self: ...
+    __replace__ = replace
     if sys.version_info >= (3, 10):
         @classmethod
         def from_callable(
@@ -335,29 +337,42 @@ class Signature:
     else:
         @classmethod
         def from_callable(cls, obj: _IntrospectableCallable, *, follow_wrapped: bool = True) -> Self: ...
+    if sys.version_info >= (3, 13):
+        def format(self, *, max_width: int | None = None) -> str: ...
 
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
 
 if sys.version_info >= (3, 10):
     def get_annotations(
-        obj: Callable[..., object] | type[Any] | ModuleType,
+        obj: Callable[..., object] | type[object] | ModuleType,  # any callable, class, or module
         *,
-        globals: Mapping[str, Any] | None = None,
-        locals: Mapping[str, Any] | None = None,
+        globals: Mapping[str, Any] | None = None,  # value types depend on the key
+        locals: Mapping[str, Any] | None = None,  # value types depend on the key
         eval_str: bool = False,
-    ) -> dict[str, Any]: ...
+    ) -> dict[str, Any]: ...  # values are type expressions
 
 # The name is the same as the enum's name in CPython
 class _ParameterKind(enum.IntEnum):
-    POSITIONAL_ONLY: int
-    POSITIONAL_OR_KEYWORD: int
-    VAR_POSITIONAL: int
-    KEYWORD_ONLY: int
-    VAR_KEYWORD: int
+    POSITIONAL_ONLY = 0
+    POSITIONAL_OR_KEYWORD = 1
+    VAR_POSITIONAL = 2
+    KEYWORD_ONLY = 3
+    VAR_KEYWORD = 4
+
+    @property
+    def description(self) -> str: ...
+
+if sys.version_info >= (3, 12):
+    AGEN_CREATED: Final = "AGEN_CREATED"
+    AGEN_RUNNING: Final = "AGEN_RUNNING"
+    AGEN_SUSPENDED: Final = "AGEN_SUSPENDED"
+    AGEN_CLOSED: Final = "AGEN_CLOSED"
 
-    if sys.version_info >= (3, 8):
-        @property
-        def description(self) -> str: ...
+    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: ...
@@ -384,7 +399,11 @@ class Parameter:
         default: Any = ...,
         annotation: Any = ...,
     ) -> Self: ...
+    if sys.version_info >= (3, 13):
+        __replace__ = replace
+
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
 
 class BoundArguments:
     arguments: OrderedDict[str, Any]
@@ -397,16 +416,16 @@ class BoundArguments:
     def __init__(self, signature: Signature, arguments: OrderedDict[str, Any]) -> None: ...
     def apply_defaults(self) -> None: ...
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 #
 # Classes and functions
 #
 
-# TODO: The actual return type should be list[_ClassTreeItem] but mypy doesn't
-# seem to be supporting this at the moment:
-# _ClassTreeItem = list[_ClassTreeItem] | Tuple[type, Tuple[type, ...]]
-def getclasstree(classes: list[type], unique: bool = False) -> list[Any]: ...
-def walktree(classes: list[type], children: Mapping[type[Any], list[type]], parent: type[Any] | None) -> list[Any]: ...
+_ClassTreeItem: TypeAlias = list[tuple[type, ...]] | list[_ClassTreeItem]
+
+def getclasstree(classes: list[type], unique: bool = False) -> _ClassTreeItem: ...
+def walktree(classes: list[type], children: Mapping[type[Any], list[type]], parent: type[Any] | None) -> _ClassTreeItem: ...
 
 class Arguments(NamedTuple):
     args: list[str]
@@ -421,6 +440,7 @@ if sys.version_info < (3, 11):
         varargs: str | None
         keywords: str | None
         defaults: tuple[Any, ...]
+
     def getargspec(func: object) -> ArgSpec: ...
 
 class FullArgSpec(NamedTuple):
@@ -472,7 +492,7 @@ def formatargvalues(
     formatvalue: Callable[[Any], str] | None = ...,
 ) -> str: ...
 def getmro(cls: type) -> tuple[type, ...]: ...
-def getcallargs(__func: Callable[_P, Any], *args: _P.args, **kwds: _P.kwargs) -> dict[str, Any]: ...
+def getcallargs(func: Callable[_P, Any], /, *args: _P.args, **kwds: _P.kwargs) -> dict[str, Any]: ...
 
 class ClosureVars(NamedTuple):
     nonlocals: Mapping[str, Any]
@@ -564,22 +584,22 @@ def getattr_static(obj: object, attr: str, default: Any | None = ...) -> Any: ..
 # Current State of Generators and Coroutines
 #
 
-GEN_CREATED: Literal["GEN_CREATED"]
-GEN_RUNNING: Literal["GEN_RUNNING"]
-GEN_SUSPENDED: Literal["GEN_SUSPENDED"]
-GEN_CLOSED: Literal["GEN_CLOSED"]
+GEN_CREATED: Final = "GEN_CREATED"
+GEN_RUNNING: Final = "GEN_RUNNING"
+GEN_SUSPENDED: Final = "GEN_SUSPENDED"
+GEN_CLOSED: Final = "GEN_CLOSED"
 
 def getgeneratorstate(
-    generator: Generator[Any, Any, Any]
+    generator: Generator[Any, Any, Any],
 ) -> Literal["GEN_CREATED", "GEN_RUNNING", "GEN_SUSPENDED", "GEN_CLOSED"]: ...
 
-CORO_CREATED: Literal["CORO_CREATED"]
-CORO_RUNNING: Literal["CORO_RUNNING"]
-CORO_SUSPENDED: Literal["CORO_SUSPENDED"]
-CORO_CLOSED: Literal["CORO_CLOSED"]
+CORO_CREATED: Final = "CORO_CREATED"
+CORO_RUNNING: Final = "CORO_RUNNING"
+CORO_SUSPENDED: Final = "CORO_SUSPENDED"
+CORO_CLOSED: Final = "CORO_CLOSED"
 
 def getcoroutinestate(
-    coroutine: Coroutine[Any, Any, Any]
+    coroutine: Coroutine[Any, Any, Any],
 ) -> Literal["CORO_CREATED", "CORO_RUNNING", "CORO_SUSPENDED", "CORO_CLOSED"]: ...
 def getgeneratorlocals(generator: Generator[Any, Any, Any]) -> dict[str, Any]: ...
 def getcoroutinelocals(coroutine: Coroutine[Any, Any, Any]) -> dict[str, Any]: ...
@@ -601,22 +621,22 @@ if sys.version_info >= (3, 9):
 
 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
+        SIMPLE = 0
+        WRITABLE = 1
+        FORMAT = 4
+        ND = 8
+        STRIDES = 24
+        C_CONTIGUOUS = 56
+        F_CONTIGUOUS = 88
+        ANY_CONTIGUOUS = 152
+        INDIRECT = 280
+        CONTIG = 9
+        CONTIG_RO = 8
+        STRIDED = 25
+        STRIDED_RO = 24
+        RECORDS = 29
+        RECORDS_RO = 28
+        FULL = 285
+        FULL_RO = 284
+        READ = 256
+        WRITE = 512
diff --git a/mypy/typeshed/stdlib/io.pyi b/mypy/typeshed/stdlib/io.pyi
index c114f839594f..5c26cb245a2f 100644
--- a/mypy/typeshed/stdlib/io.pyi
+++ b/mypy/typeshed/stdlib/io.pyi
@@ -1,17 +1,31 @@
 import abc
-import builtins
-import codecs
 import sys
-from _typeshed import FileDescriptorOrPath, ReadableBuffer, WriteableBuffer
-from collections.abc import Callable, Iterable, Iterator
-from os import _Opener
-from types import TracebackType
-from typing import IO, Any, BinaryIO, TextIO
-from typing_extensions import Literal, Self
+from _io import (
+    DEFAULT_BUFFER_SIZE as DEFAULT_BUFFER_SIZE,
+    BlockingIOError as BlockingIOError,
+    BufferedRandom as BufferedRandom,
+    BufferedReader as BufferedReader,
+    BufferedRWPair as BufferedRWPair,
+    BufferedWriter as BufferedWriter,
+    BytesIO as BytesIO,
+    FileIO as FileIO,
+    IncrementalNewlineDecoder as IncrementalNewlineDecoder,
+    StringIO as StringIO,
+    TextIOWrapper as TextIOWrapper,
+    _BufferedIOBase,
+    _IOBase,
+    _RawIOBase,
+    _TextIOBase,
+    _WrappedBuffer as _WrappedBuffer,  # used elsewhere in typeshed
+    open as open,
+    open_code as open_code,
+)
+from typing import Final
 
 __all__ = [
     "BlockingIOError",
     "open",
+    "open_code",
     "IOBase",
     "RawIOBase",
     "FileIO",
@@ -30,167 +44,17 @@ __all__ = [
     "SEEK_END",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["open_code"]
+if sys.version_info >= (3, 11):
+    from _io import text_encoding as text_encoding
 
-DEFAULT_BUFFER_SIZE: Literal[8192]
+    __all__ += ["DEFAULT_BUFFER_SIZE", "IncrementalNewlineDecoder", "text_encoding"]
 
-SEEK_SET: Literal[0]
-SEEK_CUR: Literal[1]
-SEEK_END: Literal[2]
-
-open = builtins.open
-
-if sys.version_info >= (3, 8):
-    def open_code(path: str) -> IO[bytes]: ...
-
-BlockingIOError = builtins.BlockingIOError
+SEEK_SET: Final = 0
+SEEK_CUR: Final = 1
+SEEK_END: Final = 2
 
 class UnsupportedOperation(OSError, ValueError): ...
-
-class IOBase(metaclass=abc.ABCMeta):
-    def __iter__(self) -> Iterator[bytes]: ...
-    def __next__(self) -> bytes: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> None: ...
-    def close(self) -> None: ...
-    def fileno(self) -> int: ...
-    def flush(self) -> None: ...
-    def isatty(self) -> bool: ...
-    def readable(self) -> bool: ...
-    read: Callable[..., Any]
-    def readlines(self, __hint: int = -1) -> list[bytes]: ...
-    def seek(self, __offset: int, __whence: int = ...) -> int: ...
-    def seekable(self) -> bool: ...
-    def tell(self) -> int: ...
-    def truncate(self, __size: int | None = ...) -> int: ...
-    def writable(self) -> bool: ...
-    write: Callable[..., Any]
-    def writelines(self, __lines: Iterable[ReadableBuffer]) -> None: ...
-    def readline(self, __size: int | None = -1) -> bytes: ...
-    def __del__(self) -> None: ...
-    @property
-    def closed(self) -> bool: ...
-    def _checkClosed(self, msg: str | None = ...) -> None: ...  # undocumented
-
-class RawIOBase(IOBase):
-    def readall(self) -> bytes: ...
-    def readinto(self, __buffer: WriteableBuffer) -> int | None: ...
-    def write(self, __b: ReadableBuffer) -> int | None: ...
-    def read(self, __size: int = -1) -> bytes | None: ...
-
-class BufferedIOBase(IOBase):
-    raw: RawIOBase  # This is not part of the BufferedIOBase API and may not exist on some implementations.
-    def detach(self) -> RawIOBase: ...
-    def readinto(self, __buffer: WriteableBuffer) -> int: ...
-    def write(self, __buffer: ReadableBuffer) -> int: ...
-    def readinto1(self, __buffer: WriteableBuffer) -> int: ...
-    def read(self, __size: int | None = ...) -> bytes: ...
-    def read1(self, __size: int = ...) -> bytes: ...
-
-class FileIO(RawIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
-    mode: str
-    name: FileDescriptorOrPath  # type: ignore[assignment]
-    def __init__(
-        self, file: FileDescriptorOrPath, mode: str = ..., closefd: bool = ..., opener: _Opener | None = ...
-    ) -> None: ...
-    @property
-    def closefd(self) -> bool: ...
-    def write(self, __b: ReadableBuffer) -> int: ...
-    def read(self, __size: int = -1) -> bytes: ...
-    def __enter__(self) -> Self: ...
-
-class BytesIO(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
-    def __init__(self, initial_bytes: ReadableBuffer = ...) -> None: ...
-    # BytesIO does not contain a "name" field. This workaround is necessary
-    # to allow BytesIO sub-classes to add this field, as it is defined
-    # as a read-only property on IO[].
-    name: Any
-    def __enter__(self) -> Self: ...
-    def getvalue(self) -> bytes: ...
-    def getbuffer(self) -> memoryview: ...
-    def read1(self, __size: int | None = -1) -> bytes: ...
-
-class BufferedReader(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
-    def __enter__(self) -> Self: ...
-    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
-    def peek(self, __size: int = 0) -> bytes: ...
-
-class BufferedWriter(BufferedIOBase, BinaryIO):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
-    def __enter__(self) -> Self: ...
-    def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ...
-    def write(self, __buffer: ReadableBuffer) -> int: ...
-
-class BufferedRandom(BufferedReader, BufferedWriter):  # type: ignore[misc]  # incompatible definitions of methods in the base classes
-    def __enter__(self) -> Self: ...
-    def seek(self, __target: int, __whence: int = 0) -> int: ...  # stubtest needs this
-
-class BufferedRWPair(BufferedIOBase):
-    def __init__(self, reader: RawIOBase, writer: RawIOBase, buffer_size: int = ...) -> None: ...
-    def peek(self, __size: int = ...) -> bytes: ...
-
-class TextIOBase(IOBase):
-    encoding: str
-    errors: str | None
-    newlines: str | tuple[str, ...] | None
-    def __iter__(self) -> Iterator[str]: ...  # type: ignore[override]
-    def __next__(self) -> str: ...  # type: ignore[override]
-    def detach(self) -> BinaryIO: ...
-    def write(self, __s: str) -> int: ...
-    def writelines(self, __lines: Iterable[str]) -> None: ...  # type: ignore[override]
-    def readline(self, __size: int = ...) -> str: ...  # type: ignore[override]
-    def readlines(self, __hint: int = -1) -> list[str]: ...  # type: ignore[override]
-    def read(self, __size: int | None = ...) -> str: ...
-
-class TextIOWrapper(TextIOBase, TextIO):  # type: ignore[misc]  # incompatible definitions of write in the base classes
-    def __init__(
-        self,
-        buffer: IO[bytes],
-        encoding: str | None = ...,
-        errors: str | None = ...,
-        newline: str | None = ...,
-        line_buffering: bool = ...,
-        write_through: bool = ...,
-    ) -> None: ...
-    @property
-    def buffer(self) -> BinaryIO: ...
-    @property
-    def closed(self) -> bool: ...
-    @property
-    def line_buffering(self) -> bool: ...
-    @property
-    def write_through(self) -> bool: ...
-    def reconfigure(
-        self,
-        *,
-        encoding: str | None = None,
-        errors: str | None = None,
-        newline: str | None = None,
-        line_buffering: bool | None = None,
-        write_through: bool | None = None,
-    ) -> None: ...
-    # These are inherited from TextIOBase, but must exist in the stub to satisfy mypy.
-    def __enter__(self) -> Self: ...
-    def __iter__(self) -> Iterator[str]: ...  # type: ignore[override]
-    def __next__(self) -> str: ...  # type: ignore[override]
-    def writelines(self, __lines: Iterable[str]) -> None: ...  # type: ignore[override]
-    def readline(self, __size: int = -1) -> str: ...  # type: ignore[override]
-    def readlines(self, __hint: int = -1) -> list[str]: ...  # type: ignore[override]
-    def seek(self, __cookie: int, __whence: int = 0) -> int: ...  # stubtest needs this
-
-class StringIO(TextIOWrapper):
-    def __init__(self, initial_value: str | None = ..., newline: str | None = ...) -> None: ...
-    # StringIO does not contain a "name" field. This workaround is necessary
-    # to allow StringIO sub-classes to add this field, as it is defined
-    # as a read-only property on IO[].
-    name: Any
-    def getvalue(self) -> str: ...
-
-class IncrementalNewlineDecoder(codecs.IncrementalDecoder):
-    def __init__(self, decoder: codecs.IncrementalDecoder | None, translate: bool, errors: str = ...) -> None: ...
-    def decode(self, input: ReadableBuffer | str, final: bool = False) -> str: ...
-    @property
-    def newlines(self) -> str | tuple[str, ...] | None: ...
-    def setstate(self, __state: tuple[bytes, int]) -> None: ...
+class IOBase(_IOBase, metaclass=abc.ABCMeta): ...
+class RawIOBase(_RawIOBase, IOBase): ...
+class BufferedIOBase(_BufferedIOBase, IOBase): ...
+class TextIOBase(_TextIOBase, IOBase): ...
diff --git a/mypy/typeshed/stdlib/ipaddress.pyi b/mypy/typeshed/stdlib/ipaddress.pyi
index 7a4146885b29..e8e81abc6f79 100644
--- a/mypy/typeshed/stdlib/ipaddress.pyi
+++ b/mypy/typeshed/stdlib/ipaddress.pyi
@@ -1,11 +1,11 @@
 import sys
-from collections.abc import Container, Iterable, Iterator
-from typing import Any, Generic, SupportsInt, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias
+from collections.abc import Iterable, Iterator
+from typing import Any, Final, Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
 # Undocumented length constants
-IPV4LENGTH: Literal[32]
-IPV6LENGTH: Literal[128]
+IPV4LENGTH: Final = 32
+IPV6LENGTH: Final = 128
 
 _A = TypeVar("_A", IPv4Address, IPv6Address)
 _N = TypeVar("_N", IPv4Network, IPv6Network)
@@ -18,7 +18,7 @@ def ip_network(
     address: _RawIPAddress | _RawNetworkPart | tuple[_RawIPAddress] | tuple[_RawIPAddress, int], strict: bool = True
 ) -> IPv4Network | IPv6Network: ...
 def ip_interface(
-    address: _RawIPAddress | _RawNetworkPart | tuple[_RawIPAddress] | tuple[_RawIPAddress, int]
+    address: _RawIPAddress | _RawNetworkPart | tuple[_RawIPAddress] | tuple[_RawIPAddress, int],
 ) -> IPv4Interface | IPv6Interface: ...
 
 class _IPAddressBase:
@@ -31,9 +31,9 @@ class _IPAddressBase:
     @property
     def version(self) -> int: ...
 
-class _BaseAddress(_IPAddressBase, SupportsInt):
-    def __init__(self, address: object) -> None: ...
+class _BaseAddress(_IPAddressBase):
     def __add__(self, other: int) -> Self: ...
+    def __hash__(self) -> int: ...
     def __int__(self) -> int: ...
     def __sub__(self, other: int) -> Self: ...
     if sys.version_info >= (3, 9):
@@ -50,33 +50,14 @@ class _BaseAddress(_IPAddressBase, SupportsInt):
         def __gt__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
         def __le__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
 
-    @property
-    def is_global(self) -> bool: ...
-    @property
-    def is_link_local(self) -> bool: ...
-    @property
-    def is_loopback(self) -> bool: ...
-    @property
-    def is_multicast(self) -> bool: ...
-    @property
-    def is_private(self) -> bool: ...
-    @property
-    def is_reserved(self) -> bool: ...
-    @property
-    def is_unspecified(self) -> bool: ...
-    @property
-    def max_prefixlen(self) -> int: ...
-    @property
-    def packed(self) -> bytes: ...
-
-class _BaseNetwork(_IPAddressBase, Container[_A], Iterable[_A], Generic[_A]):
+class _BaseNetwork(_IPAddressBase, Generic[_A]):
     network_address: _A
     netmask: _A
-    def __init__(self, address: object, strict: bool = ...) -> None: ...
     def __contains__(self, other: Any) -> bool: ...
     def __getitem__(self, n: int) -> _A: ...
     def __iter__(self) -> Iterator[_A]: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
     def __lt__(self, other: Self) -> bool: ...
     if sys.version_info >= (3, 11):
         def __ge__(self, other: Self) -> bool: ...
@@ -107,8 +88,6 @@ class _BaseNetwork(_IPAddressBase, Container[_A], Iterable[_A], Generic[_A]):
     @property
     def is_unspecified(self) -> bool: ...
     @property
-    def max_prefixlen(self) -> int: ...
-    @property
     def num_addresses(self) -> int: ...
     def overlaps(self, other: _BaseNetwork[IPv4Address] | _BaseNetwork[IPv6Address]) -> bool: ...
     @property
@@ -126,28 +105,52 @@ class _BaseNetwork(_IPAddressBase, Container[_A], Iterable[_A], Generic[_A]):
     @property
     def hostmask(self) -> _A: ...
 
-class _BaseInterface(_BaseAddress, Generic[_A, _N]):
-    hostmask: _A
-    netmask: _A
-    network: _N
+class _BaseV4:
     @property
-    def ip(self) -> _A: ...
+    def version(self) -> Literal[4]: ...
     @property
-    def with_hostmask(self) -> str: ...
+    def max_prefixlen(self) -> Literal[32]: ...
+
+class IPv4Address(_BaseV4, _BaseAddress):
+    def __init__(self, address: object) -> None: ...
     @property
-    def with_netmask(self) -> str: ...
+    def is_global(self) -> bool: ...
     @property
-    def with_prefixlen(self) -> str: ...
-
-class _BaseV4:
+    def is_link_local(self) -> bool: ...
     @property
-    def version(self) -> Literal[4]: ...
+    def is_loopback(self) -> bool: ...
     @property
-    def max_prefixlen(self) -> Literal[32]: ...
+    def is_multicast(self) -> bool: ...
+    @property
+    def is_private(self) -> bool: ...
+    @property
+    def is_reserved(self) -> bool: ...
+    @property
+    def is_unspecified(self) -> bool: ...
+    @property
+    def packed(self) -> bytes: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def ipv6_mapped(self) -> IPv6Address: ...
 
-class IPv4Address(_BaseV4, _BaseAddress): ...
-class IPv4Network(_BaseV4, _BaseNetwork[IPv4Address]): ...
-class IPv4Interface(IPv4Address, _BaseInterface[IPv4Address, IPv4Network]): ...
+class IPv4Network(_BaseV4, _BaseNetwork[IPv4Address]):
+    def __init__(self, address: object, strict: bool = ...) -> None: ...
+
+class IPv4Interface(IPv4Address):
+    netmask: IPv4Address
+    network: IPv4Network
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    @property
+    def hostmask(self) -> IPv4Address: ...
+    @property
+    def ip(self) -> IPv4Address: ...
+    @property
+    def with_hostmask(self) -> str: ...
+    @property
+    def with_netmask(self) -> str: ...
+    @property
+    def with_prefixlen(self) -> str: ...
 
 class _BaseV6:
     @property
@@ -156,6 +159,23 @@ class _BaseV6:
     def max_prefixlen(self) -> Literal[128]: ...
 
 class IPv6Address(_BaseV6, _BaseAddress):
+    def __init__(self, address: object) -> None: ...
+    @property
+    def is_global(self) -> bool: ...
+    @property
+    def is_link_local(self) -> bool: ...
+    @property
+    def is_loopback(self) -> bool: ...
+    @property
+    def is_multicast(self) -> bool: ...
+    @property
+    def is_private(self) -> bool: ...
+    @property
+    def is_reserved(self) -> bool: ...
+    @property
+    def is_unspecified(self) -> bool: ...
+    @property
+    def packed(self) -> bytes: ...
     @property
     def ipv4_mapped(self) -> IPv4Address | None: ...
     @property
@@ -168,11 +188,29 @@ class IPv6Address(_BaseV6, _BaseAddress):
         @property
         def scope_id(self) -> str | None: ...
 
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+
 class IPv6Network(_BaseV6, _BaseNetwork[IPv6Address]):
+    def __init__(self, address: object, strict: bool = ...) -> None: ...
     @property
     def is_site_local(self) -> bool: ...
 
-class IPv6Interface(IPv6Address, _BaseInterface[IPv6Address, IPv6Network]): ...
+class IPv6Interface(IPv6Address):
+    netmask: IPv6Address
+    network: IPv6Network
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    @property
+    def hostmask(self) -> IPv6Address: ...
+    @property
+    def ip(self) -> IPv6Address: ...
+    @property
+    def with_hostmask(self) -> str: ...
+    @property
+    def with_netmask(self) -> str: ...
+    @property
+    def with_prefixlen(self) -> str: ...
 
 def v4_int_to_packed(address: int) -> bytes: ...
 def v6_int_to_packed(address: int) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/itertools.pyi b/mypy/typeshed/stdlib/itertools.pyi
index 4b5d624c78d7..675533d44a68 100644
--- a/mypy/typeshed/stdlib/itertools.pyi
+++ b/mypy/typeshed/stdlib/itertools.pyi
@@ -1,7 +1,8 @@
 import sys
+from _typeshed import MaybeNone
 from collections.abc import Callable, Iterable, Iterator
-from typing import Any, Generic, SupportsComplex, SupportsFloat, SupportsInt, TypeVar, overload
-from typing_extensions import Literal, Self, SupportsIndex, TypeAlias
+from typing import Any, Generic, Literal, SupportsComplex, SupportsFloat, SupportsIndex, SupportsInt, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -10,12 +11,17 @@ _T = TypeVar("_T")
 _S = TypeVar("_S")
 _N = TypeVar("_N", int, float, SupportsFloat, SupportsInt, SupportsIndex, SupportsComplex)
 _T_co = TypeVar("_T_co", covariant=True)
+_S_co = TypeVar("_S_co", covariant=True)
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
 _T3 = TypeVar("_T3")
 _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
 _T6 = TypeVar("_T6")
+_T7 = TypeVar("_T7")
+_T8 = TypeVar("_T8")
+_T9 = TypeVar("_T9")
+_T10 = TypeVar("_T10")
 
 _Step: TypeAlias = SupportsFloat | SupportsInt | SupportsIndex | SupportsComplex
 
@@ -23,7 +29,7 @@ _Predicate: TypeAlias = Callable[[_T], object]
 
 # Technically count can take anything that implements a number protocol and has an add method
 # but we can't enforce the add method
-class count(Iterator[_N], Generic[_N]):
+class count(Iterator[_N]):
     @overload
     def __new__(cls) -> count[int]: ...
     @overload
@@ -33,135 +39,127 @@ class count(Iterator[_N], Generic[_N]):
     def __next__(self) -> _N: ...
     def __iter__(self) -> Self: ...
 
-class cycle(Iterator[_T], Generic[_T]):
-    def __init__(self, __iterable: Iterable[_T]) -> None: ...
+class cycle(Iterator[_T]):
+    def __new__(cls, iterable: Iterable[_T], /) -> Self: ...
     def __next__(self) -> _T: ...
     def __iter__(self) -> Self: ...
 
-class repeat(Iterator[_T], Generic[_T]):
+class repeat(Iterator[_T]):
     @overload
-    def __init__(self, object: _T) -> None: ...
+    def __new__(cls, object: _T) -> Self: ...
     @overload
-    def __init__(self, object: _T, times: int) -> None: ...
+    def __new__(cls, object: _T, times: int) -> Self: ...
     def __next__(self) -> _T: ...
     def __iter__(self) -> Self: ...
     def __length_hint__(self) -> int: ...
 
-class accumulate(Iterator[_T], Generic[_T]):
-    if sys.version_info >= (3, 8):
-        @overload
-        def __init__(self, iterable: Iterable[_T], func: None = None, *, initial: _T | None = ...) -> None: ...
-        @overload
-        def __init__(self, iterable: Iterable[_S], func: Callable[[_T, _S], _T], *, initial: _T | None = ...) -> None: ...
-    else:
-        def __init__(self, iterable: Iterable[_T], func: Callable[[_T, _T], _T] | None = ...) -> None: ...
-
+class accumulate(Iterator[_T]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], func: None = None, *, initial: _T | None = ...) -> Self: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_S], func: Callable[[_T, _S], _T], *, initial: _T | None = ...) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class chain(Iterator[_T], Generic[_T]):
-    def __init__(self, *iterables: Iterable[_T]) -> None: ...
+class chain(Iterator[_T]):
+    def __new__(cls, *iterables: Iterable[_T]) -> Self: ...
     def __next__(self) -> _T: ...
     def __iter__(self) -> Self: ...
     @classmethod
     # We use type[Any] and not type[_S] to not lose the type inference from __iterable
-    def from_iterable(cls: type[Any], __iterable: Iterable[Iterable[_S]]) -> chain[_S]: ...
+    def from_iterable(cls: type[Any], iterable: Iterable[Iterable[_S]], /) -> chain[_S]: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class compress(Iterator[_T], Generic[_T]):
-    def __init__(self, data: Iterable[_T], selectors: Iterable[Any]) -> None: ...
+class compress(Iterator[_T]):
+    def __new__(cls, data: Iterable[_T], selectors: Iterable[Any]) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class dropwhile(Iterator[_T], Generic[_T]):
-    def __init__(self, __predicate: _Predicate[_T], __iterable: Iterable[_T]) -> None: ...
+class dropwhile(Iterator[_T]):
+    def __new__(cls, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class filterfalse(Iterator[_T], Generic[_T]):
-    def __init__(self, __predicate: _Predicate[_T] | None, __iterable: Iterable[_T]) -> None: ...
+class filterfalse(Iterator[_T]):
+    def __new__(cls, function: _Predicate[_T] | None, iterable: Iterable[_T], /) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class groupby(Iterator[tuple[_T, Iterator[_S]]], Generic[_T, _S]):
+class groupby(Iterator[tuple[_T_co, Iterator[_S_co]]], Generic[_T_co, _S_co]):
     @overload
     def __new__(cls, iterable: Iterable[_T1], key: None = None) -> groupby[_T1, _T1]: ...
     @overload
     def __new__(cls, iterable: Iterable[_T1], key: Callable[[_T1], _T2]) -> groupby[_T2, _T1]: ...
     def __iter__(self) -> Self: ...
-    def __next__(self) -> tuple[_T, Iterator[_S]]: ...
+    def __next__(self) -> tuple[_T_co, Iterator[_S_co]]: ...
 
-class islice(Iterator[_T], Generic[_T]):
+class islice(Iterator[_T]):
     @overload
-    def __init__(self, __iterable: Iterable[_T], __stop: int | None) -> None: ...
+    def __new__(cls, iterable: Iterable[_T], stop: int | None, /) -> Self: ...
     @overload
-    def __init__(self, __iterable: Iterable[_T], __start: int | None, __stop: int | None, __step: int | None = ...) -> None: ...
+    def __new__(cls, iterable: Iterable[_T], start: int | None, stop: int | None, step: int | None = ..., /) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class starmap(Iterator[_T], Generic[_T]):
-    def __init__(self, __function: Callable[..., _T], __iterable: Iterable[Iterable[Any]]) -> None: ...
+class starmap(Iterator[_T_co]):
+    def __new__(cls, function: Callable[..., _T], iterable: Iterable[Iterable[Any]], /) -> starmap[_T]: ...
     def __iter__(self) -> Self: ...
-    def __next__(self) -> _T: ...
+    def __next__(self) -> _T_co: ...
 
-class takewhile(Iterator[_T], Generic[_T]):
-    def __init__(self, __predicate: _Predicate[_T], __iterable: Iterable[_T]) -> None: ...
+class takewhile(Iterator[_T]):
+    def __new__(cls, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> Self: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-def tee(__iterable: Iterable[_T], __n: int = 2) -> tuple[Iterator[_T], ...]: ...
+def tee(iterable: Iterable[_T], n: int = 2, /) -> tuple[Iterator[_T], ...]: ...
 
-class zip_longest(Iterator[_T_co], Generic[_T_co]):
+class zip_longest(Iterator[_T_co]):
     # one iterable (fillvalue doesn't matter)
     @overload
-    def __new__(cls, __iter1: Iterable[_T1], *, fillvalue: object = ...) -> zip_longest[tuple[_T1]]: ...
+    def __new__(cls, iter1: Iterable[_T1], /, *, fillvalue: object = ...) -> zip_longest[tuple[_T1]]: ...
     # two iterables
     @overload
     # In the overloads without fillvalue, all of the tuple members could theoretically be None,
     # but we return Any instead to avoid false positives for code where we know one of the iterables
     # is longer.
-    def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> zip_longest[tuple[_T1 | Any, _T2 | Any]]: ...
+    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone]]: ...
     @overload
     def __new__(
-        cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], *, fillvalue: _T
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /, *, fillvalue: _T
     ) -> zip_longest[tuple[_T1 | _T, _T2 | _T]]: ...
     # three iterables
     @overload
     def __new__(
-        cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any]]: ...
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone]]: ...
     @overload
     def __new__(
-        cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], *, fillvalue: _T
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /, *, fillvalue: _T
     ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T]]: ...
     # four iterables
     @overload
     def __new__(
-        cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4]
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any]]: ...
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone, _T4 | MaybeNone]]: ...
     @overload
     def __new__(
-        cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], *, fillvalue: _T
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /, *, fillvalue: _T
     ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T]]: ...
     # five iterables
     @overload
     def __new__(
-        cls,
-        __iter1: Iterable[_T1],
-        __iter2: Iterable[_T2],
-        __iter3: Iterable[_T3],
-        __iter4: Iterable[_T4],
-        __iter5: Iterable[_T5],
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any, _T5 | Any]]: ...
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone, _T4 | MaybeNone, _T5 | MaybeNone]]: ...
     @overload
     def __new__(
         cls,
-        __iter1: Iterable[_T1],
-        __iter2: Iterable[_T2],
-        __iter3: Iterable[_T3],
-        __iter4: Iterable[_T4],
-        __iter5: Iterable[_T5],
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        /,
         *,
         fillvalue: _T,
     ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T, _T5 | _T]]: ...
@@ -169,84 +167,131 @@ class zip_longest(Iterator[_T_co], Generic[_T_co]):
     @overload
     def __new__(
         cls,
-        __iter1: Iterable[_T],
-        __iter2: Iterable[_T],
-        __iter3: Iterable[_T],
-        __iter4: Iterable[_T],
-        __iter5: Iterable[_T],
-        __iter6: Iterable[_T],
+        iter1: Iterable[_T],
+        iter2: Iterable[_T],
+        iter3: Iterable[_T],
+        iter4: Iterable[_T],
+        iter5: Iterable[_T],
+        iter6: Iterable[_T],
+        /,
         *iterables: Iterable[_T],
-    ) -> zip_longest[tuple[_T | Any, ...]]: ...
+    ) -> zip_longest[tuple[_T | MaybeNone, ...]]: ...
     @overload
     def __new__(
         cls,
-        __iter1: Iterable[_T],
-        __iter2: Iterable[_T],
-        __iter3: Iterable[_T],
-        __iter4: Iterable[_T],
-        __iter5: Iterable[_T],
-        __iter6: Iterable[_T],
+        iter1: Iterable[_T],
+        iter2: Iterable[_T],
+        iter3: Iterable[_T],
+        iter4: Iterable[_T],
+        iter5: Iterable[_T],
+        iter6: Iterable[_T],
+        /,
         *iterables: Iterable[_T],
         fillvalue: _T,
     ) -> zip_longest[tuple[_T, ...]]: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class product(Iterator[_T_co], Generic[_T_co]):
+class product(Iterator[_T_co]):
     @overload
-    def __new__(cls, __iter1: Iterable[_T1]) -> product[tuple[_T1]]: ...
+    def __new__(cls, iter1: Iterable[_T1], /) -> product[tuple[_T1]]: ...
     @overload
-    def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> product[tuple[_T1, _T2]]: ...
+    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> product[tuple[_T1, _T2]]: ...
     @overload
-    def __new__(cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> product[tuple[_T1, _T2, _T3]]: ...
+    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /) -> product[tuple[_T1, _T2, _T3]]: ...
     @overload
     def __new__(
-        cls, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4]
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
     ) -> product[tuple[_T1, _T2, _T3, _T4]]: ...
     @overload
     def __new__(
-        cls,
-        __iter1: Iterable[_T1],
-        __iter2: Iterable[_T2],
-        __iter3: Iterable[_T3],
-        __iter4: Iterable[_T4],
-        __iter5: Iterable[_T5],
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
     ) -> product[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
     @overload
     def __new__(
         cls,
-        __iter1: Iterable[_T1],
-        __iter2: Iterable[_T2],
-        __iter3: Iterable[_T3],
-        __iter4: Iterable[_T4],
-        __iter5: Iterable[_T5],
-        __iter6: Iterable[_T6],
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        /,
     ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
     @overload
     def __new__(
         cls,
-        __iter1: Iterable[Any],
-        __iter2: Iterable[Any],
-        __iter3: Iterable[Any],
-        __iter4: Iterable[Any],
-        __iter5: Iterable[Any],
-        __iter6: Iterable[Any],
-        __iter7: Iterable[Any],
-        *iterables: Iterable[Any],
-    ) -> product[tuple[Any, ...]]: ...
-    @overload
-    def __new__(cls, *iterables: Iterable[_T1], repeat: int) -> product[tuple[_T1, ...]]: ...
-    @overload
-    def __new__(cls, *iterables: Iterable[Any], repeat: int = ...) -> product[tuple[Any, ...]]: ...
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        iter9: Iterable[_T9],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        iter9: Iterable[_T9],
+        iter10: Iterable[_T10],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10]]: ...
+    @overload
+    def __new__(cls, *iterables: Iterable[_T1], repeat: int = 1) -> product[tuple[_T1, ...]]: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class permutations(Iterator[tuple[_T, ...]], Generic[_T]):
-    def __init__(self, iterable: Iterable[_T], r: int | None = ...) -> None: ...
+class permutations(Iterator[_T_co]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> permutations[tuple[_T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> permutations[tuple[_T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> permutations[tuple[_T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> permutations[tuple[_T, _T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: int | None = ...) -> permutations[tuple[_T, ...]]: ...
     def __iter__(self) -> Self: ...
-    def __next__(self) -> tuple[_T, ...]: ...
+    def __next__(self) -> _T_co: ...
 
-class combinations(Iterator[_T_co], Generic[_T_co]):
+class combinations(Iterator[_T_co]):
     @overload
     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ...
     @overload
@@ -260,19 +305,32 @@ class combinations(Iterator[_T_co], Generic[_T_co]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class combinations_with_replacement(Iterator[tuple[_T, ...]], Generic[_T]):
-    def __init__(self, iterable: Iterable[_T], r: int) -> None: ...
+class combinations_with_replacement(Iterator[_T_co]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations_with_replacement[tuple[_T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> combinations_with_replacement[tuple[_T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> combinations_with_replacement[tuple[_T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> combinations_with_replacement[tuple[_T, _T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: int) -> combinations_with_replacement[tuple[_T, ...]]: ...
     def __iter__(self) -> Self: ...
-    def __next__(self) -> tuple[_T, ...]: ...
+    def __next__(self) -> _T_co: ...
 
 if sys.version_info >= (3, 10):
-    class pairwise(Iterator[_T_co], Generic[_T_co]):
-        def __new__(cls, __iterable: Iterable[_T]) -> pairwise[tuple[_T, _T]]: ...
+    class pairwise(Iterator[_T_co]):
+        def __new__(cls, iterable: Iterable[_T], /) -> pairwise[tuple[_T, _T]]: ...
         def __iter__(self) -> Self: ...
         def __next__(self) -> _T_co: ...
 
 if sys.version_info >= (3, 12):
     class batched(Iterator[tuple[_T_co, ...]], Generic[_T_co]):
-        def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
+        if sys.version_info >= (3, 13):
+            def __new__(cls, iterable: Iterable[_T_co], n: int, *, strict: bool = False) -> Self: ...
+        else:
+            def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
+
         def __iter__(self) -> Self: ...
         def __next__(self) -> tuple[_T_co, ...]: ...
diff --git a/mypy/typeshed/stdlib/json/__init__.pyi b/mypy/typeshed/stdlib/json/__init__.pyi
index dc0cdff926d4..63e9718ee151 100644
--- a/mypy/typeshed/stdlib/json/__init__.pyi
+++ b/mypy/typeshed/stdlib/json/__init__.pyi
@@ -1,4 +1,3 @@
-import sys
 from _typeshed import SupportsRead, SupportsWrite
 from collections.abc import Callable
 from typing import Any
@@ -7,8 +6,6 @@ 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,
@@ -62,9 +59,3 @@ 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/json/encoder.pyi b/mypy/typeshed/stdlib/json/encoder.pyi
index 0c0d366eb7a2..83b78666d4a7 100644
--- a/mypy/typeshed/stdlib/json/encoder.pyi
+++ b/mypy/typeshed/stdlib/json/encoder.pyi
@@ -1,15 +1,17 @@
 from collections.abc import Callable, Iterator
 from re import Pattern
-from typing import Any
+from typing import Any, Final
 
-ESCAPE: Pattern[str]
-ESCAPE_ASCII: Pattern[str]
-HAS_UTF8: Pattern[bytes]
-ESCAPE_DCT: dict[str, str]
-INFINITY: float
+ESCAPE: Final[Pattern[str]]  # undocumented
+ESCAPE_ASCII: Final[Pattern[str]]  # undocumented
+HAS_UTF8: Final[Pattern[bytes]]  # undocumented
+ESCAPE_DCT: Final[dict[str, str]]  # undocumented
+INFINITY: Final[float]  # undocumented
 
 def py_encode_basestring(s: str) -> str: ...  # undocumented
 def py_encode_basestring_ascii(s: str) -> str: ...  # undocumented
+def encode_basestring(s: str, /) -> str: ...  # undocumented
+def encode_basestring_ascii(s: str, /) -> str: ...  # undocumented
 
 class JSONEncoder:
     item_separator: str
diff --git a/mypy/typeshed/stdlib/json/scanner.pyi b/mypy/typeshed/stdlib/json/scanner.pyi
new file mode 100644
index 000000000000..68b42e92d295
--- /dev/null
+++ b/mypy/typeshed/stdlib/json/scanner.pyi
@@ -0,0 +1,7 @@
+from _json import make_scanner as make_scanner
+from re import Pattern
+from typing import Final
+
+__all__ = ["make_scanner"]
+
+NUMBER_RE: Final[Pattern[str]]  # undocumented
diff --git a/mypy/typeshed/stdlib/keyword.pyi b/mypy/typeshed/stdlib/keyword.pyi
index 46c386048858..960dfd2fa155 100644
--- a/mypy/typeshed/stdlib/keyword.pyi
+++ b/mypy/typeshed/stdlib/keyword.pyi
@@ -1,20 +1,20 @@
 import sys
 from collections.abc import Sequence
-from typing_extensions import Final
+from typing import Final
 
 if sys.version_info >= (3, 9):
     __all__ = ["iskeyword", "issoftkeyword", "kwlist", "softkwlist"]
 else:
     __all__ = ["iskeyword", "kwlist"]
 
-def iskeyword(s: str) -> bool: ...
+def iskeyword(s: str, /) -> bool: ...
 
 # a list at runtime, but you're not meant to mutate it;
 # type it as a sequence
 kwlist: Final[Sequence[str]]
 
 if sys.version_info >= (3, 9):
-    def issoftkeyword(s: str) -> bool: ...
+    def issoftkeyword(s: str, /) -> bool: ...
 
     # a list at runtime, but you're not meant to mutate it;
     # type it as a sequence
diff --git a/mypy/typeshed/stdlib/lib2to3/fixer_base.pyi b/mypy/typeshed/stdlib/lib2to3/fixer_base.pyi
index eef386f709ac..06813c94308a 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixer_base.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixer_base.pyi
@@ -1,8 +1,7 @@
 from _typeshed import Incomplete, StrPath
 from abc import ABCMeta, abstractmethod
 from collections.abc import MutableMapping
-from typing import ClassVar, TypeVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal, TypeVar
 
 from .pytree import Base, Leaf, Node
 
@@ -39,5 +38,5 @@ class BaseFix:
 
 class ConditionalFix(BaseFix, metaclass=ABCMeta):
     skip_on: ClassVar[str | None]
-    def start_tree(self, __tree: Node, __filename: StrPath) -> None: ...
+    def start_tree(self, tree: Node, filename: StrPath, /) -> None: ...
     def should_skip(self, node: Base) -> bool: ...
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_apply.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_apply.pyi
index 7c5451c15220..e53e3dd86457 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_apply.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_apply.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_asserts.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_asserts.pyi
index bf73009e9dbf..1bf7db2f76e9 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_asserts.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_asserts.pyi
@@ -1,9 +1,8 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Final, Literal
 
 from ..fixer_base import BaseFix
 
-NAMES: dict[str, str]
+NAMES: Final[dict[str, str]]
 
 class FixAsserts(BaseFix):
     BM_compatible: ClassVar[Literal[False]]
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_basestring.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_basestring.pyi
index 84a354d32777..8ed5ccaa7fd3 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_basestring.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_basestring.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_buffer.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_buffer.pyi
index 857c1e2241b9..1efca6228ea2 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_buffer.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_buffer.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_dict.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_dict.pyi
index 2e66911195bf..08c54c3bc376 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_dict.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_dict.pyi
@@ -1,6 +1,5 @@
 from _typeshed import Incomplete
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_except.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_except.pyi
index b87aacd342e9..30930a2c381e 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_except.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_except.pyi
@@ -1,6 +1,5 @@
 from collections.abc import Generator, Iterable
-from typing import ClassVar, TypeVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal, TypeVar
 
 from .. import fixer_base
 from ..pytree import Base
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_exec.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_exec.pyi
index 306937eb9759..71e2a820a564 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_exec.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_exec.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_execfile.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_execfile.pyi
index fb245e5a1c1c..8122a6389b12 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_execfile.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_execfile.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_exitfunc.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_exitfunc.pyi
index 10341d7985a8..7fc910c0a1bc 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_exitfunc.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_exitfunc.pyi
@@ -1,7 +1,6 @@
 from _typeshed import Incomplete, StrPath
 from lib2to3 import fixer_base
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from ..pytree import Node
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_filter.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_filter.pyi
index 3998a1dd001e..638889be8b65 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_filter.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_filter.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_funcattrs.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_funcattrs.pyi
index 59919446ffdd..60487bb1f2a6 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_funcattrs.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_funcattrs.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_future.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_future.pyi
index 8eb5ca35dcc3..12ed93f21223 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_future.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_future.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_getcwdu.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_getcwdu.pyi
index d18a38f69be0..aa3ccf50be9e 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_getcwdu.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_getcwdu.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_has_key.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_has_key.pyi
index 1e6b58dd3512..f6f5a072e21b 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_has_key.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_has_key.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_idioms.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_idioms.pyi
index 8f02252f7bb9..6b2723d09d43 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_idioms.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_idioms.pyi
@@ -1,10 +1,9 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Final, Literal
 
 from .. import fixer_base
 
-CMP: str
-TYPE: str
+CMP: Final[str]
+TYPE: Final[str]
 
 class FixIdioms(fixer_base.BaseFix):
     BM_compatible: ClassVar[Literal[False]]
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_import.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_import.pyi
index 436e7f1915b2..bf4b2d00925e 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_import.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_import.pyi
@@ -1,7 +1,6 @@
 from _typeshed import StrPath
 from collections.abc import Generator
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 from ..pytree import Node
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports.pyi
index 277a172d3af9..c747af529f44 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports.pyi
@@ -1,12 +1,11 @@
 from _typeshed import StrPath
 from collections.abc import Generator
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Final, Literal
 
 from .. import fixer_base
 from ..pytree import Node
 
-MAPPING: dict[str, str]
+MAPPING: Final[dict[str, str]]
 
 def alternates(members): ...
 def build_pattern(mapping=...) -> Generator[str, None, None]: ...
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports2.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports2.pyi
index 8d55433085dd..618ecd0424d8 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports2.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_imports2.pyi
@@ -1,6 +1,8 @@
+from typing import Final
+
 from . import fix_imports
 
-MAPPING: dict[str, str]
+MAPPING: Final[dict[str, str]]
 
 class FixImports2(fix_imports.FixImports):
     mapping = MAPPING
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_input.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_input.pyi
index df52f8d77427..fc1279535bed 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_input.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_input.pyi
@@ -1,6 +1,5 @@
 from _typeshed import Incomplete
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_intern.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_intern.pyi
index f4e71b6da5f2..804b7b2517a5 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_intern.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_intern.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_isinstance.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_isinstance.pyi
index e776ea043714..31eefd625317 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_isinstance.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_isinstance.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools.pyi
index a19f7b5e8a00..229d86ee71bb 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools_imports.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools_imports.pyi
index 1ea0b506aaa2..39a4da506867 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools_imports.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_itertools_imports.pyi
@@ -1,6 +1,5 @@
 from lib2to3 import fixer_base
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 class FixItertoolsImports(fixer_base.BaseFix):
     BM_compatible: ClassVar[Literal[True]]
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_long.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_long.pyi
index c47f4528de47..9ccf2711d7d1 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_long.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_long.pyi
@@ -1,6 +1,5 @@
 from lib2to3 import fixer_base
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 class FixLong(fixer_base.BaseFix):
     BM_compatible: ClassVar[Literal[True]]
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_map.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_map.pyi
index 66e311cba8a8..6e60282cf0be 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_map.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_map.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_metaclass.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_metaclass.pyi
index 44626b47072d..1b1ec82032b4 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_metaclass.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_metaclass.pyi
@@ -1,6 +1,5 @@
 from collections.abc import Generator
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 from ..pytree import Base
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_methodattrs.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_methodattrs.pyi
index 9bda7992dc8b..ca9b71e43f85 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_methodattrs.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_methodattrs.pyi
@@ -1,9 +1,8 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Final, Literal
 
 from .. import fixer_base
 
-MAP: dict[str, str]
+MAP: Final[dict[str, str]]
 
 class FixMethodattrs(fixer_base.BaseFix):
     BM_compatible: ClassVar[Literal[True]]
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_ne.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_ne.pyi
index 95dfacccf219..6ff1220b0472 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_ne.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_ne.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_next.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_next.pyi
index a5757d65064a..b13914ae8c01 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_next.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_next.pyi
@@ -1,6 +1,5 @@
 from _typeshed import StrPath
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 from ..pytree import Node
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_nonzero.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_nonzero.pyi
index adf268fdb8e2..5c37fc12ef08 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_nonzero.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_nonzero.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_numliterals.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_numliterals.pyi
index 6842e42e45f0..113145e395f6 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_numliterals.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_numliterals.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_operator.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_operator.pyi
index 6da150a51c0c..b9863d38347b 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_operator.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_operator.pyi
@@ -1,6 +1,5 @@
 from lib2to3 import fixer_base
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 def invocation(s): ...
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_paren.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_paren.pyi
index c730cdc5d0b2..237df6c5ff2c 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_paren.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_paren.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_print.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_print.pyi
index 2261c9489299..e9564b04ac75 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_print.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_print.pyi
@@ -1,6 +1,5 @@
 from _typeshed import Incomplete
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_raise.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_raise.pyi
index 756a05ea3ddd..e02c3080f409 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_raise.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_raise.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_raw_input.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_raw_input.pyi
index 61d6ad7676ef..d1a0eb0e0a7e 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_raw_input.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_raw_input.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_reduce.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_reduce.pyi
index 4ea07fdde00b..f8ad876c21a6 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_reduce.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_reduce.pyi
@@ -1,6 +1,5 @@
 from lib2to3 import fixer_base
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 class FixReduce(fixer_base.BaseFix):
     BM_compatible: ClassVar[Literal[True]]
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_reload.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_reload.pyi
index 8045ac507890..820075438eca 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_reload.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_reload.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_renames.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_renames.pyi
index 2ceca053e903..652d8f15ea1a 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_renames.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_renames.pyi
@@ -1,11 +1,10 @@
 from collections.abc import Generator
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Final, Literal
 
 from .. import fixer_base
 
-MAPPING: dict[str, dict[str, str]]
-LOOKUP: dict[tuple[str, str], str]
+MAPPING: Final[dict[str, dict[str, str]]]
+LOOKUP: Final[dict[tuple[str, str], str]]
 
 def alternates(members): ...
 def build_pattern() -> Generator[str, None, None]: ...
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_repr.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_repr.pyi
index 6f3305846d18..3b192d396dd6 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_repr.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_repr.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_set_literal.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_set_literal.pyi
index dd18413d6d5a..6962ff326f56 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_set_literal.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_set_literal.pyi
@@ -1,6 +1,5 @@
 from lib2to3 import fixer_base
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 class FixSetLiteral(fixer_base.BaseFix):
     BM_compatible: ClassVar[Literal[True]]
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_standarderror.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_standarderror.pyi
index fd23af5a711e..ba914bcab5d6 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_standarderror.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_standarderror.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_sys_exc.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_sys_exc.pyi
index 3dbcd38c4b26..0fa1a4787087 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_sys_exc.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_sys_exc.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_throw.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_throw.pyi
index 50e37d44a58b..4c99855e5c37 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_throw.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_throw.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_tuple_params.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_tuple_params.pyi
index 48eadf75341c..bfaa9970c996 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_tuple_params.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_tuple_params.pyi
@@ -1,6 +1,5 @@
 from _typeshed import Incomplete
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_types.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_types.pyi
index 6ac1344b1e6c..e26dbec71a97 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_types.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_types.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_unicode.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_unicode.pyi
index af63d1865f2d..85d1315213b9 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_unicode.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_unicode.pyi
@@ -1,13 +1,12 @@
 from _typeshed import StrPath
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 from ..pytree import Node
 
 class FixUnicode(fixer_base.BaseFix):
     BM_compatible: ClassVar[Literal[True]]
-    PATTERN: ClassVar[Literal["STRING | 'unicode' | 'unichr'"]]  # type: ignore[name-defined]  # Name "STRING" is not defined
+    PATTERN: ClassVar[str]
     unicode_literals: bool
     def start_tree(self, tree: Node, filename: StrPath) -> None: ...
     def transform(self, node, results): ...
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_urllib.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_urllib.pyi
index a37e63b31101..abdcc0f62970 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_urllib.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_urllib.pyi
@@ -1,9 +1,9 @@
 from collections.abc import Generator
-from typing_extensions import Literal
+from typing import Final, Literal
 
 from .fix_imports import FixImports
 
-MAPPING: dict[str, list[tuple[Literal["urllib.request", "urllib.parse", "urllib.error"], list[str]]]]
+MAPPING: Final[dict[str, list[tuple[Literal["urllib.request", "urllib.parse", "urllib.error"], list[str]]]]]
 
 def build_pattern() -> Generator[str, None, None]: ...
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_ws_comma.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_ws_comma.pyi
index 6231d90c65f1..4ce5cb2c4ac1 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_ws_comma.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_ws_comma.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 from ..pytree import Leaf
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_xrange.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_xrange.pyi
index 89d300ef063a..71318b7660b6 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_xrange.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_xrange.pyi
@@ -1,6 +1,5 @@
 from _typeshed import Incomplete, StrPath
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 from ..pytree import Node
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_xreadlines.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_xreadlines.pyi
index 39757155e5d9..b4794143a003 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_xreadlines.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_xreadlines.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/fixes/fix_zip.pyi b/mypy/typeshed/stdlib/lib2to3/fixes/fix_zip.pyi
index 0c70717aa2ac..805886ee3180 100644
--- a/mypy/typeshed/stdlib/lib2to3/fixes/fix_zip.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/fixes/fix_zip.pyi
@@ -1,5 +1,4 @@
-from typing import ClassVar
-from typing_extensions import Literal
+from typing import ClassVar, Literal
 
 from .. import fixer_base
 
diff --git a/mypy/typeshed/stdlib/lib2to3/main.pyi b/mypy/typeshed/stdlib/lib2to3/main.pyi
index cfcaeeaf64ee..5b7fdfca5d65 100644
--- a/mypy/typeshed/stdlib/lib2to3/main.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/main.pyi
@@ -1,8 +1,7 @@
 from _typeshed import FileDescriptorOrPath
 from collections.abc import Container, Iterable, Iterator, Mapping, Sequence
 from logging import _ExcInfoType
-from typing import AnyStr
-from typing_extensions import Literal
+from typing import AnyStr, Literal
 
 from . import refactor as refactor
 
diff --git a/mypy/typeshed/stdlib/lib2to3/pgen2/pgen.pyi b/mypy/typeshed/stdlib/lib2to3/pgen2/pgen.pyi
index 6d9f776c61ae..5776d100d1da 100644
--- a/mypy/typeshed/stdlib/lib2to3/pgen2/pgen.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/pgen2/pgen.pyi
@@ -1,6 +1,6 @@
 from _typeshed import Incomplete, StrPath
 from collections.abc import Iterable, Iterator
-from typing import IO, NoReturn, overload
+from typing import IO, ClassVar, NoReturn, overload
 
 from . import grammar
 from .tokenize import _TokenInfo
@@ -46,5 +46,6 @@ class DFAState:
     def addarc(self, next: DFAState, label: str) -> None: ...
     def unifystate(self, old: DFAState, new: DFAState) -> None: ...
     def __eq__(self, other: DFAState) -> bool: ...  # type: ignore[override]
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 def generate_grammar(filename: StrPath = "Grammar.txt") -> PgenGrammar: ...
diff --git a/mypy/typeshed/stdlib/lib2to3/pgen2/token.pyi b/mypy/typeshed/stdlib/lib2to3/pgen2/token.pyi
index debcb2193987..6898517acee6 100644
--- a/mypy/typeshed/stdlib/lib2to3/pgen2/token.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/pgen2/token.pyi
@@ -1,65 +1,67 @@
-ENDMARKER: int
-NAME: int
-NUMBER: int
-STRING: int
-NEWLINE: int
-INDENT: int
-DEDENT: int
-LPAR: int
-RPAR: int
-LSQB: int
-RSQB: int
-COLON: int
-COMMA: int
-SEMI: int
-PLUS: int
-MINUS: int
-STAR: int
-SLASH: int
-VBAR: int
-AMPER: int
-LESS: int
-GREATER: int
-EQUAL: int
-DOT: int
-PERCENT: int
-BACKQUOTE: int
-LBRACE: int
-RBRACE: int
-EQEQUAL: int
-NOTEQUAL: int
-LESSEQUAL: int
-GREATEREQUAL: int
-TILDE: int
-CIRCUMFLEX: int
-LEFTSHIFT: int
-RIGHTSHIFT: int
-DOUBLESTAR: int
-PLUSEQUAL: int
-MINEQUAL: int
-STAREQUAL: int
-SLASHEQUAL: int
-PERCENTEQUAL: int
-AMPEREQUAL: int
-VBAREQUAL: int
-CIRCUMFLEXEQUAL: int
-LEFTSHIFTEQUAL: int
-RIGHTSHIFTEQUAL: int
-DOUBLESTAREQUAL: int
-DOUBLESLASH: int
-DOUBLESLASHEQUAL: int
-OP: int
-COMMENT: int
-NL: int
-RARROW: int
-AT: int
-ATEQUAL: int
-AWAIT: int
-ASYNC: int
-ERRORTOKEN: int
-COLONEQUAL: int
-N_TOKENS: int
-NT_OFFSET: int
+from typing import Final
+
+ENDMARKER: Final[int]
+NAME: Final[int]
+NUMBER: Final[int]
+STRING: Final[int]
+NEWLINE: Final[int]
+INDENT: Final[int]
+DEDENT: Final[int]
+LPAR: Final[int]
+RPAR: Final[int]
+LSQB: Final[int]
+RSQB: Final[int]
+COLON: Final[int]
+COMMA: Final[int]
+SEMI: Final[int]
+PLUS: Final[int]
+MINUS: Final[int]
+STAR: Final[int]
+SLASH: Final[int]
+VBAR: Final[int]
+AMPER: Final[int]
+LESS: Final[int]
+GREATER: Final[int]
+EQUAL: Final[int]
+DOT: Final[int]
+PERCENT: Final[int]
+BACKQUOTE: Final[int]
+LBRACE: Final[int]
+RBRACE: Final[int]
+EQEQUAL: Final[int]
+NOTEQUAL: Final[int]
+LESSEQUAL: Final[int]
+GREATEREQUAL: Final[int]
+TILDE: Final[int]
+CIRCUMFLEX: Final[int]
+LEFTSHIFT: Final[int]
+RIGHTSHIFT: Final[int]
+DOUBLESTAR: Final[int]
+PLUSEQUAL: Final[int]
+MINEQUAL: Final[int]
+STAREQUAL: Final[int]
+SLASHEQUAL: Final[int]
+PERCENTEQUAL: Final[int]
+AMPEREQUAL: Final[int]
+VBAREQUAL: Final[int]
+CIRCUMFLEXEQUAL: Final[int]
+LEFTSHIFTEQUAL: Final[int]
+RIGHTSHIFTEQUAL: Final[int]
+DOUBLESTAREQUAL: Final[int]
+DOUBLESLASH: Final[int]
+DOUBLESLASHEQUAL: Final[int]
+OP: Final[int]
+COMMENT: Final[int]
+NL: Final[int]
+RARROW: Final[int]
+AT: Final[int]
+ATEQUAL: Final[int]
+AWAIT: Final[int]
+ASYNC: Final[int]
+ERRORTOKEN: Final[int]
+COLONEQUAL: Final[int]
+N_TOKENS: Final[int]
+NT_OFFSET: Final[int]
 tok_name: dict[int, str]
 
 def ISTERMINAL(x: int) -> bool: ...
diff --git a/mypy/typeshed/stdlib/lib2to3/pygram.pyi b/mypy/typeshed/stdlib/lib2to3/pygram.pyi
index 2d1e90e79927..86c74b54888a 100644
--- a/mypy/typeshed/stdlib/lib2to3/pygram.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/pygram.pyi
@@ -1,5 +1,3 @@
-import sys
-
 from .pgen2.grammar import Grammar
 
 class Symbols:
@@ -112,6 +110,5 @@ class pattern_symbols(Symbols):
 
 python_grammar: Grammar
 python_grammar_no_print_statement: Grammar
-if sys.version_info >= (3, 8):
-    python_grammar_no_print_and_exec_statement: Grammar
+python_grammar_no_print_and_exec_statement: Grammar
 pattern_grammar: Grammar
diff --git a/mypy/typeshed/stdlib/lib2to3/pytree.pyi b/mypy/typeshed/stdlib/lib2to3/pytree.pyi
index d14446f38565..51bdbc75e142 100644
--- a/mypy/typeshed/stdlib/lib2to3/pytree.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/pytree.pyi
@@ -1,7 +1,8 @@
 from _typeshed import Incomplete, SupportsGetItem, SupportsLenAndGetItem, Unused
 from abc import abstractmethod
 from collections.abc import Iterable, Iterator, MutableSequence
-from typing_extensions import Final, Self, TypeAlias
+from typing import ClassVar, Final
+from typing_extensions import Self, TypeAlias
 
 from .fixer_base import BaseFix
 from .pgen2.grammar import Grammar
@@ -23,6 +24,7 @@ class Base:
     was_changed: bool
     was_checked: bool
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     @abstractmethod
     def _eq(self, other: Base) -> bool: ...
     @abstractmethod
diff --git a/mypy/typeshed/stdlib/lib2to3/refactor.pyi b/mypy/typeshed/stdlib/lib2to3/refactor.pyi
index d750d9c4a6cf..a7f382540648 100644
--- a/mypy/typeshed/stdlib/lib2to3/refactor.pyi
+++ b/mypy/typeshed/stdlib/lib2to3/refactor.pyi
@@ -3,8 +3,7 @@ from collections.abc import Container, Generator, Iterable, Mapping
 from logging import Logger, _ExcInfoType
 from multiprocessing import JoinableQueue
 from multiprocessing.synchronize import Lock
-from typing import Any, ClassVar, NoReturn, overload
-from typing_extensions import Final
+from typing import Any, ClassVar, Final, NoReturn, overload
 
 from .btm_matcher import BottomMatcher
 from .fixer_base import BaseFix
diff --git a/mypy/typeshed/stdlib/linecache.pyi b/mypy/typeshed/stdlib/linecache.pyi
index 8e317dd38990..2e050e13b621 100644
--- a/mypy/typeshed/stdlib/linecache.pyi
+++ b/mypy/typeshed/stdlib/linecache.pyi
@@ -1,5 +1,6 @@
 import sys
-from typing import Any, Protocol
+from collections.abc import Callable
+from typing import Any
 from typing_extensions import TypeAlias
 
 if sys.version_info >= (3, 9):
@@ -10,8 +11,7 @@ else:
 _ModuleGlobals: TypeAlias = dict[str, Any]
 _ModuleMetadata: TypeAlias = tuple[int, float | None, list[str], str]
 
-class _SourceLoader(Protocol):
-    def __call__(self) -> str | None: ...
+_SourceLoader: TypeAlias = tuple[Callable[[], str | None]]
 
 cache: dict[str, _SourceLoader | _ModuleMetadata]  # undocumented
 
diff --git a/mypy/typeshed/stdlib/locale.pyi b/mypy/typeshed/stdlib/locale.pyi
index c6cc7cacfb1d..58de65449572 100644
--- a/mypy/typeshed/stdlib/locale.pyi
+++ b/mypy/typeshed/stdlib/locale.pyi
@@ -1,6 +1,94 @@
 import sys
-from _typeshed import StrPath
-from collections.abc import Callable, Iterable, Mapping
+from _locale import (
+    CHAR_MAX as CHAR_MAX,
+    LC_ALL as LC_ALL,
+    LC_COLLATE as LC_COLLATE,
+    LC_CTYPE as LC_CTYPE,
+    LC_MONETARY as LC_MONETARY,
+    LC_NUMERIC as LC_NUMERIC,
+    LC_TIME as LC_TIME,
+    localeconv as localeconv,
+    strcoll as strcoll,
+    strxfrm as strxfrm,
+)
+
+# 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
+from collections.abc import Callable, Iterable
+from decimal import Decimal
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    from _locale import getencoding as getencoding
+
+# Some parts of the `_locale` module are platform-specific:
+if sys.platform != "win32":
+    from _locale import (
+        ABDAY_1 as ABDAY_1,
+        ABDAY_2 as ABDAY_2,
+        ABDAY_3 as ABDAY_3,
+        ABDAY_4 as ABDAY_4,
+        ABDAY_5 as ABDAY_5,
+        ABDAY_6 as ABDAY_6,
+        ABDAY_7 as ABDAY_7,
+        ABMON_1 as ABMON_1,
+        ABMON_2 as ABMON_2,
+        ABMON_3 as ABMON_3,
+        ABMON_4 as ABMON_4,
+        ABMON_5 as ABMON_5,
+        ABMON_6 as ABMON_6,
+        ABMON_7 as ABMON_7,
+        ABMON_8 as ABMON_8,
+        ABMON_9 as ABMON_9,
+        ABMON_10 as ABMON_10,
+        ABMON_11 as ABMON_11,
+        ABMON_12 as ABMON_12,
+        ALT_DIGITS as ALT_DIGITS,
+        AM_STR as AM_STR,
+        CODESET as CODESET,
+        CRNCYSTR as CRNCYSTR,
+        D_FMT as D_FMT,
+        D_T_FMT as D_T_FMT,
+        DAY_1 as DAY_1,
+        DAY_2 as DAY_2,
+        DAY_3 as DAY_3,
+        DAY_4 as DAY_4,
+        DAY_5 as DAY_5,
+        DAY_6 as DAY_6,
+        DAY_7 as DAY_7,
+        ERA as ERA,
+        ERA_D_FMT as ERA_D_FMT,
+        ERA_D_T_FMT as ERA_D_T_FMT,
+        ERA_T_FMT as ERA_T_FMT,
+        LC_MESSAGES as LC_MESSAGES,
+        MON_1 as MON_1,
+        MON_2 as MON_2,
+        MON_3 as MON_3,
+        MON_4 as MON_4,
+        MON_5 as MON_5,
+        MON_6 as MON_6,
+        MON_7 as MON_7,
+        MON_8 as MON_8,
+        MON_9 as MON_9,
+        MON_10 as MON_10,
+        MON_11 as MON_11,
+        MON_12 as MON_12,
+        NOEXPR as NOEXPR,
+        PM_STR as PM_STR,
+        RADIXCHAR as RADIXCHAR,
+        T_FMT as T_FMT,
+        T_FMT_AMPM as T_FMT_AMPM,
+        THOUSEP as THOUSEP,
+        YESEXPR as YESEXPR,
+        bind_textdomain_codeset as bind_textdomain_codeset,
+        bindtextdomain as bindtextdomain,
+        dcgettext as dcgettext,
+        dgettext as dgettext,
+        gettext as gettext,
+        nl_langinfo as nl_langinfo,
+        textdomain as textdomain,
+    )
 
 __all__ = [
     "getlocale",
@@ -8,20 +96,17 @@ __all__ = [
     "getpreferredencoding",
     "Error",
     "setlocale",
-    "resetlocale",
     "localeconv",
     "strcoll",
     "strxfrm",
     "str",
     "atof",
     "atoi",
-    "format",
     "format_string",
     "currency",
     "normalize",
     "LC_CTYPE",
     "LC_COLLATE",
-    "LC_MESSAGES",
     "LC_TIME",
     "LC_MONETARY",
     "LC_NUMERIC",
@@ -32,98 +117,33 @@ __all__ = [
 if sys.version_info >= (3, 11):
     __all__ += ["getencoding"]
 
-# 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
-from decimal import Decimal
-from typing import Any
-
-CODESET: int
-D_T_FMT: int
-D_FMT: int
-T_FMT: int
-T_FMT_AMPM: int
-AM_STR: int
-PM_STR: int
+if sys.version_info < (3, 12):
+    __all__ += ["format"]
 
-DAY_1: int
-DAY_2: int
-DAY_3: int
-DAY_4: int
-DAY_5: int
-DAY_6: int
-DAY_7: int
-ABDAY_1: int
-ABDAY_2: int
-ABDAY_3: int
-ABDAY_4: int
-ABDAY_5: int
-ABDAY_6: int
-ABDAY_7: int
+if sys.version_info < (3, 13):
+    __all__ += ["resetlocale"]
 
-MON_1: int
-MON_2: int
-MON_3: int
-MON_4: int
-MON_5: int
-MON_6: int
-MON_7: int
-MON_8: int
-MON_9: int
-MON_10: int
-MON_11: int
-MON_12: int
-ABMON_1: int
-ABMON_2: int
-ABMON_3: int
-ABMON_4: int
-ABMON_5: int
-ABMON_6: int
-ABMON_7: int
-ABMON_8: int
-ABMON_9: int
-ABMON_10: int
-ABMON_11: int
-ABMON_12: int
-
-RADIXCHAR: int
-THOUSEP: int
-YESEXPR: int
-NOEXPR: int
-CRNCYSTR: int
-
-ERA: int
-ERA_D_T_FMT: int
-ERA_D_FMT: int
-ERA_T_FMT: int
-
-ALT_DIGITS: int
-
-LC_CTYPE: int
-LC_COLLATE: int
-LC_TIME: int
-LC_MONETARY: int
-LC_MESSAGES: int
-LC_NUMERIC: int
-LC_ALL: int
-
-CHAR_MAX: int
+if sys.platform != "win32":
+    __all__ += ["LC_MESSAGES"]
 
 class Error(Exception): ...
 
-def setlocale(category: int, locale: _str | Iterable[_str | None] | None = None) -> _str: ...
-def localeconv() -> Mapping[_str, int | _str | list[int]]: ...
-def nl_langinfo(__key: int) -> _str: ...
 def getdefaultlocale(
     envvars: tuple[_str, ...] = ("LC_ALL", "LC_CTYPE", "LANG", "LANGUAGE")
 ) -> tuple[_str | None, _str | None]: ...
 def getlocale(category: int = ...) -> tuple[_str | None, _str | None]: ...
+def setlocale(category: int, locale: _str | Iterable[_str | None] | None = None) -> _str: ...
 def getpreferredencoding(do_setlocale: bool = True) -> _str: ...
 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, 13):
+    def resetlocale(category: int = ...) -> None: ...
+
+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: ...
@@ -131,20 +151,6 @@ def atof(string: _str, func: Callable[[_str], float] = ...) -> float: ...
 def atoi(string: _str) -> int: ...
 def str(val: float) -> _str: ...
 
-# native gettext functions
-# https://docs.python.org/3/library/locale.html#access-to-message-catalogs
-# https://github.com/python/cpython/blob/f4c03484da59049eb62a9bf7777b963e2267d187/Modules/_localemodule.c#L626
-if sys.platform == "linux" or sys.platform == "darwin":
-    def gettext(__msg: _str) -> _str: ...
-    def dgettext(__domain: _str | None, __msg: _str) -> _str: ...
-    def dcgettext(__domain: _str | None, __msg: _str, __category: int) -> _str: ...
-    def textdomain(__domain: _str | None) -> _str: ...
-    def bindtextdomain(__domain: _str, __dir: StrPath | None) -> _str: ...
-    def bind_textdomain_codeset(__domain: _str, __codeset: _str | None) -> _str | None: ...
-
-if sys.version_info >= (3, 11):
-    def getencoding() -> _str: ...
-
 locale_alias: dict[_str, _str]  # undocumented
 locale_encoding_alias: dict[_str, _str]  # undocumented
 windows_locale: dict[int, _str]  # undocumented
diff --git a/mypy/typeshed/stdlib/logging/__init__.pyi b/mypy/typeshed/stdlib/logging/__init__.pyi
index 6ebd305aacb8..9a4827a8f626 100644
--- a/mypy/typeshed/stdlib/logging/__init__.pyi
+++ b/mypy/typeshed/stdlib/logging/__init__.pyi
@@ -7,8 +7,8 @@ from re import Pattern
 from string import Template
 from time import struct_time
 from types import FrameType, TracebackType
-from typing import Any, ClassVar, Generic, TextIO, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import Any, ClassVar, Final, Generic, Literal, Protocol, TextIO, TypeVar, overload
+from typing_extensions import Self, TypeAlias, deprecated
 
 if sys.version_info >= (3, 11):
     from types import GenericAlias
@@ -50,24 +50,36 @@ __all__ = [
     "makeLogRecord",
     "setLoggerClass",
     "shutdown",
-    "warn",
     "warning",
     "getLogRecordFactory",
     "setLogRecordFactory",
     "lastResort",
     "raiseExceptions",
+    "warn",
 ]
 
 if sys.version_info >= (3, 11):
     __all__ += ["getLevelNamesMapping"]
+if sys.version_info >= (3, 12):
+    __all__ += ["getHandlerByName", "getHandlerNames"]
 
 _SysExcInfoType: TypeAlias = tuple[type[BaseException], BaseException, TracebackType | None] | tuple[None, None, None]
 _ExcInfoType: TypeAlias = None | bool | _SysExcInfoType | BaseException
 _ArgsType: TypeAlias = tuple[object, ...] | Mapping[str, object]
-_FilterType: TypeAlias = Filter | Callable[[LogRecord], bool]
 _Level: TypeAlias = int | str
 _FormatStyle: TypeAlias = Literal["%", "{", "$"]
 
+if sys.version_info >= (3, 12):
+    class _SupportsFilter(Protocol):
+        def filter(self, record: LogRecord, /) -> bool | LogRecord: ...
+
+    _FilterType: TypeAlias = Filter | Callable[[LogRecord], bool | LogRecord] | _SupportsFilter
+else:
+    class _SupportsFilter(Protocol):
+        def filter(self, record: LogRecord, /) -> bool: ...
+
+    _FilterType: TypeAlias = Filter | Callable[[LogRecord], bool] | _SupportsFilter
+
 raiseExceptions: bool
 logThreads: bool
 logMultiprocessing: bool
@@ -83,7 +95,10 @@ class Filterer:
     filters: list[_FilterType]
     def addFilter(self, filter: _FilterType) -> None: ...
     def removeFilter(self, filter: _FilterType) -> None: ...
-    def filter(self, record: LogRecord) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def filter(self, record: LogRecord) -> bool | LogRecord: ...
+    else:
+        def filter(self, record: LogRecord) -> bool: ...
 
 class Manager:  # undocumented
     root: RootLogger
@@ -111,173 +126,97 @@ class Logger(Filterer):
     def isEnabledFor(self, level: int) -> bool: ...
     def getEffectiveLevel(self) -> int: ...
     def getChild(self, suffix: str) -> Self: ...  # see python/typing#980
-    if sys.version_info >= (3, 8):
-        def debug(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def info(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def warning(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def warn(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def error(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def exception(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = True,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def critical(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def log(
-            self,
-            level: int,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def _log(
-            self,
-            level: int,
-            msg: object,
-            args: _ArgsType,
-            exc_info: _ExcInfoType | None = None,
-            extra: Mapping[str, object] | None = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-        ) -> None: ...  # undocumented
-    else:
-        def debug(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def info(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def warning(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def warn(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def error(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def critical(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def log(
-            self,
-            level: int,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def exception(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = True,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-        ) -> None: ...
-        def _log(
-            self,
-            level: int,
-            msg: object,
-            args: _ArgsType,
-            exc_info: _ExcInfoType | None = None,
-            extra: Mapping[str, object] | None = None,
-            stack_info: bool = False,
-        ) -> None: ...  # undocumented
+    if sys.version_info >= (3, 12):
+        def getChildren(self) -> set[Logger]: ...
+
+    def debug(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def info(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def warning(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    @deprecated("Deprecated; use warning() instead.")
+    def warn(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def error(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def exception(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = True,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def critical(
+        self,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def log(
+        self,
+        level: int,
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+    def _log(
+        self,
+        level: int,
+        msg: object,
+        args: _ArgsType,
+        exc_info: _ExcInfoType | None = None,
+        extra: Mapping[str, object] | None = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+    ) -> None: ...  # undocumented
     fatal = critical
     def addHandler(self, hdlr: Handler) -> None: ...
     def removeHandler(self, hdlr: Handler) -> None: ...
-    if sys.version_info >= (3, 8):
-        def findCaller(self, stack_info: bool = False, stacklevel: int = 1) -> tuple[str, int, str, str | None]: ...
-    else:
-        def findCaller(self, stack_info: bool = False) -> tuple[str, int, str, str | None]: ...
-
+    def findCaller(self, stack_info: bool = False, stacklevel: int = 1) -> tuple[str, int, str, str | None]: ...
     def handle(self, record: LogRecord) -> None: ...
     def makeRecord(
         self,
@@ -295,14 +234,14 @@ class Logger(Filterer):
     def hasHandlers(self) -> bool: ...
     def callHandlers(self, record: LogRecord) -> None: ...  # undocumented
 
-CRITICAL: int
-FATAL: int
-ERROR: int
-WARNING: int
-WARN: int
-INFO: int
-DEBUG: int
-NOTSET: int
+CRITICAL: Final = 50
+FATAL: Final = CRITICAL
+ERROR: Final = 40
+WARNING: Final = 30
+WARN: Final = WARNING
+INFO: Final = 20
+DEBUG: Final = 10
+NOTSET: Final = 0
 
 class Handler(Filterer):
     level: int  # undocumented
@@ -324,6 +263,10 @@ class Handler(Filterer):
     def format(self, record: LogRecord) -> str: ...
     def emit(self, record: LogRecord) -> None: ...
 
+if sys.version_info >= (3, 12):
+    def getHandlerByName(name: str) -> Handler | None: ...
+    def getHandlerNames() -> frozenset[str]: ...
+
 class Formatter:
     converter: Callable[[float | None], struct_time]
     _fmt: str | None  # undocumented
@@ -345,12 +288,10 @@ class Formatter:
             *,
             defaults: Mapping[str, Any] | None = None,
         ) -> None: ...
-    elif sys.version_info >= (3, 8):
+    else:
         def __init__(
             self, fmt: str | None = None, datefmt: str | None = None, style: _FormatStyle = "%", validate: bool = True
         ) -> None: ...
-    else:
-        def __init__(self, fmt: str | None = None, datefmt: str | None = None, style: _FormatStyle = "%") -> None: ...
 
     def format(self, record: LogRecord) -> str: ...
     def formatTime(self, record: LogRecord, datefmt: str | None = None) -> str: ...
@@ -370,7 +311,10 @@ class Filter:
     name: str  # undocumented
     nlen: int  # undocumented
     def __init__(self, name: str = "") -> None: ...
-    def filter(self, record: LogRecord) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def filter(self, record: LogRecord) -> bool | LogRecord: ...
+    else:
+        def filter(self, record: LogRecord) -> bool: ...
 
 class LogRecord:
     # args can be set to None by logging.handlers.QueueHandler
@@ -398,6 +342,9 @@ class LogRecord:
     stack_info: str | None
     thread: int | None
     threadName: str | None
+    if sys.version_info >= (3, 12):
+        taskName: str | None
+
     def __init__(
         self,
         name: str,
@@ -412,331 +359,219 @@ class LogRecord:
     ) -> None: ...
     def getMessage(self) -> str: ...
     # Allows setting contextual information on LogRecord objects as per the docs, see #7833
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
 
 _L = TypeVar("_L", bound=Logger | LoggerAdapter[Any])
 
 class LoggerAdapter(Generic[_L]):
     logger: _L
     manager: Manager  # undocumented
-    if sys.version_info >= (3, 10):
-        extra: Mapping[str, object] | None
+
+    if sys.version_info >= (3, 13):
+        def __init__(self, logger: _L, extra: Mapping[str, object] | None = None, merge_extra: bool = False) -> None: ...
+    elif sys.version_info >= (3, 10):
         def __init__(self, logger: _L, extra: Mapping[str, object] | None = None) -> None: ...
     else:
-        extra: Mapping[str, object]
         def __init__(self, logger: _L, extra: Mapping[str, object]) -> None: ...
 
-    def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> tuple[Any, MutableMapping[str, Any]]: ...
-    if sys.version_info >= (3, 8):
-        def debug(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def info(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def warning(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def warn(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def error(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def exception(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = True,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def critical(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def log(
-            self,
-            level: int,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            stacklevel: int = 1,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
+    if sys.version_info >= (3, 10):
+        extra: Mapping[str, object] | None
     else:
-        def debug(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def info(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def warning(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def warn(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def error(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def exception(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = True,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def critical(
-            self,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-        def log(
-            self,
-            level: int,
-            msg: object,
-            *args: object,
-            exc_info: _ExcInfoType = None,
-            stack_info: bool = False,
-            extra: Mapping[str, object] | None = None,
-            **kwargs: object,
-        ) -> None: ...
-
-    def isEnabledFor(self, level: int) -> bool: ...
-    def getEffectiveLevel(self) -> int: ...
-    def setLevel(self, level: _Level) -> None: ...
-    def hasHandlers(self) -> bool: ...
-    def _log(
-        self,
-        level: int,
-        msg: object,
-        args: _ArgsType,
-        exc_info: _ExcInfoType | None = None,
-        extra: Mapping[str, object] | None = None,
-        stack_info: bool = False,
-    ) -> None: ...  # undocumented
-    @property
-    def name(self) -> str: ...  # undocumented
-    if sys.version_info >= (3, 11):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-def getLogger(name: str | None = None) -> Logger: ...
-def getLoggerClass() -> type[Logger]: ...
-def getLogRecordFactory() -> Callable[..., LogRecord]: ...
+        extra: Mapping[str, object]
 
-if sys.version_info >= (3, 8):
+    def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> tuple[Any, MutableMapping[str, Any]]: ...
     def debug(
+        self,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = None,
         stack_info: bool = False,
         stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
     def info(
+        self,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = None,
         stack_info: bool = False,
         stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
     def warning(
+        self,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = None,
         stack_info: bool = False,
         stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
+    @deprecated("Deprecated; use warning() instead.")
     def warn(
+        self,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = None,
         stack_info: bool = False,
         stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
     def error(
+        self,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = None,
         stack_info: bool = False,
         stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-    def critical(
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        stacklevel: int = 1,
-        extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
     def exception(
+        self,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = True,
         stack_info: bool = False,
         stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-    def log(
-        level: int,
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        stacklevel: int = 1,
-        extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-
-else:
-    def debug(
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-    def info(
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-    def warning(
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-    def warn(
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-    def error(
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
     def critical(
+        self,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = None,
         stack_info: bool = False,
+        stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
-    ) -> None: ...
-    def exception(
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = True,
-        stack_info: bool = False,
-        extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
     def log(
+        self,
         level: int,
         msg: object,
         *args: object,
         exc_info: _ExcInfoType = None,
         stack_info: bool = False,
+        stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
+        **kwargs: object,
     ) -> None: ...
+    def isEnabledFor(self, level: int) -> bool: ...
+    def getEffectiveLevel(self) -> int: ...
+    def setLevel(self, level: _Level) -> None: ...
+    def hasHandlers(self) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def _log(
+            self,
+            level: int,
+            msg: object,
+            args: _ArgsType,
+            *,
+            exc_info: _ExcInfoType | None = None,
+            extra: Mapping[str, object] | None = None,
+            stack_info: bool = False,
+        ) -> None: ...  # undocumented
+    else:
+        def _log(
+            self,
+            level: int,
+            msg: object,
+            args: _ArgsType,
+            exc_info: _ExcInfoType | None = None,
+            extra: Mapping[str, object] | None = None,
+            stack_info: bool = False,
+        ) -> None: ...  # undocumented
+
+    @property
+    def name(self) -> str: ...  # undocumented
+    if sys.version_info >= (3, 11):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+def getLogger(name: str | None = None) -> Logger: ...
+def getLoggerClass() -> type[Logger]: ...
+def getLogRecordFactory() -> Callable[..., LogRecord]: ...
+def debug(
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = None,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
+def info(
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = None,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
+def warning(
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = None,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
+@deprecated("Deprecated; use warning() instead.")
+def warn(
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = None,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
+def error(
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = None,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
+def critical(
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = None,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
+def exception(
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = True,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
+def log(
+    level: int,
+    msg: object,
+    *args: object,
+    exc_info: _ExcInfoType = None,
+    stack_info: bool = False,
+    stacklevel: int = 1,
+    extra: Mapping[str, object] | None = None,
+) -> None: ...
 
 fatal = critical
 
 def disable(level: int = 50) -> None: ...
 def addLevelName(level: int, levelName: str) -> None: ...
-def getLevelName(level: _Level) -> Any: ...
+@overload
+def getLevelName(level: int) -> str: ...
+@overload
+@deprecated("The str -> int case is considered a mistake.")
+def getLevelName(level: str) -> Any: ...
 
 if sys.version_info >= (3, 11):
     def getLevelNamesMapping() -> dict[str, int]: ...
@@ -759,20 +594,6 @@ if sys.version_info >= (3, 9):
         errors: str | None = ...,
     ) -> None: ...
 
-elif sys.version_info >= (3, 8):
-    def basicConfig(
-        *,
-        filename: StrPath | None = ...,
-        filemode: str = ...,
-        format: str = ...,
-        datefmt: str | None = ...,
-        style: _FormatStyle = ...,
-        level: _Level | None = ...,
-        stream: SupportsWrite[str] | None = ...,
-        handlers: Iterable[Handler] | None = ...,
-        force: bool = ...,
-    ) -> None: ...
-
 else:
     def basicConfig(
         *,
@@ -784,6 +605,7 @@ else:
         level: _Level | None = ...,
         stream: SupportsWrite[str] | None = ...,
         handlers: Iterable[Handler] | None = ...,
+        force: bool = ...,
     ) -> None: ...
 
 def shutdown(handlerList: Sequence[Any] = ...) -> None: ...  # handlerList is undocumented
@@ -791,7 +613,7 @@ def setLoggerClass(klass: type[Logger]) -> None: ...
 def captureWarnings(capture: bool) -> None: ...
 def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ...
 
-lastResort: StreamHandler[Any] | None
+lastResort: Handler | None
 
 _StreamT = TypeVar("_StreamT", bound=SupportsWrite[str])
 
@@ -801,10 +623,10 @@ class StreamHandler(Handler, Generic[_StreamT]):
     @overload
     def __init__(self: StreamHandler[TextIO], stream: None = None) -> None: ...
     @overload
-    def __init__(self: StreamHandler[_StreamT], stream: _StreamT) -> None: ...
+    def __init__(self: StreamHandler[_StreamT], stream: _StreamT) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]  #11780
     def setStream(self, stream: _StreamT) -> _StreamT | None: ...
     if sys.version_info >= (3, 11):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class FileHandler(StreamHandler[TextIOWrapper]):
     baseFilename: str  # undocumented
@@ -839,8 +661,7 @@ class PercentStyle:  # undocumented
     default_format: str
     asctime_format: str
     asctime_search: str
-    if sys.version_info >= (3, 8):
-        validation_pattern: Pattern[str]
+    validation_pattern: Pattern[str]
     _fmt: str
     if sys.version_info >= (3, 10):
         def __init__(self, fmt: str, *, defaults: Mapping[str, Any] | None = None) -> None: ...
@@ -848,9 +669,7 @@ class PercentStyle:  # undocumented
         def __init__(self, fmt: str) -> None: ...
 
     def usesTime(self) -> bool: ...
-    if sys.version_info >= (3, 8):
-        def validate(self) -> None: ...
-
+    def validate(self) -> None: ...
     def format(self, record: Any) -> str: ...
 
 class StrFormatStyle(PercentStyle):  # undocumented
@@ -860,6 +679,6 @@ class StrFormatStyle(PercentStyle):  # undocumented
 class StringTemplateStyle(PercentStyle):  # undocumented
     _tpl: Template
 
-_STYLES: dict[str, tuple[PercentStyle, str]]
+_STYLES: Final[dict[str, tuple[PercentStyle, str]]]
 
-BASIC_FORMAT: str
+BASIC_FORMAT: Final[str]
diff --git a/mypy/typeshed/stdlib/logging/config.pyi b/mypy/typeshed/stdlib/logging/config.pyi
index e92658f7f1b3..000ba1ebb06e 100644
--- a/mypy/typeshed/stdlib/logging/config.pyi
+++ b/mypy/typeshed/stdlib/logging/config.pyi
@@ -1,44 +1,41 @@
 import sys
 from _typeshed import StrOrBytesPath
-from collections.abc import Callable, Hashable, Iterable, Sequence
+from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
 from configparser import RawConfigParser
 from re import Pattern
 from threading import Thread
-from typing import IO, Any, overload
-from typing_extensions import Literal, SupportsIndex, TypeAlias, TypedDict
+from typing import IO, Any, Final, Literal, SupportsIndex, TypedDict, overload, type_check_only
+from typing_extensions import Required, TypeAlias
 
 from . import Filter, Filterer, Formatter, Handler, Logger, _FilterType, _FormatStyle, _Level
 
 DEFAULT_LOGGING_CONFIG_PORT: int
-RESET_ERROR: int  # undocumented
-IDENTIFIER: Pattern[str]  # undocumented
+RESET_ERROR: Final[int]  # undocumented
+IDENTIFIER: Final[Pattern[str]]  # undocumented
 
 if sys.version_info >= (3, 11):
+    @type_check_only
     class _RootLoggerConfiguration(TypedDict, total=False):
         level: _Level
         filters: Sequence[str | _FilterType]
         handlers: Sequence[str]
 
 else:
+    @type_check_only
     class _RootLoggerConfiguration(TypedDict, total=False):
         level: _Level
         filters: Sequence[str]
         handlers: Sequence[str]
 
+@type_check_only
 class _LoggerConfiguration(_RootLoggerConfiguration, TypedDict, total=False):
     propagate: bool
 
-if sys.version_info >= (3, 8):
-    _FormatterConfigurationTypedDict = TypedDict(
-        "_FormatterConfigurationTypedDict", {"class": str, "format": str, "datefmt": str, "style": _FormatStyle}, total=False
-    )
-else:
-    _FormatterConfigurationTypedDict = TypedDict(
-        "_FormatterConfigurationTypedDict",
-        {"class": str, "format": str, "datefmt": str, "style": _FormatStyle, "validate": bool},
-        total=False,
-    )
+_FormatterConfigurationTypedDict = TypedDict(
+    "_FormatterConfigurationTypedDict", {"class": str, "format": str, "datefmt": str, "style": _FormatStyle}, total=False
+)
 
+@type_check_only
 class _FilterConfigurationTypedDict(TypedDict):
     name: str
 
@@ -50,18 +47,17 @@ _FilterConfiguration: TypeAlias = _FilterConfigurationTypedDict | dict[str, Any]
 # Handler config can have additional keys even when not providing a custom factory so we just use `dict`.
 _HandlerConfiguration: TypeAlias = dict[str, Any]
 
-class _OptionalDictConfigArgs(TypedDict, total=False):
+@type_check_only
+class _DictConfigArgs(TypedDict, total=False):
+    version: Required[Literal[1]]
     formatters: dict[str, _FormatterConfiguration]
     filters: dict[str, _FilterConfiguration]
     handlers: dict[str, _HandlerConfiguration]
     loggers: dict[str, _LoggerConfiguration]
-    root: _RootLoggerConfiguration | None
+    root: _RootLoggerConfiguration
     incremental: bool
     disable_existing_loggers: bool
 
-class _DictConfigArgs(_OptionalDictConfigArgs, TypedDict):
-    version: Literal[1]
-
 # Accept dict[str, Any] to avoid false positives if called with a dict
 # type, since dict types are not compatible with TypedDicts.
 #
@@ -72,7 +68,7 @@ def dictConfig(config: _DictConfigArgs | dict[str, Any]) -> None: ...
 if sys.version_info >= (3, 10):
     def fileConfig(
         fname: StrOrBytesPath | IO[str] | RawConfigParser,
-        defaults: dict[str, str] | None = None,
+        defaults: Mapping[str, str] | None = None,
         disable_existing_loggers: bool = True,
         encoding: str | None = None,
     ) -> None: ...
@@ -80,7 +76,7 @@ if sys.version_info >= (3, 10):
 else:
     def fileConfig(
         fname: StrOrBytesPath | IO[str] | RawConfigParser,
-        defaults: dict[str, str] | None = None,
+        defaults: Mapping[str, str] | None = None,
         disable_existing_loggers: bool = True,
     ) -> None: ...
 
@@ -125,7 +121,7 @@ class BaseConfigurator:  # undocumented
     def cfg_convert(self, value: str) -> Any: ...
     def convert(self, value: Any) -> Any: ...
     def configure_custom(self, config: dict[str, Any]) -> Any: ...
-    def as_tuple(self, value: list[Any] | tuple[Any]) -> tuple[Any]: ...
+    def as_tuple(self, value: list[Any] | tuple[Any, ...]) -> tuple[Any, ...]: ...
 
 class DictConfigurator(BaseConfigurator):
     def configure(self) -> None: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/logging/handlers.pyi b/mypy/typeshed/stdlib/logging/handlers.pyi
index ad5bf392b50f..d594d6569a7e 100644
--- a/mypy/typeshed/stdlib/logging/handlers.pyi
+++ b/mypy/typeshed/stdlib/logging/handlers.pyi
@@ -7,16 +7,17 @@ from collections.abc import Callable
 from logging import FileHandler, Handler, LogRecord
 from re import Pattern
 from socket import SocketKind, socket
-from typing import Any, ClassVar, Protocol, TypeVar
+from threading import Thread
+from typing import Any, ClassVar, Final, Protocol, TypeVar
 
 _T = TypeVar("_T")
 
-DEFAULT_TCP_LOGGING_PORT: int
-DEFAULT_UDP_LOGGING_PORT: int
-DEFAULT_HTTP_LOGGING_PORT: int
-DEFAULT_SOAP_LOGGING_PORT: int
-SYSLOG_UDP_PORT: int
-SYSLOG_TCP_PORT: int
+DEFAULT_TCP_LOGGING_PORT: Final[int]
+DEFAULT_UDP_LOGGING_PORT: Final[int]
+DEFAULT_HTTP_LOGGING_PORT: Final[int]
+DEFAULT_SOAP_LOGGING_PORT: Final[int]
+SYSLOG_UDP_PORT: Final[int]
+SYSLOG_TCP_PORT: Final[int]
 
 class WatchedFileHandler(FileHandler):
     dev: int  # undocumented
@@ -45,7 +46,7 @@ class BaseRotatingHandler(FileHandler):
     def rotate(self, source: str, dest: str) -> None: ...
 
 class RotatingFileHandler(BaseRotatingHandler):
-    maxBytes: str  # undocumented
+    maxBytes: int  # undocumented
     backupCount: int  # undocumented
     if sys.version_info >= (3, 9):
         def __init__(
@@ -252,18 +253,21 @@ class HTTPHandler(Handler):
 
 class _QueueLike(Protocol[_T]):
     def get(self) -> _T: ...
-    def put_nowait(self, __item: _T) -> None: ...
+    def put_nowait(self, item: _T, /) -> None: ...
 
 class QueueHandler(Handler):
     queue: _QueueLike[Any]
     def __init__(self, queue: _QueueLike[Any]) -> None: ...
     def prepare(self, record: LogRecord) -> Any: ...
     def enqueue(self, record: LogRecord) -> None: ...
+    if sys.version_info >= (3, 12):
+        listener: QueueListener | None
 
 class QueueListener:
     handlers: tuple[Handler, ...]  # undocumented
     respect_handler_level: bool  # undocumented
     queue: _QueueLike[Any]  # undocumented
+    _thread: Thread | None  # undocumented
     def __init__(self, queue: _QueueLike[Any], *handlers: Handler, respect_handler_level: bool = False) -> None: ...
     def dequeue(self, block: bool) -> LogRecord: ...
     def prepare(self, record: LogRecord) -> Any: ...
diff --git a/mypy/typeshed/stdlib/lzma.pyi b/mypy/typeshed/stdlib/lzma.pyi
index 8e296bb5b357..2f0279f5986b 100644
--- a/mypy/typeshed/stdlib/lzma.pyi
+++ b/mypy/typeshed/stdlib/lzma.pyi
@@ -1,8 +1,42 @@
-import io
+from _compression import BaseStream
+from _lzma import (
+    CHECK_CRC32 as CHECK_CRC32,
+    CHECK_CRC64 as CHECK_CRC64,
+    CHECK_ID_MAX as CHECK_ID_MAX,
+    CHECK_NONE as CHECK_NONE,
+    CHECK_SHA256 as CHECK_SHA256,
+    CHECK_UNKNOWN as CHECK_UNKNOWN,
+    FILTER_ARM as FILTER_ARM,
+    FILTER_ARMTHUMB as FILTER_ARMTHUMB,
+    FILTER_DELTA as FILTER_DELTA,
+    FILTER_IA64 as FILTER_IA64,
+    FILTER_LZMA1 as FILTER_LZMA1,
+    FILTER_LZMA2 as FILTER_LZMA2,
+    FILTER_POWERPC as FILTER_POWERPC,
+    FILTER_SPARC as FILTER_SPARC,
+    FILTER_X86 as FILTER_X86,
+    FORMAT_ALONE as FORMAT_ALONE,
+    FORMAT_AUTO as FORMAT_AUTO,
+    FORMAT_RAW as FORMAT_RAW,
+    FORMAT_XZ as FORMAT_XZ,
+    MF_BT2 as MF_BT2,
+    MF_BT3 as MF_BT3,
+    MF_BT4 as MF_BT4,
+    MF_HC3 as MF_HC3,
+    MF_HC4 as MF_HC4,
+    MODE_FAST as MODE_FAST,
+    MODE_NORMAL as MODE_NORMAL,
+    PRESET_DEFAULT as PRESET_DEFAULT,
+    PRESET_EXTREME as PRESET_EXTREME,
+    LZMACompressor as LZMACompressor,
+    LZMADecompressor as LZMADecompressor,
+    LZMAError as LZMAError,
+    _FilterChain,
+    is_check_supported as is_check_supported,
+)
 from _typeshed import ReadableBuffer, StrOrBytesPath
-from collections.abc import Mapping, Sequence
-from typing import IO, Any, TextIO, overload
-from typing_extensions import Literal, Self, TypeAlias, final
+from typing import IO, Literal, TextIO, overload
+from typing_extensions import Self, TypeAlias
 
 __all__ = [
     "CHECK_NONE",
@@ -48,63 +82,7 @@ _OpenTextWritingMode: TypeAlias = Literal["wt", "xt", "at"]
 
 _PathOrFile: TypeAlias = StrOrBytesPath | IO[bytes]
 
-_FilterChain: TypeAlias = Sequence[Mapping[str, Any]]
-
-FORMAT_AUTO: Literal[0]
-FORMAT_XZ: Literal[1]
-FORMAT_ALONE: Literal[2]
-FORMAT_RAW: Literal[3]
-CHECK_NONE: Literal[0]
-CHECK_CRC32: Literal[1]
-CHECK_CRC64: Literal[4]
-CHECK_SHA256: Literal[10]
-CHECK_ID_MAX: Literal[15]
-CHECK_UNKNOWN: Literal[16]
-FILTER_LZMA1: int  # v big number
-FILTER_LZMA2: Literal[33]
-FILTER_DELTA: Literal[3]
-FILTER_X86: Literal[4]
-FILTER_IA64: Literal[6]
-FILTER_ARM: Literal[7]
-FILTER_ARMTHUMB: Literal[8]
-FILTER_SPARC: Literal[9]
-FILTER_POWERPC: Literal[5]
-MF_HC3: Literal[3]
-MF_HC4: Literal[4]
-MF_BT2: Literal[18]
-MF_BT3: Literal[19]
-MF_BT4: Literal[20]
-MODE_FAST: Literal[1]
-MODE_NORMAL: Literal[2]
-PRESET_DEFAULT: Literal[6]
-PRESET_EXTREME: int  # v big number
-
-# from _lzma.c
-@final
-class LZMADecompressor:
-    def __init__(self, format: int | None = ..., memlimit: int | None = ..., filters: _FilterChain | None = ...) -> None: ...
-    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
-    @property
-    def check(self) -> int: ...
-    @property
-    def eof(self) -> bool: ...
-    @property
-    def unused_data(self) -> bytes: ...
-    @property
-    def needs_input(self) -> bool: ...
-
-# from _lzma.c
-@final
-class LZMACompressor:
-    def __init__(
-        self, format: int | None = ..., check: int = ..., preset: int | None = ..., filters: _FilterChain | None = ...
-    ) -> None: ...
-    def compress(self, __data: ReadableBuffer) -> bytes: ...
-    def flush(self) -> bytes: ...
-
-class LZMAError(Exception): ...
-
-class LZMAFile(io.BufferedIOBase, IO[bytes]):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
+class LZMAFile(BaseStream, IO[bytes]):  # type: ignore[misc]  # incompatible definitions of writelines in the base classes
     def __init__(
         self,
         filename: _PathOrFile | None = None,
@@ -194,4 +172,3 @@ def compress(
 def decompress(
     data: ReadableBuffer, format: int = 0, memlimit: int | None = None, filters: _FilterChain | None = None
 ) -> bytes: ...
-def is_check_supported(__check_id: int) -> bool: ...
diff --git a/mypy/typeshed/stdlib/macpath.pyi b/mypy/typeshed/stdlib/macpath.pyi
deleted file mode 100644
index 37821f44b200..000000000000
--- a/mypy/typeshed/stdlib/macpath.pyi
+++ /dev/null
@@ -1,104 +0,0 @@
-from _typeshed import BytesPath, StrOrBytesPath, StrPath
-from genericpath import (
-    commonprefix as commonprefix,
-    exists as exists,
-    getatime as getatime,
-    getctime as getctime,
-    getmtime as getmtime,
-    getsize as getsize,
-    isdir as isdir,
-    isfile as isfile,
-    samefile as samefile,
-    sameopenfile as sameopenfile,
-    samestat as samestat,
-)
-from os import PathLike
-
-# Re-export common definitions from posixpath to reduce duplication
-from posixpath import (
-    abspath as abspath,
-    curdir as curdir,
-    defpath as defpath,
-    devnull as devnull,
-    expanduser as expanduser,
-    expandvars as expandvars,
-    extsep as extsep,
-    isabs as isabs,
-    lexists as lexists,
-    pardir as pardir,
-    pathsep as pathsep,
-    sep as sep,
-    splitdrive as splitdrive,
-    splitext as splitext,
-    supports_unicode_filenames as supports_unicode_filenames,
-)
-from typing import AnyStr, overload
-
-__all__ = [
-    "normcase",
-    "isabs",
-    "join",
-    "splitdrive",
-    "split",
-    "splitext",
-    "basename",
-    "dirname",
-    "commonprefix",
-    "getsize",
-    "getmtime",
-    "getatime",
-    "getctime",
-    "islink",
-    "exists",
-    "lexists",
-    "isdir",
-    "isfile",
-    "expanduser",
-    "expandvars",
-    "normpath",
-    "abspath",
-    "curdir",
-    "pardir",
-    "sep",
-    "pathsep",
-    "defpath",
-    "altsep",
-    "extsep",
-    "devnull",
-    "realpath",
-    "supports_unicode_filenames",
-]
-
-altsep: str | None
-
-@overload
-def basename(s: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def basename(s: AnyStr) -> AnyStr: ...
-@overload
-def dirname(s: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def dirname(s: AnyStr) -> AnyStr: ...
-@overload
-def normcase(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def normcase(path: AnyStr) -> AnyStr: ...
-@overload
-def normpath(s: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def normpath(s: AnyStr) -> AnyStr: ...
-@overload
-def realpath(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def realpath(path: AnyStr) -> AnyStr: ...
-def islink(s: StrOrBytesPath) -> bool: ...
-
-# Mypy complains that the signatures overlap, but things seem to behave correctly anyway.
-@overload
-def join(s: StrPath, *paths: StrPath) -> str: ...
-@overload
-def join(s: BytesPath, *paths: BytesPath) -> bytes: ...
-@overload
-def split(s: PathLike[AnyStr]) -> tuple[AnyStr, AnyStr]: ...
-@overload
-def split(s: AnyStr) -> tuple[AnyStr, AnyStr]: ...
diff --git a/mypy/typeshed/stdlib/mailbox.pyi b/mypy/typeshed/stdlib/mailbox.pyi
index 8053fad88ea5..a98a00a42853 100644
--- a/mypy/typeshed/stdlib/mailbox.pyi
+++ b/mypy/typeshed/stdlib/mailbox.pyi
@@ -5,8 +5,8 @@ from _typeshed import StrPath, SupportsNoArgReadline, SupportsRead
 from abc import ABCMeta, abstractmethod
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
 from types import TracebackType
-from typing import IO, Any, AnyStr, Generic, Protocol, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, AnyStr, Generic, Literal, Protocol, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -102,7 +102,7 @@ class Mailbox(Generic[_MessageT]):
     @abstractmethod
     def close(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Maildir(Mailbox[MaildirMessage]):
     colon: str
@@ -115,6 +115,14 @@ class Maildir(Mailbox[MaildirMessage]):
     def get_message(self, key: str) -> MaildirMessage: ...
     def get_bytes(self, key: str) -> bytes: ...
     def get_file(self, key: str) -> _ProxyFile[bytes]: ...
+    if sys.version_info >= (3, 13):
+        def get_info(self, key: str) -> str: ...
+        def set_info(self, key: str, info: str) -> None: ...
+        def get_flags(self, key: str) -> str: ...
+        def set_flags(self, key: str, flags: str) -> None: ...
+        def add_flag(self, key: str, flag: str) -> None: ...
+        def remove_flag(self, key: str, flag: str) -> None: ...
+
     def iterkeys(self) -> Iterator[str]: ...
     def __contains__(self, key: str) -> bool: ...
     def __len__(self) -> int: ...
@@ -244,7 +252,7 @@ class _ProxyFile(Generic[AnyStr]):
     @property
     def closed(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class _PartialFile(_ProxyFile[AnyStr]):
     def __init__(self, f: IO[AnyStr], start: int | None = None, stop: int | None = None) -> None: ...
diff --git a/mypy/typeshed/stdlib/marshal.pyi b/mypy/typeshed/stdlib/marshal.pyi
index 21f05c908479..6ab202637dda 100644
--- a/mypy/typeshed/stdlib/marshal.pyi
+++ b/mypy/typeshed/stdlib/marshal.pyi
@@ -1,4 +1,5 @@
 import builtins
+import sys
 import types
 from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
 from typing import Any
@@ -27,7 +28,14 @@ _Marshallable: TypeAlias = (
     | ReadableBuffer
 )
 
-def dump(__value: _Marshallable, __file: SupportsWrite[bytes], __version: int = 4) -> None: ...
-def load(__file: SupportsRead[bytes]) -> Any: ...
-def dumps(__value: _Marshallable, __version: int = 4) -> bytes: ...
-def loads(__bytes: ReadableBuffer) -> Any: ...
+if sys.version_info >= (3, 13):
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /, *, allow_code: bool = True) -> None: ...
+    def load(file: SupportsRead[bytes], /, *, allow_code: bool = True) -> Any: ...
+    def dumps(value: _Marshallable, version: int = 4, /, *, allow_code: bool = True) -> bytes: ...
+    def loads(bytes: ReadableBuffer, /, *, allow_code: bool = True) -> Any: ...
+
+else:
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /) -> None: ...
+    def load(file: SupportsRead[bytes], /) -> Any: ...
+    def dumps(value: _Marshallable, version: int = 4, /) -> bytes: ...
+    def loads(bytes: ReadableBuffer, /) -> Any: ...
diff --git a/mypy/typeshed/stdlib/math.pyi b/mypy/typeshed/stdlib/math.pyi
index 4a4d592b860d..f73429cf6940 100644
--- a/mypy/typeshed/stdlib/math.pyi
+++ b/mypy/typeshed/stdlib/math.pyi
@@ -1,92 +1,74 @@
 import sys
+from _typeshed import SupportsMul, SupportsRMul
 from collections.abc import Iterable
-from typing import Protocol, SupportsFloat, TypeVar, overload
-from typing_extensions import SupportsIndex, TypeAlias
+from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
+from typing_extensions import TypeAlias
 
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
 
-if sys.version_info >= (3, 8):
-    _SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex
-else:
-    _SupportsFloatOrIndex: TypeAlias = SupportsFloat
-
-e: float
-pi: float
-inf: float
-nan: float
-tau: float
-
-def acos(__x: _SupportsFloatOrIndex) -> float: ...
-def acosh(__x: _SupportsFloatOrIndex) -> float: ...
-def asin(__x: _SupportsFloatOrIndex) -> float: ...
-def asinh(__x: _SupportsFloatOrIndex) -> float: ...
-def atan(__x: _SupportsFloatOrIndex) -> float: ...
-def atan2(__y: _SupportsFloatOrIndex, __x: _SupportsFloatOrIndex) -> float: ...
-def atanh(__x: _SupportsFloatOrIndex) -> float: ...
+_SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex
+
+e: Final[float]
+pi: Final[float]
+inf: Final[float]
+nan: Final[float]
+tau: Final[float]
+
+def acos(x: _SupportsFloatOrIndex, /) -> float: ...
+def acosh(x: _SupportsFloatOrIndex, /) -> float: ...
+def asin(x: _SupportsFloatOrIndex, /) -> float: ...
+def asinh(x: _SupportsFloatOrIndex, /) -> float: ...
+def atan(x: _SupportsFloatOrIndex, /) -> float: ...
+def atan2(y: _SupportsFloatOrIndex, x: _SupportsFloatOrIndex, /) -> float: ...
+def atanh(x: _SupportsFloatOrIndex, /) -> float: ...
 
 if sys.version_info >= (3, 11):
-    def cbrt(__x: _SupportsFloatOrIndex) -> float: ...
+    def cbrt(x: _SupportsFloatOrIndex, /) -> float: ...
 
 class _SupportsCeil(Protocol[_T_co]):
     def __ceil__(self) -> _T_co: ...
 
 @overload
-def ceil(__x: _SupportsCeil[_T]) -> _T: ...
+def ceil(x: _SupportsCeil[_T], /) -> _T: ...
 @overload
-def ceil(__x: _SupportsFloatOrIndex) -> int: ...
-
-if sys.version_info >= (3, 8):
-    def comb(__n: SupportsIndex, __k: SupportsIndex) -> int: ...
-
-def copysign(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
-def cos(__x: _SupportsFloatOrIndex) -> float: ...
-def cosh(__x: _SupportsFloatOrIndex) -> float: ...
-def degrees(__x: _SupportsFloatOrIndex) -> float: ...
-
-if sys.version_info >= (3, 8):
-    def dist(__p: Iterable[_SupportsFloatOrIndex], __q: Iterable[_SupportsFloatOrIndex]) -> float: ...
-
-def erf(__x: _SupportsFloatOrIndex) -> float: ...
-def erfc(__x: _SupportsFloatOrIndex) -> float: ...
-def exp(__x: _SupportsFloatOrIndex) -> float: ...
+def ceil(x: _SupportsFloatOrIndex, /) -> int: ...
+def comb(n: SupportsIndex, k: SupportsIndex, /) -> int: ...
+def copysign(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+def cos(x: _SupportsFloatOrIndex, /) -> float: ...
+def cosh(x: _SupportsFloatOrIndex, /) -> float: ...
+def degrees(x: _SupportsFloatOrIndex, /) -> float: ...
+def dist(p: Iterable[_SupportsFloatOrIndex], q: Iterable[_SupportsFloatOrIndex], /) -> float: ...
+def erf(x: _SupportsFloatOrIndex, /) -> float: ...
+def erfc(x: _SupportsFloatOrIndex, /) -> float: ...
+def exp(x: _SupportsFloatOrIndex, /) -> float: ...
 
 if sys.version_info >= (3, 11):
-    def exp2(__x: _SupportsFloatOrIndex) -> float: ...
-
-def expm1(__x: _SupportsFloatOrIndex) -> float: ...
-def fabs(__x: _SupportsFloatOrIndex) -> float: ...
+    def exp2(x: _SupportsFloatOrIndex, /) -> float: ...
 
-if sys.version_info >= (3, 8):
-    def factorial(__x: SupportsIndex) -> int: ...
-
-else:
-    def factorial(__x: int) -> int: ...
+def expm1(x: _SupportsFloatOrIndex, /) -> float: ...
+def fabs(x: _SupportsFloatOrIndex, /) -> float: ...
+def factorial(x: SupportsIndex, /) -> int: ...
 
 class _SupportsFloor(Protocol[_T_co]):
     def __floor__(self) -> _T_co: ...
 
 @overload
-def floor(__x: _SupportsFloor[_T]) -> _T: ...
+def floor(x: _SupportsFloor[_T], /) -> _T: ...
 @overload
-def floor(__x: _SupportsFloatOrIndex) -> int: ...
-def fmod(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
-def frexp(__x: _SupportsFloatOrIndex) -> tuple[float, int]: ...
-def fsum(__seq: Iterable[_SupportsFloatOrIndex]) -> float: ...
-def gamma(__x: _SupportsFloatOrIndex) -> float: ...
+def floor(x: _SupportsFloatOrIndex, /) -> int: ...
+def fmod(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+def frexp(x: _SupportsFloatOrIndex, /) -> tuple[float, int]: ...
+def fsum(seq: Iterable[_SupportsFloatOrIndex], /) -> float: ...
+def gamma(x: _SupportsFloatOrIndex, /) -> float: ...
 
 if sys.version_info >= (3, 9):
     def gcd(*integers: SupportsIndex) -> int: ...
 
 else:
-    def gcd(__x: SupportsIndex, __y: SupportsIndex) -> int: ...
-
-if sys.version_info >= (3, 8):
-    def hypot(*coordinates: _SupportsFloatOrIndex) -> float: ...
-
-else:
-    def hypot(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+    def gcd(x: SupportsIndex, y: SupportsIndex, /) -> int: ...
 
+def hypot(*coordinates: _SupportsFloatOrIndex) -> float: ...
 def isclose(
     a: _SupportsFloatOrIndex,
     b: _SupportsFloatOrIndex,
@@ -94,58 +76,73 @@ def isclose(
     rel_tol: _SupportsFloatOrIndex = 1e-09,
     abs_tol: _SupportsFloatOrIndex = 0.0,
 ) -> bool: ...
-def isinf(__x: _SupportsFloatOrIndex) -> bool: ...
-def isfinite(__x: _SupportsFloatOrIndex) -> bool: ...
-def isnan(__x: _SupportsFloatOrIndex) -> bool: ...
-
-if sys.version_info >= (3, 8):
-    def isqrt(__n: SupportsIndex) -> int: ...
+def isinf(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isfinite(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isnan(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isqrt(n: SupportsIndex, /) -> int: ...
 
 if sys.version_info >= (3, 9):
     def lcm(*integers: SupportsIndex) -> int: ...
 
-def ldexp(__x: _SupportsFloatOrIndex, __i: int) -> float: ...
-def lgamma(__x: _SupportsFloatOrIndex) -> float: ...
+def ldexp(x: _SupportsFloatOrIndex, i: int, /) -> float: ...
+def lgamma(x: _SupportsFloatOrIndex, /) -> float: ...
 def log(x: _SupportsFloatOrIndex, base: _SupportsFloatOrIndex = ...) -> float: ...
-def log10(__x: _SupportsFloatOrIndex) -> float: ...
-def log1p(__x: _SupportsFloatOrIndex) -> float: ...
-def log2(__x: _SupportsFloatOrIndex) -> float: ...
-def modf(__x: _SupportsFloatOrIndex) -> tuple[float, float]: ...
+def log10(x: _SupportsFloatOrIndex, /) -> float: ...
+def log1p(x: _SupportsFloatOrIndex, /) -> float: ...
+def log2(x: _SupportsFloatOrIndex, /) -> float: ...
+def modf(x: _SupportsFloatOrIndex, /) -> tuple[float, float]: ...
 
 if sys.version_info >= (3, 12):
-    def nextafter(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex, *, steps: SupportsIndex | None = None) -> float: ...
+    def nextafter(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /, *, steps: SupportsIndex | None = None) -> float: ...
 
 elif sys.version_info >= (3, 9):
-    def nextafter(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+    def nextafter(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+
+def perm(n: SupportsIndex, k: SupportsIndex | None = None, /) -> int: ...
+def pow(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
 
-if sys.version_info >= (3, 8):
-    def perm(__n: SupportsIndex, __k: SupportsIndex | None = None) -> int: ...
+_PositiveInteger: TypeAlias = Literal[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]
+_NegativeInteger: TypeAlias = Literal[-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20]
+_LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
 
-def pow(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
+_MultiplicableT1 = TypeVar("_MultiplicableT1", bound=SupportsMul[Any, Any])
+_MultiplicableT2 = TypeVar("_MultiplicableT2", bound=SupportsMul[Any, Any])
 
-if sys.version_info >= (3, 8):
-    @overload
-    def prod(__iterable: Iterable[SupportsIndex], *, start: SupportsIndex = 1) -> int: ...  # type: ignore[misc]
-    @overload
-    def prod(__iterable: Iterable[_SupportsFloatOrIndex], *, start: _SupportsFloatOrIndex = 1) -> float: ...
+class _SupportsProdWithNoDefaultGiven(SupportsMul[Any, Any], SupportsRMul[int, Any], Protocol): ...
 
-def radians(__x: _SupportsFloatOrIndex) -> float: ...
-def remainder(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
-def sin(__x: _SupportsFloatOrIndex) -> float: ...
-def sinh(__x: _SupportsFloatOrIndex) -> float: ...
+_SupportsProdNoDefaultT = TypeVar("_SupportsProdNoDefaultT", bound=_SupportsProdWithNoDefaultGiven)
+
+# This stub is based on the type stub for `builtins.sum`.
+# Like `builtins.sum`, it cannot be precisely represented in a type stub
+# without introducing many false positives.
+# For more details on its limitations and false positives, see #13572.
+# Instead, just like `builtins.sum`, we explicitly handle several useful cases.
+@overload
+def prod(iterable: Iterable[bool | _LiteralInteger], /, *, start: int = 1) -> int: ...  # type: ignore[overload-overlap]
+@overload
+def prod(iterable: Iterable[_SupportsProdNoDefaultT], /) -> _SupportsProdNoDefaultT | Literal[1]: ...
+@overload
+def prod(iterable: Iterable[_MultiplicableT1], /, *, start: _MultiplicableT2) -> _MultiplicableT1 | _MultiplicableT2: ...
+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 sumprod(p: Iterable[float], q: Iterable[float], /) -> float: ...
 
-def sqrt(__x: _SupportsFloatOrIndex) -> float: ...
-def tan(__x: _SupportsFloatOrIndex) -> float: ...
-def tanh(__x: _SupportsFloatOrIndex) -> float: ...
+def sqrt(x: _SupportsFloatOrIndex, /) -> float: ...
+def tan(x: _SupportsFloatOrIndex, /) -> float: ...
+def tanh(x: _SupportsFloatOrIndex, /) -> float: ...
 
 # Is different from `_typeshed.SupportsTrunc`, which is not generic
 class _SupportsTrunc(Protocol[_T_co]):
     def __trunc__(self) -> _T_co: ...
 
-def trunc(__x: _SupportsTrunc[_T]) -> _T: ...
+def trunc(x: _SupportsTrunc[_T], /) -> _T: ...
 
 if sys.version_info >= (3, 9):
-    def ulp(__x: _SupportsFloatOrIndex) -> float: ...
+    def ulp(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 13):
+    def fma(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, z: _SupportsFloatOrIndex, /) -> float: ...
diff --git a/mypy/typeshed/stdlib/mimetypes.pyi b/mypy/typeshed/stdlib/mimetypes.pyi
index 128a05fa5752..9914a34a2d6a 100644
--- a/mypy/typeshed/stdlib/mimetypes.pyi
+++ b/mypy/typeshed/stdlib/mimetypes.pyi
@@ -19,18 +19,19 @@ __all__ = [
     "common_types",
 ]
 
-if sys.version_info >= (3, 8):
-    def guess_type(url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
-
-else:
-    def guess_type(url: str, strict: bool = True) -> tuple[str | None, str | None]: ...
+if sys.version_info >= (3, 13):
+    __all__ += ["guess_file_type"]
 
+def guess_type(url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
 def guess_all_extensions(type: str, strict: bool = True) -> list[str]: ...
 def guess_extension(type: str, strict: bool = True) -> str | None: ...
 def init(files: Sequence[str] | None = None) -> None: ...
 def read_mime_types(file: str) -> dict[str, str] | None: ...
 def add_type(type: str, ext: str, strict: bool = True) -> None: ...
 
+if sys.version_info >= (3, 13):
+    def guess_file_type(path: StrPath, *, strict: bool = True) -> tuple[str | None, str | None]: ...
+
 inited: bool
 knownfiles: list[str]
 suffix_map: dict[str, str]
@@ -44,14 +45,12 @@ class MimeTypes:
     types_map: tuple[dict[str, str], dict[str, str]]
     types_map_inv: tuple[dict[str, str], dict[str, str]]
     def __init__(self, filenames: tuple[str, ...] = (), strict: bool = True) -> None: ...
+    def add_type(self, type: str, ext: str, strict: bool = True) -> None: ...
     def guess_extension(self, type: str, strict: bool = True) -> str | None: ...
-    if sys.version_info >= (3, 8):
-        def guess_type(self, url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
-    else:
-        def guess_type(self, url: str, strict: bool = True) -> tuple[str | None, str | None]: ...
-
+    def guess_type(self, url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
     def guess_all_extensions(self, type: str, strict: bool = True) -> list[str]: ...
     def read(self, filename: str, strict: bool = True) -> None: ...
     def readfp(self, fp: IO[str], strict: bool = True) -> None: ...
-    if sys.platform == "win32":
-        def read_windows_registry(self, strict: bool = True) -> None: ...
+    def read_windows_registry(self, strict: bool = True) -> None: ...
+    if sys.version_info >= (3, 13):
+        def guess_file_type(self, path: StrPath, *, strict: bool = True) -> tuple[str | None, str | None]: ...
diff --git a/mypy/typeshed/stdlib/mmap.pyi b/mypy/typeshed/stdlib/mmap.pyi
index 38e1924392c4..c9b8358cde6c 100644
--- a/mypy/typeshed/stdlib/mmap.pyi
+++ b/mypy/typeshed/stdlib/mmap.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import ReadableBuffer, Unused
-from collections.abc import Iterable, Iterator, Sized
-from typing import NoReturn, overload
+from collections.abc import Iterator
+from typing import Final, Literal, NoReturn, overload
 from typing_extensions import Self
 
 ACCESS_DEFAULT: int
@@ -16,6 +16,8 @@ if sys.platform == "linux":
     MAP_EXECUTABLE: int
     if sys.version_info >= (3, 10):
         MAP_POPULATE: int
+if sys.version_info >= (3, 11) and sys.platform != "win32" and sys.platform != "darwin":
+    MAP_STACK: int
 
 if sys.platform != "win32":
     MAP_ANON: int
@@ -26,22 +28,31 @@ if sys.platform != "win32":
     PROT_READ: int
     PROT_WRITE: int
 
-    PAGESIZE: int
+PAGESIZE: int
 
-class mmap(Iterable[int], Sized):
+class mmap:
     if sys.platform == "win32":
         def __init__(self, fileno: int, length: int, tagname: str | None = ..., access: int = ..., offset: int = ...) -> None: ...
     else:
-        def __init__(
-            self, fileno: int, length: int, flags: int = ..., prot: int = ..., access: int = ..., offset: int = ...
-        ) -> None: ...
+        if sys.version_info >= (3, 13):
+            def __new__(
+                cls,
+                fileno: int,
+                length: int,
+                flags: int = ...,
+                prot: int = ...,
+                access: int = ...,
+                offset: int = ...,
+                *,
+                trackfd: bool = True,
+            ) -> Self: ...
+        else:
+            def __new__(
+                cls, fileno: int, length: int, flags: int = ..., prot: int = ..., access: int = ..., offset: int = ...
+            ) -> Self: ...
 
     def close(self) -> None: ...
-    if sys.version_info >= (3, 8):
-        def flush(self, offset: int = ..., size: int = ...) -> None: ...
-    else:
-        def flush(self, offset: int = ..., size: int = ...) -> int: ...
-
+    def flush(self, offset: int = ..., size: int = ...) -> None: ...
     def move(self, dest: int, src: int, count: int) -> None: ...
     def read_byte(self) -> int: ...
     def readline(self) -> bytes: ...
@@ -52,7 +63,7 @@ class mmap(Iterable[int], Sized):
     def write_byte(self, byte: int) -> None: ...
     def __len__(self) -> int: ...
     closed: bool
-    if sys.version_info >= (3, 8) and sys.platform != "win32":
+    if sys.platform != "win32":
         def madvise(self, option: int, start: int = ..., length: int = ...) -> None: ...
 
     def find(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ...
@@ -60,26 +71,28 @@ class mmap(Iterable[int], Sized):
     def read(self, n: int | None = ...) -> bytes: ...
     def write(self, bytes: ReadableBuffer) -> int: ...
     @overload
-    def __getitem__(self, __key: int) -> int: ...
+    def __getitem__(self, key: int, /) -> int: ...
     @overload
-    def __getitem__(self, __key: slice) -> bytes: ...
-    def __delitem__(self, __key: int | slice) -> NoReturn: ...
+    def __getitem__(self, key: slice, /) -> bytes: ...
+    def __delitem__(self, key: int | slice, /) -> NoReturn: ...
     @overload
-    def __setitem__(self, __key: int, __value: int) -> None: ...
+    def __setitem__(self, key: int, value: int, /) -> None: ...
     @overload
-    def __setitem__(self, __key: slice, __value: ReadableBuffer) -> None: ...
+    def __setitem__(self, key: slice, value: ReadableBuffer, /) -> None: ...
     # Doesn't actually exist, but the object actually supports "in" because it has __getitem__,
     # so we claim that there is also a __contains__ to help type checkers.
-    def __contains__(self, __o: object) -> bool: ...
+    def __contains__(self, o: object, /) -> bool: ...
     # Doesn't actually exist, but the object is actually iterable because it has __getitem__ and __len__,
     # so we claim that there is also an __iter__ to help type checkers.
     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: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+    if sys.version_info >= (3, 13):
+        def seekable(self) -> Literal[True]: ...
 
-if sys.version_info >= (3, 8) and sys.platform != "win32":
+if sys.platform != "win32":
     MADV_NORMAL: int
     MADV_RANDOM: int
     MADV_SEQUENTIAL: int
@@ -87,29 +100,47 @@ if sys.version_info >= (3, 8) and sys.platform != "win32":
     MADV_DONTNEED: int
     MADV_FREE: int
 
-    if sys.platform == "linux":
-        MADV_REMOVE: int
-        MADV_DONTFORK: int
-        MADV_DOFORK: int
-        MADV_HWPOISON: int
-        MADV_MERGEABLE: int
-        MADV_UNMERGEABLE: int
-        # Seems like this constant is not defined in glibc.
-        # See https://github.com/python/typeshed/pull/5360 for details
-        # MADV_SOFT_OFFLINE: int
-        MADV_HUGEPAGE: int
-        MADV_NOHUGEPAGE: int
-        MADV_DONTDUMP: int
-        MADV_DODUMP: int
+if sys.platform == "linux":
+    MADV_REMOVE: int
+    MADV_DONTFORK: int
+    MADV_DOFORK: int
+    MADV_HWPOISON: int
+    MADV_MERGEABLE: int
+    MADV_UNMERGEABLE: int
+    # Seems like this constant is not defined in glibc.
+    # See https://github.com/python/typeshed/pull/5360 for details
+    # MADV_SOFT_OFFLINE: int
+    MADV_HUGEPAGE: int
+    MADV_NOHUGEPAGE: int
+    MADV_DONTDUMP: int
+    MADV_DODUMP: int
 
-    # This Values are defined for FreeBSD but type checkers do not support conditions for these
-    if sys.platform != "linux" and sys.platform != "darwin":
-        MADV_NOSYNC: int
-        MADV_AUTOSYNC: int
-        MADV_NOCORE: int
-        MADV_CORE: int
-        MADV_PROTECT: int
+# This Values are defined for FreeBSD but type checkers do not support conditions for these
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    MADV_NOSYNC: int
+    MADV_AUTOSYNC: int
+    MADV_NOCORE: int
+    MADV_CORE: int
+    MADV_PROTECT: int
 
 if sys.version_info >= (3, 10) and sys.platform == "darwin":
     MADV_FREE_REUSABLE: int
     MADV_FREE_REUSE: int
+
+if sys.version_info >= (3, 13) and sys.platform != "win32":
+    MAP_32BIT: Final = 32768
+
+if sys.version_info >= (3, 13) and sys.platform == "darwin":
+    MAP_NORESERVE: Final = 64
+    MAP_NOEXTEND: Final = 256
+    MAP_HASSEMAPHORE: Final = 512
+    MAP_NOCACHE: Final = 1024
+    MAP_JIT: Final = 2048
+    MAP_RESILIENT_CODESIGN: Final = 8192
+    MAP_RESILIENT_MEDIA: Final = 16384
+    MAP_TRANSLATED_ALLOW_EXECUTE: Final = 131072
+    MAP_UNIX03: Final = 262144
+    MAP_TPRO: Final = 524288
+
+if sys.version_info >= (3, 13) and sys.platform == "linux":
+    MAP_NORESERVE: Final = 16384
diff --git a/mypy/typeshed/stdlib/modulefinder.pyi b/mypy/typeshed/stdlib/modulefinder.pyi
index 06bb50d26286..6db665a18e69 100644
--- a/mypy/typeshed/stdlib/modulefinder.pyi
+++ b/mypy/typeshed/stdlib/modulefinder.pyi
@@ -1,15 +1,15 @@
 import sys
 from collections.abc import Container, Iterable, Iterator, Sequence
 from types import CodeType
-from typing import IO, Any
+from typing import IO, Any, Final
 
 if sys.version_info < (3, 11):
-    LOAD_CONST: int  # undocumented
-    IMPORT_NAME: int  # undocumented
-    STORE_NAME: int  # undocumented
-    STORE_GLOBAL: int  # undocumented
-    STORE_OPS: tuple[int, int]  # undocumented
-    EXTENDED_ARG: int  # undocumented
+    LOAD_CONST: Final[int]  # undocumented
+    IMPORT_NAME: Final[int]  # undocumented
+    STORE_NAME: Final[int]  # undocumented
+    STORE_GLOBAL: Final[int]  # undocumented
+    STORE_OPS: Final[tuple[int, int]]  # undocumented
+    EXTENDED_ARG: Final[int]  # undocumented
 
 packagePathMap: dict[str, list[str]]  # undocumented
 
@@ -31,23 +31,13 @@ class ModuleFinder:
     excludes: Container[str]  # undocumented
     replace_paths: Sequence[tuple[str, str]]  # undocumented
 
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            path: list[str] | None = None,
-            debug: int = 0,
-            excludes: Container[str] | None = None,
-            replace_paths: Sequence[tuple[str, str]] | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            path: list[str] | None = None,
-            debug: int = 0,
-            excludes: Container[str] = [],
-            replace_paths: Sequence[tuple[str, str]] = [],
-        ) -> None: ...
-
+    def __init__(
+        self,
+        path: list[str] | None = None,
+        debug: int = 0,
+        excludes: Container[str] | None = None,
+        replace_paths: Sequence[tuple[str, str]] | None = None,
+    ) -> None: ...
     def msg(self, level: int, str: str, *args: Any) -> None: ...  # undocumented
     def msgin(self, *args: Any) -> None: ...  # undocumented
     def msgout(self, *args: Any) -> None: ...  # undocumented
@@ -74,3 +64,5 @@ class ModuleFinder:
     def any_missing(self) -> list[str]: ...  # undocumented
     def any_missing_maybe(self) -> tuple[list[str], list[str]]: ...  # undocumented
     def replace_paths_in_code(self, co: CodeType) -> CodeType: ...  # undocumented
+
+def test() -> ModuleFinder | None: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/msilib/__init__.pyi b/mypy/typeshed/stdlib/msilib/__init__.pyi
index 9f7367d152ba..3e43cbc44f52 100644
--- a/mypy/typeshed/stdlib/msilib/__init__.pyi
+++ b/mypy/typeshed/stdlib/msilib/__init__.pyi
@@ -1,8 +1,7 @@
 import sys
 from collections.abc import Container, Iterable, Sequence
 from types import ModuleType
-from typing import Any
-from typing_extensions import Literal
+from typing import Any, Literal
 
 if sys.platform == "win32":
     from _msi import *
@@ -57,6 +56,7 @@ if sys.platform == "win32":
         def gen_id(self, file: str) -> str: ...
         def append(self, full: str, file: str, logical: str) -> tuple[int, str]: ...
         def commit(self, db: _Database) -> None: ...
+
     _directories: set[str]
 
     class Directory:
diff --git a/mypy/typeshed/stdlib/msilib/text.pyi b/mypy/typeshed/stdlib/msilib/text.pyi
index 1353cf8a2392..441c843ca6cf 100644
--- a/mypy/typeshed/stdlib/msilib/text.pyi
+++ b/mypy/typeshed/stdlib/msilib/text.pyi
@@ -3,5 +3,5 @@ import sys
 if sys.platform == "win32":
     ActionText: list[tuple[str, str, str | None]]
     UIText: list[tuple[str, str | None]]
-
+    dirname: str
     tables: list[str]
diff --git a/mypy/typeshed/stdlib/msvcrt.pyi b/mypy/typeshed/stdlib/msvcrt.pyi
index 5849b9b00ca0..403a5d933522 100644
--- a/mypy/typeshed/stdlib/msvcrt.pyi
+++ b/mypy/typeshed/stdlib/msvcrt.pyi
@@ -1,28 +1,32 @@
 import sys
-from typing_extensions import Literal
+from typing import Final
 
 # This module is only available on Windows
 if sys.platform == "win32":
-    LK_UNLCK: Literal[0]
-    LK_LOCK: Literal[1]
-    LK_NBLCK: Literal[2]
-    LK_RLCK: Literal[3]
-    LK_NBRLCK: Literal[4]
+    CRT_ASSEMBLY_VERSION: Final[str]
+    LK_UNLCK: Final = 0
+    LK_LOCK: Final = 1
+    LK_NBLCK: Final = 2
+    LK_RLCK: Final = 3
+    LK_NBRLCK: Final = 4
     SEM_FAILCRITICALERRORS: int
     SEM_NOALIGNMENTFAULTEXCEPT: int
     SEM_NOGPFAULTERRORBOX: int
     SEM_NOOPENFILEERRORBOX: int
-    def locking(__fd: int, __mode: int, __nbytes: int) -> None: ...
-    def setmode(__fd: int, __mode: int) -> int: ...
-    def open_osfhandle(__handle: int, __flags: int) -> int: ...
-    def get_osfhandle(__fd: int) -> int: ...
+    def locking(fd: int, mode: int, nbytes: int, /) -> None: ...
+    def setmode(fd: int, mode: int, /) -> int: ...
+    def open_osfhandle(handle: int, flags: int, /) -> int: ...
+    def get_osfhandle(fd: int, /) -> int: ...
     def kbhit() -> bool: ...
     def getch() -> bytes: ...
     def getwch() -> str: ...
     def getche() -> bytes: ...
     def getwche() -> str: ...
-    def putch(__char: bytes | bytearray) -> None: ...
-    def putwch(__unicode_char: str) -> None: ...
-    def ungetch(__char: bytes | bytearray) -> None: ...
-    def ungetwch(__unicode_char: str) -> None: ...
+    def putch(char: bytes | bytearray, /) -> None: ...
+    def putwch(unicode_char: str, /) -> None: ...
+    def ungetch(char: bytes | bytearray, /) -> None: ...
+    def ungetwch(unicode_char: str, /) -> None: ...
     def heapmin() -> None: ...
+    def SetErrorMode(mode: int, /) -> int: ...
+    if sys.version_info >= (3, 10):
+        def GetErrorMode() -> int: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/multiprocessing/__init__.pyi b/mypy/typeshed/stdlib/multiprocessing/__init__.pyi
index 186bd54a021d..2bd6e2883ddb 100644
--- a/mypy/typeshed/stdlib/multiprocessing/__init__.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/__init__.pyi
@@ -1,4 +1,3 @@
-import sys
 from multiprocessing import context, reduction as reducer
 from multiprocessing.context import (
     AuthenticationError as AuthenticationError,
@@ -7,7 +6,11 @@ from multiprocessing.context import (
     ProcessError as ProcessError,
     TimeoutError as TimeoutError,
 )
-from multiprocessing.process import active_children as active_children, current_process as current_process
+from multiprocessing.process import (
+    active_children as active_children,
+    current_process as current_process,
+    parent_process as parent_process,
+)
 
 # These are technically functions that return instances of these Queue classes.
 # The stub here doesn't reflect reality exactly --
@@ -19,9 +22,6 @@ from multiprocessing.process import active_children as active_children, current_
 from multiprocessing.queues import JoinableQueue as JoinableQueue, Queue as Queue, SimpleQueue as SimpleQueue
 from multiprocessing.spawn import freeze_support as freeze_support
 
-if sys.version_info >= (3, 8):
-    from multiprocessing.process import parent_process as parent_process
-
 __all__ = [
     "Array",
     "AuthenticationError",
@@ -55,15 +55,13 @@ __all__ = [
     "get_logger",
     "get_start_method",
     "log_to_stderr",
+    "parent_process",
     "reducer",
     "set_executable",
     "set_forkserver_preload",
     "set_start_method",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["parent_process"]
-
 # These functions (really bound methods)
 # are all autogenerated at runtime here: https://github.com/python/cpython/blob/600c65c094b0b48704d8ec2416930648052ba715/Lib/multiprocessing/__init__.py#L23
 RawValue = context._default_context.RawValue
diff --git a/mypy/typeshed/stdlib/multiprocessing/connection.pyi b/mypy/typeshed/stdlib/multiprocessing/connection.pyi
index d034373712e0..cd4fa102c0f3 100644
--- a/mypy/typeshed/stdlib/multiprocessing/connection.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/connection.pyi
@@ -1,17 +1,21 @@
 import socket
 import sys
-import types
-from _typeshed import ReadableBuffer
+from _typeshed import Incomplete, ReadableBuffer
 from collections.abc import Iterable
-from typing import Any
-from typing_extensions import Self, SupportsIndex, TypeAlias
+from types import TracebackType
+from typing import Any, Generic, SupportsIndex, TypeVar
+from typing_extensions import Self, TypeAlias
 
 __all__ = ["Client", "Listener", "Pipe", "wait"]
 
 # https://docs.python.org/3/library/multiprocessing.html#address-formats
 _Address: TypeAlias = str | tuple[str, int]
 
-class _ConnectionBase:
+# Defaulting to Any to avoid forcing generics on a lot of pre-existing code
+_SendT_contra = TypeVar("_SendT_contra", contravariant=True, default=Any)
+_RecvT_co = TypeVar("_RecvT_co", covariant=True, default=Any)
+
+class _ConnectionBase(Generic[_SendT_contra, _RecvT_co]):
     def __init__(self, handle: SupportsIndex, readable: bool = True, writable: bool = True) -> None: ...
     @property
     def closed(self) -> bool: ...  # undocumented
@@ -22,26 +26,27 @@ class _ConnectionBase:
     def fileno(self) -> int: ...
     def close(self) -> None: ...
     def send_bytes(self, buf: ReadableBuffer, offset: int = 0, size: int | None = None) -> None: ...
-    def send(self, obj: Any) -> None: ...
+    def send(self, obj: _SendT_contra) -> None: ...
     def recv_bytes(self, maxlength: int | None = None) -> bytes: ...
     def recv_bytes_into(self, buf: Any, offset: int = 0) -> int: ...
-    def recv(self) -> Any: ...
+    def recv(self) -> _RecvT_co: ...
     def poll(self, timeout: float | None = 0.0) -> bool: ...
     def __enter__(self) -> Self: ...
     def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: types.TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
+    def __del__(self) -> None: ...
 
-class Connection(_ConnectionBase): ...
+class Connection(_ConnectionBase[_SendT_contra, _RecvT_co]): ...
 
 if sys.platform == "win32":
-    class PipeConnection(_ConnectionBase): ...
+    class PipeConnection(_ConnectionBase[_SendT_contra, _RecvT_co]): ...
 
 class Listener:
     def __init__(
         self, address: _Address | None = None, family: str | None = None, backlog: int = 1, authkey: bytes | None = None
     ) -> None: ...
-    def accept(self) -> Connection: ...
+    def accept(self) -> Connection[Incomplete, Incomplete]: ...
     def close(self) -> None: ...
     @property
     def address(self) -> _Address: ...
@@ -49,21 +54,30 @@ class Listener:
     def last_accepted(self) -> _Address | None: ...
     def __enter__(self) -> Self: ...
     def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: types.TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
 
-def deliver_challenge(connection: Connection, authkey: bytes) -> None: ...
-def answer_challenge(connection: Connection, authkey: bytes) -> None: ...
+# Any: send and recv methods unused
+if sys.version_info >= (3, 12):
+    def deliver_challenge(connection: Connection[Any, Any], authkey: bytes, digest_name: str = "sha256") -> None: ...
+
+else:
+    def deliver_challenge(connection: Connection[Any, Any], authkey: bytes) -> None: ...
+
+def answer_challenge(connection: Connection[Any, Any], authkey: bytes) -> None: ...
 def wait(
-    object_list: Iterable[Connection | socket.socket | int], timeout: float | None = None
-) -> list[Connection | socket.socket | int]: ...
-def Client(address: _Address, family: str | None = None, authkey: bytes | None = None) -> Connection: ...
+    object_list: Iterable[Connection[_SendT_contra, _RecvT_co] | socket.socket | int], timeout: float | None = None
+) -> list[Connection[_SendT_contra, _RecvT_co] | socket.socket | int]: ...
+def Client(address: _Address, family: str | None = None, authkey: bytes | None = None) -> Connection[Any, Any]: ...
 
 # N.B. Keep this in sync with multiprocessing.context.BaseContext.Pipe.
 # _ConnectionBase is the common base class of Connection and PipeConnection
 # and can be used in cross-platform code.
+#
+# The two connections should have the same generic types but inverted (Connection[_T1, _T2], Connection[_T2, _T1]).
+# However, TypeVars scoped entirely within a return annotation is unspecified in the spec.
 if sys.platform != "win32":
-    def Pipe(duplex: bool = True) -> tuple[Connection, Connection]: ...
+    def Pipe(duplex: bool = True) -> tuple[Connection[Any, Any], Connection[Any, Any]]: ...
 
 else:
-    def Pipe(duplex: bool = True) -> tuple[PipeConnection, PipeConnection]: ...
+    def Pipe(duplex: bool = True) -> tuple[PipeConnection[Any, Any], PipeConnection[Any, Any]]: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/context.pyi b/mypy/typeshed/stdlib/multiprocessing/context.pyi
index fe3b98024548..03d1d2e5c220 100644
--- a/mypy/typeshed/stdlib/multiprocessing/context.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/context.pyi
@@ -1,27 +1,26 @@
 import ctypes
 import sys
+from _ctypes import _CData
 from collections.abc import Callable, Iterable, Sequence
-from ctypes import _CData
+from ctypes import _SimpleCData, c_char
 from logging import Logger, _Level as _LoggingLevel
 from multiprocessing import popen_fork, popen_forkserver, popen_spawn_posix, popen_spawn_win32, queues, synchronize
 from multiprocessing.managers import SyncManager
 from multiprocessing.pool import Pool as _Pool
 from multiprocessing.process import BaseProcess
-from multiprocessing.sharedctypes import SynchronizedArray, SynchronizedBase
-from typing import Any, ClassVar, TypeVar, overload
-from typing_extensions import Literal, TypeAlias
+from multiprocessing.sharedctypes import Synchronized, SynchronizedArray, SynchronizedString
+from typing import Any, ClassVar, Literal, TypeVar, overload
+from typing_extensions import TypeAlias
 
 if sys.platform != "win32":
     from multiprocessing.connection import Connection
 else:
     from multiprocessing.connection import PipeConnection
 
-if sys.version_info >= (3, 8):
-    __all__ = ()
-else:
-    __all__: list[str] = []
+__all__ = ()
 
 _LockLike: TypeAlias = synchronize.Lock | synchronize.RLock
+_T = TypeVar("_T")
 _CT = TypeVar("_CT", bound=_CData)
 
 class ProcessError(Exception): ...
@@ -39,10 +38,8 @@ class BaseContext:
     # multiprocessing.*, so the signatures should be identical (modulo self).
     @staticmethod
     def current_process() -> BaseProcess: ...
-    if sys.version_info >= (3, 8):
-        @staticmethod
-        def parent_process() -> BaseProcess | None: ...
-
+    @staticmethod
+    def parent_process() -> BaseProcess | None: ...
     @staticmethod
     def active_children() -> list[BaseProcess]: ...
     def cpu_count(self) -> int: ...
@@ -51,10 +48,13 @@ class BaseContext:
     # N.B. Keep this in sync with multiprocessing.connection.Pipe.
     # _ConnectionBase is the common base class of Connection and PipeConnection
     # and can be used in cross-platform code.
+    #
+    # The two connections should have the same generic types but inverted (Connection[_T1, _T2], Connection[_T2, _T1]).
+    # However, TypeVars scoped entirely within a return annotation is unspecified in the spec.
     if sys.platform != "win32":
-        def Pipe(self, duplex: bool = True) -> tuple[Connection, Connection]: ...
+        def Pipe(self, duplex: bool = True) -> tuple[Connection[Any, Any], Connection[Any, Any]]: ...
     else:
-        def Pipe(self, duplex: bool = True) -> tuple[PipeConnection, PipeConnection]: ...
+        def Pipe(self, duplex: bool = True) -> tuple[PipeConnection[Any, Any], PipeConnection[Any, Any]]: ...
 
     def Barrier(
         self, parties: int, action: Callable[..., object] | None = None, timeout: float | None = None
@@ -84,19 +84,33 @@ class BaseContext:
     @overload
     def RawArray(self, typecode_or_type: str, size_or_initializer: int | Sequence[Any]) -> Any: ...
     @overload
-    def Value(self, typecode_or_type: type[_CT], *args: Any, lock: Literal[False]) -> _CT: ...
+    def Value(
+        self, typecode_or_type: type[_SimpleCData[_T]], *args: Any, lock: Literal[True] | _LockLike = True
+    ) -> Synchronized[_T]: ...
+    @overload
+    def Value(self, typecode_or_type: type[_CT], *args: Any, lock: Literal[False]) -> Synchronized[_CT]: ...
     @overload
-    def Value(self, typecode_or_type: type[_CT], *args: Any, lock: Literal[True] | _LockLike = True) -> SynchronizedBase[_CT]: ...
+    def Value(self, typecode_or_type: type[_CT], *args: Any, lock: Literal[True] | _LockLike = True) -> Synchronized[_CT]: ...
     @overload
-    def Value(self, typecode_or_type: str, *args: Any, lock: Literal[True] | _LockLike = True) -> SynchronizedBase[Any]: ...
+    def Value(self, typecode_or_type: str, *args: Any, lock: Literal[True] | _LockLike = True) -> Synchronized[Any]: ...
     @overload
     def Value(self, typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True) -> Any: ...
     @overload
-    def Array(self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]) -> _CT: ...
+    def Array(
+        self, typecode_or_type: type[_SimpleCData[_T]], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
+    ) -> SynchronizedArray[_T]: ...
+    @overload
+    def Array(
+        self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
+    ) -> SynchronizedString: ...
     @overload
     def Array(
-        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
-    ) -> SynchronizedArray[_CT]: ...
+        self,
+        typecode_or_type: type[_SimpleCData[_T]],
+        size_or_initializer: int | Sequence[Any],
+        *,
+        lock: Literal[True] | _LockLike = True,
+    ) -> SynchronizedArray[_T]: ...
     @overload
     def Array(
         self, typecode_or_type: str, size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
@@ -151,8 +165,6 @@ class DefaultContext(BaseContext):
     def __init__(self, context: BaseContext) -> None: ...
     def get_start_method(self, allow_none: bool = False) -> str: ...
     def get_all_start_methods(self) -> list[str]: ...
-    if sys.version_info < (3, 8):
-        __all__: ClassVar[list[str]]
 
 _default_context: DefaultContext
 
diff --git a/mypy/typeshed/stdlib/multiprocessing/dummy/__init__.pyi b/mypy/typeshed/stdlib/multiprocessing/dummy/__init__.pyi
index 967b57ded6c8..3cbeeb057791 100644
--- a/mypy/typeshed/stdlib/multiprocessing/dummy/__init__.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/dummy/__init__.pyi
@@ -12,8 +12,7 @@ from threading import (
     RLock as RLock,
     Semaphore as Semaphore,
 )
-from typing import Any
-from typing_extensions import Literal
+from typing import Any, Literal
 
 from .connection import Pipe as Pipe
 
@@ -58,8 +57,8 @@ Process = DummyProcess
 
 class Namespace:
     def __init__(self, **kwds: Any) -> None: ...
-    def __getattr__(self, __name: str) -> Any: ...
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
+    def __getattr__(self, name: str, /) -> Any: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
 
 class Value:
     _typecode: Any
diff --git a/mypy/typeshed/stdlib/multiprocessing/forkserver.pyi b/mypy/typeshed/stdlib/multiprocessing/forkserver.pyi
index 9a15f2683b7d..31b982856355 100644
--- a/mypy/typeshed/stdlib/multiprocessing/forkserver.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/forkserver.pyi
@@ -1,12 +1,12 @@
 from _typeshed import FileDescriptorLike, Unused
 from collections.abc import Sequence
 from struct import Struct
-from typing import Any
+from typing import Any, Final
 
 __all__ = ["ensure_running", "get_inherited_fds", "connect_to_new_process", "set_forkserver_preload"]
 
-MAXFDS_TO_SEND: int
-SIGNED_STRUCT: Struct
+MAXFDS_TO_SEND: Final = 256
+SIGNED_STRUCT: Final[Struct]
 
 class ForkServer:
     def set_forkserver_preload(self, modules_names: list[str]) -> None: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/managers.pyi b/mypy/typeshed/stdlib/multiprocessing/managers.pyi
index 27a903fb9987..ad5697e0ab1c 100644
--- a/mypy/typeshed/stdlib/multiprocessing/managers.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/managers.pyi
@@ -4,19 +4,16 @@ import threading
 from _typeshed import SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
 from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping, MutableSequence, Sequence
 from types import TracebackType
-from typing import Any, AnyStr, ClassVar, Generic, TypeVar, overload
-from typing_extensions import Self, SupportsIndex, TypeAlias
+from typing import Any, AnyStr, ClassVar, Generic, SupportsIndex, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
-from .connection import Connection
+from . import pool
+from .connection import Connection, _Address
 from .context import BaseContext
+from .shared_memory import _SLT, ShareableList as _ShareableList, SharedMemory as _SharedMemory
+from .util import Finalize as _Finalize
 
-if sys.version_info >= (3, 8):
-    from .shared_memory import _SLT, ShareableList as _ShareableList, SharedMemory as _SharedMemory
-
-    __all__ = ["BaseManager", "SyncManager", "BaseProxy", "Token", "SharedMemoryManager"]
-
-else:
-    __all__ = ["BaseManager", "SyncManager", "BaseProxy", "Token"]
+__all__ = ["BaseManager", "SyncManager", "BaseProxy", "Token", "SharedMemoryManager"]
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -27,21 +24,21 @@ _VT = TypeVar("_VT")
 
 class Namespace:
     def __init__(self, **kwds: Any) -> None: ...
-    def __getattr__(self, __name: str) -> Any: ...
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
+    def __getattr__(self, name: str, /) -> Any: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
 
 _Namespace: TypeAlias = Namespace
 
 class Token:
     typeid: str | bytes | None
-    address: tuple[str | bytes, int]
+    address: _Address | None
     id: str | bytes | int | None
-    def __init__(self, typeid: bytes | str | None, address: tuple[str | bytes, int], id: str | bytes | int | None) -> None: ...
+    def __init__(self, typeid: bytes | str | None, address: _Address | None, id: str | bytes | int | None) -> None: ...
     def __getstate__(self) -> tuple[str | bytes | None, tuple[str | bytes, int], str | bytes | int | None]: ...
     def __setstate__(self, state: tuple[str | bytes | None, tuple[str | bytes, int], str | bytes | int | None]) -> None: ...
 
 class BaseProxy:
-    _address_to_local: dict[Any, Any]
+    _address_to_local: dict[_Address, Any]
     _mutex: Any
     def __init__(
         self,
@@ -63,51 +60,85 @@ class ValueProxy(BaseProxy, Generic[_T]):
     def set(self, value: _T) -> None: ...
     value: _T
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class DictProxy(BaseProxy, MutableMapping[_KT, _VT]):
-    __builtins__: ClassVar[dict[str, Any]]
-    def __len__(self) -> int: ...
-    def __getitem__(self, __key: _KT) -> _VT: ...
-    def __setitem__(self, __key: _KT, __value: _VT) -> None: ...
-    def __delitem__(self, __key: _KT) -> None: ...
-    def __iter__(self) -> Iterator[_KT]: ...
-    def copy(self) -> dict[_KT, _VT]: ...
-    @overload
-    def get(self, __key: _KT) -> _VT | None: ...
-    @overload
-    def get(self, __key: _KT, __default: _VT | _T) -> _VT | _T: ...
-    @overload
-    def pop(self, __key: _KT) -> _VT: ...
-    @overload
-    def pop(self, __key: _KT, __default: _VT | _T) -> _VT | _T: ...
-    def keys(self) -> list[_KT]: ...  # type: ignore[override]
-    def items(self) -> list[tuple[_KT, _VT]]: ...  # type: ignore[override]
-    def values(self) -> list[_VT]: ...  # type: ignore[override]
+if sys.version_info >= (3, 13):
+    class _BaseDictProxy(BaseProxy, MutableMapping[_KT, _VT]):
+        __builtins__: ClassVar[dict[str, Any]]
+        def __len__(self) -> int: ...
+        def __getitem__(self, key: _KT, /) -> _VT: ...
+        def __setitem__(self, key: _KT, value: _VT, /) -> None: ...
+        def __delitem__(self, key: _KT, /) -> None: ...
+        def __iter__(self) -> Iterator[_KT]: ...
+        def copy(self) -> dict[_KT, _VT]: ...
+        @overload  # type: ignore[override]
+        def get(self, key: _KT, /) -> _VT | None: ...
+        @overload
+        def get(self, key: _KT, default: _VT, /) -> _VT: ...
+        @overload
+        def get(self, key: _KT, default: _T, /) -> _VT | _T: ...
+        @overload
+        def pop(self, key: _KT, /) -> _VT: ...
+        @overload
+        def pop(self, key: _KT, default: _VT, /) -> _VT: ...
+        @overload
+        def pop(self, key: _KT, default: _T, /) -> _VT | _T: ...
+        def keys(self) -> list[_KT]: ...  # type: ignore[override]
+        def items(self) -> list[tuple[_KT, _VT]]: ...  # type: ignore[override]
+        def values(self) -> list[_VT]: ...  # type: ignore[override]
+
+    class DictProxy(_BaseDictProxy[_KT, _VT]):
+        def __class_getitem__(cls, args: Any, /) -> GenericAlias: ...
+
+else:
+    class DictProxy(BaseProxy, MutableMapping[_KT, _VT]):
+        __builtins__: ClassVar[dict[str, Any]]
+        def __len__(self) -> int: ...
+        def __getitem__(self, key: _KT, /) -> _VT: ...
+        def __setitem__(self, key: _KT, value: _VT, /) -> None: ...
+        def __delitem__(self, key: _KT, /) -> None: ...
+        def __iter__(self) -> Iterator[_KT]: ...
+        def copy(self) -> dict[_KT, _VT]: ...
+        @overload  # type: ignore[override]
+        def get(self, key: _KT, /) -> _VT | None: ...
+        @overload
+        def get(self, key: _KT, default: _VT, /) -> _VT: ...
+        @overload
+        def get(self, key: _KT, default: _T, /) -> _VT | _T: ...
+        @overload
+        def pop(self, key: _KT, /) -> _VT: ...
+        @overload
+        def pop(self, key: _KT, default: _VT, /) -> _VT: ...
+        @overload
+        def pop(self, key: _KT, default: _T, /) -> _VT | _T: ...
+        def keys(self) -> list[_KT]: ...  # type: ignore[override]
+        def items(self) -> list[tuple[_KT, _VT]]: ...  # type: ignore[override]
+        def values(self) -> list[_VT]: ...  # type: ignore[override]
 
 class BaseListProxy(BaseProxy, MutableSequence[_T]):
     __builtins__: ClassVar[dict[str, Any]]
     def __len__(self) -> int: ...
-    def __add__(self, __x: list[_T]) -> list[_T]: ...
-    def __delitem__(self, __i: SupportsIndex | slice) -> None: ...
+    def __add__(self, x: list[_T], /) -> list[_T]: ...
+    def __delitem__(self, i: SupportsIndex | slice, /) -> None: ...
     @overload
-    def __getitem__(self, __i: SupportsIndex) -> _T: ...
+    def __getitem__(self, i: SupportsIndex, /) -> _T: ...
     @overload
-    def __getitem__(self, __s: slice) -> list[_T]: ...
+    def __getitem__(self, s: slice, /) -> list[_T]: ...
     @overload
-    def __setitem__(self, __i: SupportsIndex, __o: _T) -> None: ...
+    def __setitem__(self, i: SupportsIndex, o: _T, /) -> None: ...
     @overload
-    def __setitem__(self, __s: slice, __o: Iterable[_T]) -> None: ...
-    def __mul__(self, __n: SupportsIndex) -> list[_T]: ...
-    def __rmul__(self, __n: SupportsIndex) -> list[_T]: ...
+    def __setitem__(self, s: slice, o: Iterable[_T], /) -> None: ...
+    def __mul__(self, n: SupportsIndex, /) -> list[_T]: ...
+    def __rmul__(self, n: SupportsIndex, /) -> list[_T]: ...
+    def __imul__(self, value: SupportsIndex, /) -> Self: ...
     def __reversed__(self) -> Iterator[_T]: ...
-    def append(self, __object: _T) -> None: ...
-    def extend(self, __iterable: Iterable[_T]) -> None: ...
-    def pop(self, __index: SupportsIndex = ...) -> _T: ...
-    def index(self, __value: _T, __start: SupportsIndex = ..., __stop: SupportsIndex = ...) -> int: ...
-    def count(self, __value: _T) -> int: ...
-    def insert(self, __index: SupportsIndex, __object: _T) -> None: ...
-    def remove(self, __value: _T) -> None: ...
+    def append(self, object: _T, /) -> None: ...
+    def extend(self, iterable: Iterable[_T], /) -> None: ...
+    def pop(self, index: SupportsIndex = ..., /) -> _T: ...
+    def index(self, value: _T, start: SupportsIndex = ..., stop: SupportsIndex = ..., /) -> int: ...
+    def count(self, value: _T, /) -> int: ...
+    def insert(self, index: SupportsIndex, object: _T, /) -> None: ...
+    def remove(self, value: _T, /) -> None: ...
     # Use BaseListProxy[SupportsRichComparisonT] for the first overload rather than [SupportsRichComparison]
     # to work around invariance
     @overload
@@ -116,23 +147,55 @@ class BaseListProxy(BaseProxy, MutableSequence[_T]):
     def sort(self, *, key: Callable[[_T], SupportsRichComparison], reverse: bool = ...) -> None: ...
 
 class ListProxy(BaseListProxy[_T]):
-    def __iadd__(self, __value: Iterable[_T]) -> Self: ...  # type: ignore[override]
-    def __imul__(self, __value: SupportsIndex) -> Self: ...  # type: ignore[override]
+    def __iadd__(self, value: Iterable[_T], /) -> Self: ...  # type: ignore[override]
+    def __imul__(self, value: SupportsIndex, /) -> Self: ...  # type: ignore[override]
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, args: Any, /) -> Any: ...
+
+# Send is (kind, result)
+# Receive is (id, methodname, args, kwds)
+_ServerConnection: TypeAlias = Connection[tuple[str, Any], tuple[str, str, Iterable[Any], Mapping[str, Any]]]
 
 # Returned by BaseManager.get_server()
 class Server:
-    address: Any
+    address: _Address | None
+    id_to_obj: dict[str, tuple[Any, set[str], dict[str, str]]]
+    fallback_mapping: dict[str, Callable[[_ServerConnection, str, Any], Any]]
+    public: list[str]
+    # Registry values are (callable, exposed, method_to_typeid, proxytype)
     def __init__(
-        self, registry: dict[str, tuple[Callable[..., Any], Any, Any, Any]], address: Any, authkey: bytes, serializer: str
+        self,
+        registry: dict[str, tuple[Callable[..., Any], Iterable[str], dict[str, str], Any]],
+        address: _Address | None,
+        authkey: bytes,
+        serializer: str,
     ) -> None: ...
     def serve_forever(self) -> None: ...
-    def accept_connection(self, c: Connection, name: str) -> None: ...
+    def accepter(self) -> None: ...
+    if sys.version_info >= (3, 10):
+        def handle_request(self, conn: _ServerConnection) -> None: ...
+    else:
+        def handle_request(self, c: _ServerConnection) -> None: ...
+
+    def serve_client(self, conn: _ServerConnection) -> None: ...
+    def fallback_getvalue(self, conn: _ServerConnection, ident: str, obj: _T) -> _T: ...
+    def fallback_str(self, conn: _ServerConnection, ident: str, obj: Any) -> str: ...
+    def fallback_repr(self, conn: _ServerConnection, ident: str, obj: Any) -> str: ...
+    def dummy(self, c: _ServerConnection) -> None: ...
+    def debug_info(self, c: _ServerConnection) -> str: ...
+    def number_of_objects(self, c: _ServerConnection) -> int: ...
+    def shutdown(self, c: _ServerConnection) -> None: ...
+    def create(self, c: _ServerConnection, typeid: str, /, *args: Any, **kwds: Any) -> tuple[str, tuple[str, ...]]: ...
+    def get_methods(self, c: _ServerConnection, token: Token) -> set[str]: ...
+    def accept_connection(self, c: _ServerConnection, name: str) -> None: ...
+    def incref(self, c: _ServerConnection, ident: str) -> None: ...
+    def decref(self, c: _ServerConnection, ident: str) -> None: ...
 
 class BaseManager:
     if sys.version_info >= (3, 11):
         def __init__(
             self,
-            address: Any | None = None,
+            address: _Address | None = None,
             authkey: bytes | None = None,
             serializer: str = "pickle",
             ctx: BaseContext | None = None,
@@ -142,7 +205,7 @@ class BaseManager:
     else:
         def __init__(
             self,
-            address: Any | None = None,
+            address: _Address | None = None,
             authkey: bytes | None = None,
             serializer: str = "pickle",
             ctx: BaseContext | None = None,
@@ -151,10 +214,10 @@ class BaseManager:
     def get_server(self) -> Server: ...
     def connect(self) -> None: ...
     def start(self, initializer: Callable[..., object] | None = None, initargs: Iterable[Any] = ()) -> None: ...
-    def shutdown(self) -> None: ...  # only available after start() was called
+    shutdown: _Finalize  # only available after start() was called
     def join(self, timeout: float | None = None) -> None: ...  # undocumented
     @property
-    def address(self) -> Any: ...
+    def address(self) -> _Address | None: ...
     @classmethod
     def register(
         cls,
@@ -171,14 +234,26 @@ class BaseManager:
     ) -> None: ...
 
 class SyncManager(BaseManager):
-    def BoundedSemaphore(self, value: Any = ...) -> threading.BoundedSemaphore: ...
-    def Condition(self, lock: Any = ...) -> threading.Condition: ...
+    def Barrier(
+        self, parties: int, action: Callable[[], None] | None = None, timeout: float | None = None
+    ) -> threading.Barrier: ...
+    def BoundedSemaphore(self, value: int = 1) -> threading.BoundedSemaphore: ...
+    def Condition(self, lock: threading.Lock | threading._RLock | None = None) -> threading.Condition: ...
     def Event(self) -> threading.Event: ...
     def Lock(self) -> threading.Lock: ...
     def Namespace(self) -> _Namespace: ...
+    def Pool(
+        self,
+        processes: int | None = None,
+        initializer: Callable[..., object] | None = None,
+        initargs: Iterable[Any] = (),
+        maxtasksperchild: int | None = None,
+        context: Any | None = None,
+    ) -> pool.Pool: ...
     def Queue(self, maxsize: int = ...) -> queue.Queue[Any]: ...
+    def JoinableQueue(self, maxsize: int = ...) -> queue.Queue[Any]: ...
     def RLock(self) -> threading.RLock: ...
-    def Semaphore(self, value: Any = ...) -> threading.Semaphore: ...
+    def Semaphore(self, value: int = 1) -> threading.Semaphore: ...
     def Array(self, typecode: Any, sequence: Sequence[_T]) -> Sequence[_T]: ...
     def Value(self, typecode: Any, value: _T) -> ValueProxy[_T]: ...
     # Overloads are copied from builtins.dict.__init__
@@ -187,28 +262,31 @@ class SyncManager(BaseManager):
     @overload
     def dict(self, **kwargs: _VT) -> DictProxy[str, _VT]: ...
     @overload
-    def dict(self, __map: SupportsKeysAndGetItem[_KT, _VT]) -> DictProxy[_KT, _VT]: ...
+    def dict(self, map: SupportsKeysAndGetItem[_KT, _VT], /) -> DictProxy[_KT, _VT]: ...
     @overload
-    def dict(self, __map: SupportsKeysAndGetItem[str, _VT], **kwargs: _VT) -> DictProxy[str, _VT]: ...
+    def dict(self, map: SupportsKeysAndGetItem[str, _VT], /, **kwargs: _VT) -> DictProxy[str, _VT]: ...
     @overload
-    def dict(self, __iterable: Iterable[tuple[_KT, _VT]]) -> DictProxy[_KT, _VT]: ...
+    def dict(self, iterable: Iterable[tuple[_KT, _VT]], /) -> DictProxy[_KT, _VT]: ...
     @overload
-    def dict(self, __iterable: Iterable[tuple[str, _VT]], **kwargs: _VT) -> DictProxy[str, _VT]: ...
+    def dict(self, iterable: Iterable[tuple[str, _VT]], /, **kwargs: _VT) -> DictProxy[str, _VT]: ...
     @overload
-    def dict(self, __iterable: Iterable[list[str]]) -> DictProxy[str, str]: ...
+    def dict(self, iterable: Iterable[list[str]], /) -> DictProxy[str, str]: ...
     @overload
-    def dict(self, __iterable: Iterable[list[bytes]]) -> DictProxy[bytes, bytes]: ...
+    def dict(self, iterable: Iterable[list[bytes]], /) -> DictProxy[bytes, bytes]: ...
     @overload
-    def list(self, __sequence: Sequence[_T]) -> ListProxy[_T]: ...
+    def list(self, sequence: Sequence[_T], /) -> ListProxy[_T]: ...
     @overload
     def list(self) -> ListProxy[Any]: ...
 
 class RemoteError(Exception): ...
 
-if sys.version_info >= (3, 8):
-    class SharedMemoryServer(Server): ...
+class SharedMemoryServer(Server):
+    def track_segment(self, c: _ServerConnection, segment_name: str) -> None: ...
+    def release_segment(self, c: _ServerConnection, segment_name: str) -> None: ...
+    def list_segments(self, c: _ServerConnection) -> list[str]: ...
 
-    class SharedMemoryManager(BaseManager):
-        def get_server(self) -> SharedMemoryServer: ...
-        def SharedMemory(self, size: int) -> _SharedMemory: ...
-        def ShareableList(self, sequence: Iterable[_SLT] | None) -> _ShareableList[_SLT]: ...
+class SharedMemoryManager(BaseManager):
+    def get_server(self) -> SharedMemoryServer: ...
+    def SharedMemory(self, size: int) -> _SharedMemory: ...
+    def ShareableList(self, sequence: Iterable[_SLT] | None) -> _ShareableList[_SLT]: ...
+    def __del__(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/pool.pyi b/mypy/typeshed/stdlib/multiprocessing/pool.pyi
index dd4b865a3574..93197e5d4265 100644
--- a/mypy/typeshed/stdlib/multiprocessing/pool.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/pool.pyi
@@ -1,8 +1,9 @@
 import sys
 from collections.abc import Callable, Iterable, Iterator, Mapping
+from multiprocessing.context import DefaultContext, Process
 from types import TracebackType
-from typing import Any, Generic, TypeVar
-from typing_extensions import Literal, Self
+from typing import Any, Final, Generic, TypeVar
+from typing_extensions import Self
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -13,54 +14,31 @@ _S = TypeVar("_S")
 _T = TypeVar("_T")
 
 class ApplyResult(Generic[_T]):
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self, pool: Pool, callback: Callable[[_T], object] | None, error_callback: Callable[[BaseException], object] | None
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            cache: dict[int, ApplyResult[Any]],
-            callback: Callable[[_T], object] | None,
-            error_callback: Callable[[BaseException], object] | None,
-        ) -> None: ...
-
+    def __init__(
+        self, pool: Pool, callback: Callable[[_T], object] | None, error_callback: Callable[[BaseException], object] | None
+    ) -> None: ...
     def get(self, timeout: float | None = None) -> _T: ...
     def wait(self, timeout: float | None = None) -> None: ...
     def ready(self) -> bool: ...
     def successful(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # alias created during issue #17805
 AsyncResult = ApplyResult
 
 class MapResult(ApplyResult[list[_T]]):
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            pool: Pool,
-            chunksize: int,
-            length: int,
-            callback: Callable[[list[_T]], object] | None,
-            error_callback: Callable[[BaseException], object] | None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            cache: dict[int, ApplyResult[Any]],
-            chunksize: int,
-            length: int,
-            callback: Callable[[list[_T]], object] | None,
-            error_callback: Callable[[BaseException], object] | None,
-        ) -> None: ...
+    def __init__(
+        self,
+        pool: Pool,
+        chunksize: int,
+        length: int,
+        callback: Callable[[list[_T]], object] | None,
+        error_callback: Callable[[BaseException], object] | None,
+    ) -> None: ...
 
 class IMapIterator(Iterator[_T]):
-    if sys.version_info >= (3, 8):
-        def __init__(self, pool: Pool) -> None: ...
-    else:
-        def __init__(self, cache: dict[int, IMapIterator[Any]]) -> None: ...
-
+    def __init__(self, pool: Pool) -> None: ...
     def __iter__(self) -> Self: ...
     def next(self, timeout: float | None = None) -> _T: ...
     def __next__(self, timeout: float | None = None) -> _T: ...
@@ -76,6 +54,8 @@ class Pool:
         maxtasksperchild: int | None = None,
         context: Any | None = None,
     ) -> None: ...
+    @staticmethod
+    def Process(ctx: DefaultContext, *args: Any, **kwds: Any) -> Process: ...
     def apply(self, func: Callable[..., _T], args: Iterable[Any] = (), kwds: Mapping[str, Any] = {}) -> _T: ...
     def apply_async(
         self,
@@ -91,7 +71,7 @@ class Pool:
         func: Callable[[_S], _T],
         iterable: Iterable[_S],
         chunksize: int | None = None,
-        callback: Callable[[_T], object] | None = None,
+        callback: Callable[[list[_T]], object] | None = None,
         error_callback: Callable[[BaseException], object] | None = None,
     ) -> MapResult[_T]: ...
     def imap(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: int | None = 1) -> IMapIterator[_T]: ...
@@ -102,7 +82,7 @@ class Pool:
         func: Callable[..., _T],
         iterable: Iterable[Iterable[Any]],
         chunksize: int | None = None,
-        callback: Callable[[_T], object] | None = None,
+        callback: Callable[[list[_T]], object] | None = None,
         error_callback: Callable[[BaseException], object] | None = None,
     ) -> AsyncResult[list[_T]]: ...
     def close(self) -> None: ...
@@ -112,6 +92,7 @@ class Pool:
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
+    def __del__(self) -> None: ...
 
 class ThreadPool(Pool):
     def __init__(
@@ -119,12 +100,7 @@ class ThreadPool(Pool):
     ) -> None: ...
 
 # undocumented
-if sys.version_info >= (3, 8):
-    INIT: Literal["INIT"]
-    RUN: Literal["RUN"]
-    CLOSE: Literal["CLOSE"]
-    TERMINATE: Literal["TERMINATE"]
-else:
-    RUN: Literal[0]
-    CLOSE: Literal[1]
-    TERMINATE: Literal[2]
+INIT: Final = "INIT"
+RUN: Final = "RUN"
+CLOSE: Final = "CLOSE"
+TERMINATE: Final = "TERMINATE"
diff --git a/mypy/typeshed/stdlib/multiprocessing/popen_spawn_win32.pyi b/mypy/typeshed/stdlib/multiprocessing/popen_spawn_win32.pyi
index 3dc9d5bd7332..481b9eec5a37 100644
--- a/mypy/typeshed/stdlib/multiprocessing/popen_spawn_win32.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/popen_spawn_win32.pyi
@@ -1,16 +1,16 @@
 import sys
 from multiprocessing.process import BaseProcess
-from typing import ClassVar
+from typing import ClassVar, Final
 
 from .util import Finalize
 
 if sys.platform == "win32":
     __all__ = ["Popen"]
 
-    TERMINATE: int
-    WINEXE: bool
-    WINSERVICE: bool
-    WINENV: bool
+    TERMINATE: Final[int]
+    WINEXE: Final[bool]
+    WINSERVICE: Final[bool]
+    WINENV: Final[bool]
 
     class Popen:
         finalizer: Finalize
diff --git a/mypy/typeshed/stdlib/multiprocessing/process.pyi b/mypy/typeshed/stdlib/multiprocessing/process.pyi
index 9863013fc05f..4d129b27b0e8 100644
--- a/mypy/typeshed/stdlib/multiprocessing/process.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/process.pyi
@@ -1,11 +1,7 @@
-import sys
 from collections.abc import Callable, Iterable, Mapping
 from typing import Any
 
-if sys.version_info >= (3, 8):
-    __all__ = ["BaseProcess", "current_process", "active_children", "parent_process"]
-else:
-    __all__ = ["BaseProcess", "current_process", "active_children"]
+__all__ = ["BaseProcess", "current_process", "active_children", "parent_process"]
 
 class BaseProcess:
     name: str
@@ -40,6 +36,4 @@ class BaseProcess:
 
 def current_process() -> BaseProcess: ...
 def active_children() -> list[BaseProcess]: ...
-
-if sys.version_info >= (3, 8):
-    def parent_process() -> BaseProcess | None: ...
+def parent_process() -> BaseProcess | None: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/queues.pyi b/mypy/typeshed/stdlib/multiprocessing/queues.pyi
index a26ab7173232..581a46ea0bc8 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: ...
@@ -36,4 +38,4 @@ class SimpleQueue(Generic[_T]):
     def get(self) -> _T: ...
     def put(self, obj: _T) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/reduction.pyi b/mypy/typeshed/stdlib/multiprocessing/reduction.pyi
index e5a8cde8f849..942e92ce530e 100644
--- a/mypy/typeshed/stdlib/multiprocessing/reduction.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/reduction.pyi
@@ -1,22 +1,21 @@
 import pickle
 import sys
+from _pickle import _ReducedType
 from _typeshed import HasFileno, SupportsWrite, Unused
 from abc import ABCMeta
 from builtins import type as Type  # alias to avoid name clash
 from collections.abc import Callable
 from copyreg import _DispatchTableType
 from multiprocessing import connection
-from pickle import _ReducedType
 from socket import socket
-from typing import Any
-from typing_extensions import Literal
+from typing import Any, Final
 
 if sys.platform == "win32":
     __all__ = ["send_handle", "recv_handle", "ForkingPickler", "register", "dump", "DupHandle", "duplicate", "steal_handle"]
 else:
     __all__ = ["send_handle", "recv_handle", "ForkingPickler", "register", "dump", "DupFd", "sendfds", "recvfds"]
 
-HAVE_SEND_HANDLE: bool
+HAVE_SEND_HANDLE: Final[bool]
 
 class ForkingPickler(pickle.Pickler):
     dispatch_table: _DispatchTableType
@@ -32,26 +31,19 @@ register = ForkingPickler.register
 def dump(obj: Any, file: SupportsWrite[bytes], protocol: int | None = None) -> None: ...
 
 if sys.platform == "win32":
-    if sys.version_info >= (3, 8):
-        def duplicate(
-            handle: int, target_process: int | None = None, inheritable: bool = False, *, source_process: int | None = None
-        ) -> int: ...
-    else:
-        def duplicate(handle: int, target_process: int | None = None, inheritable: bool = False) -> int: ...
-
+    def duplicate(
+        handle: int, target_process: int | None = None, inheritable: bool = False, *, source_process: int | None = None
+    ) -> int: ...
     def steal_handle(source_pid: int, handle: int) -> int: ...
-    def send_handle(conn: connection.PipeConnection, handle: int, destination_pid: int) -> None: ...
-    def recv_handle(conn: connection.PipeConnection) -> int: ...
+    def send_handle(conn: connection.PipeConnection[DupHandle, Any], handle: int, destination_pid: int) -> None: ...
+    def recv_handle(conn: connection.PipeConnection[Any, DupHandle]) -> int: ...
 
     class DupHandle:
         def __init__(self, handle: int, access: int, pid: int | None = None) -> None: ...
         def detach(self) -> int: ...
 
 else:
-    if sys.platform == "darwin":
-        ACKNOWLEDGE: Literal[True]
-    else:
-        ACKNOWLEDGE: Literal[False]
+    ACKNOWLEDGE: Final[bool]
 
     def recvfds(sock: socket, size: int) -> list[int]: ...
     def send_handle(conn: HasFileno, handle: int, destination_pid: Unused) -> None: ...
@@ -91,4 +83,5 @@ class AbstractReducer(metaclass=ABCMeta):
         sendfds = _sendfds
         recvfds = _recvfds
         DupFd = _DupFd
+
     def __init__(self, *args: Unused) -> None: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/resource_tracker.pyi b/mypy/typeshed/stdlib/multiprocessing/resource_tracker.pyi
index 7f726a00d73a..61da7fdf1ceb 100644
--- a/mypy/typeshed/stdlib/multiprocessing/resource_tracker.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/resource_tracker.pyi
@@ -1,4 +1,4 @@
-from _typeshed import FileDescriptorOrPath, Incomplete
+from _typeshed import FileDescriptorOrPath
 from collections.abc import Sized
 
 __all__ = ["ensure_running", "register", "unregister"]
@@ -6,8 +6,8 @@ __all__ = ["ensure_running", "register", "unregister"]
 class ResourceTracker:
     def getfd(self) -> int | None: ...
     def ensure_running(self) -> None: ...
-    def register(self, name: Sized, rtype: Incomplete) -> None: ...
-    def unregister(self, name: Sized, rtype: Incomplete) -> None: ...
+    def register(self, name: Sized, rtype: str) -> None: ...
+    def unregister(self, name: Sized, rtype: str) -> None: ...
 
 _resource_tracker: ResourceTracker
 ensure_running = _resource_tracker.ensure_running
diff --git a/mypy/typeshed/stdlib/multiprocessing/shared_memory.pyi b/mypy/typeshed/stdlib/multiprocessing/shared_memory.pyi
index ae6e2a0ed19f..b63cedf85867 100644
--- a/mypy/typeshed/stdlib/multiprocessing/shared_memory.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/shared_memory.pyi
@@ -11,7 +11,11 @@ __all__ = ["SharedMemory", "ShareableList"]
 _SLT = TypeVar("_SLT", int, float, bool, str, bytes, None)
 
 class SharedMemory:
-    def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(self, name: str | None = None, create: bool = False, size: int = 0, *, track: bool = True) -> None: ...
+    else:
+        def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
+
     @property
     def buf(self) -> memoryview: ...
     @property
@@ -20,6 +24,7 @@ class SharedMemory:
     def size(self) -> int: ...
     def close(self) -> None: ...
     def unlink(self) -> None: ...
+    def __del__(self) -> None: ...
 
 class ShareableList(Generic[_SLT]):
     shm: SharedMemory
@@ -36,4 +41,4 @@ class ShareableList(Generic[_SLT]):
     def count(self, value: _SLT) -> int: ...
     def index(self, value: _SLT) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/sharedctypes.pyi b/mypy/typeshed/stdlib/multiprocessing/sharedctypes.pyi
index 686a45d9ae41..5283445d8545 100644
--- a/mypy/typeshed/stdlib/multiprocessing/sharedctypes.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/sharedctypes.pyi
@@ -1,11 +1,11 @@
 import ctypes
+from _ctypes import _CData
 from collections.abc import Callable, Iterable, Sequence
-from ctypes import _CData, _SimpleCData, c_char
+from ctypes import _SimpleCData, c_char
 from multiprocessing.context import BaseContext
 from multiprocessing.synchronize import _LockLike
 from types import TracebackType
-from typing import Any, Generic, Protocol, TypeVar, overload
-from typing_extensions import Literal
+from typing import Any, Generic, Literal, Protocol, TypeVar, overload
 
 __all__ = ["RawValue", "RawArray", "Value", "Array", "copy", "synchronized"]
 
@@ -40,12 +40,20 @@ def Array(
 ) -> _CT: ...
 @overload
 def Array(
-    typecode_or_type: type[_CT],
+    typecode_or_type: type[c_char],
     size_or_initializer: int | Sequence[Any],
     *,
     lock: Literal[True] | _LockLike = True,
     ctx: BaseContext | None = None,
-) -> SynchronizedArray[_CT]: ...
+) -> SynchronizedString: ...
+@overload
+def Array(
+    typecode_or_type: type[_SimpleCData[_T]],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[_T]: ...
 @overload
 def Array(
     typecode_or_type: str,
@@ -68,12 +76,14 @@ def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any
 @overload
 def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
 @overload
-def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
+def synchronized(
+    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
+) -> SynchronizedArray[_T]: ...
 @overload
 def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
 
 class _AcquireFunc(Protocol):
-    def __call__(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
+    def __call__(self, block: bool = ..., timeout: float | None = ..., /) -> bool: ...
 
 class SynchronizedBase(Generic[_CT]):
     acquire: _AcquireFunc
@@ -84,19 +94,36 @@ class SynchronizedBase(Generic[_CT]):
     def get_lock(self) -> _LockLike: ...
     def __enter__(self) -> bool: ...
     def __exit__(
-        self, __exc_type: type[BaseException] | None, __exc_val: BaseException | None, __exc_tb: TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
     ) -> None: ...
 
 class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
     value: _T
 
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
     def __len__(self) -> int: ...
-    def __getitem__(self, i: int) -> _CT: ...
-    def __setitem__(self, i: int, value: _CT) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_CT]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_CT]) -> None: ...
+    @overload
+    def __getitem__(self, i: slice) -> list[_T]: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
+    @overload
+    def __setitem__(self, i: int, value: _T) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
+    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
+
+class SynchronizedString(SynchronizedArray[bytes]):
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: slice) -> bytes: ...
+    @overload
+    def __getitem__(self, i: int) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: slice, value: bytes) -> None: ...
+    @overload
+    def __setitem__(self, i: int, value: bytes) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
+    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
 
-class SynchronizedString(SynchronizedArray[c_char]):
     value: bytes
     raw: bytes
diff --git a/mypy/typeshed/stdlib/multiprocessing/spawn.pyi b/mypy/typeshed/stdlib/multiprocessing/spawn.pyi
index 26ff165756bf..4a9753222897 100644
--- a/mypy/typeshed/stdlib/multiprocessing/spawn.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/spawn.pyi
@@ -1,6 +1,6 @@
 from collections.abc import Mapping, Sequence
 from types import ModuleType
-from typing import Any
+from typing import Any, Final
 
 __all__ = [
     "_main",
@@ -12,8 +12,8 @@ __all__ = [
     "import_main_path",
 ]
 
-WINEXE: bool
-WINSERVICE: bool
+WINEXE: Final[bool]
+WINSERVICE: Final[bool]
 
 def set_executable(exe: str) -> None: ...
 def get_executable() -> str: ...
@@ -23,7 +23,7 @@ def get_command_line(**kwds: Any) -> list[str]: ...
 def spawn_main(pipe_handle: int, parent_pid: int | None = None, tracker_fd: int | None = None) -> None: ...
 
 # undocumented
-def _main(fd: int) -> Any: ...
+def _main(fd: int, parent_sentinel: int) -> int: ...
 def get_preparation_data(name: str) -> dict[str, Any]: ...
 
 old_main_modules: list[ModuleType]
diff --git a/mypy/typeshed/stdlib/multiprocessing/synchronize.pyi b/mypy/typeshed/stdlib/multiprocessing/synchronize.pyi
index a4e36cfa0b6e..a0d97baa0633 100644
--- a/mypy/typeshed/stdlib/multiprocessing/synchronize.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/synchronize.pyi
@@ -1,6 +1,5 @@
 import threading
 from collections.abc import Callable
-from contextlib import AbstractContextManager
 from multiprocessing.context import BaseContext
 from types import TracebackType
 from typing_extensions import TypeAlias
@@ -11,20 +10,23 @@ _LockLike: TypeAlias = Lock | RLock
 
 class Barrier(threading.Barrier):
     def __init__(
-        self, parties: int, action: Callable[[], object] | None = None, timeout: float | None = None, *ctx: BaseContext
+        self, parties: int, action: Callable[[], object] | None = None, timeout: float | None = None, *, ctx: BaseContext
     ) -> None: ...
 
-class Condition(AbstractContextManager[bool]):
+class Condition:
     def __init__(self, lock: _LockLike | None = None, *, ctx: BaseContext) -> None: ...
     def notify(self, n: int = 1) -> None: ...
     def notify_all(self) -> None: ...
     def wait(self, timeout: float | None = None) -> bool: ...
     def wait_for(self, predicate: Callable[[], bool], timeout: float | None = None) -> bool: ...
-    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
-    def release(self) -> None: ...
+    def __enter__(self) -> bool: ...
     def __exit__(
-        self, __exc_type: type[BaseException] | None, __exc_val: BaseException | None, __exc_tb: TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
     ) -> None: ...
+    # These methods are copied from the lock passed to the constructor, or an
+    # instance of ctx.RLock() if lock was None.
+    def acquire(self, block: bool = True, timeout: float | None = None) -> bool: ...
+    def release(self) -> None: ...
 
 class Event:
     def __init__(self, *, ctx: BaseContext) -> None: ...
@@ -34,12 +36,15 @@ class Event:
     def wait(self, timeout: float | None = None) -> bool: ...
 
 # Not part of public API
-class SemLock(AbstractContextManager[bool]):
-    def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
-    def release(self) -> None: ...
+class SemLock:
+    def __init__(self, kind: int, value: int, maxvalue: int, *, ctx: BaseContext | None) -> None: ...
+    def __enter__(self) -> bool: ...
     def __exit__(
-        self, __exc_type: type[BaseException] | None, __exc_val: BaseException | None, __exc_tb: TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
     ) -> None: ...
+    # These methods are copied from the wrapped _multiprocessing.SemLock object
+    def acquire(self, block: bool = True, timeout: float | None = None) -> bool: ...
+    def release(self) -> None: ...
 
 class Lock(SemLock):
     def __init__(self, *, ctx: BaseContext) -> None: ...
@@ -49,6 +54,7 @@ class RLock(SemLock):
 
 class Semaphore(SemLock):
     def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
+    def get_value(self) -> int: ...
 
 class BoundedSemaphore(Semaphore):
     def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/util.pyi b/mypy/typeshed/stdlib/multiprocessing/util.pyi
index 7ca650511e51..d5b6384afd5e 100644
--- a/mypy/typeshed/stdlib/multiprocessing/util.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/util.pyi
@@ -1,9 +1,8 @@
 import threading
-from _typeshed import Incomplete, ReadableBuffer, SupportsTrunc, Unused
+from _typeshed import ConvertibleToInt, Incomplete, Unused
 from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence
 from logging import Logger, _Level as _LoggingLevel
-from typing import Any, SupportsInt
-from typing_extensions import SupportsIndex
+from typing import Any, Final, Generic, TypeVar, overload
 
 __all__ = [
     "sub_debug",
@@ -23,14 +22,17 @@ __all__ = [
     "SUBWARNING",
 ]
 
-NOTSET: int
-SUBDEBUG: int
-DEBUG: int
-INFO: int
-SUBWARNING: int
+_T = TypeVar("_T")
+_R_co = TypeVar("_R_co", default=Any, covariant=True)
 
-LOGGER_NAME: str
-DEFAULT_LOGGING_FORMAT: str
+NOTSET: Final[int]
+SUBDEBUG: Final[int]
+DEBUG: Final[int]
+INFO: Final[int]
+SUBWARNING: Final[int]
+
+LOGGER_NAME: Final[str]
+DEFAULT_LOGGING_FORMAT: Final[str]
 
 def sub_debug(msg: object, *args: object) -> None: ...
 def debug(msg: object, *args: object) -> None: ...
@@ -43,13 +45,29 @@ def is_abstract_socket_namespace(address: str | bytes | None) -> bool: ...
 abstract_sockets_supported: bool
 
 def get_temp_dir() -> str: ...
-def register_after_fork(obj: Incomplete, func: Callable[[Incomplete], object]) -> None: ...
+def register_after_fork(obj: _T, func: Callable[[_T], object]) -> None: ...
 
-class Finalize:
+class Finalize(Generic[_R_co]):
+    # "args" and "kwargs" are passed as arguments to "callback".
+    @overload
+    def __init__(
+        self,
+        obj: None,
+        callback: Callable[..., _R_co],
+        *,
+        args: Sequence[Any] = (),
+        kwargs: Mapping[str, Any] | None = None,
+        exitpriority: int,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self, obj: None, callback: Callable[..., _R_co], args: Sequence[Any], kwargs: Mapping[str, Any] | None, exitpriority: int
+    ) -> None: ...
+    @overload
     def __init__(
         self,
-        obj: Incomplete | None,
-        callback: Callable[..., Incomplete],
+        obj: Any,
+        callback: Callable[..., _R_co],
         args: Sequence[Any] = (),
         kwargs: Mapping[str, Any] | None = None,
         exitpriority: int | None = None,
@@ -60,7 +78,7 @@ class Finalize:
         _finalizer_registry: MutableMapping[Incomplete, Incomplete] = {},
         sub_debug: Callable[..., object] = ...,
         getpid: Callable[[], int] = ...,
-    ) -> Incomplete: ...
+    ) -> _R_co: ...
     def cancel(self) -> None: ...
     def still_active(self) -> bool: ...
 
@@ -74,12 +92,7 @@ class ForkAwareThreadLock:
 
 class ForkAwareLocal(threading.local): ...
 
-MAXFD: int
+MAXFD: Final[int]
 
 def close_all_fds_except(fds: Iterable[int]) -> None: ...
-def spawnv_passfds(
-    path: bytes,
-    # args is anything that can be passed to the int constructor
-    args: Sequence[str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc],
-    passfds: Sequence[int],
-) -> int: ...
+def spawnv_passfds(path: bytes, args: Sequence[ConvertibleToInt], passfds: Sequence[int]) -> int: ...
diff --git a/mypy/typeshed/stdlib/nntplib.pyi b/mypy/typeshed/stdlib/nntplib.pyi
index f948c1430c90..85dfbff1cb50 100644
--- a/mypy/typeshed/stdlib/nntplib.pyi
+++ b/mypy/typeshed/stdlib/nntplib.pyi
@@ -5,8 +5,8 @@ import sys
 from _typeshed import Unused
 from builtins import list as _list  # conflicts with a method named "list"
 from collections.abc import Iterable
-from typing import IO, Any, NamedTuple
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, Final, NamedTuple
+from typing_extensions import Self, TypeAlias
 
 __all__ = [
     "NNTP",
@@ -31,8 +31,8 @@ class NNTPPermanentError(NNTPError): ...
 class NNTPProtocolError(NNTPError): ...
 class NNTPDataError(NNTPError): ...
 
-NNTP_PORT: Literal[119]
-NNTP_SSL_PORT: Literal[563]
+NNTP_PORT: Final = 119
+NNTP_SSL_PORT: Final = 563
 
 class GroupInfo(NamedTuple):
     group: str
diff --git a/mypy/typeshed/stdlib/nt.pyi b/mypy/typeshed/stdlib/nt.pyi
new file mode 100644
index 000000000000..e1d57d09a9bd
--- /dev/null
+++ b/mypy/typeshed/stdlib/nt.pyi
@@ -0,0 +1,113 @@
+import sys
+
+if sys.platform == "win32":
+    # Actually defined here and re-exported from os at runtime,
+    # but this leads to less code duplication
+    from os import (
+        F_OK as F_OK,
+        O_APPEND as O_APPEND,
+        O_BINARY as O_BINARY,
+        O_CREAT as O_CREAT,
+        O_EXCL as O_EXCL,
+        O_NOINHERIT as O_NOINHERIT,
+        O_RANDOM as O_RANDOM,
+        O_RDONLY as O_RDONLY,
+        O_RDWR as O_RDWR,
+        O_SEQUENTIAL as O_SEQUENTIAL,
+        O_SHORT_LIVED as O_SHORT_LIVED,
+        O_TEMPORARY as O_TEMPORARY,
+        O_TEXT as O_TEXT,
+        O_TRUNC as O_TRUNC,
+        O_WRONLY as O_WRONLY,
+        P_DETACH as P_DETACH,
+        P_NOWAIT as P_NOWAIT,
+        P_NOWAITO as P_NOWAITO,
+        P_OVERLAY as P_OVERLAY,
+        P_WAIT as P_WAIT,
+        R_OK as R_OK,
+        TMP_MAX as TMP_MAX,
+        W_OK as W_OK,
+        X_OK as X_OK,
+        DirEntry as DirEntry,
+        abort as abort,
+        access as access,
+        chdir as chdir,
+        chmod as chmod,
+        close as close,
+        closerange as closerange,
+        cpu_count as cpu_count,
+        device_encoding as device_encoding,
+        dup as dup,
+        dup2 as dup2,
+        error as error,
+        execv as execv,
+        execve as execve,
+        fspath as fspath,
+        fstat as fstat,
+        fsync as fsync,
+        ftruncate as ftruncate,
+        get_handle_inheritable as get_handle_inheritable,
+        get_inheritable as get_inheritable,
+        get_terminal_size as get_terminal_size,
+        getcwd as getcwd,
+        getcwdb as getcwdb,
+        getlogin as getlogin,
+        getpid as getpid,
+        getppid as getppid,
+        isatty as isatty,
+        kill as kill,
+        link as link,
+        listdir as listdir,
+        lseek as lseek,
+        lstat as lstat,
+        mkdir as mkdir,
+        open as open,
+        pipe as pipe,
+        putenv as putenv,
+        read as read,
+        readlink as readlink,
+        remove as remove,
+        rename as rename,
+        replace as replace,
+        rmdir as rmdir,
+        scandir as scandir,
+        set_handle_inheritable as set_handle_inheritable,
+        set_inheritable as set_inheritable,
+        spawnv as spawnv,
+        spawnve as spawnve,
+        startfile as startfile,
+        stat as stat,
+        stat_result as stat_result,
+        statvfs_result as statvfs_result,
+        strerror as strerror,
+        symlink as symlink,
+        system as system,
+        terminal_size as terminal_size,
+        times as times,
+        times_result as times_result,
+        truncate as truncate,
+        umask as umask,
+        uname_result as uname_result,
+        unlink as unlink,
+        urandom as urandom,
+        utime as utime,
+        waitpid as waitpid,
+        write as write,
+    )
+
+    if sys.version_info >= (3, 9):
+        from os import unsetenv as unsetenv, waitstatus_to_exitcode as waitstatus_to_exitcode
+    if sys.version_info >= (3, 11):
+        from os import EX_OK as EX_OK
+    if sys.version_info >= (3, 12):
+        from os import (
+            get_blocking as get_blocking,
+            listdrives as listdrives,
+            listmounts as listmounts,
+            listvolumes as listvolumes,
+            set_blocking as set_blocking,
+        )
+    if sys.version_info >= (3, 13):
+        from os import fchmod as fchmod, lchmod as lchmod
+
+    environ: dict[str, str]
diff --git a/mypy/typeshed/stdlib/ntpath.pyi b/mypy/typeshed/stdlib/ntpath.pyi
index f1fa137c6d88..ebe305ef708c 100644
--- a/mypy/typeshed/stdlib/ntpath.pyi
+++ b/mypy/typeshed/stdlib/ntpath.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import BytesPath, StrPath
+from _typeshed import BytesPath, StrOrBytesPath, StrPath
 from genericpath import (
     commonprefix as commonprefix,
     exists as exists,
@@ -45,6 +45,11 @@ from posixpath import (
 from typing import AnyStr, overload
 from typing_extensions import LiteralString
 
+if sys.version_info >= (3, 12):
+    from posixpath import isjunction as isjunction, splitroot as splitroot
+if sys.version_info >= (3, 13):
+    from genericpath import isdevdrive as isdevdrive
+
 __all__ = [
     "normcase",
     "isabs",
@@ -85,6 +90,10 @@ __all__ = [
     "samestat",
     "commonpath",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["isjunction", "splitroot"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isdevdrive", "isreserved"]
 
 altsep: LiteralString
 
@@ -92,11 +101,11 @@ altsep: LiteralString
 # but must be defined as pos-only in the stub or cross-platform code doesn't type-check,
 # as the parameter name is different in posixpath.join()
 @overload
-def join(__path: LiteralString, *paths: LiteralString) -> LiteralString: ...
+def join(path: LiteralString, /, *paths: LiteralString) -> LiteralString: ...
 @overload
-def join(__path: StrPath, *paths: StrPath) -> str: ...
+def join(path: StrPath, /, *paths: StrPath) -> str: ...
 @overload
-def join(__path: BytesPath, *paths: BytesPath) -> bytes: ...
+def join(path: BytesPath, /, *paths: BytesPath) -> bytes: ...
 
 if sys.platform == "win32":
     if sys.version_info >= (3, 10):
@@ -112,3 +121,6 @@ if sys.platform == "win32":
 
 else:
     realpath = abspath
+
+if sys.version_info >= (3, 13):
+    def isreserved(path: StrOrBytesPath) -> bool: ...
diff --git a/mypy/typeshed/stdlib/numbers.pyi b/mypy/typeshed/stdlib/numbers.pyi
index 55f21041ae44..f2bca4e58bc5 100644
--- a/mypy/typeshed/stdlib/numbers.pyi
+++ b/mypy/typeshed/stdlib/numbers.pyi
@@ -1,129 +1,210 @@
 # Note: these stubs are incomplete. The more complex type
 # signatures are currently omitted.
+#
+# Use _ComplexLike, _RealLike and _IntegralLike for return types in this module
+# rather than `numbers.Complex`, `numbers.Real` and `numbers.Integral`,
+# to avoid an excessive number of `type: ignore`s in subclasses of these ABCs
+# (since type checkers don't see `complex` as a subtype of `numbers.Complex`,
+# nor `float` as a subtype of `numbers.Real`, etc.)
 
+from _typeshed import Incomplete
 from abc import ABCMeta, abstractmethod
-from typing import Any, SupportsFloat, overload
+from typing import ClassVar, Literal, Protocol, overload
 
 __all__ = ["Number", "Complex", "Real", "Rational", "Integral"]
 
+############################
+# Protocols for return types
+############################
+
+# `_ComplexLike` is a structural-typing approximation
+# of the `Complex` ABC, which is not (and cannot be) a protocol
+#
+# NOTE: We can't include `__complex__` here,
+# as we want `int` to be seen as a subtype of `_ComplexLike`,
+# and `int.__complex__` does not exist :(
+class _ComplexLike(Protocol):
+    def __neg__(self) -> _ComplexLike: ...
+    def __pos__(self) -> _ComplexLike: ...
+    def __abs__(self) -> _RealLike: ...
+
+# _RealLike is a structural-typing approximation
+# of the `Real` ABC, which is not (and cannot be) a protocol
+class _RealLike(_ComplexLike, Protocol):
+    def __trunc__(self) -> _IntegralLike: ...
+    def __floor__(self) -> _IntegralLike: ...
+    def __ceil__(self) -> _IntegralLike: ...
+    def __float__(self) -> float: ...
+    # Overridden from `_ComplexLike`
+    # for a more precise return type:
+    def __neg__(self) -> _RealLike: ...
+    def __pos__(self) -> _RealLike: ...
+
+# _IntegralLike is a structural-typing approximation
+# of the `Integral` ABC, which is not (and cannot be) a protocol
+class _IntegralLike(_RealLike, Protocol):
+    def __invert__(self) -> _IntegralLike: ...
+    def __int__(self) -> int: ...
+    def __index__(self) -> int: ...
+    # Overridden from `_ComplexLike`
+    # for a more precise return type:
+    def __abs__(self) -> _IntegralLike: ...
+    # Overridden from `RealLike`
+    # for a more precise return type:
+    def __neg__(self) -> _IntegralLike: ...
+    def __pos__(self) -> _IntegralLike: ...
+
+#################
+# Module "proper"
+#################
+
 class Number(metaclass=ABCMeta):
     @abstractmethod
     def __hash__(self) -> int: ...
 
-class Complex(Number):
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Complex(Number, _ComplexLike):
     @abstractmethod
     def __complex__(self) -> complex: ...
     def __bool__(self) -> bool: ...
     @property
     @abstractmethod
-    def real(self) -> Any: ...
+    def real(self) -> _RealLike: ...
     @property
     @abstractmethod
-    def imag(self) -> Any: ...
+    def imag(self) -> _RealLike: ...
     @abstractmethod
-    def __add__(self, other: Any) -> Any: ...
+    def __add__(self, other) -> _ComplexLike: ...
     @abstractmethod
-    def __radd__(self, other: Any) -> Any: ...
+    def __radd__(self, other) -> _ComplexLike: ...
     @abstractmethod
-    def __neg__(self) -> Any: ...
+    def __neg__(self) -> _ComplexLike: ...
     @abstractmethod
-    def __pos__(self) -> Any: ...
-    def __sub__(self, other: Any) -> Any: ...
-    def __rsub__(self, other: Any) -> Any: ...
+    def __pos__(self) -> _ComplexLike: ...
+    def __sub__(self, other) -> _ComplexLike: ...
+    def __rsub__(self, other) -> _ComplexLike: ...
     @abstractmethod
-    def __mul__(self, other: Any) -> Any: ...
+    def __mul__(self, other) -> _ComplexLike: ...
     @abstractmethod
-    def __rmul__(self, other: Any) -> Any: ...
+    def __rmul__(self, other) -> _ComplexLike: ...
     @abstractmethod
-    def __truediv__(self, other: Any) -> Any: ...
+    def __truediv__(self, other) -> _ComplexLike: ...
     @abstractmethod
-    def __rtruediv__(self, other: Any) -> Any: ...
+    def __rtruediv__(self, other) -> _ComplexLike: ...
     @abstractmethod
-    def __pow__(self, exponent: Any) -> Any: ...
+    def __pow__(self, exponent) -> _ComplexLike: ...
     @abstractmethod
-    def __rpow__(self, base: Any) -> Any: ...
+    def __rpow__(self, base) -> _ComplexLike: ...
     @abstractmethod
-    def __abs__(self) -> Real: ...
+    def __abs__(self) -> _RealLike: ...
     @abstractmethod
-    def conjugate(self) -> Any: ...
+    def conjugate(self) -> _ComplexLike: ...
     @abstractmethod
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
-class Real(Complex, SupportsFloat):
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Real(Complex, _RealLike):
     @abstractmethod
     def __float__(self) -> float: ...
     @abstractmethod
-    def __trunc__(self) -> int: ...
+    def __trunc__(self) -> _IntegralLike: ...
     @abstractmethod
-    def __floor__(self) -> int: ...
+    def __floor__(self) -> _IntegralLike: ...
     @abstractmethod
-    def __ceil__(self) -> int: ...
+    def __ceil__(self) -> _IntegralLike: ...
     @abstractmethod
     @overload
-    def __round__(self, ndigits: None = None) -> int: ...
+    def __round__(self, ndigits: None = None) -> _IntegralLike: ...
     @abstractmethod
     @overload
-    def __round__(self, ndigits: int) -> Any: ...
-    def __divmod__(self, other: Any) -> Any: ...
-    def __rdivmod__(self, other: Any) -> Any: ...
+    def __round__(self, ndigits: int) -> _RealLike: ...
+    def __divmod__(self, other) -> tuple[_RealLike, _RealLike]: ...
+    def __rdivmod__(self, other) -> tuple[_RealLike, _RealLike]: ...
     @abstractmethod
-    def __floordiv__(self, other: Any) -> int: ...
+    def __floordiv__(self, other) -> _RealLike: ...
     @abstractmethod
-    def __rfloordiv__(self, other: Any) -> int: ...
+    def __rfloordiv__(self, other) -> _RealLike: ...
     @abstractmethod
-    def __mod__(self, other: Any) -> Any: ...
+    def __mod__(self, other) -> _RealLike: ...
     @abstractmethod
-    def __rmod__(self, other: Any) -> Any: ...
+    def __rmod__(self, other) -> _RealLike: ...
     @abstractmethod
-    def __lt__(self, other: Any) -> bool: ...
+    def __lt__(self, other) -> bool: ...
     @abstractmethod
-    def __le__(self, other: Any) -> bool: ...
+    def __le__(self, other) -> bool: ...
     def __complex__(self) -> complex: ...
     @property
-    def real(self) -> Any: ...
+    def real(self) -> _RealLike: ...
     @property
-    def imag(self) -> Any: ...
-    def conjugate(self) -> Any: ...
+    def imag(self) -> Literal[0]: ...
+    def conjugate(self) -> _RealLike: ...
+    # Not actually overridden at runtime,
+    # but we override these in the stub to give them more precise return types:
+    @abstractmethod
+    def __pos__(self) -> _RealLike: ...
+    @abstractmethod
+    def __neg__(self) -> _RealLike: ...
 
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
 class Rational(Real):
     @property
     @abstractmethod
-    def numerator(self) -> int: ...
+    def numerator(self) -> _IntegralLike: ...
     @property
     @abstractmethod
-    def denominator(self) -> int: ...
+    def denominator(self) -> _IntegralLike: ...
     def __float__(self) -> float: ...
 
-class Integral(Rational):
+# See comment at the top of the file
+# for why some of these return types are purposefully vague
+class Integral(Rational, _IntegralLike):
     @abstractmethod
     def __int__(self) -> int: ...
     def __index__(self) -> int: ...
     @abstractmethod
-    def __pow__(self, exponent: Any, modulus: Any | None = None) -> Any: ...
+    def __pow__(self, exponent, modulus: Incomplete | None = None) -> _IntegralLike: ...
     @abstractmethod
-    def __lshift__(self, other: Any) -> Any: ...
+    def __lshift__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __rlshift__(self, other: Any) -> Any: ...
+    def __rlshift__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __rshift__(self, other: Any) -> Any: ...
+    def __rshift__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __rrshift__(self, other: Any) -> Any: ...
+    def __rrshift__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __and__(self, other: Any) -> Any: ...
+    def __and__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __rand__(self, other: Any) -> Any: ...
+    def __rand__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __xor__(self, other: Any) -> Any: ...
+    def __xor__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __rxor__(self, other: Any) -> Any: ...
+    def __rxor__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __or__(self, other: Any) -> Any: ...
+    def __or__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __ror__(self, other: Any) -> Any: ...
+    def __ror__(self, other) -> _IntegralLike: ...
     @abstractmethod
-    def __invert__(self) -> Any: ...
+    def __invert__(self) -> _IntegralLike: ...
     def __float__(self) -> float: ...
     @property
-    def numerator(self) -> int: ...
+    def numerator(self) -> _IntegralLike: ...
     @property
-    def denominator(self) -> int: ...
+    def denominator(self) -> Literal[1]: ...
+    # Not actually overridden at runtime,
+    # but we override these in the stub to give them more precise return types:
+    @abstractmethod
+    def __pos__(self) -> _IntegralLike: ...
+    @abstractmethod
+    def __neg__(self) -> _IntegralLike: ...
+    @abstractmethod
+    def __abs__(self) -> _IntegralLike: ...
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: None = None) -> _IntegralLike: ...
+    @abstractmethod
+    @overload
+    def __round__(self, ndigits: int) -> _IntegralLike: ...
diff --git a/mypy/typeshed/stdlib/opcode.pyi b/mypy/typeshed/stdlib/opcode.pyi
index 1232454e71ea..f9f76962f876 100644
--- a/mypy/typeshed/stdlib/opcode.pyi
+++ b/mypy/typeshed/stdlib/opcode.pyi
@@ -1,5 +1,5 @@
 import sys
-from typing_extensions import Literal
+from typing import Literal
 
 __all__ = [
     "cmp_op",
@@ -14,9 +14,14 @@ __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, 13):
+    __all__ += ["hasjump"]
 
 if sys.version_info >= (3, 9):
     cmp_op: tuple[Literal["<"], Literal["<="], Literal["=="], Literal["!="], Literal[">"], Literal[">="]]
@@ -42,16 +47,17 @@ 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]
+if sys.version_info >= (3, 13):
+    hasjump: list[int]
 opname: list[str]
 
 opmap: dict[str, int]
-HAVE_ARGUMENT: Literal[90]
-EXTENDED_ARG: Literal[144]
-
-if sys.version_info >= (3, 8):
-    def stack_effect(__opcode: int, __oparg: int | None = None, *, jump: bool | None = None) -> int: ...
-
-else:
-    def stack_effect(__opcode: int, __oparg: int | None = None) -> int: ...
+HAVE_ARGUMENT: int
+EXTENDED_ARG: int
 
-hasnargs: list[int]
+def stack_effect(opcode: int, oparg: int | None = None, /, *, jump: bool | None = None) -> int: ...
diff --git a/mypy/typeshed/stdlib/operator.pyi b/mypy/typeshed/stdlib/operator.pyi
index a0e5df7977da..bc2b5e026617 100644
--- a/mypy/typeshed/stdlib/operator.pyi
+++ b/mypy/typeshed/stdlib/operator.pyi
@@ -1,5 +1,66 @@
 import sys
-from _operator import *
+from _operator import (
+    abs as abs,
+    add as add,
+    and_ as and_,
+    concat as concat,
+    contains as contains,
+    countOf as countOf,
+    delitem as delitem,
+    eq as eq,
+    floordiv as floordiv,
+    ge as ge,
+    getitem as getitem,
+    gt as gt,
+    iadd as iadd,
+    iand as iand,
+    iconcat as iconcat,
+    ifloordiv as ifloordiv,
+    ilshift as ilshift,
+    imatmul as imatmul,
+    imod as imod,
+    imul as imul,
+    index as index,
+    indexOf as indexOf,
+    inv as inv,
+    invert as invert,
+    ior as ior,
+    ipow as ipow,
+    irshift as irshift,
+    is_ as is_,
+    is_not as is_not,
+    isub as isub,
+    itruediv as itruediv,
+    ixor as ixor,
+    le as le,
+    length_hint as length_hint,
+    lshift as lshift,
+    lt as lt,
+    matmul as matmul,
+    mod as mod,
+    mul as mul,
+    ne as ne,
+    neg as neg,
+    not_ as not_,
+    or_ as or_,
+    pos as pos,
+    pow as pow,
+    rshift as rshift,
+    setitem as setitem,
+    sub as sub,
+    truediv as truediv,
+    truth as truth,
+    xor as xor,
+)
+from _typeshed import SupportsGetItem
+from typing import Any, Generic, TypeVar, final, overload
+from typing_extensions import Self, TypeVarTuple, Unpack
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_Ts = TypeVarTuple("_Ts")
 
 __all__ = [
     "abs",
@@ -59,8 +120,15 @@ __all__ = [
 ]
 
 if sys.version_info >= (3, 11):
+    from _operator import call as call
+
     __all__ += ["call"]
 
+if sys.version_info >= (3, 14):
+    from _operator import is_none as is_none, is_not_none as is_not_none
+
+    __all__ += ["is_none", "is_not_none"]
+
 __lt__ = lt
 __le__ = le
 __eq__ = eq
@@ -108,3 +176,40 @@ __itruediv__ = itruediv
 __ixor__ = ixor
 if sys.version_info >= (3, 11):
     __call__ = call
+
+# At runtime, these classes are implemented in C as part of the _operator module
+# However, they consider themselves to live in the operator module, so we'll put
+# them here.
+@final
+class attrgetter(Generic[_T_co]):
+    @overload
+    def __new__(cls, attr: str, /) -> attrgetter[Any]: ...
+    @overload
+    def __new__(cls, attr: str, attr2: str, /) -> attrgetter[tuple[Any, Any]]: ...
+    @overload
+    def __new__(cls, attr: str, attr2: str, attr3: str, /) -> attrgetter[tuple[Any, Any, Any]]: ...
+    @overload
+    def __new__(cls, attr: str, attr2: str, attr3: str, attr4: str, /) -> attrgetter[tuple[Any, Any, Any, Any]]: ...
+    @overload
+    def __new__(cls, attr: str, /, *attrs: str) -> attrgetter[tuple[Any, ...]]: ...
+    def __call__(self, obj: Any, /) -> _T_co: ...
+
+@final
+class itemgetter(Generic[_T_co]):
+    @overload
+    def __new__(cls, item: _T, /) -> itemgetter[_T]: ...
+    @overload
+    def __new__(cls, item1: _T1, item2: _T2, /, *items: Unpack[_Ts]) -> itemgetter[tuple[_T1, _T2, Unpack[_Ts]]]: ...
+    # __key: _KT_contra in SupportsGetItem seems to be causing variance issues, ie:
+    # TypeVar "_KT_contra@SupportsGetItem" is contravariant
+    #   "tuple[int, int]" is incompatible with protocol "SupportsIndex"
+    # preventing [_T_co, ...] instead of [Any, ...]
+    #
+    # A suspected mypy issue prevents using [..., _T] instead of [..., Any] here.
+    # https://github.com/python/mypy/issues/14032
+    def __call__(self, obj: SupportsGetItem[Any, Any]) -> Any: ...
+
+@final
+class methodcaller:
+    def __new__(cls, name: str, /, *args: Any, **kwargs: Any) -> Self: ...
+    def __call__(self, obj: Any) -> Any: ...
diff --git a/mypy/typeshed/stdlib/optparse.pyi b/mypy/typeshed/stdlib/optparse.pyi
index a8c1c4cfb93e..56a4574bdba8 100644
--- a/mypy/typeshed/stdlib/optparse.pyi
+++ b/mypy/typeshed/stdlib/optparse.pyi
@@ -1,6 +1,9 @@
+import builtins
+from _typeshed import MaybeNone, SupportsWrite
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Mapping, Sequence
-from typing import IO, Any, AnyStr, overload
+from typing import Any, ClassVar, Final, Literal, NoReturn, overload
+from typing_extensions import Self
 
 __all__ = [
     "Option",
@@ -21,13 +24,14 @@ __all__ = [
     "BadOptionError",
     "check_choice",
 ]
+# pytype is not happy with `NO_DEFAULT: Final = ("NO", "DEFAULT")`
+NO_DEFAULT: Final[tuple[Literal["NO"], Literal["DEFAULT"]]]
+SUPPRESS_HELP: Final = "SUPPRESSHELP"
+SUPPRESS_USAGE: Final = "SUPPRESSUSAGE"
 
-NO_DEFAULT: tuple[str, ...]
-SUPPRESS_HELP: str
-SUPPRESS_USAGE: str
-
-def check_builtin(option: Option, opt: Any, value: str) -> Any: ...
-def check_choice(option: Option, opt: Any, value: str) -> str: ...
+# Can return complex, float, or int depending on the option's type
+def check_builtin(option: Option, opt: str, value: str) -> complex: ...
+def check_choice(option: Option, opt: str, value: str) -> str: ...
 
 class OptParseError(Exception):
     msg: str
@@ -54,26 +58,28 @@ class HelpFormatter:
     _short_opt_fmt: str
     current_indent: int
     default_tag: str
-    help_position: Any
-    help_width: Any
+    help_position: int
+    help_width: int | MaybeNone  # initialized as None and computed later as int when storing option strings
     indent_increment: int
     level: int
     max_help_position: int
     option_strings: dict[Option, str]
     parser: OptionParser
-    short_first: Any
+    short_first: bool | Literal[0, 1]
     width: int
-    def __init__(self, indent_increment: int, max_help_position: int, width: int | None, short_first: int) -> None: ...
+    def __init__(
+        self, indent_increment: int, max_help_position: int, width: int | None, short_first: bool | Literal[0, 1]
+    ) -> None: ...
     def dedent(self) -> None: ...
     def expand_default(self, option: Option) -> str: ...
-    def format_description(self, description: str) -> str: ...
-    def format_epilog(self, epilog: str) -> str: ...
+    def format_description(self, description: str | None) -> str: ...
+    def format_epilog(self, epilog: str | None) -> str: ...
     @abstractmethod
-    def format_heading(self, heading: Any) -> str: ...
+    def format_heading(self, heading: str) -> str: ...
     def format_option(self, option: Option) -> str: ...
     def format_option_strings(self, option: Option) -> str: ...
     @abstractmethod
-    def format_usage(self, usage: Any) -> str: ...
+    def format_usage(self, usage: str) -> str: ...
     def indent(self) -> None: ...
     def set_long_opt_delimiter(self, delim: str) -> None: ...
     def set_parser(self, parser: OptionParser) -> None: ...
@@ -82,14 +88,22 @@ class HelpFormatter:
 
 class IndentedHelpFormatter(HelpFormatter):
     def __init__(
-        self, indent_increment: int = 2, max_help_position: int = 24, width: int | None = None, short_first: int = 1
+        self,
+        indent_increment: int = 2,
+        max_help_position: int = 24,
+        width: int | None = None,
+        short_first: bool | Literal[0, 1] = 1,
     ) -> None: ...
     def format_heading(self, heading: str) -> str: ...
     def format_usage(self, usage: str) -> str: ...
 
 class TitledHelpFormatter(HelpFormatter):
     def __init__(
-        self, indent_increment: int = 0, max_help_position: int = 24, width: int | None = None, short_first: int = 0
+        self,
+        indent_increment: int = 0,
+        max_help_position: int = 24,
+        width: int | None = None,
+        short_first: bool | Literal[0, 1] = 0,
     ) -> None: ...
     def format_heading(self, heading: str) -> str: ...
     def format_usage(self, usage: str) -> str: ...
@@ -98,25 +112,46 @@ class Option:
     ACTIONS: tuple[str, ...]
     ALWAYS_TYPED_ACTIONS: tuple[str, ...]
     ATTRS: list[str]
-    CHECK_METHODS: list[Callable[..., Any]] | None
+    CHECK_METHODS: list[Callable[[Self], object]] | None
     CONST_ACTIONS: tuple[str, ...]
     STORE_ACTIONS: tuple[str, ...]
     TYPED_ACTIONS: tuple[str, ...]
     TYPES: tuple[str, ...]
-    TYPE_CHECKER: dict[str, Callable[..., Any]]
+    TYPE_CHECKER: dict[str, Callable[[Option, str, str], object]]
     _long_opts: list[str]
     _short_opts: list[str]
     action: str
+    type: str | None
     dest: str | None
-    default: Any
+    default: Any  # default can be "any" type
     nargs: int
-    type: Any
-    callback: Callable[..., Any] | None
+    const: Any | None  # const can be "any" type
+    choices: list[str] | tuple[str, ...] | None
+    # Callback args and kwargs cannot be expressed in Python's type system.
+    # Revisit if ParamSpec is ever changed to work with packed args/kwargs.
+    callback: Callable[..., object] | None
     callback_args: tuple[Any, ...] | None
     callback_kwargs: dict[str, Any] | None
     help: str | None
     metavar: str | None
-    def __init__(self, *opts: str | None, **attrs: Any) -> None: ...
+    def __init__(
+        self,
+        *opts: str | None,
+        # The following keywords are handled by the _set_attrs method. All default to
+        # `None` except for `default`, which defaults to `NO_DEFAULT`.
+        action: str | None = None,
+        type: str | builtins.type | None = None,
+        dest: str | None = None,
+        default: Any = ...,  # = NO_DEFAULT
+        nargs: int | None = None,
+        const: Any | None = None,
+        choices: list[str] | tuple[str, ...] | None = None,
+        callback: Callable[..., object] | None = None,
+        callback_args: tuple[Any, ...] | None = None,
+        callback_kwargs: dict[str, Any] | None = None,
+        help: str | None = None,
+        metavar: str | None = None,
+    ) -> None: ...
     def _check_action(self) -> None: ...
     def _check_callback(self) -> None: ...
     def _check_choice(self) -> None: ...
@@ -125,13 +160,14 @@ class Option:
     def _check_nargs(self) -> None: ...
     def _check_opt_strings(self, opts: Iterable[str | None]) -> list[str]: ...
     def _check_type(self) -> None: ...
-    def _set_attrs(self, attrs: dict[str, Any]) -> None: ...
+    def _set_attrs(self, attrs: dict[str, Any]) -> None: ...  # accepted attrs depend on the ATTRS attribute
     def _set_opt_strings(self, opts: Iterable[str]) -> None: ...
-    def check_value(self, opt: str, value: Any) -> Any: ...
-    def convert_value(self, opt: str, value: Any) -> Any: ...
+    def check_value(self, opt: str, value: str) -> Any: ...  # return type cannot be known statically
+    def convert_value(self, opt: str, value: str | tuple[str, ...] | None) -> Any: ...  # return type cannot be known statically
     def get_opt_string(self) -> str: ...
-    def process(self, opt: Any, value: Any, values: Any, parser: OptionParser) -> int: ...
-    def take_action(self, action: str, dest: str, opt: Any, value: Any, values: Any, parser: OptionParser) -> int: ...
+    def process(self, opt: str, value: str | tuple[str, ...] | None, values: Values, parser: OptionParser) -> int: ...
+    # value of take_action can be "any" type
+    def take_action(self, action: str, dest: str, opt: str, value: Any, values: Values, parser: OptionParser) -> int: ...
     def takes_value(self) -> bool: ...
 
 make_option = Option
@@ -140,28 +176,48 @@ class OptionContainer:
     _long_opt: dict[str, Option]
     _short_opt: dict[str, Option]
     conflict_handler: str
-    defaults: dict[str, Any]
-    description: Any
+    defaults: dict[str, Any]  # default values can be "any" type
+    description: str | None
     option_class: type[Option]
-    def __init__(self, option_class: type[Option], conflict_handler: Any, description: Any) -> None: ...
-    def _check_conflict(self, option: Any) -> None: ...
+    def __init__(
+        self, option_class: type[Option], conflict_handler: Literal["error", "resolve"], description: str | None
+    ) -> None: ...
+    def _check_conflict(self, option: Option) -> None: ...
     def _create_option_mappings(self) -> None: ...
     def _share_option_mappings(self, parser: OptionParser) -> None: ...
     @overload
-    def add_option(self, opt: Option) -> Option: ...
+    def add_option(self, opt: Option, /) -> Option: ...
     @overload
-    def add_option(self, *args: str | None, **kwargs: Any) -> Any: ...
+    def add_option(
+        self,
+        opt_str: str,
+        /,
+        *opts: str | None,
+        action: str | None = None,
+        type: str | builtins.type | None = None,
+        dest: str | None = None,
+        default: Any = ...,  # = NO_DEFAULT
+        nargs: int | None = None,
+        const: Any | None = None,
+        choices: list[str] | tuple[str, ...] | None = None,
+        callback: Callable[..., object] | None = None,
+        callback_args: tuple[Any, ...] | None = None,
+        callback_kwargs: dict[str, Any] | None = None,
+        help: str | None = None,
+        metavar: str | None = None,
+        **kwargs,  # Allow arbitrary keyword arguments for user defined option_class
+    ) -> Option: ...
     def add_options(self, option_list: Iterable[Option]) -> None: ...
     def destroy(self) -> None: ...
-    def format_description(self, formatter: HelpFormatter | None) -> Any: ...
-    def format_help(self, formatter: HelpFormatter | None) -> str: ...
-    def format_option_help(self, formatter: HelpFormatter | None) -> str: ...
-    def get_description(self) -> Any: ...
+    def format_option_help(self, formatter: HelpFormatter) -> str: ...
+    def format_description(self, formatter: HelpFormatter) -> str: ...
+    def format_help(self, formatter: HelpFormatter) -> str: ...
+    def get_description(self) -> str | None: ...
     def get_option(self, opt_str: str) -> Option | None: ...
     def has_option(self, opt_str: str) -> bool: ...
     def remove_option(self, opt_str: str) -> None: ...
-    def set_conflict_handler(self, handler: Any) -> None: ...
-    def set_description(self, description: Any) -> None: ...
+    def set_conflict_handler(self, handler: Literal["error", "resolve"]) -> None: ...
+    def set_description(self, description: str | None) -> None: ...
 
 class OptionGroup(OptionContainer):
     option_list: list[Option]
@@ -172,15 +228,19 @@ class OptionGroup(OptionContainer):
     def set_title(self, title: str) -> None: ...
 
 class Values:
-    def __init__(self, defaults: Mapping[str, Any] | None = None) -> None: ...
-    def _update(self, dict: Mapping[str, Any], mode: Any) -> None: ...
-    def _update_careful(self, dict: Mapping[str, Any]) -> None: ...
-    def _update_loose(self, dict: Mapping[str, Any]) -> None: ...
-    def ensure_value(self, attr: str, value: Any) -> Any: ...
-    def read_file(self, filename: str, mode: str = "careful") -> None: ...
-    def read_module(self, modname: str, mode: str = "careful") -> None: ...
+    def __init__(self, defaults: Mapping[str, object] | None = None) -> None: ...
+    def _update(self, dict: Mapping[str, object], mode: Literal["careful", "loose"]) -> None: ...
+    def _update_careful(self, dict: Mapping[str, object]) -> None: ...
+    def _update_loose(self, dict: Mapping[str, object]) -> None: ...
+    def ensure_value(self, attr: str, value: object) -> Any: ...  # return type cannot be known statically
+    def read_file(self, filename: str, mode: Literal["careful", "loose"] = "careful") -> None: ...
+    def read_module(self, modname: str, mode: Literal["careful", "loose"] = "careful") -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    # __getattr__ doesn't exist, but anything passed as a default to __init__
+    # is set on the instance.
     def __getattr__(self, name: str) -> Any: ...
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
+    # TODO mypy infers -> object for __getattr__ if __setattr__ has `value: object`
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
     def __eq__(self, other: object) -> bool: ...
 
 class OptionParser(OptionContainer):
@@ -190,9 +250,9 @@ class OptionParser(OptionContainer):
     largs: list[str] | None
     option_groups: list[OptionGroup]
     option_list: list[Option]
-    process_default_values: Any
+    process_default_values: bool
     prog: str | None
-    rargs: list[Any] | None
+    rargs: list[str] | None
     standard_option_list: list[Option]
     usage: str | None
     values: Values | None
@@ -214,39 +274,36 @@ class OptionParser(OptionContainer):
     def _add_version_option(self) -> None: ...
     def _create_option_list(self) -> None: ...
     def _get_all_options(self) -> list[Option]: ...
-    def _get_args(self, args: Iterable[Any]) -> list[Any]: ...
+    def _get_args(self, args: list[str] | None) -> list[str]: ...
     def _init_parsing_state(self) -> None: ...
     def _match_long_opt(self, opt: str) -> str: ...
-    def _populate_option_list(self, option_list: Iterable[Option], add_help: bool = True) -> None: ...
-    def _process_args(self, largs: list[Any], rargs: list[Any], values: Values) -> None: ...
-    def _process_long_opt(self, rargs: list[Any], values: Any) -> None: ...
-    def _process_short_opts(self, rargs: list[Any], values: Any) -> None: ...
+    def _populate_option_list(self, option_list: Iterable[Option] | None, add_help: bool = True) -> None: ...
+    def _process_args(self, largs: list[str], rargs: list[str], values: Values) -> None: ...
+    def _process_long_opt(self, rargs: list[str], values: Values) -> None: ...
+    def _process_short_opts(self, rargs: list[str], values: Values) -> None: ...
     @overload
-    def add_option_group(self, __opt_group: OptionGroup) -> OptionGroup: ...
+    def add_option_group(self, opt_group: OptionGroup, /) -> OptionGroup: ...
     @overload
-    def add_option_group(self, *args: Any, **kwargs: Any) -> OptionGroup: ...
+    def add_option_group(self, title: str, /, description: str | None = None) -> OptionGroup: ...
     def check_values(self, values: Values, args: list[str]) -> tuple[Values, list[str]]: ...
     def disable_interspersed_args(self) -> None: ...
     def enable_interspersed_args(self) -> None: ...
-    def error(self, msg: str) -> None: ...
-    def exit(self, status: int = 0, msg: str | None = None) -> None: ...
-    def expand_prog_name(self, s: str | None) -> Any: ...
-    def format_epilog(self, formatter: HelpFormatter) -> Any: ...
+    def error(self, msg: str) -> NoReturn: ...
+    def exit(self, status: int = 0, msg: str | None = None) -> NoReturn: ...
+    def expand_prog_name(self, s: str) -> str: ...
+    def format_epilog(self, formatter: HelpFormatter) -> str: ...
     def format_help(self, formatter: HelpFormatter | None = None) -> str: ...
     def format_option_help(self, formatter: HelpFormatter | None = None) -> str: ...
     def get_default_values(self) -> Values: ...
-    def get_option_group(self, opt_str: str) -> Any: ...
+    def get_option_group(self, opt_str: str) -> OptionGroup | None: ...
     def get_prog_name(self) -> str: ...
     def get_usage(self) -> str: ...
     def get_version(self) -> str: ...
-    @overload
-    def parse_args(self, args: None = None, values: Values | None = None) -> tuple[Values, list[str]]: ...
-    @overload
-    def parse_args(self, args: Sequence[AnyStr], values: Values | None = None) -> tuple[Values, list[AnyStr]]: ...
-    def print_usage(self, file: IO[str] | None = None) -> None: ...
-    def print_help(self, file: IO[str] | None = None) -> None: ...
-    def print_version(self, file: IO[str] | None = None) -> None: ...
-    def set_default(self, dest: Any, value: Any) -> None: ...
-    def set_defaults(self, **kwargs: Any) -> None: ...
-    def set_process_default_values(self, process: Any) -> None: ...
-    def set_usage(self, usage: str) -> None: ...
+    def parse_args(self, args: list[str] | None = None, values: Values | None = None) -> tuple[Values, list[str]]: ...
+    def print_usage(self, file: SupportsWrite[str] | None = None) -> None: ...
+    def print_help(self, file: SupportsWrite[str] | None = None) -> None: ...
+    def print_version(self, file: SupportsWrite[str] | None = None) -> None: ...
+    def set_default(self, dest: str, value: Any) -> None: ...  # default value can be "any" type
+    def set_defaults(self, **kwargs: Any) -> None: ...  # default values can be "any" type
+    def set_process_default_values(self, process: bool) -> None: ...
+    def set_usage(self, usage: str | None) -> None: ...
diff --git a/mypy/typeshed/stdlib/os/__init__.pyi b/mypy/typeshed/stdlib/os/__init__.pyi
index efe80d82ffba..4a7c03632a67 100644
--- a/mypy/typeshed/stdlib/os/__init__.pyi
+++ b/mypy/typeshed/stdlib/os/__init__.pyi
@@ -2,6 +2,7 @@ import sys
 from _typeshed import (
     AnyStr_co,
     BytesPath,
+    FileDescriptor,
     FileDescriptorLike,
     FileDescriptorOrPath,
     GenericPath,
@@ -18,20 +19,476 @@ from _typeshed import (
     WriteableBuffer,
     structseq,
 )
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from builtins import OSError
 from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping, Sequence
-from contextlib import AbstractContextManager
-from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper as _TextIOWrapper
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 from subprocess import Popen
-from typing import IO, Any, AnyStr, BinaryIO, Generic, NoReturn, Protocol, TypeVar, overload, runtime_checkable
-from typing_extensions import Final, Literal, Self, TypeAlias, final
+from types import TracebackType
+from typing import (
+    IO,
+    Any,
+    AnyStr,
+    BinaryIO,
+    Final,
+    Generic,
+    Literal,
+    NoReturn,
+    Protocol,
+    TypeVar,
+    final,
+    overload,
+    runtime_checkable,
+)
+from typing_extensions import Self, TypeAlias, Unpack, deprecated
 
 from . import path as _path
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 
+__all__ = [
+    "F_OK",
+    "O_APPEND",
+    "O_CREAT",
+    "O_EXCL",
+    "O_RDONLY",
+    "O_RDWR",
+    "O_TRUNC",
+    "O_WRONLY",
+    "P_NOWAIT",
+    "P_NOWAITO",
+    "P_WAIT",
+    "R_OK",
+    "SEEK_CUR",
+    "SEEK_END",
+    "SEEK_SET",
+    "TMP_MAX",
+    "W_OK",
+    "X_OK",
+    "DirEntry",
+    "_exit",
+    "abort",
+    "access",
+    "altsep",
+    "chdir",
+    "chmod",
+    "close",
+    "closerange",
+    "cpu_count",
+    "curdir",
+    "defpath",
+    "device_encoding",
+    "devnull",
+    "dup",
+    "dup2",
+    "environ",
+    "error",
+    "execl",
+    "execle",
+    "execlp",
+    "execlpe",
+    "execv",
+    "execve",
+    "execvp",
+    "execvpe",
+    "extsep",
+    "fdopen",
+    "fsdecode",
+    "fsencode",
+    "fspath",
+    "fstat",
+    "fsync",
+    "ftruncate",
+    "get_exec_path",
+    "get_inheritable",
+    "get_terminal_size",
+    "getcwd",
+    "getcwdb",
+    "getenv",
+    "getlogin",
+    "getpid",
+    "getppid",
+    "isatty",
+    "kill",
+    "linesep",
+    "link",
+    "listdir",
+    "lseek",
+    "lstat",
+    "makedirs",
+    "mkdir",
+    "name",
+    "open",
+    "pardir",
+    "path",
+    "pathsep",
+    "pipe",
+    "popen",
+    "putenv",
+    "read",
+    "readlink",
+    "remove",
+    "removedirs",
+    "rename",
+    "renames",
+    "replace",
+    "rmdir",
+    "scandir",
+    "sep",
+    "set_inheritable",
+    "spawnl",
+    "spawnle",
+    "spawnv",
+    "spawnve",
+    "stat",
+    "stat_result",
+    "statvfs_result",
+    "strerror",
+    "supports_bytes_environ",
+    "symlink",
+    "system",
+    "terminal_size",
+    "times",
+    "times_result",
+    "truncate",
+    "umask",
+    "uname_result",
+    "unlink",
+    "urandom",
+    "utime",
+    "waitpid",
+    "walk",
+    "write",
+]
+if sys.version_info >= (3, 9):
+    __all__ += ["waitstatus_to_exitcode"]
+if sys.platform == "darwin" and sys.version_info >= (3, 12):
+    __all__ += ["PRIO_DARWIN_BG", "PRIO_DARWIN_NONUI", "PRIO_DARWIN_PROCESS", "PRIO_DARWIN_THREAD"]
+if sys.platform == "darwin" and sys.version_info >= (3, 10):
+    __all__ += ["O_EVTONLY", "O_NOFOLLOW_ANY", "O_SYMLINK"]
+if sys.platform == "linux":
+    __all__ += [
+        "GRND_NONBLOCK",
+        "GRND_RANDOM",
+        "MFD_ALLOW_SEALING",
+        "MFD_CLOEXEC",
+        "MFD_HUGETLB",
+        "MFD_HUGE_16GB",
+        "MFD_HUGE_16MB",
+        "MFD_HUGE_1GB",
+        "MFD_HUGE_1MB",
+        "MFD_HUGE_256MB",
+        "MFD_HUGE_2GB",
+        "MFD_HUGE_2MB",
+        "MFD_HUGE_32MB",
+        "MFD_HUGE_512KB",
+        "MFD_HUGE_512MB",
+        "MFD_HUGE_64KB",
+        "MFD_HUGE_8MB",
+        "MFD_HUGE_MASK",
+        "MFD_HUGE_SHIFT",
+        "O_DIRECT",
+        "O_LARGEFILE",
+        "O_NOATIME",
+        "O_PATH",
+        "O_RSYNC",
+        "O_TMPFILE",
+        "RTLD_DEEPBIND",
+        "SCHED_BATCH",
+        "SCHED_IDLE",
+        "SCHED_RESET_ON_FORK",
+        "XATTR_CREATE",
+        "XATTR_REPLACE",
+        "XATTR_SIZE_MAX",
+        "copy_file_range",
+        "getrandom",
+        "getxattr",
+        "listxattr",
+        "memfd_create",
+        "removexattr",
+        "setxattr",
+    ]
+if sys.platform == "linux" and sys.version_info >= (3, 13):
+    __all__ += [
+        "POSIX_SPAWN_CLOSEFROM",
+        "TFD_CLOEXEC",
+        "TFD_NONBLOCK",
+        "TFD_TIMER_ABSTIME",
+        "TFD_TIMER_CANCEL_ON_SET",
+        "timerfd_create",
+        "timerfd_gettime",
+        "timerfd_gettime_ns",
+        "timerfd_settime",
+        "timerfd_settime_ns",
+    ]
+if sys.platform == "linux" and sys.version_info >= (3, 12):
+    __all__ += [
+        "CLONE_FILES",
+        "CLONE_FS",
+        "CLONE_NEWCGROUP",
+        "CLONE_NEWIPC",
+        "CLONE_NEWNET",
+        "CLONE_NEWNS",
+        "CLONE_NEWPID",
+        "CLONE_NEWTIME",
+        "CLONE_NEWUSER",
+        "CLONE_NEWUTS",
+        "CLONE_SIGHAND",
+        "CLONE_SYSVSEM",
+        "CLONE_THREAD",
+        "CLONE_VM",
+        "setns",
+        "unshare",
+        "PIDFD_NONBLOCK",
+    ]
+if sys.platform == "linux" and sys.version_info >= (3, 10):
+    __all__ += [
+        "EFD_CLOEXEC",
+        "EFD_NONBLOCK",
+        "EFD_SEMAPHORE",
+        "RWF_APPEND",
+        "SPLICE_F_MORE",
+        "SPLICE_F_MOVE",
+        "SPLICE_F_NONBLOCK",
+        "eventfd",
+        "eventfd_read",
+        "eventfd_write",
+        "splice",
+    ]
+if sys.platform == "linux" and sys.version_info >= (3, 9):
+    __all__ += ["P_PIDFD", "pidfd_open"]
+if sys.platform == "win32":
+    __all__ += [
+        "O_BINARY",
+        "O_NOINHERIT",
+        "O_RANDOM",
+        "O_SEQUENTIAL",
+        "O_SHORT_LIVED",
+        "O_TEMPORARY",
+        "O_TEXT",
+        "P_DETACH",
+        "P_OVERLAY",
+        "get_handle_inheritable",
+        "set_handle_inheritable",
+        "startfile",
+    ]
+if sys.platform == "win32" and sys.version_info >= (3, 12):
+    __all__ += ["listdrives", "listmounts", "listvolumes"]
+if sys.platform != "win32":
+    __all__ += [
+        "CLD_CONTINUED",
+        "CLD_DUMPED",
+        "CLD_EXITED",
+        "CLD_TRAPPED",
+        "EX_CANTCREAT",
+        "EX_CONFIG",
+        "EX_DATAERR",
+        "EX_IOERR",
+        "EX_NOHOST",
+        "EX_NOINPUT",
+        "EX_NOPERM",
+        "EX_NOUSER",
+        "EX_OSERR",
+        "EX_OSFILE",
+        "EX_PROTOCOL",
+        "EX_SOFTWARE",
+        "EX_TEMPFAIL",
+        "EX_UNAVAILABLE",
+        "EX_USAGE",
+        "F_LOCK",
+        "F_TEST",
+        "F_TLOCK",
+        "F_ULOCK",
+        "NGROUPS_MAX",
+        "O_ACCMODE",
+        "O_ASYNC",
+        "O_CLOEXEC",
+        "O_DIRECTORY",
+        "O_DSYNC",
+        "O_NDELAY",
+        "O_NOCTTY",
+        "O_NOFOLLOW",
+        "O_NONBLOCK",
+        "O_SYNC",
+        "POSIX_SPAWN_CLOSE",
+        "POSIX_SPAWN_DUP2",
+        "POSIX_SPAWN_OPEN",
+        "PRIO_PGRP",
+        "PRIO_PROCESS",
+        "PRIO_USER",
+        "P_ALL",
+        "P_PGID",
+        "P_PID",
+        "RTLD_GLOBAL",
+        "RTLD_LAZY",
+        "RTLD_LOCAL",
+        "RTLD_NODELETE",
+        "RTLD_NOLOAD",
+        "RTLD_NOW",
+        "SCHED_FIFO",
+        "SCHED_OTHER",
+        "SCHED_RR",
+        "SEEK_DATA",
+        "SEEK_HOLE",
+        "ST_NOSUID",
+        "ST_RDONLY",
+        "WCONTINUED",
+        "WCOREDUMP",
+        "WEXITED",
+        "WEXITSTATUS",
+        "WIFCONTINUED",
+        "WIFEXITED",
+        "WIFSIGNALED",
+        "WIFSTOPPED",
+        "WNOHANG",
+        "WNOWAIT",
+        "WSTOPPED",
+        "WSTOPSIG",
+        "WTERMSIG",
+        "WUNTRACED",
+        "chown",
+        "chroot",
+        "confstr",
+        "confstr_names",
+        "ctermid",
+        "environb",
+        "fchdir",
+        "fchown",
+        "fork",
+        "forkpty",
+        "fpathconf",
+        "fstatvfs",
+        "fwalk",
+        "getegid",
+        "getenvb",
+        "geteuid",
+        "getgid",
+        "getgrouplist",
+        "getgroups",
+        "getloadavg",
+        "getpgid",
+        "getpgrp",
+        "getpriority",
+        "getsid",
+        "getuid",
+        "initgroups",
+        "killpg",
+        "lchown",
+        "lockf",
+        "major",
+        "makedev",
+        "minor",
+        "mkfifo",
+        "mknod",
+        "nice",
+        "openpty",
+        "pathconf",
+        "pathconf_names",
+        "posix_spawn",
+        "posix_spawnp",
+        "pread",
+        "preadv",
+        "pwrite",
+        "pwritev",
+        "readv",
+        "register_at_fork",
+        "sched_get_priority_max",
+        "sched_get_priority_min",
+        "sched_yield",
+        "sendfile",
+        "setegid",
+        "seteuid",
+        "setgid",
+        "setgroups",
+        "setpgid",
+        "setpgrp",
+        "setpriority",
+        "setregid",
+        "setreuid",
+        "setsid",
+        "setuid",
+        "spawnlp",
+        "spawnlpe",
+        "spawnvp",
+        "spawnvpe",
+        "statvfs",
+        "sync",
+        "sysconf",
+        "sysconf_names",
+        "tcgetpgrp",
+        "tcsetpgrp",
+        "ttyname",
+        "uname",
+        "wait",
+        "wait3",
+        "wait4",
+        "writev",
+    ]
+if sys.platform != "win32" and sys.version_info >= (3, 13):
+    __all__ += ["grantpt", "posix_openpt", "ptsname", "unlockpt"]
+if sys.platform != "win32" and sys.version_info >= (3, 11):
+    __all__ += ["login_tty"]
+if sys.platform != "win32" and sys.version_info >= (3, 10):
+    __all__ += ["O_FSYNC"]
+if sys.platform != "win32" and sys.version_info >= (3, 9):
+    __all__ += ["CLD_KILLED", "CLD_STOPPED"]
+if sys.platform != "darwin" and sys.platform != "win32":
+    __all__ += [
+        "POSIX_FADV_DONTNEED",
+        "POSIX_FADV_NOREUSE",
+        "POSIX_FADV_NORMAL",
+        "POSIX_FADV_RANDOM",
+        "POSIX_FADV_SEQUENTIAL",
+        "POSIX_FADV_WILLNEED",
+        "RWF_DSYNC",
+        "RWF_HIPRI",
+        "RWF_NOWAIT",
+        "RWF_SYNC",
+        "ST_APPEND",
+        "ST_MANDLOCK",
+        "ST_NOATIME",
+        "ST_NODEV",
+        "ST_NODIRATIME",
+        "ST_NOEXEC",
+        "ST_RELATIME",
+        "ST_SYNCHRONOUS",
+        "ST_WRITE",
+        "fdatasync",
+        "getresgid",
+        "getresuid",
+        "pipe2",
+        "posix_fadvise",
+        "posix_fallocate",
+        "sched_getaffinity",
+        "sched_getparam",
+        "sched_getscheduler",
+        "sched_param",
+        "sched_rr_get_interval",
+        "sched_setaffinity",
+        "sched_setparam",
+        "sched_setscheduler",
+        "setresgid",
+        "setresuid",
+    ]
+if sys.platform != "linux" and sys.platform != "win32":
+    __all__ += ["O_EXLOCK", "O_SHLOCK", "chflags", "lchflags"]
+if sys.platform != "linux" and sys.platform != "win32" and sys.version_info >= (3, 13):
+    __all__ += ["O_EXEC", "O_SEARCH"]
+if sys.platform != "darwin" or sys.version_info >= (3, 13):
+    if sys.platform != "win32":
+        __all__ += ["waitid", "waitid_result"]
+if sys.platform != "win32" or sys.version_info >= (3, 13):
+    __all__ += ["fchmod"]
+    if sys.platform != "linux":
+        __all__ += ["lchmod"]
+if sys.platform != "win32" or sys.version_info >= (3, 12):
+    __all__ += ["get_blocking", "set_blocking"]
+if sys.platform != "win32" or sys.version_info >= (3, 11):
+    __all__ += ["EX_OK"]
+if sys.platform != "win32" or sys.version_info >= (3, 9):
+    __all__ += ["unsetenv"]
+
 # This unnecessary alias is to work around various errors
 path = _path
 
@@ -69,9 +526,20 @@ if sys.platform != "win32":
         POSIX_FADV_WILLNEED: int
         POSIX_FADV_DONTNEED: int
 
-    SF_NODISKIO: int
-    SF_MNOWAIT: int
-    SF_SYNC: int
+    if sys.platform != "linux" and sys.platform != "darwin":
+        # In the os-module docs, these are marked as being available
+        # on "Unix, not Emscripten, not WASI."
+        # However, in the source code, a comment indicates they're "FreeBSD constants".
+        # sys.platform could have one of many values on a FreeBSD Python build,
+        # so the sys-module docs recommend doing `if sys.platform.startswith('freebsd')`
+        # to detect FreeBSD builds. Unfortunately that would be too dynamic
+        # for type checkers, however.
+        SF_NODISKIO: int
+        SF_MNOWAIT: int
+        SF_SYNC: int
+
+        if sys.version_info >= (3, 11):
+            SF_NOCACHE: int
 
     if sys.platform == "linux":
         XATTR_SIZE_MAX: int
@@ -98,15 +566,16 @@ if sys.platform != "win32":
         CLD_KILLED: int
         CLD_STOPPED: int
 
-    # TODO: SCHED_RESET_ON_FORK not available on darwin?
-    # TODO: SCHED_BATCH and SCHED_IDLE are linux only?
-    SCHED_OTHER: int  # some flavors of Unix
-    SCHED_BATCH: int  # some flavors of Unix
-    SCHED_IDLE: int  # some flavors of Unix
-    SCHED_SPORADIC: int  # some flavors of Unix
-    SCHED_FIFO: int  # some flavors of Unix
-    SCHED_RR: int  # some flavors of Unix
-    SCHED_RESET_ON_FORK: int  # some flavors of Unix
+    SCHED_OTHER: int
+    SCHED_FIFO: int
+    SCHED_RR: int
+    if sys.platform != "darwin" and sys.platform != "linux":
+        SCHED_SPORADIC: int
+
+if sys.platform == "linux":
+    SCHED_BATCH: int
+    SCHED_IDLE: int
+    SCHED_RESET_ON_FORK: int
 
 if sys.platform != "win32":
     RTLD_LAZY: int
@@ -121,12 +590,18 @@ if sys.platform == "linux":
     GRND_NONBLOCK: int
     GRND_RANDOM: int
 
+if sys.platform == "darwin" and sys.version_info >= (3, 12):
+    PRIO_DARWIN_BG: int
+    PRIO_DARWIN_NONUI: int
+    PRIO_DARWIN_PROCESS: int
+    PRIO_DARWIN_THREAD: int
+
 SEEK_SET: int
 SEEK_CUR: int
 SEEK_END: int
 if sys.platform != "win32":
-    SEEK_DATA: int  # some flavors of Unix
-    SEEK_HOLE: int  # some flavors of Unix
+    SEEK_DATA: int
+    SEEK_HOLE: int
 
 O_RDONLY: int
 O_WRONLY: int
@@ -135,34 +610,50 @@ O_APPEND: int
 O_CREAT: int
 O_EXCL: int
 O_TRUNC: int
-# We don't use sys.platform for O_* flags to denote platform-dependent APIs because some codes,
-# including tests for mypy, use a more finer way than sys.platform before using these APIs
-# See https://github.com/python/typeshed/pull/2286 for discussions
-O_DSYNC: int  # Unix only
-O_RSYNC: int  # Unix only
-O_SYNC: int  # Unix only
-O_NDELAY: int  # Unix only
-O_NONBLOCK: int  # Unix only
-O_NOCTTY: int  # Unix only
-O_CLOEXEC: int  # Unix only
-O_SHLOCK: int  # Unix only
-O_EXLOCK: int  # Unix only
-O_BINARY: int  # Windows only
-O_NOINHERIT: int  # Windows only
-O_SHORT_LIVED: int  # Windows only
-O_TEMPORARY: int  # Windows only
-O_RANDOM: int  # Windows only
-O_SEQUENTIAL: int  # Windows only
-O_TEXT: int  # Windows only
-O_ASYNC: int  # Gnu extension if in C library
-O_DIRECT: int  # Gnu extension if in C library
-O_DIRECTORY: int  # Gnu extension if in C library
-O_NOFOLLOW: int  # Gnu extension if in C library
-O_NOATIME: int  # Gnu extension if in C library
-O_PATH: int  # Gnu extension if in C library
-O_TMPFILE: int  # Gnu extension if in C library
-O_LARGEFILE: int  # Gnu extension if in C library
-O_ACCMODE: int  # TODO: when does this exist?
+if sys.platform == "win32":
+    O_BINARY: int
+    O_NOINHERIT: int
+    O_SHORT_LIVED: int
+    O_TEMPORARY: int
+    O_RANDOM: int
+    O_SEQUENTIAL: int
+    O_TEXT: int
+
+if sys.platform != "win32":
+    O_DSYNC: int
+    O_SYNC: int
+    O_NDELAY: int
+    O_NONBLOCK: int
+    O_NOCTTY: int
+    O_CLOEXEC: int
+    O_ASYNC: int  # Gnu extension if in C library
+    O_DIRECTORY: int  # Gnu extension if in C library
+    O_NOFOLLOW: int  # Gnu extension if in C library
+    O_ACCMODE: int  # TODO: when does this exist?
+
+if sys.platform == "linux":
+    O_RSYNC: int
+    O_DIRECT: int  # Gnu extension if in C library
+    O_NOATIME: int  # Gnu extension if in C library
+    O_PATH: int  # Gnu extension if in C library
+    O_TMPFILE: int  # Gnu extension if in C library
+    O_LARGEFILE: int  # Gnu extension if in C library
+
+if sys.platform != "linux" and sys.platform != "win32":
+    O_SHLOCK: int
+    O_EXLOCK: int
+
+if sys.platform == "darwin" and sys.version_info >= (3, 10):
+    O_EVTONLY: int
+    O_NOFOLLOW_ANY: int
+    O_SYMLINK: int
+
+if sys.platform != "win32" and sys.version_info >= (3, 10):
+    O_FSYNC: int
+
+if sys.platform != "linux" and sys.platform != "win32" and sys.version_info >= (3, 13):
+    O_EXEC: int
+    O_SEARCH: int
 
 if sys.platform != "win32" and sys.platform != "darwin":
     # posix, but apparently missing on macos
@@ -230,7 +721,7 @@ class _Environ(MutableMapping[AnyStr, AnyStr], Generic[AnyStr]):
             unsetenv: Callable[[AnyStr, AnyStr], object],
         ) -> None: ...
 
-    def setdefault(self, key: AnyStr, value: AnyStr) -> AnyStr: ...  # type: ignore[override]
+    def setdefault(self, key: AnyStr, value: AnyStr) -> AnyStr: ...
     def copy(self) -> dict[AnyStr, AnyStr]: ...
     def __delitem__(self, key: AnyStr) -> None: ...
     def __getitem__(self, key: AnyStr) -> AnyStr: ...
@@ -252,12 +743,14 @@ environ: _Environ[str]
 if sys.platform != "win32":
     environb: _Environ[bytes]
 
+if sys.version_info >= (3, 11) or sys.platform != "win32":
+    EX_OK: int
+
 if sys.platform != "win32":
     confstr_names: dict[str, int]
     pathconf_names: dict[str, int]
     sysconf_names: dict[str, int]
 
-    EX_OK: int
     EX_USAGE: int
     EX_DATAERR: int
     EX_NOINPUT: int
@@ -273,6 +766,9 @@ if sys.platform != "win32":
     EX_PROTOCOL: int
     EX_NOPERM: int
     EX_CONFIG: int
+
+# Exists on some Unix platforms, e.g. Solaris.
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     EX_NOTFOUND: int
 
 P_NOWAIT: int
@@ -305,6 +801,7 @@ class stat_result(structseq[float], tuple[int, int, int, int, int, int, int, flo
     # More items may be added at the end by some implementations.
     if sys.version_info >= (3, 10):
         __match_args__: Final = ("st_mode", "st_ino", "st_dev", "st_nlink", "st_uid", "st_gid", "st_size")
+
     @property
     def st_mode(self) -> int: ...  # protection bits,
     @property
@@ -324,8 +821,18 @@ class stat_result(structseq[float], tuple[int, int, int, int, int, int, int, flo
     @property
     def st_mtime(self) -> float: ...  # time of most recent content modification,
     # platform dependent (time of most recent metadata change on Unix, or the time of creation on Windows)
-    @property
-    def st_ctime(self) -> float: ...
+    if sys.version_info >= (3, 12) and sys.platform == "win32":
+        @property
+        @deprecated(
+            """\
+Use st_birthtime instead to retrieve the file creation time. \
+In the future, this property will contain the last metadata change time."""
+        )
+        def st_ctime(self) -> float: ...
+    else:
+        @property
+        def st_ctime(self) -> float: ...
+
     @property
     def st_atime_ns(self) -> int: ...  # time of most recent access, in nanoseconds
     @property
@@ -336,9 +843,13 @@ class stat_result(structseq[float], tuple[int, int, int, int, int, int, int, flo
     if sys.platform == "win32":
         @property
         def st_file_attributes(self) -> int: ...
-        if sys.version_info >= (3, 8):
+        @property
+        def st_reparse_tag(self) -> int: ...
+        if sys.version_info >= (3, 12):
+            @property
+            def st_birthtime(self) -> float: ...  # time of file creation in seconds
             @property
-            def st_reparse_tag(self) -> int: ...
+            def st_birthtime_ns(self) -> int: ...  # time of file creation in nanoseconds
     else:
         @property
         def st_blocks(self) -> int: ...  # number of blocks allocated for file
@@ -347,21 +858,24 @@ class stat_result(structseq[float], tuple[int, int, int, int, int, int, int, flo
         @property
         def st_rdev(self) -> int: ...  # type of device if an inode device
         if sys.platform != "linux":
-            # These properties are available on MacOS, but not on Windows or Ubuntu.
+            # These properties are available on MacOS, but not Ubuntu.
             # On other Unix systems (such as FreeBSD), the following attributes may be
             # available (but may be only filled out if root tries to use them):
             @property
             def st_gen(self) -> int: ...  # file generation number
             @property
-            def st_birthtime(self) -> int: ...  # time of file creation
+            def st_birthtime(self) -> float: ...  # time of file creation in seconds
     if sys.platform == "darwin":
         @property
         def st_flags(self) -> int: ...  # user defined flags for file
     # Attributes documented as sometimes appearing, but deliberately omitted from the stub: `st_creator`, `st_rsize`, `st_type`.
     # See https://github.com/python/typeshed/pull/6560#issuecomment-991253327
 
+# mypy and pyright object to this being both ABC and Protocol.
+# At runtime it inherits from ABC and is not a Protocol, but it will be
+# on the allowlist for use as a Protocol starting in 3.14.
 @runtime_checkable
-class PathLike(Protocol[AnyStr_co]):
+class PathLike(ABC, Protocol[AnyStr_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     @abstractmethod
     def __fspath__(self) -> AnyStr_co: ...
 
@@ -387,7 +901,9 @@ class DirEntry(Generic[AnyStr]):
     def stat(self, *, follow_symlinks: bool = True) -> stat_result: ...
     def __fspath__(self) -> AnyStr: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    if sys.version_info >= (3, 12):
+        def is_junction(self) -> bool: ...
 
 @final
 class statvfs_result(structseq[int], tuple[int, int, int, int, int, int, int, int, int, int, int]):
@@ -404,6 +920,7 @@ class statvfs_result(structseq[int], tuple[int, int, int, int, int, int, int, in
             "f_flag",
             "f_namemax",
         )
+
     @property
     def f_bsize(self) -> int: ...
     @property
@@ -440,12 +957,13 @@ def get_exec_path(env: Mapping[str, str] | None = None) -> list[str]: ...
 def getlogin() -> str: ...
 def getpid() -> int: ...
 def getppid() -> int: ...
-def strerror(__code: int) -> str: ...
-def umask(__mask: int) -> int: ...
+def strerror(code: int, /) -> str: ...
+def umask(mask: int, /) -> int: ...
 @final
 class uname_result(structseq[str], tuple[str, str, str, str, str]):
     if sys.version_info >= (3, 10):
         __match_args__: Final = ("sysname", "nodename", "release", "version", "machine")
+
     @property
     def sysname(self) -> str: ...
     @property
@@ -462,9 +980,9 @@ if sys.platform != "win32":
     def getegid() -> int: ...
     def geteuid() -> int: ...
     def getgid() -> int: ...
-    def getgrouplist(__user: str, __group: int) -> list[int]: ...
+    def getgrouplist(user: str, group: int, /) -> list[int]: ...
     def getgroups() -> list[int]: ...  # Unix only, behaves differently on Mac
-    def initgroups(__username: str, __gid: int) -> None: ...
+    def initgroups(username: str, gid: int, /) -> None: ...
     def getpgid(pid: int) -> int: ...
     def getpgrp() -> int: ...
     def getpriority(which: int, who: int) -> int: ...
@@ -474,21 +992,21 @@ if sys.platform != "win32":
         def getresgid() -> tuple[int, int, int]: ...
 
     def getuid() -> int: ...
-    def setegid(__egid: int) -> None: ...
-    def seteuid(__euid: int) -> None: ...
-    def setgid(__gid: int) -> None: ...
-    def setgroups(__groups: Sequence[int]) -> None: ...
+    def setegid(egid: int, /) -> None: ...
+    def seteuid(euid: int, /) -> None: ...
+    def setgid(gid: int, /) -> None: ...
+    def setgroups(groups: Sequence[int], /) -> None: ...
     def setpgrp() -> None: ...
-    def setpgid(__pid: int, __pgrp: int) -> None: ...
-    def setregid(__rgid: int, __egid: int) -> None: ...
+    def setpgid(pid: int, pgrp: int, /) -> None: ...
+    def setregid(rgid: int, egid: int, /) -> None: ...
     if sys.platform != "darwin":
-        def setresgid(rgid: int, egid: int, sgid: int) -> None: ...
-        def setresuid(ruid: int, euid: int, suid: int) -> None: ...
+        def setresgid(rgid: int, egid: int, sgid: int, /) -> None: ...
+        def setresuid(ruid: int, euid: int, suid: int, /) -> None: ...
 
-    def setreuid(__ruid: int, __euid: int) -> None: ...
-    def getsid(__pid: int) -> int: ...
+    def setreuid(ruid: int, euid: int, /) -> None: ...
+    def getsid(pid: int, /) -> int: ...
     def setsid() -> None: ...
-    def setuid(__uid: int) -> None: ...
+    def setuid(uid: int, /) -> None: ...
     def uname() -> uname_result: ...
 
 @overload
@@ -501,14 +1019,14 @@ if sys.platform != "win32":
     def getenvb(key: bytes) -> bytes | None: ...
     @overload
     def getenvb(key: bytes, default: _T) -> bytes | _T: ...
-    def putenv(__name: StrOrBytesPath, __value: StrOrBytesPath) -> None: ...
-    def unsetenv(__name: StrOrBytesPath) -> None: ...
+    def putenv(name: StrOrBytesPath, value: StrOrBytesPath, /) -> None: ...
+    def unsetenv(name: StrOrBytesPath, /) -> None: ...
 
 else:
-    def putenv(__name: str, __value: str) -> None: ...
+    def putenv(name: str, value: str, /) -> None: ...
 
     if sys.version_info >= (3, 9):
-        def unsetenv(__name: str) -> None: ...
+        def unsetenv(name: str, /) -> None: ...
 
 _Opener: TypeAlias = Callable[[str, int], int]
 
@@ -522,7 +1040,7 @@ def fdopen(
     newline: str | None = ...,
     closefd: bool = ...,
     opener: _Opener | None = ...,
-) -> _TextIOWrapper: ...
+) -> TextIOWrapper: ...
 @overload
 def fdopen(
     fd: int,
@@ -590,43 +1108,49 @@ def fdopen(
     opener: _Opener | None = ...,
 ) -> IO[Any]: ...
 def close(fd: int) -> None: ...
-def closerange(__fd_low: int, __fd_high: int) -> None: ...
+def closerange(fd_low: int, fd_high: int, /) -> None: ...
 def device_encoding(fd: int) -> str | None: ...
-def dup(__fd: int) -> int: ...
+def dup(fd: int, /) -> int: ...
 def dup2(fd: int, fd2: int, inheritable: bool = True) -> int: ...
 def fstat(fd: int) -> stat_result: ...
-def ftruncate(__fd: int, __length: int) -> None: ...
+def ftruncate(fd: int, length: int, /) -> None: ...
 def fsync(fd: FileDescriptorLike) -> None: ...
-def isatty(__fd: int) -> bool: ...
+def isatty(fd: int, /) -> bool: ...
 
 if sys.platform != "win32" and sys.version_info >= (3, 11):
-    def login_tty(__fd: int) -> None: ...
+    def login_tty(fd: int, /) -> None: ...
+
+if sys.version_info >= (3, 11):
+    def lseek(fd: int, position: int, whence: int, /) -> int: ...
+
+else:
+    def lseek(fd: int, position: int, how: int, /) -> int: ...
 
-def lseek(__fd: int, __position: int, __how: int) -> int: ...
 def open(path: StrOrBytesPath, flags: int, mode: int = 0o777, *, dir_fd: int | None = None) -> int: ...
 def pipe() -> tuple[int, int]: ...
-def read(__fd: int, __length: int) -> bytes: ...
+def read(fd: int, length: int, /) -> bytes: ...
+
+if sys.version_info >= (3, 12) or sys.platform != "win32":
+    def get_blocking(fd: int, /) -> bool: ...
+    def set_blocking(fd: int, blocking: bool, /) -> None: ...
 
 if sys.platform != "win32":
-    def fchmod(fd: int, mode: int) -> None: ...
     def fchown(fd: int, uid: int, gid: int) -> None: ...
-    def fpathconf(__fd: int, __name: str | int) -> int: ...
-    def fstatvfs(__fd: int) -> statvfs_result: ...
-    def get_blocking(__fd: int) -> bool: ...
-    def set_blocking(__fd: int, __blocking: bool) -> None: ...
-    def lockf(__fd: int, __command: int, __length: int) -> None: ...
+    def fpathconf(fd: int, name: str | int, /) -> int: ...
+    def fstatvfs(fd: int, /) -> statvfs_result: ...
+    def lockf(fd: int, command: int, length: int, /) -> None: ...
     def openpty() -> tuple[int, int]: ...  # some flavors of Unix
     if sys.platform != "darwin":
         def fdatasync(fd: FileDescriptorLike) -> None: ...
-        def pipe2(__flags: int) -> tuple[int, int]: ...  # some flavors of Unix
-        def posix_fallocate(__fd: int, __offset: int, __length: int) -> None: ...
-        def posix_fadvise(__fd: int, __offset: int, __length: int, __advice: int) -> None: ...
+        def pipe2(flags: int, /) -> tuple[int, int]: ...  # some flavors of Unix
+        def posix_fallocate(fd: int, offset: int, length: int, /) -> None: ...
+        def posix_fadvise(fd: int, offset: int, length: int, advice: int, /) -> None: ...
 
-    def pread(__fd: int, __length: int, __offset: int) -> bytes: ...
-    def pwrite(__fd: int, __buffer: ReadableBuffer, __offset: int) -> int: ...
+    def pread(fd: int, length: int, offset: int, /) -> bytes: ...
+    def pwrite(fd: int, buffer: ReadableBuffer, offset: int, /) -> int: ...
     # In CI, stubtest sometimes reports that these are available on MacOS, sometimes not
-    def preadv(__fd: int, __buffers: SupportsLenAndGetItem[WriteableBuffer], __offset: int, __flags: int = 0) -> int: ...
-    def pwritev(__fd: int, __buffers: SupportsLenAndGetItem[ReadableBuffer], __offset: int, __flags: int = 0) -> int: ...
+    def preadv(fd: int, buffers: SupportsLenAndGetItem[WriteableBuffer], offset: int, flags: int = 0, /) -> int: ...
+    def pwritev(fd: int, buffers: SupportsLenAndGetItem[ReadableBuffer], offset: int, flags: int = 0, /) -> int: ...
     if sys.platform != "darwin":
         if sys.version_info >= (3, 10):
             RWF_APPEND: int  # docs say available on 3.7+, stubtest says otherwise
@@ -634,45 +1158,48 @@ if sys.platform != "win32":
         RWF_SYNC: int
         RWF_HIPRI: int
         RWF_NOWAIT: int
-    @overload
-    def sendfile(out_fd: int, in_fd: int, offset: int | None, count: int) -> int: ...
-    @overload
-    def sendfile(
-        out_fd: int,
-        in_fd: int,
-        offset: int,
-        count: int,
-        headers: Sequence[ReadableBuffer] = ...,
-        trailers: Sequence[ReadableBuffer] = ...,
-        flags: int = 0,
-    ) -> int: ...  # FreeBSD and Mac OS X only
-    def readv(__fd: int, __buffers: SupportsLenAndGetItem[WriteableBuffer]) -> int: ...
-    def writev(__fd: int, __buffers: SupportsLenAndGetItem[ReadableBuffer]) -> int: ...
+
+    if sys.platform == "linux":
+        def sendfile(out_fd: FileDescriptor, in_fd: FileDescriptor, offset: int | None, count: int) -> int: ...
+    else:
+        def sendfile(
+            out_fd: FileDescriptor,
+            in_fd: FileDescriptor,
+            offset: int,
+            count: int,
+            headers: Sequence[ReadableBuffer] = ...,
+            trailers: Sequence[ReadableBuffer] = ...,
+            flags: int = 0,
+        ) -> int: ...  # FreeBSD and Mac OS X only
+
+    def readv(fd: int, buffers: SupportsLenAndGetItem[WriteableBuffer], /) -> int: ...
+    def writev(fd: int, buffers: SupportsLenAndGetItem[ReadableBuffer], /) -> int: ...
 
 @final
 class terminal_size(structseq[int], tuple[int, int]):
     if sys.version_info >= (3, 10):
         __match_args__: Final = ("columns", "lines")
+
     @property
     def columns(self) -> int: ...
     @property
     def lines(self) -> int: ...
 
-def get_terminal_size(__fd: int = ...) -> terminal_size: ...
-def get_inheritable(__fd: int) -> bool: ...
-def set_inheritable(__fd: int, __inheritable: bool) -> None: ...
+def get_terminal_size(fd: int = ..., /) -> terminal_size: ...
+def get_inheritable(fd: int, /) -> bool: ...
+def set_inheritable(fd: int, inheritable: bool, /) -> None: ...
 
 if sys.platform == "win32":
-    def get_handle_inheritable(__handle: int) -> bool: ...
-    def set_handle_inheritable(__handle: int, __inheritable: bool) -> None: ...
+    def get_handle_inheritable(handle: int, /) -> bool: ...
+    def set_handle_inheritable(handle: int, inheritable: bool, /) -> None: ...
 
 if sys.platform != "win32":
     # Unix only
-    def tcgetpgrp(__fd: int) -> int: ...
-    def tcsetpgrp(__fd: int, __pgid: int) -> None: ...
-    def ttyname(__fd: int) -> str: ...
+    def tcgetpgrp(fd: int, /) -> int: ...
+    def tcsetpgrp(fd: int, pgid: int, /) -> None: ...
+    def ttyname(fd: int, /) -> str: ...
 
-def write(__fd: int, __data: ReadableBuffer) -> int: ...
+def write(fd: int, data: ReadableBuffer, /) -> int: ...
 def access(
     path: FileDescriptorOrPath, mode: int, *, dir_fd: int | None = None, effective_ids: bool = False, follow_symlinks: bool = True
 ) -> bool: ...
@@ -683,12 +1210,11 @@ if sys.platform != "win32":
 
 def getcwd() -> str: ...
 def getcwdb() -> bytes: ...
-def chmod(path: FileDescriptorOrPath, mode: int, *, dir_fd: int | None = None, follow_symlinks: bool = True) -> None: ...
+def chmod(path: FileDescriptorOrPath, mode: int, *, dir_fd: int | None = None, follow_symlinks: bool = ...) -> None: ...
 
 if sys.platform != "win32" and sys.platform != "linux":
     def chflags(path: StrOrBytesPath, flags: int, follow_symlinks: bool = True) -> None: ...  # some flavors of Unix
     def lchflags(path: StrOrBytesPath, flags: int) -> None: ...
-    def lchmod(path: StrOrBytesPath, mode: int) -> None: ...
 
 if sys.platform != "win32":
     def chroot(path: StrOrBytesPath) -> None: ...
@@ -715,9 +1241,9 @@ def makedirs(name: StrOrBytesPath, mode: int = 0o777, exist_ok: bool = False) ->
 
 if sys.platform != "win32":
     def mknod(path: StrOrBytesPath, mode: int = 0o600, device: int = 0, *, dir_fd: int | None = None) -> None: ...
-    def major(__device: int) -> int: ...
-    def minor(__device: int) -> int: ...
-    def makedev(__major: int, __minor: int) -> int: ...
+    def major(device: int, /) -> int: ...
+    def minor(device: int, /) -> int: ...
+    def makedev(major: int, minor: int, /) -> int: ...
     def pathconf(path: FileDescriptorOrPath, name: str | int) -> int: ...  # Unix only
 
 def readlink(path: GenericPath[AnyStr], *, dir_fd: int | None = None) -> AnyStr: ...
@@ -729,9 +1255,12 @@ def replace(
     src: StrOrBytesPath, dst: StrOrBytesPath, *, src_dir_fd: int | None = None, dst_dir_fd: int | None = None
 ) -> None: ...
 def rmdir(path: StrOrBytesPath, *, dir_fd: int | None = None) -> None: ...
-
-class _ScandirIterator(Iterator[DirEntry[AnyStr]], AbstractContextManager[_ScandirIterator[AnyStr]]):
+@final
+class _ScandirIterator(Generic[AnyStr]):
+    def __del__(self) -> None: ...
+    def __iter__(self) -> Self: ...
     def __next__(self) -> DirEntry[AnyStr]: ...
+    def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
     def close(self) -> None: ...
 
@@ -805,12 +1334,16 @@ if sys.platform != "win32":
 def abort() -> NoReturn: ...
 
 # These are defined as execl(file, *args) but the first *arg is mandatory.
-def execl(file: StrOrBytesPath, __arg0: StrOrBytesPath, *args: StrOrBytesPath) -> NoReturn: ...
-def execlp(file: StrOrBytesPath, __arg0: StrOrBytesPath, *args: StrOrBytesPath) -> NoReturn: ...
+def execl(file: StrOrBytesPath, *args: Unpack[tuple[StrOrBytesPath, Unpack[tuple[StrOrBytesPath, ...]]]]) -> NoReturn: ...
+def execlp(file: StrOrBytesPath, *args: Unpack[tuple[StrOrBytesPath, Unpack[tuple[StrOrBytesPath, ...]]]]) -> NoReturn: ...
 
 # These are: execle(file, *args, env) but env is pulled from the last element of the args.
-def execle(file: StrOrBytesPath, __arg0: StrOrBytesPath, *args: Any) -> NoReturn: ...
-def execlpe(file: StrOrBytesPath, __arg0: StrOrBytesPath, *args: Any) -> NoReturn: ...
+def execle(
+    file: StrOrBytesPath, *args: Unpack[tuple[StrOrBytesPath, Unpack[tuple[StrOrBytesPath, ...]], _ExecEnv]]
+) -> NoReturn: ...
+def execlpe(
+    file: StrOrBytesPath, *args: Unpack[tuple[StrOrBytesPath, Unpack[tuple[StrOrBytesPath, ...]], _ExecEnv]]
+) -> NoReturn: ...
 
 # The docs say `args: tuple or list of strings`
 # The implementation enforces tuple or list so we can't use Sequence.
@@ -833,25 +1366,41 @@ _ExecVArgs: TypeAlias = (
 # we limit to str | bytes.
 _ExecEnv: TypeAlias = Mapping[bytes, bytes | str] | Mapping[str, bytes | str]
 
-def execv(__path: StrOrBytesPath, __argv: _ExecVArgs) -> NoReturn: ...
+def execv(path: StrOrBytesPath, argv: _ExecVArgs, /) -> NoReturn: ...
 def execve(path: FileDescriptorOrPath, argv: _ExecVArgs, env: _ExecEnv) -> NoReturn: ...
 def execvp(file: StrOrBytesPath, args: _ExecVArgs) -> NoReturn: ...
 def execvpe(file: StrOrBytesPath, args: _ExecVArgs, env: _ExecEnv) -> NoReturn: ...
 def _exit(status: int) -> NoReturn: ...
-def kill(__pid: int, __signal: int) -> None: ...
+def kill(pid: int, signal: int, /) -> None: ...
 
 if sys.platform != "win32":
     # Unix only
     def fork() -> int: ...
     def forkpty() -> tuple[int, int]: ...  # some flavors of Unix
-    def killpg(__pgid: int, __signal: int) -> None: ...
-    def nice(__increment: int) -> int: ...
-    if sys.platform != "darwin":
-        def plock(__op: int) -> None: ...  # ???op is int?
-
-class _wrap_close(_TextIOWrapper):
-    def __init__(self, stream: _TextIOWrapper, proc: Popen[str]) -> None: ...
-    def close(self) -> int | None: ...  # type: ignore[override]
+    def killpg(pgid: int, signal: int, /) -> None: ...
+    def nice(increment: int, /) -> int: ...
+    if sys.platform != "darwin" and sys.platform != "linux":
+        def plock(op: int, /) -> None: ...
+
+class _wrap_close:
+    def __init__(self, stream: TextIOWrapper, proc: Popen[str]) -> None: ...
+    def close(self) -> int | None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def __iter__(self) -> Iterator[str]: ...
+    # Methods below here don't exist directly on the _wrap_close object, but
+    # are copied from the wrapped TextIOWrapper object via __getattr__.
+    # The full set of TextIOWrapper methods are technically available this way,
+    # but undocumented. Only a subset are currently included here.
+    def read(self, size: int | None = -1, /) -> str: ...
+    def readable(self) -> bool: ...
+    def readline(self, size: int = -1, /) -> str: ...
+    def readlines(self, hint: int = -1, /) -> list[str]: ...
+    def writable(self) -> bool: ...
+    def write(self, s: str, /) -> int: ...
+    def writelines(self, lines: Iterable[str], /) -> None: ...
 
 def popen(cmd: str, mode: str = "r", buffering: int = -1) -> _wrap_close: ...
 def spawnl(mode: int, file: StrOrBytesPath, arg0: StrOrBytesPath, *args: StrOrBytesPath) -> int: ...
@@ -862,14 +1411,15 @@ if sys.platform != "win32":
     def spawnve(mode: int, file: StrOrBytesPath, args: _ExecVArgs, env: _ExecEnv) -> int: ...
 
 else:
-    def spawnv(__mode: int, __path: StrOrBytesPath, __argv: _ExecVArgs) -> int: ...
-    def spawnve(__mode: int, __path: StrOrBytesPath, __argv: _ExecVArgs, __env: _ExecEnv) -> int: ...
+    def spawnv(mode: int, path: StrOrBytesPath, argv: _ExecVArgs, /) -> int: ...
+    def spawnve(mode: int, path: StrOrBytesPath, argv: _ExecVArgs, env: _ExecEnv, /) -> int: ...
 
 def system(command: StrOrBytesPath) -> int: ...
 @final
 class times_result(structseq[float], tuple[float, float, float, float, float]):
     if sys.version_info >= (3, 10):
         __match_args__: Final = ("user", "system", "children_user", "children_system", "elapsed")
+
     @property
     def user(self) -> float: ...
     @property
@@ -882,13 +1432,19 @@ class times_result(structseq[float], tuple[float, float, float, float, float]):
     def elapsed(self) -> float: ...
 
 def times() -> times_result: ...
-def waitpid(__pid: int, __options: int) -> tuple[int, int]: ...
+def waitpid(pid: int, options: int, /) -> tuple[int, int]: ...
 
 if sys.platform == "win32":
-    if sys.version_info >= (3, 8):
-        def startfile(path: StrOrBytesPath, operation: str | None = None) -> None: ...
+    if sys.version_info >= (3, 10):
+        def startfile(
+            filepath: StrOrBytesPath,
+            operation: str = ...,
+            arguments: str = "",
+            cwd: StrOrBytesPath | None = None,
+            show_cmd: int = 1,
+        ) -> None: ...
     else:
-        def startfile(filepath: StrOrBytesPath, operation: str | None = None) -> None: ...
+        def startfile(filepath: StrOrBytesPath, operation: str = ...) -> None: ...
 
 else:
     def spawnlp(mode: int, file: StrOrBytesPath, arg0: StrOrBytesPath, *args: StrOrBytesPath) -> int: ...
@@ -896,11 +1452,13 @@ else:
     def spawnvp(mode: int, file: StrOrBytesPath, args: _ExecVArgs) -> int: ...
     def spawnvpe(mode: int, file: StrOrBytesPath, args: _ExecVArgs, env: _ExecEnv) -> int: ...
     def wait() -> tuple[int, int]: ...  # Unix only
-    if sys.platform != "darwin":
+    # Added to MacOS in 3.13
+    if sys.platform != "darwin" or sys.version_info >= (3, 13):
         @final
         class waitid_result(structseq[int], tuple[int, int, int, int, int]):
             if sys.version_info >= (3, 10):
                 __match_args__: Final = ("si_pid", "si_uid", "si_signo", "si_status", "si_code")
+
             @property
             def si_pid(self) -> int: ...
             @property
@@ -912,11 +1470,13 @@ else:
             @property
             def si_code(self) -> int: ...
 
-        def waitid(__idtype: int, __ident: int, __options: int) -> waitid_result: ...
+        def waitid(idtype: int, ident: int, options: int, /) -> waitid_result | None: ...
 
-    def wait3(options: int) -> tuple[int, int, Any]: ...
-    def wait4(pid: int, options: int) -> tuple[int, int, Any]: ...
-    def WCOREDUMP(__status: int) -> bool: ...
+    from resource import struct_rusage
+
+    def wait3(options: int) -> tuple[int, int, struct_rusage]: ...
+    def wait4(pid: int, options: int) -> tuple[int, int, struct_rusage]: ...
+    def WCOREDUMP(status: int, /) -> bool: ...
     def WIFCONTINUED(status: int) -> bool: ...
     def WIFSTOPPED(status: int) -> bool: ...
     def WIFSIGNALED(status: int) -> bool: ...
@@ -924,42 +1484,44 @@ else:
     def WEXITSTATUS(status: int) -> int: ...
     def WSTOPSIG(status: int) -> int: ...
     def WTERMSIG(status: int) -> int: ...
-    if sys.version_info >= (3, 8):
-        def posix_spawn(
-            path: StrOrBytesPath,
-            argv: _ExecVArgs,
-            env: _ExecEnv,
-            *,
-            file_actions: Sequence[tuple[Any, ...]] | None = ...,
-            setpgroup: int | None = ...,
-            resetids: bool = ...,
-            setsid: bool = ...,
-            setsigmask: Iterable[int] = ...,
-            setsigdef: Iterable[int] = ...,
-            scheduler: tuple[Any, sched_param] | None = ...,
-        ) -> int: ...
-        def posix_spawnp(
-            path: StrOrBytesPath,
-            argv: _ExecVArgs,
-            env: _ExecEnv,
-            *,
-            file_actions: Sequence[tuple[Any, ...]] | None = ...,
-            setpgroup: int | None = ...,
-            resetids: bool = ...,
-            setsid: bool = ...,
-            setsigmask: Iterable[int] = ...,
-            setsigdef: Iterable[int] = ...,
-            scheduler: tuple[Any, sched_param] | None = ...,
-        ) -> int: ...
-        POSIX_SPAWN_OPEN: int
-        POSIX_SPAWN_CLOSE: int
-        POSIX_SPAWN_DUP2: int
+    def posix_spawn(
+        path: StrOrBytesPath,
+        argv: _ExecVArgs,
+        env: _ExecEnv,
+        /,
+        *,
+        file_actions: Sequence[tuple[Any, ...]] | None = ...,
+        setpgroup: int | None = ...,
+        resetids: bool = ...,
+        setsid: bool = ...,
+        setsigmask: Iterable[int] = ...,
+        setsigdef: Iterable[int] = ...,
+        scheduler: tuple[Any, sched_param] | None = ...,
+    ) -> int: ...
+    def posix_spawnp(
+        path: StrOrBytesPath,
+        argv: _ExecVArgs,
+        env: _ExecEnv,
+        /,
+        *,
+        file_actions: Sequence[tuple[Any, ...]] | None = ...,
+        setpgroup: int | None = ...,
+        resetids: bool = ...,
+        setsid: bool = ...,
+        setsigmask: Iterable[int] = ...,
+        setsigdef: Iterable[int] = ...,
+        scheduler: tuple[Any, sched_param] | None = ...,
+    ) -> int: ...
+    POSIX_SPAWN_OPEN: int
+    POSIX_SPAWN_CLOSE: int
+    POSIX_SPAWN_DUP2: int
 
 if sys.platform != "win32":
     @final
     class sched_param(structseq[int], tuple[int]):
         if sys.version_info >= (3, 10):
             __match_args__: Final = ("sched_priority",)
+
         def __new__(cls, sched_priority: int) -> Self: ...
         @property
         def sched_priority(self) -> int: ...
@@ -968,26 +1530,34 @@ if sys.platform != "win32":
     def sched_get_priority_max(policy: int) -> int: ...  # some flavors of Unix
     def sched_yield() -> None: ...  # some flavors of Unix
     if sys.platform != "darwin":
-        def sched_setscheduler(__pid: int, __policy: int, __param: sched_param) -> None: ...  # some flavors of Unix
-        def sched_getscheduler(__pid: int) -> int: ...  # some flavors of Unix
-        def sched_rr_get_interval(__pid: int) -> float: ...  # some flavors of Unix
-        def sched_setparam(__pid: int, __param: sched_param) -> None: ...  # some flavors of Unix
-        def sched_getparam(__pid: int) -> sched_param: ...  # some flavors of Unix
-        def sched_setaffinity(__pid: int, __mask: Iterable[int]) -> None: ...  # some flavors of Unix
-        def sched_getaffinity(__pid: int) -> set[int]: ...  # some flavors of Unix
+        def sched_setscheduler(pid: int, policy: int, param: sched_param, /) -> None: ...  # some flavors of Unix
+        def sched_getscheduler(pid: int, /) -> int: ...  # some flavors of Unix
+        def sched_rr_get_interval(pid: int, /) -> float: ...  # some flavors of Unix
+        def sched_setparam(pid: int, param: sched_param, /) -> None: ...  # some flavors of Unix
+        def sched_getparam(pid: int, /) -> sched_param: ...  # some flavors of Unix
+        def sched_setaffinity(pid: int, mask: Iterable[int], /) -> None: ...  # some flavors of Unix
+        def sched_getaffinity(pid: int, /) -> set[int]: ...  # some flavors of Unix
 
 def cpu_count() -> int | None: ...
 
+if sys.version_info >= (3, 13):
+    # Documented to return `int | None`, but falls back to `len(sched_getaffinity(0))` when
+    # available. See https://github.com/python/cpython/blob/417c130/Lib/os.py#L1175-L1186.
+    if sys.platform != "win32" and sys.platform != "darwin":
+        def process_cpu_count() -> int: ...
+    else:
+        def process_cpu_count() -> int | None: ...
+
 if sys.platform != "win32":
     # Unix only
-    def confstr(__name: str | int) -> str | None: ...
+    def confstr(name: str | int, /) -> str | None: ...
     def getloadavg() -> tuple[float, float, float]: ...
-    def sysconf(__name: str | int) -> int: ...
+    def sysconf(name: str | int, /) -> int: ...
 
 if sys.platform == "linux":
     def getrandom(size: int, flags: int = 0) -> bytes: ...
 
-def urandom(__size: int) -> bytes: ...
+def urandom(size: int, /) -> bytes: ...
 
 if sys.platform != "win32":
     def register_at_fork(
@@ -997,41 +1567,114 @@ if sys.platform != "win32":
         after_in_child: Callable[..., Any] | None = ...,
     ) -> None: ...
 
-if sys.version_info >= (3, 8):
-    if sys.platform == "win32":
-        class _AddedDllDirectory:
-            path: str | None
-            def __init__(self, path: str | None, cookie: _T, remove_dll_directory: Callable[[_T], object]) -> None: ...
-            def close(self) -> None: ...
-            def __enter__(self) -> Self: ...
-            def __exit__(self, *args: Unused) -> None: ...
-
-        def add_dll_directory(path: str) -> _AddedDllDirectory: ...
-    if sys.platform == "linux":
-        MFD_CLOEXEC: int
-        MFD_ALLOW_SEALING: int
-        MFD_HUGETLB: int
-        MFD_HUGE_SHIFT: int
-        MFD_HUGE_MASK: int
-        MFD_HUGE_64KB: int
-        MFD_HUGE_512KB: int
-        MFD_HUGE_1MB: int
-        MFD_HUGE_2MB: int
-        MFD_HUGE_8MB: int
-        MFD_HUGE_16MB: int
-        MFD_HUGE_32MB: int
-        MFD_HUGE_256MB: int
-        MFD_HUGE_512MB: int
-        MFD_HUGE_1GB: int
-        MFD_HUGE_2GB: int
-        MFD_HUGE_16GB: int
-        def memfd_create(name: str, flags: int = ...) -> int: ...
-        def copy_file_range(
-            src: int, dst: int, count: int, offset_src: int | None = ..., offset_dst: int | None = ...
-        ) -> int: ...
+if sys.platform == "win32":
+    class _AddedDllDirectory:
+        path: str | None
+        def __init__(self, path: str | None, cookie: _T, remove_dll_directory: Callable[[_T], object]) -> None: ...
+        def close(self) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(self, *args: Unused) -> None: ...
+
+    def add_dll_directory(path: str) -> _AddedDllDirectory: ...
+
+if sys.platform == "linux":
+    MFD_CLOEXEC: int
+    MFD_ALLOW_SEALING: int
+    MFD_HUGETLB: int
+    MFD_HUGE_SHIFT: int
+    MFD_HUGE_MASK: int
+    MFD_HUGE_64KB: int
+    MFD_HUGE_512KB: int
+    MFD_HUGE_1MB: int
+    MFD_HUGE_2MB: int
+    MFD_HUGE_8MB: int
+    MFD_HUGE_16MB: int
+    MFD_HUGE_32MB: int
+    MFD_HUGE_256MB: int
+    MFD_HUGE_512MB: int
+    MFD_HUGE_1GB: int
+    MFD_HUGE_2GB: int
+    MFD_HUGE_16GB: int
+    def memfd_create(name: str, flags: int = ...) -> int: ...
+    def copy_file_range(src: int, dst: int, count: int, offset_src: int | None = ..., offset_dst: int | None = ...) -> int: ...
 
 if sys.version_info >= (3, 9):
     def waitstatus_to_exitcode(status: int) -> int: ...
 
     if sys.platform == "linux":
         def pidfd_open(pid: int, flags: int = ...) -> int: ...
+
+if sys.version_info >= (3, 12) and sys.platform == "linux":
+    PIDFD_NONBLOCK: Final = 2048
+
+if sys.version_info >= (3, 12) and sys.platform == "win32":
+    def listdrives() -> list[str]: ...
+    def listmounts(volume: str) -> list[str]: ...
+    def listvolumes() -> list[str]: ...
+
+if sys.version_info >= (3, 10) and sys.platform == "linux":
+    EFD_CLOEXEC: int
+    EFD_NONBLOCK: int
+    EFD_SEMAPHORE: int
+    SPLICE_F_MORE: int
+    SPLICE_F_MOVE: int
+    SPLICE_F_NONBLOCK: int
+    def eventfd(initval: int, flags: int = 524288) -> FileDescriptor: ...
+    def eventfd_read(fd: FileDescriptor) -> int: ...
+    def eventfd_write(fd: FileDescriptor, value: int) -> None: ...
+    def splice(
+        src: FileDescriptor,
+        dst: FileDescriptor,
+        count: int,
+        offset_src: int | None = ...,
+        offset_dst: int | None = ...,
+        flags: int = 0,
+    ) -> int: ...
+
+if sys.version_info >= (3, 12) and sys.platform == "linux":
+    CLONE_FILES: int
+    CLONE_FS: int
+    CLONE_NEWCGROUP: int  # Linux 4.6+
+    CLONE_NEWIPC: int  # Linux 2.6.19+
+    CLONE_NEWNET: int  # Linux 2.6.24+
+    CLONE_NEWNS: int
+    CLONE_NEWPID: int  # Linux 3.8+
+    CLONE_NEWTIME: int  # Linux 5.6+
+    CLONE_NEWUSER: int  # Linux 3.8+
+    CLONE_NEWUTS: int  # Linux 2.6.19+
+    CLONE_SIGHAND: int
+    CLONE_SYSVSEM: int  # Linux 2.6.26+
+    CLONE_THREAD: int
+    CLONE_VM: int
+    def unshare(flags: int) -> None: ...
+    def setns(fd: FileDescriptorLike, nstype: int = 0) -> None: ...
+
+if sys.version_info >= (3, 13) and sys.platform != "win32":
+    def posix_openpt(oflag: int, /) -> int: ...
+    def grantpt(fd: FileDescriptorLike, /) -> None: ...
+    def unlockpt(fd: FileDescriptorLike, /) -> None: ...
+    def ptsname(fd: FileDescriptorLike, /) -> str: ...
+
+if sys.version_info >= (3, 13) and sys.platform == "linux":
+    TFD_TIMER_ABSTIME: Final = 1
+    TFD_TIMER_CANCEL_ON_SET: Final = 2
+    TFD_NONBLOCK: Final[int]
+    TFD_CLOEXEC: Final[int]
+    POSIX_SPAWN_CLOSEFROM: Final[int]
+
+    def timerfd_create(clockid: int, /, *, flags: int = 0) -> int: ...
+    def timerfd_settime(
+        fd: FileDescriptor, /, *, flags: int = 0, initial: float = 0.0, interval: float = 0.0
+    ) -> tuple[float, float]: ...
+    def timerfd_settime_ns(fd: FileDescriptor, /, *, flags: int = 0, initial: int = 0, interval: int = 0) -> tuple[int, int]: ...
+    def timerfd_gettime(fd: FileDescriptor, /) -> tuple[float, float]: ...
+    def timerfd_gettime_ns(fd: FileDescriptor, /) -> tuple[int, int]: ...
+
+if sys.version_info >= (3, 13) or sys.platform != "win32":
+    # Added to Windows in 3.13.
+    def fchmod(fd: int, mode: int) -> None: ...
+
+if sys.platform != "linux":
+    if sys.version_info >= (3, 13) or sys.platform != "win32":
+        # Added to Windows in 3.13.
+        def lchmod(path: StrOrBytesPath, mode: int) -> None: ...
diff --git a/mypy/typeshed/stdlib/ossaudiodev.pyi b/mypy/typeshed/stdlib/ossaudiodev.pyi
index d956a89729fd..b9ee3edab033 100644
--- a/mypy/typeshed/stdlib/ossaudiodev.pyi
+++ b/mypy/typeshed/stdlib/ossaudiodev.pyi
@@ -1,6 +1,5 @@
 import sys
-from typing import Any, overload
-from typing_extensions import Literal
+from typing import Any, Literal, overload
 
 if sys.platform != "win32" and sys.platform != "darwin":
     AFMT_AC3: int
diff --git a/mypy/typeshed/stdlib/parser.pyi b/mypy/typeshed/stdlib/parser.pyi
index cce8594eac58..26140c76248a 100644
--- a/mypy/typeshed/stdlib/parser.pyi
+++ b/mypy/typeshed/stdlib/parser.pyi
@@ -1,8 +1,7 @@
 from _typeshed import StrOrBytesPath
 from collections.abc import Sequence
 from types import CodeType
-from typing import Any
-from typing_extensions import final
+from typing import Any, ClassVar, final
 
 def expr(source: str) -> STType: ...
 def suite(source: str) -> STType: ...
@@ -18,6 +17,7 @@ class ParserError(Exception): ...
 
 @final
 class STType:
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def compile(self, filename: StrOrBytesPath = ...) -> CodeType: ...
     def isexpr(self) -> bool: ...
     def issuite(self) -> bool: ...
diff --git a/mypy/typeshed/stdlib/pathlib.pyi b/mypy/typeshed/stdlib/pathlib.pyi
index 7aec66b584e3..a18aed4ba57a 100644
--- a/mypy/typeshed/stdlib/pathlib.pyi
+++ b/mypy/typeshed/stdlib/pathlib.pyi
@@ -1,4 +1,5 @@
 import sys
+import types
 from _typeshed import (
     OpenBinaryMode,
     OpenBinaryModeReading,
@@ -8,20 +9,28 @@ from _typeshed import (
     ReadableBuffer,
     StrOrBytesPath,
     StrPath,
+    Unused,
 )
 from collections.abc import Callable, Generator, Iterator, Sequence
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 from os import PathLike, stat_result
 from types import TracebackType
-from typing import IO, Any, BinaryIO, overload
-from typing_extensions import Literal, Self
+from typing import IO, Any, BinaryIO, ClassVar, Literal, overload
+from typing_extensions import Never, Self, deprecated
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 
 __all__ = ["PurePath", "PurePosixPath", "PureWindowsPath", "Path", "PosixPath", "WindowsPath"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["UnsupportedOperation"]
+
 class PurePath(PathLike[str]):
+    if sys.version_info >= (3, 13):
+        parser: ClassVar[types.ModuleType]
+        def full_match(self, pattern: StrPath, *, case_sensitive: bool | None = None) -> bool: ...
+
     @property
     def parts(self) -> tuple[str, ...]: ...
     @property
@@ -38,8 +47,13 @@ class PurePath(PathLike[str]):
     def suffixes(self) -> list[str]: ...
     @property
     def stem(self) -> str: ...
-    def __new__(cls, *args: StrPath) -> Self: ...
-    def __eq__(self, other: object) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def __new__(cls, *args: StrPath, **kwargs: Unused) -> Self: ...
+        def __init__(self, *args: StrPath) -> None: ...  # pyright: ignore[reportInconsistentConstructor]
+    else:
+        def __new__(cls, *args: StrPath) -> Self: ...
+
+    def __hash__(self) -> int: ...
     def __fspath__(self) -> str: ...
     def __lt__(self, other: PurePath) -> bool: ...
     def __le__(self, other: PurePath) -> bool: ...
@@ -52,11 +66,21 @@ class PurePath(PathLike[str]):
     def as_uri(self) -> str: ...
     def is_absolute(self) -> bool: ...
     def is_reserved(self) -> bool: ...
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 12):
+        def is_relative_to(self, other: StrPath, /, *_deprecated: StrPath) -> bool: ...
+    elif sys.version_info >= (3, 9):
         def is_relative_to(self, *other: StrPath) -> bool: ...
 
-    def match(self, path_pattern: str) -> bool: ...
-    def relative_to(self, *other: StrPath) -> Self: ...
+    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: ...
+
+    if sys.version_info >= (3, 12):
+        def relative_to(self, other: StrPath, /, *_deprecated: StrPath, walk_up: bool = False) -> Self: ...
+    else:
+        def relative_to(self, *other: StrPath) -> Self: ...
+
     def with_name(self, name: str) -> Self: ...
     if sys.version_info >= (3, 9):
         def with_stem(self, stem: str) -> Self: ...
@@ -70,13 +94,18 @@ 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): ...
 
 class Path(PurePath):
-    def __new__(cls, *args: StrPath, **kwargs: Any) -> Self: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __new__(cls, *args: StrPath, **kwargs: Unused) -> Self: ...  # pyright: ignore[reportInconsistentConstructor]
+    else:
+        def __new__(cls, *args: StrPath, **kwargs: Unused) -> Self: ...
+
     @classmethod
     def cwd(cls) -> Self: ...
     if sys.version_info >= (3, 10):
@@ -86,19 +115,62 @@ 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]: ...
-    def is_dir(self) -> bool: ...
-    def is_file(self) -> bool: ...
+    if sys.version_info >= (3, 13):
+        @classmethod
+        def from_uri(cls, uri: str) -> Self: ...
+        def is_dir(self, *, follow_symlinks: bool = True) -> bool: ...
+        def is_file(self, *, follow_symlinks: bool = True) -> bool: ...
+        def read_text(self, encoding: str | None = None, errors: str | None = None, newline: str | None = None) -> str: ...
+    else:
+        def __enter__(self) -> Self: ...
+        def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+        def is_dir(self) -> bool: ...
+        def is_file(self) -> bool: ...
+        def read_text(self, encoding: str | None = None, errors: str | None = None) -> str: ...
+
+    if sys.version_info >= (3, 13):
+        def glob(self, pattern: str, *, case_sensitive: bool | None = None, recurse_symlinks: bool = False) -> Iterator[Self]: ...
+        def rglob(
+            self, pattern: str, *, case_sensitive: bool | None = None, recurse_symlinks: bool = False
+        ) -> Iterator[Self]: ...
+    elif sys.version_info >= (3, 12):
+        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 glob(self, pattern: str) -> Generator[Self, None, None]: ...
+        def rglob(self, pattern: str) -> Generator[Self, None, None]: ...
+
+    if sys.version_info >= (3, 12):
+        def exists(self, *, follow_symlinks: bool = True) -> bool: ...
+    else:
+        def exists(self) -> bool: ...
+
     def is_symlink(self) -> bool: ...
     def is_socket(self) -> bool: ...
     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: ...
     def mkdir(self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def copy(self, target: StrPath, *, follow_symlinks: bool = True, preserve_metadata: bool = False) -> None: ...
+        def copytree(
+            self,
+            target: StrPath,
+            *,
+            follow_symlinks: bool = True,
+            preserve_metadata: bool = False,
+            dirs_exist_ok: bool = False,
+            ignore: Callable[[Self], bool] | None = None,
+            on_error: Callable[[OSError], object] | None = None,
+        ) -> None: ...
+
     # Adapted from builtins.open
     # Text mode: always returns a TextIOWrapper
     # The Traversable .open in stdlib/importlib/abc.pyi should be kept in sync with this.
@@ -154,41 +226,53 @@ class Path(PurePath):
     def open(
         self, mode: str, buffering: int = -1, encoding: str | None = None, errors: str | None = None, newline: str | None = None
     ) -> IO[Any]: ...
-    if sys.platform != "win32":
-        # These methods do "exist" on Windows, but they always raise NotImplementedError,
-        # so it's safer to pretend they don't exist
-        def owner(self) -> str: ...
-        def group(self) -> str: ...
+
+    # These methods do "exist" on Windows on <3.13, but they always raise NotImplementedError.
+    if sys.platform == "win32":
+        if sys.version_info < (3, 13):
+            def owner(self: Never) -> str: ...  # type: ignore[misc]
+            def group(self: Never) -> str: ...  # type: ignore[misc]
+    else:
+        if sys.version_info >= (3, 13):
+            def owner(self, *, follow_symlinks: bool = True) -> str: ...
+            def group(self, *, follow_symlinks: bool = True) -> str: ...
+        else:
+            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" and sys.version_info < (3, 12):
+        def is_mount(self: Never) -> bool: ...  # type: ignore[misc]
+    else:
         def is_mount(self) -> bool: ...
 
     if sys.version_info >= (3, 9):
         def readlink(self) -> Self: ...
-    if sys.version_info >= (3, 8):
+
+    if sys.version_info >= (3, 10):
+        def rename(self, target: StrPath) -> Self: ...
+        def replace(self, target: StrPath) -> Self: ...
+    else:
         def rename(self, target: str | PurePath) -> Self: ...
         def replace(self, target: str | PurePath) -> Self: ...
-    else:
-        def rename(self, target: str | PurePath) -> None: ...
-        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: ...
+    if sys.version_info >= (3, 14):
+        def delete(self, ignore_errors: bool = False, on_error: Callable[[OSError], object] | None = None) -> None: ...
+
     def symlink_to(self, target: StrOrBytesPath, target_is_directory: bool = False) -> None: ...
     if sys.version_info >= (3, 10):
         def hardlink_to(self, target: StrOrBytesPath) -> None: ...
 
     def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None: ...
-    if sys.version_info >= (3, 8):
-        def unlink(self, missing_ok: bool = False) -> None: ...
-    else:
-        def unlink(self) -> None: ...
-
+    def unlink(self, missing_ok: bool = False) -> None: ...
     @classmethod
     def home(cls) -> Self: ...
     def absolute(self) -> Self: ...
     def expanduser(self) -> Self: ...
     def read_bytes(self) -> bytes: ...
-    def read_text(self, encoding: str | None = None, errors: str | None = None) -> str: ...
     def samefile(self, other_path: StrPath) -> bool: ...
     def write_bytes(self, data: ReadableBuffer) -> int: ...
     if sys.version_info >= (3, 10):
@@ -197,12 +281,22 @@ class Path(PurePath):
         ) -> int: ...
     else:
         def write_text(self, data: str, encoding: str | None = None, errors: str | None = None) -> int: ...
-    if sys.version_info >= (3, 8) and sys.version_info < (3, 12):
-        def link_to(self, target: StrOrBytesPath) -> None: ...
+    if sys.version_info < (3, 12):
+        if sys.version_info >= (3, 10):
+            @deprecated("Deprecated as of Python 3.10 and removed in Python 3.12. Use hardlink_to() instead.")
+            def link_to(self, target: StrOrBytesPath) -> None: ...
+        else:
+            def link_to(self, target: StrOrBytesPath) -> None: ...
     if sys.version_info >= (3, 12):
         def walk(
             self, top_down: bool = ..., on_error: Callable[[OSError], object] | None = ..., follow_symlinks: bool = ...
         ) -> Iterator[tuple[Self, list[str], list[str]]]: ...
 
+    if sys.version_info >= (3, 14):
+        def rmtree(self, ignore_errors: bool = False, on_error: Callable[[OSError], object] | None = None) -> None: ...
+
 class PosixPath(Path, PurePosixPath): ...
 class WindowsPath(Path, PureWindowsPath): ...
+
+if sys.version_info >= (3, 13):
+    class UnsupportedOperation(NotImplementedError): ...
diff --git a/mypy/typeshed/stdlib/pdb.pyi b/mypy/typeshed/stdlib/pdb.pyi
index 405c45ca01ac..61e8b7176e84 100644
--- a/mypy/typeshed/stdlib/pdb.pyi
+++ b/mypy/typeshed/stdlib/pdb.pyi
@@ -5,7 +5,7 @@ from cmd import Cmd
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from inspect import _SourceObjectType
 from types import CodeType, FrameType, TracebackType
-from typing import IO, Any, ClassVar, TypeVar
+from typing import IO, Any, ClassVar, Final, TypeVar
 from typing_extensions import ParamSpec, Self
 
 __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace", "post_mortem", "help"]
@@ -30,6 +30,9 @@ class Pdb(Bdb, Cmd):
 
     commands_resuming: ClassVar[list[str]]
 
+    if sys.version_info >= (3, 13):
+        MAX_CHAINED_EXCEPTION_DEPTH: Final = 999
+
     aliases: dict[str, str]
     mainpyfile: str
     _wait_for_mainpyfile: bool
@@ -55,9 +58,19 @@ class Pdb(Bdb, Cmd):
     ) -> None: ...
     def forget(self) -> None: ...
     def setup(self, f: FrameType | None, tb: TracebackType | None) -> None: ...
-    def execRcLines(self) -> None: ...
+    if sys.version_info < (3, 11):
+        def execRcLines(self) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        user_opcode = Bdb.user_line
+
     def bp_commands(self, frame: FrameType) -> bool: ...
-    def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        def interaction(self, frame: FrameType | None, tb_or_exc: TracebackType | BaseException | None) -> None: ...
+    else:
+        def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
+
     def displayhook(self, obj: object) -> None: ...
     def handle_command_def(self, line: str) -> bool: ...
     def defaultFile(self) -> str: ...
@@ -70,6 +83,9 @@ class Pdb(Bdb, Cmd):
     if sys.version_info < (3, 11):
         def _runscript(self, filename: str) -> None: ...
 
+    if sys.version_info >= (3, 13):
+        def completedefault(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...
+
     def do_commands(self, arg: str) -> bool | None: ...
     def do_break(self, arg: str, temporary: bool = ...) -> bool | None: ...
     def do_tbreak(self, arg: str) -> bool | None: ...
@@ -79,6 +95,9 @@ class Pdb(Bdb, Cmd):
     def do_ignore(self, arg: str) -> bool | None: ...
     def do_clear(self, arg: str) -> bool | None: ...
     def do_where(self, arg: str) -> bool | None: ...
+    if sys.version_info >= (3, 13):
+        def do_exceptions(self, arg: str) -> bool | None: ...
+
     def do_up(self, arg: str) -> bool | None: ...
     def do_down(self, arg: str) -> bool | None: ...
     def do_until(self, arg: str) -> bool | None: ...
@@ -123,8 +142,17 @@ class Pdb(Bdb, Cmd):
     def help_exec(self) -> None: ...
     def help_pdb(self) -> None: ...
     def sigint_handler(self, signum: signal.Signals, frame: FrameType) -> None: ...
-    def message(self, msg: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def message(self, msg: str, end: str = "\n") -> None: ...
+    else:
+        def message(self, msg: str) -> None: ...
+
     def error(self, msg: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def completenames(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...  # type: ignore[override]
+    if sys.version_info >= (3, 12):
+        def set_convenience_variable(self, frame: FrameType, name: str, value: Any) -> None: ...
+
     def _select_frame(self, number: int) -> None: ...
     def _getval_except(self, arg: str, frame: FrameType | None = None) -> object: ...
     def _print_lines(
@@ -168,7 +196,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/pickle.pyi b/mypy/typeshed/stdlib/pickle.pyi
index cf3995d74f5d..2d80d61645e0 100644
--- a/mypy/typeshed/stdlib/pickle.pyi
+++ b/mypy/typeshed/stdlib/pickle.pyi
@@ -1,10 +1,24 @@
-import sys
+from _pickle import (
+    PickleError as PickleError,
+    Pickler as Pickler,
+    PicklingError as PicklingError,
+    Unpickler as Unpickler,
+    UnpicklingError as UnpicklingError,
+    _BufferCallback,
+    _ReadableFileobj,
+    _ReducedType,
+    dump as dump,
+    dumps as dumps,
+    load as load,
+    loads as loads,
+)
 from _typeshed import ReadableBuffer, SupportsWrite
-from collections.abc import Callable, Iterable, Iterator, Mapping
-from typing import Any, ClassVar, Protocol, SupportsBytes
-from typing_extensions import SupportsIndex, TypeAlias, final
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any, ClassVar, SupportsBytes, SupportsIndex, final
+from typing_extensions import Self
 
 __all__ = [
+    "PickleBuffer",
     "PickleError",
     "PicklingError",
     "UnpicklingError",
@@ -30,6 +44,7 @@ __all__ = [
     "BINUNICODE",
     "BINUNICODE8",
     "BUILD",
+    "BYTEARRAY8",
     "DEFAULT_PROTOCOL",
     "DICT",
     "DUP",
@@ -61,6 +76,7 @@ __all__ = [
     "NEWOBJ",
     "NEWOBJ_EX",
     "NEWTRUE",
+    "NEXT_BUFFER",
     "NONE",
     "OBJ",
     "PERSID",
@@ -68,6 +84,7 @@ __all__ = [
     "POP_MARK",
     "PROTO",
     "PUT",
+    "READONLY_BUFFER",
     "REDUCE",
     "SETITEM",
     "SETITEMS",
@@ -85,117 +102,18 @@ __all__ = [
     "UNICODE",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["BYTEARRAY8", "NEXT_BUFFER", "PickleBuffer", "READONLY_BUFFER"]
-
 HIGHEST_PROTOCOL: int
 DEFAULT_PROTOCOL: int
 
 bytes_types: tuple[type[Any], ...]  # undocumented
 
-class _ReadableFileobj(Protocol):
-    def read(self, __n: int) -> bytes: ...
-    def readline(self) -> bytes: ...
-
-if sys.version_info >= (3, 8):
-    @final
-    class PickleBuffer:
-        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,
-        file: SupportsWrite[bytes],
-        protocol: int | None = None,
-        *,
-        fix_imports: bool = True,
-        buffer_callback: _BufferCallback = None,
-    ) -> None: ...
-    def dumps(
-        obj: Any, protocol: int | None = None, *, fix_imports: bool = True, buffer_callback: _BufferCallback = None
-    ) -> bytes: ...
-    def load(
-        file: _ReadableFileobj,
-        *,
-        fix_imports: bool = True,
-        encoding: str = "ASCII",
-        errors: str = "strict",
-        buffers: Iterable[Any] | None = (),
-    ) -> Any: ...
-    def loads(
-        __data: ReadableBuffer,
-        *,
-        fix_imports: bool = True,
-        encoding: str = "ASCII",
-        errors: str = "strict",
-        buffers: Iterable[Any] | None = (),
-    ) -> Any: ...
-
-else:
-    def dump(obj: Any, file: SupportsWrite[bytes], protocol: int | None = None, *, fix_imports: bool = True) -> None: ...
-    def dumps(obj: Any, protocol: int | None = None, *, fix_imports: bool = True) -> bytes: ...
-    def load(file: _ReadableFileobj, *, fix_imports: bool = True, encoding: str = "ASCII", errors: str = "strict") -> Any: ...
-    def loads(data: ReadableBuffer, *, fix_imports: bool = True, encoding: str = "ASCII", errors: str = "strict") -> Any: ...
-
-class PickleError(Exception): ...
-class PicklingError(PickleError): ...
-class UnpicklingError(PickleError): ...
-
-_ReducedType: TypeAlias = (
-    str
-    | tuple[Callable[..., Any], tuple[Any, ...]]
-    | tuple[Callable[..., Any], tuple[Any, ...], Any]
-    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None]
-    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None, Iterator[Any] | None]
-)
-
-class Pickler:
-    fast: bool
-    dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
-    bin: bool  # undocumented
-    dispatch: ClassVar[dict[type, Callable[[Unpickler, Any], None]]]  # undocumented, _Pickler only
-
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            file: SupportsWrite[bytes],
-            protocol: int | None = ...,
-            *,
-            fix_imports: bool = ...,
-            buffer_callback: _BufferCallback = ...,
-        ) -> None: ...
-        def reducer_override(self, obj: Any) -> Any: ...
-    else:
-        def __init__(self, file: SupportsWrite[bytes], protocol: int | None = ..., *, fix_imports: bool = ...) -> None: ...
-
-    def dump(self, __obj: Any) -> None: ...
-    def clear_memo(self) -> None: ...
-    def persistent_id(self, obj: Any) -> Any: ...
-
-class Unpickler:
-    dispatch: ClassVar[dict[int, Callable[[Unpickler], None]]]  # undocumented, _Unpickler only
-
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            file: _ReadableFileobj,
-            *,
-            fix_imports: bool = ...,
-            encoding: str = ...,
-            errors: str = ...,
-            buffers: Iterable[Any] | None = ...,
-        ) -> None: ...
-    else:
-        def __init__(
-            self, file: _ReadableFileobj, *, fix_imports: bool = ..., encoding: str = ..., errors: str = ...
-        ) -> None: ...
-
-    def load(self) -> Any: ...
-    def find_class(self, __module_name: str, __global_name: str) -> Any: ...
-    def persistent_load(self, pid: Any) -> Any: ...
+@final
+class PickleBuffer:
+    def __new__(cls, buffer: ReadableBuffer) -> Self: ...
+    def raw(self) -> memoryview: ...
+    def release(self) -> None: ...
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None: ...
 
 MARK: bytes
 STOP: bytes
@@ -272,15 +190,44 @@ STACK_GLOBAL: bytes
 MEMOIZE: bytes
 FRAME: bytes
 
-if sys.version_info >= (3, 8):
-    # Protocol 5
-    BYTEARRAY8: bytes
-    NEXT_BUFFER: bytes
-    READONLY_BUFFER: bytes
+# protocol 5
+BYTEARRAY8: bytes
+NEXT_BUFFER: bytes
+READONLY_BUFFER: bytes
 
 def encode_long(x: int) -> bytes: ...  # undocumented
 def decode_long(data: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer) -> int: ...  # undocumented
 
-# pure-Python implementations
-_Pickler = Pickler  # undocumented
-_Unpickler = Unpickler  # undocumented
+# undocumented pure-Python implementations
+class _Pickler:
+    fast: bool
+    dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
+    bin: bool  # undocumented
+    dispatch: ClassVar[dict[type, Callable[[Unpickler, Any], None]]]  # undocumented, _Pickler only
+    reducer_override: Callable[[Any], Any]
+    def __init__(
+        self,
+        file: SupportsWrite[bytes],
+        protocol: int | None = None,
+        *,
+        fix_imports: bool = True,
+        buffer_callback: _BufferCallback = None,
+    ) -> None: ...
+    def dump(self, obj: Any) -> None: ...
+    def clear_memo(self) -> None: ...
+    def persistent_id(self, obj: Any) -> Any: ...
+
+class _Unpickler:
+    dispatch: ClassVar[dict[int, Callable[[Unpickler], None]]]  # undocumented, _Unpickler only
+    def __init__(
+        self,
+        file: _ReadableFileobj,
+        *,
+        fix_imports: bool = True,
+        encoding: str = "ASCII",
+        errors: str = "strict",
+        buffers: Iterable[Any] | None = None,
+    ) -> None: ...
+    def load(self) -> Any: ...
+    def find_class(self, module: str, name: str) -> Any: ...
+    def persistent_load(self, pid: Any) -> Any: ...
diff --git a/mypy/typeshed/stdlib/pickletools.pyi b/mypy/typeshed/stdlib/pickletools.pyi
index 542172814926..cdade08d39a8 100644
--- a/mypy/typeshed/stdlib/pickletools.pyi
+++ b/mypy/typeshed/stdlib/pickletools.pyi
@@ -1,3 +1,4 @@
+import sys
 from collections.abc import Callable, Iterator, MutableMapping
 from typing import IO, Any
 from typing_extensions import TypeAlias
@@ -40,7 +41,13 @@ def read_uint8(f: IO[bytes]) -> int: ...
 
 uint8: ArgumentDescriptor
 
-def read_stringnl(f: IO[bytes], decode: bool = True, stripquotes: bool = True) -> bytes | str: ...
+if sys.version_info >= (3, 12):
+    def read_stringnl(
+        f: IO[bytes], decode: bool = True, stripquotes: bool = True, *, encoding: str = "latin-1"
+    ) -> bytes | str: ...
+
+else:
+    def read_stringnl(f: IO[bytes], decode: bool = True, stripquotes: bool = True) -> bytes | str: ...
 
 stringnl: ArgumentDescriptor
 
diff --git a/mypy/typeshed/stdlib/pkgutil.pyi b/mypy/typeshed/stdlib/pkgutil.pyi
index f9808c9e5de8..59d70779c72f 100644
--- a/mypy/typeshed/stdlib/pkgutil.pyi
+++ b/mypy/typeshed/stdlib/pkgutil.pyi
@@ -1,8 +1,9 @@
 import sys
-from _typeshed import SupportsRead
+from _typeshed import StrOrBytesPath, SupportsRead
+from _typeshed.importlib import LoaderProtocol, MetaPathFinderProtocol, PathEntryFinderProtocol
 from collections.abc import Callable, Iterable, Iterator
-from importlib.abc import Loader, MetaPathFinder, PathEntryFinder
 from typing import IO, Any, NamedTuple, TypeVar
+from typing_extensions import deprecated
 
 __all__ = [
     "get_importer",
@@ -12,36 +13,39 @@ __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])
 
 class ModuleInfo(NamedTuple):
-    module_finder: MetaPathFinder | PathEntryFinder
+    module_finder: MetaPathFinderProtocol | PathEntryFinderProtocol
     name: str
     ispkg: bool
 
 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: StrOrBytesPath | 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: StrOrBytesPath, etc: tuple[str, str, int]) -> None: ...
 
-def find_loader(fullname: str) -> Loader | None: ...
-def get_importer(path_item: str) -> PathEntryFinder | None: ...
-def get_loader(module_or_name: str) -> Loader | None: ...
-def iter_importers(fullname: str = "") -> Iterator[MetaPathFinder | PathEntryFinder]: ...
-def iter_modules(path: Iterable[str] | None = None, prefix: str = "") -> Iterator[ModuleInfo]: ...
+@deprecated("Use importlib.util.find_spec() instead. Will be removed in Python 3.14.")
+def find_loader(fullname: str) -> LoaderProtocol | None: ...
+def get_importer(path_item: StrOrBytesPath) -> PathEntryFinderProtocol | None: ...
+@deprecated("Use importlib.util.find_spec() instead. Will be removed in Python 3.14.")
+def get_loader(module_or_name: str) -> LoaderProtocol | None: ...
+def iter_importers(fullname: str = "") -> Iterator[MetaPathFinderProtocol | PathEntryFinderProtocol]: ...
+def iter_modules(path: Iterable[StrOrBytesPath] | None = None, prefix: str = "") -> Iterator[ModuleInfo]: ...
 def read_code(stream: SupportsRead[bytes]) -> Any: ...  # undocumented
 def walk_packages(
-    path: Iterable[str] | None = None, prefix: str = "", onerror: Callable[[str], object] | None = None
+    path: Iterable[StrOrBytesPath] | None = None, prefix: str = "", onerror: Callable[[str], object] | None = None
 ) -> Iterator[ModuleInfo]: ...
 def get_data(package: str, resource: str) -> bytes | None: ...
 
diff --git a/mypy/typeshed/stdlib/platform.pyi b/mypy/typeshed/stdlib/platform.pyi
index 483d6c454c2e..73393eada02c 100644
--- a/mypy/typeshed/stdlib/platform.pyi
+++ b/mypy/typeshed/stdlib/platform.pyi
@@ -1,37 +1,11 @@
 import sys
+from typing import NamedTuple, type_check_only
+from typing_extensions import Self
 
-if sys.version_info < (3, 8):
-    import os
-
-    DEV_NULL = os.devnull
-from typing import NamedTuple
-
-if sys.version_info >= (3, 8):
-    def libc_ver(executable: str | None = None, lib: str = "", version: str = "", chunksize: int = 16384) -> tuple[str, str]: ...
-
-else:
-    def libc_ver(
-        executable: str = sys.executable, lib: str = "", version: str = "", chunksize: int = 16384
-    ) -> tuple[str, str]: ...
-
-if sys.version_info < (3, 8):
-    def linux_distribution(
-        distname: str = "",
-        version: str = "",
-        id: str = "",
-        supported_dists: tuple[str, ...] = ...,
-        full_distribution_name: bool = ...,
-    ) -> tuple[str, str, str]: ...
-    def dist(
-        distname: str = "", version: str = "", id: str = "", supported_dists: tuple[str, ...] = ...
-    ) -> tuple[str, str, str]: ...
-
+def libc_ver(executable: str | None = None, lib: str = "", version: str = "", chunksize: int = 16384) -> tuple[str, str]: ...
 def win32_ver(release: str = "", version: str = "", csd: str = "", ptype: str = "") -> tuple[str, str, str, str]: ...
-
-if sys.version_info >= (3, 8):
-    def win32_edition() -> str: ...
-    def win32_is_iot() -> bool: ...
-
+def win32_edition() -> str: ...
+def win32_is_iot() -> bool: ...
 def mac_ver(
     release: str = "", versioninfo: tuple[str, str, str] = ("", "", ""), machine: str = ""
 ) -> tuple[str, tuple[str, str, str], str]: ...
@@ -41,13 +15,40 @@ def java_ver(
 def system_alias(system: str, release: str, version: str) -> tuple[str, str, str]: ...
 def architecture(executable: str = sys.executable, bits: str = "", linkage: str = "") -> tuple[str, str]: ...
 
-class uname_result(NamedTuple):
-    system: str
-    node: str
-    release: str
-    version: str
-    machine: str
-    processor: str
+if sys.version_info >= (3, 9):
+    # This class is not exposed. It calls itself platform.uname_result_base.
+    # At runtime it only has 5 fields.
+    @type_check_only
+    class _uname_result_base(NamedTuple):
+        system: str
+        node: str
+        release: str
+        version: str
+        machine: str
+        # This base class doesn't have this field at runtime, but claiming it
+        # does is the least bad way to handle the situation. Nobody really
+        # sees this class anyway. See #13068
+        processor: str
+
+    # uname_result emulates a 6-field named tuple, but the processor field
+    # is lazily evaluated rather than being passed in to the constructor.
+    class uname_result(_uname_result_base):
+        if sys.version_info >= (3, 10):
+            __match_args__ = ("system", "node", "release", "version", "machine")  # pyright: ignore[reportAssignmentType]
+
+        def __new__(_cls, system: str, node: str, release: str, version: str, machine: str) -> Self: ...
+        @property
+        def processor(self) -> str: ...
+
+else:
+    # On 3.8, uname_result is actually just a regular NamedTuple.
+    class uname_result(NamedTuple):
+        system: str
+        node: str
+        release: str
+        version: str
+        machine: str
+        processor: str
 
 def uname() -> uname_result: ...
 def system() -> str: ...
@@ -67,3 +68,28 @@ def platform(aliased: bool = ..., terse: bool = ...) -> str: ...
 
 if sys.version_info >= (3, 10):
     def freedesktop_os_release() -> dict[str, str]: ...
+
+if sys.version_info >= (3, 13):
+    class AndroidVer(NamedTuple):
+        release: str
+        api_level: int
+        manufacturer: str
+        model: str
+        device: str
+        is_emulator: bool
+
+    class IOSVersionInfo(NamedTuple):
+        system: str
+        release: str
+        model: str
+        is_simulator: bool
+
+    def android_ver(
+        release: str = "",
+        api_level: int = 0,
+        manufacturer: str = "",
+        model: str = "",
+        device: str = "",
+        is_emulator: bool = False,
+    ) -> AndroidVer: ...
+    def ios_ver(system: str = "", release: str = "", model: str = "", is_simulator: bool = False) -> IOSVersionInfo: ...
diff --git a/mypy/typeshed/stdlib/plistlib.pyi b/mypy/typeshed/stdlib/plistlib.pyi
index 5b76c935f76e..72b5398f0a52 100644
--- a/mypy/typeshed/stdlib/plistlib.pyi
+++ b/mypy/typeshed/stdlib/plistlib.pyi
@@ -3,51 +3,36 @@ from _typeshed import ReadableBuffer
 from collections.abc import Mapping, MutableMapping
 from datetime import datetime
 from enum import Enum
-from typing import IO, Any
+from typing import IO, Any, ClassVar
 from typing_extensions import Self
 
-if sys.version_info >= (3, 9):
-    __all__ = ["InvalidFileException", "FMT_XML", "FMT_BINARY", "load", "dump", "loads", "dumps", "UID"]
-elif sys.version_info >= (3, 8):
-    __all__ = [
-        "readPlist",
-        "writePlist",
-        "readPlistFromBytes",
-        "writePlistToBytes",
-        "Data",
-        "InvalidFileException",
-        "FMT_XML",
-        "FMT_BINARY",
-        "load",
-        "dump",
-        "loads",
-        "dumps",
-        "UID",
-    ]
-else:
-    __all__ = [
-        "readPlist",
-        "writePlist",
-        "readPlistFromBytes",
-        "writePlistToBytes",
-        "Data",
-        "InvalidFileException",
-        "FMT_XML",
-        "FMT_BINARY",
-        "load",
-        "dump",
-        "loads",
-        "dumps",
-    ]
+__all__ = ["InvalidFileException", "FMT_XML", "FMT_BINARY", "load", "dump", "loads", "dumps", "UID"]
+if sys.version_info < (3, 9):
+    __all__ += ["readPlist", "writePlist", "readPlistFromBytes", "writePlistToBytes", "Data"]
 
 class PlistFormat(Enum):
-    FMT_XML: int
-    FMT_BINARY: int
+    FMT_XML = 1
+    FMT_BINARY = 2
 
 FMT_XML = PlistFormat.FMT_XML
 FMT_BINARY = PlistFormat.FMT_BINARY
+if sys.version_info >= (3, 13):
+    def load(
+        fp: IO[bytes],
+        *,
+        fmt: PlistFormat | None = None,
+        dict_type: type[MutableMapping[str, Any]] = ...,
+        aware_datetime: bool = False,
+    ) -> Any: ...
+    def loads(
+        value: ReadableBuffer | str,
+        *,
+        fmt: PlistFormat | None = None,
+        dict_type: type[MutableMapping[str, Any]] = ...,
+        aware_datetime: bool = False,
+    ) -> Any: ...
 
-if sys.version_info >= (3, 9):
+elif sys.version_info >= (3, 9):
     def load(fp: IO[bytes], *, fmt: PlistFormat | None = None, dict_type: type[MutableMapping[str, Any]] = ...) -> Any: ...
     def loads(
         value: ReadableBuffer, *, fmt: PlistFormat | None = None, dict_type: type[MutableMapping[str, Any]] = ...
@@ -69,21 +54,41 @@ else:
         dict_type: type[MutableMapping[str, Any]] = ...,
     ) -> Any: ...
 
-def dump(
-    value: Mapping[str, Any] | list[Any] | tuple[Any, ...] | str | bool | float | bytes | bytearray | datetime,
-    fp: IO[bytes],
-    *,
-    fmt: PlistFormat = ...,
-    sort_keys: bool = True,
-    skipkeys: bool = False,
-) -> None: ...
-def dumps(
-    value: Mapping[str, Any] | list[Any] | tuple[Any, ...] | str | bool | float | bytes | bytearray | datetime,
-    *,
-    fmt: PlistFormat = ...,
-    skipkeys: bool = False,
-    sort_keys: bool = True,
-) -> bytes: ...
+if sys.version_info >= (3, 13):
+    def dump(
+        value: Mapping[str, Any] | list[Any] | tuple[Any, ...] | str | bool | float | bytes | bytearray | datetime,
+        fp: IO[bytes],
+        *,
+        fmt: PlistFormat = ...,
+        sort_keys: bool = True,
+        skipkeys: bool = False,
+        aware_datetime: bool = False,
+    ) -> None: ...
+    def dumps(
+        value: Mapping[str, Any] | list[Any] | tuple[Any, ...] | str | bool | float | bytes | bytearray | datetime,
+        *,
+        fmt: PlistFormat = ...,
+        skipkeys: bool = False,
+        sort_keys: bool = True,
+        aware_datetime: bool = False,
+    ) -> bytes: ...
+
+else:
+    def dump(
+        value: Mapping[str, Any] | list[Any] | tuple[Any, ...] | str | bool | float | bytes | bytearray | datetime,
+        fp: IO[bytes],
+        *,
+        fmt: PlistFormat = ...,
+        sort_keys: bool = True,
+        skipkeys: bool = False,
+    ) -> None: ...
+    def dumps(
+        value: Mapping[str, Any] | list[Any] | tuple[Any, ...] | str | bool | float | bytes | bytearray | datetime,
+        *,
+        fmt: PlistFormat = ...,
+        skipkeys: bool = False,
+        sort_keys: bool = True,
+    ) -> bytes: ...
 
 if sys.version_info < (3, 9):
     def readPlist(pathOrFile: str | IO[bytes]) -> Any: ...
@@ -95,14 +100,15 @@ if sys.version_info < (3, 9):
     class Data:
         data: bytes
         def __init__(self, data: bytes) -> None: ...
+        __hash__: ClassVar[None]  # type: ignore[assignment]
 
-if sys.version_info >= (3, 8):
-    class UID:
-        data: int
-        def __init__(self, data: int) -> None: ...
-        def __index__(self) -> int: ...
-        def __reduce__(self) -> tuple[type[Self], tuple[int]]: ...
-        def __eq__(self, other: object) -> bool: ...
+class UID:
+    data: int
+    def __init__(self, data: int) -> None: ...
+    def __index__(self) -> int: ...
+    def __reduce__(self) -> tuple[type[Self], tuple[int]]: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
 
 class InvalidFileException(ValueError):
     def __init__(self, message: str = "Invalid file") -> None: ...
diff --git a/mypy/typeshed/stdlib/poplib.pyi b/mypy/typeshed/stdlib/poplib.pyi
index c64e47e8ef72..a1e41be86a7f 100644
--- a/mypy/typeshed/stdlib/poplib.pyi
+++ b/mypy/typeshed/stdlib/poplib.pyi
@@ -1,9 +1,10 @@
 import socket
 import ssl
+import sys
 from builtins import list as _list  # conflicts with a method named "list"
 from re import Pattern
-from typing import Any, BinaryIO, NoReturn, overload
-from typing_extensions import Literal, TypeAlias
+from typing import Any, BinaryIO, Final, NoReturn, overload
+from typing_extensions import TypeAlias
 
 __all__ = ["POP3", "error_proto", "POP3_SSL"]
 
@@ -11,11 +12,11 @@ _LongResp: TypeAlias = tuple[bytes, list[bytes], int]
 
 class error_proto(Exception): ...
 
-POP3_PORT: Literal[110]
-POP3_SSL_PORT: Literal[995]
-CR: Literal[b"\r"]
-LF: Literal[b"\n"]
-CRLF: Literal[b"\r\n"]
+POP3_PORT: Final = 110
+POP3_SSL_PORT: Final = 995
+CR: Final = b"\r"
+LF: Final = b"\n"
+CRLF: Final = b"\r\n"
 HAVE_SSL: bool
 
 class POP3:
@@ -51,14 +52,21 @@ class POP3:
     def stls(self, context: ssl.SSLContext | None = None) -> bytes: ...
 
 class POP3_SSL(POP3):
-    def __init__(
-        self,
-        host: str,
-        port: int = 995,
-        keyfile: str | None = None,
-        certfile: str | None = None,
-        timeout: float = ...,
-        context: ssl.SSLContext | None = None,
-    ) -> None: ...
-    # "context" is actually the last argument, but that breaks LSP and it doesn't really matter because all the arguments are ignored
-    def stls(self, context: Any = None, keyfile: Any = None, certfile: Any = None) -> NoReturn: ...
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self, host: str, port: int = 995, *, timeout: float = ..., context: ssl.SSLContext | None = None
+        ) -> None: ...
+        def stls(self, context: Any = None) -> NoReturn: ...
+    else:
+        def __init__(
+            self,
+            host: str,
+            port: int = 995,
+            keyfile: str | None = None,
+            certfile: str | None = None,
+            timeout: float = ...,
+            context: ssl.SSLContext | None = None,
+        ) -> None: ...
+        # "context" is actually the last argument,
+        # but that breaks LSP and it doesn't really matter because all the arguments are ignored
+        def stls(self, context: Any = None, keyfile: Any = None, certfile: Any = None) -> NoReturn: ...
diff --git a/mypy/typeshed/stdlib/posix.pyi b/mypy/typeshed/stdlib/posix.pyi
index ffd96757586b..e7223842ace5 100644
--- a/mypy/typeshed/stdlib/posix.pyi
+++ b/mypy/typeshed/stdlib/posix.pyi
@@ -14,7 +14,6 @@ if sys.platform != "win32":
         EX_NOHOST as EX_NOHOST,
         EX_NOINPUT as EX_NOINPUT,
         EX_NOPERM as EX_NOPERM,
-        EX_NOTFOUND as EX_NOTFOUND,
         EX_NOUSER as EX_NOUSER,
         EX_OK as EX_OK,
         EX_OSERR as EX_OSERR,
@@ -29,28 +28,30 @@ if sys.platform != "win32":
         F_TEST as F_TEST,
         F_TLOCK as F_TLOCK,
         F_ULOCK as F_ULOCK,
+        NGROUPS_MAX as NGROUPS_MAX,
+        O_ACCMODE as O_ACCMODE,
         O_APPEND as O_APPEND,
         O_ASYNC as O_ASYNC,
+        O_CLOEXEC as O_CLOEXEC,
         O_CREAT as O_CREAT,
-        O_DIRECT as O_DIRECT,
         O_DIRECTORY as O_DIRECTORY,
         O_DSYNC as O_DSYNC,
         O_EXCL as O_EXCL,
-        O_LARGEFILE as O_LARGEFILE,
         O_NDELAY as O_NDELAY,
-        O_NOATIME as O_NOATIME,
         O_NOCTTY as O_NOCTTY,
         O_NOFOLLOW as O_NOFOLLOW,
         O_NONBLOCK as O_NONBLOCK,
         O_RDONLY as O_RDONLY,
         O_RDWR as O_RDWR,
-        O_RSYNC as O_RSYNC,
         O_SYNC as O_SYNC,
         O_TRUNC as O_TRUNC,
         O_WRONLY as O_WRONLY,
         P_ALL as P_ALL,
         P_PGID as P_PGID,
         P_PID as P_PID,
+        POSIX_SPAWN_CLOSE as POSIX_SPAWN_CLOSE,
+        POSIX_SPAWN_DUP2 as POSIX_SPAWN_DUP2,
+        POSIX_SPAWN_OPEN as POSIX_SPAWN_OPEN,
         PRIO_PGRP as PRIO_PGRP,
         PRIO_PROCESS as PRIO_PROCESS,
         PRIO_USER as PRIO_USER,
@@ -61,13 +62,9 @@ if sys.platform != "win32":
         RTLD_NODELETE as RTLD_NODELETE,
         RTLD_NOLOAD as RTLD_NOLOAD,
         RTLD_NOW as RTLD_NOW,
-        SCHED_BATCH as SCHED_BATCH,
         SCHED_FIFO as SCHED_FIFO,
-        SCHED_IDLE as SCHED_IDLE,
         SCHED_OTHER as SCHED_OTHER,
-        SCHED_RESET_ON_FORK as SCHED_RESET_ON_FORK,
         SCHED_RR as SCHED_RR,
-        SCHED_SPORADIC as SCHED_SPORADIC,
         SEEK_DATA as SEEK_DATA,
         SEEK_HOLE as SEEK_HOLE,
         ST_NOSUID as ST_NOSUID,
@@ -161,12 +158,17 @@ if sys.platform != "win32":
         pathconf as pathconf,
         pathconf_names as pathconf_names,
         pipe as pipe,
+        posix_spawn as posix_spawn,
+        posix_spawnp as posix_spawnp,
         pread as pread,
+        preadv as preadv,
         putenv as putenv,
         pwrite as pwrite,
+        pwritev as pwritev,
         read as read,
         readlink as readlink,
         readv as readv,
+        register_at_fork as register_at_fork,
         remove as remove,
         rename as rename,
         replace as replace,
@@ -222,22 +224,40 @@ if sys.platform != "win32":
         writev as writev,
     )
 
-    if sys.platform == "linux":
+    if sys.version_info >= (3, 9):
+        from os import CLD_KILLED as CLD_KILLED, CLD_STOPPED as CLD_STOPPED, waitstatus_to_exitcode as waitstatus_to_exitcode
+
+    if sys.version_info >= (3, 10):
+        from os import O_FSYNC as O_FSYNC
+
+    if sys.version_info >= (3, 11):
+        from os import login_tty as login_tty
+
+    if sys.version_info >= (3, 13):
+        from os import grantpt as grantpt, posix_openpt as posix_openpt, ptsname as ptsname, unlockpt as unlockpt
+
+    if sys.version_info >= (3, 13) and sys.platform == "linux":
         from os import (
-            GRND_NONBLOCK as GRND_NONBLOCK,
-            GRND_RANDOM as GRND_RANDOM,
-            RTLD_DEEPBIND as RTLD_DEEPBIND,
-            XATTR_CREATE as XATTR_CREATE,
-            XATTR_REPLACE as XATTR_REPLACE,
-            XATTR_SIZE_MAX as XATTR_SIZE_MAX,
-            getrandom as getrandom,
-            getxattr as getxattr,
-            listxattr as listxattr,
-            removexattr as removexattr,
-            setxattr as setxattr,
+            POSIX_SPAWN_CLOSEFROM as POSIX_SPAWN_CLOSEFROM,
+            TFD_CLOEXEC as TFD_CLOEXEC,
+            TFD_NONBLOCK as TFD_NONBLOCK,
+            TFD_TIMER_ABSTIME as TFD_TIMER_ABSTIME,
+            TFD_TIMER_CANCEL_ON_SET as TFD_TIMER_CANCEL_ON_SET,
+            timerfd_create as timerfd_create,
+            timerfd_gettime as timerfd_gettime,
+            timerfd_gettime_ns as timerfd_gettime_ns,
+            timerfd_settime as timerfd_settime,
+            timerfd_settime_ns as timerfd_settime_ns,
         )
-    else:
-        from os import chflags as chflags, lchflags as lchflags, lchmod as lchmod
+
+    if sys.platform != "linux":
+        from os import O_EXLOCK as O_EXLOCK, O_SHLOCK as O_SHLOCK, chflags as chflags, lchflags as lchflags, lchmod as lchmod
+
+    if sys.platform != "linux" and sys.platform != "darwin":
+        from os import EX_NOTFOUND as EX_NOTFOUND, SCHED_SPORADIC as SCHED_SPORADIC
+
+    if sys.platform != "linux" and sys.version_info >= (3, 13):
+        from os import O_EXEC as O_EXEC, O_SEARCH as O_SEARCH
 
     if sys.platform != "darwin":
         from os import (
@@ -247,6 +267,19 @@ if sys.platform != "win32":
             POSIX_FADV_RANDOM as POSIX_FADV_RANDOM,
             POSIX_FADV_SEQUENTIAL as POSIX_FADV_SEQUENTIAL,
             POSIX_FADV_WILLNEED as POSIX_FADV_WILLNEED,
+            RWF_DSYNC as RWF_DSYNC,
+            RWF_HIPRI as RWF_HIPRI,
+            RWF_NOWAIT as RWF_NOWAIT,
+            RWF_SYNC as RWF_SYNC,
+            ST_APPEND as ST_APPEND,
+            ST_MANDLOCK as ST_MANDLOCK,
+            ST_NOATIME as ST_NOATIME,
+            ST_NODEV as ST_NODEV,
+            ST_NODIRATIME as ST_NODIRATIME,
+            ST_NOEXEC as ST_NOEXEC,
+            ST_RELATIME as ST_RELATIME,
+            ST_SYNCHRONOUS as ST_SYNCHRONOUS,
+            ST_WRITE as ST_WRITE,
             fdatasync as fdatasync,
             getresgid as getresgid,
             getresuid as getresuid,
@@ -262,57 +295,105 @@ if sys.platform != "win32":
             sched_setscheduler as sched_setscheduler,
             setresgid as setresgid,
             setresuid as setresuid,
-            waitid as waitid,
-            waitid_result as waitid_result,
         )
 
         if sys.version_info >= (3, 10):
             from os import RWF_APPEND as RWF_APPEND
 
-    if sys.version_info >= (3, 11):
-        from os import login_tty as login_tty
+    if sys.platform != "darwin" or sys.version_info >= (3, 13):
+        from os import waitid as waitid, waitid_result as waitid_result
 
-    if sys.version_info >= (3, 9):
-        from os import CLD_KILLED as CLD_KILLED, CLD_STOPPED as CLD_STOPPED, waitstatus_to_exitcode as waitstatus_to_exitcode
+    if sys.platform == "linux":
+        from os import (
+            GRND_NONBLOCK as GRND_NONBLOCK,
+            GRND_RANDOM as GRND_RANDOM,
+            MFD_ALLOW_SEALING as MFD_ALLOW_SEALING,
+            MFD_CLOEXEC as MFD_CLOEXEC,
+            MFD_HUGE_1GB as MFD_HUGE_1GB,
+            MFD_HUGE_1MB as MFD_HUGE_1MB,
+            MFD_HUGE_2GB as MFD_HUGE_2GB,
+            MFD_HUGE_2MB as MFD_HUGE_2MB,
+            MFD_HUGE_8MB as MFD_HUGE_8MB,
+            MFD_HUGE_16GB as MFD_HUGE_16GB,
+            MFD_HUGE_16MB as MFD_HUGE_16MB,
+            MFD_HUGE_32MB as MFD_HUGE_32MB,
+            MFD_HUGE_64KB as MFD_HUGE_64KB,
+            MFD_HUGE_256MB as MFD_HUGE_256MB,
+            MFD_HUGE_512KB as MFD_HUGE_512KB,
+            MFD_HUGE_512MB as MFD_HUGE_512MB,
+            MFD_HUGE_MASK as MFD_HUGE_MASK,
+            MFD_HUGE_SHIFT as MFD_HUGE_SHIFT,
+            MFD_HUGETLB as MFD_HUGETLB,
+            O_DIRECT as O_DIRECT,
+            O_LARGEFILE as O_LARGEFILE,
+            O_NOATIME as O_NOATIME,
+            O_PATH as O_PATH,
+            O_RSYNC as O_RSYNC,
+            O_TMPFILE as O_TMPFILE,
+            RTLD_DEEPBIND as RTLD_DEEPBIND,
+            SCHED_BATCH as SCHED_BATCH,
+            SCHED_IDLE as SCHED_IDLE,
+            SCHED_RESET_ON_FORK as SCHED_RESET_ON_FORK,
+            XATTR_CREATE as XATTR_CREATE,
+            XATTR_REPLACE as XATTR_REPLACE,
+            XATTR_SIZE_MAX as XATTR_SIZE_MAX,
+            copy_file_range as copy_file_range,
+            getrandom as getrandom,
+            getxattr as getxattr,
+            listxattr as listxattr,
+            memfd_create as memfd_create,
+            removexattr as removexattr,
+            setxattr as setxattr,
+        )
 
-        if sys.platform == "linux":
+        if sys.version_info >= (3, 9):
             from os import P_PIDFD as P_PIDFD, pidfd_open as pidfd_open
 
-    if sys.version_info >= (3, 8):
-        from os import (
-            POSIX_SPAWN_CLOSE as POSIX_SPAWN_CLOSE,
-            POSIX_SPAWN_DUP2 as POSIX_SPAWN_DUP2,
-            POSIX_SPAWN_OPEN as POSIX_SPAWN_OPEN,
-            posix_spawn as posix_spawn,
-            posix_spawnp as posix_spawnp,
-        )
+        if sys.version_info >= (3, 10):
+            from os import (
+                EFD_CLOEXEC as EFD_CLOEXEC,
+                EFD_NONBLOCK as EFD_NONBLOCK,
+                EFD_SEMAPHORE as EFD_SEMAPHORE,
+                SPLICE_F_MORE as SPLICE_F_MORE,
+                SPLICE_F_MOVE as SPLICE_F_MOVE,
+                SPLICE_F_NONBLOCK as SPLICE_F_NONBLOCK,
+                eventfd as eventfd,
+                eventfd_read as eventfd_read,
+                eventfd_write as eventfd_write,
+                splice as splice,
+            )
 
-        if sys.platform == "linux":
+        if sys.version_info >= (3, 12):
             from os import (
-                MFD_ALLOW_SEALING as MFD_ALLOW_SEALING,
-                MFD_CLOEXEC as MFD_CLOEXEC,
-                MFD_HUGE_1GB as MFD_HUGE_1GB,
-                MFD_HUGE_1MB as MFD_HUGE_1MB,
-                MFD_HUGE_2GB as MFD_HUGE_2GB,
-                MFD_HUGE_2MB as MFD_HUGE_2MB,
-                MFD_HUGE_8MB as MFD_HUGE_8MB,
-                MFD_HUGE_16GB as MFD_HUGE_16GB,
-                MFD_HUGE_16MB as MFD_HUGE_16MB,
-                MFD_HUGE_32MB as MFD_HUGE_32MB,
-                MFD_HUGE_64KB as MFD_HUGE_64KB,
-                MFD_HUGE_256MB as MFD_HUGE_256MB,
-                MFD_HUGE_512KB as MFD_HUGE_512KB,
-                MFD_HUGE_512MB as MFD_HUGE_512MB,
-                MFD_HUGE_MASK as MFD_HUGE_MASK,
-                MFD_HUGE_SHIFT as MFD_HUGE_SHIFT,
-                MFD_HUGETLB as MFD_HUGETLB,
-                copy_file_range as copy_file_range,
-                memfd_create as memfd_create,
+                CLONE_FILES as CLONE_FILES,
+                CLONE_FS as CLONE_FS,
+                CLONE_NEWCGROUP as CLONE_NEWCGROUP,
+                CLONE_NEWIPC as CLONE_NEWIPC,
+                CLONE_NEWNET as CLONE_NEWNET,
+                CLONE_NEWNS as CLONE_NEWNS,
+                CLONE_NEWPID as CLONE_NEWPID,
+                CLONE_NEWTIME as CLONE_NEWTIME,
+                CLONE_NEWUSER as CLONE_NEWUSER,
+                CLONE_NEWUTS as CLONE_NEWUTS,
+                CLONE_SIGHAND as CLONE_SIGHAND,
+                CLONE_SYSVSEM as CLONE_SYSVSEM,
+                CLONE_THREAD as CLONE_THREAD,
+                CLONE_VM as CLONE_VM,
+                PIDFD_NONBLOCK as PIDFD_NONBLOCK,
+                setns as setns,
+                unshare as unshare,
             )
-    from os import preadv as preadv, pwritev as pwritev, register_at_fork as register_at_fork
 
-    if sys.platform != "darwin":
-        from os import RWF_DSYNC as RWF_DSYNC, RWF_HIPRI as RWF_HIPRI, RWF_NOWAIT as RWF_NOWAIT, RWF_SYNC as RWF_SYNC
+    if sys.platform == "darwin":
+        if sys.version_info >= (3, 12):
+            from os import (
+                PRIO_DARWIN_BG as PRIO_DARWIN_BG,
+                PRIO_DARWIN_NONUI as PRIO_DARWIN_NONUI,
+                PRIO_DARWIN_PROCESS as PRIO_DARWIN_PROCESS,
+                PRIO_DARWIN_THREAD as PRIO_DARWIN_THREAD,
+            )
+    if sys.platform == "darwin" and sys.version_info >= (3, 10):
+        from os import O_EVTONLY as O_EVTONLY, O_NOFOLLOW_ANY as O_NOFOLLOW_ANY, O_SYMLINK as O_SYMLINK
 
     # Not same as os.environ or os.environb
     # Because of this variable, we can't do "from posix import *" in os/__init__.pyi
diff --git a/mypy/typeshed/stdlib/posixpath.pyi b/mypy/typeshed/stdlib/posixpath.pyi
index 1945190be5f8..3313667f1781 100644
--- a/mypy/typeshed/stdlib/posixpath.pyi
+++ b/mypy/typeshed/stdlib/posixpath.pyi
@@ -1,6 +1,6 @@
 import sys
 from _typeshed import AnyOrLiteralStr, BytesPath, FileDescriptorOrPath, StrOrBytesPath, StrPath
-from collections.abc import Sequence
+from collections.abc import Iterable
 from genericpath import (
     commonprefix as commonprefix,
     exists as exists,
@@ -14,6 +14,9 @@ from genericpath import (
     sameopenfile as sameopenfile,
     samestat as samestat,
 )
+
+if sys.version_info >= (3, 13):
+    from genericpath import isdevdrive as isdevdrive
 from os import PathLike
 from typing import AnyStr, overload
 from typing_extensions import LiteralString
@@ -58,6 +61,10 @@ __all__ = [
     "relpath",
     "commonpath",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["isjunction", "splitroot"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isdevdrive"]
 
 supports_unicode_filenames: bool
 # aliases (also in os)
@@ -70,7 +77,7 @@ pathsep: LiteralString
 defpath: LiteralString
 devnull: LiteralString
 
-# Overloads are necessary to work around python/mypy#3644.
+# Overloads are necessary to work around python/mypy#17952 & python/mypy#11880
 @overload
 def abspath(path: PathLike[AnyStr]) -> AnyStr: ...
 @overload
@@ -100,21 +107,21 @@ def normpath(path: PathLike[AnyStr]) -> AnyStr: ...
 @overload
 def normpath(path: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
 @overload
-def commonpath(paths: Sequence[LiteralString]) -> LiteralString: ...
+def commonpath(paths: Iterable[LiteralString]) -> LiteralString: ...
 @overload
-def commonpath(paths: Sequence[StrPath]) -> str: ...
+def commonpath(paths: Iterable[StrPath]) -> str: ...
 @overload
-def commonpath(paths: Sequence[BytesPath]) -> bytes: ...
+def commonpath(paths: Iterable[BytesPath]) -> bytes: ...
 
 # First parameter is not actually pos-only,
 # but must be defined as pos-only in the stub or cross-platform code doesn't type-check,
 # as the parameter name is different in ntpath.join()
 @overload
-def join(__a: LiteralString, *paths: LiteralString) -> LiteralString: ...
+def join(a: LiteralString, /, *paths: LiteralString) -> LiteralString: ...
 @overload
-def join(__a: StrPath, *paths: StrPath) -> str: ...
+def join(a: StrPath, /, *paths: StrPath) -> str: ...
 @overload
-def join(__a: BytesPath, *paths: BytesPath) -> bytes: ...
+def join(a: BytesPath, /, *paths: BytesPath) -> bytes: ...
 
 if sys.version_info >= (3, 10):
     @overload
@@ -150,3 +157,10 @@ def isabs(s: StrOrBytesPath) -> bool: ...
 def islink(path: FileDescriptorOrPath) -> bool: ...
 def ismount(path: FileDescriptorOrPath) -> bool: ...
 def lexists(path: FileDescriptorOrPath) -> bool: ...
+
+if sys.version_info >= (3, 12):
+    def isjunction(path: StrOrBytesPath) -> bool: ...
+    @overload
+    def splitroot(p: AnyOrLiteralStr) -> tuple[AnyOrLiteralStr, AnyOrLiteralStr, AnyOrLiteralStr]: ...
+    @overload
+    def splitroot(p: PathLike[AnyStr]) -> tuple[AnyStr, AnyStr, AnyStr]: ...
diff --git a/mypy/typeshed/stdlib/pprint.pyi b/mypy/typeshed/stdlib/pprint.pyi
index 5a909c69b077..171878f4165d 100644
--- a/mypy/typeshed/stdlib/pprint.pyi
+++ b/mypy/typeshed/stdlib/pprint.pyi
@@ -1,10 +1,7 @@
 import sys
 from typing import IO
 
-if sys.version_info >= (3, 8):
-    __all__ = ["pprint", "pformat", "isreadable", "isrecursive", "saferepr", "PrettyPrinter", "pp"]
-else:
-    __all__ = ["pprint", "pformat", "isreadable", "isrecursive", "saferepr", "PrettyPrinter"]
+__all__ = ["pprint", "pformat", "isreadable", "isrecursive", "saferepr", "PrettyPrinter", "pp"]
 
 if sys.version_info >= (3, 10):
     def pformat(
@@ -18,7 +15,7 @@ if sys.version_info >= (3, 10):
         underscore_numbers: bool = False,
     ) -> str: ...
 
-elif sys.version_info >= (3, 8):
+else:
     def pformat(
         object: object,
         indent: int = 1,
@@ -29,9 +26,6 @@ elif sys.version_info >= (3, 8):
         sort_dicts: bool = True,
     ) -> str: ...
 
-else:
-    def pformat(object: object, indent: int = 1, width: int = 80, depth: int | None = None, *, compact: bool = False) -> str: ...
-
 if sys.version_info >= (3, 10):
     def pp(
         object: object,
@@ -45,7 +39,7 @@ if sys.version_info >= (3, 10):
         underscore_numbers: bool = ...,
     ) -> None: ...
 
-elif sys.version_info >= (3, 8):
+else:
     def pp(
         object: object,
         stream: IO[str] | None = ...,
@@ -70,18 +64,6 @@ if sys.version_info >= (3, 10):
         underscore_numbers: bool = False,
     ) -> None: ...
 
-elif sys.version_info >= (3, 8):
-    def pprint(
-        object: object,
-        stream: IO[str] | None = None,
-        indent: int = 1,
-        width: int = 80,
-        depth: int | None = None,
-        *,
-        compact: bool = False,
-        sort_dicts: bool = True,
-    ) -> None: ...
-
 else:
     def pprint(
         object: object,
@@ -91,6 +73,7 @@ else:
         depth: int | None = None,
         *,
         compact: bool = False,
+        sort_dicts: bool = True,
     ) -> None: ...
 
 def isreadable(object: object) -> bool: ...
@@ -110,17 +93,6 @@ class PrettyPrinter:
             sort_dicts: bool = True,
             underscore_numbers: bool = False,
         ) -> None: ...
-    elif sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            indent: int = 1,
-            width: int = 80,
-            depth: int | None = None,
-            stream: IO[str] | None = None,
-            *,
-            compact: bool = False,
-            sort_dicts: bool = True,
-        ) -> None: ...
     else:
         def __init__(
             self,
@@ -130,6 +102,7 @@ class PrettyPrinter:
             stream: IO[str] | None = None,
             *,
             compact: bool = False,
+            sort_dicts: bool = True,
         ) -> None: ...
 
     def pformat(self, object: object) -> str: ...
diff --git a/mypy/typeshed/stdlib/profile.pyi b/mypy/typeshed/stdlib/profile.pyi
index 6ae375004158..696193d9dc16 100644
--- a/mypy/typeshed/stdlib/profile.pyi
+++ b/mypy/typeshed/stdlib/profile.pyi
@@ -1,5 +1,5 @@
 from _typeshed import StrOrBytesPath
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import Any, TypeVar
 from typing_extensions import ParamSpec, Self, TypeAlias
 
@@ -7,7 +7,7 @@ __all__ = ["run", "runctx", "Profile"]
 
 def run(statement: str, filename: str | None = None, sort: str | int = -1) -> None: ...
 def runctx(
-    statement: str, globals: dict[str, Any], locals: dict[str, Any], filename: str | None = None, sort: str | int = -1
+    statement: str, globals: dict[str, Any], locals: Mapping[str, Any], filename: str | None = None, sort: str | int = -1
 ) -> None: ...
 
 _T = TypeVar("_T")
@@ -26,6 +26,6 @@ class Profile:
     def create_stats(self) -> None: ...
     def snapshot_stats(self) -> None: ...
     def run(self, cmd: str) -> Self: ...
-    def runctx(self, cmd: str, globals: dict[str, Any], locals: dict[str, Any]) -> Self: ...
-    def runcall(self, __func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs) -> _T: ...
+    def runctx(self, cmd: str, globals: dict[str, Any], locals: Mapping[str, Any]) -> Self: ...
+    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kw: _P.kwargs) -> _T: ...
     def calibrate(self, m: int, verbose: int = 0) -> float: ...
diff --git a/mypy/typeshed/stdlib/pstats.pyi b/mypy/typeshed/stdlib/pstats.pyi
index 5d25d1bb3641..d41fa202cf77 100644
--- a/mypy/typeshed/stdlib/pstats.pyi
+++ b/mypy/typeshed/stdlib/pstats.pyi
@@ -2,10 +2,14 @@ import sys
 from _typeshed import StrOrBytesPath
 from collections.abc import Iterable
 from cProfile import Profile as _cProfile
-from enum import Enum
 from profile import Profile
-from typing import IO, Any, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, Literal, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from enum import Enum
 
 if sys.version_info >= (3, 9):
     __all__ = ["Stats", "SortKey", "FunctionProfile", "StatsProfile"]
@@ -14,16 +18,29 @@ else:
 
 _Selector: TypeAlias = str | float | int
 
-class SortKey(str, Enum):
-    CALLS: str
-    CUMULATIVE: str
-    FILENAME: str
-    LINE: str
-    NAME: str
-    NFL: str
-    PCALLS: str
-    STDNAME: str
-    TIME: str
+if sys.version_info >= (3, 11):
+    class SortKey(StrEnum):
+        CALLS = "calls"
+        CUMULATIVE = "cumulative"
+        FILENAME = "filename"
+        LINE = "line"
+        NAME = "name"
+        NFL = "nfl"
+        PCALLS = "pcalls"
+        STDNAME = "stdname"
+        TIME = "time"
+
+else:
+    class SortKey(str, Enum):
+        CALLS = "calls"
+        CUMULATIVE = "cumulative"
+        FILENAME = "filename"
+        LINE = "line"
+        NAME = "name"
+        NFL = "nfl"
+        PCALLS = "pcalls"
+        STDNAME = "stdname"
+        TIME = "time"
 
 if sys.version_info >= (3, 9):
     from dataclasses import dataclass
@@ -37,6 +54,7 @@ if sys.version_info >= (3, 9):
         percall_cumtime: float
         file_name: str
         line_number: int
+
     @dataclass(unsafe_hash=True)
     class StatsProfile:
         total_tt: float
@@ -48,7 +66,8 @@ class Stats:
     sort_arg_dict_default: _SortArgDict
     def __init__(
         self,
-        __arg: None | str | Profile | _cProfile = ...,
+        arg: None | str | Profile | _cProfile = ...,
+        /,
         *args: None | str | Profile | _cProfile | Self,
         stream: IO[Any] | None = None,
     ) -> None: ...
diff --git a/mypy/typeshed/stdlib/pty.pyi b/mypy/typeshed/stdlib/pty.pyi
index a6a2d8fabb69..941915179c4a 100644
--- a/mypy/typeshed/stdlib/pty.pyi
+++ b/mypy/typeshed/stdlib/pty.pyi
@@ -1,18 +1,24 @@
 import sys
 from collections.abc import Callable, Iterable
-from typing_extensions import Literal, TypeAlias
+from typing import Final
+from typing_extensions import TypeAlias, deprecated
 
 if sys.platform != "win32":
     __all__ = ["openpty", "fork", "spawn"]
     _Reader: TypeAlias = Callable[[int], bytes]
 
-    STDIN_FILENO: Literal[0]
-    STDOUT_FILENO: Literal[1]
-    STDERR_FILENO: Literal[2]
+    STDIN_FILENO: Final = 0
+    STDOUT_FILENO: Final = 1
+    STDERR_FILENO: Final = 2
 
-    CHILD: Literal[0]
+    CHILD: Final = 0
     def openpty() -> tuple[int, int]: ...
-    def master_open() -> tuple[int, str]: ...  # deprecated, use openpty()
-    def slave_open(tty_name: str) -> int: ...  # deprecated, use openpty()
+
+    if sys.version_info < (3, 14):
+        @deprecated("Deprecated in 3.12, to be removed in 3.14; use openpty() instead")
+        def master_open() -> tuple[int, str]: ...
+        @deprecated("Deprecated in 3.12, to be removed in 3.14; use openpty() instead")
+        def slave_open(tty_name: str) -> int: ...
+
     def fork() -> tuple[int, int]: ...
     def spawn(argv: str | Iterable[str], master_read: _Reader = ..., stdin_read: _Reader = ...) -> int: ...
diff --git a/mypy/typeshed/stdlib/pwd.pyi b/mypy/typeshed/stdlib/pwd.pyi
index 80813479d7af..a84ba324718a 100644
--- a/mypy/typeshed/stdlib/pwd.pyi
+++ b/mypy/typeshed/stdlib/pwd.pyi
@@ -1,13 +1,13 @@
 import sys
 from _typeshed import structseq
-from typing import Any
-from typing_extensions import Final, final
+from typing import Any, Final, final
 
 if sys.platform != "win32":
     @final
     class struct_passwd(structseq[Any], tuple[str, str, int, int, str, str, str]):
         if sys.version_info >= (3, 10):
             __match_args__: Final = ("pw_name", "pw_passwd", "pw_uid", "pw_gid", "pw_gecos", "pw_dir", "pw_shell")
+
         @property
         def pw_name(self) -> str: ...
         @property
@@ -24,5 +24,5 @@ if sys.platform != "win32":
         def pw_shell(self) -> str: ...
 
     def getpwall() -> list[struct_passwd]: ...
-    def getpwuid(__uid: int) -> struct_passwd: ...
-    def getpwnam(__name: str) -> struct_passwd: ...
+    def getpwuid(uid: int, /) -> struct_passwd: ...
+    def getpwnam(name: str, /) -> struct_passwd: ...
diff --git a/mypy/typeshed/stdlib/py_compile.pyi b/mypy/typeshed/stdlib/py_compile.pyi
index 48f1d7dc3e70..334ce79b5dd0 100644
--- a/mypy/typeshed/stdlib/py_compile.pyi
+++ b/mypy/typeshed/stdlib/py_compile.pyi
@@ -12,32 +12,20 @@ class PyCompileError(Exception):
     def __init__(self, exc_type: type[BaseException], exc_value: BaseException, file: str, msg: str = "") -> None: ...
 
 class PycInvalidationMode(enum.Enum):
-    TIMESTAMP: int
-    CHECKED_HASH: int
-    UNCHECKED_HASH: int
+    TIMESTAMP = 1
+    CHECKED_HASH = 2
+    UNCHECKED_HASH = 3
 
 def _get_default_invalidation_mode() -> PycInvalidationMode: ...
-
-if sys.version_info >= (3, 8):
-    def compile(
-        file: AnyStr,
-        cfile: AnyStr | None = None,
-        dfile: AnyStr | None = None,
-        doraise: bool = False,
-        optimize: int = -1,
-        invalidation_mode: PycInvalidationMode | None = None,
-        quiet: int = 0,
-    ) -> AnyStr | None: ...
-
-else:
-    def compile(
-        file: AnyStr,
-        cfile: AnyStr | None = None,
-        dfile: AnyStr | None = None,
-        doraise: bool = False,
-        optimize: int = -1,
-        invalidation_mode: PycInvalidationMode | None = None,
-    ) -> AnyStr | None: ...
+def compile(
+    file: AnyStr,
+    cfile: AnyStr | None = None,
+    dfile: AnyStr | None = None,
+    doraise: bool = False,
+    optimize: int = -1,
+    invalidation_mode: PycInvalidationMode | None = None,
+    quiet: int = 0,
+) -> AnyStr | None: ...
 
 if sys.version_info >= (3, 10):
     def main() -> None: ...
diff --git a/mypy/typeshed/stdlib/pyclbr.pyi b/mypy/typeshed/stdlib/pyclbr.pyi
index 38658a03139c..504a5d5f115a 100644
--- a/mypy/typeshed/stdlib/pyclbr.pyi
+++ b/mypy/typeshed/stdlib/pyclbr.pyi
@@ -1,20 +1,35 @@
 import sys
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 
 __all__ = ["readmodule", "readmodule_ex", "Class", "Function"]
 
-class Class:
+class _Object:
     module: str
     name: str
-    super: list[Class | str] | None
-    methods: dict[str, int]
     file: int
     lineno: int
 
     if sys.version_info >= (3, 10):
         end_lineno: int | None
 
-    parent: Class | None
+    parent: _Object | None
+
+    # This is a dict at runtime, but we're typing it as Mapping to
+    # avoid variance issues in the subclasses
+    children: Mapping[str, _Object]
+
+    if sys.version_info >= (3, 10):
+        def __init__(
+            self, module: str, name: str, file: str, lineno: int, end_lineno: int | None, parent: _Object | None
+        ) -> None: ...
+    else:
+        def __init__(self, module: str, name: str, file: str, lineno: int, parent: _Object | None) -> None: ...
+
+class Function(_Object):
+    if sys.version_info >= (3, 10):
+        is_async: bool
+
+    parent: Function | Class | None
     children: dict[str, Class | Function]
 
     if sys.version_info >= (3, 10):
@@ -22,29 +37,20 @@ class Class:
             self,
             module: str,
             name: str,
-            super_: list[Class | str] | None,
             file: str,
             lineno: int,
-            parent: Class | None = None,
+            parent: Function | Class | None = None,
+            is_async: bool = False,
             *,
             end_lineno: int | None = None,
         ) -> None: ...
     else:
-        def __init__(
-            self, module: str, name: str, super: list[Class | str] | None, file: str, lineno: int, parent: Class | None = None
-        ) -> None: ...
-
-class Function:
-    module: str
-    name: str
-    file: int
-    lineno: int
-
-    if sys.version_info >= (3, 10):
-        end_lineno: int | None
-        is_async: bool
+        def __init__(self, module: str, name: str, file: str, lineno: int, parent: Function | Class | None = None) -> None: ...
 
-    parent: Function | Class | None
+class Class(_Object):
+    super: list[Class | str] | None
+    methods: dict[str, int]
+    parent: Class | None
     children: dict[str, Class | Function]
 
     if sys.version_info >= (3, 10):
@@ -52,15 +58,17 @@ class Function:
             self,
             module: str,
             name: str,
+            super_: list[Class | str] | None,
             file: str,
             lineno: int,
-            parent: Function | Class | None = None,
-            is_async: bool = False,
+            parent: Class | None = None,
             *,
             end_lineno: int | None = None,
         ) -> None: ...
     else:
-        def __init__(self, module: str, name: str, file: str, lineno: int, parent: Function | Class | None = None) -> None: ...
+        def __init__(
+            self, module: str, name: str, super: list[Class | str] | None, file: str, lineno: int, parent: Class | None = None
+        ) -> None: ...
 
 def readmodule(module: str, path: Sequence[str] | None = None) -> dict[str, Class]: ...
 def readmodule_ex(module: str, path: Sequence[str] | None = None) -> dict[str, Class | Function | list[str]]: ...
diff --git a/mypy/typeshed/stdlib/pydoc.pyi b/mypy/typeshed/stdlib/pydoc.pyi
index ed97f1918e01..144f782acad5 100644
--- a/mypy/typeshed/stdlib/pydoc.pyi
+++ b/mypy/typeshed/stdlib/pydoc.pyi
@@ -1,12 +1,12 @@
 import sys
-from _typeshed import OptExcInfo, SupportsWrite
+from _typeshed import OptExcInfo, SupportsWrite, Unused
 from abc import abstractmethod
 from builtins import list as _list  # "list" conflicts with method name
 from collections.abc import Callable, Container, Mapping, MutableMapping
 from reprlib import Repr
 from types import MethodType, ModuleType, TracebackType
-from typing import IO, Any, AnyStr, NoReturn, TypeVar
-from typing_extensions import Final, TypeGuard
+from typing import IO, Any, AnyStr, Final, NoReturn, Protocol, TypeVar
+from typing_extensions import TypeGuard
 
 __all__ = ["help"]
 
@@ -17,6 +17,9 @@ __date__: Final[str]
 __version__: Final[str]
 __credits__: Final[str]
 
+class _Pager(Protocol):
+    def __call__(self, text: str, title: str = "") -> None: ...
+
 def pathdirs() -> list[str]: ...
 def getdoc(object: object) -> str: ...
 def splitdoc(doc: AnyStr) -> tuple[AnyStr, AnyStr]: ...
@@ -61,6 +64,7 @@ class Doc:
     def getdocloc(self, object: object, basedir: str = ...) -> str | None: ...
 
 class HTMLRepr(Repr):
+    def __init__(self) -> None: ...
     def escape(self, text: str) -> str: ...
     def repr(self, object: object) -> str: ...
     def repr1(self, x: object, level: complex) -> str: ...
@@ -120,7 +124,7 @@ class HTMLDoc(Doc):
     def formattree(
         self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None
     ) -> str: ...
-    def docmodule(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Any) -> str: ...
+    def docmodule(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Unused) -> str: ...
     def docclass(
         self,
         object: object,
@@ -128,26 +132,49 @@ class HTMLDoc(Doc):
         mod: str | None = None,
         funcs: Mapping[str, str] = {},
         classes: Mapping[str, str] = {},
-        *ignored: Any,
+        *ignored: Unused,
     ) -> str: ...
     def formatvalue(self, object: object) -> str: ...
-    def docroutine(  # type: ignore[override]
-        self,
-        object: object,
-        name: str | None = None,
-        mod: str | None = None,
-        funcs: Mapping[str, str] = {},
-        classes: Mapping[str, str] = {},
-        methods: Mapping[str, str] = {},
-        cl: type | None = None,
-    ) -> str: ...
-    def docproperty(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docother(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Any) -> str: ...
-    def docdata(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    def docother(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Unused) -> str: ...
+    if sys.version_info >= (3, 11):
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            funcs: Mapping[str, str] = {},
+            classes: Mapping[str, str] = {},
+            methods: Mapping[str, str] = {},
+            cl: type | None = None,
+            homecls: type | None = None,
+        ) -> str: ...
+        def docproperty(
+            self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docdata(
+            self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+    else:
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            funcs: Mapping[str, str] = {},
+            classes: Mapping[str, str] = {},
+            methods: Mapping[str, str] = {},
+            cl: type | None = None,
+        ) -> str: ...
+        def docproperty(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docdata(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    if sys.version_info >= (3, 11):
+        def parentlink(self, object: type | ModuleType, modname: str) -> str: ...
+
     def index(self, dir: str, shadowed: MutableMapping[str, bool] | None = None) -> str: ...
     def filelink(self, url: str, path: str) -> str: ...
 
 class TextRepr(Repr):
+    def __init__(self) -> None: ...
     def repr1(self, x: object, level: complex) -> str: ...
     def repr_string(self, x: str, level: complex) -> str: ...
     def repr_str(self, x: str, level: complex) -> str: ...
@@ -162,32 +189,79 @@ class TextDoc(Doc):
     def formattree(
         self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None, prefix: str = ""
     ) -> str: ...
-    def docmodule(self, object: object, name: str | None = None, mod: Any | None = None) -> str: ...  # type: ignore[override]
-    def docclass(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Any) -> str: ...
+    def docclass(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Unused) -> str: ...
     def formatvalue(self, object: object) -> str: ...
-    def docroutine(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docproperty(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docdata(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docother(  # type: ignore[override]
-        self,
-        object: object,
-        name: str | None = None,
-        mod: str | None = None,
-        parent: str | None = None,
-        maxlen: int | None = None,
-        doc: Any | None = None,
-    ) -> str: ...
+    if sys.version_info >= (3, 11):
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            cl: Any | None = None,
+            homecls: Any | None = None,
+        ) -> str: ...
+        def docmodule(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Unused) -> str: ...
+        def docproperty(
+            self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docdata(
+            self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docother(
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            parent: str | None = None,
+            *ignored: Unused,
+            maxlen: int | None = None,
+            doc: Any | None = None,
+        ) -> str: ...
+    else:
+        def docroutine(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docmodule(self, object: object, name: str | None = None, mod: Any | None = None) -> str: ...  # type: ignore[override]
+        def docproperty(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docdata(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docother(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            parent: str | None = None,
+            maxlen: int | None = None,
+            doc: Any | None = None,
+        ) -> str: ...
+
+if sys.version_info >= (3, 13):
+    def pager(text: str, title: str = "") -> None: ...
+
+else:
+    def pager(text: str) -> None: ...
 
-def pager(text: str) -> None: ...
-def getpager() -> Callable[[str], None]: ...
 def plain(text: str) -> str: ...
-def pipepager(text: str, cmd: str) -> None: ...
-def tempfilepager(text: str, cmd: str) -> None: ...
-def ttypager(text: str) -> None: ...
-def plainpager(text: str) -> None: ...
 def describe(thing: Any) -> str: ...
 def locate(path: str, forceload: bool = ...) -> object: ...
 
+if sys.version_info >= (3, 13):
+    def get_pager() -> _Pager: ...
+    def pipe_pager(text: str, cmd: str, title: str = "") -> None: ...
+    def tempfile_pager(text: str, cmd: str, title: str = "") -> None: ...
+    def tty_pager(text: str, title: str = "") -> None: ...
+    def plain_pager(text: str, title: str = "") -> None: ...
+
+    # For backwards compatibility.
+    getpager = get_pager
+    pipepager = pipe_pager
+    tempfilepager = tempfile_pager
+    ttypager = tty_pager
+    plainpager = plain_pager
+else:
+    def getpager() -> Callable[[str], None]: ...
+    def pipepager(text: str, cmd: str) -> None: ...
+    def tempfilepager(text: str, cmd: str) -> None: ...
+    def ttypager(text: str) -> None: ...
+    def plainpager(text: str) -> None: ...
+
 text: TextDoc
 html: HTMLDoc
 
@@ -195,12 +269,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, 11):
+    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 +302,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, 11):
+        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/pyexpat/__init__.pyi b/mypy/typeshed/stdlib/pyexpat/__init__.pyi
index 9e1eea08be54..21e676052098 100644
--- a/mypy/typeshed/stdlib/pyexpat/__init__.pyi
+++ b/mypy/typeshed/stdlib/pyexpat/__init__.pyi
@@ -1,37 +1,34 @@
 from _typeshed import ReadableBuffer, SupportsRead
 from collections.abc import Callable
 from pyexpat import errors as errors, model as model
-from typing import Any
-from typing_extensions import TypeAlias, final
+from typing import Any, Final, final
+from typing_extensions import CapsuleType, TypeAlias
+from xml.parsers.expat import ExpatError as ExpatError
 
-EXPAT_VERSION: str  # undocumented
+EXPAT_VERSION: Final[str]  # undocumented
 version_info: tuple[int, int, int]  # undocumented
 native_encoding: str  # undocumented
 features: list[tuple[str, int]]  # undocumented
 
-class ExpatError(Exception):
-    code: int
-    lineno: int
-    offset: int
-
 error = ExpatError
-
-XML_PARAM_ENTITY_PARSING_NEVER: int
-XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: int
-XML_PARAM_ENTITY_PARSING_ALWAYS: int
+XML_PARAM_ENTITY_PARSING_NEVER: Final = 0
+XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: Final = 1
+XML_PARAM_ENTITY_PARSING_ALWAYS: Final = 2
 
 _Model: TypeAlias = tuple[int, int, str | None, tuple[Any, ...]]
 
 @final
 class XMLParserType:
-    def Parse(self, __data: str | ReadableBuffer, __isfinal: bool = False) -> int: ...
-    def ParseFile(self, __file: SupportsRead[bytes]) -> int: ...
-    def SetBase(self, __base: str) -> None: ...
+    def Parse(self, data: str | ReadableBuffer, isfinal: bool = False, /) -> int: ...
+    def ParseFile(self, file: SupportsRead[bytes], /) -> int: ...
+    def SetBase(self, base: str, /) -> None: ...
     def GetBase(self) -> str | None: ...
     def GetInputContext(self) -> bytes | None: ...
-    def ExternalEntityParserCreate(self, __context: str | None, __encoding: str = ...) -> XMLParserType: ...
-    def SetParamEntityParsing(self, __flag: int) -> int: ...
-    def UseForeignDTD(self, __flag: bool = True) -> None: ...
+    def ExternalEntityParserCreate(self, context: str | None, encoding: str = ..., /) -> XMLParserType: ...
+    def SetParamEntityParsing(self, flag: int, /) -> int: ...
+    def UseForeignDTD(self, flag: bool = True, /) -> None: ...
+    def GetReparseDeferralEnabled(self) -> bool: ...
+    def SetReparseDeferralEnabled(self, enabled: bool, /) -> None: ...
     @property
     def intern(self) -> dict[str, str]: ...
     buffer_size: int
@@ -52,9 +49,12 @@ class XMLParserType:
     EndDoctypeDeclHandler: Callable[[], Any] | None
     ElementDeclHandler: Callable[[str, _Model], Any] | None
     AttlistDeclHandler: Callable[[str, str, str, str | None, bool], Any] | None
-    StartElementHandler: Callable[[str, dict[str, str]], Any] | Callable[[str, list[str]], Any] | Callable[
-        [str, dict[str, str], list[str]], Any
-    ] | None
+    StartElementHandler: (
+        Callable[[str, dict[str, str]], Any]
+        | Callable[[str, list[str]], Any]
+        | Callable[[str, dict[str, str], list[str]], Any]
+        | None
+    )
     EndElementHandler: Callable[[str], Any] | None
     ProcessingInstructionHandler: Callable[[str, str], Any] | None
     CharacterDataHandler: Callable[[str], Any] | None
@@ -72,9 +72,11 @@ class XMLParserType:
     ExternalEntityRefHandler: Callable[[str, str | None, str | None, str | None], int] | None
     SkippedEntityHandler: Callable[[str, bool], Any] | None
 
-def ErrorString(__code: int) -> str: ...
+def ErrorString(code: int, /) -> str: ...
 
 # intern is undocumented
 def ParserCreate(
     encoding: str | None = None, namespace_separator: str | None = None, intern: dict[str, Any] | None = None
 ) -> XMLParserType: ...
+
+expat_CAPI: CapsuleType
diff --git a/mypy/typeshed/stdlib/pyexpat/errors.pyi b/mypy/typeshed/stdlib/pyexpat/errors.pyi
index 2e512eb12989..cae4da089161 100644
--- a/mypy/typeshed/stdlib/pyexpat/errors.pyi
+++ b/mypy/typeshed/stdlib/pyexpat/errors.pyi
@@ -1,49 +1,51 @@
 import sys
+from typing import Final
+from typing_extensions import LiteralString
 
 codes: dict[str, int]
 messages: dict[int, str]
 
-XML_ERROR_ABORTED: str
-XML_ERROR_ASYNC_ENTITY: str
-XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: str
-XML_ERROR_BAD_CHAR_REF: str
-XML_ERROR_BINARY_ENTITY_REF: str
-XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: str
-XML_ERROR_DUPLICATE_ATTRIBUTE: str
-XML_ERROR_ENTITY_DECLARED_IN_PE: str
-XML_ERROR_EXTERNAL_ENTITY_HANDLING: str
-XML_ERROR_FEATURE_REQUIRES_XML_DTD: str
-XML_ERROR_FINISHED: str
-XML_ERROR_INCOMPLETE_PE: str
-XML_ERROR_INCORRECT_ENCODING: str
-XML_ERROR_INVALID_TOKEN: str
-XML_ERROR_JUNK_AFTER_DOC_ELEMENT: str
-XML_ERROR_MISPLACED_XML_PI: str
-XML_ERROR_NOT_STANDALONE: str
-XML_ERROR_NOT_SUSPENDED: str
-XML_ERROR_NO_ELEMENTS: str
-XML_ERROR_NO_MEMORY: str
-XML_ERROR_PARAM_ENTITY_REF: str
-XML_ERROR_PARTIAL_CHAR: str
-XML_ERROR_PUBLICID: str
-XML_ERROR_RECURSIVE_ENTITY_REF: str
-XML_ERROR_SUSPENDED: str
-XML_ERROR_SUSPEND_PE: str
-XML_ERROR_SYNTAX: str
-XML_ERROR_TAG_MISMATCH: str
-XML_ERROR_TEXT_DECL: str
-XML_ERROR_UNBOUND_PREFIX: str
-XML_ERROR_UNCLOSED_CDATA_SECTION: str
-XML_ERROR_UNCLOSED_TOKEN: str
-XML_ERROR_UNDECLARING_PREFIX: str
-XML_ERROR_UNDEFINED_ENTITY: str
-XML_ERROR_UNEXPECTED_STATE: str
-XML_ERROR_UNKNOWN_ENCODING: str
-XML_ERROR_XML_DECL: str
+XML_ERROR_ABORTED: Final[LiteralString]
+XML_ERROR_ASYNC_ENTITY: Final[LiteralString]
+XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: Final[LiteralString]
+XML_ERROR_BAD_CHAR_REF: Final[LiteralString]
+XML_ERROR_BINARY_ENTITY_REF: Final[LiteralString]
+XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: Final[LiteralString]
+XML_ERROR_DUPLICATE_ATTRIBUTE: Final[LiteralString]
+XML_ERROR_ENTITY_DECLARED_IN_PE: Final[LiteralString]
+XML_ERROR_EXTERNAL_ENTITY_HANDLING: Final[LiteralString]
+XML_ERROR_FEATURE_REQUIRES_XML_DTD: Final[LiteralString]
+XML_ERROR_FINISHED: Final[LiteralString]
+XML_ERROR_INCOMPLETE_PE: Final[LiteralString]
+XML_ERROR_INCORRECT_ENCODING: Final[LiteralString]
+XML_ERROR_INVALID_TOKEN: Final[LiteralString]
+XML_ERROR_JUNK_AFTER_DOC_ELEMENT: Final[LiteralString]
+XML_ERROR_MISPLACED_XML_PI: Final[LiteralString]
+XML_ERROR_NOT_STANDALONE: Final[LiteralString]
+XML_ERROR_NOT_SUSPENDED: Final[LiteralString]
+XML_ERROR_NO_ELEMENTS: Final[LiteralString]
+XML_ERROR_NO_MEMORY: Final[LiteralString]
+XML_ERROR_PARAM_ENTITY_REF: Final[LiteralString]
+XML_ERROR_PARTIAL_CHAR: Final[LiteralString]
+XML_ERROR_PUBLICID: Final[LiteralString]
+XML_ERROR_RECURSIVE_ENTITY_REF: Final[LiteralString]
+XML_ERROR_SUSPENDED: Final[LiteralString]
+XML_ERROR_SUSPEND_PE: Final[LiteralString]
+XML_ERROR_SYNTAX: Final[LiteralString]
+XML_ERROR_TAG_MISMATCH: Final[LiteralString]
+XML_ERROR_TEXT_DECL: Final[LiteralString]
+XML_ERROR_UNBOUND_PREFIX: Final[LiteralString]
+XML_ERROR_UNCLOSED_CDATA_SECTION: Final[LiteralString]
+XML_ERROR_UNCLOSED_TOKEN: Final[LiteralString]
+XML_ERROR_UNDECLARING_PREFIX: Final[LiteralString]
+XML_ERROR_UNDEFINED_ENTITY: Final[LiteralString]
+XML_ERROR_UNEXPECTED_STATE: Final[LiteralString]
+XML_ERROR_UNKNOWN_ENCODING: Final[LiteralString]
+XML_ERROR_XML_DECL: Final[LiteralString]
 if sys.version_info >= (3, 11):
-    XML_ERROR_RESERVED_PREFIX_XML: str
-    XML_ERROR_RESERVED_PREFIX_XMLNS: str
-    XML_ERROR_RESERVED_NAMESPACE_URI: str
-    XML_ERROR_INVALID_ARGUMENT: str
-    XML_ERROR_NO_BUFFER: str
-    XML_ERROR_AMPLIFICATION_LIMIT_BREACH: str
+    XML_ERROR_RESERVED_PREFIX_XML: Final[LiteralString]
+    XML_ERROR_RESERVED_PREFIX_XMLNS: Final[LiteralString]
+    XML_ERROR_RESERVED_NAMESPACE_URI: Final[LiteralString]
+    XML_ERROR_INVALID_ARGUMENT: Final[LiteralString]
+    XML_ERROR_NO_BUFFER: Final[LiteralString]
+    XML_ERROR_AMPLIFICATION_LIMIT_BREACH: Final[LiteralString]
diff --git a/mypy/typeshed/stdlib/pyexpat/model.pyi b/mypy/typeshed/stdlib/pyexpat/model.pyi
index f357cf6511a2..bac8f3692ce5 100644
--- a/mypy/typeshed/stdlib/pyexpat/model.pyi
+++ b/mypy/typeshed/stdlib/pyexpat/model.pyi
@@ -1,11 +1,13 @@
-XML_CTYPE_ANY: int
-XML_CTYPE_CHOICE: int
-XML_CTYPE_EMPTY: int
-XML_CTYPE_MIXED: int
-XML_CTYPE_NAME: int
-XML_CTYPE_SEQ: int
+from typing import Final
 
-XML_CQUANT_NONE: int
-XML_CQUANT_OPT: int
-XML_CQUANT_PLUS: int
-XML_CQUANT_REP: int
+XML_CTYPE_ANY: Final = 2
+XML_CTYPE_EMPTY: Final = 1
+XML_CTYPE_MIXED: Final = 3
+XML_CTYPE_NAME: Final = 4
+XML_CTYPE_CHOICE: Final = 5
+XML_CTYPE_SEQ: Final = 6
+
+XML_CQUANT_NONE: Final = 0
+XML_CQUANT_OPT: Final = 1
+XML_CQUANT_REP: Final = 2
+XML_CQUANT_PLUS: Final = 3
diff --git a/mypy/typeshed/stdlib/queue.pyi b/mypy/typeshed/stdlib/queue.pyi
index 3537e445ed97..4fb49cb6102b 100644
--- a/mypy/typeshed/stdlib/queue.pyi
+++ b/mypy/typeshed/stdlib/queue.pyi
@@ -1,4 +1,5 @@
 import sys
+from _queue import Empty as Empty, SimpleQueue as SimpleQueue
 from threading import Condition, Lock
 from typing import Any, Generic, TypeVar
 
@@ -6,12 +7,16 @@ if sys.version_info >= (3, 9):
     from types import GenericAlias
 
 __all__ = ["Empty", "Full", "Queue", "PriorityQueue", "LifoQueue", "SimpleQueue"]
+if sys.version_info >= (3, 13):
+    __all__ += ["ShutDown"]
 
 _T = TypeVar("_T")
 
-class Empty(Exception): ...
 class Full(Exception): ...
 
+if sys.version_info >= (3, 13):
+    class ShutDown(Exception): ...
+
 class Queue(Generic[_T]):
     maxsize: int
 
@@ -20,6 +25,8 @@ class Queue(Generic[_T]):
     not_full: Condition  # undocumented
     all_tasks_done: Condition  # undocumented
     unfinished_tasks: int  # undocumented
+    if sys.version_info >= (3, 13):
+        is_shutdown: bool  # undocumented
     # Despite the fact that `queue` has `deque` type,
     # we treat it as `Any` to allow different implementations in subtypes.
     queue: Any  # undocumented
@@ -29,6 +36,9 @@ class Queue(Generic[_T]):
     def full(self) -> bool: ...
     def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
     def get_nowait(self) -> _T: ...
+    if sys.version_info >= (3, 13):
+        def shutdown(self, immediate: bool = False) -> None: ...
+
     def _get(self) -> _T: ...
     def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
     def put_nowait(self, item: _T) -> None: ...
@@ -38,21 +48,10 @@ class Queue(Generic[_T]):
     def _qsize(self) -> int: ...
     def task_done(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class PriorityQueue(Queue[_T]):
     queue: list[_T]
 
 class LifoQueue(Queue[_T]):
     queue: list[_T]
-
-class SimpleQueue(Generic[_T]):
-    def __init__(self) -> None: ...
-    def empty(self) -> bool: ...
-    def get(self, block: bool = True, timeout: float | None = None) -> _T: ...
-    def get_nowait(self) -> _T: ...
-    def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
-    def put_nowait(self, item: _T) -> None: ...
-    def qsize(self) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
diff --git a/mypy/typeshed/stdlib/random.pyi b/mypy/typeshed/stdlib/random.pyi
index 9fd1c64f2bba..e7320369c377 100644
--- a/mypy/typeshed/stdlib/random.pyi
+++ b/mypy/typeshed/stdlib/random.pyi
@@ -41,7 +41,10 @@ _T = TypeVar("_T")
 
 class Random(_random.Random):
     VERSION: ClassVar[int]
-    def __init__(self, x: Any = None) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __init__(self, x: int | float | str | bytes | bytearray | None = None) -> None: ...  # noqa: Y041
+    else:
+        def __init__(self, x: Any = None) -> None: ...
     # Using other `seed` types is deprecated since 3.9 and removed in 3.11
     # Ignore Y041, since random.seed doesn't treat int like a float subtype. Having an explicit
     # int better documents conventional usage of random.seed.
diff --git a/mypy/typeshed/stdlib/re.pyi b/mypy/typeshed/stdlib/re.pyi
index 4e53141ade84..fccdedae9436 100644
--- a/mypy/typeshed/stdlib/re.pyi
+++ b/mypy/typeshed/stdlib/re.pyi
@@ -1,11 +1,11 @@
 import enum
 import sre_compile
+import sre_constants
 import sys
-from _typeshed import ReadableBuffer
+from _typeshed import MaybeNone, ReadableBuffer
 from collections.abc import Callable, Iterator, Mapping
-from sre_constants import error as error
-from typing import Any, AnyStr, Generic, TypeVar, overload
-from typing_extensions import Literal, TypeAlias, final
+from typing import Any, AnyStr, Final, Generic, Literal, TypeVar, final, overload
+from typing_extensions import TypeAlias
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -21,7 +21,6 @@ __all__ = [
     "finditer",
     "compile",
     "purge",
-    "template",
     "escape",
     "error",
     "A",
@@ -41,12 +40,29 @@ __all__ = [
     "Match",
     "Pattern",
 ]
+if sys.version_info < (3, 13):
+    __all__ += ["template"]
 
 if sys.version_info >= (3, 11):
     __all__ += ["NOFLAG", "RegexFlag"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["PatternError"]
+
+    PatternError = sre_constants.error
+
 _T = TypeVar("_T")
 
+# The implementation defines this in re._constants (version_info >= 3, 11) or
+# sre_constants. Typeshed has it here because its __module__ attribute is set to "re".
+class error(Exception):
+    msg: str
+    pattern: str | bytes | None
+    pos: int | None
+    lineno: int
+    colno: int
+    def __init__(self, msg: str, pattern: str | bytes | None = None, pos: int | None = None) -> None: ...
+
 @final
 class Match(Generic[AnyStr]):
     @property
@@ -67,42 +83,42 @@ class Match(Generic[AnyStr]):
     @overload
     def expand(self: Match[str], template: str) -> str: ...
     @overload
-    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes: ...  # type: ignore[misc]
+    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes: ...
     @overload
     def expand(self, template: AnyStr) -> AnyStr: ...
     # group() returns "AnyStr" or "AnyStr | None", depending on the pattern.
     @overload
-    def group(self, __group: Literal[0] = 0) -> AnyStr: ...
+    def group(self, group: Literal[0] = 0, /) -> AnyStr: ...
     @overload
-    def group(self, __group: str | int) -> AnyStr | Any: ...
+    def group(self, group: str | int, /) -> AnyStr | MaybeNone: ...
     @overload
-    def group(self, __group1: str | int, __group2: str | int, *groups: str | int) -> tuple[AnyStr | Any, ...]: ...
+    def group(self, group1: str | int, group2: str | int, /, *groups: str | int) -> tuple[AnyStr | MaybeNone, ...]: ...
     # Each item of groups()'s return tuple is either "AnyStr" or
     # "AnyStr | None", depending on the pattern.
     @overload
-    def groups(self) -> tuple[AnyStr | Any, ...]: ...
+    def groups(self) -> tuple[AnyStr | MaybeNone, ...]: ...
     @overload
     def groups(self, default: _T) -> tuple[AnyStr | _T, ...]: ...
     # Each value in groupdict()'s return dict is either "AnyStr" or
     # "AnyStr | None", depending on the pattern.
     @overload
-    def groupdict(self) -> dict[str, AnyStr | Any]: ...
+    def groupdict(self) -> dict[str, AnyStr | MaybeNone]: ...
     @overload
     def groupdict(self, default: _T) -> dict[str, AnyStr | _T]: ...
-    def start(self, __group: int | str = 0) -> int: ...
-    def end(self, __group: int | str = 0) -> int: ...
-    def span(self, __group: int | str = 0) -> tuple[int, int]: ...
+    def start(self, group: int | str = 0, /) -> int: ...
+    def end(self, group: int | str = 0, /) -> int: ...
+    def span(self, group: int | str = 0, /) -> tuple[int, int]: ...
     @property
     def regs(self) -> tuple[tuple[int, int], ...]: ...  # undocumented
     # __getitem__() returns "AnyStr" or "AnyStr | None", depending on the pattern.
     @overload
-    def __getitem__(self, __key: Literal[0]) -> AnyStr: ...
+    def __getitem__(self, key: Literal[0], /) -> AnyStr: ...
     @overload
-    def __getitem__(self, __key: int | str) -> AnyStr | Any: ...
+    def __getitem__(self, key: int | str, /) -> AnyStr | MaybeNone: ...
     def __copy__(self) -> Match[AnyStr]: ...
-    def __deepcopy__(self, __memo: Any) -> Match[AnyStr]: ...
+    def __deepcopy__(self, memo: Any, /) -> Match[AnyStr]: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @final
 class Pattern(Generic[AnyStr]):
@@ -117,27 +133,29 @@ class Pattern(Generic[AnyStr]):
     @overload
     def search(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
     @overload
-    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[misc]
+    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...
     @overload
     def search(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
     @overload
     def match(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
     @overload
-    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[misc]
+    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...
     @overload
     def match(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
     @overload
     def fullmatch(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
     @overload
-    def fullmatch(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[misc]
+    def fullmatch(
+        self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize
+    ) -> Match[bytes] | None: ...
     @overload
     def fullmatch(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
     @overload
-    def split(self: Pattern[str], string: str, maxsplit: int = 0) -> list[str | Any]: ...
+    def split(self: Pattern[str], string: str, maxsplit: int = 0) -> list[str | MaybeNone]: ...
     @overload
-    def split(self: Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0) -> list[bytes | Any]: ...
+    def split(self: Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0) -> list[bytes | MaybeNone]: ...
     @overload
-    def split(self, string: AnyStr, maxsplit: int = 0) -> list[AnyStr | Any]: ...
+    def split(self, string: AnyStr, maxsplit: int = 0) -> list[AnyStr | MaybeNone]: ...
     # return type depends on the number of groups in the pattern
     @overload
     def findall(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> list[Any]: ...
@@ -148,13 +166,15 @@ class Pattern(Generic[AnyStr]):
     @overload
     def finditer(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[str]]: ...
     @overload
-    def finditer(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[bytes]]: ...  # type: ignore[misc]
+    def finditer(
+        self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize
+    ) -> Iterator[Match[bytes]]: ...
     @overload
     def finditer(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[AnyStr]]: ...
     @overload
     def sub(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> str: ...
     @overload
-    def sub(  # type: ignore[misc]
+    def sub(
         self: Pattern[bytes],
         repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
         string: ReadableBuffer,
@@ -165,7 +185,7 @@ class Pattern(Generic[AnyStr]):
     @overload
     def subn(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> tuple[str, int]: ...
     @overload
-    def subn(  # type: ignore[misc]
+    def subn(
         self: Pattern[bytes],
         repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
         string: ReadableBuffer,
@@ -174,9 +194,11 @@ class Pattern(Generic[AnyStr]):
     @overload
     def subn(self, repl: AnyStr | Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = 0) -> tuple[AnyStr, int]: ...
     def __copy__(self) -> Pattern[AnyStr]: ...
-    def __deepcopy__(self, __memo: Any) -> Pattern[AnyStr]: ...
+    def __deepcopy__(self, memo: Any, /) -> Pattern[AnyStr]: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # ----- re variables and constants -----
 
@@ -196,29 +218,33 @@ class RegexFlag(enum.IntFlag):
     VERBOSE = X
     U = sre_compile.SRE_FLAG_UNICODE
     UNICODE = U
-    T = sre_compile.SRE_FLAG_TEMPLATE
-    TEMPLATE = T
+    if sys.version_info < (3, 13):
+        T = sre_compile.SRE_FLAG_TEMPLATE
+        TEMPLATE = T
     if sys.version_info >= (3, 11):
-        NOFLAG: int
+        NOFLAG = 0
 
-A = RegexFlag.A
-ASCII = RegexFlag.ASCII
-DEBUG = RegexFlag.DEBUG
-I = RegexFlag.I
-IGNORECASE = RegexFlag.IGNORECASE
-L = RegexFlag.L
-LOCALE = RegexFlag.LOCALE
-M = RegexFlag.M
-MULTILINE = RegexFlag.MULTILINE
-S = RegexFlag.S
-DOTALL = RegexFlag.DOTALL
-X = RegexFlag.X
-VERBOSE = RegexFlag.VERBOSE
-U = RegexFlag.U
-UNICODE = RegexFlag.UNICODE
-T = RegexFlag.T
-TEMPLATE = RegexFlag.TEMPLATE
+A: Final = RegexFlag.A
+ASCII: Final = RegexFlag.ASCII
+DEBUG: Final = RegexFlag.DEBUG
+I: Final = RegexFlag.I
+IGNORECASE: Final = RegexFlag.IGNORECASE
+L: Final = RegexFlag.L
+LOCALE: Final = RegexFlag.LOCALE
+M: Final = RegexFlag.M
+MULTILINE: Final = RegexFlag.MULTILINE
+S: Final = RegexFlag.S
+DOTALL: Final = RegexFlag.DOTALL
+X: Final = RegexFlag.X
+VERBOSE: Final = RegexFlag.VERBOSE
+U: Final = RegexFlag.U
+UNICODE: Final = RegexFlag.UNICODE
+if sys.version_info < (3, 13):
+    T: Final = RegexFlag.T
+    TEMPLATE: Final = RegexFlag.TEMPLATE
 if sys.version_info >= (3, 11):
+    # pytype chokes on `NOFLAG: Final = RegexFlag.NOFLAG` with `LiteralValueError`
+    # mypy chokes on `NOFLAG: Final[Literal[RegexFlag.NOFLAG]]` with `Literal[...] is invalid`
     NOFLAG = RegexFlag.NOFLAG
 _FlagsType: TypeAlias = int | RegexFlag
 
@@ -246,11 +272,11 @@ def fullmatch(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -
 @overload
 def fullmatch(pattern: bytes | Pattern[bytes], string: ReadableBuffer, flags: _FlagsType = 0) -> Match[bytes] | None: ...
 @overload
-def split(pattern: str | Pattern[str], string: str, maxsplit: int = 0, flags: _FlagsType = 0) -> list[str | Any]: ...
+def split(pattern: str | Pattern[str], string: str, maxsplit: int = 0, flags: _FlagsType = 0) -> list[str | MaybeNone]: ...
 @overload
 def split(
     pattern: bytes | Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0, flags: _FlagsType = 0
-) -> list[bytes | Any]: ...
+) -> list[bytes | MaybeNone]: ...
 @overload
 def findall(pattern: str | Pattern[str], string: str, flags: _FlagsType = 0) -> list[Any]: ...
 @overload
@@ -285,4 +311,6 @@ def subn(
 ) -> tuple[bytes, int]: ...
 def escape(pattern: AnyStr) -> AnyStr: ...
 def purge() -> None: ...
-def template(pattern: AnyStr | Pattern[AnyStr], flags: _FlagsType = 0) -> Pattern[AnyStr]: ...
+
+if sys.version_info < (3, 13):
+    def template(pattern: AnyStr | Pattern[AnyStr], flags: _FlagsType = 0) -> Pattern[AnyStr]: ...
diff --git a/mypy/typeshed/stdlib/readline.pyi b/mypy/typeshed/stdlib/readline.pyi
index 14c01a986351..7325c267b32c 100644
--- a/mypy/typeshed/stdlib/readline.pyi
+++ b/mypy/typeshed/stdlib/readline.pyi
@@ -1,36 +1,40 @@
 import sys
 from _typeshed import StrOrBytesPath
 from collections.abc import Callable, Sequence
+from typing import Literal
 from typing_extensions import TypeAlias
 
 if sys.platform != "win32":
     _Completer: TypeAlias = Callable[[str, int], str | None]
     _CompDisp: TypeAlias = Callable[[str, Sequence[str], int], None]
 
-    def parse_and_bind(__string: str) -> None: ...
-    def read_init_file(__filename: StrOrBytesPath | None = None) -> None: ...
+    def parse_and_bind(string: str, /) -> None: ...
+    def read_init_file(filename: StrOrBytesPath | None = None, /) -> None: ...
     def get_line_buffer() -> str: ...
-    def insert_text(__string: str) -> None: ...
+    def insert_text(string: str, /) -> None: ...
     def redisplay() -> None: ...
-    def read_history_file(__filename: StrOrBytesPath | None = None) -> None: ...
-    def write_history_file(__filename: StrOrBytesPath | None = None) -> None: ...
-    def append_history_file(__nelements: int, __filename: StrOrBytesPath | None = None) -> None: ...
+    def read_history_file(filename: StrOrBytesPath | None = None, /) -> None: ...
+    def write_history_file(filename: StrOrBytesPath | None = None, /) -> None: ...
+    def append_history_file(nelements: int, filename: StrOrBytesPath | None = None, /) -> None: ...
     def get_history_length() -> int: ...
-    def set_history_length(__length: int) -> None: ...
+    def set_history_length(length: int, /) -> None: ...
     def clear_history() -> None: ...
     def get_current_history_length() -> int: ...
-    def get_history_item(__index: int) -> str: ...
-    def remove_history_item(__pos: int) -> None: ...
-    def replace_history_item(__pos: int, __line: str) -> None: ...
-    def add_history(__string: str) -> None: ...
-    def set_auto_history(__enabled: bool) -> None: ...
-    def set_startup_hook(__function: Callable[[], object] | None = None) -> None: ...
-    def set_pre_input_hook(__function: Callable[[], object] | None = None) -> None: ...
-    def set_completer(__function: _Completer | None = None) -> None: ...
+    def get_history_item(index: int, /) -> str: ...
+    def remove_history_item(pos: int, /) -> None: ...
+    def replace_history_item(pos: int, line: str, /) -> None: ...
+    def add_history(string: str, /) -> None: ...
+    def set_auto_history(enabled: bool, /) -> None: ...
+    def set_startup_hook(function: Callable[[], object] | None = None, /) -> None: ...
+    def set_pre_input_hook(function: Callable[[], object] | None = None, /) -> None: ...
+    def set_completer(function: _Completer | None = None, /) -> None: ...
     def get_completer() -> _Completer | None: ...
     def get_completion_type() -> int: ...
     def get_begidx() -> int: ...
     def get_endidx() -> int: ...
-    def set_completer_delims(__string: str) -> None: ...
+    def set_completer_delims(string: str, /) -> None: ...
     def get_completer_delims() -> str: ...
-    def set_completion_display_matches_hook(__function: _CompDisp | None = None) -> None: ...
+    def set_completion_display_matches_hook(function: _CompDisp | None = None, /) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        backend: Literal["readline", "editline"]
diff --git a/mypy/typeshed/stdlib/resource.pyi b/mypy/typeshed/stdlib/resource.pyi
index f2e979ff89af..5e468c2cead5 100644
--- a/mypy/typeshed/stdlib/resource.pyi
+++ b/mypy/typeshed/stdlib/resource.pyi
@@ -1,7 +1,6 @@
 import sys
 from _typeshed import structseq
-from typing import overload
-from typing_extensions import Final, final
+from typing import Final, final
 
 if sys.platform != "win32":
     RLIMIT_AS: int
@@ -25,6 +24,7 @@ if sys.platform != "win32":
         RLIMIT_RTTIME: int
         RLIMIT_SIGPENDING: int
         RUSAGE_THREAD: int
+
     @final
     class struct_rusage(
         structseq[float], tuple[float, float, int, int, int, int, int, int, int, int, int, int, int, int, int, int]
@@ -48,6 +48,7 @@ if sys.platform != "win32":
                 "ru_nvcsw",
                 "ru_nivcsw",
             )
+
         @property
         def ru_utime(self) -> float: ...
         @property
@@ -82,12 +83,12 @@ if sys.platform != "win32":
         def ru_nivcsw(self) -> int: ...
 
     def getpagesize() -> int: ...
-    def getrlimit(__resource: int) -> tuple[int, int]: ...
-    def getrusage(__who: int) -> struct_rusage: ...
-    def setrlimit(__resource: int, __limits: tuple[int, int]) -> None: ...
+    def getrlimit(resource: int, /) -> tuple[int, int]: ...
+    def getrusage(who: int, /) -> struct_rusage: ...
+    def setrlimit(resource: int, limits: tuple[int, int], /) -> None: ...
     if sys.platform == "linux":
-        @overload
-        def prlimit(pid: int, resource: int, limits: tuple[int, int]) -> tuple[int, int]: ...
-        @overload
-        def prlimit(pid: int, resource: int) -> tuple[int, int]: ...
+        if sys.version_info >= (3, 12):
+            def prlimit(pid: int, resource: int, limits: tuple[int, int] | None = None, /) -> tuple[int, int]: ...
+        else:
+            def prlimit(pid: int, resource: int, limits: tuple[int, int] = ..., /) -> tuple[int, int]: ...
     error = OSError
diff --git a/mypy/typeshed/stdlib/sched.pyi b/mypy/typeshed/stdlib/sched.pyi
index 75dd63d0414a..52f87ab68ff5 100644
--- a/mypy/typeshed/stdlib/sched.pyi
+++ b/mypy/typeshed/stdlib/sched.pyi
@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Callable
-from typing import Any, NamedTuple
+from typing import Any, ClassVar, NamedTuple, type_check_only
 from typing_extensions import TypeAlias
 
 __all__ = ["scheduler"]
@@ -17,13 +17,17 @@ if sys.version_info >= (3, 10):
         kwargs: dict[str, Any]
 
 else:
-    class Event(NamedTuple):
+    @type_check_only
+    class _EventBase(NamedTuple):
         time: float
         priority: Any
         action: _ActionCallback
         argument: tuple[Any, ...]
         kwargs: dict[str, Any]
 
+    class Event(_EventBase):
+        __hash__: ClassVar[None]  # type: ignore[assignment]
+
 class scheduler:
     timefunc: Callable[[], float]
     delayfunc: Callable[[float], object]
diff --git a/mypy/typeshed/stdlib/select.pyi b/mypy/typeshed/stdlib/select.pyi
index c86d20c352e0..42941b9e41fa 100644
--- a/mypy/typeshed/stdlib/select.pyi
+++ b/mypy/typeshed/stdlib/select.pyi
@@ -2,32 +2,37 @@ import sys
 from _typeshed import FileDescriptorLike
 from collections.abc import Iterable
 from types import TracebackType
-from typing import Any
-from typing_extensions import Self, final
+from typing import Any, ClassVar, final
+from typing_extensions import Self
 
 if sys.platform != "win32":
     PIPE_BUF: int
     POLLERR: int
     POLLHUP: int
     POLLIN: int
-    POLLMSG: int
+    if sys.platform == "linux":
+        POLLMSG: int
     POLLNVAL: int
     POLLOUT: int
     POLLPRI: int
     POLLRDBAND: int
-    POLLRDHUP: int
+    if sys.platform == "linux":
+        POLLRDHUP: int
     POLLRDNORM: int
     POLLWRBAND: int
     POLLWRNORM: int
 
-class poll:
-    def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
-    def modify(self, fd: FileDescriptorLike, eventmask: int) -> None: ...
-    def unregister(self, fd: FileDescriptorLike) -> None: ...
-    def poll(self, timeout: float | None = ...) -> list[tuple[int, int]]: ...
+    # This is actually a function that returns an instance of a class.
+    # The class is not accessible directly, and also calls itself select.poll.
+    class poll:
+        # default value is select.POLLIN | select.POLLPRI | select.POLLOUT
+        def register(self, fd: FileDescriptorLike, eventmask: int = 7, /) -> None: ...
+        def modify(self, fd: FileDescriptorLike, eventmask: int, /) -> None: ...
+        def unregister(self, fd: FileDescriptorLike, /) -> None: ...
+        def poll(self, timeout: float | None = None, /) -> list[tuple[int, int]]: ...
 
 def select(
-    __rlist: Iterable[Any], __wlist: Iterable[Any], __xlist: Iterable[Any], __timeout: float | None = None
+    rlist: Iterable[Any], wlist: Iterable[Any], xlist: Iterable[Any], timeout: float | None = None, /
 ) -> tuple[list[Any], list[Any], list[Any]]: ...
 
 error = OSError
@@ -51,6 +56,8 @@ if sys.platform != "linux" and sys.platform != "win32":
             data: Any = ...,
             udata: Any = ...,
         ) -> None: ...
+        __hash__: ClassVar[None]  # type: ignore[assignment]
+
     # BSD only
     @final
     class kqueue:
@@ -58,11 +65,12 @@ if sys.platform != "linux" and sys.platform != "win32":
         def __init__(self) -> None: ...
         def close(self) -> None: ...
         def control(
-            self, __changelist: Iterable[kevent] | None, __maxevents: int, __timeout: float | None = None
+            self, changelist: Iterable[kevent] | None, maxevents: int, timeout: float | None = None, /
         ) -> list[kevent]: ...
         def fileno(self) -> int: ...
         @classmethod
-        def fromfd(cls, __fd: FileDescriptorLike) -> kqueue: ...
+        def fromfd(cls, fd: FileDescriptorLike, /) -> kqueue: ...
+
     KQ_EV_ADD: int
     KQ_EV_CLEAR: int
     KQ_EV_DELETE: int
@@ -74,7 +82,8 @@ if sys.platform != "linux" and sys.platform != "win32":
     KQ_EV_ONESHOT: int
     KQ_EV_SYSFLAGS: int
     KQ_FILTER_AIO: int
-    KQ_FILTER_NETDEV: int
+    if sys.platform != "darwin":
+        KQ_FILTER_NETDEV: int
     KQ_FILTER_PROC: int
     KQ_FILTER_READ: int
     KQ_FILTER_SIGNAL: int
@@ -109,9 +118,10 @@ if sys.platform == "linux":
         def __enter__(self) -> Self: ...
         def __exit__(
             self,
-            __exc_type: type[BaseException] | None = None,
-            __exc_value: BaseException | None = ...,
-            __exc_tb: TracebackType | None = None,
+            exc_type: type[BaseException] | None = None,
+            exc_value: BaseException | None = ...,
+            exc_tb: TracebackType | None = None,
+            /,
         ) -> None: ...
         def close(self) -> None: ...
         closed: bool
@@ -121,7 +131,8 @@ if sys.platform == "linux":
         def unregister(self, fd: FileDescriptorLike) -> None: ...
         def poll(self, timeout: float | None = None, maxevents: int = -1) -> list[tuple[int, int]]: ...
         @classmethod
-        def fromfd(cls, __fd: FileDescriptorLike) -> epoll: ...
+        def fromfd(cls, fd: FileDescriptorLike, /) -> epoll: ...
+
     EPOLLERR: int
     EPOLLEXCLUSIVE: int
     EPOLLET: int
@@ -136,7 +147,6 @@ if sys.platform == "linux":
     EPOLLRDNORM: int
     EPOLLWRBAND: int
     EPOLLWRNORM: int
-    EPOLL_RDHUP: int
     EPOLL_CLOEXEC: int
 
 if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
diff --git a/mypy/typeshed/stdlib/selectors.pyi b/mypy/typeshed/stdlib/selectors.pyi
index 90a923f09355..0ba843a403d8 100644
--- a/mypy/typeshed/stdlib/selectors.pyi
+++ b/mypy/typeshed/stdlib/selectors.pyi
@@ -31,43 +31,39 @@ class BaseSelector(metaclass=ABCMeta):
     def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
 
-class SelectSelector(BaseSelector):
+class _BaseSelectorImpl(BaseSelector, metaclass=ABCMeta):
     def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = None) -> SelectorKey: ...
     def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
-    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
+    def modify(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = None) -> SelectorKey: ...
     def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
 
+class SelectSelector(_BaseSelectorImpl):
+    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
+
+class _PollLikeSelector(_BaseSelectorImpl):
+    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
+
 if sys.platform != "win32":
-    class PollSelector(BaseSelector):
-        def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = None) -> SelectorKey: ...
-        def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
-        def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
-        def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
+    class PollSelector(_PollLikeSelector): ...
 
 if sys.platform == "linux":
-    class EpollSelector(BaseSelector):
+    class EpollSelector(_PollLikeSelector):
         def fileno(self) -> int: ...
-        def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = None) -> SelectorKey: ...
-        def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
-        def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
-        def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
 
-class DevpollSelector(BaseSelector):
-    def fileno(self) -> int: ...
-    def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ...
-    def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
-    def select(self, timeout: float | None = ...) -> list[tuple[SelectorKey, _EventMask]]: ...
-    def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    # Solaris only
+    class DevpollSelector(_PollLikeSelector):
+        def fileno(self) -> int: ...
 
-class KqueueSelector(BaseSelector):
-    def fileno(self) -> int: ...
-    def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = None) -> SelectorKey: ...
-    def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
-    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
-    def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
+if sys.platform != "win32" and sys.platform != "linux":
+    class KqueueSelector(_BaseSelectorImpl):
+        def fileno(self) -> int: ...
+        def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
 
-class DefaultSelector(BaseSelector):
-    def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = None) -> SelectorKey: ...
-    def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
+# Not a real class at runtime, it is just a conditional alias to other real selectors.
+# The runtime logic is more fine-grained than a `sys.platform` check;
+# not really expressible in the stubs
+class DefaultSelector(_BaseSelectorImpl):
     def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...
-    def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
+    if sys.platform != "win32":
+        def fileno(self) -> int: ...
diff --git a/mypy/typeshed/stdlib/shelve.pyi b/mypy/typeshed/stdlib/shelve.pyi
index 82d0b03f4049..654c2ea097f7 100644
--- a/mypy/typeshed/stdlib/shelve.pyi
+++ b/mypy/typeshed/stdlib/shelve.pyi
@@ -1,3 +1,5 @@
+import sys
+from _typeshed import StrOrBytesPath
 from collections.abc import Iterator, MutableMapping
 from dbm import _TFlags
 from types import TracebackType
@@ -15,8 +17,10 @@ class Shelf(MutableMapping[str, _VT]):
     ) -> None: ...
     def __iter__(self) -> Iterator[str]: ...
     def __len__(self) -> int: ...
+    @overload  # type: ignore[override]
+    def get(self, key: str, default: None = None) -> _VT | None: ...
     @overload
-    def get(self, key: str) -> _VT | None: ...
+    def get(self, key: str, default: _VT) -> _VT: ...
     @overload
     def get(self, key: str, default: _T) -> _VT | _T: ...
     def __getitem__(self, key: str) -> _VT: ...
@@ -27,6 +31,7 @@ class Shelf(MutableMapping[str, _VT]):
     def __exit__(
         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
     ) -> None: ...
+    def __del__(self) -> None: ...
     def close(self) -> None: ...
     def sync(self) -> None: ...
 
@@ -38,6 +43,17 @@ class BsdDbShelf(Shelf[_VT]):
     def last(self) -> tuple[str, _VT]: ...
 
 class DbfilenameShelf(Shelf[_VT]):
-    def __init__(self, filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> None: ...
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self, filename: StrOrBytesPath, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False
+        ) -> None: ...
+    else:
+        def __init__(self, filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> None: ...
 
-def open(filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> Shelf[Any]: ...
+if sys.version_info >= (3, 11):
+    def open(
+        filename: StrOrBytesPath, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False
+    ) -> Shelf[Any]: ...
+
+else:
+    def open(filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> Shelf[Any]: ...
diff --git a/mypy/typeshed/stdlib/shlex.pyi b/mypy/typeshed/stdlib/shlex.pyi
index c4fd23d60666..1c27483782fb 100644
--- a/mypy/typeshed/stdlib/shlex.pyi
+++ b/mypy/typeshed/stdlib/shlex.pyi
@@ -1,21 +1,33 @@
 import sys
+from collections import deque
 from collections.abc import Iterable
-from typing import TextIO
-from typing_extensions import Self
+from io import TextIOWrapper
+from typing import Literal, Protocol, overload, type_check_only
+from typing_extensions import Self, deprecated
 
-if sys.version_info >= (3, 8):
-    __all__ = ["shlex", "split", "quote", "join"]
-else:
-    __all__ = ["shlex", "split", "quote"]
+__all__ = ["shlex", "split", "quote", "join"]
+
+@type_check_only
+class _ShlexInstream(Protocol):
+    def read(self, size: Literal[1], /) -> str: ...
+    def readline(self) -> object: ...
+    def close(self) -> object: ...
 
-def split(s: str, comments: bool = False, posix: bool = True) -> list[str]: ...
+if sys.version_info >= (3, 12):
+    def split(s: str | _ShlexInstream, comments: bool = False, posix: bool = True) -> list[str]: ...
 
-if sys.version_info >= (3, 8):
-    def join(split_command: Iterable[str]) -> str: ...
+else:
+    @overload
+    def split(s: str | _ShlexInstream, comments: bool = False, posix: bool = True) -> list[str]: ...
+    @overload
+    @deprecated("Passing None for 's' to shlex.split() is deprecated and will raise an error in Python 3.12.")
+    def split(s: None, comments: bool = False, posix: bool = True) -> list[str]: ...
 
+def join(split_command: Iterable[str]) -> str: ...
 def quote(s: str) -> str: ...
 
-class shlex(Iterable[str]):
+# TODO: Make generic over infile once PEP 696 is implemented.
+class shlex:
     commenters: str
     wordchars: str
     whitespace: str
@@ -24,17 +36,18 @@ class shlex(Iterable[str]):
     escapedquotes: str
     whitespace_split: bool
     infile: str | None
-    instream: TextIO
+    instream: _ShlexInstream
     source: str
     debug: int
     lineno: int
     token: str
+    filestack: deque[tuple[str | None, _ShlexInstream, int]]
     eof: str | None
     @property
     def punctuation_chars(self) -> str: ...
     def __init__(
         self,
-        instream: str | TextIO | None = None,
+        instream: str | _ShlexInstream | None = None,
         infile: str | None = None,
         posix: bool = False,
         punctuation_chars: bool | str = False,
@@ -42,8 +55,8 @@ class shlex(Iterable[str]):
     def get_token(self) -> str | None: ...
     def push_token(self, tok: str) -> None: ...
     def read_token(self) -> str | None: ...
-    def sourcehook(self, newfile: str) -> tuple[str, TextIO] | None: ...
-    def push_source(self, newstream: str | TextIO, newfile: str | None = None) -> None: ...
+    def sourcehook(self, newfile: str) -> tuple[str, TextIOWrapper] | None: ...
+    def push_source(self, newstream: str | _ShlexInstream, newfile: str | None = None) -> None: ...
     def pop_source(self) -> None: ...
     def error_leader(self, infile: str | None = None, lineno: int | None = None) -> str: ...
     def __iter__(self) -> Self: ...
diff --git a/mypy/typeshed/stdlib/shutil.pyi b/mypy/typeshed/stdlib/shutil.pyi
index ef716d4049dd..0fe560fd9b6a 100644
--- a/mypy/typeshed/stdlib/shutil.pyi
+++ b/mypy/typeshed/stdlib/shutil.pyi
@@ -1,9 +1,10 @@
 import os
 import sys
-from _typeshed import BytesPath, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
+from _typeshed import BytesPath, ExcInfo, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
 from collections.abc import Callable, Iterable, Sequence
-from typing import Any, AnyStr, NamedTuple, Protocol, TypeVar, overload
-from typing_extensions import TypeAlias
+from tarfile import _TarfileFilter
+from typing import Any, AnyStr, NamedTuple, NoReturn, Protocol, TypeVar, overload
+from typing_extensions import TypeAlias, deprecated
 
 __all__ = [
     "copyfileobj",
@@ -35,7 +36,6 @@ __all__ = [
 ]
 
 _StrOrBytesPathT = TypeVar("_StrOrBytesPathT", bound=StrOrBytesPath)
-_StrPathT = TypeVar("_StrPathT", bound=StrPath)
 # Return value of some functions that may either return a path-like object that was passed in or
 # a string
 _PathReturn: TypeAlias = Any
@@ -47,12 +47,7 @@ class ExecError(OSError): ...
 class ReadError(OSError): ...
 class RegistryError(Exception): ...
 
-if sys.version_info >= (3, 8):
-    def copyfileobj(fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr], length: int = 0) -> None: ...
-
-else:
-    def copyfileobj(fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr], length: int = 16384) -> None: ...
-
+def copyfileobj(fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr], length: int = 0) -> None: ...
 def copyfile(src: StrOrBytesPath, dst: _StrOrBytesPathT, *, follow_symlinks: bool = True) -> _StrOrBytesPathT: ...
 def copymode(src: StrOrBytesPath, dst: StrOrBytesPath, *, follow_symlinks: bool = True) -> None: ...
 def copystat(src: StrOrBytesPath, dst: StrOrBytesPath, *, follow_symlinks: bool = True) -> None: ...
@@ -65,41 +60,41 @@ def copy2(src: StrPath, dst: StrPath, *, follow_symlinks: bool = True) -> _PathR
 @overload
 def copy2(src: BytesPath, dst: BytesPath, *, follow_symlinks: bool = True) -> _PathReturn: ...
 def ignore_patterns(*patterns: StrPath) -> Callable[[Any, list[str]], set[str]]: ...
-
-if sys.version_info >= (3, 8):
-    def copytree(
-        src: StrPath,
-        dst: StrPath,
-        symlinks: bool = False,
-        ignore: None | Callable[[str, list[str]], Iterable[str]] | Callable[[StrPath, list[str]], Iterable[str]] = None,
-        copy_function: Callable[[str, str], object] = ...,
-        ignore_dangling_symlinks: bool = False,
-        dirs_exist_ok: bool = False,
-    ) -> _PathReturn: ...
-
-else:
-    def copytree(
-        src: StrPath,
-        dst: StrPath,
-        symlinks: bool = False,
-        ignore: None | Callable[[str, list[str]], Iterable[str]] | Callable[[StrPath, list[str]], Iterable[str]] = None,
-        copy_function: Callable[[str, str], object] = ...,
-        ignore_dangling_symlinks: bool = False,
-    ) -> _PathReturn: ...
-
-_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, Any], object]
-_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, Exception], object]
+def copytree(
+    src: StrPath,
+    dst: StrPath,
+    symlinks: bool = False,
+    ignore: None | Callable[[str, list[str]], Iterable[str]] | Callable[[StrPath, list[str]], Iterable[str]] = None,
+    copy_function: Callable[[str, str], object] = ...,
+    ignore_dangling_symlinks: bool = False,
+    dirs_exist_ok: bool = False,
+) -> _PathReturn: ...
+
+_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, ExcInfo], object]
+_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, BaseException], object]
 
 class _RmtreeType(Protocol):
     avoids_symlink_attacks: bool
     if sys.version_info >= (3, 12):
         @overload
+        @deprecated("The `onerror` parameter is deprecated. Use `onexc` instead.")
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool,
+            onerror: _OnErrorCallback | None,
+            *,
+            onexc: None = None,
+            dir_fd: int | None = None,
+        ) -> None: ...
+        @overload
+        @deprecated("The `onerror` parameter is deprecated. Use `onexc` instead.")
         def __call__(
             self,
             path: StrOrBytesPath,
             ignore_errors: bool = False,
-            onerror: _OnErrorCallback | None = None,
             *,
+            onerror: _OnErrorCallback | None,
             onexc: None = None,
             dir_fd: int | None = None,
         ) -> None: ...
@@ -108,9 +103,8 @@ class _RmtreeType(Protocol):
             self,
             path: StrOrBytesPath,
             ignore_errors: bool = False,
-            onerror: None = None,
             *,
-            onexc: _OnExcCallback,
+            onexc: _OnExcCallback | None = None,
             dir_fd: int | None = None,
         ) -> None: ...
     elif sys.version_info >= (3, 11):
@@ -152,24 +146,53 @@ def disk_usage(path: FileDescriptorOrPath) -> _ntuple_diskusage: ...
 # While chown can be imported on Windows, it doesn't actually work;
 # see https://bugs.python.org/issue33140. We keep it here because it's
 # in __all__.
-@overload
-def chown(path: StrOrBytesPath, user: str | int, group: None = None) -> None: ...
-@overload
-def chown(path: StrOrBytesPath, user: None = None, *, group: str | int) -> None: ...
-@overload
-def chown(path: StrOrBytesPath, user: None, group: str | int) -> None: ...
-@overload
-def chown(path: StrOrBytesPath, user: str | int, group: str | int) -> None: ...
-
-if sys.version_info >= (3, 8):
+if sys.version_info >= (3, 13):
     @overload
-    def which(cmd: _StrPathT, mode: int = 1, path: StrPath | None = None) -> str | _StrPathT | None: ...
+    def chown(
+        path: FileDescriptorOrPath,
+        user: str | int,
+        group: None = None,
+        *,
+        dir_fd: int | None = None,
+        follow_symlinks: bool = True,
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath,
+        user: None = None,
+        *,
+        group: str | int,
+        dir_fd: int | None = None,
+        follow_symlinks: bool = True,
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath, user: None, group: str | int, *, dir_fd: int | None = None, follow_symlinks: bool = True
+    ) -> None: ...
     @overload
-    def which(cmd: bytes, mode: int = 1, path: StrPath | None = None) -> bytes | None: ...
+    def chown(
+        path: FileDescriptorOrPath, user: str | int, group: str | int, *, dir_fd: int | None = None, follow_symlinks: bool = True
+    ) -> None: ...
 
 else:
-    def which(cmd: _StrPathT, mode: int = 1, path: StrPath | None = None) -> str | _StrPathT | None: ...
+    @overload
+    def chown(path: FileDescriptorOrPath, user: str | int, group: None = None) -> None: ...
+    @overload
+    def chown(path: FileDescriptorOrPath, user: None = None, *, group: str | int) -> None: ...
+    @overload
+    def chown(path: FileDescriptorOrPath, user: None, group: str | int) -> None: ...
+    @overload
+    def chown(path: FileDescriptorOrPath, user: str | int, group: str | int) -> None: ...
 
+if sys.platform == "win32" and sys.version_info < (3, 12):
+    @overload
+    @deprecated("On Windows before Python 3.12, using a PathLike as `cmd` would always fail or return `None`.")
+    def which(cmd: os.PathLike[str], mode: int = 1, path: StrPath | None = None) -> NoReturn: ...
+
+@overload
+def which(cmd: StrPath, mode: int = 1, path: StrPath | None = None) -> str | None: ...
+@overload
+def which(cmd: bytes, mode: int = 1, path: StrPath | None = None) -> bytes | None: ...
 def make_archive(
     base_name: str,
     format: str,
@@ -191,15 +214,9 @@ 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: ...
-
-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: ...
-
+def unpack_archive(
+    filename: StrPath, extract_dir: StrPath | None = None, format: str | None = None, *, filter: _TarfileFilter | None = None
+) -> None: ...
 @overload
 def register_unpack_format(
     name: str,
diff --git a/mypy/typeshed/stdlib/signal.pyi b/mypy/typeshed/stdlib/signal.pyi
index 4c961a0c9aab..8fc853b25cc1 100644
--- a/mypy/typeshed/stdlib/signal.pyi
+++ b/mypy/typeshed/stdlib/signal.pyi
@@ -3,117 +3,119 @@ from _typeshed import structseq
 from collections.abc import Callable, Iterable
 from enum import IntEnum
 from types import FrameType
-from typing import Any
-from typing_extensions import Final, Never, TypeAlias, final
+from typing import Any, Final, Literal, final
+from typing_extensions import Never, TypeAlias
 
 NSIG: int
 
 class Signals(IntEnum):
-    SIGABRT: int
-    SIGEMT: int
-    SIGFPE: int
-    SIGILL: int
-    SIGINFO: int
-    SIGINT: int
-    SIGSEGV: int
-    SIGTERM: int
+    SIGABRT = 6
+    SIGFPE = 8
+    SIGILL = 4
+    SIGINT = 2
+    SIGSEGV = 11
+    SIGTERM = 15
 
     if sys.platform == "win32":
-        SIGBREAK: int
-        CTRL_C_EVENT: int
-        CTRL_BREAK_EVENT: int
+        SIGBREAK = 21
+        CTRL_C_EVENT = 0
+        CTRL_BREAK_EVENT = 1
     else:
-        SIGALRM: int
-        SIGBUS: int
-        SIGCHLD: int
-        SIGCONT: int
-        SIGHUP: int
-        SIGIO: int
-        SIGIOT: int
-        SIGKILL: int
-        SIGPIPE: int
-        SIGPROF: int
-        SIGQUIT: int
-        SIGSTOP: int
-        SIGSYS: int
-        SIGTRAP: int
-        SIGTSTP: int
-        SIGTTIN: int
-        SIGTTOU: int
-        SIGURG: int
-        SIGUSR1: int
-        SIGUSR2: int
-        SIGVTALRM: int
-        SIGWINCH: int
-        SIGXCPU: int
-        SIGXFSZ: int
+        SIGALRM = 14
+        SIGBUS = 7
+        SIGCHLD = 17
+        SIGCONT = 18
+        SIGHUP = 1
+        SIGIO = 29
+        SIGIOT = 6
+        SIGKILL = 9
+        SIGPIPE = 13
+        SIGPROF = 27
+        SIGQUIT = 3
+        SIGSTOP = 19
+        SIGSYS = 31
+        SIGTRAP = 5
+        SIGTSTP = 20
+        SIGTTIN = 21
+        SIGTTOU = 22
+        SIGURG = 23
+        SIGUSR1 = 10
+        SIGUSR2 = 12
+        SIGVTALRM = 26
+        SIGWINCH = 28
+        SIGXCPU = 24
+        SIGXFSZ = 25
+        if sys.platform != "linux":
+            SIGEMT = 7
+            SIGINFO = 29
         if sys.platform != "darwin":
-            SIGCLD: int
-            SIGPOLL: int
-            SIGPWR: int
-            SIGRTMAX: int
-            SIGRTMIN: int
+            SIGCLD = 17
+            SIGPOLL = 29
+            SIGPWR = 30
+            SIGRTMAX = 64
+            SIGRTMIN = 34
             if sys.version_info >= (3, 11):
-                SIGSTKFLT: int
+                SIGSTKFLT = 16
 
 class Handlers(IntEnum):
-    SIG_DFL: int
-    SIG_IGN: int
+    SIG_DFL = 0
+    SIG_IGN = 1
 
-SIG_DFL: Handlers
-SIG_IGN: Handlers
+SIG_DFL: Literal[Handlers.SIG_DFL]
+SIG_IGN: Literal[Handlers.SIG_IGN]
 
 _SIGNUM: TypeAlias = int | Signals
 _HANDLER: TypeAlias = Callable[[int, FrameType | None], Any] | int | Handlers | None
 
-def default_int_handler(__signalnum: int, __frame: FrameType | None) -> Never: ...
+def default_int_handler(signalnum: int, frame: FrameType | None, /) -> Never: ...
 
 if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
     def getsignal(signalnum: _SIGNUM) -> _HANDLER: ...
     def signal(signalnum: _SIGNUM, handler: _HANDLER) -> _HANDLER: ...
 
 else:
-    def getsignal(__signalnum: _SIGNUM) -> _HANDLER: ...
-    def signal(__signalnum: _SIGNUM, __handler: _HANDLER) -> _HANDLER: ...
-
-SIGABRT: Signals
-SIGEMT: Signals
-SIGFPE: Signals
-SIGILL: Signals
-SIGINFO: Signals
-SIGINT: Signals
-SIGSEGV: Signals
-SIGTERM: Signals
+    def getsignal(signalnum: _SIGNUM, /) -> _HANDLER: ...
+    def signal(signalnum: _SIGNUM, handler: _HANDLER, /) -> _HANDLER: ...
+
+SIGABRT: Literal[Signals.SIGABRT]
+SIGFPE: Literal[Signals.SIGFPE]
+SIGILL: Literal[Signals.SIGILL]
+SIGINT: Literal[Signals.SIGINT]
+SIGSEGV: Literal[Signals.SIGSEGV]
+SIGTERM: Literal[Signals.SIGTERM]
 
 if sys.platform == "win32":
-    SIGBREAK: Signals
-    CTRL_C_EVENT: Signals
-    CTRL_BREAK_EVENT: Signals
+    SIGBREAK: Literal[Signals.SIGBREAK]
+    CTRL_C_EVENT: Literal[Signals.CTRL_C_EVENT]
+    CTRL_BREAK_EVENT: Literal[Signals.CTRL_BREAK_EVENT]
 else:
-    SIGALRM: Signals
-    SIGBUS: Signals
-    SIGCHLD: Signals
-    SIGCONT: Signals
-    SIGHUP: Signals
-    SIGIO: Signals
-    SIGIOT: Signals
-    SIGKILL: Signals
-    SIGPIPE: Signals
-    SIGPROF: Signals
-    SIGQUIT: Signals
-    SIGSTOP: Signals
-    SIGSYS: Signals
-    SIGTRAP: Signals
-    SIGTSTP: Signals
-    SIGTTIN: Signals
-    SIGTTOU: Signals
-    SIGURG: Signals
-    SIGUSR1: Signals
-    SIGUSR2: Signals
-    SIGVTALRM: Signals
-    SIGWINCH: Signals
-    SIGXCPU: Signals
-    SIGXFSZ: Signals
+    if sys.platform != "linux":
+        SIGINFO: Literal[Signals.SIGINFO]
+        SIGEMT: Literal[Signals.SIGEMT]
+    SIGALRM: Literal[Signals.SIGALRM]
+    SIGBUS: Literal[Signals.SIGBUS]
+    SIGCHLD: Literal[Signals.SIGCHLD]
+    SIGCONT: Literal[Signals.SIGCONT]
+    SIGHUP: Literal[Signals.SIGHUP]
+    SIGIO: Literal[Signals.SIGIO]
+    SIGIOT: Literal[Signals.SIGABRT]  # alias
+    SIGKILL: Literal[Signals.SIGKILL]
+    SIGPIPE: Literal[Signals.SIGPIPE]
+    SIGPROF: Literal[Signals.SIGPROF]
+    SIGQUIT: Literal[Signals.SIGQUIT]
+    SIGSTOP: Literal[Signals.SIGSTOP]
+    SIGSYS: Literal[Signals.SIGSYS]
+    SIGTRAP: Literal[Signals.SIGTRAP]
+    SIGTSTP: Literal[Signals.SIGTSTP]
+    SIGTTIN: Literal[Signals.SIGTTIN]
+    SIGTTOU: Literal[Signals.SIGTTOU]
+    SIGURG: Literal[Signals.SIGURG]
+    SIGUSR1: Literal[Signals.SIGUSR1]
+    SIGUSR2: Literal[Signals.SIGUSR2]
+    SIGVTALRM: Literal[Signals.SIGVTALRM]
+    SIGWINCH: Literal[Signals.SIGWINCH]
+    SIGXCPU: Literal[Signals.SIGXCPU]
+    SIGXFSZ: Literal[Signals.SIGXFSZ]
 
     class ItimerError(OSError): ...
     ITIMER_PROF: int
@@ -121,40 +123,43 @@ else:
     ITIMER_VIRTUAL: int
 
     class Sigmasks(IntEnum):
-        SIG_BLOCK: int
-        SIG_UNBLOCK: int
-        SIG_SETMASK: int
-    SIG_BLOCK = Sigmasks.SIG_BLOCK
-    SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
-    SIG_SETMASK = Sigmasks.SIG_SETMASK
-    def alarm(__seconds: int) -> int: ...
-    def getitimer(__which: int) -> tuple[float, float]: ...
+        SIG_BLOCK = 0
+        SIG_UNBLOCK = 1
+        SIG_SETMASK = 2
+
+    SIG_BLOCK: Literal[Sigmasks.SIG_BLOCK]
+    SIG_UNBLOCK: Literal[Sigmasks.SIG_UNBLOCK]
+    SIG_SETMASK: Literal[Sigmasks.SIG_SETMASK]
+    def alarm(seconds: int, /) -> int: ...
+    def getitimer(which: int, /) -> tuple[float, float]: ...
     def pause() -> None: ...
-    def pthread_kill(__thread_id: int, __signalnum: int) -> None: ...
+    def pthread_kill(thread_id: int, signalnum: int, /) -> None: ...
     if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
         def pthread_sigmask(how: int, mask: Iterable[int]) -> set[_SIGNUM]: ...
     else:
-        def pthread_sigmask(__how: int, __mask: Iterable[int]) -> set[_SIGNUM]: ...
+        def pthread_sigmask(how: int, mask: Iterable[int], /) -> set[_SIGNUM]: ...
 
-    def setitimer(__which: int, __seconds: float, __interval: float = 0.0) -> tuple[float, float]: ...
-    def siginterrupt(__signalnum: int, __flag: bool) -> None: ...
+    def setitimer(which: int, seconds: float, interval: float = 0.0, /) -> tuple[float, float]: ...
+    def siginterrupt(signalnum: int, flag: bool, /) -> None: ...
     def sigpending() -> Any: ...
     if sys.version_info >= (3, 10):  # argument changed in 3.10.2
         def sigwait(sigset: Iterable[int]) -> _SIGNUM: ...
     else:
-        def sigwait(__sigset: Iterable[int]) -> _SIGNUM: ...
+        def sigwait(sigset: Iterable[int], /) -> _SIGNUM: ...
     if sys.platform != "darwin":
-        SIGCLD: Signals
-        SIGPOLL: Signals
-        SIGPWR: Signals
-        SIGRTMAX: Signals
-        SIGRTMIN: Signals
+        SIGCLD: Literal[Signals.SIGCHLD]  # alias
+        SIGPOLL: Literal[Signals.SIGIO]  # alias
+        SIGPWR: Literal[Signals.SIGPWR]
+        SIGRTMAX: Literal[Signals.SIGRTMAX]
+        SIGRTMIN: Literal[Signals.SIGRTMIN]
         if sys.version_info >= (3, 11):
-            SIGSTKFLT: Signals
+            SIGSTKFLT: Literal[Signals.SIGSTKFLT]
+
         @final
         class struct_siginfo(structseq[int], tuple[int, int, int, int, int, int, int]):
             if sys.version_info >= (3, 10):
                 __match_args__: Final = ("si_signo", "si_code", "si_errno", "si_pid", "si_uid", "si_status", "si_band")
+
             @property
             def si_signo(self) -> int: ...
             @property
@@ -170,16 +175,14 @@ else:
             @property
             def si_band(self) -> int: ...
 
-        def sigtimedwait(sigset: Iterable[int], timeout: float) -> struct_siginfo | None: ...
-        def sigwaitinfo(sigset: Iterable[int]) -> struct_siginfo: ...
-
-if sys.version_info >= (3, 8):
-    def strsignal(__signalnum: _SIGNUM) -> str | None: ...
-    def valid_signals() -> set[Signals]: ...
-    def raise_signal(__signalnum: _SIGNUM) -> None: ...
+        def sigtimedwait(sigset: Iterable[int], timeout: float, /) -> struct_siginfo | None: ...
+        def sigwaitinfo(sigset: Iterable[int], /) -> struct_siginfo: ...
 
-def set_wakeup_fd(fd: int, *, warn_on_full_buffer: bool = ...) -> int: ...
+def strsignal(signalnum: _SIGNUM, /) -> str | None: ...
+def valid_signals() -> set[Signals]: ...
+def raise_signal(signalnum: _SIGNUM, /) -> None: ...
+def set_wakeup_fd(fd: int, /, *, warn_on_full_buffer: bool = ...) -> int: ...
 
 if sys.version_info >= (3, 9):
     if sys.platform == "linux":
-        def pidfd_send_signal(__pidfd: int, __sig: int, __siginfo: None = None, __flags: int = ...) -> None: ...
+        def pidfd_send_signal(pidfd: int, sig: int, siginfo: None = None, flags: int = ..., /) -> None: ...
diff --git a/mypy/typeshed/stdlib/site.pyi b/mypy/typeshed/stdlib/site.pyi
index a8c6bcb417f4..6e39677aaea0 100644
--- a/mypy/typeshed/stdlib/site.pyi
+++ b/mypy/typeshed/stdlib/site.pyi
@@ -1,3 +1,4 @@
+import sys
 from _typeshed import StrPath
 from collections.abc import Iterable
 
@@ -13,7 +14,15 @@ def addsitedir(sitedir: str, known_paths: set[str] | None = None) -> None: ...
 def addsitepackages(known_paths: set[str] | None, prefixes: Iterable[str] | None = None) -> set[str] | None: ...  # undocumented
 def addusersitepackages(known_paths: set[str] | None) -> set[str] | None: ...  # undocumented
 def check_enableusersite() -> bool | None: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def gethistoryfile() -> str: ...  # undocumented
+
 def enablerlcompleter() -> None: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def register_readline() -> None: ...  # undocumented
+
 def execsitecustomize() -> None: ...  # undocumented
 def execusercustomize() -> None: ...  # undocumented
 def getsitepackages(prefixes: Iterable[str] | None = None) -> list[str]: ...
diff --git a/mypy/typeshed/stdlib/smtplib.pyi b/mypy/typeshed/stdlib/smtplib.pyi
index 584fa164fec9..a762427bcab3 100644
--- a/mypy/typeshed/stdlib/smtplib.pyi
+++ b/mypy/typeshed/stdlib/smtplib.pyi
@@ -68,9 +68,9 @@ def quotedata(data: str) -> str: ...
 
 class _AuthObject(Protocol):
     @overload
-    def __call__(self, challenge: None = None) -> str | None: ...
+    def __call__(self, challenge: None = None, /) -> str | None: ...
     @overload
-    def __call__(self, challenge: bytes) -> str: ...
+    def __call__(self, challenge: bytes, /) -> str: ...
 
 class SMTP:
     debuglevel: int
@@ -128,7 +128,13 @@ class SMTP:
     def auth_plain(self, challenge: ReadableBuffer | None = None) -> str: ...
     def auth_login(self, challenge: ReadableBuffer | None = None) -> str: ...
     def login(self, user: str, password: str, *, initial_response_ok: bool = True) -> _Reply: ...
-    def starttls(self, keyfile: str | None = None, certfile: str | None = None, context: SSLContext | None = None) -> _Reply: ...
+    if sys.version_info >= (3, 12):
+        def starttls(self, *, context: SSLContext | None = None) -> _Reply: ...
+    else:
+        def starttls(
+            self, keyfile: str | None = None, certfile: str | None = None, context: SSLContext | None = None
+        ) -> _Reply: ...
+
     def sendmail(
         self,
         from_addr: str,
@@ -152,17 +158,29 @@ class SMTP_SSL(SMTP):
     keyfile: str | None
     certfile: str | None
     context: SSLContext
-    def __init__(
-        self,
-        host: str = "",
-        port: int = 0,
-        local_hostname: str | None = None,
-        keyfile: str | None = None,
-        certfile: str | None = None,
-        timeout: float = ...,
-        source_address: _SourceAddress | None = None,
-        context: SSLContext | None = None,
-    ) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            host: str = "",
+            port: int = 0,
+            local_hostname: str | None = None,
+            *,
+            timeout: float = ...,
+            source_address: _SourceAddress | None = None,
+            context: SSLContext | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            host: str = "",
+            port: int = 0,
+            local_hostname: str | None = None,
+            keyfile: str | None = None,
+            certfile: str | None = None,
+            timeout: float = ...,
+            source_address: _SourceAddress | None = None,
+            context: SSLContext | None = None,
+        ) -> None: ...
 
 LMTP_PORT: int
 
diff --git a/mypy/typeshed/stdlib/socket.pyi b/mypy/typeshed/stdlib/socket.pyi
index 6c897b919909..1c996ac32278 100644
--- a/mypy/typeshed/stdlib/socket.pyi
+++ b/mypy/typeshed/stdlib/socket.pyi
@@ -4,7 +4,7 @@
 import _socket
 import sys
 from _socket import (
-    _FD,
+    CAPI as CAPI,
     EAI_AGAIN as EAI_AGAIN,
     EAI_BADFLAGS as EAI_BADFLAGS,
     EAI_FAIL as EAI_FAIL,
@@ -28,14 +28,28 @@ from _socket import (
     IP_MULTICAST_LOOP as IP_MULTICAST_LOOP,
     IP_MULTICAST_TTL as IP_MULTICAST_TTL,
     IP_OPTIONS as IP_OPTIONS,
-    IP_RECVDSTADDR as IP_RECVDSTADDR,
     IP_TOS as IP_TOS,
     IP_TTL as IP_TTL,
     IPPORT_RESERVED as IPPORT_RESERVED,
     IPPORT_USERRESERVED as IPPORT_USERRESERVED,
+    IPPROTO_AH as IPPROTO_AH,
+    IPPROTO_DSTOPTS as IPPROTO_DSTOPTS,
+    IPPROTO_EGP as IPPROTO_EGP,
+    IPPROTO_ESP as IPPROTO_ESP,
+    IPPROTO_FRAGMENT as IPPROTO_FRAGMENT,
+    IPPROTO_HOPOPTS as IPPROTO_HOPOPTS,
     IPPROTO_ICMP as IPPROTO_ICMP,
+    IPPROTO_ICMPV6 as IPPROTO_ICMPV6,
+    IPPROTO_IDP as IPPROTO_IDP,
+    IPPROTO_IGMP as IPPROTO_IGMP,
     IPPROTO_IP as IPPROTO_IP,
+    IPPROTO_IPV6 as IPPROTO_IPV6,
+    IPPROTO_NONE as IPPROTO_NONE,
+    IPPROTO_PIM as IPPROTO_PIM,
+    IPPROTO_PUP as IPPROTO_PUP,
     IPPROTO_RAW as IPPROTO_RAW,
+    IPPROTO_ROUTING as IPPROTO_ROUTING,
+    IPPROTO_SCTP as IPPROTO_SCTP,
     IPPROTO_TCP as IPPROTO_TCP,
     IPPROTO_UDP as IPPROTO_UDP,
     IPV6_CHECKSUM as IPV6_CHECKSUM,
@@ -74,7 +88,6 @@ from _socket import (
     SO_SNDLOWAT as SO_SNDLOWAT,
     SO_SNDTIMEO as SO_SNDTIMEO,
     SO_TYPE as SO_TYPE,
-    SO_USELOOPBACK as SO_USELOOPBACK,
     SOL_IP as SOL_IP,
     SOL_SOCKET as SOL_SOCKET,
     SOL_TCP as SOL_TCP,
@@ -82,14 +95,14 @@ from _socket import (
     SOMAXCONN as SOMAXCONN,
     TCP_FASTOPEN as TCP_FASTOPEN,
     TCP_KEEPCNT as TCP_KEEPCNT,
+    TCP_KEEPINTVL as TCP_KEEPINTVL,
     TCP_MAXSEG as TCP_MAXSEG,
     TCP_NODELAY as TCP_NODELAY,
     SocketType as SocketType,
     _Address as _Address,
     _RetAddress as _RetAddress,
+    close as close,
     dup as dup,
-    error as error,
-    gaierror as gaierror,
     getdefaulttimeout as getdefaulttimeout,
     gethostbyaddr as gethostbyaddr,
     gethostbyname as gethostbyname,
@@ -100,9 +113,11 @@ from _socket import (
     getservbyname as getservbyname,
     getservbyport as getservbyport,
     has_ipv6 as has_ipv6,
-    herror as herror,
     htonl as htonl,
     htons as htons,
+    if_indextoname as if_indextoname,
+    if_nameindex as if_nameindex,
+    if_nametoindex as if_nametoindex,
     inet_aton as inet_aton,
     inet_ntoa as inet_ntoa,
     inet_ntop as inet_ntop,
@@ -110,14 +125,215 @@ from _socket import (
     ntohl as ntohl,
     ntohs as ntohs,
     setdefaulttimeout as setdefaulttimeout,
-    timeout as timeout,
 )
 from _typeshed import ReadableBuffer, Unused, WriteableBuffer
 from collections.abc import Iterable
 from enum import IntEnum, IntFlag
 from io import BufferedReader, BufferedRWPair, BufferedWriter, IOBase, RawIOBase, TextIOWrapper
-from typing import Any, Protocol, overload
-from typing_extensions import Literal, Self
+from typing import Any, Literal, Protocol, SupportsIndex, overload
+from typing_extensions import Self
+
+__all__ = [
+    "fromfd",
+    "getfqdn",
+    "create_connection",
+    "create_server",
+    "has_dualstack_ipv6",
+    "AddressFamily",
+    "SocketKind",
+    "AF_APPLETALK",
+    "AF_DECnet",
+    "AF_INET",
+    "AF_INET6",
+    "AF_IPX",
+    "AF_SNA",
+    "AF_UNSPEC",
+    "AI_ADDRCONFIG",
+    "AI_ALL",
+    "AI_CANONNAME",
+    "AI_NUMERICHOST",
+    "AI_NUMERICSERV",
+    "AI_PASSIVE",
+    "AI_V4MAPPED",
+    "CAPI",
+    "EAI_AGAIN",
+    "EAI_BADFLAGS",
+    "EAI_FAIL",
+    "EAI_FAMILY",
+    "EAI_MEMORY",
+    "EAI_NODATA",
+    "EAI_NONAME",
+    "EAI_SERVICE",
+    "EAI_SOCKTYPE",
+    "INADDR_ALLHOSTS_GROUP",
+    "INADDR_ANY",
+    "INADDR_BROADCAST",
+    "INADDR_LOOPBACK",
+    "INADDR_MAX_LOCAL_GROUP",
+    "INADDR_NONE",
+    "INADDR_UNSPEC_GROUP",
+    "IPPORT_RESERVED",
+    "IPPORT_USERRESERVED",
+    "IPPROTO_AH",
+    "IPPROTO_DSTOPTS",
+    "IPPROTO_EGP",
+    "IPPROTO_ESP",
+    "IPPROTO_FRAGMENT",
+    "IPPROTO_HOPOPTS",
+    "IPPROTO_ICMP",
+    "IPPROTO_ICMPV6",
+    "IPPROTO_IDP",
+    "IPPROTO_IGMP",
+    "IPPROTO_IP",
+    "IPPROTO_IPV6",
+    "IPPROTO_NONE",
+    "IPPROTO_PIM",
+    "IPPROTO_PUP",
+    "IPPROTO_RAW",
+    "IPPROTO_ROUTING",
+    "IPPROTO_SCTP",
+    "IPPROTO_TCP",
+    "IPPROTO_UDP",
+    "IPV6_CHECKSUM",
+    "IPV6_JOIN_GROUP",
+    "IPV6_LEAVE_GROUP",
+    "IPV6_MULTICAST_HOPS",
+    "IPV6_MULTICAST_IF",
+    "IPV6_MULTICAST_LOOP",
+    "IPV6_RECVTCLASS",
+    "IPV6_TCLASS",
+    "IPV6_UNICAST_HOPS",
+    "IPV6_V6ONLY",
+    "IP_ADD_MEMBERSHIP",
+    "IP_DROP_MEMBERSHIP",
+    "IP_HDRINCL",
+    "IP_MULTICAST_IF",
+    "IP_MULTICAST_LOOP",
+    "IP_MULTICAST_TTL",
+    "IP_OPTIONS",
+    "IP_TOS",
+    "IP_TTL",
+    "MSG_CTRUNC",
+    "MSG_DONTROUTE",
+    "MSG_OOB",
+    "MSG_PEEK",
+    "MSG_TRUNC",
+    "MSG_WAITALL",
+    "NI_DGRAM",
+    "NI_MAXHOST",
+    "NI_MAXSERV",
+    "NI_NAMEREQD",
+    "NI_NOFQDN",
+    "NI_NUMERICHOST",
+    "NI_NUMERICSERV",
+    "SHUT_RD",
+    "SHUT_RDWR",
+    "SHUT_WR",
+    "SOCK_DGRAM",
+    "SOCK_RAW",
+    "SOCK_RDM",
+    "SOCK_SEQPACKET",
+    "SOCK_STREAM",
+    "SOL_IP",
+    "SOL_SOCKET",
+    "SOL_TCP",
+    "SOL_UDP",
+    "SOMAXCONN",
+    "SO_ACCEPTCONN",
+    "SO_BROADCAST",
+    "SO_DEBUG",
+    "SO_DONTROUTE",
+    "SO_ERROR",
+    "SO_KEEPALIVE",
+    "SO_LINGER",
+    "SO_OOBINLINE",
+    "SO_RCVBUF",
+    "SO_RCVLOWAT",
+    "SO_RCVTIMEO",
+    "SO_REUSEADDR",
+    "SO_SNDBUF",
+    "SO_SNDLOWAT",
+    "SO_SNDTIMEO",
+    "SO_TYPE",
+    "SocketType",
+    "TCP_FASTOPEN",
+    "TCP_KEEPCNT",
+    "TCP_KEEPINTVL",
+    "TCP_MAXSEG",
+    "TCP_NODELAY",
+    "close",
+    "dup",
+    "error",
+    "gaierror",
+    "getaddrinfo",
+    "getdefaulttimeout",
+    "gethostbyaddr",
+    "gethostbyname",
+    "gethostbyname_ex",
+    "gethostname",
+    "getnameinfo",
+    "getprotobyname",
+    "getservbyname",
+    "getservbyport",
+    "has_ipv6",
+    "herror",
+    "htonl",
+    "htons",
+    "if_indextoname",
+    "if_nameindex",
+    "if_nametoindex",
+    "inet_aton",
+    "inet_ntoa",
+    "inet_ntop",
+    "inet_pton",
+    "ntohl",
+    "ntohs",
+    "setdefaulttimeout",
+    "socket",
+    "socketpair",
+    "timeout",
+]
+
+if sys.platform == "win32":
+    from _socket import (
+        IPPROTO_CBT as IPPROTO_CBT,
+        IPPROTO_ICLFXBM as IPPROTO_ICLFXBM,
+        IPPROTO_IGP as IPPROTO_IGP,
+        IPPROTO_L2TP as IPPROTO_L2TP,
+        IPPROTO_PGM as IPPROTO_PGM,
+        IPPROTO_RDP as IPPROTO_RDP,
+        IPPROTO_ST as IPPROTO_ST,
+        RCVALL_MAX as RCVALL_MAX,
+        RCVALL_OFF as RCVALL_OFF,
+        RCVALL_ON as RCVALL_ON,
+        RCVALL_SOCKETLEVELONLY as RCVALL_SOCKETLEVELONLY,
+        SIO_KEEPALIVE_VALS as SIO_KEEPALIVE_VALS,
+        SIO_LOOPBACK_FAST_PATH as SIO_LOOPBACK_FAST_PATH,
+        SIO_RCVALL as SIO_RCVALL,
+        SO_EXCLUSIVEADDRUSE as SO_EXCLUSIVEADDRUSE,
+    )
+
+    __all__ += [
+        "IPPROTO_CBT",
+        "IPPROTO_ICLFXBM",
+        "IPPROTO_IGP",
+        "IPPROTO_L2TP",
+        "IPPROTO_PGM",
+        "IPPROTO_RDP",
+        "IPPROTO_ST",
+        "RCVALL_MAX",
+        "RCVALL_OFF",
+        "RCVALL_ON",
+        "RCVALL_SOCKETLEVELONLY",
+        "SIO_KEEPALIVE_VALS",
+        "SIO_LOOPBACK_FAST_PATH",
+        "SIO_RCVALL",
+        "SO_EXCLUSIVEADDRUSE",
+        "fromshare",
+        "errorTab",
+        "MSG_BCAST",
+        "MSG_MCAST",
+    ]
 
 if sys.platform != "darwin" or sys.version_info >= (3, 9):
     from _socket import (
@@ -129,89 +345,105 @@ if sys.platform != "darwin" or sys.version_info >= (3, 9):
         IPV6_RTHDR as IPV6_RTHDR,
     )
 
-if sys.platform != "darwin":
-    from _socket import SO_EXCLUSIVEADDRUSE as SO_EXCLUSIVEADDRUSE
+    __all__ += ["IPV6_DONTFRAG", "IPV6_HOPLIMIT", "IPV6_HOPOPTS", "IPV6_PKTINFO", "IPV6_RECVRTHDR", "IPV6_RTHDR"]
 
-if sys.version_info >= (3, 10):
-    from _socket import IP_RECVTOS as IP_RECVTOS
-elif sys.platform != "darwin" and sys.platform != "win32":
-    from _socket import IP_RECVTOS as IP_RECVTOS
+if sys.platform == "darwin":
+    from _socket import PF_SYSTEM as PF_SYSTEM, SYSPROTO_CONTROL as SYSPROTO_CONTROL
 
-from _socket import TCP_KEEPINTVL as TCP_KEEPINTVL, close as close
+    __all__ += ["PF_SYSTEM", "SYSPROTO_CONTROL", "AF_SYSTEM"]
 
 if sys.platform != "darwin":
     from _socket import TCP_KEEPIDLE as TCP_KEEPIDLE
 
-if sys.platform != "win32" or sys.version_info >= (3, 8):
-    from _socket import (
-        IPPROTO_AH as IPPROTO_AH,
-        IPPROTO_DSTOPTS as IPPROTO_DSTOPTS,
-        IPPROTO_EGP as IPPROTO_EGP,
-        IPPROTO_ESP as IPPROTO_ESP,
-        IPPROTO_FRAGMENT as IPPROTO_FRAGMENT,
-        IPPROTO_GGP as IPPROTO_GGP,
-        IPPROTO_HOPOPTS as IPPROTO_HOPOPTS,
-        IPPROTO_ICMPV6 as IPPROTO_ICMPV6,
-        IPPROTO_IDP as IPPROTO_IDP,
-        IPPROTO_IGMP as IPPROTO_IGMP,
-        IPPROTO_IPV4 as IPPROTO_IPV4,
-        IPPROTO_IPV6 as IPPROTO_IPV6,
-        IPPROTO_MAX as IPPROTO_MAX,
-        IPPROTO_ND as IPPROTO_ND,
-        IPPROTO_NONE as IPPROTO_NONE,
-        IPPROTO_PIM as IPPROTO_PIM,
-        IPPROTO_PUP as IPPROTO_PUP,
-        IPPROTO_ROUTING as IPPROTO_ROUTING,
-        IPPROTO_SCTP as IPPROTO_SCTP,
-    )
+    __all__ += ["TCP_KEEPIDLE", "AF_IRDA", "MSG_ERRQUEUE"]
+
+if sys.version_info >= (3, 10):
+    from _socket import IP_RECVTOS as IP_RECVTOS
+
+    __all__ += ["IP_RECVTOS"]
 
-    if sys.platform != "darwin":
-        from _socket import (
-            IPPROTO_CBT as IPPROTO_CBT,
-            IPPROTO_ICLFXBM as IPPROTO_ICLFXBM,
-            IPPROTO_IGP as IPPROTO_IGP,
-            IPPROTO_L2TP as IPPROTO_L2TP,
-            IPPROTO_PGM as IPPROTO_PGM,
-            IPPROTO_RDP as IPPROTO_RDP,
-            IPPROTO_ST as IPPROTO_ST,
-        )
 if sys.platform != "win32" and sys.platform != "darwin":
     from _socket import (
         IP_TRANSPARENT as IP_TRANSPARENT,
-        IPPROTO_BIP as IPPROTO_BIP,
-        IPPROTO_MOBILE as IPPROTO_MOBILE,
-        IPPROTO_VRRP as IPPROTO_VRRP,
         IPX_TYPE as IPX_TYPE,
         SCM_CREDENTIALS as SCM_CREDENTIALS,
-        SO_BINDTODEVICE as SO_BINDTODEVICE,
+        SO_DOMAIN as SO_DOMAIN,
         SO_MARK as SO_MARK,
         SO_PASSCRED as SO_PASSCRED,
+        SO_PASSSEC as SO_PASSSEC,
         SO_PEERCRED as SO_PEERCRED,
+        SO_PEERSEC as SO_PEERSEC,
         SO_PRIORITY as SO_PRIORITY,
-        SO_SETFIB as SO_SETFIB,
+        SO_PROTOCOL as SO_PROTOCOL,
         SOL_ATALK as SOL_ATALK,
         SOL_AX25 as SOL_AX25,
         SOL_HCI as SOL_HCI,
         SOL_IPX as SOL_IPX,
         SOL_NETROM as SOL_NETROM,
         SOL_ROSE as SOL_ROSE,
+        TCP_CONGESTION as TCP_CONGESTION,
         TCP_CORK as TCP_CORK,
         TCP_DEFER_ACCEPT as TCP_DEFER_ACCEPT,
         TCP_INFO as TCP_INFO,
         TCP_LINGER2 as TCP_LINGER2,
         TCP_QUICKACK as TCP_QUICKACK,
         TCP_SYNCNT as TCP_SYNCNT,
+        TCP_USER_TIMEOUT as TCP_USER_TIMEOUT,
         TCP_WINDOW_CLAMP as TCP_WINDOW_CLAMP,
     )
+
+    __all__ += [
+        "IP_TRANSPARENT",
+        "SCM_CREDENTIALS",
+        "SO_DOMAIN",
+        "SO_MARK",
+        "SO_PASSCRED",
+        "SO_PASSSEC",
+        "SO_PEERCRED",
+        "SO_PEERSEC",
+        "SO_PRIORITY",
+        "SO_PROTOCOL",
+        "TCP_CONGESTION",
+        "TCP_CORK",
+        "TCP_DEFER_ACCEPT",
+        "TCP_INFO",
+        "TCP_LINGER2",
+        "TCP_QUICKACK",
+        "TCP_SYNCNT",
+        "TCP_USER_TIMEOUT",
+        "TCP_WINDOW_CLAMP",
+        "AF_ASH",
+        "AF_ATMPVC",
+        "AF_ATMSVC",
+        "AF_AX25",
+        "AF_BRIDGE",
+        "AF_ECONET",
+        "AF_KEY",
+        "AF_LLC",
+        "AF_NETBEUI",
+        "AF_NETROM",
+        "AF_PPPOX",
+        "AF_ROSE",
+        "AF_SECURITY",
+        "AF_WANPIPE",
+        "AF_X25",
+        "MSG_CMSG_CLOEXEC",
+        "MSG_CONFIRM",
+        "MSG_FASTOPEN",
+        "MSG_MORE",
+    ]
+
+if sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 11):
+    from _socket import IP_BIND_ADDRESS_NO_PORT as IP_BIND_ADDRESS_NO_PORT
+
+    __all__ += ["IP_BIND_ADDRESS_NO_PORT"]
+
 if sys.platform != "win32":
     from _socket import (
         CMSG_LEN as CMSG_LEN,
         CMSG_SPACE as CMSG_SPACE,
         EAI_ADDRFAMILY as EAI_ADDRFAMILY,
-        EAI_BADHINTS as EAI_BADHINTS,
-        EAI_MAX as EAI_MAX,
         EAI_OVERFLOW as EAI_OVERFLOW,
-        EAI_PROTOCOL as EAI_PROTOCOL,
         EAI_SYSTEM as EAI_SYSTEM,
         IP_DEFAULT_MULTICAST_LOOP as IP_DEFAULT_MULTICAST_LOOP,
         IP_DEFAULT_MULTICAST_TTL as IP_DEFAULT_MULTICAST_TTL,
@@ -219,22 +451,45 @@ if sys.platform != "win32":
         IP_RECVOPTS as IP_RECVOPTS,
         IP_RECVRETOPTS as IP_RECVRETOPTS,
         IP_RETOPTS as IP_RETOPTS,
-        IPPROTO_EON as IPPROTO_EON,
         IPPROTO_GRE as IPPROTO_GRE,
-        IPPROTO_HELLO as IPPROTO_HELLO,
-        IPPROTO_IPCOMP as IPPROTO_IPCOMP,
         IPPROTO_IPIP as IPPROTO_IPIP,
         IPPROTO_RSVP as IPPROTO_RSVP,
         IPPROTO_TP as IPPROTO_TP,
-        IPPROTO_XTP as IPPROTO_XTP,
         IPV6_RTHDR_TYPE_0 as IPV6_RTHDR_TYPE_0,
-        LOCAL_PEERCRED as LOCAL_PEERCRED,
-        SCM_CREDS as SCM_CREDS,
         SCM_RIGHTS as SCM_RIGHTS,
         SO_REUSEPORT as SO_REUSEPORT,
+        TCP_NOTSENT_LOWAT as TCP_NOTSENT_LOWAT,
         sethostname as sethostname,
     )
 
+    __all__ += [
+        "CMSG_LEN",
+        "CMSG_SPACE",
+        "EAI_ADDRFAMILY",
+        "EAI_OVERFLOW",
+        "EAI_SYSTEM",
+        "IP_DEFAULT_MULTICAST_LOOP",
+        "IP_DEFAULT_MULTICAST_TTL",
+        "IP_MAX_MEMBERSHIPS",
+        "IP_RECVOPTS",
+        "IP_RECVRETOPTS",
+        "IP_RETOPTS",
+        "IPPROTO_GRE",
+        "IPPROTO_IPIP",
+        "IPPROTO_RSVP",
+        "IPPROTO_TP",
+        "IPV6_RTHDR_TYPE_0",
+        "SCM_RIGHTS",
+        "SO_REUSEPORT",
+        "TCP_NOTSENT_LOWAT",
+        "sethostname",
+        "AF_ROUTE",
+        "AF_UNIX",
+        "MSG_DONTWAIT",
+        "MSG_EOR",
+        "MSG_NOSIGNAL",
+    ]
+
     if sys.platform != "darwin" or sys.version_info >= (3, 9):
         from _socket import (
             IPV6_DSTOPTS as IPV6_DSTOPTS,
@@ -246,19 +501,41 @@ if sys.platform != "win32":
             IPV6_RECVPATHMTU as IPV6_RECVPATHMTU,
             IPV6_RECVPKTINFO as IPV6_RECVPKTINFO,
             IPV6_RTHDRDSTOPTS as IPV6_RTHDRDSTOPTS,
-            IPV6_USE_MIN_MTU as IPV6_USE_MIN_MTU,
         )
 
-if sys.platform != "win32" or sys.version_info >= (3, 8):
-    from _socket import if_indextoname as if_indextoname, if_nameindex as if_nameindex, if_nametoindex as if_nametoindex
+        __all__ += [
+            "IPV6_DSTOPTS",
+            "IPV6_NEXTHOP",
+            "IPV6_PATHMTU",
+            "IPV6_RECVDSTOPTS",
+            "IPV6_RECVHOPLIMIT",
+            "IPV6_RECVHOPOPTS",
+            "IPV6_RECVPATHMTU",
+            "IPV6_RECVPKTINFO",
+            "IPV6_RTHDRDSTOPTS",
+        ]
 
-if sys.platform != "darwin":
+    if sys.platform != "darwin":
+        from _socket import SO_BINDTODEVICE as SO_BINDTODEVICE
+
+        __all__ += ["SO_BINDTODEVICE"]
+
+if sys.platform != "darwin" and sys.platform != "linux":
     if sys.platform != "win32" or sys.version_info >= (3, 9):
         from _socket import BDADDR_ANY as BDADDR_ANY, BDADDR_LOCAL as BDADDR_LOCAL, BTPROTO_RFCOMM as BTPROTO_RFCOMM
 
+        __all__ += ["BDADDR_ANY", "BDADDR_LOCAL", "BTPROTO_RFCOMM"]
+
 if sys.platform == "darwin" and sys.version_info >= (3, 10):
     from _socket import TCP_KEEPALIVE as TCP_KEEPALIVE
 
+    __all__ += ["TCP_KEEPALIVE"]
+
+if sys.platform == "darwin" and sys.version_info >= (3, 11):
+    from _socket import TCP_CONNECTION_INFO as TCP_CONNECTION_INFO
+
+    __all__ += ["TCP_CONNECTION_INFO"]
+
 if sys.platform == "linux":
     from _socket import (
         ALG_OP_DECRYPT as ALG_OP_DECRYPT,
@@ -272,15 +549,27 @@ if sys.platform == "linux":
         ALG_SET_OP as ALG_SET_OP,
         ALG_SET_PUBKEY as ALG_SET_PUBKEY,
         CAN_BCM as CAN_BCM,
+        CAN_BCM_CAN_FD_FRAME as CAN_BCM_CAN_FD_FRAME,
+        CAN_BCM_RX_ANNOUNCE_RESUME as CAN_BCM_RX_ANNOUNCE_RESUME,
         CAN_BCM_RX_CHANGED as CAN_BCM_RX_CHANGED,
+        CAN_BCM_RX_CHECK_DLC as CAN_BCM_RX_CHECK_DLC,
         CAN_BCM_RX_DELETE as CAN_BCM_RX_DELETE,
+        CAN_BCM_RX_FILTER_ID as CAN_BCM_RX_FILTER_ID,
+        CAN_BCM_RX_NO_AUTOTIMER as CAN_BCM_RX_NO_AUTOTIMER,
         CAN_BCM_RX_READ as CAN_BCM_RX_READ,
+        CAN_BCM_RX_RTR_FRAME as CAN_BCM_RX_RTR_FRAME,
         CAN_BCM_RX_SETUP as CAN_BCM_RX_SETUP,
         CAN_BCM_RX_STATUS as CAN_BCM_RX_STATUS,
         CAN_BCM_RX_TIMEOUT as CAN_BCM_RX_TIMEOUT,
+        CAN_BCM_SETTIMER as CAN_BCM_SETTIMER,
+        CAN_BCM_STARTTIMER as CAN_BCM_STARTTIMER,
+        CAN_BCM_TX_ANNOUNCE as CAN_BCM_TX_ANNOUNCE,
+        CAN_BCM_TX_COUNTEVT as CAN_BCM_TX_COUNTEVT,
+        CAN_BCM_TX_CP_CAN_ID as CAN_BCM_TX_CP_CAN_ID,
         CAN_BCM_TX_DELETE as CAN_BCM_TX_DELETE,
         CAN_BCM_TX_EXPIRED as CAN_BCM_TX_EXPIRED,
         CAN_BCM_TX_READ as CAN_BCM_TX_READ,
+        CAN_BCM_TX_RESET_MULTI_IDX as CAN_BCM_TX_RESET_MULTI_IDX,
         CAN_BCM_TX_SEND as CAN_BCM_TX_SEND,
         CAN_BCM_TX_SETUP as CAN_BCM_TX_SETUP,
         CAN_BCM_TX_STATUS as CAN_BCM_TX_STATUS,
@@ -288,27 +577,22 @@ if sys.platform == "linux":
         CAN_EFF_MASK as CAN_EFF_MASK,
         CAN_ERR_FLAG as CAN_ERR_FLAG,
         CAN_ERR_MASK as CAN_ERR_MASK,
+        CAN_ISOTP as CAN_ISOTP,
         CAN_RAW as CAN_RAW,
-        CAN_RAW_ERR_FILTER as CAN_RAW_ERR_FILTER,
         CAN_RAW_FD_FRAMES as CAN_RAW_FD_FRAMES,
         CAN_RAW_FILTER as CAN_RAW_FILTER,
         CAN_RAW_LOOPBACK as CAN_RAW_LOOPBACK,
         CAN_RAW_RECV_OWN_MSGS as CAN_RAW_RECV_OWN_MSGS,
         CAN_RTR_FLAG as CAN_RTR_FLAG,
         CAN_SFF_MASK as CAN_SFF_MASK,
-        NETLINK_ARPD as NETLINK_ARPD,
+        IOCTL_VM_SOCKETS_GET_LOCAL_CID as IOCTL_VM_SOCKETS_GET_LOCAL_CID,
         NETLINK_CRYPTO as NETLINK_CRYPTO,
         NETLINK_DNRTMSG as NETLINK_DNRTMSG,
         NETLINK_FIREWALL as NETLINK_FIREWALL,
         NETLINK_IP6_FW as NETLINK_IP6_FW,
         NETLINK_NFLOG as NETLINK_NFLOG,
         NETLINK_ROUTE as NETLINK_ROUTE,
-        NETLINK_ROUTE6 as NETLINK_ROUTE6,
-        NETLINK_SKIP as NETLINK_SKIP,
-        NETLINK_TAPBASE as NETLINK_TAPBASE,
-        NETLINK_TCPDIAG as NETLINK_TCPDIAG,
         NETLINK_USERSOCK as NETLINK_USERSOCK,
-        NETLINK_W1 as NETLINK_W1,
         NETLINK_XFRM as NETLINK_XFRM,
         PACKET_BROADCAST as PACKET_BROADCAST,
         PACKET_FASTROUTE as PACKET_FASTROUTE,
@@ -325,7 +609,6 @@ if sys.platform == "linux":
         RDS_CMSG_RDMA_DEST as RDS_CMSG_RDMA_DEST,
         RDS_CMSG_RDMA_MAP as RDS_CMSG_RDMA_MAP,
         RDS_CMSG_RDMA_STATUS as RDS_CMSG_RDMA_STATUS,
-        RDS_CMSG_RDMA_UPDATE as RDS_CMSG_RDMA_UPDATE,
         RDS_CONG_MONITOR as RDS_CONG_MONITOR,
         RDS_FREE_MR as RDS_FREE_MR,
         RDS_GET_MR as RDS_GET_MR,
@@ -338,6 +621,9 @@ if sys.platform == "linux":
         RDS_RDMA_SILENT as RDS_RDMA_SILENT,
         RDS_RDMA_USE_ONCE as RDS_RDMA_USE_ONCE,
         RDS_RECVERR as RDS_RECVERR,
+        SO_VM_SOCKETS_BUFFER_MAX_SIZE as SO_VM_SOCKETS_BUFFER_MAX_SIZE,
+        SO_VM_SOCKETS_BUFFER_MIN_SIZE as SO_VM_SOCKETS_BUFFER_MIN_SIZE,
+        SO_VM_SOCKETS_BUFFER_SIZE as SO_VM_SOCKETS_BUFFER_SIZE,
         SOL_ALG as SOL_ALG,
         SOL_CAN_BASE as SOL_CAN_BASE,
         SOL_CAN_RAW as SOL_CAN_RAW,
@@ -366,40 +652,136 @@ if sys.platform == "linux":
         TIPC_WAIT_FOREVER as TIPC_WAIT_FOREVER,
         TIPC_WITHDRAWN as TIPC_WITHDRAWN,
         TIPC_ZONE_SCOPE as TIPC_ZONE_SCOPE,
-    )
-if sys.platform == "linux":
-    from _socket import (
-        CAN_ISOTP as CAN_ISOTP,
-        IOCTL_VM_SOCKETS_GET_LOCAL_CID as IOCTL_VM_SOCKETS_GET_LOCAL_CID,
-        SO_VM_SOCKETS_BUFFER_MAX_SIZE as SO_VM_SOCKETS_BUFFER_MAX_SIZE,
-        SO_VM_SOCKETS_BUFFER_MIN_SIZE as SO_VM_SOCKETS_BUFFER_MIN_SIZE,
-        SO_VM_SOCKETS_BUFFER_SIZE as SO_VM_SOCKETS_BUFFER_SIZE,
         VM_SOCKETS_INVALID_VERSION as VM_SOCKETS_INVALID_VERSION,
         VMADDR_CID_ANY as VMADDR_CID_ANY,
         VMADDR_CID_HOST as VMADDR_CID_HOST,
         VMADDR_PORT_ANY as VMADDR_PORT_ANY,
     )
-if sys.platform != "win32":
-    from _socket import TCP_NOTSENT_LOWAT as TCP_NOTSENT_LOWAT
-if sys.platform == "linux" and sys.version_info >= (3, 8):
-    from _socket import (
-        CAN_BCM_CAN_FD_FRAME as CAN_BCM_CAN_FD_FRAME,
-        CAN_BCM_RX_ANNOUNCE_RESUME as CAN_BCM_RX_ANNOUNCE_RESUME,
-        CAN_BCM_RX_CHECK_DLC as CAN_BCM_RX_CHECK_DLC,
-        CAN_BCM_RX_FILTER_ID as CAN_BCM_RX_FILTER_ID,
-        CAN_BCM_RX_NO_AUTOTIMER as CAN_BCM_RX_NO_AUTOTIMER,
-        CAN_BCM_RX_RTR_FRAME as CAN_BCM_RX_RTR_FRAME,
-        CAN_BCM_SETTIMER as CAN_BCM_SETTIMER,
-        CAN_BCM_STARTTIMER as CAN_BCM_STARTTIMER,
-        CAN_BCM_TX_ANNOUNCE as CAN_BCM_TX_ANNOUNCE,
-        CAN_BCM_TX_COUNTEVT as CAN_BCM_TX_COUNTEVT,
-        CAN_BCM_TX_CP_CAN_ID as CAN_BCM_TX_CP_CAN_ID,
-        CAN_BCM_TX_RESET_MULTI_IDX as CAN_BCM_TX_RESET_MULTI_IDX,
-    )
+
+    __all__ += [
+        "ALG_OP_DECRYPT",
+        "ALG_OP_ENCRYPT",
+        "ALG_OP_SIGN",
+        "ALG_OP_VERIFY",
+        "ALG_SET_AEAD_ASSOCLEN",
+        "ALG_SET_AEAD_AUTHSIZE",
+        "ALG_SET_IV",
+        "ALG_SET_KEY",
+        "ALG_SET_OP",
+        "ALG_SET_PUBKEY",
+        "CAN_BCM",
+        "CAN_BCM_CAN_FD_FRAME",
+        "CAN_BCM_RX_ANNOUNCE_RESUME",
+        "CAN_BCM_RX_CHANGED",
+        "CAN_BCM_RX_CHECK_DLC",
+        "CAN_BCM_RX_DELETE",
+        "CAN_BCM_RX_FILTER_ID",
+        "CAN_BCM_RX_NO_AUTOTIMER",
+        "CAN_BCM_RX_READ",
+        "CAN_BCM_RX_RTR_FRAME",
+        "CAN_BCM_RX_SETUP",
+        "CAN_BCM_RX_STATUS",
+        "CAN_BCM_RX_TIMEOUT",
+        "CAN_BCM_SETTIMER",
+        "CAN_BCM_STARTTIMER",
+        "CAN_BCM_TX_ANNOUNCE",
+        "CAN_BCM_TX_COUNTEVT",
+        "CAN_BCM_TX_CP_CAN_ID",
+        "CAN_BCM_TX_DELETE",
+        "CAN_BCM_TX_EXPIRED",
+        "CAN_BCM_TX_READ",
+        "CAN_BCM_TX_RESET_MULTI_IDX",
+        "CAN_BCM_TX_SEND",
+        "CAN_BCM_TX_SETUP",
+        "CAN_BCM_TX_STATUS",
+        "CAN_EFF_FLAG",
+        "CAN_EFF_MASK",
+        "CAN_ERR_FLAG",
+        "CAN_ERR_MASK",
+        "CAN_ISOTP",
+        "CAN_RAW",
+        "CAN_RAW_FD_FRAMES",
+        "CAN_RAW_FILTER",
+        "CAN_RAW_LOOPBACK",
+        "CAN_RAW_RECV_OWN_MSGS",
+        "CAN_RTR_FLAG",
+        "CAN_SFF_MASK",
+        "IOCTL_VM_SOCKETS_GET_LOCAL_CID",
+        "NETLINK_CRYPTO",
+        "NETLINK_DNRTMSG",
+        "NETLINK_FIREWALL",
+        "NETLINK_IP6_FW",
+        "NETLINK_NFLOG",
+        "NETLINK_ROUTE",
+        "NETLINK_USERSOCK",
+        "NETLINK_XFRM",
+        "PACKET_BROADCAST",
+        "PACKET_FASTROUTE",
+        "PACKET_HOST",
+        "PACKET_LOOPBACK",
+        "PACKET_MULTICAST",
+        "PACKET_OTHERHOST",
+        "PACKET_OUTGOING",
+        "PF_CAN",
+        "PF_PACKET",
+        "PF_RDS",
+        "SO_VM_SOCKETS_BUFFER_MAX_SIZE",
+        "SO_VM_SOCKETS_BUFFER_MIN_SIZE",
+        "SO_VM_SOCKETS_BUFFER_SIZE",
+        "SOL_ALG",
+        "SOL_CAN_BASE",
+        "SOL_CAN_RAW",
+        "SOL_RDS",
+        "SOL_TIPC",
+        "TIPC_ADDR_ID",
+        "TIPC_ADDR_NAME",
+        "TIPC_ADDR_NAMESEQ",
+        "TIPC_CFG_SRV",
+        "TIPC_CLUSTER_SCOPE",
+        "TIPC_CONN_TIMEOUT",
+        "TIPC_CRITICAL_IMPORTANCE",
+        "TIPC_DEST_DROPPABLE",
+        "TIPC_HIGH_IMPORTANCE",
+        "TIPC_IMPORTANCE",
+        "TIPC_LOW_IMPORTANCE",
+        "TIPC_MEDIUM_IMPORTANCE",
+        "TIPC_NODE_SCOPE",
+        "TIPC_PUBLISHED",
+        "TIPC_SRC_DROPPABLE",
+        "TIPC_SUB_CANCEL",
+        "TIPC_SUB_PORTS",
+        "TIPC_SUB_SERVICE",
+        "TIPC_SUBSCR_TIMEOUT",
+        "TIPC_TOP_SRV",
+        "TIPC_WAIT_FOREVER",
+        "TIPC_WITHDRAWN",
+        "TIPC_ZONE_SCOPE",
+        "VM_SOCKETS_INVALID_VERSION",
+        "VMADDR_CID_ANY",
+        "VMADDR_CID_HOST",
+        "VMADDR_PORT_ANY",
+        "AF_CAN",
+        "AF_PACKET",
+        "AF_RDS",
+        "AF_TIPC",
+        "AF_ALG",
+        "AF_NETLINK",
+        "AF_VSOCK",
+        "AF_QIPCRTR",
+        "SOCK_CLOEXEC",
+        "SOCK_NONBLOCK",
+    ]
+
+    if sys.version_info < (3, 11):
+        from _socket import CAN_RAW_ERR_FILTER as CAN_RAW_ERR_FILTER
+
+        __all__ += ["CAN_RAW_ERR_FILTER"]
+
 if sys.platform == "linux" and sys.version_info >= (3, 9):
     from _socket import (
         CAN_J1939 as CAN_J1939,
         CAN_RAW_JOIN_FILTERS as CAN_RAW_JOIN_FILTERS,
+        IPPROTO_UDPLITE as IPPROTO_UDPLITE,
         J1939_EE_INFO_NONE as J1939_EE_INFO_NONE,
         J1939_EE_INFO_TX_ABORT as J1939_EE_INFO_TX_ABORT,
         J1939_FILTER_MAX as J1939_FILTER_MAX,
@@ -423,77 +805,300 @@ if sys.platform == "linux" and sys.version_info >= (3, 9):
         SO_J1939_FILTER as SO_J1939_FILTER,
         SO_J1939_PROMISC as SO_J1939_PROMISC,
         SO_J1939_SEND_PRIO as SO_J1939_SEND_PRIO,
+        UDPLITE_RECV_CSCOV as UDPLITE_RECV_CSCOV,
+        UDPLITE_SEND_CSCOV as UDPLITE_SEND_CSCOV,
     )
+
+    __all__ += [
+        "CAN_J1939",
+        "CAN_RAW_JOIN_FILTERS",
+        "IPPROTO_UDPLITE",
+        "J1939_EE_INFO_NONE",
+        "J1939_EE_INFO_TX_ABORT",
+        "J1939_FILTER_MAX",
+        "J1939_IDLE_ADDR",
+        "J1939_MAX_UNICAST_ADDR",
+        "J1939_NLA_BYTES_ACKED",
+        "J1939_NLA_PAD",
+        "J1939_NO_ADDR",
+        "J1939_NO_NAME",
+        "J1939_NO_PGN",
+        "J1939_PGN_ADDRESS_CLAIMED",
+        "J1939_PGN_ADDRESS_COMMANDED",
+        "J1939_PGN_MAX",
+        "J1939_PGN_PDU1_MAX",
+        "J1939_PGN_REQUEST",
+        "SCM_J1939_DEST_ADDR",
+        "SCM_J1939_DEST_NAME",
+        "SCM_J1939_ERRQUEUE",
+        "SCM_J1939_PRIO",
+        "SO_J1939_ERRQUEUE",
+        "SO_J1939_FILTER",
+        "SO_J1939_PROMISC",
+        "SO_J1939_SEND_PRIO",
+        "UDPLITE_RECV_CSCOV",
+        "UDPLITE_SEND_CSCOV",
+    ]
 if sys.platform == "linux" and sys.version_info >= (3, 10):
     from _socket import IPPROTO_MPTCP as IPPROTO_MPTCP
+
+    __all__ += ["IPPROTO_MPTCP"]
 if sys.platform == "linux" and sys.version_info >= (3, 11):
     from _socket import SO_INCOMING_CPU as SO_INCOMING_CPU
-if sys.platform == "win32":
+
+    __all__ += ["SO_INCOMING_CPU"]
+if sys.platform == "linux" and sys.version_info >= (3, 12):
     from _socket import (
-        RCVALL_MAX as RCVALL_MAX,
-        RCVALL_OFF as RCVALL_OFF,
-        RCVALL_ON as RCVALL_ON,
-        RCVALL_SOCKETLEVELONLY as RCVALL_SOCKETLEVELONLY,
-        SIO_KEEPALIVE_VALS as SIO_KEEPALIVE_VALS,
-        SIO_LOOPBACK_FAST_PATH as SIO_LOOPBACK_FAST_PATH,
-        SIO_RCVALL as SIO_RCVALL,
+        TCP_CC_INFO as TCP_CC_INFO,
+        TCP_FASTOPEN_CONNECT as TCP_FASTOPEN_CONNECT,
+        TCP_FASTOPEN_KEY as TCP_FASTOPEN_KEY,
+        TCP_FASTOPEN_NO_COOKIE as TCP_FASTOPEN_NO_COOKIE,
+        TCP_INQ as TCP_INQ,
+        TCP_MD5SIG as TCP_MD5SIG,
+        TCP_MD5SIG_EXT as TCP_MD5SIG_EXT,
+        TCP_QUEUE_SEQ as TCP_QUEUE_SEQ,
+        TCP_REPAIR as TCP_REPAIR,
+        TCP_REPAIR_OPTIONS as TCP_REPAIR_OPTIONS,
+        TCP_REPAIR_QUEUE as TCP_REPAIR_QUEUE,
+        TCP_REPAIR_WINDOW as TCP_REPAIR_WINDOW,
+        TCP_SAVE_SYN as TCP_SAVE_SYN,
+        TCP_SAVED_SYN as TCP_SAVED_SYN,
+        TCP_THIN_DUPACK as TCP_THIN_DUPACK,
+        TCP_THIN_LINEAR_TIMEOUTS as TCP_THIN_LINEAR_TIMEOUTS,
+        TCP_TIMESTAMP as TCP_TIMESTAMP,
+        TCP_TX_DELAY as TCP_TX_DELAY,
+        TCP_ULP as TCP_ULP,
+        TCP_ZEROCOPY_RECEIVE as TCP_ZEROCOPY_RECEIVE,
+    )
+
+    __all__ += [
+        "TCP_CC_INFO",
+        "TCP_FASTOPEN_CONNECT",
+        "TCP_FASTOPEN_KEY",
+        "TCP_FASTOPEN_NO_COOKIE",
+        "TCP_INQ",
+        "TCP_MD5SIG",
+        "TCP_MD5SIG_EXT",
+        "TCP_QUEUE_SEQ",
+        "TCP_REPAIR",
+        "TCP_REPAIR_OPTIONS",
+        "TCP_REPAIR_QUEUE",
+        "TCP_REPAIR_WINDOW",
+        "TCP_SAVED_SYN",
+        "TCP_SAVE_SYN",
+        "TCP_THIN_DUPACK",
+        "TCP_THIN_LINEAR_TIMEOUTS",
+        "TCP_TIMESTAMP",
+        "TCP_TX_DELAY",
+        "TCP_ULP",
+        "TCP_ZEROCOPY_RECEIVE",
+    ]
+
+if sys.platform == "linux" and sys.version_info >= (3, 13):
+    from _socket import NI_IDN as NI_IDN, SO_BINDTOIFINDEX as SO_BINDTOIFINDEX
+
+    __all__ += ["NI_IDN", "SO_BINDTOIFINDEX"]
+
+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,
+    )
+
+    __all__ += ["IP_ADD_SOURCE_MEMBERSHIP", "IP_BLOCK_SOURCE", "IP_DROP_SOURCE_MEMBERSHIP", "IP_PKTINFO", "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,
+        )
+
+        __all__ += [
+            "HV_GUID_BROADCAST",
+            "HV_GUID_CHILDREN",
+            "HV_GUID_LOOPBACK",
+            "HV_GUID_PARENT",
+            "HV_GUID_WILDCARD",
+            "HV_GUID_ZERO",
+            "HV_PROTOCOL_RAW",
+            "HVSOCKET_ADDRESS_FLAG_PASSTHRU",
+            "HVSOCKET_CONNECT_TIMEOUT",
+            "HVSOCKET_CONNECT_TIMEOUT_MAX",
+            "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,
+        )
+
+        __all__ += ["ETHERTYPE_ARP", "ETHERTYPE_IP", "ETHERTYPE_IPV6", "ETHERTYPE_VLAN"]
+
+    if sys.platform == "linux":
+        from _socket import ETH_P_ALL as ETH_P_ALL
+
+        __all__ += ["ETH_P_ALL"]
+
+    if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin":
+        # FreeBSD >= 14.0
+        from _socket import PF_DIVERT as PF_DIVERT
+
+        __all__ += ["PF_DIVERT", "AF_DIVERT"]
+
+if sys.platform != "win32" and sys.version_info >= (3, 9):
+    __all__ += ["send_fds", "recv_fds"]
+
+if sys.platform != "win32" or sys.version_info >= (3, 9):
+    if sys.platform != "linux":
+        __all__ += ["AF_LINK"]
+    if sys.platform != "darwin" and sys.platform != "linux":
+        __all__ += ["AF_BLUETOOTH"]
+
+if sys.platform == "win32" and sys.version_info >= (3, 12):
+    __all__ += ["AF_HYPERV"]
+
+if sys.platform != "win32" and sys.platform != "linux":
+    from _socket import (
+        EAI_BADHINTS as EAI_BADHINTS,
+        EAI_MAX as EAI_MAX,
+        EAI_PROTOCOL as EAI_PROTOCOL,
+        IPPROTO_EON as IPPROTO_EON,
+        IPPROTO_HELLO as IPPROTO_HELLO,
+        IPPROTO_IPCOMP as IPPROTO_IPCOMP,
+        IPPROTO_XTP as IPPROTO_XTP,
+        LOCAL_PEERCRED as LOCAL_PEERCRED,
+        SCM_CREDS as SCM_CREDS,
+    )
+
+    __all__ += [
+        "EAI_BADHINTS",
+        "EAI_MAX",
+        "EAI_PROTOCOL",
+        "IPPROTO_EON",
+        "IPPROTO_HELLO",
+        "IPPROTO_IPCOMP",
+        "IPPROTO_XTP",
+        "LOCAL_PEERCRED",
+        "SCM_CREDS",
+        "AI_DEFAULT",
+        "AI_MASK",
+        "AI_V4MAPPED_CFG",
+        "MSG_EOF",
+    ]
+    if sys.platform != "darwin" or sys.version_info >= (3, 9):
+        from _socket import IPV6_USE_MIN_MTU as IPV6_USE_MIN_MTU
+
+        __all__ += ["IPV6_USE_MIN_MTU"]
+
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+    from _socket import (
+        IPPROTO_BIP as IPPROTO_BIP,
+        IPPROTO_MOBILE as IPPROTO_MOBILE,
+        IPPROTO_VRRP as IPPROTO_VRRP,
+        MSG_BTAG as MSG_BTAG,
+        MSG_ETAG as MSG_ETAG,
+        SO_SETFIB as SO_SETFIB,
+    )
+
+    __all__ += ["SO_SETFIB", "MSG_BTAG", "MSG_ETAG", "IPPROTO_BIP", "IPPROTO_MOBILE", "IPPROTO_VRRP", "MSG_NOTIFICATION"]
+
+if sys.platform != "linux":
+    from _socket import (
+        IP_RECVDSTADDR as IP_RECVDSTADDR,
+        IPPROTO_GGP as IPPROTO_GGP,
+        IPPROTO_IPV4 as IPPROTO_IPV4,
+        IPPROTO_MAX as IPPROTO_MAX,
+        IPPROTO_ND as IPPROTO_ND,
+        SO_USELOOPBACK as SO_USELOOPBACK,
     )
 
+    __all__ += ["IPPROTO_GGP", "IPPROTO_IPV4", "IPPROTO_MAX", "IPPROTO_ND", "IP_RECVDSTADDR", "SO_USELOOPBACK"]
+
 # Re-exported from errno
 EBADF: int
 EAGAIN: int
 EWOULDBLOCK: int
 
+# These errors are implemented in _socket at runtime
+# but they consider themselves to live in socket so we'll put them here.
+error = OSError
+
+class herror(error): ...
+class gaierror(error): ...
+
+if sys.version_info >= (3, 10):
+    timeout = TimeoutError
+else:
+    class timeout(error): ...
+
 class AddressFamily(IntEnum):
-    AF_INET: int
-    AF_INET6: int
-    AF_APPLETALK: int
-    AF_DECnet: int
-    AF_IPX: int
-    AF_SNA: int
-    AF_UNSPEC: int
+    AF_INET = 2
+    AF_INET6 = 10
+    AF_APPLETALK = 5
+    AF_IPX = 4
+    AF_SNA = 22
+    AF_UNSPEC = 0
     if sys.platform != "darwin":
-        AF_IRDA: int
+        AF_IRDA = 23
     if sys.platform != "win32":
-        AF_ROUTE: int
-        AF_SYSTEM: int
-        AF_UNIX: int
-    if sys.platform != "darwin" and sys.platform != "win32":
-        AF_AAL5: int
-        AF_ASH: int
-        AF_ATMPVC: int
-        AF_ATMSVC: int
-        AF_AX25: int
-        AF_BRIDGE: int
-        AF_ECONET: int
-        AF_KEY: int
-        AF_LLC: int
-        AF_NETBEUI: int
-        AF_NETROM: int
-        AF_PPPOX: int
-        AF_ROSE: int
-        AF_SECURITY: int
-        AF_WANPIPE: int
-        AF_X25: int
+        AF_ROUTE = 16
+        AF_UNIX = 1
+    if sys.platform == "darwin":
+        AF_SYSTEM = 32
+    if sys.platform != "win32" and sys.platform != "darwin":
+        AF_ASH = 18
+        AF_ATMPVC = 8
+        AF_ATMSVC = 20
+        AF_AX25 = 3
+        AF_BRIDGE = 7
+        AF_ECONET = 19
+        AF_KEY = 15
+        AF_LLC = 26
+        AF_NETBEUI = 13
+        AF_NETROM = 6
+        AF_PPPOX = 24
+        AF_ROSE = 11
+        AF_SECURITY = 14
+        AF_WANPIPE = 25
+        AF_X25 = 9
     if sys.platform == "linux":
-        AF_CAN: int
-        AF_PACKET: int
-        AF_RDS: int
-        AF_TIPC: int
-        AF_ALG: int
-        AF_NETLINK: int
-        AF_VSOCK: int
-        if sys.version_info >= (3, 8):
-            AF_QIPCRTR: int
+        AF_CAN = 29
+        AF_PACKET = 17
+        AF_RDS = 21
+        AF_TIPC = 30
+        AF_ALG = 38
+        AF_NETLINK = 16
+        AF_VSOCK = 40
+        AF_QIPCRTR = 42
     if sys.platform != "win32" or sys.version_info >= (3, 9):
-        AF_LINK: int
-        if sys.platform != "darwin":
-            AF_BLUETOOTH: int
+        if sys.platform != "linux":
+            AF_LINK = 33
+        if sys.platform != "darwin" and sys.platform != "linux":
+            AF_BLUETOOTH = 32
+    if sys.platform == "win32" and sys.version_info >= (3, 12):
+        AF_HYPERV = 34
+    if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 12):
+        # FreeBSD >= 14.0
+        AF_DIVERT = 44
 
 AF_INET = AddressFamily.AF_INET
 AF_INET6 = AddressFamily.AF_INET6
 AF_APPLETALK = AddressFamily.AF_APPLETALK
-AF_DECnet = AddressFamily.AF_DECnet
+AF_DECnet: Literal[12]
 AF_IPX = AddressFamily.AF_IPX
 AF_SNA = AddressFamily.AF_SNA
 AF_UNSPEC = AddressFamily.AF_UNSPEC
@@ -503,11 +1108,12 @@ if sys.platform != "darwin":
 
 if sys.platform != "win32":
     AF_ROUTE = AddressFamily.AF_ROUTE
-    AF_SYSTEM = AddressFamily.AF_SYSTEM
     AF_UNIX = AddressFamily.AF_UNIX
 
+if sys.platform == "darwin":
+    AF_SYSTEM = AddressFamily.AF_SYSTEM
+
 if sys.platform != "win32" and sys.platform != "darwin":
-    AF_AAL5 = AddressFamily.AF_AAL5
     AF_ASH = AddressFamily.AF_ASH
     AF_ATMPVC = AddressFamily.AF_ATMPVC
     AF_ATMSVC = AddressFamily.AF_ATMSVC
@@ -532,23 +1138,29 @@ if sys.platform == "linux":
     AF_ALG = AddressFamily.AF_ALG
     AF_NETLINK = AddressFamily.AF_NETLINK
     AF_VSOCK = AddressFamily.AF_VSOCK
-    if sys.version_info >= (3, 8):
-        AF_QIPCRTR = AddressFamily.AF_QIPCRTR
+    AF_QIPCRTR = AddressFamily.AF_QIPCRTR
 
 if sys.platform != "win32" or sys.version_info >= (3, 9):
-    AF_LINK = AddressFamily.AF_LINK
-    if sys.platform != "darwin":
+    if sys.platform != "linux":
+        AF_LINK = AddressFamily.AF_LINK
+    if sys.platform != "darwin" and sys.platform != "linux":
         AF_BLUETOOTH = AddressFamily.AF_BLUETOOTH
 
+if sys.platform == "win32" and sys.version_info >= (3, 12):
+    AF_HYPERV = AddressFamily.AF_HYPERV
+if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 12):
+    # FreeBSD >= 14.0
+    AF_DIVERT = AddressFamily.AF_DIVERT
+
 class SocketKind(IntEnum):
-    SOCK_STREAM: int
-    SOCK_DGRAM: int
-    SOCK_RAW: int
-    SOCK_RDM: int
-    SOCK_SEQPACKET: int
+    SOCK_STREAM = 1
+    SOCK_DGRAM = 2
+    SOCK_RAW = 3
+    SOCK_RDM = 4
+    SOCK_SEQPACKET = 5
     if sys.platform == "linux":
-        SOCK_CLOEXEC: int
-        SOCK_NONBLOCK: int
+        SOCK_CLOEXEC = 524288
+        SOCK_NONBLOCK = 2048
 
 SOCK_STREAM = SocketKind.SOCK_STREAM
 SOCK_DGRAM = SocketKind.SOCK_DGRAM
@@ -560,32 +1172,34 @@ if sys.platform == "linux":
     SOCK_NONBLOCK = SocketKind.SOCK_NONBLOCK
 
 class MsgFlag(IntFlag):
-    MSG_CTRUNC: int
-    MSG_DONTROUTE: int
-    MSG_OOB: int
-    MSG_PEEK: int
-    MSG_TRUNC: int
-    MSG_WAITALL: int
+    MSG_CTRUNC = 8
+    MSG_DONTROUTE = 4
+    MSG_OOB = 1
+    MSG_PEEK = 2
+    MSG_TRUNC = 32
+    MSG_WAITALL = 256
+    if sys.platform == "win32":
+        MSG_BCAST = 1024
+        MSG_MCAST = 2048
 
     if sys.platform != "darwin":
-        MSG_BCAST: int
-        MSG_MCAST: int
-        MSG_ERRQUEUE: int
+        MSG_ERRQUEUE = 8192
 
     if sys.platform != "win32" and sys.platform != "darwin":
-        MSG_BTAG: int
-        MSG_CMSG_CLOEXEC: int
-        MSG_CONFIRM: int
-        MSG_ETAG: int
-        MSG_FASTOPEN: int
-        MSG_MORE: int
-        MSG_NOTIFICATION: int
+        MSG_CMSG_CLOEXEC = 1073741821
+        MSG_CONFIRM = 2048
+        MSG_FASTOPEN = 536870912
+        MSG_MORE = 32768
+
+    if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
+        MSG_NOTIFICATION = 8192
 
     if sys.platform != "win32":
-        MSG_DONTWAIT: int
-        MSG_EOF: int
-        MSG_EOR: int
-        MSG_NOSIGNAL: int  # sometimes this exists on darwin, sometimes not
+        MSG_DONTWAIT = 64
+        MSG_EOR = 128
+        MSG_NOSIGNAL = 16384  # sometimes this exists on darwin, sometimes not
+    if sys.platform != "win32" and sys.platform != "linux":
+        MSG_EOF = 256
 
 MSG_CTRUNC = MsgFlag.MSG_CTRUNC
 MSG_DONTROUTE = MsgFlag.MSG_DONTROUTE
@@ -594,38 +1208,42 @@ MSG_PEEK = MsgFlag.MSG_PEEK
 MSG_TRUNC = MsgFlag.MSG_TRUNC
 MSG_WAITALL = MsgFlag.MSG_WAITALL
 
-if sys.platform != "darwin":
+if sys.platform == "win32":
     MSG_BCAST = MsgFlag.MSG_BCAST
     MSG_MCAST = MsgFlag.MSG_MCAST
+
+if sys.platform != "darwin":
     MSG_ERRQUEUE = MsgFlag.MSG_ERRQUEUE
 
 if sys.platform != "win32":
     MSG_DONTWAIT = MsgFlag.MSG_DONTWAIT
-    MSG_EOF = MsgFlag.MSG_EOF
     MSG_EOR = MsgFlag.MSG_EOR
     MSG_NOSIGNAL = MsgFlag.MSG_NOSIGNAL  # Sometimes this exists on darwin, sometimes not
 
 if sys.platform != "win32" and sys.platform != "darwin":
-    MSG_BTAG = MsgFlag.MSG_BTAG
     MSG_CMSG_CLOEXEC = MsgFlag.MSG_CMSG_CLOEXEC
     MSG_CONFIRM = MsgFlag.MSG_CONFIRM
-    MSG_ETAG = MsgFlag.MSG_ETAG
     MSG_FASTOPEN = MsgFlag.MSG_FASTOPEN
     MSG_MORE = MsgFlag.MSG_MORE
+
+if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     MSG_NOTIFICATION = MsgFlag.MSG_NOTIFICATION
 
+if sys.platform != "win32" and sys.platform != "linux":
+    MSG_EOF = MsgFlag.MSG_EOF
+
 class AddressInfo(IntFlag):
-    AI_ADDRCONFIG: int
-    AI_ALL: int
-    AI_CANONNAME: int
-    AI_NUMERICHOST: int
-    AI_NUMERICSERV: int
-    AI_PASSIVE: int
-    AI_V4MAPPED: int
-    if sys.platform != "win32":
-        AI_DEFAULT: int
-        AI_MASK: int
-        AI_V4MAPPED_CFG: int
+    AI_ADDRCONFIG = 32
+    AI_ALL = 16
+    AI_CANONNAME = 2
+    AI_NUMERICHOST = 4
+    AI_NUMERICSERV = 1024
+    AI_PASSIVE = 1
+    AI_V4MAPPED = 8
+    if sys.platform != "win32" and sys.platform != "linux":
+        AI_DEFAULT = 1536
+        AI_MASK = 5127
+        AI_V4MAPPED_CFG = 512
 
 AI_ADDRCONFIG = AddressInfo.AI_ADDRCONFIG
 AI_ALL = AddressInfo.AI_ALL
@@ -635,7 +1253,7 @@ AI_NUMERICSERV = AddressInfo.AI_NUMERICSERV
 AI_PASSIVE = AddressInfo.AI_PASSIVE
 AI_V4MAPPED = AddressInfo.AI_V4MAPPED
 
-if sys.platform != "win32":
+if sys.platform != "win32" and sys.platform != "linux":
     AI_DEFAULT = AddressInfo.AI_DEFAULT
     AI_MASK = AddressInfo.AI_MASK
     AI_V4MAPPED_CFG = AddressInfo.AI_V4MAPPED_CFG
@@ -644,8 +1262,8 @@ if sys.platform == "win32":
     errorTab: dict[int, str]  # undocumented
 
 class _SendableFile(Protocol):
-    def read(self, __size: int) -> bytes: ...
-    def seek(self, __offset: int) -> object: ...
+    def read(self, size: int, /) -> bytes: ...
+    def seek(self, offset: int, /) -> object: ...
 
     # optional fields:
     #
@@ -659,7 +1277,7 @@ class socket(_socket.socket):
     ) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
-    def dup(self) -> Self: ...  # noqa: F811
+    def dup(self) -> Self: ...
     def accept(self) -> tuple[socket, _RetAddress]: ...
     # Note that the makefile's documented windows-specific behavior is not represented
     # mode strings with duplicates are intentionally excluded
@@ -731,7 +1349,7 @@ class socket(_socket.socket):
     def get_inheritable(self) -> bool: ...
     def set_inheritable(self, inheritable: bool) -> None: ...
 
-def fromfd(fd: _FD, family: AddressFamily | int, type: SocketKind | int, proto: int = 0) -> socket: ...
+def fromfd(fd: SupportsIndex, family: AddressFamily | int, type: SocketKind | int, proto: int = 0) -> socket: ...
 
 if sys.platform != "win32":
     if sys.version_info >= (3, 9):
@@ -765,7 +1383,7 @@ def getfqdn(name: str = "") -> str: ...
 if sys.version_info >= (3, 11):
     def create_connection(
         address: tuple[str | None, int],
-        timeout: float | None = ...,  # noqa: F811
+        timeout: float | None = ...,
         source_address: _Address | None = None,
         *,
         all_errors: bool = False,
@@ -773,21 +1391,15 @@ if sys.version_info >= (3, 11):
 
 else:
     def create_connection(
-        address: tuple[str | None, int], timeout: float | None = ..., source_address: _Address | None = None  # noqa: F811
+        address: tuple[str | None, int], timeout: float | None = ..., source_address: _Address | None = None
     ) -> socket: ...
 
-if sys.version_info >= (3, 8):
-    def has_dualstack_ipv6() -> bool: ...
-    def create_server(
-        address: _Address,
-        *,
-        family: int = ...,
-        backlog: int | None = None,
-        reuse_port: bool = False,
-        dualstack_ipv6: bool = False,
-    ) -> socket: ...
+def has_dualstack_ipv6() -> bool: ...
+def create_server(
+    address: _Address, *, family: int = ..., backlog: int | None = None, reuse_port: bool = False, dualstack_ipv6: bool = False
+) -> socket: ...
 
-# the 5th tuple item is an address
+# The 5th tuple item is the socket address, for IP4, IP6, or IP6 if Python is compiled with --disable-ipv6, respectively.
 def getaddrinfo(
     host: bytes | str | None, port: bytes | str | int | None, family: int = 0, type: int = 0, proto: int = 0, flags: int = 0
-) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
+) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]: ...
diff --git a/mypy/typeshed/stdlib/socketserver.pyi b/mypy/typeshed/stdlib/socketserver.pyi
index 3799d82a0065..061932f0fac7 100644
--- a/mypy/typeshed/stdlib/socketserver.pyi
+++ b/mypy/typeshed/stdlib/socketserver.pyi
@@ -3,8 +3,9 @@ import types
 from _socket import _Address, _RetAddress
 from _typeshed import ReadableBuffer
 from collections.abc import Callable
+from io import BufferedIOBase
 from socket import socket as _socket
-from typing import Any, BinaryIO, ClassVar
+from typing import Any, ClassVar
 from typing_extensions import Self, TypeAlias
 
 __all__ = [
@@ -28,6 +29,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
@@ -35,29 +38,22 @@ _AfInetAddress: TypeAlias = tuple[str | bytes | bytearray, int]  # address accep
 
 # This can possibly be generic at some point:
 class BaseServer:
-    address_family: int
     server_address: _Address
-    socket: _socket
-    allow_reuse_address: bool
-    request_queue_size: int
-    socket_type: int
     timeout: float | None
     RequestHandlerClass: Callable[[Any, _RetAddress, Self], BaseRequestHandler]
     def __init__(
         self, server_address: _Address, RequestHandlerClass: Callable[[Any, _RetAddress, Self], BaseRequestHandler]
     ) -> None: ...
-    def fileno(self) -> int: ...
     def handle_request(self) -> None: ...
     def serve_forever(self, poll_interval: float = 0.5) -> None: ...
     def shutdown(self) -> None: ...
     def server_close(self) -> None: ...
     def finish_request(self, request: _RequestType, client_address: _RetAddress) -> None: ...
-    def get_request(self) -> tuple[Any, Any]: ...
+    def get_request(self) -> tuple[Any, Any]: ...  # Not implemented here, but expected to exist on subclasses
     def handle_error(self, request: _RequestType, client_address: _RetAddress) -> None: ...
     def handle_timeout(self) -> None: ...
     def process_request(self, request: _RequestType, client_address: _RetAddress) -> None: ...
     def server_activate(self) -> None: ...
-    def server_bind(self) -> None: ...
     def verify_request(self, request: _RequestType, client_address: _RetAddress) -> bool: ...
     def __enter__(self) -> Self: ...
     def __exit__(
@@ -68,6 +64,11 @@ class BaseServer:
     def close_request(self, request: _RequestType) -> None: ...  # undocumented
 
 class TCPServer(BaseServer):
+    address_family: int
+    socket: _socket
+    allow_reuse_address: bool
+    request_queue_size: int
+    socket_type: int
     if sys.version_info >= (3, 11):
         allow_reuse_port: bool
     server_address: _AfInetAddress
@@ -77,14 +78,16 @@ class TCPServer(BaseServer):
         RequestHandlerClass: Callable[[Any, _RetAddress, Self], BaseRequestHandler],
         bind_and_activate: bool = True,
     ) -> None: ...
+    def fileno(self) -> int: ...
     def get_request(self) -> tuple[_socket, _RetAddress]: ...
+    def server_bind(self) -> None: ...
 
 class UDPServer(TCPServer):
     max_packet_size: ClassVar[int]
     def get_request(self) -> tuple[tuple[bytes, _socket], _RetAddress]: ...  # type: ignore[override]
 
 if sys.platform != "win32":
-    class UnixStreamServer(BaseServer):
+    class UnixStreamServer(TCPServer):
         server_address: _AfUnixAddress  # type: ignore[assignment]
         def __init__(
             self,
@@ -93,7 +96,7 @@ if sys.platform != "win32":
             bind_and_activate: bool = True,
         ) -> None: ...
 
-    class UnixDatagramServer(BaseServer):
+    class UnixDatagramServer(UDPServer):
         server_address: _AfUnixAddress  # type: ignore[assignment]
         def __init__(
             self,
@@ -124,6 +127,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): ...
@@ -153,11 +159,11 @@ class StreamRequestHandler(BaseRequestHandler):
     timeout: ClassVar[float | None]  # undocumented
     disable_nagle_algorithm: ClassVar[bool]  # undocumented
     connection: Any  # undocumented
-    rfile: BinaryIO
-    wfile: BinaryIO
+    rfile: BufferedIOBase
+    wfile: BufferedIOBase
 
 class DatagramRequestHandler(BaseRequestHandler):
-    packet: _socket  # undocumented
+    packet: bytes  # undocumented
     socket: _socket  # undocumented
-    rfile: BinaryIO
-    wfile: BinaryIO
+    rfile: BufferedIOBase
+    wfile: BufferedIOBase
diff --git a/mypy/typeshed/stdlib/spwd.pyi b/mypy/typeshed/stdlib/spwd.pyi
index 27b1061e1b0e..3a5d39997dcc 100644
--- a/mypy/typeshed/stdlib/spwd.pyi
+++ b/mypy/typeshed/stdlib/spwd.pyi
@@ -1,7 +1,6 @@
 import sys
 from _typeshed import structseq
-from typing import Any
-from typing_extensions import Final, final
+from typing import Any, Final, final
 
 if sys.platform != "win32":
     @final
@@ -18,6 +17,7 @@ if sys.platform != "win32":
                 "sp_expire",
                 "sp_flag",
             )
+
         @property
         def sp_namp(self) -> str: ...
         @property
@@ -36,6 +36,11 @@ if sys.platform != "win32":
         def sp_expire(self) -> int: ...
         @property
         def sp_flag(self) -> int: ...
+        # Deprecated aliases below.
+        @property
+        def sp_nam(self) -> str: ...
+        @property
+        def sp_pwd(self) -> str: ...
 
     def getspall() -> list[struct_spwd]: ...
-    def getspnam(__arg: str) -> struct_spwd: ...
+    def getspnam(arg: str, /) -> struct_spwd: ...
diff --git a/mypy/typeshed/stdlib/sqlite3/__init__.pyi b/mypy/typeshed/stdlib/sqlite3/__init__.pyi
index d747be90fd0a..724bc3166fd0 100644
--- a/mypy/typeshed/stdlib/sqlite3/__init__.pyi
+++ b/mypy/typeshed/stdlib/sqlite3/__init__.pyi
@@ -1 +1,467 @@
-from sqlite3.dbapi2 import *
+import sys
+from _typeshed import MaybeNone, ReadableBuffer, StrOrBytesPath, SupportsLenAndGetItem, Unused
+from collections.abc import Callable, Generator, Iterable, Iterator, Mapping, Sequence
+from sqlite3.dbapi2 import (
+    PARSE_COLNAMES as PARSE_COLNAMES,
+    PARSE_DECLTYPES as PARSE_DECLTYPES,
+    SQLITE_ALTER_TABLE as SQLITE_ALTER_TABLE,
+    SQLITE_ANALYZE as SQLITE_ANALYZE,
+    SQLITE_ATTACH as SQLITE_ATTACH,
+    SQLITE_CREATE_INDEX as SQLITE_CREATE_INDEX,
+    SQLITE_CREATE_TABLE as SQLITE_CREATE_TABLE,
+    SQLITE_CREATE_TEMP_INDEX as SQLITE_CREATE_TEMP_INDEX,
+    SQLITE_CREATE_TEMP_TABLE as SQLITE_CREATE_TEMP_TABLE,
+    SQLITE_CREATE_TEMP_TRIGGER as SQLITE_CREATE_TEMP_TRIGGER,
+    SQLITE_CREATE_TEMP_VIEW as SQLITE_CREATE_TEMP_VIEW,
+    SQLITE_CREATE_TRIGGER as SQLITE_CREATE_TRIGGER,
+    SQLITE_CREATE_VIEW as SQLITE_CREATE_VIEW,
+    SQLITE_CREATE_VTABLE as SQLITE_CREATE_VTABLE,
+    SQLITE_DELETE as SQLITE_DELETE,
+    SQLITE_DENY as SQLITE_DENY,
+    SQLITE_DETACH as SQLITE_DETACH,
+    SQLITE_DONE as SQLITE_DONE,
+    SQLITE_DROP_INDEX as SQLITE_DROP_INDEX,
+    SQLITE_DROP_TABLE as SQLITE_DROP_TABLE,
+    SQLITE_DROP_TEMP_INDEX as SQLITE_DROP_TEMP_INDEX,
+    SQLITE_DROP_TEMP_TABLE as SQLITE_DROP_TEMP_TABLE,
+    SQLITE_DROP_TEMP_TRIGGER as SQLITE_DROP_TEMP_TRIGGER,
+    SQLITE_DROP_TEMP_VIEW as SQLITE_DROP_TEMP_VIEW,
+    SQLITE_DROP_TRIGGER as SQLITE_DROP_TRIGGER,
+    SQLITE_DROP_VIEW as SQLITE_DROP_VIEW,
+    SQLITE_DROP_VTABLE as SQLITE_DROP_VTABLE,
+    SQLITE_FUNCTION as SQLITE_FUNCTION,
+    SQLITE_IGNORE as SQLITE_IGNORE,
+    SQLITE_INSERT as SQLITE_INSERT,
+    SQLITE_OK as SQLITE_OK,
+    SQLITE_PRAGMA as SQLITE_PRAGMA,
+    SQLITE_READ as SQLITE_READ,
+    SQLITE_RECURSIVE as SQLITE_RECURSIVE,
+    SQLITE_REINDEX as SQLITE_REINDEX,
+    SQLITE_SAVEPOINT as SQLITE_SAVEPOINT,
+    SQLITE_SELECT as SQLITE_SELECT,
+    SQLITE_TRANSACTION as SQLITE_TRANSACTION,
+    SQLITE_UPDATE as SQLITE_UPDATE,
+    Binary as Binary,
+    Date as Date,
+    DateFromTicks as DateFromTicks,
+    Time as Time,
+    TimeFromTicks as TimeFromTicks,
+    TimestampFromTicks as TimestampFromTicks,
+    adapt as adapt,
+    adapters as adapters,
+    apilevel as apilevel,
+    complete_statement as complete_statement,
+    connect as connect,
+    converters as converters,
+    enable_callback_tracebacks as enable_callback_tracebacks,
+    paramstyle as paramstyle,
+    register_adapter as register_adapter,
+    register_converter as register_converter,
+    sqlite_version as sqlite_version,
+    sqlite_version_info as sqlite_version_info,
+    threadsafety as threadsafety,
+    version_info as version_info,
+)
+from types import TracebackType
+from typing import Any, Literal, Protocol, SupportsIndex, TypeVar, final, overload, type_check_only
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 12):
+    from sqlite3.dbapi2 import (
+        LEGACY_TRANSACTION_CONTROL as LEGACY_TRANSACTION_CONTROL,
+        SQLITE_DBCONFIG_DEFENSIVE as SQLITE_DBCONFIG_DEFENSIVE,
+        SQLITE_DBCONFIG_DQS_DDL as SQLITE_DBCONFIG_DQS_DDL,
+        SQLITE_DBCONFIG_DQS_DML as SQLITE_DBCONFIG_DQS_DML,
+        SQLITE_DBCONFIG_ENABLE_FKEY as SQLITE_DBCONFIG_ENABLE_FKEY,
+        SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER as SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER,
+        SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION as SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION,
+        SQLITE_DBCONFIG_ENABLE_QPSG as SQLITE_DBCONFIG_ENABLE_QPSG,
+        SQLITE_DBCONFIG_ENABLE_TRIGGER as SQLITE_DBCONFIG_ENABLE_TRIGGER,
+        SQLITE_DBCONFIG_ENABLE_VIEW as SQLITE_DBCONFIG_ENABLE_VIEW,
+        SQLITE_DBCONFIG_LEGACY_ALTER_TABLE as SQLITE_DBCONFIG_LEGACY_ALTER_TABLE,
+        SQLITE_DBCONFIG_LEGACY_FILE_FORMAT as SQLITE_DBCONFIG_LEGACY_FILE_FORMAT,
+        SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE as SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE,
+        SQLITE_DBCONFIG_RESET_DATABASE as SQLITE_DBCONFIG_RESET_DATABASE,
+        SQLITE_DBCONFIG_TRIGGER_EQP as SQLITE_DBCONFIG_TRIGGER_EQP,
+        SQLITE_DBCONFIG_TRUSTED_SCHEMA as SQLITE_DBCONFIG_TRUSTED_SCHEMA,
+        SQLITE_DBCONFIG_WRITABLE_SCHEMA as SQLITE_DBCONFIG_WRITABLE_SCHEMA,
+    )
+
+if sys.version_info >= (3, 11):
+    from sqlite3.dbapi2 import (
+        SQLITE_ABORT as SQLITE_ABORT,
+        SQLITE_ABORT_ROLLBACK as SQLITE_ABORT_ROLLBACK,
+        SQLITE_AUTH as SQLITE_AUTH,
+        SQLITE_AUTH_USER as SQLITE_AUTH_USER,
+        SQLITE_BUSY as SQLITE_BUSY,
+        SQLITE_BUSY_RECOVERY as SQLITE_BUSY_RECOVERY,
+        SQLITE_BUSY_SNAPSHOT as SQLITE_BUSY_SNAPSHOT,
+        SQLITE_BUSY_TIMEOUT as SQLITE_BUSY_TIMEOUT,
+        SQLITE_CANTOPEN as SQLITE_CANTOPEN,
+        SQLITE_CANTOPEN_CONVPATH as SQLITE_CANTOPEN_CONVPATH,
+        SQLITE_CANTOPEN_DIRTYWAL as SQLITE_CANTOPEN_DIRTYWAL,
+        SQLITE_CANTOPEN_FULLPATH as SQLITE_CANTOPEN_FULLPATH,
+        SQLITE_CANTOPEN_ISDIR as SQLITE_CANTOPEN_ISDIR,
+        SQLITE_CANTOPEN_NOTEMPDIR as SQLITE_CANTOPEN_NOTEMPDIR,
+        SQLITE_CANTOPEN_SYMLINK as SQLITE_CANTOPEN_SYMLINK,
+        SQLITE_CONSTRAINT as SQLITE_CONSTRAINT,
+        SQLITE_CONSTRAINT_CHECK as SQLITE_CONSTRAINT_CHECK,
+        SQLITE_CONSTRAINT_COMMITHOOK as SQLITE_CONSTRAINT_COMMITHOOK,
+        SQLITE_CONSTRAINT_FOREIGNKEY as SQLITE_CONSTRAINT_FOREIGNKEY,
+        SQLITE_CONSTRAINT_FUNCTION as SQLITE_CONSTRAINT_FUNCTION,
+        SQLITE_CONSTRAINT_NOTNULL as SQLITE_CONSTRAINT_NOTNULL,
+        SQLITE_CONSTRAINT_PINNED as SQLITE_CONSTRAINT_PINNED,
+        SQLITE_CONSTRAINT_PRIMARYKEY as SQLITE_CONSTRAINT_PRIMARYKEY,
+        SQLITE_CONSTRAINT_ROWID as SQLITE_CONSTRAINT_ROWID,
+        SQLITE_CONSTRAINT_TRIGGER as SQLITE_CONSTRAINT_TRIGGER,
+        SQLITE_CONSTRAINT_UNIQUE as SQLITE_CONSTRAINT_UNIQUE,
+        SQLITE_CONSTRAINT_VTAB as SQLITE_CONSTRAINT_VTAB,
+        SQLITE_CORRUPT as SQLITE_CORRUPT,
+        SQLITE_CORRUPT_INDEX as SQLITE_CORRUPT_INDEX,
+        SQLITE_CORRUPT_SEQUENCE as SQLITE_CORRUPT_SEQUENCE,
+        SQLITE_CORRUPT_VTAB as SQLITE_CORRUPT_VTAB,
+        SQLITE_EMPTY as SQLITE_EMPTY,
+        SQLITE_ERROR as SQLITE_ERROR,
+        SQLITE_ERROR_MISSING_COLLSEQ as SQLITE_ERROR_MISSING_COLLSEQ,
+        SQLITE_ERROR_RETRY as SQLITE_ERROR_RETRY,
+        SQLITE_ERROR_SNAPSHOT as SQLITE_ERROR_SNAPSHOT,
+        SQLITE_FORMAT as SQLITE_FORMAT,
+        SQLITE_FULL as SQLITE_FULL,
+        SQLITE_INTERNAL as SQLITE_INTERNAL,
+        SQLITE_INTERRUPT as SQLITE_INTERRUPT,
+        SQLITE_IOERR as SQLITE_IOERR,
+        SQLITE_IOERR_ACCESS as SQLITE_IOERR_ACCESS,
+        SQLITE_IOERR_AUTH as SQLITE_IOERR_AUTH,
+        SQLITE_IOERR_BEGIN_ATOMIC as SQLITE_IOERR_BEGIN_ATOMIC,
+        SQLITE_IOERR_BLOCKED as SQLITE_IOERR_BLOCKED,
+        SQLITE_IOERR_CHECKRESERVEDLOCK as SQLITE_IOERR_CHECKRESERVEDLOCK,
+        SQLITE_IOERR_CLOSE as SQLITE_IOERR_CLOSE,
+        SQLITE_IOERR_COMMIT_ATOMIC as SQLITE_IOERR_COMMIT_ATOMIC,
+        SQLITE_IOERR_CONVPATH as SQLITE_IOERR_CONVPATH,
+        SQLITE_IOERR_CORRUPTFS as SQLITE_IOERR_CORRUPTFS,
+        SQLITE_IOERR_DATA as SQLITE_IOERR_DATA,
+        SQLITE_IOERR_DELETE as SQLITE_IOERR_DELETE,
+        SQLITE_IOERR_DELETE_NOENT as SQLITE_IOERR_DELETE_NOENT,
+        SQLITE_IOERR_DIR_CLOSE as SQLITE_IOERR_DIR_CLOSE,
+        SQLITE_IOERR_DIR_FSYNC as SQLITE_IOERR_DIR_FSYNC,
+        SQLITE_IOERR_FSTAT as SQLITE_IOERR_FSTAT,
+        SQLITE_IOERR_FSYNC as SQLITE_IOERR_FSYNC,
+        SQLITE_IOERR_GETTEMPPATH as SQLITE_IOERR_GETTEMPPATH,
+        SQLITE_IOERR_LOCK as SQLITE_IOERR_LOCK,
+        SQLITE_IOERR_MMAP as SQLITE_IOERR_MMAP,
+        SQLITE_IOERR_NOMEM as SQLITE_IOERR_NOMEM,
+        SQLITE_IOERR_RDLOCK as SQLITE_IOERR_RDLOCK,
+        SQLITE_IOERR_READ as SQLITE_IOERR_READ,
+        SQLITE_IOERR_ROLLBACK_ATOMIC as SQLITE_IOERR_ROLLBACK_ATOMIC,
+        SQLITE_IOERR_SEEK as SQLITE_IOERR_SEEK,
+        SQLITE_IOERR_SHMLOCK as SQLITE_IOERR_SHMLOCK,
+        SQLITE_IOERR_SHMMAP as SQLITE_IOERR_SHMMAP,
+        SQLITE_IOERR_SHMOPEN as SQLITE_IOERR_SHMOPEN,
+        SQLITE_IOERR_SHMSIZE as SQLITE_IOERR_SHMSIZE,
+        SQLITE_IOERR_SHORT_READ as SQLITE_IOERR_SHORT_READ,
+        SQLITE_IOERR_TRUNCATE as SQLITE_IOERR_TRUNCATE,
+        SQLITE_IOERR_UNLOCK as SQLITE_IOERR_UNLOCK,
+        SQLITE_IOERR_VNODE as SQLITE_IOERR_VNODE,
+        SQLITE_IOERR_WRITE as SQLITE_IOERR_WRITE,
+        SQLITE_LIMIT_ATTACHED as SQLITE_LIMIT_ATTACHED,
+        SQLITE_LIMIT_COLUMN as SQLITE_LIMIT_COLUMN,
+        SQLITE_LIMIT_COMPOUND_SELECT as SQLITE_LIMIT_COMPOUND_SELECT,
+        SQLITE_LIMIT_EXPR_DEPTH as SQLITE_LIMIT_EXPR_DEPTH,
+        SQLITE_LIMIT_FUNCTION_ARG as SQLITE_LIMIT_FUNCTION_ARG,
+        SQLITE_LIMIT_LENGTH as SQLITE_LIMIT_LENGTH,
+        SQLITE_LIMIT_LIKE_PATTERN_LENGTH as SQLITE_LIMIT_LIKE_PATTERN_LENGTH,
+        SQLITE_LIMIT_SQL_LENGTH as SQLITE_LIMIT_SQL_LENGTH,
+        SQLITE_LIMIT_TRIGGER_DEPTH as SQLITE_LIMIT_TRIGGER_DEPTH,
+        SQLITE_LIMIT_VARIABLE_NUMBER as SQLITE_LIMIT_VARIABLE_NUMBER,
+        SQLITE_LIMIT_VDBE_OP as SQLITE_LIMIT_VDBE_OP,
+        SQLITE_LIMIT_WORKER_THREADS as SQLITE_LIMIT_WORKER_THREADS,
+        SQLITE_LOCKED as SQLITE_LOCKED,
+        SQLITE_LOCKED_SHAREDCACHE as SQLITE_LOCKED_SHAREDCACHE,
+        SQLITE_LOCKED_VTAB as SQLITE_LOCKED_VTAB,
+        SQLITE_MISMATCH as SQLITE_MISMATCH,
+        SQLITE_MISUSE as SQLITE_MISUSE,
+        SQLITE_NOLFS as SQLITE_NOLFS,
+        SQLITE_NOMEM as SQLITE_NOMEM,
+        SQLITE_NOTADB as SQLITE_NOTADB,
+        SQLITE_NOTFOUND as SQLITE_NOTFOUND,
+        SQLITE_NOTICE as SQLITE_NOTICE,
+        SQLITE_NOTICE_RECOVER_ROLLBACK as SQLITE_NOTICE_RECOVER_ROLLBACK,
+        SQLITE_NOTICE_RECOVER_WAL as SQLITE_NOTICE_RECOVER_WAL,
+        SQLITE_OK_LOAD_PERMANENTLY as SQLITE_OK_LOAD_PERMANENTLY,
+        SQLITE_OK_SYMLINK as SQLITE_OK_SYMLINK,
+        SQLITE_PERM as SQLITE_PERM,
+        SQLITE_PROTOCOL as SQLITE_PROTOCOL,
+        SQLITE_RANGE as SQLITE_RANGE,
+        SQLITE_READONLY as SQLITE_READONLY,
+        SQLITE_READONLY_CANTINIT as SQLITE_READONLY_CANTINIT,
+        SQLITE_READONLY_CANTLOCK as SQLITE_READONLY_CANTLOCK,
+        SQLITE_READONLY_DBMOVED as SQLITE_READONLY_DBMOVED,
+        SQLITE_READONLY_DIRECTORY as SQLITE_READONLY_DIRECTORY,
+        SQLITE_READONLY_RECOVERY as SQLITE_READONLY_RECOVERY,
+        SQLITE_READONLY_ROLLBACK as SQLITE_READONLY_ROLLBACK,
+        SQLITE_ROW as SQLITE_ROW,
+        SQLITE_SCHEMA as SQLITE_SCHEMA,
+        SQLITE_TOOBIG as SQLITE_TOOBIG,
+        SQLITE_WARNING as SQLITE_WARNING,
+        SQLITE_WARNING_AUTOINDEX as SQLITE_WARNING_AUTOINDEX,
+    )
+
+if sys.version_info < (3, 12):
+    from sqlite3.dbapi2 import enable_shared_cache as enable_shared_cache, version as version
+
+if sys.version_info < (3, 10):
+    from sqlite3.dbapi2 import OptimizedUnicode as OptimizedUnicode
+
+_CursorT = TypeVar("_CursorT", bound=Cursor)
+_SqliteData: TypeAlias = str | ReadableBuffer | int | float | None
+# Data that is passed through adapters can be of any type accepted by an adapter.
+_AdaptedInputData: TypeAlias = _SqliteData | Any
+# The Mapping must really be a dict, but making it invariant is too annoying.
+_Parameters: TypeAlias = SupportsLenAndGetItem[_AdaptedInputData] | Mapping[str, _AdaptedInputData]
+
+class _AnyParamWindowAggregateClass(Protocol):
+    def step(self, *args: Any) -> object: ...
+    def inverse(self, *args: Any) -> object: ...
+    def value(self) -> _SqliteData: ...
+    def finalize(self) -> _SqliteData: ...
+
+class _WindowAggregateClass(Protocol):
+    step: Callable[..., object]
+    inverse: Callable[..., object]
+    def value(self) -> _SqliteData: ...
+    def finalize(self) -> _SqliteData: ...
+
+class _AggregateProtocol(Protocol):
+    def step(self, value: int, /) -> object: ...
+    def finalize(self) -> int: ...
+
+class _SingleParamWindowAggregateClass(Protocol):
+    def step(self, param: Any, /) -> object: ...
+    def inverse(self, param: Any, /) -> object: ...
+    def value(self) -> _SqliteData: ...
+    def finalize(self) -> _SqliteData: ...
+
+# These classes are implemented in the C module _sqlite3. At runtime, they're imported
+# from there into sqlite3.dbapi2 and from that module to here. However, they
+# consider themselves to live in the sqlite3.* namespace, so we'll define them here.
+
+class Error(Exception):
+    if sys.version_info >= (3, 11):
+        sqlite_errorcode: int
+        sqlite_errorname: str
+
+class DatabaseError(Error): ...
+class DataError(DatabaseError): ...
+class IntegrityError(DatabaseError): ...
+class InterfaceError(Error): ...
+class InternalError(DatabaseError): ...
+class NotSupportedError(DatabaseError): ...
+class OperationalError(DatabaseError): ...
+class ProgrammingError(DatabaseError): ...
+class Warning(Exception): ...
+
+class Connection:
+    @property
+    def DataError(self) -> type[DataError]: ...
+    @property
+    def DatabaseError(self) -> type[DatabaseError]: ...
+    @property
+    def Error(self) -> type[Error]: ...
+    @property
+    def IntegrityError(self) -> type[IntegrityError]: ...
+    @property
+    def InterfaceError(self) -> type[InterfaceError]: ...
+    @property
+    def InternalError(self) -> type[InternalError]: ...
+    @property
+    def NotSupportedError(self) -> type[NotSupportedError]: ...
+    @property
+    def OperationalError(self) -> type[OperationalError]: ...
+    @property
+    def ProgrammingError(self) -> type[ProgrammingError]: ...
+    @property
+    def Warning(self) -> type[Warning]: ...
+    @property
+    def in_transaction(self) -> bool: ...
+    isolation_level: str | None  # one of '', 'DEFERRED', 'IMMEDIATE' or 'EXCLUSIVE'
+    @property
+    def total_changes(self) -> int: ...
+    if sys.version_info >= (3, 12):
+        @property
+        def autocommit(self) -> int: ...
+        @autocommit.setter
+        def autocommit(self, val: int) -> None: ...
+    row_factory: Any
+    text_factory: Any
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            database: StrOrBytesPath,
+            timeout: float = ...,
+            detect_types: int = ...,
+            isolation_level: str | None = ...,
+            check_same_thread: bool = ...,
+            factory: type[Connection] | None = ...,
+            cached_statements: int = ...,
+            uri: bool = ...,
+            autocommit: bool = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            database: StrOrBytesPath,
+            timeout: float = ...,
+            detect_types: int = ...,
+            isolation_level: str | None = ...,
+            check_same_thread: bool = ...,
+            factory: type[Connection] | None = ...,
+            cached_statements: int = ...,
+            uri: bool = ...,
+        ) -> None: ...
+
+    def close(self) -> None: ...
+    if sys.version_info >= (3, 11):
+        def blobopen(self, table: str, column: str, row: int, /, *, readonly: bool = False, name: str = "main") -> Blob: ...
+
+    def commit(self) -> None: ...
+    def create_aggregate(self, name: str, n_arg: int, aggregate_class: Callable[[], _AggregateProtocol]) -> None: ...
+    if sys.version_info >= (3, 11):
+        # num_params determines how many params will be passed to the aggregate class. We provide an overload
+        # for the case where num_params = 1, which is expected to be the common case.
+        @overload
+        def create_window_function(
+            self, name: str, num_params: Literal[1], aggregate_class: Callable[[], _SingleParamWindowAggregateClass] | None, /
+        ) -> None: ...
+        # And for num_params = -1, which means the aggregate must accept any number of parameters.
+        @overload
+        def create_window_function(
+            self, name: str, num_params: Literal[-1], aggregate_class: Callable[[], _AnyParamWindowAggregateClass] | None, /
+        ) -> None: ...
+        @overload
+        def create_window_function(
+            self, name: str, num_params: int, aggregate_class: Callable[[], _WindowAggregateClass] | None, /
+        ) -> None: ...
+
+    def create_collation(self, name: str, callback: Callable[[str, str], int | SupportsIndex] | None, /) -> None: ...
+    def create_function(
+        self, name: str, narg: int, func: Callable[..., _SqliteData] | None, *, deterministic: bool = False
+    ) -> None: ...
+    @overload
+    def cursor(self, factory: None = None) -> Cursor: ...
+    @overload
+    def cursor(self, factory: Callable[[Connection], _CursorT]) -> _CursorT: ...
+    def execute(self, sql: str, parameters: _Parameters = ..., /) -> Cursor: ...
+    def executemany(self, sql: str, parameters: Iterable[_Parameters], /) -> Cursor: ...
+    def executescript(self, sql_script: str, /) -> Cursor: ...
+    def interrupt(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def iterdump(self, *, filter: str | None = None) -> Generator[str, None, None]: ...
+    else:
+        def iterdump(self) -> Generator[str, None, None]: ...
+
+    def rollback(self) -> None: ...
+    def set_authorizer(
+        self, authorizer_callback: Callable[[int, str | None, str | None, str | None, str | None], int] | None
+    ) -> None: ...
+    def set_progress_handler(self, progress_handler: Callable[[], int | None] | None, n: int) -> None: ...
+    def set_trace_callback(self, trace_callback: Callable[[str], object] | None) -> None: ...
+    # enable_load_extension and load_extension is not available on python distributions compiled
+    # without sqlite3 loadable extension support. see footnotes https://docs.python.org/3/library/sqlite3.html#f1
+    def enable_load_extension(self, enable: bool, /) -> None: ...
+    if sys.version_info >= (3, 12):
+        def load_extension(self, name: str, /, *, entrypoint: str | None = None) -> None: ...
+    else:
+        def load_extension(self, name: str, /) -> None: ...
+
+    def backup(
+        self,
+        target: Connection,
+        *,
+        pages: int = -1,
+        progress: Callable[[int, int, int], object] | None = None,
+        name: str = "main",
+        sleep: float = 0.25,
+    ) -> None: ...
+    if sys.version_info >= (3, 11):
+        def setlimit(self, category: int, limit: int, /) -> int: ...
+        def getlimit(self, category: int, /) -> int: ...
+        def serialize(self, *, name: str = "main") -> bytes: ...
+        def deserialize(self, data: ReadableBuffer, /, *, name: str = "main") -> None: ...
+    if sys.version_info >= (3, 12):
+        def getconfig(self, op: int, /) -> bool: ...
+        def setconfig(self, op: int, enable: bool = True, /) -> bool: ...
+
+    def __call__(self, sql: str, /) -> _Statement: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None, /
+    ) -> Literal[False]: ...
+
+class Cursor(Iterator[Any]):
+    arraysize: int
+    @property
+    def connection(self) -> Connection: ...
+    # May be None, but using `| MaybeNone` (`| Any`) instead to avoid slightly annoying false positives.
+    @property
+    def description(self) -> tuple[tuple[str, None, None, None, None, None, None], ...] | MaybeNone: ...
+    @property
+    def lastrowid(self) -> int | None: ...
+    row_factory: Callable[[Cursor, Row], object] | None
+    @property
+    def rowcount(self) -> int: ...
+    def __init__(self, cursor: Connection, /) -> None: ...
+    def close(self) -> None: ...
+    def execute(self, sql: str, parameters: _Parameters = (), /) -> Self: ...
+    def executemany(self, sql: str, seq_of_parameters: Iterable[_Parameters], /) -> Self: ...
+    def executescript(self, sql_script: str, /) -> Cursor: ...
+    def fetchall(self) -> list[Any]: ...
+    def fetchmany(self, size: int | None = 1) -> list[Any]: ...
+    # Returns either a row (as created by the row_factory) or None, but
+    # putting None in the return annotation causes annoying false positives.
+    def fetchone(self) -> Any: ...
+    def setinputsizes(self, sizes: Unused, /) -> None: ...  # does nothing
+    def setoutputsize(self, size: Unused, column: Unused = None, /) -> None: ...  # does nothing
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> Any: ...
+
+@final
+class PrepareProtocol:
+    def __init__(self, *args: object, **kwargs: object) -> None: ...
+
+class Row(Sequence[Any]):
+    def __new__(cls, cursor: Cursor, data: tuple[Any, ...], /) -> Self: ...
+    def keys(self) -> list[str]: ...
+    @overload
+    def __getitem__(self, key: int | str, /) -> Any: ...
+    @overload
+    def __getitem__(self, key: slice, /) -> tuple[Any, ...]: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> Iterator[Any]: ...
+    def __len__(self) -> int: ...
+    # These return NotImplemented for anything that is not a Row.
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ge__(self, value: object, /) -> bool: ...
+    def __gt__(self, value: object, /) -> bool: ...
+    def __le__(self, value: object, /) -> bool: ...
+    def __lt__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
+
+# This class is not exposed. It calls itself sqlite3.Statement.
+@final
+@type_check_only
+class _Statement: ...
+
+if sys.version_info >= (3, 11):
+    @final
+    class Blob:
+        def close(self) -> None: ...
+        def read(self, length: int = -1, /) -> bytes: ...
+        def write(self, data: ReadableBuffer, /) -> None: ...
+        def tell(self) -> int: ...
+        # whence must be one of os.SEEK_SET, os.SEEK_CUR, os.SEEK_END
+        def seek(self, offset: int, origin: int = 0, /) -> None: ...
+        def __len__(self) -> int: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(self, type: object, val: object, tb: object, /) -> Literal[False]: ...
+        def __getitem__(self, key: SupportsIndex | slice, /) -> int: ...
+        def __setitem__(self, key: SupportsIndex | slice, value: int, /) -> None: ...
diff --git a/mypy/typeshed/stdlib/sqlite3/dbapi2.pyi b/mypy/typeshed/stdlib/sqlite3/dbapi2.pyi
index 24974f787c62..d3ea3ef0e896 100644
--- a/mypy/typeshed/stdlib/sqlite3/dbapi2.pyi
+++ b/mypy/typeshed/stdlib/sqlite3/dbapi2.pyi
@@ -1,21 +1,226 @@
-import sqlite3
 import sys
-from _typeshed import Incomplete, ReadableBuffer, StrOrBytesPath, SupportsLenAndGetItem, Unused
-from collections.abc import Callable, Generator, Iterable, Iterator, Mapping
+from _sqlite3 import (
+    PARSE_COLNAMES as PARSE_COLNAMES,
+    PARSE_DECLTYPES as PARSE_DECLTYPES,
+    SQLITE_ALTER_TABLE as SQLITE_ALTER_TABLE,
+    SQLITE_ANALYZE as SQLITE_ANALYZE,
+    SQLITE_ATTACH as SQLITE_ATTACH,
+    SQLITE_CREATE_INDEX as SQLITE_CREATE_INDEX,
+    SQLITE_CREATE_TABLE as SQLITE_CREATE_TABLE,
+    SQLITE_CREATE_TEMP_INDEX as SQLITE_CREATE_TEMP_INDEX,
+    SQLITE_CREATE_TEMP_TABLE as SQLITE_CREATE_TEMP_TABLE,
+    SQLITE_CREATE_TEMP_TRIGGER as SQLITE_CREATE_TEMP_TRIGGER,
+    SQLITE_CREATE_TEMP_VIEW as SQLITE_CREATE_TEMP_VIEW,
+    SQLITE_CREATE_TRIGGER as SQLITE_CREATE_TRIGGER,
+    SQLITE_CREATE_VIEW as SQLITE_CREATE_VIEW,
+    SQLITE_CREATE_VTABLE as SQLITE_CREATE_VTABLE,
+    SQLITE_DELETE as SQLITE_DELETE,
+    SQLITE_DENY as SQLITE_DENY,
+    SQLITE_DETACH as SQLITE_DETACH,
+    SQLITE_DONE as SQLITE_DONE,
+    SQLITE_DROP_INDEX as SQLITE_DROP_INDEX,
+    SQLITE_DROP_TABLE as SQLITE_DROP_TABLE,
+    SQLITE_DROP_TEMP_INDEX as SQLITE_DROP_TEMP_INDEX,
+    SQLITE_DROP_TEMP_TABLE as SQLITE_DROP_TEMP_TABLE,
+    SQLITE_DROP_TEMP_TRIGGER as SQLITE_DROP_TEMP_TRIGGER,
+    SQLITE_DROP_TEMP_VIEW as SQLITE_DROP_TEMP_VIEW,
+    SQLITE_DROP_TRIGGER as SQLITE_DROP_TRIGGER,
+    SQLITE_DROP_VIEW as SQLITE_DROP_VIEW,
+    SQLITE_DROP_VTABLE as SQLITE_DROP_VTABLE,
+    SQLITE_FUNCTION as SQLITE_FUNCTION,
+    SQLITE_IGNORE as SQLITE_IGNORE,
+    SQLITE_INSERT as SQLITE_INSERT,
+    SQLITE_OK as SQLITE_OK,
+    SQLITE_PRAGMA as SQLITE_PRAGMA,
+    SQLITE_READ as SQLITE_READ,
+    SQLITE_RECURSIVE as SQLITE_RECURSIVE,
+    SQLITE_REINDEX as SQLITE_REINDEX,
+    SQLITE_SAVEPOINT as SQLITE_SAVEPOINT,
+    SQLITE_SELECT as SQLITE_SELECT,
+    SQLITE_TRANSACTION as SQLITE_TRANSACTION,
+    SQLITE_UPDATE as SQLITE_UPDATE,
+    adapt as adapt,
+    adapters as adapters,
+    complete_statement as complete_statement,
+    connect as connect,
+    converters as converters,
+    enable_callback_tracebacks as enable_callback_tracebacks,
+    register_adapter as register_adapter,
+    register_converter as register_converter,
+    sqlite_version as sqlite_version,
+)
 from datetime import date, datetime, time
-from types import TracebackType
-from typing import Any, Protocol, TypeVar, overload
-from typing_extensions import Literal, Self, SupportsIndex, TypeAlias, final
+from sqlite3 import (
+    Connection as Connection,
+    Cursor as Cursor,
+    DatabaseError as DatabaseError,
+    DataError as DataError,
+    Error as Error,
+    IntegrityError as IntegrityError,
+    InterfaceError as InterfaceError,
+    InternalError as InternalError,
+    NotSupportedError as NotSupportedError,
+    OperationalError as OperationalError,
+    PrepareProtocol as PrepareProtocol,
+    ProgrammingError as ProgrammingError,
+    Row as Row,
+    Warning as Warning,
+)
+
+if sys.version_info >= (3, 12):
+    from _sqlite3 import (
+        LEGACY_TRANSACTION_CONTROL as LEGACY_TRANSACTION_CONTROL,
+        SQLITE_DBCONFIG_DEFENSIVE as SQLITE_DBCONFIG_DEFENSIVE,
+        SQLITE_DBCONFIG_DQS_DDL as SQLITE_DBCONFIG_DQS_DDL,
+        SQLITE_DBCONFIG_DQS_DML as SQLITE_DBCONFIG_DQS_DML,
+        SQLITE_DBCONFIG_ENABLE_FKEY as SQLITE_DBCONFIG_ENABLE_FKEY,
+        SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER as SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER,
+        SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION as SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION,
+        SQLITE_DBCONFIG_ENABLE_QPSG as SQLITE_DBCONFIG_ENABLE_QPSG,
+        SQLITE_DBCONFIG_ENABLE_TRIGGER as SQLITE_DBCONFIG_ENABLE_TRIGGER,
+        SQLITE_DBCONFIG_ENABLE_VIEW as SQLITE_DBCONFIG_ENABLE_VIEW,
+        SQLITE_DBCONFIG_LEGACY_ALTER_TABLE as SQLITE_DBCONFIG_LEGACY_ALTER_TABLE,
+        SQLITE_DBCONFIG_LEGACY_FILE_FORMAT as SQLITE_DBCONFIG_LEGACY_FILE_FORMAT,
+        SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE as SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE,
+        SQLITE_DBCONFIG_RESET_DATABASE as SQLITE_DBCONFIG_RESET_DATABASE,
+        SQLITE_DBCONFIG_TRIGGER_EQP as SQLITE_DBCONFIG_TRIGGER_EQP,
+        SQLITE_DBCONFIG_TRUSTED_SCHEMA as SQLITE_DBCONFIG_TRUSTED_SCHEMA,
+        SQLITE_DBCONFIG_WRITABLE_SCHEMA as SQLITE_DBCONFIG_WRITABLE_SCHEMA,
+    )
 
-_T = TypeVar("_T")
-_CursorT = TypeVar("_CursorT", bound=Cursor)
-_SqliteData: TypeAlias = str | ReadableBuffer | int | float | None
-# Data that is passed through adapters can be of any type accepted by an adapter.
-_AdaptedInputData: TypeAlias = _SqliteData | Any
-# The Mapping must really be a dict, but making it invariant is too annoying.
-_Parameters: TypeAlias = SupportsLenAndGetItem[_AdaptedInputData] | Mapping[str, _AdaptedInputData]
-_Adapter: TypeAlias = Callable[[_T], _SqliteData]
-_Converter: TypeAlias = Callable[[bytes], Any]
+if sys.version_info >= (3, 11):
+    from _sqlite3 import (
+        SQLITE_ABORT as SQLITE_ABORT,
+        SQLITE_ABORT_ROLLBACK as SQLITE_ABORT_ROLLBACK,
+        SQLITE_AUTH as SQLITE_AUTH,
+        SQLITE_AUTH_USER as SQLITE_AUTH_USER,
+        SQLITE_BUSY as SQLITE_BUSY,
+        SQLITE_BUSY_RECOVERY as SQLITE_BUSY_RECOVERY,
+        SQLITE_BUSY_SNAPSHOT as SQLITE_BUSY_SNAPSHOT,
+        SQLITE_BUSY_TIMEOUT as SQLITE_BUSY_TIMEOUT,
+        SQLITE_CANTOPEN as SQLITE_CANTOPEN,
+        SQLITE_CANTOPEN_CONVPATH as SQLITE_CANTOPEN_CONVPATH,
+        SQLITE_CANTOPEN_DIRTYWAL as SQLITE_CANTOPEN_DIRTYWAL,
+        SQLITE_CANTOPEN_FULLPATH as SQLITE_CANTOPEN_FULLPATH,
+        SQLITE_CANTOPEN_ISDIR as SQLITE_CANTOPEN_ISDIR,
+        SQLITE_CANTOPEN_NOTEMPDIR as SQLITE_CANTOPEN_NOTEMPDIR,
+        SQLITE_CANTOPEN_SYMLINK as SQLITE_CANTOPEN_SYMLINK,
+        SQLITE_CONSTRAINT as SQLITE_CONSTRAINT,
+        SQLITE_CONSTRAINT_CHECK as SQLITE_CONSTRAINT_CHECK,
+        SQLITE_CONSTRAINT_COMMITHOOK as SQLITE_CONSTRAINT_COMMITHOOK,
+        SQLITE_CONSTRAINT_FOREIGNKEY as SQLITE_CONSTRAINT_FOREIGNKEY,
+        SQLITE_CONSTRAINT_FUNCTION as SQLITE_CONSTRAINT_FUNCTION,
+        SQLITE_CONSTRAINT_NOTNULL as SQLITE_CONSTRAINT_NOTNULL,
+        SQLITE_CONSTRAINT_PINNED as SQLITE_CONSTRAINT_PINNED,
+        SQLITE_CONSTRAINT_PRIMARYKEY as SQLITE_CONSTRAINT_PRIMARYKEY,
+        SQLITE_CONSTRAINT_ROWID as SQLITE_CONSTRAINT_ROWID,
+        SQLITE_CONSTRAINT_TRIGGER as SQLITE_CONSTRAINT_TRIGGER,
+        SQLITE_CONSTRAINT_UNIQUE as SQLITE_CONSTRAINT_UNIQUE,
+        SQLITE_CONSTRAINT_VTAB as SQLITE_CONSTRAINT_VTAB,
+        SQLITE_CORRUPT as SQLITE_CORRUPT,
+        SQLITE_CORRUPT_INDEX as SQLITE_CORRUPT_INDEX,
+        SQLITE_CORRUPT_SEQUENCE as SQLITE_CORRUPT_SEQUENCE,
+        SQLITE_CORRUPT_VTAB as SQLITE_CORRUPT_VTAB,
+        SQLITE_EMPTY as SQLITE_EMPTY,
+        SQLITE_ERROR as SQLITE_ERROR,
+        SQLITE_ERROR_MISSING_COLLSEQ as SQLITE_ERROR_MISSING_COLLSEQ,
+        SQLITE_ERROR_RETRY as SQLITE_ERROR_RETRY,
+        SQLITE_ERROR_SNAPSHOT as SQLITE_ERROR_SNAPSHOT,
+        SQLITE_FORMAT as SQLITE_FORMAT,
+        SQLITE_FULL as SQLITE_FULL,
+        SQLITE_INTERNAL as SQLITE_INTERNAL,
+        SQLITE_INTERRUPT as SQLITE_INTERRUPT,
+        SQLITE_IOERR as SQLITE_IOERR,
+        SQLITE_IOERR_ACCESS as SQLITE_IOERR_ACCESS,
+        SQLITE_IOERR_AUTH as SQLITE_IOERR_AUTH,
+        SQLITE_IOERR_BEGIN_ATOMIC as SQLITE_IOERR_BEGIN_ATOMIC,
+        SQLITE_IOERR_BLOCKED as SQLITE_IOERR_BLOCKED,
+        SQLITE_IOERR_CHECKRESERVEDLOCK as SQLITE_IOERR_CHECKRESERVEDLOCK,
+        SQLITE_IOERR_CLOSE as SQLITE_IOERR_CLOSE,
+        SQLITE_IOERR_COMMIT_ATOMIC as SQLITE_IOERR_COMMIT_ATOMIC,
+        SQLITE_IOERR_CONVPATH as SQLITE_IOERR_CONVPATH,
+        SQLITE_IOERR_CORRUPTFS as SQLITE_IOERR_CORRUPTFS,
+        SQLITE_IOERR_DATA as SQLITE_IOERR_DATA,
+        SQLITE_IOERR_DELETE as SQLITE_IOERR_DELETE,
+        SQLITE_IOERR_DELETE_NOENT as SQLITE_IOERR_DELETE_NOENT,
+        SQLITE_IOERR_DIR_CLOSE as SQLITE_IOERR_DIR_CLOSE,
+        SQLITE_IOERR_DIR_FSYNC as SQLITE_IOERR_DIR_FSYNC,
+        SQLITE_IOERR_FSTAT as SQLITE_IOERR_FSTAT,
+        SQLITE_IOERR_FSYNC as SQLITE_IOERR_FSYNC,
+        SQLITE_IOERR_GETTEMPPATH as SQLITE_IOERR_GETTEMPPATH,
+        SQLITE_IOERR_LOCK as SQLITE_IOERR_LOCK,
+        SQLITE_IOERR_MMAP as SQLITE_IOERR_MMAP,
+        SQLITE_IOERR_NOMEM as SQLITE_IOERR_NOMEM,
+        SQLITE_IOERR_RDLOCK as SQLITE_IOERR_RDLOCK,
+        SQLITE_IOERR_READ as SQLITE_IOERR_READ,
+        SQLITE_IOERR_ROLLBACK_ATOMIC as SQLITE_IOERR_ROLLBACK_ATOMIC,
+        SQLITE_IOERR_SEEK as SQLITE_IOERR_SEEK,
+        SQLITE_IOERR_SHMLOCK as SQLITE_IOERR_SHMLOCK,
+        SQLITE_IOERR_SHMMAP as SQLITE_IOERR_SHMMAP,
+        SQLITE_IOERR_SHMOPEN as SQLITE_IOERR_SHMOPEN,
+        SQLITE_IOERR_SHMSIZE as SQLITE_IOERR_SHMSIZE,
+        SQLITE_IOERR_SHORT_READ as SQLITE_IOERR_SHORT_READ,
+        SQLITE_IOERR_TRUNCATE as SQLITE_IOERR_TRUNCATE,
+        SQLITE_IOERR_UNLOCK as SQLITE_IOERR_UNLOCK,
+        SQLITE_IOERR_VNODE as SQLITE_IOERR_VNODE,
+        SQLITE_IOERR_WRITE as SQLITE_IOERR_WRITE,
+        SQLITE_LIMIT_ATTACHED as SQLITE_LIMIT_ATTACHED,
+        SQLITE_LIMIT_COLUMN as SQLITE_LIMIT_COLUMN,
+        SQLITE_LIMIT_COMPOUND_SELECT as SQLITE_LIMIT_COMPOUND_SELECT,
+        SQLITE_LIMIT_EXPR_DEPTH as SQLITE_LIMIT_EXPR_DEPTH,
+        SQLITE_LIMIT_FUNCTION_ARG as SQLITE_LIMIT_FUNCTION_ARG,
+        SQLITE_LIMIT_LENGTH as SQLITE_LIMIT_LENGTH,
+        SQLITE_LIMIT_LIKE_PATTERN_LENGTH as SQLITE_LIMIT_LIKE_PATTERN_LENGTH,
+        SQLITE_LIMIT_SQL_LENGTH as SQLITE_LIMIT_SQL_LENGTH,
+        SQLITE_LIMIT_TRIGGER_DEPTH as SQLITE_LIMIT_TRIGGER_DEPTH,
+        SQLITE_LIMIT_VARIABLE_NUMBER as SQLITE_LIMIT_VARIABLE_NUMBER,
+        SQLITE_LIMIT_VDBE_OP as SQLITE_LIMIT_VDBE_OP,
+        SQLITE_LIMIT_WORKER_THREADS as SQLITE_LIMIT_WORKER_THREADS,
+        SQLITE_LOCKED as SQLITE_LOCKED,
+        SQLITE_LOCKED_SHAREDCACHE as SQLITE_LOCKED_SHAREDCACHE,
+        SQLITE_LOCKED_VTAB as SQLITE_LOCKED_VTAB,
+        SQLITE_MISMATCH as SQLITE_MISMATCH,
+        SQLITE_MISUSE as SQLITE_MISUSE,
+        SQLITE_NOLFS as SQLITE_NOLFS,
+        SQLITE_NOMEM as SQLITE_NOMEM,
+        SQLITE_NOTADB as SQLITE_NOTADB,
+        SQLITE_NOTFOUND as SQLITE_NOTFOUND,
+        SQLITE_NOTICE as SQLITE_NOTICE,
+        SQLITE_NOTICE_RECOVER_ROLLBACK as SQLITE_NOTICE_RECOVER_ROLLBACK,
+        SQLITE_NOTICE_RECOVER_WAL as SQLITE_NOTICE_RECOVER_WAL,
+        SQLITE_OK_LOAD_PERMANENTLY as SQLITE_OK_LOAD_PERMANENTLY,
+        SQLITE_OK_SYMLINK as SQLITE_OK_SYMLINK,
+        SQLITE_PERM as SQLITE_PERM,
+        SQLITE_PROTOCOL as SQLITE_PROTOCOL,
+        SQLITE_RANGE as SQLITE_RANGE,
+        SQLITE_READONLY as SQLITE_READONLY,
+        SQLITE_READONLY_CANTINIT as SQLITE_READONLY_CANTINIT,
+        SQLITE_READONLY_CANTLOCK as SQLITE_READONLY_CANTLOCK,
+        SQLITE_READONLY_DBMOVED as SQLITE_READONLY_DBMOVED,
+        SQLITE_READONLY_DIRECTORY as SQLITE_READONLY_DIRECTORY,
+        SQLITE_READONLY_RECOVERY as SQLITE_READONLY_RECOVERY,
+        SQLITE_READONLY_ROLLBACK as SQLITE_READONLY_ROLLBACK,
+        SQLITE_ROW as SQLITE_ROW,
+        SQLITE_SCHEMA as SQLITE_SCHEMA,
+        SQLITE_TOOBIG as SQLITE_TOOBIG,
+        SQLITE_WARNING as SQLITE_WARNING,
+        SQLITE_WARNING_AUTOINDEX as SQLITE_WARNING_AUTOINDEX,
+    )
+    from sqlite3 import Blob as Blob
+
+if sys.version_info < (3, 14):
+    # Deprecated and removed from _sqlite3 in 3.12, but removed from here in 3.14.
+    version: str
+
+if sys.version_info < (3, 12):
+    if sys.version_info >= (3, 10):
+        # deprecation wrapper that has a different name for the argument...
+        def enable_shared_cache(enable: int) -> None: ...
+    else:
+        from _sqlite3 import enable_shared_cache as enable_shared_cache
+
+if sys.version_info < (3, 10):
+    from _sqlite3 import OptimizedUnicode as OptimizedUnicode
 
 paramstyle: str
 threadsafety: int
@@ -28,430 +233,9 @@ def DateFromTicks(ticks: float) -> Date: ...
 def TimeFromTicks(ticks: float) -> Time: ...
 def TimestampFromTicks(ticks: float) -> Timestamp: ...
 
-version_info: tuple[int, int, int]
+if sys.version_info < (3, 14):
+    # Deprecated in 3.12, removed in 3.14.
+    version_info: tuple[int, int, int]
+
 sqlite_version_info: tuple[int, int, int]
 Binary = memoryview
-
-# The remaining definitions are imported from _sqlite3.
-
-PARSE_COLNAMES: int
-PARSE_DECLTYPES: int
-SQLITE_ALTER_TABLE: int
-SQLITE_ANALYZE: int
-SQLITE_ATTACH: int
-SQLITE_CREATE_INDEX: int
-SQLITE_CREATE_TABLE: int
-SQLITE_CREATE_TEMP_INDEX: int
-SQLITE_CREATE_TEMP_TABLE: int
-SQLITE_CREATE_TEMP_TRIGGER: int
-SQLITE_CREATE_TEMP_VIEW: int
-SQLITE_CREATE_TRIGGER: int
-SQLITE_CREATE_VIEW: int
-SQLITE_CREATE_VTABLE: int
-SQLITE_DELETE: int
-SQLITE_DENY: int
-SQLITE_DETACH: int
-SQLITE_DONE: int
-SQLITE_DROP_INDEX: int
-SQLITE_DROP_TABLE: int
-SQLITE_DROP_TEMP_INDEX: int
-SQLITE_DROP_TEMP_TABLE: int
-SQLITE_DROP_TEMP_TRIGGER: int
-SQLITE_DROP_TEMP_VIEW: int
-SQLITE_DROP_TRIGGER: int
-SQLITE_DROP_VIEW: int
-SQLITE_DROP_VTABLE: int
-SQLITE_FUNCTION: int
-SQLITE_IGNORE: int
-SQLITE_INSERT: int
-SQLITE_OK: int
-if sys.version_info >= (3, 11):
-    SQLITE_LIMIT_LENGTH: int
-    SQLITE_LIMIT_SQL_LENGTH: int
-    SQLITE_LIMIT_COLUMN: int
-    SQLITE_LIMIT_EXPR_DEPTH: int
-    SQLITE_LIMIT_COMPOUND_SELECT: int
-    SQLITE_LIMIT_VDBE_OP: int
-    SQLITE_LIMIT_FUNCTION_ARG: int
-    SQLITE_LIMIT_ATTACHED: int
-    SQLITE_LIMIT_LIKE_PATTERN_LENGTH: int
-    SQLITE_LIMIT_VARIABLE_NUMBER: int
-    SQLITE_LIMIT_TRIGGER_DEPTH: int
-    SQLITE_LIMIT_WORKER_THREADS: int
-SQLITE_PRAGMA: int
-SQLITE_READ: int
-SQLITE_REINDEX: int
-SQLITE_RECURSIVE: int
-SQLITE_SAVEPOINT: int
-SQLITE_SELECT: int
-SQLITE_TRANSACTION: int
-SQLITE_UPDATE: int
-adapters: dict[tuple[type[Any], type[Any]], _Adapter[Any]]
-converters: dict[str, _Converter]
-sqlite_version: str
-version: str
-
-if sys.version_info >= (3, 11):
-    SQLITE_ABORT: int
-    SQLITE_ABORT_ROLLBACK: int
-    SQLITE_AUTH: int
-    SQLITE_AUTH_USER: int
-    SQLITE_BUSY: int
-    SQLITE_BUSY_RECOVERY: int
-    SQLITE_BUSY_SNAPSHOT: int
-    SQLITE_BUSY_TIMEOUT: int
-    SQLITE_CANTOPEN: int
-    SQLITE_CANTOPEN_CONVPATH: int
-    SQLITE_CANTOPEN_DIRTYWAL: int
-    SQLITE_CANTOPEN_FULLPATH: int
-    SQLITE_CANTOPEN_ISDIR: int
-    SQLITE_CANTOPEN_NOTEMPDIR: int
-    SQLITE_CANTOPEN_SYMLINK: int
-    SQLITE_CONSTRAINT: int
-    SQLITE_CONSTRAINT_CHECK: int
-    SQLITE_CONSTRAINT_COMMITHOOK: int
-    SQLITE_CONSTRAINT_FOREIGNKEY: int
-    SQLITE_CONSTRAINT_FUNCTION: int
-    SQLITE_CONSTRAINT_NOTNULL: int
-    SQLITE_CONSTRAINT_PINNED: int
-    SQLITE_CONSTRAINT_PRIMARYKEY: int
-    SQLITE_CONSTRAINT_ROWID: int
-    SQLITE_CONSTRAINT_TRIGGER: int
-    SQLITE_CONSTRAINT_UNIQUE: int
-    SQLITE_CONSTRAINT_VTAB: int
-    SQLITE_CORRUPT: int
-    SQLITE_CORRUPT_INDEX: int
-    SQLITE_CORRUPT_SEQUENCE: int
-    SQLITE_CORRUPT_VTAB: int
-    SQLITE_EMPTY: int
-    SQLITE_ERROR: int
-    SQLITE_ERROR_MISSING_COLLSEQ: int
-    SQLITE_ERROR_RETRY: int
-    SQLITE_ERROR_SNAPSHOT: int
-    SQLITE_FORMAT: int
-    SQLITE_FULL: int
-    SQLITE_INTERNAL: int
-    SQLITE_INTERRUPT: int
-    SQLITE_IOERR: int
-    SQLITE_IOERR_ACCESS: int
-    SQLITE_IOERR_AUTH: int
-    SQLITE_IOERR_BEGIN_ATOMIC: int
-    SQLITE_IOERR_BLOCKED: int
-    SQLITE_IOERR_CHECKRESERVEDLOCK: int
-    SQLITE_IOERR_CLOSE: int
-    SQLITE_IOERR_COMMIT_ATOMIC: int
-    SQLITE_IOERR_CONVPATH: int
-    SQLITE_IOERR_CORRUPTFS: int
-    SQLITE_IOERR_DATA: int
-    SQLITE_IOERR_DELETE: int
-    SQLITE_IOERR_DELETE_NOENT: int
-    SQLITE_IOERR_DIR_CLOSE: int
-    SQLITE_IOERR_DIR_FSYNC: int
-    SQLITE_IOERR_FSTAT: int
-    SQLITE_IOERR_FSYNC: int
-    SQLITE_IOERR_GETTEMPPATH: int
-    SQLITE_IOERR_LOCK: int
-    SQLITE_IOERR_MMAP: int
-    SQLITE_IOERR_NOMEM: int
-    SQLITE_IOERR_RDLOCK: int
-    SQLITE_IOERR_READ: int
-    SQLITE_IOERR_ROLLBACK_ATOMIC: int
-    SQLITE_IOERR_SEEK: int
-    SQLITE_IOERR_SHMLOCK: int
-    SQLITE_IOERR_SHMMAP: int
-    SQLITE_IOERR_SHMOPEN: int
-    SQLITE_IOERR_SHMSIZE: int
-    SQLITE_IOERR_SHORT_READ: int
-    SQLITE_IOERR_TRUNCATE: int
-    SQLITE_IOERR_UNLOCK: int
-    SQLITE_IOERR_VNODE: int
-    SQLITE_IOERR_WRITE: int
-    SQLITE_LOCKED: int
-    SQLITE_LOCKED_SHAREDCACHE: int
-    SQLITE_LOCKED_VTAB: int
-    SQLITE_MISMATCH: int
-    SQLITE_MISUSE: int
-    SQLITE_NOLFS: int
-    SQLITE_NOMEM: int
-    SQLITE_NOTADB: int
-    SQLITE_NOTFOUND: int
-    SQLITE_NOTICE: int
-    SQLITE_NOTICE_RECOVER_ROLLBACK: int
-    SQLITE_NOTICE_RECOVER_WAL: int
-    SQLITE_OK_LOAD_PERMANENTLY: int
-    SQLITE_OK_SYMLINK: int
-    SQLITE_PERM: int
-    SQLITE_PROTOCOL: int
-    SQLITE_RANGE: int
-    SQLITE_READONLY: int
-    SQLITE_READONLY_CANTINIT: int
-    SQLITE_READONLY_CANTLOCK: int
-    SQLITE_READONLY_DBMOVED: int
-    SQLITE_READONLY_DIRECTORY: int
-    SQLITE_READONLY_RECOVERY: int
-    SQLITE_READONLY_ROLLBACK: int
-    SQLITE_ROW: int
-    SQLITE_SCHEMA: int
-    SQLITE_TOOBIG: int
-    SQLITE_WARNING: int
-    SQLITE_WARNING_AUTOINDEX: int
-
-# Can take or return anything depending on what's in the registry.
-@overload
-def adapt(__obj: Any, __proto: Any) -> Any: ...
-@overload
-def adapt(__obj: Any, __proto: Any, __alt: _T) -> Any | _T: ...
-def complete_statement(statement: str) -> bool: ...
-def connect(
-    database: StrOrBytesPath,
-    timeout: float = ...,
-    detect_types: int = ...,
-    isolation_level: str | None = ...,
-    check_same_thread: bool = ...,
-    factory: type[Connection] | None = ...,
-    cached_statements: int = ...,
-    uri: bool = ...,
-) -> Connection: ...
-def enable_callback_tracebacks(__enable: bool) -> None: ...
-
-# takes a pos-or-keyword argument because there is a C wrapper
-def enable_shared_cache(enable: int) -> None: ...
-
-if sys.version_info >= (3, 10):
-    def register_adapter(__type: type[_T], __adapter: _Adapter[_T]) -> None: ...
-    def register_converter(__typename: str, __converter: _Converter) -> None: ...
-
-else:
-    def register_adapter(__type: type[_T], __caster: _Adapter[_T]) -> None: ...
-    def register_converter(__name: str, __converter: _Converter) -> None: ...
-
-if sys.version_info < (3, 8):
-    class Cache:
-        def __init__(self, *args: Incomplete, **kwargs: Unused) -> None: ...
-        def display(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
-        def get(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
-
-class _AggregateProtocol(Protocol):
-    def step(self, __value: int) -> object: ...
-    def finalize(self) -> int: ...
-
-class _SingleParamWindowAggregateClass(Protocol):
-    def step(self, __param: Any) -> object: ...
-    def inverse(self, __param: Any) -> object: ...
-    def value(self) -> _SqliteData: ...
-    def finalize(self) -> _SqliteData: ...
-
-class _AnyParamWindowAggregateClass(Protocol):
-    def step(self, *args: Any) -> object: ...
-    def inverse(self, *args: Any) -> object: ...
-    def value(self) -> _SqliteData: ...
-    def finalize(self) -> _SqliteData: ...
-
-class _WindowAggregateClass(Protocol):
-    step: Callable[..., object]
-    inverse: Callable[..., object]
-    def value(self) -> _SqliteData: ...
-    def finalize(self) -> _SqliteData: ...
-
-class Connection:
-    @property
-    def DataError(self) -> type[sqlite3.DataError]: ...
-    @property
-    def DatabaseError(self) -> type[sqlite3.DatabaseError]: ...
-    @property
-    def Error(self) -> type[sqlite3.Error]: ...
-    @property
-    def IntegrityError(self) -> type[sqlite3.IntegrityError]: ...
-    @property
-    def InterfaceError(self) -> type[sqlite3.InterfaceError]: ...
-    @property
-    def InternalError(self) -> type[sqlite3.InternalError]: ...
-    @property
-    def NotSupportedError(self) -> type[sqlite3.NotSupportedError]: ...
-    @property
-    def OperationalError(self) -> type[sqlite3.OperationalError]: ...
-    @property
-    def ProgrammingError(self) -> type[sqlite3.ProgrammingError]: ...
-    @property
-    def Warning(self) -> type[sqlite3.Warning]: ...
-    @property
-    def in_transaction(self) -> bool: ...
-    isolation_level: str | None  # one of '', 'DEFERRED', 'IMMEDIATE' or 'EXCLUSIVE'
-    @property
-    def total_changes(self) -> int: ...
-    row_factory: Any
-    text_factory: Any
-    def __init__(
-        self,
-        database: StrOrBytesPath,
-        timeout: float = ...,
-        detect_types: int = ...,
-        isolation_level: str | None = ...,
-        check_same_thread: bool = ...,
-        factory: type[Connection] | None = ...,
-        cached_statements: int = ...,
-        uri: bool = ...,
-    ) -> None: ...
-    def close(self) -> None: ...
-    if sys.version_info >= (3, 11):
-        def blobopen(self, __table: str, __column: str, __row: int, *, readonly: bool = False, name: str = "main") -> Blob: ...
-
-    def commit(self) -> None: ...
-    def create_aggregate(self, name: str, n_arg: int, aggregate_class: Callable[[], _AggregateProtocol]) -> None: ...
-    if sys.version_info >= (3, 11):
-        # num_params determines how many params will be passed to the aggregate class. We provide an overload
-        # for the case where num_params = 1, which is expected to be the common case.
-        @overload
-        def create_window_function(
-            self, __name: str, __num_params: Literal[1], __aggregate_class: Callable[[], _SingleParamWindowAggregateClass] | None
-        ) -> None: ...
-        # And for num_params = -1, which means the aggregate must accept any number of parameters.
-        @overload
-        def create_window_function(
-            self, __name: str, __num_params: Literal[-1], __aggregate_class: Callable[[], _AnyParamWindowAggregateClass] | None
-        ) -> None: ...
-        @overload
-        def create_window_function(
-            self, __name: str, __num_params: int, __aggregate_class: Callable[[], _WindowAggregateClass] | None
-        ) -> None: ...
-
-    def create_collation(self, __name: str, __callback: Callable[[str, str], int | SupportsIndex] | None) -> None: ...
-    if sys.version_info >= (3, 8):
-        def create_function(
-            self, name: str, narg: int, func: Callable[..., _SqliteData] | None, *, deterministic: bool = False
-        ) -> None: ...
-    else:
-        def create_function(self, name: str, num_params: int, func: Callable[..., _SqliteData] | None) -> None: ...
-
-    @overload
-    def cursor(self, cursorClass: None = None) -> Cursor: ...
-    @overload
-    def cursor(self, cursorClass: Callable[[], _CursorT]) -> _CursorT: ...
-    def execute(self, sql: str, parameters: _Parameters = ...) -> Cursor: ...
-    def executemany(self, __sql: str, __parameters: Iterable[_Parameters]) -> Cursor: ...
-    def executescript(self, __sql_script: str) -> Cursor: ...
-    def interrupt(self) -> None: ...
-    def iterdump(self) -> Generator[str, None, None]: ...
-    def rollback(self) -> None: ...
-    def set_authorizer(
-        self, authorizer_callback: Callable[[int, str | None, str | None, str | None, str | None], int] | None
-    ) -> None: ...
-    def set_progress_handler(self, progress_handler: Callable[[], int | None] | None, n: int) -> None: ...
-    def set_trace_callback(self, trace_callback: Callable[[str], object] | None) -> None: ...
-    # enable_load_extension and load_extension is not available on python distributions compiled
-    # without sqlite3 loadable extension support. see footnotes https://docs.python.org/3/library/sqlite3.html#f1
-    def enable_load_extension(self, __enable: bool) -> None: ...
-    def load_extension(self, __name: str) -> None: ...
-    def backup(
-        self,
-        target: Connection,
-        *,
-        pages: int = -1,
-        progress: Callable[[int, int, int], object] | None = None,
-        name: str = "main",
-        sleep: float = 0.25,
-    ) -> None: ...
-    if sys.version_info >= (3, 11):
-        def setlimit(self, __category: int, __limit: int) -> int: ...
-        def getlimit(self, __category: int) -> int: ...
-        def serialize(self, *, name: str = "main") -> bytes: ...
-        def deserialize(self, __data: ReadableBuffer, *, name: str = "main") -> None: ...
-
-    def __call__(self, __sql: str) -> _Statement: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, __type: type[BaseException] | None, __value: BaseException | None, __traceback: TracebackType | None
-    ) -> Literal[False]: ...
-
-class Cursor(Iterator[Any]):
-    arraysize: int
-    @property
-    def connection(self) -> Connection: ...
-    # May be None, but using | Any instead to avoid slightly annoying false positives.
-    @property
-    def description(self) -> tuple[tuple[str, None, None, None, None, None, None], ...] | Any: ...
-    @property
-    def lastrowid(self) -> int | None: ...
-    row_factory: Callable[[Cursor, Row], object] | None
-    @property
-    def rowcount(self) -> int: ...
-    def __init__(self, __cursor: Connection) -> None: ...
-    def close(self) -> None: ...
-    def execute(self, __sql: str, __parameters: _Parameters = ()) -> Self: ...
-    def executemany(self, __sql: str, __seq_of_parameters: Iterable[_Parameters]) -> Self: ...
-    def executescript(self, __sql_script: str) -> Cursor: ...
-    def fetchall(self) -> list[Any]: ...
-    def fetchmany(self, size: int | None = 1) -> list[Any]: ...
-    # Returns either a row (as created by the row_factory) or None, but
-    # putting None in the return annotation causes annoying false positives.
-    def fetchone(self) -> Any: ...
-    def setinputsizes(self, __sizes: Unused) -> None: ...  # does nothing
-    def setoutputsize(self, __size: Unused, __column: Unused = None) -> None: ...  # does nothing
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> Any: ...
-
-class Error(Exception):
-    if sys.version_info >= (3, 11):
-        sqlite_errorcode: int
-        sqlite_errorname: str
-
-class DatabaseError(Error): ...
-class DataError(DatabaseError): ...
-class IntegrityError(DatabaseError): ...
-class InterfaceError(Error): ...
-class InternalError(DatabaseError): ...
-class NotSupportedError(DatabaseError): ...
-class OperationalError(DatabaseError): ...
-
-if sys.version_info < (3, 10):
-    OptimizedUnicode = str
-
-@final
-class PrepareProtocol:
-    def __init__(self, *args: object, **kwargs: object) -> None: ...
-
-class ProgrammingError(DatabaseError): ...
-
-class Row:
-    def __init__(self, __cursor: Cursor, __data: tuple[Any, ...]) -> None: ...
-    def keys(self) -> list[str]: ...
-    @overload
-    def __getitem__(self, __key: int | str) -> Any: ...
-    @overload
-    def __getitem__(self, __key: slice) -> tuple[Any, ...]: ...
-    def __iter__(self) -> Iterator[Any]: ...
-    def __len__(self) -> int: ...
-    # These return NotImplemented for anything that is not a Row.
-    def __eq__(self, __value: object) -> bool: ...
-    def __ge__(self, __value: object) -> bool: ...
-    def __gt__(self, __value: object) -> bool: ...
-    def __le__(self, __value: object) -> bool: ...
-    def __lt__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
-
-if sys.version_info >= (3, 8):
-    @final
-    class _Statement: ...
-
-else:
-    @final
-    class Statement:
-        def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ...
-    _Statement: TypeAlias = Statement
-
-class Warning(Exception): ...
-
-if sys.version_info >= (3, 11):
-    @final
-    class Blob:
-        def close(self) -> None: ...
-        def read(self, __length: int = -1) -> bytes: ...
-        def write(self, __data: ReadableBuffer) -> None: ...
-        def tell(self) -> int: ...
-        # whence must be one of os.SEEK_SET, os.SEEK_CUR, os.SEEK_END
-        def seek(self, __offset: int, __origin: int = 0) -> None: ...
-        def __len__(self) -> int: ...
-        def __enter__(self) -> Self: ...
-        def __exit__(self, __type: object, __val: object, __tb: object) -> Literal[False]: ...
-        def __getitem__(self, __key: SupportsIndex | slice) -> int: ...
-        def __setitem__(self, __key: SupportsIndex | slice, __value: int) -> None: ...
diff --git a/mypy/typeshed/stdlib/sqlite3/dump.pyi b/mypy/typeshed/stdlib/sqlite3/dump.pyi
new file mode 100644
index 000000000000..ed95fa46e1c7
--- /dev/null
+++ b/mypy/typeshed/stdlib/sqlite3/dump.pyi
@@ -0,0 +1,2 @@
+# This file is intentionally empty. The runtime module contains only
+# private functions.
diff --git a/mypy/typeshed/stdlib/sre_constants.pyi b/mypy/typeshed/stdlib/sre_constants.pyi
index d522372c438c..c41a52b26d5a 100644
--- a/mypy/typeshed/stdlib/sre_constants.pyi
+++ b/mypy/typeshed/stdlib/sre_constants.pyi
@@ -1,24 +1,17 @@
 import sys
-from typing import Any
+from re import error as error
+from typing import Final
 from typing_extensions import Self
 
-MAXGROUPS: int
+MAXGROUPS: Final[int]
 
-MAGIC: int
-
-class error(Exception):
-    msg: str
-    pattern: str | bytes | None
-    pos: int | None
-    lineno: int
-    colno: int
-    def __init__(self, msg: str, pattern: str | bytes | None = None, pos: int | None = None) -> None: ...
+MAGIC: Final[int]
 
 class _NamedIntConstant(int):
-    name: Any
+    name: str
     def __new__(cls, value: int, name: str) -> Self: ...
 
-MAXREPEAT: _NamedIntConstant
+MAXREPEAT: Final[_NamedIntConstant]
 OPCODES: list[_NamedIntConstant]
 ATCODES: list[_NamedIntConstant]
 CHCODES: list[_NamedIntConstant]
@@ -30,101 +23,104 @@ AT_LOCALE: dict[_NamedIntConstant, _NamedIntConstant]
 AT_UNICODE: dict[_NamedIntConstant, _NamedIntConstant]
 CH_LOCALE: dict[_NamedIntConstant, _NamedIntConstant]
 CH_UNICODE: dict[_NamedIntConstant, _NamedIntConstant]
-SRE_FLAG_TEMPLATE: int
-SRE_FLAG_IGNORECASE: int
-SRE_FLAG_LOCALE: int
-SRE_FLAG_MULTILINE: int
-SRE_FLAG_DOTALL: int
-SRE_FLAG_UNICODE: int
-SRE_FLAG_VERBOSE: int
-SRE_FLAG_DEBUG: int
-SRE_FLAG_ASCII: int
-SRE_INFO_PREFIX: int
-SRE_INFO_LITERAL: int
-SRE_INFO_CHARSET: int
+# flags
+if sys.version_info < (3, 13):
+    SRE_FLAG_TEMPLATE: Final = 1
+SRE_FLAG_IGNORECASE: Final = 2
+SRE_FLAG_LOCALE: Final = 4
+SRE_FLAG_MULTILINE: Final = 8
+SRE_FLAG_DOTALL: Final = 16
+SRE_FLAG_UNICODE: Final = 32
+SRE_FLAG_VERBOSE: Final = 64
+SRE_FLAG_DEBUG: Final = 128
+SRE_FLAG_ASCII: Final = 256
+# flags for INFO primitive
+SRE_INFO_PREFIX: Final = 1
+SRE_INFO_LITERAL: Final = 2
+SRE_INFO_CHARSET: Final = 4
 
 # Stubgen above; manually defined constants below (dynamic at runtime)
 
 # from OPCODES
-FAILURE: _NamedIntConstant
-SUCCESS: _NamedIntConstant
-ANY: _NamedIntConstant
-ANY_ALL: _NamedIntConstant
-ASSERT: _NamedIntConstant
-ASSERT_NOT: _NamedIntConstant
-AT: _NamedIntConstant
-BRANCH: _NamedIntConstant
+FAILURE: Final[_NamedIntConstant]
+SUCCESS: Final[_NamedIntConstant]
+ANY: Final[_NamedIntConstant]
+ANY_ALL: Final[_NamedIntConstant]
+ASSERT: Final[_NamedIntConstant]
+ASSERT_NOT: Final[_NamedIntConstant]
+AT: Final[_NamedIntConstant]
+BRANCH: Final[_NamedIntConstant]
 if sys.version_info < (3, 11):
-    CALL: _NamedIntConstant
-CATEGORY: _NamedIntConstant
-CHARSET: _NamedIntConstant
-BIGCHARSET: _NamedIntConstant
-GROUPREF: _NamedIntConstant
-GROUPREF_EXISTS: _NamedIntConstant
-GROUPREF_IGNORE: _NamedIntConstant
-IN: _NamedIntConstant
-IN_IGNORE: _NamedIntConstant
-INFO: _NamedIntConstant
-JUMP: _NamedIntConstant
-LITERAL: _NamedIntConstant
-LITERAL_IGNORE: _NamedIntConstant
-MARK: _NamedIntConstant
-MAX_UNTIL: _NamedIntConstant
-MIN_UNTIL: _NamedIntConstant
-NOT_LITERAL: _NamedIntConstant
-NOT_LITERAL_IGNORE: _NamedIntConstant
-NEGATE: _NamedIntConstant
-RANGE: _NamedIntConstant
-REPEAT: _NamedIntConstant
-REPEAT_ONE: _NamedIntConstant
-SUBPATTERN: _NamedIntConstant
-MIN_REPEAT_ONE: _NamedIntConstant
+    CALL: Final[_NamedIntConstant]
+CATEGORY: Final[_NamedIntConstant]
+CHARSET: Final[_NamedIntConstant]
+BIGCHARSET: Final[_NamedIntConstant]
+GROUPREF: Final[_NamedIntConstant]
+GROUPREF_EXISTS: Final[_NamedIntConstant]
+GROUPREF_IGNORE: Final[_NamedIntConstant]
+IN: Final[_NamedIntConstant]
+IN_IGNORE: Final[_NamedIntConstant]
+INFO: Final[_NamedIntConstant]
+JUMP: Final[_NamedIntConstant]
+LITERAL: Final[_NamedIntConstant]
+LITERAL_IGNORE: Final[_NamedIntConstant]
+MARK: Final[_NamedIntConstant]
+MAX_UNTIL: Final[_NamedIntConstant]
+MIN_UNTIL: Final[_NamedIntConstant]
+NOT_LITERAL: Final[_NamedIntConstant]
+NOT_LITERAL_IGNORE: Final[_NamedIntConstant]
+NEGATE: Final[_NamedIntConstant]
+RANGE: Final[_NamedIntConstant]
+REPEAT: Final[_NamedIntConstant]
+REPEAT_ONE: Final[_NamedIntConstant]
+SUBPATTERN: Final[_NamedIntConstant]
+MIN_REPEAT_ONE: Final[_NamedIntConstant]
 if sys.version_info >= (3, 11):
-    ATOMIC_GROUP: _NamedIntConstant
-    POSSESSIVE_REPEAT: _NamedIntConstant
-    POSSESSIVE_REPEAT_ONE: _NamedIntConstant
-RANGE_UNI_IGNORE: _NamedIntConstant
-GROUPREF_LOC_IGNORE: _NamedIntConstant
-GROUPREF_UNI_IGNORE: _NamedIntConstant
-IN_LOC_IGNORE: _NamedIntConstant
-IN_UNI_IGNORE: _NamedIntConstant
-LITERAL_LOC_IGNORE: _NamedIntConstant
-LITERAL_UNI_IGNORE: _NamedIntConstant
-NOT_LITERAL_LOC_IGNORE: _NamedIntConstant
-NOT_LITERAL_UNI_IGNORE: _NamedIntConstant
-MIN_REPEAT: _NamedIntConstant
-MAX_REPEAT: _NamedIntConstant
+    ATOMIC_GROUP: Final[_NamedIntConstant]
+    POSSESSIVE_REPEAT: Final[_NamedIntConstant]
+    POSSESSIVE_REPEAT_ONE: Final[_NamedIntConstant]
+RANGE_UNI_IGNORE: Final[_NamedIntConstant]
+GROUPREF_LOC_IGNORE: Final[_NamedIntConstant]
+GROUPREF_UNI_IGNORE: Final[_NamedIntConstant]
+IN_LOC_IGNORE: Final[_NamedIntConstant]
+IN_UNI_IGNORE: Final[_NamedIntConstant]
+LITERAL_LOC_IGNORE: Final[_NamedIntConstant]
+LITERAL_UNI_IGNORE: Final[_NamedIntConstant]
+NOT_LITERAL_LOC_IGNORE: Final[_NamedIntConstant]
+NOT_LITERAL_UNI_IGNORE: Final[_NamedIntConstant]
+MIN_REPEAT: Final[_NamedIntConstant]
+MAX_REPEAT: Final[_NamedIntConstant]
 
 # from ATCODES
-AT_BEGINNING: _NamedIntConstant
-AT_BEGINNING_LINE: _NamedIntConstant
-AT_BEGINNING_STRING: _NamedIntConstant
-AT_BOUNDARY: _NamedIntConstant
-AT_NON_BOUNDARY: _NamedIntConstant
-AT_END: _NamedIntConstant
-AT_END_LINE: _NamedIntConstant
-AT_END_STRING: _NamedIntConstant
-AT_LOC_BOUNDARY: _NamedIntConstant
-AT_LOC_NON_BOUNDARY: _NamedIntConstant
-AT_UNI_BOUNDARY: _NamedIntConstant
-AT_UNI_NON_BOUNDARY: _NamedIntConstant
+AT_BEGINNING: Final[_NamedIntConstant]
+AT_BEGINNING_LINE: Final[_NamedIntConstant]
+AT_BEGINNING_STRING: Final[_NamedIntConstant]
+AT_BOUNDARY: Final[_NamedIntConstant]
+AT_NON_BOUNDARY: Final[_NamedIntConstant]
+AT_END: Final[_NamedIntConstant]
+AT_END_LINE: Final[_NamedIntConstant]
+AT_END_STRING: Final[_NamedIntConstant]
+AT_LOC_BOUNDARY: Final[_NamedIntConstant]
+AT_LOC_NON_BOUNDARY: Final[_NamedIntConstant]
+AT_UNI_BOUNDARY: Final[_NamedIntConstant]
+AT_UNI_NON_BOUNDARY: Final[_NamedIntConstant]
 
 # from CHCODES
-CATEGORY_DIGIT: _NamedIntConstant
-CATEGORY_NOT_DIGIT: _NamedIntConstant
-CATEGORY_SPACE: _NamedIntConstant
-CATEGORY_NOT_SPACE: _NamedIntConstant
-CATEGORY_WORD: _NamedIntConstant
-CATEGORY_NOT_WORD: _NamedIntConstant
-CATEGORY_LINEBREAK: _NamedIntConstant
-CATEGORY_NOT_LINEBREAK: _NamedIntConstant
-CATEGORY_LOC_WORD: _NamedIntConstant
-CATEGORY_LOC_NOT_WORD: _NamedIntConstant
-CATEGORY_UNI_DIGIT: _NamedIntConstant
-CATEGORY_UNI_NOT_DIGIT: _NamedIntConstant
-CATEGORY_UNI_SPACE: _NamedIntConstant
-CATEGORY_UNI_NOT_SPACE: _NamedIntConstant
-CATEGORY_UNI_WORD: _NamedIntConstant
-CATEGORY_UNI_NOT_WORD: _NamedIntConstant
-CATEGORY_UNI_LINEBREAK: _NamedIntConstant
-CATEGORY_UNI_NOT_LINEBREAK: _NamedIntConstant
+CATEGORY_DIGIT: Final[_NamedIntConstant]
+CATEGORY_NOT_DIGIT: Final[_NamedIntConstant]
+CATEGORY_SPACE: Final[_NamedIntConstant]
+CATEGORY_NOT_SPACE: Final[_NamedIntConstant]
+CATEGORY_WORD: Final[_NamedIntConstant]
+CATEGORY_NOT_WORD: Final[_NamedIntConstant]
+CATEGORY_LINEBREAK: Final[_NamedIntConstant]
+CATEGORY_NOT_LINEBREAK: Final[_NamedIntConstant]
+CATEGORY_LOC_WORD: Final[_NamedIntConstant]
+CATEGORY_LOC_NOT_WORD: Final[_NamedIntConstant]
+CATEGORY_UNI_DIGIT: Final[_NamedIntConstant]
+CATEGORY_UNI_NOT_DIGIT: Final[_NamedIntConstant]
+CATEGORY_UNI_SPACE: Final[_NamedIntConstant]
+CATEGORY_UNI_NOT_SPACE: Final[_NamedIntConstant]
+CATEGORY_UNI_WORD: Final[_NamedIntConstant]
+CATEGORY_UNI_NOT_WORD: Final[_NamedIntConstant]
+CATEGORY_UNI_LINEBREAK: Final[_NamedIntConstant]
+CATEGORY_UNI_NOT_LINEBREAK: Final[_NamedIntConstant]
diff --git a/mypy/typeshed/stdlib/sre_parse.pyi b/mypy/typeshed/stdlib/sre_parse.pyi
index 56f10bb41d57..c242bd2a065f 100644
--- a/mypy/typeshed/stdlib/sre_parse.pyi
+++ b/mypy/typeshed/stdlib/sre_parse.pyi
@@ -19,10 +19,20 @@ FLAGS: dict[str, int]
 TYPE_FLAGS: int
 GLOBAL_FLAGS: int
 
+if sys.version_info >= (3, 11):
+    MAXWIDTH: int
+
 if sys.version_info < (3, 11):
     class Verbose(Exception): ...
 
-class _State:
+_OpSubpatternType: TypeAlias = tuple[int | None, int, int, SubPattern]
+_OpGroupRefExistsType: TypeAlias = tuple[int, SubPattern, SubPattern]
+_OpInType: TypeAlias = list[tuple[_NIC, int]]
+_OpBranchType: TypeAlias = tuple[None, list[SubPattern]]
+_AvType: TypeAlias = _OpInType | _OpBranchType | Iterable[SubPattern] | _OpGroupRefExistsType | _OpSubpatternType
+_CodeType: TypeAlias = tuple[_NIC, _AvType]
+
+class State:
     flags: int
     groupdict: dict[str, int]
     groupwidths: list[int | None]
@@ -34,29 +44,12 @@ class _State:
     def checkgroup(self, gid: int) -> bool: ...
     def checklookbehindgroup(self, gid: int, source: Tokenizer) -> None: ...
 
-if sys.version_info >= (3, 8):
-    State: TypeAlias = _State
-else:
-    Pattern: TypeAlias = _State
-
-_OpSubpatternType: TypeAlias = tuple[int | None, int, int, SubPattern]
-_OpGroupRefExistsType: TypeAlias = tuple[int, SubPattern, SubPattern]
-_OpInType: TypeAlias = list[tuple[_NIC, int]]
-_OpBranchType: TypeAlias = tuple[None, list[SubPattern]]
-_AvType: TypeAlias = _OpInType | _OpBranchType | Iterable[SubPattern] | _OpGroupRefExistsType | _OpSubpatternType
-_CodeType: TypeAlias = tuple[_NIC, _AvType]
-
 class SubPattern:
     data: list[_CodeType]
     width: int | None
+    state: State
 
-    if sys.version_info >= (3, 8):
-        state: State
-        def __init__(self, state: State, data: list[_CodeType] | None = None) -> None: ...
-    else:
-        pattern: Pattern
-        def __init__(self, pattern: Pattern, data: list[_CodeType] | None = None) -> None: ...
-
+    def __init__(self, state: State, data: list[_CodeType] | None = None) -> None: ...
     def dump(self, level: int = 0) -> None: ...
     def __len__(self) -> int: ...
     def __delitem__(self, index: int | slice) -> None: ...
@@ -76,36 +69,36 @@ class Tokenizer:
     def match(self, char: str) -> bool: ...
     def get(self) -> str | None: ...
     def getwhile(self, n: int, charset: Iterable[str]) -> str: ...
-    if sys.version_info >= (3, 8):
-        def getuntil(self, terminator: str, name: str) -> str: ...
-    else:
-        def getuntil(self, terminator: str) -> str: ...
-
+    def getuntil(self, terminator: str, name: str) -> str: ...
     @property
     def pos(self) -> int: ...
     def tell(self) -> int: ...
     def seek(self, index: int) -> None: ...
     def error(self, msg: str, offset: int = 0) -> _Error: ...
 
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 12):
+        def checkgroupname(self, name: str, offset: int) -> None: ...
+    elif sys.version_info >= (3, 11):
         def checkgroupname(self, name: str, offset: int, nested: int) -> None: ...
 
 def fix_flags(src: str | bytes, flags: int) -> int: ...
 
 _TemplateType: TypeAlias = tuple[list[tuple[int, int]], list[str | None]]
 _TemplateByteType: TypeAlias = tuple[list[tuple[int, int]], list[bytes | None]]
-if sys.version_info >= (3, 8):
-    def parse(str: str, flags: int = 0, state: State | None = None) -> SubPattern: ...
+
+if sys.version_info >= (3, 12):
     @overload
-    def parse_template(source: str, state: _Pattern[Any]) -> _TemplateType: ...
+    def parse_template(source: str, pattern: _Pattern[Any]) -> _TemplateType: ...
     @overload
-    def parse_template(source: bytes, state: _Pattern[Any]) -> _TemplateByteType: ...
+    def parse_template(source: bytes, pattern: _Pattern[Any]) -> _TemplateByteType: ...
 
 else:
-    def parse(str: str, flags: int = 0, pattern: Pattern | None = None) -> SubPattern: ...
     @overload
-    def parse_template(source: str, pattern: _Pattern[Any]) -> _TemplateType: ...
+    def parse_template(source: str, state: _Pattern[Any]) -> _TemplateType: ...
     @overload
-    def parse_template(source: bytes, pattern: _Pattern[Any]) -> _TemplateByteType: ...
+    def parse_template(source: bytes, state: _Pattern[Any]) -> _TemplateByteType: ...
+
+def parse(str: str, flags: int = 0, state: State | None = None) -> SubPattern: ...
 
-def expand_template(template: _TemplateType, match: Match[Any]) -> str: ...
+if sys.version_info < (3, 12):
+    def expand_template(template: _TemplateType, match: Match[Any]) -> str: ...
diff --git a/mypy/typeshed/stdlib/ssl.pyi b/mypy/typeshed/stdlib/ssl.pyi
index 20b8802bd7b9..388e521c1ef5 100644
--- a/mypy/typeshed/stdlib/ssl.pyi
+++ b/mypy/typeshed/stdlib/ssl.pyi
@@ -1,20 +1,55 @@
 import enum
 import socket
 import sys
+from _ssl import (
+    _DEFAULT_CIPHERS as _DEFAULT_CIPHERS,
+    _OPENSSL_API_VERSION as _OPENSSL_API_VERSION,
+    HAS_ALPN as HAS_ALPN,
+    HAS_ECDH as HAS_ECDH,
+    HAS_NPN as HAS_NPN,
+    HAS_SNI as HAS_SNI,
+    OPENSSL_VERSION as OPENSSL_VERSION,
+    OPENSSL_VERSION_INFO as OPENSSL_VERSION_INFO,
+    OPENSSL_VERSION_NUMBER as OPENSSL_VERSION_NUMBER,
+    HAS_SSLv2 as HAS_SSLv2,
+    HAS_SSLv3 as HAS_SSLv3,
+    HAS_TLSv1 as HAS_TLSv1,
+    HAS_TLSv1_1 as HAS_TLSv1_1,
+    HAS_TLSv1_2 as HAS_TLSv1_2,
+    HAS_TLSv1_3 as HAS_TLSv1_3,
+    MemoryBIO as MemoryBIO,
+    RAND_add as RAND_add,
+    RAND_bytes as RAND_bytes,
+    RAND_status as RAND_status,
+    SSLSession as SSLSession,
+    _PasswordType as _PasswordType,  # typeshed only, but re-export for other type stubs to use
+    _SSLContext,
+)
 from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
 from collections.abc import Callable, Iterable
-from typing import Any, NamedTuple, overload
-from typing_extensions import Literal, Self, TypeAlias, TypedDict, final
+from typing import Any, Literal, NamedTuple, TypedDict, overload, type_check_only
+from typing_extensions import Never, Self, TypeAlias
+
+if sys.version_info >= (3, 13):
+    from _ssl import HAS_PSK as HAS_PSK
+
+if sys.version_info < (3, 12):
+    from _ssl import RAND_pseudo_bytes as RAND_pseudo_bytes
+
+if sys.version_info < (3, 10):
+    from _ssl import RAND_egd as RAND_egd
+
+if sys.platform == "win32":
+    from _ssl import enum_certificates as enum_certificates, enum_crls as enum_crls
 
 _PCTRTT: TypeAlias = tuple[tuple[str, str], ...]
 _PCTRTTT: TypeAlias = tuple[_PCTRTT, ...]
 _PeerCertRetDictType: TypeAlias = dict[str, str | _PCTRTTT | _PCTRTT]
 _PeerCertRetType: TypeAlias = _PeerCertRetDictType | bytes | None
-_EnumRetType: TypeAlias = list[tuple[bytes, str, set[str] | bool]]
-_PasswordType: TypeAlias = Callable[[], str | bytes | bytearray] | str | bytes | bytearray
-
 _SrvnmeCbType: TypeAlias = Callable[[SSLSocket | SSLObject, str | None, SSLSocket], int | None]
 
+socket_error = OSError
+
 class _Cipher(TypedDict):
     aead: bool
     alg_bits: int
@@ -44,18 +79,20 @@ class SSLCertVerificationError(SSLError, ValueError):
 
 CertificateError = SSLCertVerificationError
 
-def wrap_socket(
-    sock: socket.socket,
-    keyfile: StrOrBytesPath | None = None,
-    certfile: StrOrBytesPath | None = None,
-    server_side: bool = False,
-    cert_reqs: int = ...,
-    ssl_version: int = ...,
-    ca_certs: str | None = None,
-    do_handshake_on_connect: bool = True,
-    suppress_ragged_eofs: bool = True,
-    ciphers: str | None = None,
-) -> SSLSocket: ...
+if sys.version_info < (3, 12):
+    def wrap_socket(
+        sock: socket.socket,
+        keyfile: StrOrBytesPath | None = None,
+        certfile: StrOrBytesPath | None = None,
+        server_side: bool = False,
+        cert_reqs: int = ...,
+        ssl_version: int = ...,
+        ca_certs: str | None = None,
+        do_handshake_on_connect: bool = True,
+        suppress_ragged_eofs: bool = True,
+        ciphers: str | None = None,
+    ) -> SSLSocket: ...
+
 def create_default_context(
     purpose: Purpose = ...,
     *,
@@ -94,12 +131,6 @@ else:
 
 _create_default_https_context: Callable[..., SSLContext]
 
-def RAND_bytes(__n: int) -> bytes: ...
-def RAND_pseudo_bytes(__n: int) -> tuple[bytes, bool]: ...
-def RAND_status() -> bool: ...
-def RAND_egd(path: str) -> None: ...
-def RAND_add(__string: str | ReadableBuffer, __entropy: float) -> None: ...
-
 if sys.version_info < (3, 12):
     def match_hostname(cert: _PeerCertRetDictType, hostname: str) -> None: ...
 
@@ -126,28 +157,24 @@ class DefaultVerifyPaths(NamedTuple):
 
 def get_default_verify_paths() -> DefaultVerifyPaths: ...
 
-if sys.platform == "win32":
-    def enum_certificates(store_name: str) -> _EnumRetType: ...
-    def enum_crls(store_name: str) -> _EnumRetType: ...
-
 class VerifyMode(enum.IntEnum):
-    CERT_NONE: int
-    CERT_OPTIONAL: int
-    CERT_REQUIRED: int
+    CERT_NONE = 0
+    CERT_OPTIONAL = 1
+    CERT_REQUIRED = 2
 
 CERT_NONE: VerifyMode
 CERT_OPTIONAL: VerifyMode
 CERT_REQUIRED: VerifyMode
 
 class VerifyFlags(enum.IntFlag):
-    VERIFY_DEFAULT: int
-    VERIFY_CRL_CHECK_LEAF: int
-    VERIFY_CRL_CHECK_CHAIN: int
-    VERIFY_X509_STRICT: int
-    VERIFY_X509_TRUSTED_FIRST: int
+    VERIFY_DEFAULT = 0
+    VERIFY_CRL_CHECK_LEAF = 4
+    VERIFY_CRL_CHECK_CHAIN = 12
+    VERIFY_X509_STRICT = 32
+    VERIFY_X509_TRUSTED_FIRST = 32768
     if sys.version_info >= (3, 10):
-        VERIFY_ALLOW_PROXY_CERTS: int
-        VERIFY_X509_PARTIAL_CHAIN: int
+        VERIFY_ALLOW_PROXY_CERTS = 64
+        VERIFY_X509_PARTIAL_CHAIN = 524288
 
 VERIFY_DEFAULT: VerifyFlags
 VERIFY_CRL_CHECK_LEAF: VerifyFlags
@@ -160,15 +187,15 @@ if sys.version_info >= (3, 10):
     VERIFY_X509_PARTIAL_CHAIN: VerifyFlags
 
 class _SSLMethod(enum.IntEnum):
-    PROTOCOL_SSLv23: int
-    PROTOCOL_SSLv2: int
-    PROTOCOL_SSLv3: int
-    PROTOCOL_TLSv1: int
-    PROTOCOL_TLSv1_1: int
-    PROTOCOL_TLSv1_2: int
-    PROTOCOL_TLS: int
-    PROTOCOL_TLS_CLIENT: int
-    PROTOCOL_TLS_SERVER: int
+    PROTOCOL_SSLv23 = 2
+    PROTOCOL_SSLv2 = ...
+    PROTOCOL_SSLv3 = ...
+    PROTOCOL_TLSv1 = 3
+    PROTOCOL_TLSv1_1 = 4
+    PROTOCOL_TLSv1_2 = 5
+    PROTOCOL_TLS = 2
+    PROTOCOL_TLS_CLIENT = 16
+    PROTOCOL_TLS_SERVER = 17
 
 PROTOCOL_SSLv23: _SSLMethod
 PROTOCOL_SSLv2: _SSLMethod
@@ -181,23 +208,25 @@ PROTOCOL_TLS_CLIENT: _SSLMethod
 PROTOCOL_TLS_SERVER: _SSLMethod
 
 class Options(enum.IntFlag):
-    OP_ALL: int
-    OP_NO_SSLv2: int
-    OP_NO_SSLv3: int
-    OP_NO_TLSv1: int
-    OP_NO_TLSv1_1: int
-    OP_NO_TLSv1_2: int
-    OP_NO_TLSv1_3: int
-    OP_CIPHER_SERVER_PREFERENCE: int
-    OP_SINGLE_DH_USE: int
-    OP_SINGLE_ECDH_USE: int
-    OP_NO_COMPRESSION: int
-    OP_NO_TICKET: int
-    OP_NO_RENEGOTIATION: int
-    if sys.version_info >= (3, 8):
-        OP_ENABLE_MIDDLEBOX_COMPAT: int
-        if sys.platform == "linux":
-            OP_IGNORE_UNEXPECTED_EOF: int
+    OP_ALL = 2147483728
+    OP_NO_SSLv2 = 0
+    OP_NO_SSLv3 = 33554432
+    OP_NO_TLSv1 = 67108864
+    OP_NO_TLSv1_1 = 268435456
+    OP_NO_TLSv1_2 = 134217728
+    OP_NO_TLSv1_3 = 536870912
+    OP_CIPHER_SERVER_PREFERENCE = 4194304
+    OP_SINGLE_DH_USE = 0
+    OP_SINGLE_ECDH_USE = 0
+    OP_NO_COMPRESSION = 131072
+    OP_NO_TICKET = 16384
+    OP_NO_RENEGOTIATION = 1073741824
+    OP_ENABLE_MIDDLEBOX_COMPAT = 1048576
+    if sys.version_info >= (3, 12):
+        OP_LEGACY_SERVER_CONNECT = 4
+        OP_ENABLE_KTLS = 8
+    if sys.version_info >= (3, 11) or sys.platform == "linux":
+        OP_IGNORE_UNEXPECTED_EOF = 128
 
 OP_ALL: Options
 OP_NO_SSLv2: Options
@@ -212,56 +241,45 @@ OP_SINGLE_ECDH_USE: Options
 OP_NO_COMPRESSION: Options
 OP_NO_TICKET: Options
 OP_NO_RENEGOTIATION: Options
-if sys.version_info >= (3, 8):
-    OP_ENABLE_MIDDLEBOX_COMPAT: Options
-    if sys.platform == "linux":
-        OP_IGNORE_UNEXPECTED_EOF: Options
+OP_ENABLE_MIDDLEBOX_COMPAT: Options
+if sys.version_info >= (3, 12):
+    OP_LEGACY_SERVER_CONNECT: Options
+    OP_ENABLE_KTLS: Options
+if sys.version_info >= (3, 11) or sys.platform == "linux":
+    OP_IGNORE_UNEXPECTED_EOF: Options
 
 HAS_NEVER_CHECK_COMMON_NAME: bool
-HAS_SSLv2: bool
-HAS_SSLv3: bool
-HAS_TLSv1: bool
-HAS_TLSv1_1: bool
-HAS_TLSv1_2: bool
-HAS_TLSv1_3: bool
-HAS_ALPN: bool
-HAS_ECDH: bool
-HAS_SNI: bool
-HAS_NPN: bool
-CHANNEL_BINDING_TYPES: list[str]
 
-OPENSSL_VERSION: str
-OPENSSL_VERSION_INFO: tuple[int, int, int, int, int]
-OPENSSL_VERSION_NUMBER: int
+CHANNEL_BINDING_TYPES: list[str]
 
 class AlertDescription(enum.IntEnum):
-    ALERT_DESCRIPTION_ACCESS_DENIED: int
-    ALERT_DESCRIPTION_BAD_CERTIFICATE: int
-    ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE: int
-    ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE: int
-    ALERT_DESCRIPTION_BAD_RECORD_MAC: int
-    ALERT_DESCRIPTION_CERTIFICATE_EXPIRED: int
-    ALERT_DESCRIPTION_CERTIFICATE_REVOKED: int
-    ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN: int
-    ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE: int
-    ALERT_DESCRIPTION_CLOSE_NOTIFY: int
-    ALERT_DESCRIPTION_DECODE_ERROR: int
-    ALERT_DESCRIPTION_DECOMPRESSION_FAILURE: int
-    ALERT_DESCRIPTION_DECRYPT_ERROR: int
-    ALERT_DESCRIPTION_HANDSHAKE_FAILURE: int
-    ALERT_DESCRIPTION_ILLEGAL_PARAMETER: int
-    ALERT_DESCRIPTION_INSUFFICIENT_SECURITY: int
-    ALERT_DESCRIPTION_INTERNAL_ERROR: int
-    ALERT_DESCRIPTION_NO_RENEGOTIATION: int
-    ALERT_DESCRIPTION_PROTOCOL_VERSION: int
-    ALERT_DESCRIPTION_RECORD_OVERFLOW: int
-    ALERT_DESCRIPTION_UNEXPECTED_MESSAGE: int
-    ALERT_DESCRIPTION_UNKNOWN_CA: int
-    ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY: int
-    ALERT_DESCRIPTION_UNRECOGNIZED_NAME: int
-    ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE: int
-    ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION: int
-    ALERT_DESCRIPTION_USER_CANCELLED: int
+    ALERT_DESCRIPTION_ACCESS_DENIED = 49
+    ALERT_DESCRIPTION_BAD_CERTIFICATE = 42
+    ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE = 114
+    ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE = 113
+    ALERT_DESCRIPTION_BAD_RECORD_MAC = 20
+    ALERT_DESCRIPTION_CERTIFICATE_EXPIRED = 45
+    ALERT_DESCRIPTION_CERTIFICATE_REVOKED = 44
+    ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN = 46
+    ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE = 111
+    ALERT_DESCRIPTION_CLOSE_NOTIFY = 0
+    ALERT_DESCRIPTION_DECODE_ERROR = 50
+    ALERT_DESCRIPTION_DECOMPRESSION_FAILURE = 30
+    ALERT_DESCRIPTION_DECRYPT_ERROR = 51
+    ALERT_DESCRIPTION_HANDSHAKE_FAILURE = 40
+    ALERT_DESCRIPTION_ILLEGAL_PARAMETER = 47
+    ALERT_DESCRIPTION_INSUFFICIENT_SECURITY = 71
+    ALERT_DESCRIPTION_INTERNAL_ERROR = 80
+    ALERT_DESCRIPTION_NO_RENEGOTIATION = 100
+    ALERT_DESCRIPTION_PROTOCOL_VERSION = 70
+    ALERT_DESCRIPTION_RECORD_OVERFLOW = 22
+    ALERT_DESCRIPTION_UNEXPECTED_MESSAGE = 10
+    ALERT_DESCRIPTION_UNKNOWN_CA = 48
+    ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY = 115
+    ALERT_DESCRIPTION_UNRECOGNIZED_NAME = 112
+    ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE = 43
+    ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION = 110
+    ALERT_DESCRIPTION_USER_CANCELLED = 90
 
 ALERT_DESCRIPTION_HANDSHAKE_FAILURE: AlertDescription
 ALERT_DESCRIPTION_INTERNAL_ERROR: AlertDescription
@@ -291,6 +309,8 @@ ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE: AlertDescription
 ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION: AlertDescription
 ALERT_DESCRIPTION_USER_CANCELLED: AlertDescription
 
+# This class is not exposed. It calls itself ssl._ASN1Object.
+@type_check_only
 class _ASN1ObjectBase(NamedTuple):
     nid: int
     shortname: str
@@ -305,8 +325,12 @@ class _ASN1Object(_ASN1ObjectBase):
     def fromname(cls, name: str) -> Self: ...
 
 class Purpose(_ASN1Object, enum.Enum):
-    SERVER_AUTH: _ASN1Object
-    CLIENT_AUTH: _ASN1Object
+    # Normally this class would inherit __new__ from _ASN1Object, but
+    # because this is an enum, the inherited __new__ is replaced at runtime with
+    # Enum.__new__.
+    def __new__(cls, value: object) -> Self: ...
+    SERVER_AUTH = (129, "serverAuth", "TLS Web Server Authentication", "1.3.6.1.5.5.7.3.2")  # pyright: ignore[reportCallIssue]
+    CLIENT_AUTH = (130, "clientAuth", "TLS Web Client Authentication", "1.3.6.1.5.5.7.3.1")  # pyright: ignore[reportCallIssue]
 
 class SSLSocket(socket.socket):
     context: SSLContext
@@ -350,37 +374,40 @@ class SSLSocket(socket.socket):
     def unwrap(self) -> socket.socket: ...
     def version(self) -> str | None: ...
     def pending(self) -> int: ...
-    if sys.version_info >= (3, 8):
-        def verify_client_post_handshake(self) -> None: ...
+    def verify_client_post_handshake(self) -> None: ...
+    # These methods always raise `NotImplementedError`:
+    def recvmsg(self, *args: Never, **kwargs: Never) -> Never: ...  # type: ignore[override]
+    def recvmsg_into(self, *args: Never, **kwargs: Never) -> Never: ...  # type: ignore[override]
+    def sendmsg(self, *args: Never, **kwargs: Never) -> Never: ...  # type: ignore[override]
+    if sys.version_info >= (3, 13):
+        def get_verified_chain(self) -> list[bytes]: ...
+        def get_unverified_chain(self) -> list[bytes]: ...
 
 class TLSVersion(enum.IntEnum):
-    MINIMUM_SUPPORTED: int
-    MAXIMUM_SUPPORTED: int
-    SSLv3: int
-    TLSv1: int
-    TLSv1_1: int
-    TLSv1_2: int
-    TLSv1_3: int
-
-class SSLContext:
-    check_hostname: bool
+    MINIMUM_SUPPORTED = -2
+    MAXIMUM_SUPPORTED = -1
+    SSLv3 = 768
+    TLSv1 = 769
+    TLSv1_1 = 770
+    TLSv1_2 = 771
+    TLSv1_3 = 772
+
+class SSLContext(_SSLContext):
     options: Options
     verify_flags: VerifyFlags
     verify_mode: VerifyMode
     @property
-    def protocol(self) -> _SSLMethod: ...
+    def protocol(self) -> _SSLMethod: ...  # type: ignore[override]
     hostname_checks_common_name: bool
     maximum_version: TLSVersion
     minimum_version: TLSVersion
-    sni_callback: Callable[[SSLObject, str, SSLContext], None | int] | None
     # The following two attributes have class-level defaults.
     # However, the docs explicitly state that it's OK to override these attributes on instances,
     # so making these ClassVars wouldn't be appropriate
     sslobject_class: type[SSLObject]
     sslsocket_class: type[SSLSocket]
-    if sys.version_info >= (3, 8):
-        keylog_filename: str
-        post_handshake_auth: bool
+    keylog_filename: str
+    post_handshake_auth: bool
     if sys.version_info >= (3, 10):
         security_level: int
     if sys.version_info >= (3, 10):
@@ -390,10 +417,6 @@ class SSLContext:
     else:
         def __new__(cls, protocol: int = ..., *args: Any, **kwargs: Any) -> Self: ...
 
-    def cert_store_stats(self) -> dict[str, int]: ...
-    def load_cert_chain(
-        self, certfile: StrOrBytesPath, keyfile: StrOrBytesPath | None = None, password: _PasswordType | None = None
-    ) -> None: ...
     def load_default_certs(self, purpose: Purpose = ...) -> None: ...
     def load_verify_locations(
         self,
@@ -409,19 +432,19 @@ class SSLContext:
     def get_ca_certs(self, binary_form: bool = False) -> Any: ...
     def get_ciphers(self) -> list[_Cipher]: ...
     def set_default_verify_paths(self) -> None: ...
-    def set_ciphers(self, __cipherlist: str) -> None: ...
+    def set_ciphers(self, cipherlist: str, /) -> None: ...
     def set_alpn_protocols(self, alpn_protocols: Iterable[str]) -> None: ...
     def set_npn_protocols(self, npn_protocols: Iterable[str]) -> None: ...
     def set_servername_callback(self, server_name_callback: _SrvnmeCbType | None) -> None: ...
-    def load_dh_params(self, __path: str) -> None: ...
-    def set_ecdh_curve(self, __name: str) -> None: ...
+    def load_dh_params(self, path: str, /) -> None: ...
+    def set_ecdh_curve(self, name: str, /) -> None: ...
     def wrap_socket(
         self,
         sock: socket.socket,
         server_side: bool = False,
         do_handshake_on_connect: bool = True,
         suppress_ragged_eofs: bool = True,
-        server_hostname: str | None = None,
+        server_hostname: str | bytes | None = None,
         session: SSLSession | None = None,
     ) -> SSLSocket: ...
     def wrap_bio(
@@ -429,10 +452,9 @@ class SSLContext:
         incoming: MemoryBIO,
         outgoing: MemoryBIO,
         server_side: bool = False,
-        server_hostname: str | None = None,
+        server_hostname: str | bytes | None = None,
         session: SSLSession | None = None,
     ) -> SSLObject: ...
-    def session_stats(self) -> dict[str, int]: ...
 
 class SSLObject:
     context: SSLContext
@@ -462,40 +484,21 @@ class SSLObject:
     def unwrap(self) -> None: ...
     def version(self) -> str | None: ...
     def get_channel_binding(self, cb_type: str = "tls-unique") -> bytes | None: ...
-    if sys.version_info >= (3, 8):
-        def verify_client_post_handshake(self) -> None: ...
-
-@final
-class MemoryBIO:
-    pending: int
-    eof: bool
-    def read(self, __size: int = -1) -> bytes: ...
-    def write(self, __b: ReadableBuffer) -> int: ...
-    def write_eof(self) -> None: ...
-
-@final
-class SSLSession:
-    @property
-    def has_ticket(self) -> bool: ...
-    @property
-    def id(self) -> bytes: ...
-    @property
-    def ticket_lifetime_hint(self) -> int: ...
-    @property
-    def time(self) -> int: ...
-    @property
-    def timeout(self) -> int: ...
+    def verify_client_post_handshake(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def get_verified_chain(self) -> list[bytes]: ...
+        def get_unverified_chain(self) -> list[bytes]: ...
 
 class SSLErrorNumber(enum.IntEnum):
-    SSL_ERROR_EOF: int
-    SSL_ERROR_INVALID_ERROR_CODE: int
-    SSL_ERROR_SSL: int
-    SSL_ERROR_SYSCALL: int
-    SSL_ERROR_WANT_CONNECT: int
-    SSL_ERROR_WANT_READ: int
-    SSL_ERROR_WANT_WRITE: int
-    SSL_ERROR_WANT_X509_LOOKUP: int
-    SSL_ERROR_ZERO_RETURN: int
+    SSL_ERROR_EOF = 8
+    SSL_ERROR_INVALID_ERROR_CODE = 10
+    SSL_ERROR_SSL = 1
+    SSL_ERROR_SYSCALL = 5
+    SSL_ERROR_WANT_CONNECT = 7
+    SSL_ERROR_WANT_READ = 2
+    SSL_ERROR_WANT_WRITE = 3
+    SSL_ERROR_WANT_X509_LOOKUP = 4
+    SSL_ERROR_ZERO_RETURN = 6
 
 SSL_ERROR_EOF: SSLErrorNumber  # undocumented
 SSL_ERROR_INVALID_ERROR_CODE: SSLErrorNumber  # undocumented
diff --git a/mypy/typeshed/stdlib/stat.pyi b/mypy/typeshed/stdlib/stat.pyi
index 4518acb5a162..face28ab0cbb 100644
--- a/mypy/typeshed/stdlib/stat.pyi
+++ b/mypy/typeshed/stdlib/stat.pyi
@@ -1 +1,7 @@
+import sys
 from _stat import *
+from typing import Final
+
+if sys.version_info >= (3, 13):
+    # https://github.com/python/cpython/issues/114081#issuecomment-2119017790
+    SF_RESTRICTED: Final = 0x00080000
diff --git a/mypy/typeshed/stdlib/statistics.pyi b/mypy/typeshed/stdlib/statistics.pyi
index af5fcec6ad0c..9418bdea9d6d 100644
--- a/mypy/typeshed/stdlib/statistics.pyi
+++ b/mypy/typeshed/stdlib/statistics.pyi
@@ -1,13 +1,17 @@
 import sys
 from _typeshed import SupportsRichComparisonT
-from collections.abc import Hashable, Iterable, Sequence
+from collections.abc import Callable, Hashable, Iterable, Sequence
 from decimal import Decimal
 from fractions import Fraction
-from typing import Any, NamedTuple, SupportsFloat, TypeVar
-from typing_extensions import Literal, Self, TypeAlias
+from typing import Literal, NamedTuple, SupportsFloat, SupportsIndex, TypeVar
+from typing_extensions import Self, TypeAlias
 
 __all__ = [
     "StatisticsError",
+    "fmean",
+    "geometric_mean",
+    "mean",
+    "harmonic_mean",
     "pstdev",
     "pvariance",
     "stdev",
@@ -16,16 +20,16 @@ __all__ = [
     "median_low",
     "median_high",
     "median_grouped",
-    "mean",
     "mode",
-    "harmonic_mean",
+    "multimode",
+    "NormalDist",
+    "quantiles",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["geometric_mean", "multimode", "NormalDist", "fmean", "quantiles"]
-
 if sys.version_info >= (3, 10):
     __all__ += ["covariance", "correlation", "linear_regression"]
+if sys.version_info >= (3, 13):
+    __all__ += ["kde", "kde_random"]
 
 # Most functions in this module accept homogeneous collections of one of these types
 _Number: TypeAlias = float | Decimal | Fraction
@@ -34,17 +38,18 @@ _NumberT = TypeVar("_NumberT", float, Decimal, Fraction)
 # Used in mode, multimode
 _HashableT = TypeVar("_HashableT", bound=Hashable)
 
+# Used in NormalDist.samples and kde_random
+_Seed: TypeAlias = int | float | str | bytes | bytearray  # noqa: Y041
+
 class StatisticsError(ValueError): ...
 
 if sys.version_info >= (3, 11):
     def fmean(data: Iterable[SupportsFloat], weights: Iterable[SupportsFloat] | None = None) -> float: ...
 
-elif sys.version_info >= (3, 8):
+else:
     def fmean(data: Iterable[SupportsFloat]) -> float: ...
 
-if sys.version_info >= (3, 8):
-    def geometric_mean(data: Iterable[SupportsFloat]) -> float: ...
-
+def geometric_mean(data: Iterable[SupportsFloat]) -> float: ...
 def mean(data: Iterable[_NumberT]) -> _NumberT: ...
 
 if sys.version_info >= (3, 10):
@@ -64,66 +69,60 @@ else:
     def median_grouped(data: Iterable[_NumberT], interval: _NumberT | float = 1) -> _NumberT | float: ...
 
 def mode(data: Iterable[_HashableT]) -> _HashableT: ...
-
-if sys.version_info >= (3, 8):
-    def multimode(data: Iterable[_HashableT]) -> list[_HashableT]: ...
-
+def multimode(data: Iterable[_HashableT]) -> list[_HashableT]: ...
 def pstdev(data: Iterable[_NumberT], mu: _NumberT | None = None) -> _NumberT: ...
 def pvariance(data: Iterable[_NumberT], mu: _NumberT | None = None) -> _NumberT: ...
-
-if sys.version_info >= (3, 8):
-    def quantiles(
-        data: Iterable[_NumberT], *, n: int = 4, method: Literal["inclusive", "exclusive"] = "exclusive"
-    ) -> list[_NumberT]: ...
-
+def quantiles(
+    data: Iterable[_NumberT], *, n: int = 4, method: Literal["inclusive", "exclusive"] = "exclusive"
+) -> list[_NumberT]: ...
 def stdev(data: Iterable[_NumberT], xbar: _NumberT | None = None) -> _NumberT: ...
 def variance(data: Iterable[_NumberT], xbar: _NumberT | None = None) -> _NumberT: ...
 
-if sys.version_info >= (3, 8):
-    class NormalDist:
-        def __init__(self, mu: float = 0.0, sigma: float = 1.0) -> None: ...
-        @property
-        def mean(self) -> float: ...
-        @property
-        def median(self) -> float: ...
-        @property
-        def mode(self) -> float: ...
-        @property
-        def stdev(self) -> float: ...
-        @property
-        def variance(self) -> float: ...
-        @classmethod
-        def from_samples(cls, data: Iterable[SupportsFloat]) -> Self: ...
-        def samples(self, n: int, *, seed: Any | None = None) -> list[float]: ...
-        def pdf(self, x: float) -> float: ...
-        def cdf(self, x: float) -> float: ...
-        def inv_cdf(self, p: float) -> float: ...
-        def overlap(self, other: NormalDist) -> float: ...
-        def quantiles(self, n: int = 4) -> list[float]: ...
-        if sys.version_info >= (3, 9):
-            def zscore(self, x: float) -> float: ...
-
-        def __eq__(self, x2: object) -> bool: ...
-        def __add__(self, x2: float | NormalDist) -> NormalDist: ...
-        def __sub__(self, x2: float | NormalDist) -> NormalDist: ...
-        def __mul__(self, x2: float) -> NormalDist: ...
-        def __truediv__(self, x2: float) -> NormalDist: ...
-        def __pos__(self) -> NormalDist: ...
-        def __neg__(self) -> NormalDist: ...
-        __radd__ = __add__
-        def __rsub__(self, x2: float | NormalDist) -> NormalDist: ...
-        __rmul__ = __mul__
+class NormalDist:
+    def __init__(self, mu: float = 0.0, sigma: float = 1.0) -> None: ...
+    @property
+    def mean(self) -> float: ...
+    @property
+    def median(self) -> float: ...
+    @property
+    def mode(self) -> float: ...
+    @property
+    def stdev(self) -> float: ...
+    @property
+    def variance(self) -> float: ...
+    @classmethod
+    def from_samples(cls, data: Iterable[SupportsFloat]) -> Self: ...
+    def samples(self, n: SupportsIndex, *, seed: _Seed | None = None) -> list[float]: ...
+    def pdf(self, x: float) -> float: ...
+    def cdf(self, x: float) -> float: ...
+    def inv_cdf(self, p: float) -> float: ...
+    def overlap(self, other: NormalDist) -> float: ...
+    def quantiles(self, n: int = 4) -> list[float]: ...
+    if sys.version_info >= (3, 9):
+        def zscore(self, x: float) -> float: ...
+
+    def __eq__(x1, x2: object) -> bool: ...
+    def __add__(x1, x2: float | NormalDist) -> NormalDist: ...
+    def __sub__(x1, x2: float | NormalDist) -> NormalDist: ...
+    def __mul__(x1, x2: float) -> NormalDist: ...
+    def __truediv__(x1, x2: float) -> NormalDist: ...
+    def __pos__(x1) -> NormalDist: ...
+    def __neg__(x1) -> NormalDist: ...
+    __radd__ = __add__
+    def __rsub__(x1, x2: float | NormalDist) -> NormalDist: ...
+    __rmul__ = __mul__
+    def __hash__(self) -> int: ...
 
 if sys.version_info >= (3, 12):
     def correlation(
-        __x: Sequence[_Number], __y: Sequence[_Number], *, method: Literal["linear", "ranked"] = "linear"
+        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: ...
+    def correlation(x: Sequence[_Number], y: Sequence[_Number], /) -> float: ...
 
 if sys.version_info >= (3, 10):
-    def covariance(__x: Sequence[_Number], __y: Sequence[_Number]) -> float: ...
+    def covariance(x: Sequence[_Number], y: Sequence[_Number], /) -> float: ...
 
     class LinearRegression(NamedTuple):
         slope: float
@@ -131,8 +130,31 @@ if sys.version_info >= (3, 10):
 
 if sys.version_info >= (3, 11):
     def linear_regression(
-        __regressor: Sequence[_Number], __dependent_variable: Sequence[_Number], *, proportional: bool = False
+        regressor: Sequence[_Number], dependent_variable: Sequence[_Number], /, *, proportional: bool = False
     ) -> LinearRegression: ...
 
 elif sys.version_info >= (3, 10):
-    def linear_regression(__regressor: Sequence[_Number], __dependent_variable: Sequence[_Number]) -> LinearRegression: ...
+    def linear_regression(regressor: Sequence[_Number], dependent_variable: Sequence[_Number], /) -> LinearRegression: ...
+
+if sys.version_info >= (3, 13):
+    _Kernel: TypeAlias = Literal[
+        "normal",
+        "gauss",
+        "logistic",
+        "sigmoid",
+        "rectangular",
+        "uniform",
+        "triangular",
+        "parabolic",
+        "epanechnikov",
+        "quartic",
+        "biweight",
+        "triweight",
+        "cosine",
+    ]
+    def kde(
+        data: Sequence[float], h: float, kernel: _Kernel = "normal", *, cumulative: bool = False
+    ) -> Callable[[float], float]: ...
+    def kde_random(
+        data: Sequence[float], h: float, kernel: _Kernel = "normal", *, seed: _Seed | None = None
+    ) -> Callable[[], float]: ...
diff --git a/mypy/typeshed/stdlib/string.pyi b/mypy/typeshed/stdlib/string.pyi
index 1a875a071bf5..35a76e9c8628 100644
--- a/mypy/typeshed/stdlib/string.pyi
+++ b/mypy/typeshed/stdlib/string.pyi
@@ -47,17 +47,17 @@ class Template(metaclass=_TemplateMetaclass):
     flags: ClassVar[RegexFlag]
     pattern: ClassVar[Pattern[str]]
     def __init__(self, template: str) -> None: ...
-    def substitute(self, __mapping: Mapping[str, object] = {}, **kwds: object) -> str: ...
-    def safe_substitute(self, __mapping: Mapping[str, object] = {}, **kwds: object) -> str: ...
+    def substitute(self, mapping: Mapping[str, object] = {}, /, **kwds: object) -> str: ...
+    def safe_substitute(self, mapping: Mapping[str, object] = {}, /, **kwds: object) -> str: ...
     if sys.version_info >= (3, 11):
         def get_identifiers(self) -> list[str]: ...
         def is_valid(self) -> bool: ...
 
 class Formatter:
     @overload
-    def format(self, __format_string: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
+    def format(self, format_string: LiteralString, /, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
     @overload
-    def format(self, __format_string: str, *args: Any, **kwargs: Any) -> str: ...
+    def format(self, format_string: str, /, *args: Any, **kwargs: Any) -> str: ...
     @overload
     def vformat(
         self, format_string: LiteralString, args: Sequence[LiteralString], kwargs: Mapping[LiteralString, LiteralString]
@@ -80,4 +80,4 @@ class Formatter:
     def get_value(self, key: int | str, args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any: ...
     def check_unused_args(self, used_args: set[int | str], args: Sequence[Any], kwargs: Mapping[str, Any]) -> None: ...
     def format_field(self, value: Any, format_spec: str) -> Any: ...
-    def convert_field(self, value: Any, conversion: str) -> Any: ...
+    def convert_field(self, value: Any, conversion: str | None) -> Any: ...
diff --git a/mypy/typeshed/stdlib/struct.pyi b/mypy/typeshed/stdlib/struct.pyi
index 4220cd825b76..2c26908746ec 100644
--- a/mypy/typeshed/stdlib/struct.pyi
+++ b/mypy/typeshed/stdlib/struct.pyi
@@ -1,26 +1,5 @@
-from _typeshed import ReadableBuffer, WriteableBuffer
-from collections.abc import Iterator
-from typing import Any
+from _struct import *
 
 __all__ = ["calcsize", "pack", "pack_into", "unpack", "unpack_from", "iter_unpack", "Struct", "error"]
 
 class error(Exception): ...
-
-def pack(__fmt: str | bytes, *v: Any) -> bytes: ...
-def pack_into(__fmt: str | bytes, __buffer: WriteableBuffer, __offset: int, *v: Any) -> None: ...
-def unpack(__format: str | bytes, __buffer: ReadableBuffer) -> tuple[Any, ...]: ...
-def unpack_from(__format: str | bytes, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]: ...
-def iter_unpack(__format: str | bytes, __buffer: ReadableBuffer) -> Iterator[tuple[Any, ...]]: ...
-def calcsize(__format: str | bytes) -> int: ...
-
-class Struct:
-    @property
-    def format(self) -> str: ...
-    @property
-    def size(self) -> int: ...
-    def __init__(self, format: str | bytes) -> None: ...
-    def pack(self, *v: Any) -> bytes: ...
-    def pack_into(self, buffer: WriteableBuffer, offset: int, *v: Any) -> None: ...
-    def unpack(self, __buffer: ReadableBuffer) -> tuple[Any, ...]: ...
-    def unpack_from(self, buffer: ReadableBuffer, offset: int = 0) -> tuple[Any, ...]: ...
-    def iter_unpack(self, __buffer: ReadableBuffer) -> Iterator[tuple[Any, ...]]: ...
diff --git a/mypy/typeshed/stdlib/subprocess.pyi b/mypy/typeshed/stdlib/subprocess.pyi
index 346e4d5513d8..fef35b56945a 100644
--- a/mypy/typeshed/stdlib/subprocess.pyi
+++ b/mypy/typeshed/stdlib/subprocess.pyi
@@ -1,9 +1,9 @@
 import sys
-from _typeshed import ReadableBuffer, StrOrBytesPath
+from _typeshed import MaybeNone, ReadableBuffer, StrOrBytesPath
 from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
 from types import TracebackType
-from typing import IO, Any, AnyStr, Generic, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, AnyStr, Final, Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -64,12 +64,7 @@ if sys.platform == "win32":
 #    reveal_type(e.cmd)  # Any, but morally is _CMD
 _FILE: TypeAlias = None | int | IO[Any]
 _InputString: TypeAlias = ReadableBuffer | str
-if sys.version_info >= (3, 8):
-    _CMD: TypeAlias = StrOrBytesPath | Sequence[StrOrBytesPath]
-else:
-    # Python 3.7 doesn't support _CMD being a single PathLike.
-    # See: https://bugs.python.org/issue31961
-    _CMD: TypeAlias = str | bytes | Sequence[StrOrBytesPath]
+_CMD: TypeAlias = StrOrBytesPath | Sequence[StrOrBytesPath]
 if sys.platform == "win32":
     _ENV: TypeAlias = Mapping[str, str]
 else:
@@ -79,9 +74,8 @@ _T = TypeVar("_T")
 
 # These two are private but documented
 if sys.version_info >= (3, 11):
-    _USE_VFORK: bool
-if sys.version_info >= (3, 8):
-    _USE_POSIX_SPAWN: bool
+    _USE_VFORK: Final[bool]
+_USE_POSIX_SPAWN: Final[bool]
 
 class CompletedProcess(Generic[_T]):
     # morally: _CMD
@@ -94,7 +88,7 @@ class CompletedProcess(Generic[_T]):
     def __init__(self, args: _CMD, returncode: int, stdout: _T | None = None, stderr: _T | None = None) -> None: ...
     def check_returncode(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 11):
     # 3.11 adds "process_group" argument
@@ -248,7 +242,7 @@ if sys.version_info >= (3, 11):
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -260,7 +254,7 @@ if sys.version_info >= (3, 11):
         encoding: None = None,
         errors: None = None,
         input: ReadableBuffer | None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
         timeout: float | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -452,7 +446,7 @@ elif sys.version_info >= (3, 10):
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -464,7 +458,7 @@ elif sys.version_info >= (3, 10):
         encoding: None = None,
         errors: None = None,
         input: ReadableBuffer | None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
         timeout: float | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -650,7 +644,7 @@ elif sys.version_info >= (3, 9):
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -662,7 +656,7 @@ elif sys.version_info >= (3, 9):
         encoding: None = None,
         errors: None = None,
         input: ReadableBuffer | None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
         timeout: float | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -829,7 +823,7 @@ else:
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -841,7 +835,7 @@ else:
         encoding: None = None,
         errors: None = None,
         input: ReadableBuffer | None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
         timeout: float | None = None,
     ) -> CompletedProcess[bytes]: ...
     @overload
@@ -895,6 +889,7 @@ if sys.version_info >= (3, 11):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -926,6 +921,7 @@ elif sys.version_info >= (3, 10):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -956,6 +952,7 @@ elif sys.version_info >= (3, 9):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -984,6 +981,7 @@ else:
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
     ) -> int: ...
@@ -1011,6 +1009,7 @@ if sys.version_info >= (3, 11):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1042,6 +1041,7 @@ elif sys.version_info >= (3, 10):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1072,6 +1072,7 @@ elif sys.version_info >= (3, 9):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1100,6 +1101,7 @@ else:
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
     ) -> int: ...
 
@@ -1242,7 +1244,7 @@ if sys.version_info >= (3, 11):
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -1253,7 +1255,7 @@ if sys.version_info >= (3, 11):
         input: _InputString | None = ...,
         encoding: None = None,
         errors: None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
         extra_groups: Iterable[str | int] | None = None,
@@ -1428,7 +1430,7 @@ elif sys.version_info >= (3, 10):
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -1439,7 +1441,7 @@ elif sys.version_info >= (3, 10):
         input: _InputString | None = ...,
         encoding: None = None,
         errors: None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
         extra_groups: Iterable[str | int] | None = None,
@@ -1608,7 +1610,7 @@ elif sys.version_info >= (3, 9):
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -1619,7 +1621,7 @@ elif sys.version_info >= (3, 9):
         input: _InputString | None = ...,
         encoding: None = None,
         errors: None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
         extra_groups: Iterable[str | int] | None = None,
@@ -1769,7 +1771,7 @@ else:
         shell: bool = False,
         cwd: StrOrBytesPath | None = None,
         env: _ENV | None = None,
-        universal_newlines: Literal[False, None] = None,
+        universal_newlines: Literal[False] | None = None,
         startupinfo: Any = None,
         creationflags: int = 0,
         restore_signals: bool = True,
@@ -1780,7 +1782,7 @@ else:
         input: _InputString | None = ...,
         encoding: None = None,
         errors: None = None,
-        text: Literal[None, False] = None,
+        text: Literal[False] | None = None,
     ) -> bytes: ...
     @overload
     def check_output(
@@ -1808,9 +1810,9 @@ else:
         text: bool | None = None,
     ) -> Any: ...  # morally: -> str | bytes
 
-PIPE: int
-STDOUT: int
-DEVNULL: int
+PIPE: Final[int]
+STDOUT: Final[int]
+DEVNULL: Final[int]
 
 class SubprocessError(Exception): ...
 
@@ -1846,7 +1848,7 @@ class Popen(Generic[AnyStr]):
     stdout: IO[AnyStr] | None
     stderr: IO[AnyStr] | None
     pid: int
-    returncode: int | Any
+    returncode: int | MaybeNone
     universal_newlines: bool
 
     if sys.version_info >= (3, 11):
@@ -1990,14 +1992,14 @@ class Popen(Generic[AnyStr]):
             shell: bool = False,
             cwd: StrOrBytesPath | None = None,
             env: _ENV | None = None,
-            universal_newlines: Literal[False, None] = None,
+            universal_newlines: Literal[False] | None = None,
             startupinfo: Any | None = None,
             creationflags: int = 0,
             restore_signals: bool = True,
             start_new_session: bool = False,
             pass_fds: Collection[int] = (),
             *,
-            text: Literal[None, False] = None,
+            text: Literal[False] | None = None,
             encoding: None = None,
             errors: None = None,
             user: str | int | None = None,
@@ -2175,14 +2177,14 @@ class Popen(Generic[AnyStr]):
             shell: bool = False,
             cwd: StrOrBytesPath | None = None,
             env: _ENV | None = None,
-            universal_newlines: Literal[False, None] = None,
+            universal_newlines: Literal[False] | None = None,
             startupinfo: Any | None = None,
             creationflags: int = 0,
             restore_signals: bool = True,
             start_new_session: bool = False,
             pass_fds: Collection[int] = (),
             *,
-            text: Literal[None, False] = None,
+            text: Literal[False] | None = None,
             encoding: None = None,
             errors: None = None,
             user: str | int | None = None,
@@ -2354,14 +2356,14 @@ class Popen(Generic[AnyStr]):
             shell: bool = False,
             cwd: StrOrBytesPath | None = None,
             env: _ENV | None = None,
-            universal_newlines: Literal[False, None] = None,
+            universal_newlines: Literal[False] | None = None,
             startupinfo: Any | None = None,
             creationflags: int = 0,
             restore_signals: bool = True,
             start_new_session: bool = False,
             pass_fds: Collection[int] = (),
             *,
-            text: Literal[None, False] = None,
+            text: Literal[False] | None = None,
             encoding: None = None,
             errors: None = None,
             user: str | int | None = None,
@@ -2514,14 +2516,14 @@ class Popen(Generic[AnyStr]):
             shell: bool = False,
             cwd: StrOrBytesPath | None = None,
             env: _ENV | None = None,
-            universal_newlines: Literal[False, None] = None,
+            universal_newlines: Literal[False] | None = None,
             startupinfo: Any | None = None,
             creationflags: int = 0,
             restore_signals: bool = True,
             start_new_session: bool = False,
             pass_fds: Collection[int] = (),
             *,
-            text: Literal[None, False] = None,
+            text: Literal[False] | None = None,
             encoding: None = None,
             errors: None = None,
         ) -> None: ...
@@ -2564,25 +2566,27 @@ class Popen(Generic[AnyStr]):
     def __exit__(
         self, exc_type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
     ) -> None: ...
+    def __del__(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # The result really is always a str.
 if sys.version_info >= (3, 11):
-    def getstatusoutput(cmd: str | bytes, *, encoding: str | None = None, errors: str | None = None) -> tuple[int, str]: ...
-    def getoutput(cmd: str | bytes, *, encoding: str | None = None, errors: str | None = None) -> str: ...
+    def getstatusoutput(cmd: _CMD, *, encoding: str | None = None, errors: str | None = None) -> tuple[int, str]: ...
+    def getoutput(cmd: _CMD, *, encoding: str | None = None, errors: str | None = None) -> str: ...
 
 else:
-    def getstatusoutput(cmd: str | bytes) -> tuple[int, str]: ...
-    def getoutput(cmd: str | bytes) -> str: ...
+    def getstatusoutput(cmd: _CMD) -> tuple[int, str]: ...
+    def getoutput(cmd: _CMD) -> str: ...
 
-if sys.version_info >= (3, 8):
-    def list2cmdline(seq: Iterable[StrOrBytesPath]) -> str: ...  # undocumented
-
-else:
-    def list2cmdline(seq: Iterable[str]) -> str: ...  # undocumented
+def list2cmdline(seq: Iterable[StrOrBytesPath]) -> str: ...  # undocumented
 
 if sys.platform == "win32":
+    if sys.version_info >= (3, 13):
+        from _winapi import STARTF_FORCEOFFFEEDBACK, STARTF_FORCEONFEEDBACK
+
+        __all__ += ["STARTF_FORCEOFFFEEDBACK", "STARTF_FORCEONFEEDBACK"]
+
     class STARTUPINFO:
         def __init__(
             self,
@@ -2600,6 +2604,8 @@ if sys.platform == "win32":
         hStdError: Any | None
         wShowWindow: int
         lpAttributeList: Mapping[str, Any]
+        def copy(self) -> STARTUPINFO: ...
+
     from _winapi import (
         ABOVE_NORMAL_PRIORITY_CLASS as ABOVE_NORMAL_PRIORITY_CLASS,
         BELOW_NORMAL_PRIORITY_CLASS as BELOW_NORMAL_PRIORITY_CLASS,
diff --git a/mypy/typeshed/stdlib/sunau.pyi b/mypy/typeshed/stdlib/sunau.pyi
index 6109b368c01a..9b051e82b64b 100644
--- a/mypy/typeshed/stdlib/sunau.pyi
+++ b/mypy/typeshed/stdlib/sunau.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import Unused
-from typing import IO, Any, NamedTuple, NoReturn, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, Literal, NamedTuple, NoReturn, overload
+from typing_extensions import Self, TypeAlias
 
 _File: TypeAlias = str | IO[bytes]
 
@@ -34,6 +34,7 @@ class Au_read:
     def __init__(self, f: _File) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
+    def __del__(self) -> None: ...
     def getfp(self) -> IO[bytes] | None: ...
     def rewind(self) -> None: ...
     def close(self) -> None: ...
@@ -54,6 +55,7 @@ class Au_write:
     def __init__(self, f: _File) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
+    def __del__(self) -> None: ...
     def setnchannels(self, nchannels: int) -> None: ...
     def getnchannels(self) -> int: ...
     def setsampwidth(self, sampwidth: int) -> None: ...
diff --git a/mypy/typeshed/stdlib/symbol.pyi b/mypy/typeshed/stdlib/symbol.pyi
index bb6660374d16..48ae3567a1a5 100644
--- a/mypy/typeshed/stdlib/symbol.pyi
+++ b/mypy/typeshed/stdlib/symbol.pyi
@@ -1,5 +1,3 @@
-import sys
-
 single_input: int
 file_input: int
 eval_input: int
@@ -87,11 +85,9 @@ encoding_decl: int
 yield_expr: int
 yield_arg: int
 sync_comp_for: int
-if sys.version_info >= (3, 8):
-    func_body_suite: int
-    func_type: int
-    func_type_input: int
-    namedexpr_test: int
-    typelist: int
-
+func_body_suite: int
+func_type: int
+func_type_input: int
+namedexpr_test: int
+typelist: int
 sym_name: dict[int, str]
diff --git a/mypy/typeshed/stdlib/symtable.pyi b/mypy/typeshed/stdlib/symtable.pyi
index 304ae8bf8126..ee0a1eb2f1cb 100644
--- a/mypy/typeshed/stdlib/symtable.pyi
+++ b/mypy/typeshed/stdlib/symtable.pyi
@@ -2,14 +2,34 @@ import sys
 from _collections_abc import dict_keys
 from collections.abc import Sequence
 from typing import Any
+from typing_extensions import deprecated
 
 __all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["SymbolTableType"]
+
 def symtable(code: str, filename: str, compile_type: str) -> SymbolTable: ...
 
+if sys.version_info >= (3, 13):
+    from enum import StrEnum
+
+    class SymbolTableType(StrEnum):
+        MODULE = "module"
+        FUNCTION = "function"
+        CLASS = "class"
+        ANNOTATION = "annotation"
+        TYPE_ALIAS = "type alias"
+        TYPE_PARAMETERS = "type parameters"
+        TYPE_VARIABLE = "type variable"
+
 class SymbolTable:
     def __init__(self, raw_table: Any, filename: str) -> None: ...
-    def get_type(self) -> str: ...
+    if sys.version_info >= (3, 13):
+        def get_type(self) -> SymbolTableType: ...
+    else:
+        def get_type(self) -> str: ...
+
     def get_id(self) -> int: ...
     def get_name(self) -> str: ...
     def get_lineno(self) -> int: ...
@@ -29,31 +49,38 @@ class Function(SymbolTable):
     def get_locals(self) -> tuple[str, ...]: ...
     def get_globals(self) -> tuple[str, ...]: ...
     def get_frees(self) -> tuple[str, ...]: ...
-    if sys.version_info >= (3, 8):
-        def get_nonlocals(self) -> tuple[str, ...]: ...
+    def get_nonlocals(self) -> tuple[str, ...]: ...
 
 class Class(SymbolTable):
-    def get_methods(self) -> tuple[str, ...]: ...
+    if sys.version_info < (3, 16):
+        @deprecated("deprecated in Python 3.14, will be removed in Python 3.16")
+        def get_methods(self) -> tuple[str, ...]: ...
 
 class Symbol:
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self, name: str, flags: int, namespaces: Sequence[SymbolTable] | None = None, *, module_scope: bool = False
-        ) -> None: ...
-        def is_nonlocal(self) -> bool: ...
-    else:
-        def __init__(self, name: str, flags: int, namespaces: Sequence[SymbolTable] | None = None) -> None: ...
-
+    def __init__(
+        self, name: str, flags: int, namespaces: Sequence[SymbolTable] | None = None, *, module_scope: bool = False
+    ) -> None: ...
+    def is_nonlocal(self) -> bool: ...
     def get_name(self) -> str: ...
     def is_referenced(self) -> bool: ...
     def is_parameter(self) -> bool: ...
+    if sys.version_info >= (3, 14):
+        def is_type_parameter(self) -> bool: ...
+
     def is_global(self) -> bool: ...
     def is_declared_global(self) -> bool: ...
     def is_local(self) -> bool: ...
     def is_annotated(self) -> bool: ...
     def is_free(self) -> bool: ...
+    if sys.version_info >= (3, 14):
+        def is_free_class(self) -> bool: ...
+
     def is_imported(self) -> bool: ...
     def is_assigned(self) -> bool: ...
+    if sys.version_info >= (3, 14):
+        def is_comp_iter(self) -> bool: ...
+        def is_comp_cell(self) -> bool: ...
+
     def is_namespace(self) -> bool: ...
     def get_namespaces(self) -> Sequence[SymbolTable]: ...
     def get_namespace(self) -> SymbolTable: ...
diff --git a/mypy/typeshed/stdlib/sys.pyi b/mypy/typeshed/stdlib/sys/__init__.pyi
similarity index 55%
rename from mypy/typeshed/stdlib/sys.pyi
rename to mypy/typeshed/stdlib/sys/__init__.pyi
index c2fdbeccca72..4aa1699e8b42 100644
--- a/mypy/typeshed/stdlib/sys.pyi
+++ b/mypy/typeshed/stdlib/sys/__init__.pyi
@@ -1,23 +1,17 @@
 import sys
-from _typeshed import OptExcInfo, ProfileFunction, TraceFunction, structseq
+from _typeshed import MaybeNone, OptExcInfo, ProfileFunction, TraceFunction, structseq
+from _typeshed.importlib import MetaPathFinderProtocol, PathEntryFinderProtocol
 from builtins import object as _object
-from collections.abc import AsyncGenerator, Callable, Coroutine, Sequence
-from importlib.abc import PathEntryFinder
-from importlib.machinery import ModuleSpec
+from collections.abc import AsyncGenerator, Callable, Sequence
 from io import TextIOWrapper
 from types import FrameType, ModuleType, TracebackType
-from typing import Any, NoReturn, Protocol, TextIO, TypeVar
-from typing_extensions import Final, Literal, TypeAlias, final
+from typing import Any, Final, Literal, NoReturn, Protocol, TextIO, TypeVar, final, type_check_only
+from typing_extensions import LiteralString, TypeAlias
 
 _T = TypeVar("_T")
 
 # see https://github.com/python/typeshed/issues/8513#issue-1333671093 for the rationale behind this alias
 _ExitCode: TypeAlias = str | int | None
-_OptExcInfo: TypeAlias = OptExcInfo  # noqa: Y047  # TODO: obsolete, remove fall 2022 or later
-
-# Intentionally omits one deprecated and one optional method of `importlib.abc.MetaPathFinder`
-class _MetaPathFinder(Protocol):
-    def find_spec(self, fullname: str, path: Sequence[str] | None, target: ModuleType | None = ...) -> ModuleSpec | None: ...
 
 # ----- sys variables -----
 if sys.platform != "win32":
@@ -40,44 +34,46 @@ hexversion: int
 last_type: type[BaseException] | None
 last_value: BaseException | None
 last_traceback: TracebackType | None
+if sys.version_info >= (3, 12):
+    last_exc: BaseException  # or undefined.
 maxsize: int
 maxunicode: int
-meta_path: list[_MetaPathFinder]
+meta_path: list[MetaPathFinderProtocol]
 modules: dict[str, ModuleType]
 if sys.version_info >= (3, 10):
     orig_argv: list[str]
 path: list[str]
-path_hooks: list[Callable[[str], PathEntryFinder]]
-path_importer_cache: dict[str, PathEntryFinder | None]
-platform: str
+path_hooks: list[Callable[[str], PathEntryFinderProtocol]]
+path_importer_cache: dict[str, PathEntryFinderProtocol | None]
+platform: LiteralString
 if sys.version_info >= (3, 9):
     platlibdir: str
 prefix: str
-if sys.version_info >= (3, 8):
-    pycache_prefix: str | None
+pycache_prefix: str | None
 ps1: object
 ps2: object
 
 # TextIO is used instead of more specific types for the standard streams,
 # since they are often monkeypatched at runtime. At startup, the objects
-# are initialized to instances of TextIOWrapper.
+# are initialized to instances of TextIOWrapper, but can also be None under
+# some circumstances.
 #
 # To use methods from TextIOWrapper, use an isinstance check to ensure that
 # the streams have not been overridden:
 #
 # if isinstance(sys.stdout, io.TextIOWrapper):
 #    sys.stdout.reconfigure(...)
-stdin: TextIO
-stdout: TextIO
-stderr: TextIO
+stdin: TextIO | MaybeNone
+stdout: TextIO | MaybeNone
+stderr: TextIO | MaybeNone
 
 if sys.version_info >= (3, 10):
     stdlib_module_names: frozenset[str]
 
-__stdin__: Final[TextIOWrapper]  # Contains the original value of stdin
-__stdout__: Final[TextIOWrapper]  # Contains the original value of stdout
-__stderr__: Final[TextIOWrapper]  # Contains the original value of stderr
-tracebacklimit: int
+__stdin__: Final[TextIOWrapper | None]  # Contains the original value of stdin
+__stdout__: Final[TextIOWrapper | None]  # Contains the original value of stdout
+__stderr__: Final[TextIOWrapper | None]  # Contains the original value of stderr
+tracebacklimit: int | None
 version: str
 api_version: int
 warnoptions: Any
@@ -93,13 +89,63 @@ _UninstantiableStructseq: TypeAlias = structseq[Any]
 
 flags: _flags
 
-if sys.version_info >= (3, 10):
-    _FlagTuple: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int, int, int, int, bool, int, int]
-else:
-    _FlagTuple: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int, int, int, int, bool, int]
-
+# This class is not exposed at runtime. It calls itself sys.flags.
+# As a tuple, it can have a length between 15 and 18. We don't model
+# the exact length here because that varies by patch version due to
+# the backported security fix int_max_str_digits. The exact length shouldn't
+# be relied upon. See #13031
+# This can be re-visited when typeshed drops support for 3.10,
+# at which point all supported versions will include int_max_str_digits
+# in all patch versions.
+# 3.8 and 3.9 are 15 or 16-tuple
+# 3.10 is 16 or 17-tuple
+# 3.11+ is an 18-tuple.
 @final
-class _flags(_UninstantiableStructseq, _FlagTuple):
+@type_check_only
+class _flags(_UninstantiableStructseq, tuple[int, ...]):
+    # `safe_path` was added in py311
+    if sys.version_info >= (3, 11):
+        __match_args__: Final = (
+            "debug",
+            "inspect",
+            "interactive",
+            "optimize",
+            "dont_write_bytecode",
+            "no_user_site",
+            "no_site",
+            "ignore_environment",
+            "verbose",
+            "bytes_warning",
+            "quiet",
+            "hash_randomization",
+            "isolated",
+            "dev_mode",
+            "utf8_mode",
+            "warn_default_encoding",
+            "safe_path",
+            "int_max_str_digits",
+        )
+    elif sys.version_info >= (3, 10):
+        __match_args__: Final = (
+            "debug",
+            "inspect",
+            "interactive",
+            "optimize",
+            "dont_write_bytecode",
+            "no_user_site",
+            "no_site",
+            "ignore_environment",
+            "verbose",
+            "bytes_warning",
+            "quiet",
+            "hash_randomization",
+            "isolated",
+            "dev_mode",
+            "utf8_mode",
+            "warn_default_encoding",
+            "int_max_str_digits",
+        )
+
     @property
     def debug(self) -> int: ...
     @property
@@ -132,15 +178,39 @@ class _flags(_UninstantiableStructseq, _FlagTuple):
     def utf8_mode(self) -> int: ...
     if sys.version_info >= (3, 10):
         @property
-        def warn_default_encoding(self) -> int: ...  # undocumented
+        def warn_default_encoding(self) -> int: ...
     if sys.version_info >= (3, 11):
         @property
         def safe_path(self) -> bool: ...
+    # Whether or not this exists on lower versions of Python
+    # may depend on which patch release you're using
+    # (it was backported to all Python versions on 3.8+ as a security fix)
+    # Added in: 3.8.14, 3.9.14, 3.10.7
+    # and present in all versions of 3.11 and later.
+    @property
+    def int_max_str_digits(self) -> int: ...
 
 float_info: _float_info
 
+# This class is not exposed at runtime. It calls itself sys.float_info.
 @final
+@type_check_only
 class _float_info(structseq[float], tuple[float, int, int, float, int, int, int, int, float, int, int]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = (
+            "max",
+            "max_exp",
+            "max_10_exp",
+            "min",
+            "min_exp",
+            "min_10_exp",
+            "dig",
+            "mant_dig",
+            "epsilon",
+            "radix",
+            "rounds",
+        )
+
     @property
     def max(self) -> float: ...  # DBL_MAX
     @property
@@ -166,8 +236,13 @@ class _float_info(structseq[float], tuple[float, int, int, float, int, int, int,
 
 hash_info: _hash_info
 
+# This class is not exposed at runtime. It calls itself sys.hash_info.
 @final
+@type_check_only
 class _hash_info(structseq[Any | int], tuple[int, int, int, int, int, str, int, int, int]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("width", "modulus", "inf", "nan", "imag", "algorithm", "hash_bits", "seed_bits", "cutoff")
+
     @property
     def width(self) -> int: ...
     @property
@@ -189,6 +264,9 @@ class _hash_info(structseq[Any | int], tuple[int, int, int, int, int, str, int,
 
 implementation: _implementation
 
+# This class isn't really a thing. At runtime, implementation is an instance
+# of types.SimpleNamespace. This allows for better typing.
+@type_check_only
 class _implementation:
     name: str
     version: _version_info
@@ -201,8 +279,13 @@ class _implementation:
 
 int_info: _int_info
 
+# This class is not exposed at runtime. It calls itself sys.int_info.
 @final
+@type_check_only
 class _int_info(structseq[int], tuple[int, int, int, int]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("bits_per_digit", "sizeof_digit", "default_max_str_digits", "str_digits_check_threshold")
+
     @property
     def bits_per_digit(self) -> int: ...
     @property
@@ -215,8 +298,13 @@ class _int_info(structseq[int], tuple[int, int, int, int]):
 _ThreadInfoName: TypeAlias = Literal["nt", "pthread", "pthread-stubs", "solaris"]
 _ThreadInfoLock: TypeAlias = Literal["semaphore", "mutex+cond"] | None
 
+# This class is not exposed at runtime. It calls itself sys.thread_info.
 @final
+@type_check_only
 class _thread_info(_UninstantiableStructseq, tuple[_ThreadInfoName, _ThreadInfoLock, str | None]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("name", "lock", "version")
+
     @property
     def name(self) -> _ThreadInfoName: ...
     @property
@@ -225,9 +313,15 @@ class _thread_info(_UninstantiableStructseq, tuple[_ThreadInfoName, _ThreadInfoL
     def version(self) -> str | None: ...
 
 thread_info: _thread_info
+_ReleaseLevel: TypeAlias = Literal["alpha", "beta", "candidate", "final"]
 
+# This class is not exposed at runtime. It calls itself sys.version_info.
 @final
-class _version_info(_UninstantiableStructseq, tuple[int, int, int, str, int]):
+@type_check_only
+class _version_info(_UninstantiableStructseq, tuple[int, int, int, _ReleaseLevel, int]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("major", "minor", "micro", "releaselevel", "serial")
+
     @property
     def major(self) -> int: ...
     @property
@@ -235,25 +329,25 @@ class _version_info(_UninstantiableStructseq, tuple[int, int, int, str, int]):
     @property
     def micro(self) -> int: ...
     @property
-    def releaselevel(self) -> str: ...
+    def releaselevel(self) -> _ReleaseLevel: ...
     @property
     def serial(self) -> int: ...
 
 version_info: _version_info
 
-def call_tracing(__func: Callable[..., _T], __args: Any) -> _T: ...
+def call_tracing(func: Callable[..., _T], args: Any, /) -> _T: ...
 def _clear_type_cache() -> None: ...
 def _current_frames() -> dict[int, FrameType]: ...
-def _getframe(__depth: int = 0) -> FrameType: ...
+def _getframe(depth: int = 0, /) -> FrameType: ...
 def _debugmallocstats() -> None: ...
-def __displayhook__(__object: object) -> None: ...
-def __excepthook__(__exctype: type[BaseException], __value: BaseException, __traceback: TracebackType | None) -> None: ...
+def __displayhook__(object: object, /) -> None: ...
+def __excepthook__(exctype: type[BaseException], value: BaseException, traceback: TracebackType | None, /) -> None: ...
 def exc_info() -> OptExcInfo: ...
 
 if sys.version_info >= (3, 11):
     def exception() -> BaseException | None: ...
 
-def exit(__status: _ExitCode = None) -> NoReturn: ...
+def exit(status: _ExitCode = None, /) -> NoReturn: ...
 def getallocatedblocks() -> int: ...
 def getdefaultencoding() -> str: ...
 
@@ -262,14 +356,14 @@ if sys.platform != "win32":
 
 def getfilesystemencoding() -> str: ...
 def getfilesystemencodeerrors() -> str: ...
-def getrefcount(__object: Any) -> int: ...
+def getrefcount(object: Any, /) -> int: ...
 def getrecursionlimit() -> int: ...
 def getsizeof(obj: object, default: int = ...) -> int: ...
 def getswitchinterval() -> float: ...
 def getprofile() -> ProfileFunction | None: ...
-def setprofile(profilefunc: ProfileFunction | None) -> None: ...
+def setprofile(function: ProfileFunction | None, /) -> None: ...
 def gettrace() -> TraceFunction | None: ...
-def settrace(tracefunc: TraceFunction | None) -> None: ...
+def settrace(function: TraceFunction | None, /) -> None: ...
 
 if sys.platform == "win32":
     # A tuple of length 5, even though it has more than 5 attributes.
@@ -298,44 +392,56 @@ if sys.platform == "win32":
 
     def getwindowsversion() -> _WinVersion: ...
 
-def intern(__string: str) -> str: ...
+def intern(string: str, /) -> str: ...
+
+if sys.version_info >= (3, 13):
+    def _is_gil_enabled() -> bool: ...
+    def _clear_internal_caches() -> None: ...
+
 def is_finalizing() -> bool: ...
 def breakpointhook(*args: Any, **kwargs: Any) -> Any: ...
 
 __breakpointhook__ = breakpointhook  # Contains the original value of breakpointhook
 
 if sys.platform != "win32":
-    def setdlopenflags(__flags: int) -> None: ...
+    def setdlopenflags(flags: int, /) -> None: ...
 
-def setrecursionlimit(__limit: int) -> None: ...
-def setswitchinterval(__interval: float) -> None: ...
+def setrecursionlimit(limit: int, /) -> None: ...
+def setswitchinterval(interval: float, /) -> None: ...
 def gettotalrefcount() -> int: ...  # Debug builds only
 
 if sys.version_info < (3, 9):
     def getcheckinterval() -> int: ...  # deprecated
-    def setcheckinterval(__n: int) -> None: ...  # deprecated
+    def setcheckinterval(n: int, /) -> None: ...  # deprecated
 
 if sys.version_info < (3, 9):
     # An 11-tuple or None
     def callstats() -> tuple[int, int, int, int, int, int, int, int, int, int, int] | None: ...
 
-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:
-        exc_type: type[BaseException]
-        exc_value: BaseException | None
-        exc_traceback: TracebackType | None
-        err_msg: str | None
-        object: _object
-    unraisablehook: Callable[[UnraisableHookArgs], Any]
-    def __unraisablehook__(__unraisable: UnraisableHookArgs) -> Any: ...
-    def addaudithook(hook: Callable[[str, tuple[Any, ...]], Any]) -> None: ...
-    def audit(__event: str, *args: Any) -> None: ...
+# Doesn't exist at runtime, but exported in the stubs so pytest etc. can annotate their code more easily.
+@type_check_only
+class UnraisableHookArgs(Protocol):
+    exc_type: type[BaseException]
+    exc_value: BaseException | None
+    exc_traceback: TracebackType | None
+    err_msg: str | None
+    object: _object
+
+unraisablehook: Callable[[UnraisableHookArgs], Any]
+
+def __unraisablehook__(unraisable: UnraisableHookArgs, /) -> Any: ...
+def addaudithook(hook: Callable[[str, tuple[Any, ...]], Any]) -> None: ...
+def audit(event: str, /, *args: Any) -> None: ...
 
 _AsyncgenHook: TypeAlias = Callable[[AsyncGenerator[Any, Any]], None] | None
 
+# This class is not exposed at runtime. It calls itself builtins.asyncgen_hooks.
 @final
+@type_check_only
 class _asyncgen_hooks(structseq[_AsyncgenHook], tuple[_AsyncgenHook, _AsyncgenHook]):
+    if sys.version_info >= (3, 10):
+        __match_args__: Final = ("firstiter", "finalizer")
+
     @property
     def firstiter(self) -> _AsyncgenHook: ...
     @property
@@ -350,12 +456,25 @@ if sys.platform == "win32":
 def get_coroutine_origin_tracking_depth() -> int: ...
 def set_coroutine_origin_tracking_depth(depth: int) -> None: ...
 
-if sys.version_info < (3, 8):
-    _CoroWrapper: TypeAlias = Callable[[Coroutine[Any, Any, Any]], Any]
-    def set_coroutine_wrapper(__wrapper: _CoroWrapper) -> None: ...
-    def get_coroutine_wrapper() -> _CoroWrapper: ...
-
-# The following two functions were added in 3.11.0, 3.10.7, 3.9.14, 3.8.14, & 3.7.14,
+# The following two functions were added in 3.11.0, 3.10.7, 3.9.14, and 3.8.14,
 # 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):
+    if sys.version_info >= (3, 13):
+        def getunicodeinternedsize(*, _only_immortal: bool = False) -> int: ...
+    else:
+        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: ...
+
+    from . import _monitoring
+
+    monitoring = _monitoring
diff --git a/mypy/typeshed/stdlib/sys/_monitoring.pyi b/mypy/typeshed/stdlib/sys/_monitoring.pyi
new file mode 100644
index 000000000000..0507eeedc26d
--- /dev/null
+++ b/mypy/typeshed/stdlib/sys/_monitoring.pyi
@@ -0,0 +1,52 @@
+# This py312+ module provides annotations for `sys.monitoring`.
+# It's named `sys._monitoring` in typeshed,
+# because trying to import `sys.monitoring` will fail at runtime!
+# At runtime, `sys.monitoring` has the unique status
+# of being a `types.ModuleType` instance that cannot be directly imported,
+# and exists in the `sys`-module namespace despite `sys` not being a package.
+
+from collections.abc import Callable
+from types import CodeType
+from typing import Any
+
+DEBUGGER_ID: int
+COVERAGE_ID: int
+PROFILER_ID: int
+OPTIMIZER_ID: int
+
+def use_tool_id(tool_id: int, name: str, /) -> None: ...
+def free_tool_id(tool_id: int, /) -> None: ...
+def get_tool(tool_id: int, /) -> str | None: ...
+
+events: _events
+
+class _events:
+    BRANCH: int
+    CALL: int
+    C_RAISE: int
+    C_RETURN: int
+    EXCEPTION_HANDLED: int
+    INSTRUCTION: int
+    JUMP: int
+    LINE: int
+    NO_EVENTS: int
+    PY_RESUME: int
+    PY_RETURN: int
+    PY_START: int
+    PY_THROW: int
+    PY_UNWIND: int
+    PY_YIELD: int
+    RAISE: int
+    RERAISE: int
+    STOP_ITERATION: int
+
+def get_events(tool_id: int, /) -> int: ...
+def set_events(tool_id: int, event_set: int, /) -> None: ...
+def get_local_events(tool_id: int, code: CodeType, /) -> int: ...
+def set_local_events(tool_id: int, code: CodeType, event_set: int, /) -> int: ...
+def restart_events() -> None: ...
+
+DISABLE: object
+MISSING: object
+
+def register_callback(tool_id: int, event: int, func: Callable[..., Any] | None, /) -> Callable[..., Any] | None: ...
diff --git a/mypy/typeshed/stdlib/sysconfig.pyi b/mypy/typeshed/stdlib/sysconfig.pyi
index 7e29cf1326d6..807a979050e8 100644
--- a/mypy/typeshed/stdlib/sysconfig.pyi
+++ b/mypy/typeshed/stdlib/sysconfig.pyi
@@ -1,6 +1,6 @@
 import sys
-from typing import IO, Any, overload
-from typing_extensions import Literal
+from typing import IO, Any, Literal, overload
+from typing_extensions import deprecated
 
 __all__ = [
     "get_config_h_filename",
@@ -16,11 +16,15 @@ __all__ = [
     "parse_config_h",
 ]
 
+@overload
+@deprecated("SO is deprecated, use EXT_SUFFIX. Support is removed in Python 3.11")
+def get_config_var(name: Literal["SO"]) -> Any: ...
+@overload
 def get_config_var(name: str) -> Any: ...
 @overload
 def get_config_vars() -> dict[str, Any]: ...
 @overload
-def get_config_vars(arg: str, *args: str) -> list[Any]: ...
+def get_config_vars(arg: str, /, *args: str) -> list[Any]: ...
 def get_scheme_names() -> tuple[str, ...]: ...
 
 if sys.version_info >= (3, 10):
diff --git a/mypy/typeshed/stdlib/syslog.pyi b/mypy/typeshed/stdlib/syslog.pyi
index cfa8df887c1b..1e0d0d383902 100644
--- a/mypy/typeshed/stdlib/syslog.pyi
+++ b/mypy/typeshed/stdlib/syslog.pyi
@@ -1,46 +1,56 @@
 import sys
-from typing import overload
-from typing_extensions import Literal
+from typing import Final, overload
 
 if sys.platform != "win32":
-    LOG_ALERT: Literal[1]
-    LOG_AUTH: Literal[32]
-    LOG_AUTHPRIV: Literal[80]
-    LOG_CONS: Literal[2]
-    LOG_CRIT: Literal[2]
-    LOG_CRON: Literal[72]
-    LOG_DAEMON: Literal[24]
-    LOG_DEBUG: Literal[7]
-    LOG_EMERG: Literal[0]
-    LOG_ERR: Literal[3]
-    LOG_INFO: Literal[6]
-    LOG_KERN: Literal[0]
-    LOG_LOCAL0: Literal[128]
-    LOG_LOCAL1: Literal[136]
-    LOG_LOCAL2: Literal[144]
-    LOG_LOCAL3: Literal[152]
-    LOG_LOCAL4: Literal[160]
-    LOG_LOCAL5: Literal[168]
-    LOG_LOCAL6: Literal[176]
-    LOG_LOCAL7: Literal[184]
-    LOG_LPR: Literal[48]
-    LOG_MAIL: Literal[16]
-    LOG_NDELAY: Literal[8]
-    LOG_NEWS: Literal[56]
-    LOG_NOTICE: Literal[5]
-    LOG_NOWAIT: Literal[16]
-    LOG_ODELAY: Literal[4]
-    LOG_PERROR: Literal[32]
-    LOG_PID: Literal[1]
-    LOG_SYSLOG: Literal[40]
-    LOG_USER: Literal[8]
-    LOG_UUCP: Literal[64]
-    LOG_WARNING: Literal[4]
-    def LOG_MASK(a: int) -> int: ...
-    def LOG_UPTO(a: int) -> int: ...
+    LOG_ALERT: Final = 1
+    LOG_AUTH: Final = 32
+    LOG_AUTHPRIV: Final = 80
+    LOG_CONS: Final = 2
+    LOG_CRIT: Final = 2
+    LOG_CRON: Final = 72
+    LOG_DAEMON: Final = 24
+    LOG_DEBUG: Final = 7
+    LOG_EMERG: Final = 0
+    LOG_ERR: Final = 3
+    LOG_INFO: Final = 6
+    LOG_KERN: Final = 0
+    LOG_LOCAL0: Final = 128
+    LOG_LOCAL1: Final = 136
+    LOG_LOCAL2: Final = 144
+    LOG_LOCAL3: Final = 152
+    LOG_LOCAL4: Final = 160
+    LOG_LOCAL5: Final = 168
+    LOG_LOCAL6: Final = 176
+    LOG_LOCAL7: Final = 184
+    LOG_LPR: Final = 48
+    LOG_MAIL: Final = 16
+    LOG_NDELAY: Final = 8
+    LOG_NEWS: Final = 56
+    LOG_NOTICE: Final = 5
+    LOG_NOWAIT: Final = 16
+    LOG_ODELAY: Final = 4
+    LOG_PERROR: Final = 32
+    LOG_PID: Final = 1
+    LOG_SYSLOG: Final = 40
+    LOG_USER: Final = 8
+    LOG_UUCP: Final = 64
+    LOG_WARNING: Final = 4
+
+    if sys.version_info >= (3, 13):
+        LOG_FTP: Final = 88
+
+        if sys.platform == "darwin":
+            LOG_INSTALL: Final = 112
+            LOG_LAUNCHD: Final = 192
+            LOG_NETINFO: Final = 96
+            LOG_RAS: Final = 120
+            LOG_REMOTEAUTH: Final = 104
+
+    def LOG_MASK(pri: int, /) -> int: ...
+    def LOG_UPTO(pri: int, /) -> int: ...
     def closelog() -> None: ...
     def openlog(ident: str = ..., logoption: int = ..., facility: int = ...) -> None: ...
-    def setlogmask(x: int) -> int: ...
+    def setlogmask(maskpri: int, /) -> int: ...
     @overload
     def syslog(priority: int, message: str) -> None: ...
     @overload
diff --git a/mypy/typeshed/stdlib/tarfile.pyi b/mypy/typeshed/stdlib/tarfile.pyi
index 5cf1d55cac63..6a00e070aee9 100644
--- a/mypy/typeshed/stdlib/tarfile.pyi
+++ b/mypy/typeshed/stdlib/tarfile.pyi
@@ -1,13 +1,13 @@
 import bz2
 import io
 import sys
-from _typeshed import StrOrBytesPath, StrPath
+from _typeshed import ReadableBuffer, StrOrBytesPath, StrPath, SupportsRead, WriteableBuffer
 from builtins import list as _list  # aliases to avoid name clashes with fields named "type" or "list"
 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 import IO, ClassVar, Literal, Protocol, overload
+from typing_extensions import Self, TypeAlias
 
 __all__ = [
     "TarFile",
@@ -26,12 +26,27 @@ __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: ...
-    def write(self, __b: bytes) -> object: ...
+    def read(self, size: int, /) -> bytes: ...
+    def write(self, b: bytes, /) -> object: ...
     def tell(self) -> int: ...
-    def seek(self, __pos: int) -> object: ...
+    def seek(self, pos: int, /) -> object: ...
     def close(self) -> object: ...
     # Optional fields:
     # name: str | bytes
@@ -88,24 +103,6 @@ PAX_NAME_FIELDS: set[str]
 
 ENCODING: str
 
-def open(
-    name: StrOrBytesPath | None = None,
-    mode: str = "r",
-    fileobj: IO[bytes] | None = None,  # depends on mode
-    bufsize: int = 10240,
-    *,
-    format: int | None = ...,
-    tarinfo: type[TarInfo] | None = ...,
-    dereference: bool | None = ...,
-    ignore_zeros: bool | None = ...,
-    encoding: str | None = ...,
-    errors: str = ...,
-    pax_headers: Mapping[str, str] | None = ...,
-    debug: int | None = ...,
-    errorlevel: int | None = ...,
-    compresslevel: int | None = ...,
-) -> TarFile: ...
-
 class ExFileObject(io.BufferedReader):
     def __init__(self, tarfile: TarFile, tarinfo: TarInfo) -> None: ...
 
@@ -125,35 +122,135 @@ class TarFile:
     debug: int | None
     errorlevel: int | None
     offset: int  # undocumented
-    def __init__(
-        self,
-        name: StrOrBytesPath | None = None,
-        mode: Literal["r", "a", "w", "x"] = "r",
-        fileobj: _Fileobj | None = None,
-        format: int | None = None,
-        tarinfo: type[TarInfo] | None = None,
-        dereference: bool | None = None,
-        ignore_zeros: bool | None = None,
-        encoding: str | None = None,
-        errors: str = "surrogateescape",
-        pax_headers: Mapping[str, str] | None = None,
-        debug: int | None = None,
-        errorlevel: int | None = None,
-        copybufsize: int | None = None,  # undocumented
-    ) -> None: ...
+    extraction_filter: _FilterFunction | None
+    if sys.version_info >= (3, 13):
+        stream: bool
+        def __init__(
+            self,
+            name: StrOrBytesPath | None = None,
+            mode: Literal["r", "a", "w", "x"] = "r",
+            fileobj: _Fileobj | None = None,
+            format: int | None = None,
+            tarinfo: type[TarInfo] | None = None,
+            dereference: bool | None = None,
+            ignore_zeros: bool | None = None,
+            encoding: str | None = None,
+            errors: str = "surrogateescape",
+            pax_headers: Mapping[str, str] | None = None,
+            debug: int | None = None,
+            errorlevel: int | None = None,
+            copybufsize: int | None = None,  # undocumented
+            stream: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: StrOrBytesPath | None = None,
+            mode: Literal["r", "a", "w", "x"] = "r",
+            fileobj: _Fileobj | None = None,
+            format: int | None = None,
+            tarinfo: type[TarInfo] | None = None,
+            dereference: bool | None = None,
+            ignore_zeros: bool | None = None,
+            encoding: str | None = None,
+            errors: str = "surrogateescape",
+            pax_headers: Mapping[str, str] | None = None,
+            debug: int | None = None,
+            errorlevel: int | None = None,
+            copybufsize: int | None = None,  # undocumented
+        ) -> None: ...
+
     def __enter__(self) -> Self: ...
     def __exit__(
         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
     ) -> None: ...
     def __iter__(self) -> Iterator[TarInfo]: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | None = None,
+        mode: Literal["r", "r:*", "r:", "r:gz", "r:bz2", "r:xz"] = "r",
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["x", "x:", "a", "a:", "w", "w:", "w:tar"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
     @classmethod
     def open(
         cls,
         name: StrOrBytesPath | None = None,
-        mode: str = "r",
-        fileobj: IO[bytes] | None = None,  # depends on mode
+        *,
+        mode: Literal["x", "x:", "a", "a:", "w", "w:", "w:tar"],
+        fileobj: _Fileobj | None = None,
         bufsize: int = 10240,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["x:gz", "x:bz2", "w:gz", "w:bz2"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+        compresslevel: int = 9,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | None = None,
         *,
+        mode: Literal["x:gz", "x:bz2", "w:gz", "w:bz2"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
         format: int | None = ...,
         tarinfo: type[TarInfo] | None = ...,
         dereference: bool | None = ...,
@@ -163,6 +260,105 @@ class TarFile:
         pax_headers: Mapping[str, str] | None = ...,
         debug: int | None = ...,
         errorlevel: int | None = ...,
+        compresslevel: int = 9,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | None,
+        mode: Literal["x:xz", "w:xz"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        *,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+        preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | None = None,
+        *,
+        mode: Literal["x:xz", "w:xz"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+        preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | ReadableBuffer | None = None,
+        *,
+        mode: Literal["r|*", "r|", "r|gz", "r|bz2", "r|xz"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | WriteableBuffer | None = None,
+        *,
+        mode: Literal["w|", "w|xz"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+    ) -> Self: ...
+    @overload
+    @classmethod
+    def open(
+        cls,
+        name: StrOrBytesPath | WriteableBuffer | None = None,
+        *,
+        mode: Literal["w|gz", "w|bz2"],
+        fileobj: _Fileobj | None = None,
+        bufsize: int = 10240,
+        format: int | None = ...,
+        tarinfo: type[TarInfo] | None = ...,
+        dereference: bool | None = ...,
+        ignore_zeros: bool | None = ...,
+        encoding: str | None = ...,
+        errors: str = ...,
+        pax_headers: Mapping[str, str] | None = ...,
+        debug: int | None = ...,
+        errorlevel: int | None = ...,
+        compresslevel: int = 9,
     ) -> Self: ...
     @classmethod
     def taropen(
@@ -275,11 +471,25 @@ class TarFile:
     def getnames(self) -> _list[str]: ...
     def list(self, verbose: bool = True, *, members: _list[TarInfo] | None = None) -> None: ...
     def next(self) -> TarInfo | None: ...
+    # Calling this method without `filter` is deprecated, but it may be set either on the class or in an
+    # individual call, so we can't mark it as @deprecated here.
     def extractall(
-        self, path: StrOrBytesPath = ".", members: Iterable[TarInfo] | None = None, *, numeric_owner: bool = False
+        self,
+        path: StrOrBytesPath = ".",
+        members: Iterable[TarInfo] | None = None,
+        *,
+        numeric_owner: bool = False,
+        filter: _TarfileFilter | None = ...,
     ) -> None: ...
+    # Same situation as for `extractall`.
     def extract(
-        self, member: str | TarInfo, path: StrOrBytesPath = "", set_attrs: bool = True, *, numeric_owner: bool = False
+        self,
+        member: str | TarInfo,
+        path: StrOrBytesPath = "",
+        set_attrs: bool = True,
+        *,
+        numeric_owner: bool = False,
+        filter: _TarfileFilter | None = ...,
     ) -> None: ...
     def _extract_member(
         self, tarinfo: TarInfo, targetpath: str, set_attrs: bool = True, numeric_owner: bool = False
@@ -302,21 +512,20 @@ class TarFile:
         *,
         filter: Callable[[TarInfo], TarInfo | None] | None = None,
     ) -> None: ...
-    def addfile(self, tarinfo: TarInfo, fileobj: IO[bytes] | None = None) -> None: ...
+    def addfile(self, tarinfo: TarInfo, fileobj: SupportsRead[bytes] | None = None) -> None: ...
     def gettarinfo(
         self, name: StrOrBytesPath | None = None, arcname: str | None = None, fileobj: IO[bytes] | None = None
     ) -> TarInfo: ...
     def close(self) -> None: ...
 
+open = TarFile.open
+
 if sys.version_info >= (3, 9):
     def is_tarfile(name: StrOrBytesPath | IO[bytes]) -> bool: ...
 
 else:
     def is_tarfile(name: StrOrBytesPath) -> bool: ...
 
-if sys.version_info < (3, 8):
-    def filemode(mode: int) -> str: ...  # undocumented
-
 class TarError(Exception): ...
 class ReadError(TarError): ...
 class CompressionError(TarError): ...
@@ -324,11 +533,35 @@ class StreamError(TarError): ...
 class ExtractError(TarError): ...
 class HeaderError(TarError): ...
 
+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
     size: int
-    mtime: int
+    mtime: int | float
     chksum: int
     devmajor: int
     devminor: int
@@ -353,12 +586,21 @@ class TarInfo:
     def linkpath(self) -> str: ...
     @linkpath.setter
     def linkpath(self, linkname: str) -> None: ...
+    def replace(
+        self,
+        *,
+        name: str = ...,
+        mtime: float = ...,
+        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: ...
-    else:
-        def tobuf(self, format: int | None = 1, encoding: str | None = "utf-8", errors: str = "surrogateescape") -> bytes: ...
-
+    def tobuf(self, format: int | None = 2, encoding: str | None = "utf-8", errors: str = "surrogateescape") -> bytes: ...
     def create_ustar_header(
         self, info: Mapping[str, str | int | bytes | Mapping[str, str]], encoding: str, errors: str
     ) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/telnetlib.pyi b/mypy/typeshed/stdlib/telnetlib.pyi
index 10f6e4930f75..6b599256d17b 100644
--- a/mypy/typeshed/stdlib/telnetlib.pyi
+++ b/mypy/typeshed/stdlib/telnetlib.pyi
@@ -1,5 +1,5 @@
 import socket
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, MutableSequence, Sequence
 from re import Match, Pattern
 from types import TracebackType
 from typing import Any
@@ -88,6 +88,7 @@ NOOPT: bytes
 
 class Telnet:
     host: str | None  # undocumented
+    sock: socket.socket | None  # undocumented
     def __init__(self, host: str | None = None, port: int = 0, timeout: float = ...) -> None: ...
     def open(self, host: str, port: int = 0, timeout: float = ...) -> None: ...
     def msg(self, msg: str, *args: Any) -> None: ...
@@ -113,9 +114,10 @@ class Telnet:
     def mt_interact(self) -> None: ...
     def listener(self) -> None: ...
     def expect(
-        self, list: Sequence[Pattern[bytes] | bytes], timeout: float | None = None
+        self, list: MutableSequence[Pattern[bytes] | bytes] | Sequence[Pattern[bytes]], timeout: float | None = None
     ) -> tuple[int, Match[bytes] | None, bytes]: ...
     def __enter__(self) -> Self: ...
     def __exit__(
         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
     ) -> None: ...
+    def __del__(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/tempfile.pyi b/mypy/typeshed/stdlib/tempfile.pyi
index cd27e91fbc75..d2677603bc47 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 import IO, Any, AnyStr, Generic, Literal, overload
+from typing_extensions import Self
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -30,13 +41,10 @@ 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, 8):
+if sys.version_info >= (3, 12):
     @overload
     def NamedTemporaryFile(
-        mode: _StrMode,
+        mode: OpenTextMode,
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -46,10 +54,11 @@ if sys.version_info >= (3, 8):
         delete: bool = True,
         *,
         errors: str | None = None,
+        delete_on_close: bool = True,
     ) -> _TemporaryFileWrapper[str]: ...
     @overload
     def NamedTemporaryFile(
-        mode: _BytesMode = "w+b",
+        mode: OpenBinaryMode = "w+b",
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -59,6 +68,7 @@ if sys.version_info >= (3, 8):
         delete: bool = True,
         *,
         errors: str | None = None,
+        delete_on_close: bool = True,
     ) -> _TemporaryFileWrapper[bytes]: ...
     @overload
     def NamedTemporaryFile(
@@ -72,12 +82,13 @@ if sys.version_info >= (3, 8):
         delete: bool = True,
         *,
         errors: str | None = None,
+        delete_on_close: bool = True,
     ) -> _TemporaryFileWrapper[Any]: ...
 
 else:
     @overload
     def NamedTemporaryFile(
-        mode: _StrMode,
+        mode: OpenTextMode,
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -85,10 +96,12 @@ else:
         prefix: AnyStr | None = None,
         dir: GenericPath[AnyStr] | None = None,
         delete: bool = True,
+        *,
+        errors: str | None = None,
     ) -> _TemporaryFileWrapper[str]: ...
     @overload
     def NamedTemporaryFile(
-        mode: _BytesMode = "w+b",
+        mode: OpenBinaryMode = "w+b",
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -96,6 +109,8 @@ else:
         prefix: AnyStr | None = None,
         dir: GenericPath[AnyStr] | None = None,
         delete: bool = True,
+        *,
+        errors: str | None = None,
     ) -> _TemporaryFileWrapper[bytes]: ...
     @overload
     def NamedTemporaryFile(
@@ -107,85 +122,107 @@ else:
         prefix: AnyStr | None = None,
         dir: GenericPath[AnyStr] | None = None,
         delete: bool = True,
+        *,
+        errors: str | None = None,
     ) -> _TemporaryFileWrapper[Any]: ...
 
 if sys.platform == "win32":
     TemporaryFile = NamedTemporaryFile
 else:
-    if sys.version_info >= (3, 8):
-        @overload
-        def TemporaryFile(
-            mode: _StrMode,
-            buffering: int = -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[str]: ...
-        @overload
-        def TemporaryFile(
-            mode: _BytesMode = "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,
-            *,
-            errors: str | None = None,
-        ) -> IO[bytes]: ...
-        @overload
-        def TemporaryFile(
-            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,
-            *,
-            errors: str | None = None,
-        ) -> IO[Any]: ...
-    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]: ...
-        @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]: ...
-        @overload
-        def TemporaryFile(
-            mode: str = ...,
-            buffering: int = ...,
-            encoding: str | None = ...,
-            newline: str | None = ...,
-            suffix: AnyStr | None = ...,
-            prefix: AnyStr | None = ...,
-            dir: GenericPath[AnyStr] | None = ...,
-        ) -> IO[Any]: ...
+    # See the comments for builtins.open() for an explanation of the overloads.
+    @overload
+    def TemporaryFile(
+        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,
+        *,
+        errors: str | 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,
+        *,
+        errors: str | 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,
+        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",
+        buffering: int = -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[Any]: ...
 
-class _TemporaryFileWrapper(Generic[AnyStr], IO[AnyStr]):
+class _TemporaryFileWrapper(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: ...
@@ -216,17 +253,19 @@ class _TemporaryFileWrapper(Generic[AnyStr], IO[AnyStr]):
     def truncate(self, size: int | None = ...) -> int: ...
     def writable(self) -> bool: ...
     @overload
-    def write(self: _TemporaryFileWrapper[str], s: str) -> int: ...
+    def write(self: _TemporaryFileWrapper[str], s: str, /) -> int: ...
     @overload
-    def write(self: _TemporaryFileWrapper[bytes], s: ReadableBuffer) -> int: ...
+    def write(self: _TemporaryFileWrapper[bytes], s: ReadableBuffer, /) -> int: ...
     @overload
-    def write(self, s: AnyStr) -> int: ...
+    def write(self, s: AnyStr, /) -> int: ...
     @overload
     def writelines(self: _TemporaryFileWrapper[str], lines: Iterable[str]) -> None: ...
     @overload
     def writelines(self: _TemporaryFileWrapper[bytes], lines: Iterable[ReadableBuffer]) -> None: ...
     @overload
     def writelines(self, lines: Iterable[AnyStr]) -> None: ...
+    @property
+    def closed(self) -> bool: ...
 
 if sys.version_info >= (3, 11):
     _SpooledTemporaryFileBase = io.IOBase
@@ -236,148 +275,84 @@ 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
     def newlines(self) -> str | tuple[str, ...] | None: ...  # undocumented
     # bytes needs to go first, as default mode is to open as bytes
-    if sys.version_info >= (3, 8):
-        @overload
-        def __init__(
-            self: SpooledTemporaryFile[bytes],
-            max_size: int = 0,
-            mode: _BytesMode = "w+b",
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-            *,
-            errors: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: SpooledTemporaryFile[str],
-            max_size: int,
-            mode: _StrMode,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-            *,
-            errors: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: SpooledTemporaryFile[str],
-            max_size: int = 0,
-            *,
-            mode: _StrMode,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-            errors: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            max_size: int,
-            mode: str,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-            *,
-            errors: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            max_size: int = 0,
-            *,
-            mode: str,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-            errors: str | None = None,
-        ) -> None: ...
-        @property
-        def errors(self) -> str | None: ...
-    else:
-        @overload
-        def __init__(
-            self: SpooledTemporaryFile[bytes],
-            max_size: int = 0,
-            mode: _BytesMode = "w+b",
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: SpooledTemporaryFile[str],
-            max_size: int,
-            mode: _StrMode,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: SpooledTemporaryFile[str],
-            max_size: int = 0,
-            *,
-            mode: _StrMode,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            max_size: int,
-            mode: str,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            max_size: int = 0,
-            *,
-            mode: str,
-            buffering: int = -1,
-            encoding: str | None = None,
-            newline: str | None = None,
-            suffix: str | None = None,
-            prefix: str | None = None,
-            dir: str | None = None,
-        ) -> None: ...
-
+    @overload
+    def __init__(
+        self: SpooledTemporaryFile[bytes],
+        max_size: int = 0,
+        mode: OpenBinaryMode = "w+b",
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        *,
+        errors: str | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: SpooledTemporaryFile[str],
+        max_size: int,
+        mode: OpenTextMode,
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        *,
+        errors: str | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: SpooledTemporaryFile[str],
+        max_size: int = 0,
+        *,
+        mode: OpenTextMode,
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        errors: str | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        max_size: int,
+        mode: str,
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        *,
+        errors: str | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        max_size: int = 0,
+        *,
+        mode: str,
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        errors: str | None = None,
+    ) -> None: ...
+    @property
+    def errors(self) -> str | None: ...
     def rollover(self) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, exc: type[BaseException] | None, value: BaseException | None, tb: TracebackType | None) -> None: ...
@@ -391,24 +366,28 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
     if sys.version_info >= (3, 11):
         # These three work only if the SpooledTemporaryFile is opened in binary mode,
         # because the underlying object in text mode does not have these methods.
-        def read1(self, __size: int = ...) -> AnyStr: ...
+        def read1(self, size: int = ..., /) -> AnyStr: ...
         def readinto(self, b: WriteableBuffer) -> int: ...
         def readinto1(self, b: WriteableBuffer) -> int: ...
         def detach(self) -> io.RawIOBase: ...
 
-    def read(self, __n: int = ...) -> AnyStr: ...
-    def readline(self, __limit: int | None = ...) -> AnyStr: ...  # type: ignore[override]
-    def readlines(self, __hint: int = ...) -> list[AnyStr]: ...  # type: ignore[override]
+    def read(self, n: int = ..., /) -> AnyStr: ...
+    def readline(self, limit: int | None = ..., /) -> AnyStr: ...  # type: ignore[override]
+    def readlines(self, hint: int = ..., /) -> list[AnyStr]: ...  # type: ignore[override]
     def seek(self, offset: int, whence: int = ...) -> int: ...
     def tell(self) -> int: ...
-    def truncate(self, size: int | None = None) -> None: ...  # type: ignore[override]
+    if sys.version_info >= (3, 11):
+        def truncate(self, size: int | None = None) -> int: ...
+    else:
+        def truncate(self, size: int | None = None) -> None: ...  # type: ignore[override]
+
     @overload
     def write(self: SpooledTemporaryFile[str], s: str) -> int: ...
     @overload
     def write(self: SpooledTemporaryFile[bytes], s: ReadableBuffer) -> int: ...
     @overload
     def write(self, s: AnyStr) -> int: ...
-    @overload
+    @overload  #  type: ignore[override]
     def writelines(self: SpooledTemporaryFile[str], iterable: Iterable[str]) -> None: ...
     @overload
     def writelines(self: SpooledTemporaryFile[bytes], iterable: Iterable[ReadableBuffer]) -> None: ...
@@ -421,11 +400,32 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
     def writable(self) -> bool: ...
     def __next__(self) -> AnyStr: ...  # type: ignore[override]
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 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],
@@ -459,11 +459,11 @@ class TemporaryDirectory(Generic[AnyStr]):
     def __enter__(self) -> AnyStr: ...
     def __exit__(self, exc: type[BaseException] | None, value: BaseException | None, tb: TracebackType | None) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # The overloads overlap, but they should still work fine.
 @overload
-def mkstemp(  # type: ignore[misc]
+def mkstemp(
     suffix: str | None = None, prefix: str | None = None, dir: StrPath | None = None, text: bool = False
 ) -> tuple[int, str]: ...
 @overload
@@ -473,7 +473,7 @@ def mkstemp(
 
 # The overloads overlap, but they should still work fine.
 @overload
-def mkdtemp(suffix: str | None = None, prefix: str | None = None, dir: StrPath | None = None) -> str: ...  # type: ignore[misc]
+def mkdtemp(suffix: str | None = None, prefix: str | None = None, dir: StrPath | None = None) -> str: ...
 @overload
 def mkdtemp(suffix: bytes | None = None, prefix: bytes | None = None, dir: BytesPath | None = None) -> bytes: ...
 def mktemp(suffix: str = "", prefix: str = "tmp", dir: StrPath | None = None) -> str: ...
diff --git a/mypy/typeshed/stdlib/termios.pyi b/mypy/typeshed/stdlib/termios.pyi
index bf8d7bee2473..5a5a1f53be3c 100644
--- a/mypy/typeshed/stdlib/termios.pyi
+++ b/mypy/typeshed/stdlib/termios.pyi
@@ -3,63 +3,45 @@ from _typeshed import FileDescriptorLike
 from typing import Any
 from typing_extensions import TypeAlias
 
-if sys.platform != "win32":
-    # Must be a list of length 7, containing 6 ints and a list of NCCS 1-character bytes or ints.
-    _Attr: TypeAlias = list[int | list[bytes | int]]
+# Must be a list of length 7, containing 6 ints and a list of NCCS 1-character bytes or ints.
+_Attr: TypeAlias = list[int | list[bytes | int]] | list[int | list[bytes]] | list[int | list[int]]
+# Same as _Attr for return types; we use Any to avoid a union.
+_AttrReturn: TypeAlias = list[Any]
 
+if sys.platform != "win32":
     B0: int
-    B1000000: int
     B110: int
     B115200: int
-    B1152000: int
     B1200: int
     B134: int
     B150: int
-    B1500000: int
     B1800: int
     B19200: int
     B200: int
-    B2000000: int
     B230400: int
     B2400: int
-    B2500000: int
     B300: int
-    B3000000: int
-    B3500000: int
     B38400: int
-    B4000000: int
-    B460800: int
     B4800: int
     B50: int
-    B500000: int
     B57600: int
-    B576000: int
     B600: int
     B75: int
-    B921600: int
     B9600: int
     BRKINT: int
     BS0: int
     BS1: int
     BSDLY: int
-    CBAUD: int
-    CBAUDEX: int
-    CDEL: int
     CDSUSP: int
     CEOF: int
     CEOL: int
-    CEOL2: int
     CEOT: int
     CERASE: int
-    CESC: int
     CFLUSH: int
-    CIBAUD: int
     CINTR: int
     CKILL: int
     CLNEXT: int
     CLOCAL: int
-    CNUL: int
-    COMMON: int
     CQUIT: int
     CR0: int
     CR1: int
@@ -78,7 +60,6 @@ if sys.platform != "win32":
     CSTOP: int
     CSTOPB: int
     CSUSP: int
-    CSWTCH: int
     CWERASE: int
     ECHO: int
     ECHOCTL: int
@@ -99,7 +80,6 @@ if sys.platform != "win32":
     FIONREAD: int
     FLUSHO: int
     HUPCL: int
-    IBSHIFT: int
     ICANON: int
     ICRNL: int
     IEXTEN: int
@@ -107,33 +87,21 @@ if sys.platform != "win32":
     IGNCR: int
     IGNPAR: int
     IMAXBEL: int
-    INIT_C_CC: int
     INLCR: int
     INPCK: int
-    IOCSIZE_MASK: int
-    IOCSIZE_SHIFT: int
     ISIG: int
     ISTRIP: int
-    IUCLC: int
     IXANY: int
     IXOFF: int
     IXON: int
-    N_MOUSE: int
-    N_PPP: int
-    N_SLIP: int
-    N_STRIP: int
-    N_TTY: int
-    NCC: int
     NCCS: int
     NL0: int
     NL1: int
     NLDLY: int
     NOFLSH: int
-    NSWTCH: int
     OCRNL: int
     OFDEL: int
     OFILL: int
-    OLCUC: int
     ONLCR: int
     ONLRET: int
     ONOCR: int
@@ -147,9 +115,6 @@ if sys.platform != "win32":
     TAB2: int
     TAB3: int
     TABDLY: int
-    TCFLSH: int
-    TCGETA: int
-    TCGETS: int
     TCIFLUSH: int
     TCIOFF: int
     TCIOFLUSH: int
@@ -160,28 +125,11 @@ if sys.platform != "win32":
     TCSADRAIN: int
     TCSAFLUSH: int
     TCSANOW: int
-    TCSASOFT: int
-    TCSBRK: int
-    TCSBRKP: int
-    TCSETA: int
-    TCSETAF: int
-    TCSETAW: int
-    TCSETS: int
-    TCSETSF: int
-    TCSETSW: int
-    TCXONC: int
     TIOCCONS: int
     TIOCEXCL: int
     TIOCGETD: int
-    TIOCGICOUNT: int
-    TIOCGLCKTRMIOS: int
     TIOCGPGRP: int
-    TIOCGSERIAL: int
-    TIOCGSIZE: int
-    TIOCGSOFTCAR: int
     TIOCGWINSZ: int
-    TIOCINQ: int
-    TIOCLINUX: int
     TIOCM_CAR: int
     TIOCM_CD: int
     TIOCM_CTS: int
@@ -196,7 +144,6 @@ if sys.platform != "win32":
     TIOCMBIC: int
     TIOCMBIS: int
     TIOCMGET: int
-    TIOCMIWAIT: int
     TIOCMSET: int
     TIOCNOTTY: int
     TIOCNXCL: int
@@ -210,23 +157,10 @@ if sys.platform != "win32":
     TIOCPKT_STOP: int
     TIOCPKT: int
     TIOCSCTTY: int
-    TIOCSER_TEMT: int
-    TIOCSERCONFIG: int
-    TIOCSERGETLSR: int
-    TIOCSERGETMULTI: int
-    TIOCSERGSTRUCT: int
-    TIOCSERGWILD: int
-    TIOCSERSETMULTI: int
-    TIOCSERSWILD: int
     TIOCSETD: int
-    TIOCSLCKTRMIOS: int
     TIOCSPGRP: int
-    TIOCSSERIAL: int
-    TIOCSSIZE: int
-    TIOCSSOFTCAR: int
     TIOCSTI: int
     TIOCSWINSZ: int
-    TIOCTTYGSTRUCT: int
     TOSTOP: int
     VDISCARD: int
     VEOF: int
@@ -242,24 +176,128 @@ if sys.platform != "win32":
     VSTART: int
     VSTOP: int
     VSUSP: int
-    VSWTC: int
-    VSWTCH: int
     VT0: int
     VT1: int
     VTDLY: int
     VTIME: int
     VWERASE: int
-    XCASE: int
-    XTABS: int
 
-    def tcgetattr(__fd: FileDescriptorLike) -> list[Any]: ...  # Returns _Attr; we use Any to avoid a union in the return type
-    def tcsetattr(__fd: FileDescriptorLike, __when: int, __attributes: _Attr) -> None: ...
-    def tcsendbreak(__fd: FileDescriptorLike, __duration: int) -> None: ...
-    def tcdrain(__fd: FileDescriptorLike) -> None: ...
-    def tcflush(__fd: FileDescriptorLike, __queue: int) -> None: ...
-    def tcflow(__fd: FileDescriptorLike, __action: int) -> None: ...
+    if sys.version_info >= (3, 13):
+        EXTPROC: int
+        IUTF8: int
+
+    if sys.platform == "darwin" and sys.version_info >= (3, 13):
+        ALTWERASE: int
+        B14400: int
+        B28800: int
+        B7200: int
+        B76800: int
+        CCAR_OFLOW: int
+        CCTS_OFLOW: int
+        CDSR_OFLOW: int
+        CDTR_IFLOW: int
+        CIGNORE: int
+        CRTS_IFLOW: int
+        MDMBUF: int
+        NL2: int
+        NL3: int
+        NOKERNINFO: int
+        ONOEOT: int
+        OXTABS: int
+        VDSUSP: int
+        VSTATUS: int
+
+    if sys.platform == "darwin" and sys.version_info >= (3, 11):
+        TIOCGSIZE: int
+        TIOCSSIZE: int
+
+    if sys.platform == "linux":
+        B1152000: int
+        B576000: int
+        CBAUD: int
+        CBAUDEX: int
+        CIBAUD: int
+        IOCSIZE_MASK: int
+        IOCSIZE_SHIFT: int
+        IUCLC: int
+        N_MOUSE: int
+        N_PPP: int
+        N_SLIP: int
+        N_STRIP: int
+        N_TTY: int
+        NCC: int
+        OLCUC: int
+        TCFLSH: int
+        TCGETA: int
+        TCGETS: int
+        TCSBRK: int
+        TCSBRKP: int
+        TCSETA: int
+        TCSETAF: int
+        TCSETAW: int
+        TCSETS: int
+        TCSETSF: int
+        TCSETSW: int
+        TCXONC: int
+        TIOCGICOUNT: int
+        TIOCGLCKTRMIOS: int
+        TIOCGSERIAL: int
+        TIOCGSOFTCAR: int
+        TIOCINQ: int
+        TIOCLINUX: int
+        TIOCMIWAIT: int
+        TIOCTTYGSTRUCT: int
+        TIOCSER_TEMT: int
+        TIOCSERCONFIG: int
+        TIOCSERGETLSR: int
+        TIOCSERGETMULTI: int
+        TIOCSERGSTRUCT: int
+        TIOCSERGWILD: int
+        TIOCSERSETMULTI: int
+        TIOCSERSWILD: int
+        TIOCSLCKTRMIOS: int
+        TIOCSSERIAL: int
+        TIOCSSOFTCAR: int
+        VSWTC: int
+        VSWTCH: int
+        XCASE: int
+        XTABS: int
+
+    if sys.platform != "darwin":
+        B1000000: int
+        B1500000: int
+        B2000000: int
+        B2500000: int
+        B3000000: int
+        B3500000: int
+        B4000000: int
+        B460800: int
+        B500000: int
+        B921600: int
+
+    if sys.platform != "linux":
+        TCSASOFT: int
+
+    if sys.platform != "darwin" and sys.platform != "linux":
+        # not available on FreeBSD either.
+        CDEL: int
+        CEOL2: int
+        CESC: int
+        CNUL: int
+        COMMON: int
+        CSWTCH: int
+        IBSHIFT: int
+        INIT_C_CC: int
+        NSWTCH: int
+
+    def tcgetattr(fd: FileDescriptorLike, /) -> _AttrReturn: ...
+    def tcsetattr(fd: FileDescriptorLike, when: int, attributes: _Attr, /) -> None: ...
+    def tcsendbreak(fd: FileDescriptorLike, duration: int, /) -> None: ...
+    def tcdrain(fd: FileDescriptorLike, /) -> None: ...
+    def tcflush(fd: FileDescriptorLike, queue: int, /) -> None: ...
+    def tcflow(fd: FileDescriptorLike, action: int, /) -> None: ...
     if sys.version_info >= (3, 11):
-        def tcgetwinsize(__fd: FileDescriptorLike) -> tuple[int, int]: ...
-        def tcsetwinsize(__fd: FileDescriptorLike, __winsize: tuple[int, int]) -> None: ...
+        def tcgetwinsize(fd: FileDescriptorLike, /) -> tuple[int, int]: ...
+        def tcsetwinsize(fd: FileDescriptorLike, winsize: tuple[int, int], /) -> None: ...
 
     class error(Exception): ...
diff --git a/mypy/typeshed/stdlib/threading.pyi b/mypy/typeshed/stdlib/threading.pyi
index 6275e4552630..efeea69d0234 100644
--- a/mypy/typeshed/stdlib/threading.pyi
+++ b/mypy/typeshed/stdlib/threading.pyi
@@ -1,9 +1,10 @@
+import _thread
 import sys
+from _thread import _excepthook, _ExceptHookArgs, get_native_id as get_native_id
 from _typeshed import ProfileFunction, TraceFunction
 from collections.abc import Callable, Iterable, Mapping
 from types import TracebackType
-from typing import Any, TypeVar
-from typing_extensions import final
+from typing import Any, TypeVar, final
 
 _T = TypeVar("_T")
 
@@ -25,18 +26,21 @@ __all__ = [
     "BrokenBarrierError",
     "Timer",
     "ThreadError",
+    "ExceptHookArgs",
     "setprofile",
     "settrace",
     "local",
     "stack_size",
+    "excepthook",
+    "get_native_id",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["ExceptHookArgs", "excepthook", "get_native_id"]
-
 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: ...
@@ -46,27 +50,23 @@ def currentThread() -> Thread: ...  # deprecated alias for current_thread()
 def get_ident() -> int: ...
 def enumerate() -> list[Thread]: ...
 def main_thread() -> Thread: ...
-
-if sys.version_info >= (3, 8):
-    from _thread import get_native_id as get_native_id
-
 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: ...
 
-def stack_size(size: int = ...) -> int: ...
+def stack_size(size: int = 0, /) -> int: ...
 
 TIMEOUT_MAX: float
 
-class ThreadError(Exception): ...
-
-class local:
-    def __getattribute__(self, __name: str) -> Any: ...
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
-    def __delattr__(self, __name: str) -> None: ...
+ThreadError = _thread.error
+local = _thread._local
 
 class Thread:
     name: str
@@ -86,10 +86,8 @@ class Thread:
     def start(self) -> None: ...
     def run(self) -> None: ...
     def join(self, timeout: float | None = None) -> None: ...
-    if sys.version_info >= (3, 8):
-        @property
-        def native_id(self) -> int | None: ...  # only available on some platforms
-
+    @property
+    def native_id(self) -> int | None: ...  # only available on some platforms
     def is_alive(self) -> bool: ...
     if sys.version_info < (3, 9):
         def isAlive(self) -> bool: ...
@@ -102,27 +100,22 @@ class Thread:
 class _DummyThread(Thread):
     def __init__(self) -> None: ...
 
-@final
-class Lock:
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> None: ...
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
-    def release(self) -> None: ...
-    def locked(self) -> bool: ...
+# This is actually the function _thread.allocate_lock for <= 3.12
+Lock = _thread.LockType
 
+# Python implementation of RLock.
 @final
 class _RLock:
+    _count: int
     def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
     def release(self) -> None: ...
     __enter__ = acquire
     def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
 
-RLock = _RLock
+RLock = _thread.RLock  # Actually a function at runtime.
 
 class Condition:
-    def __init__(self, lock: Lock | _RLock | None = None) -> None: ...
+    def __init__(self, lock: Lock | _RLock | RLock | None = None) -> None: ...
     def __enter__(self) -> bool: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
@@ -155,11 +148,8 @@ class Event:
     def clear(self) -> None: ...
     def wait(self, timeout: float | None = None) -> bool: ...
 
-if sys.version_info >= (3, 8):
-    from _thread import _excepthook, _ExceptHookArgs
-
-    excepthook = _excepthook
-    ExceptHookArgs = _ExceptHookArgs
+excepthook = _excepthook
+ExceptHookArgs = _ExceptHookArgs
 
 class Timer(Thread):
     args: Iterable[Any]  # undocumented
diff --git a/mypy/typeshed/stdlib/time.pyi b/mypy/typeshed/stdlib/time.pyi
index 035d78934f3a..71cdc4d78fdc 100644
--- a/mypy/typeshed/stdlib/time.pyi
+++ b/mypy/typeshed/stdlib/time.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import structseq
-from typing import Any, Protocol
-from typing_extensions import Final, Literal, TypeAlias, final
+from typing import Any, Final, Literal, Protocol, final
+from typing_extensions import TypeAlias
 
 _TimeTuple: TypeAlias = tuple[int, int, int, int, int, int, int, int, int]
 
@@ -25,8 +25,11 @@ if sys.platform != "win32":
     if sys.platform != "linux" and sys.platform != "darwin":
         CLOCK_HIGHRES: int  # Solaris only
 
-if sys.version_info >= (3, 8) and sys.platform == "darwin":
+if sys.platform == "darwin":
     CLOCK_UPTIME_RAW: int
+    if sys.version_info >= (3, 13):
+        CLOCK_UPTIME_RAW_APPROX: int
+        CLOCK_MONOTONIC_RAW_APPROX: int
 
 if sys.version_info >= (3, 9) and sys.platform == "linux":
     CLOCK_TAI: int
@@ -39,6 +42,7 @@ if sys.version_info >= (3, 9) and sys.platform == "linux":
 class struct_time(structseq[Any | int], _TimeTuple):
     if sys.version_info >= (3, 10):
         __match_args__: Final = ("tm_year", "tm_mon", "tm_mday", "tm_hour", "tm_min", "tm_sec", "tm_wday", "tm_yday", "tm_isdst")
+
     @property
     def tm_year(self) -> int: ...
     @property
@@ -63,18 +67,14 @@ class struct_time(structseq[Any | int], _TimeTuple):
     @property
     def tm_gmtoff(self) -> int: ...
 
-def asctime(t: _TimeTuple | struct_time = ...) -> str: ...
-
-if sys.version_info < (3, 8):
-    def clock() -> float: ...
-
-def ctime(secs: float | None = ...) -> str: ...
-def gmtime(secs: float | None = ...) -> struct_time: ...
-def localtime(secs: float | None = ...) -> struct_time: ...
-def mktime(t: _TimeTuple | struct_time) -> float: ...
-def sleep(secs: float) -> None: ...
-def strftime(format: str, t: _TimeTuple | struct_time = ...) -> str: ...
-def strptime(string: str, format: str = ...) -> struct_time: ...
+def asctime(time_tuple: _TimeTuple | struct_time = ..., /) -> str: ...
+def ctime(seconds: float | None = None, /) -> str: ...
+def gmtime(seconds: float | None = None, /) -> struct_time: ...
+def localtime(seconds: float | None = None, /) -> struct_time: ...
+def mktime(time_tuple: _TimeTuple | struct_time, /) -> float: ...
+def sleep(seconds: float, /) -> None: ...
+def strftime(format: str, time_tuple: _TimeTuple | struct_time = ..., /) -> str: ...
+def strptime(data_string: str, format: str = "%a %b %d %H:%M:%S %Y", /) -> struct_time: ...
 def time() -> float: ...
 
 if sys.platform != "win32":
@@ -86,22 +86,22 @@ class _ClockInfo(Protocol):
     monotonic: bool
     resolution: float
 
-def get_clock_info(name: Literal["monotonic", "perf_counter", "process_time", "time", "thread_time"]) -> _ClockInfo: ...
+def get_clock_info(name: Literal["monotonic", "perf_counter", "process_time", "time", "thread_time"], /) -> _ClockInfo: ...
 def monotonic() -> float: ...
 def perf_counter() -> float: ...
 def process_time() -> float: ...
 
 if sys.platform != "win32":
-    def clock_getres(clk_id: int) -> float: ...  # Unix only
-    def clock_gettime(clk_id: int) -> float: ...  # Unix only
-    def clock_settime(clk_id: int, time: float) -> None: ...  # Unix only
+    def clock_getres(clk_id: int, /) -> float: ...  # Unix only
+    def clock_gettime(clk_id: int, /) -> float: ...  # Unix only
+    def clock_settime(clk_id: int, time: float, /) -> None: ...  # Unix only
 
 if sys.platform != "win32":
-    def clock_gettime_ns(clock_id: int) -> int: ...
-    def clock_settime_ns(clock_id: int, time: int) -> int: ...
+    def clock_gettime_ns(clk_id: int, /) -> int: ...
+    def clock_settime_ns(clock_id: int, time: int, /) -> int: ...
 
 if sys.platform == "linux":
-    def pthread_getcpuclockid(thread_id: int) -> int: ...
+    def pthread_getcpuclockid(thread_id: int, /) -> int: ...
 
 def monotonic_ns() -> int: ...
 def perf_counter_ns() -> int: ...
diff --git a/mypy/typeshed/stdlib/tkinter/__init__.pyi b/mypy/typeshed/stdlib/tkinter/__init__.pyi
index 3291b0c9dd98..73c1e0400fe8 100644
--- a/mypy/typeshed/stdlib/tkinter/__init__.pyi
+++ b/mypy/typeshed/stdlib/tkinter/__init__.pyi
@@ -1,13 +1,17 @@
 import _tkinter
 import sys
-from _typeshed import Incomplete, StrOrBytesPath
-from collections.abc import Callable, Mapping, Sequence
-from enum import Enum
+from _typeshed import Incomplete, MaybeNone, StrOrBytesPath
+from collections.abc import Callable, Iterable, Mapping, Sequence
 from tkinter.constants import *
 from tkinter.font import _FontDescription
 from types import TracebackType
-from typing import Any, Generic, NamedTuple, Protocol, TypeVar, overload, type_check_only
-from typing_extensions import Literal, TypeAlias, TypedDict
+from typing import Any, ClassVar, Generic, Literal, NamedTuple, Protocol, TypedDict, TypeVar, overload, type_check_only
+from typing_extensions import TypeAlias, TypeVarTuple, Unpack, deprecated
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from enum import Enum
 
 if sys.version_info >= (3, 9):
     __all__ = [
@@ -179,62 +183,107 @@ _Compound: TypeAlias = Literal["top", "left", "center", "right", "bottom", "none
 _Cursor: TypeAlias = str | tuple[str] | tuple[str, str] | tuple[str, str, str] | tuple[str, str, str, str]
 # example when it's sequence:  entry['invalidcommand'] = [entry.register(print), '%P']
 _EntryValidateCommand: TypeAlias = str | list[str] | tuple[str, ...] | Callable[[], bool]
-_GridIndex: TypeAlias = int | str
 _ImageSpec: TypeAlias = _Image | str  # str can be from e.g. tkinter.image_names()
 _Relief: TypeAlias = Literal["raised", "sunken", "flat", "ridge", "solid", "groove"]  # manual page: Tk_GetRelief
 _ScreenUnits: TypeAlias = str | float  # Often the right type instead of int. Manual page: Tk_GetPixels
 # -xscrollcommand and -yscrollcommand in 'options' manual page
 _XYScrollCommand: TypeAlias = str | Callable[[float, float], object]
-_TakeFocusValue: TypeAlias = int | Literal[""] | Callable[[str], bool | None]  # -takefocus in manual page named 'options'
+_TakeFocusValue: TypeAlias = bool | Literal[0, 1, ""] | Callable[[str], bool | None]  # -takefocus in manual page named 'options'
 
 if sys.version_info >= (3, 11):
-    class _VersionInfoType(NamedTuple):
+    @type_check_only
+    class _VersionInfoTypeBase(NamedTuple):
         major: int
         minor: int
         micro: int
         releaselevel: str
         serial: int
 
-class EventType(str, Enum):
-    Activate: str
-    ButtonPress: str
-    Button = ButtonPress
-    ButtonRelease: str
-    Circulate: str
-    CirculateRequest: str
-    ClientMessage: str
-    Colormap: str
-    Configure: str
-    ConfigureRequest: str
-    Create: str
-    Deactivate: str
-    Destroy: str
-    Enter: str
-    Expose: str
-    FocusIn: str
-    FocusOut: str
-    GraphicsExpose: str
-    Gravity: str
-    KeyPress: str
-    Key = KeyPress
-    KeyRelease: str
-    Keymap: str
-    Leave: str
-    Map: str
-    MapRequest: str
-    Mapping: str
-    Motion: str
-    MouseWheel: str
-    NoExpose: str
-    Property: str
-    Reparent: str
-    ResizeRequest: str
-    Selection: str
-    SelectionClear: str
-    SelectionRequest: str
-    Unmap: str
-    VirtualEvent: str
-    Visibility: str
+    class _VersionInfoType(_VersionInfoTypeBase): ...
+
+if sys.version_info >= (3, 11):
+    class EventType(StrEnum):
+        Activate = "36"
+        ButtonPress = "4"
+        Button = ButtonPress
+        ButtonRelease = "5"
+        Circulate = "26"
+        CirculateRequest = "27"
+        ClientMessage = "33"
+        Colormap = "32"
+        Configure = "22"
+        ConfigureRequest = "23"
+        Create = "16"
+        Deactivate = "37"
+        Destroy = "17"
+        Enter = "7"
+        Expose = "12"
+        FocusIn = "9"
+        FocusOut = "10"
+        GraphicsExpose = "13"
+        Gravity = "24"
+        KeyPress = "2"
+        Key = "2"
+        KeyRelease = "3"
+        Keymap = "11"
+        Leave = "8"
+        Map = "19"
+        MapRequest = "20"
+        Mapping = "34"
+        Motion = "6"
+        MouseWheel = "38"
+        NoExpose = "14"
+        Property = "28"
+        Reparent = "21"
+        ResizeRequest = "25"
+        Selection = "31"
+        SelectionClear = "29"
+        SelectionRequest = "30"
+        Unmap = "18"
+        VirtualEvent = "35"
+        Visibility = "15"
+
+else:
+    class EventType(str, Enum):
+        Activate = "36"
+        ButtonPress = "4"
+        Button = ButtonPress
+        ButtonRelease = "5"
+        Circulate = "26"
+        CirculateRequest = "27"
+        ClientMessage = "33"
+        Colormap = "32"
+        Configure = "22"
+        ConfigureRequest = "23"
+        Create = "16"
+        Deactivate = "37"
+        Destroy = "17"
+        Enter = "7"
+        Expose = "12"
+        FocusIn = "9"
+        FocusOut = "10"
+        GraphicsExpose = "13"
+        Gravity = "24"
+        KeyPress = "2"
+        Key = KeyPress
+        KeyRelease = "3"
+        Keymap = "11"
+        Leave = "8"
+        Map = "19"
+        MapRequest = "20"
+        Mapping = "34"
+        Motion = "6"
+        MouseWheel = "38"
+        NoExpose = "14"
+        Property = "28"
+        Reparent = "21"
+        ResizeRequest = "25"
+        Selection = "31"
+        SelectionClear = "29"
+        SelectionRequest = "30"
+        Unmap = "18"
+        VirtualEvent = "35"
+        Visibility = "15"
 
 _W = TypeVar("_W", bound=Misc)
 # Events considered covariant because you should never assign to event.widget.
@@ -263,21 +312,25 @@ class Event(Generic[_W_co]):
 
 def NoDefaultRoot() -> None: ...
 
-_TraceMode: TypeAlias = Literal["array", "read", "write", "unset"]
-
 class Variable:
     def __init__(self, master: Misc | None = None, value: Incomplete | None = None, name: str | None = None) -> None: ...
     def set(self, value) -> None: ...
     initialize = set
     def get(self): ...
-    def trace_add(self, mode: _TraceMode, callback: Callable[[str, str, str], object]) -> str: ...
-    def trace_remove(self, mode: _TraceMode, cbname: str) -> None: ...
-    def trace_info(self) -> list[tuple[tuple[_TraceMode, ...], str]]: ...
-    def trace_variable(self, mode, callback): ...  # deprecated
-    def trace_vdelete(self, mode, cbname) -> None: ...  # deprecated
-    def trace_vinfo(self): ...  # deprecated
-    trace = trace_variable  # deprecated
+    def trace_add(self, mode: Literal["array", "read", "write", "unset"], callback: Callable[[str, str, str], object]) -> str: ...
+    def trace_remove(self, mode: Literal["array", "read", "write", "unset"], cbname: str) -> None: ...
+    def trace_info(self) -> list[tuple[tuple[Literal["array", "read", "write", "unset"], ...], str]]: ...
+    @deprecated("use trace_add() instead of trace()")
+    def trace(self, mode, callback): ...
+    @deprecated("use trace_add() instead of trace_variable()")
+    def trace_variable(self, mode, callback): ...
+    @deprecated("use trace_remove() instead of trace_vdelete()")
+    def trace_vdelete(self, mode, cbname) -> None: ...
+    @deprecated("use trace_info() instead of trace_vinfo()")
+    def trace_vinfo(self): ...
     def __eq__(self, other: object) -> bool: ...
+    def __del__(self) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class StringVar(Variable):
     def __init__(self, master: Misc | None = None, value: str | None = None, name: str | None = None) -> None: ...
@@ -310,12 +363,17 @@ getdouble: Incomplete
 
 def getboolean(s): ...
 
+_Ts = TypeVarTuple("_Ts")
+
 class _GridIndexInfo(TypedDict, total=False):
     minsize: _ScreenUnits
     pad: _ScreenUnits
     uniform: str | None
     weight: int
 
+class _BusyInfo(TypedDict):
+    cursor: _Cursor
+
 class Misc:
     master: Misc | None
     tk: _tkinter.TkappType
@@ -343,14 +401,35 @@ class Misc:
     def tk_focusFollowsMouse(self) -> None: ...
     def tk_focusNext(self) -> Misc | None: ...
     def tk_focusPrev(self) -> Misc | None: ...
-    @overload
-    def after(self, ms: int, func: None = None) -> None: ...
-    @overload
-    def after(self, ms: int | Literal["idle"], func: Callable[..., object], *args: Any) -> str: ...
+    # .after() can be called without the "func" argument, but it is basically never what you want.
+    # It behaves like time.sleep() and freezes the GUI app.
+    def after(self, ms: int | Literal["idle"], func: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> str: ...
     # after_idle is essentially partialmethod(after, "idle")
-    def after_idle(self, func: Callable[..., object], *args: Any) -> str: ...
+    def after_idle(self, func: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> str: ...
     def after_cancel(self, id: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def after_info(self, id: str | None = None) -> tuple[str, ...]: ...
+
     def bell(self, displayof: Literal[0] | Misc | None = 0) -> None: ...
+    if sys.version_info >= (3, 13):
+        # Supports options from `_BusyInfo``
+        def tk_busy_cget(self, option: Literal["cursor"]) -> _Cursor: ...
+        busy_cget = tk_busy_cget
+        def tk_busy_configure(self, cnf: Any = None, **kw: Any) -> Any: ...
+        tk_busy_config = tk_busy_configure
+        busy_configure = tk_busy_configure
+        busy_config = tk_busy_configure
+        def tk_busy_current(self, pattern: str | None = None) -> list[Misc]: ...
+        busy_current = tk_busy_current
+        def tk_busy_forget(self) -> None: ...
+        busy_forget = tk_busy_forget
+        def tk_busy_hold(self, **kw: Unpack[_BusyInfo]) -> None: ...
+        tk_busy = tk_busy_hold
+        busy_hold = tk_busy_hold
+        busy = tk_busy_hold
+        def tk_busy_status(self) -> bool: ...
+        busy_status = tk_busy_status
+
     def clipboard_get(self, *, displayof: Misc = ..., type: str = ...) -> str: ...
     def clipboard_clear(self, *, displayof: Misc = ...) -> None: ...
     def clipboard_append(self, string: str, *, displayof: Misc = ..., format: str = ..., type: str = ...) -> None: ...
@@ -500,24 +579,24 @@ class Misc:
     bbox = grid_bbox
     def grid_columnconfigure(
         self,
-        index: _GridIndex,
+        index: int | str | list[int] | tuple[int, ...],
         cnf: _GridIndexInfo = {},
         *,
         minsize: _ScreenUnits = ...,
         pad: _ScreenUnits = ...,
         uniform: str = ...,
         weight: int = ...,
-    ) -> _GridIndexInfo | Any: ...  # can be None but annoying to check
+    ) -> _GridIndexInfo | MaybeNone: ...  # can be None but annoying to check
     def grid_rowconfigure(
         self,
-        index: _GridIndex,
+        index: int | str | list[int] | tuple[int, ...],
         cnf: _GridIndexInfo = {},
         *,
         minsize: _ScreenUnits = ...,
         pad: _ScreenUnits = ...,
         uniform: str = ...,
         weight: int = ...,
-    ) -> _GridIndexInfo | Any: ...  # can be None but annoying to check
+    ) -> _GridIndexInfo | MaybeNone: ...  # can be None but annoying to check
     columnconfigure = grid_columnconfigure
     rowconfigure = grid_rowconfigure
     def grid_location(self, x: _ScreenUnits, y: _ScreenUnits) -> tuple[int, int]: ...
@@ -574,7 +653,8 @@ class Misc:
     def __getitem__(self, key: str) -> Any: ...
     def cget(self, key: str) -> Any: ...
     def configure(self, cnf: Any = None) -> Any: ...
-    # TODO: config is an alias of configure, but adding that here creates lots of mypy errors
+    # TODO: config is an alias of configure, but adding that here creates
+    # conflict with the type of config in the subclasses. See #13149
 
 class CallWrapper:
     func: Incomplete
@@ -605,6 +685,38 @@ class YView:
     @overload
     def yview_scroll(self, number: _ScreenUnits, what: Literal["pixels"]) -> None: ...
 
+if sys.platform == "darwin":
+    @type_check_only
+    class _WmAttributes(TypedDict):
+        alpha: float
+        fullscreen: bool
+        modified: bool
+        notify: bool
+        titlepath: str
+        topmost: bool
+        transparent: bool
+        type: str  # Present, but not actually used on darwin
+
+elif sys.platform == "win32":
+    @type_check_only
+    class _WmAttributes(TypedDict):
+        alpha: float
+        transparentcolor: str
+        disabled: bool
+        fullscreen: bool
+        toolwindow: bool
+        topmost: bool
+
+else:
+    # X11
+    @type_check_only
+    class _WmAttributes(TypedDict):
+        alpha: float
+        topmost: bool
+        zoomed: bool
+        fullscreen: bool
+        type: str
+
 class Wm:
     @overload
     def wm_aspect(self, minNumer: int, minDenom: int, maxNumer: int, maxDenom: int) -> None: ...
@@ -613,21 +725,153 @@ class Wm:
         self, minNumer: None = None, minDenom: None = None, maxNumer: None = None, maxDenom: None = None
     ) -> tuple[int, int, int, int] | None: ...
     aspect = wm_aspect
-    @overload
-    def wm_attributes(self) -> tuple[Any, ...]: ...
-    @overload
-    def wm_attributes(self, __option: str): ...
-    @overload
-    def wm_attributes(self, __option: str, __value, *__other_option_value_pairs: Any) -> None: ...
+    if sys.version_info >= (3, 13):
+        @overload
+        def wm_attributes(self, *, return_python_dict: Literal[False] = False) -> tuple[Any, ...]: ...
+        @overload
+        def wm_attributes(self, *, return_python_dict: Literal[True]) -> _WmAttributes: ...
+
+    else:
+        @overload
+        def wm_attributes(self) -> tuple[Any, ...]: ...
+
+    @overload
+    def wm_attributes(self, option: Literal["-alpha"], /) -> float: ...
+    @overload
+    def wm_attributes(self, option: Literal["-fullscreen"], /) -> bool: ...
+    @overload
+    def wm_attributes(self, option: Literal["-topmost"], /) -> bool: ...
+    if sys.platform == "darwin":
+        @overload
+        def wm_attributes(self, option: Literal["-modified"], /) -> bool: ...
+        @overload
+        def wm_attributes(self, option: Literal["-notify"], /) -> bool: ...
+        @overload
+        def wm_attributes(self, option: Literal["-titlepath"], /) -> str: ...
+        @overload
+        def wm_attributes(self, option: Literal["-transparent"], /) -> bool: ...
+        @overload
+        def wm_attributes(self, option: Literal["-type"], /) -> str: ...
+    elif sys.platform == "win32":
+        @overload
+        def wm_attributes(self, option: Literal["-transparentcolor"], /) -> str: ...
+        @overload
+        def wm_attributes(self, option: Literal["-disabled"], /) -> bool: ...
+        @overload
+        def wm_attributes(self, option: Literal["-toolwindow"], /) -> bool: ...
+    else:
+        # X11
+        @overload
+        def wm_attributes(self, option: Literal["-zoomed"], /) -> bool: ...
+        @overload
+        def wm_attributes(self, option: Literal["-type"], /) -> str: ...
+    if sys.version_info >= (3, 13):
+        @overload
+        def wm_attributes(self, option: Literal["alpha"], /) -> float: ...
+        @overload
+        def wm_attributes(self, option: Literal["fullscreen"], /) -> bool: ...
+        @overload
+        def wm_attributes(self, option: Literal["topmost"], /) -> bool: ...
+        if sys.platform == "darwin":
+            @overload
+            def wm_attributes(self, option: Literal["modified"], /) -> bool: ...
+            @overload
+            def wm_attributes(self, option: Literal["notify"], /) -> bool: ...
+            @overload
+            def wm_attributes(self, option: Literal["titlepath"], /) -> str: ...
+            @overload
+            def wm_attributes(self, option: Literal["transparent"], /) -> bool: ...
+            @overload
+            def wm_attributes(self, option: Literal["type"], /) -> str: ...
+        elif sys.platform == "win32":
+            @overload
+            def wm_attributes(self, option: Literal["transparentcolor"], /) -> str: ...
+            @overload
+            def wm_attributes(self, option: Literal["disabled"], /) -> bool: ...
+            @overload
+            def wm_attributes(self, option: Literal["toolwindow"], /) -> bool: ...
+        else:
+            # X11
+            @overload
+            def wm_attributes(self, option: Literal["zoomed"], /) -> bool: ...
+            @overload
+            def wm_attributes(self, option: Literal["type"], /) -> str: ...
+
+    @overload
+    def wm_attributes(self, option: str, /): ...
+    @overload
+    def wm_attributes(self, option: Literal["-alpha"], value: float, /) -> Literal[""]: ...
+    @overload
+    def wm_attributes(self, option: Literal["-fullscreen"], value: bool, /) -> Literal[""]: ...
+    @overload
+    def wm_attributes(self, option: Literal["-topmost"], value: bool, /) -> Literal[""]: ...
+    if sys.platform == "darwin":
+        @overload
+        def wm_attributes(self, option: Literal["-modified"], value: bool, /) -> Literal[""]: ...
+        @overload
+        def wm_attributes(self, option: Literal["-notify"], value: bool, /) -> Literal[""]: ...
+        @overload
+        def wm_attributes(self, option: Literal["-titlepath"], value: str, /) -> Literal[""]: ...
+        @overload
+        def wm_attributes(self, option: Literal["-transparent"], value: bool, /) -> Literal[""]: ...
+    elif sys.platform == "win32":
+        @overload
+        def wm_attributes(self, option: Literal["-transparentcolor"], value: str, /) -> Literal[""]: ...
+        @overload
+        def wm_attributes(self, option: Literal["-disabled"], value: bool, /) -> Literal[""]: ...
+        @overload
+        def wm_attributes(self, option: Literal["-toolwindow"], value: bool, /) -> Literal[""]: ...
+    else:
+        # X11
+        @overload
+        def wm_attributes(self, option: Literal["-zoomed"], value: bool, /) -> Literal[""]: ...
+        @overload
+        def wm_attributes(self, option: Literal["-type"], value: str, /) -> Literal[""]: ...
+
+    @overload
+    def wm_attributes(self, option: str, value, /, *__other_option_value_pairs: Any) -> Literal[""]: ...
+    if sys.version_info >= (3, 13):
+        if sys.platform == "darwin":
+            @overload
+            def wm_attributes(
+                self,
+                *,
+                alpha: float = ...,
+                fullscreen: bool = ...,
+                modified: bool = ...,
+                notify: bool = ...,
+                titlepath: str = ...,
+                topmost: bool = ...,
+                transparent: bool = ...,
+            ) -> None: ...
+        elif sys.platform == "win32":
+            @overload
+            def wm_attributes(
+                self,
+                *,
+                alpha: float = ...,
+                transparentcolor: str = ...,
+                disabled: bool = ...,
+                fullscreen: bool = ...,
+                toolwindow: bool = ...,
+                topmost: bool = ...,
+            ) -> None: ...
+        else:
+            # X11
+            @overload
+            def wm_attributes(
+                self, *, alpha: float = ..., topmost: bool = ..., zoomed: bool = ..., fullscreen: bool = ..., type: str = ...
+            ) -> None: ...
+
     attributes = wm_attributes
     def wm_client(self, name: str | None = None) -> str: ...
     client = wm_client
     @overload
     def wm_colormapwindows(self) -> list[Misc]: ...
     @overload
-    def wm_colormapwindows(self, __wlist: list[Misc] | tuple[Misc, ...]) -> None: ...
+    def wm_colormapwindows(self, wlist: list[Misc] | tuple[Misc, ...], /) -> None: ...
     @overload
-    def wm_colormapwindows(self, __first_wlist_item: Misc, *other_wlist_items: Misc) -> None: ...
+    def wm_colormapwindows(self, first_wlist_item: Misc, /, *other_wlist_items: Misc) -> None: ...
     colormapwindows = wm_colormapwindows
     def wm_command(self, value: str | None = None) -> str: ...
     command = wm_command
@@ -663,7 +907,7 @@ class Wm:
     iconmask = wm_iconmask
     def wm_iconname(self, newName: Incomplete | None = None) -> str: ...
     iconname = wm_iconname
-    def wm_iconphoto(self, default: bool, __image1: _PhotoImageLike | str, *args: _PhotoImageLike | str) -> None: ...
+    def wm_iconphoto(self, default: bool, image1: _PhotoImageLike | str, /, *args: _PhotoImageLike | str) -> None: ...
     iconphoto = wm_iconphoto
     def wm_iconposition(self, x: int | None = None, y: int | None = None) -> tuple[int, int] | None: ...
     iconposition = wm_iconposition
@@ -720,9 +964,6 @@ class Wm:
     def wm_withdraw(self) -> None: ...
     withdraw = wm_withdraw
 
-class _ExceptionReportingCallback(Protocol):
-    def __call__(self, __exc: type[BaseException], __val: BaseException, __tb: TracebackType | None) -> object: ...
-
 class Tk(Misc, Wm):
     master: None
     def __init__(
@@ -764,35 +1005,35 @@ class Tk(Misc, Wm):
     config = configure
     def destroy(self) -> None: ...
     def readprofile(self, baseName: str, className: str) -> None: ...
-    report_callback_exception: _ExceptionReportingCallback
+    report_callback_exception: Callable[[type[BaseException], BaseException, TracebackType | None], object]
     # Tk has __getattr__ so that tk_instance.foo falls back to tk_instance.tk.foo
     # Please keep in sync with _tkinter.TkappType.
     # Some methods are intentionally missing because they are inherited from Misc instead.
-    def adderrorinfo(self, __msg): ...
-    def call(self, __command: Any, *args: Any) -> Any: ...
-    def createcommand(self, __name, __func): ...
+    def adderrorinfo(self, msg, /): ...
+    def call(self, command: Any, /, *args: Any) -> Any: ...
+    def createcommand(self, name, func, /): ...
     if sys.platform != "win32":
-        def createfilehandler(self, __file, __mask, __func): ...
-        def deletefilehandler(self, __file): ...
-
-    def createtimerhandler(self, __milliseconds, __func): ...
-    def dooneevent(self, __flags: int = ...): ...
-    def eval(self, __script: str) -> str: ...
-    def evalfile(self, __fileName): ...
-    def exprboolean(self, __s): ...
-    def exprdouble(self, __s): ...
-    def exprlong(self, __s): ...
-    def exprstring(self, __s): ...
+        def createfilehandler(self, file, mask, func, /): ...
+        def deletefilehandler(self, file, /): ...
+
+    def createtimerhandler(self, milliseconds, func, /): ...
+    def dooneevent(self, flags: int = ..., /): ...
+    def eval(self, script: str, /) -> str: ...
+    def evalfile(self, fileName, /): ...
+    def exprboolean(self, s, /): ...
+    def exprdouble(self, s, /): ...
+    def exprlong(self, s, /): ...
+    def exprstring(self, s, /): ...
     def globalgetvar(self, *args, **kwargs): ...
     def globalsetvar(self, *args, **kwargs): ...
     def globalunsetvar(self, *args, **kwargs): ...
     def interpaddr(self): ...
     def loadtk(self) -> None: ...
-    def record(self, __script): ...
+    def record(self, script, /): ...
     if sys.version_info < (3, 11):
-        def split(self, __arg): ...
+        def split(self, arg, /): ...
 
-    def splitlist(self, __arg): ...
+    def splitlist(self, arg, /): ...
     def unsetvar(self, *args, **kwargs): ...
     def wantobjects(self, *args, **kwargs): ...
     def willdispatch(self): ...
@@ -827,7 +1068,7 @@ class Pack:
         after: Misc = ...,
         anchor: _Anchor = ...,
         before: Misc = ...,
-        expand: int = ...,
+        expand: bool | Literal[0, 1] = 0,
         fill: Literal["none", "x", "y", "both"] = ...,
         side: Literal["left", "right", "top", "bottom"] = ...,
         ipadx: _ScreenUnits = ...,
@@ -947,28 +1188,28 @@ class Toplevel(BaseWidget, Wm):
         cnf: dict[str, Any] | None = {},
         *,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 0,
         bg: str = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
-        class_: str = ...,
-        colormap: Literal["new", ""] | Misc = ...,
-        container: bool = ...,
-        cursor: _Cursor = ...,
-        height: _ScreenUnits = ...,
+        border: _ScreenUnits = 0,
+        borderwidth: _ScreenUnits = 0,
+        class_: str = "Toplevel",
+        colormap: Literal["new", ""] | Misc = "",
+        container: bool = False,
+        cursor: _Cursor = "",
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
+        highlightthickness: _ScreenUnits = 0,
         menu: Menu = ...,
         name: str = ...,
-        padx: _ScreenUnits = ...,
-        pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
-        screen: str = ...,  # can't be changed after creating widget
-        takefocus: _TakeFocusValue = ...,
+        padx: _ScreenUnits = 0,
+        pady: _ScreenUnits = 0,
+        relief: _Relief = "flat",
+        screen: str = "",  # can't be changed after creating widget
+        takefocus: _TakeFocusValue = 0,
         use: int = ...,
-        visual: str | tuple[str, int] = ...,
-        width: _ScreenUnits = ...,
+        visual: str | tuple[str, int] = "",
+        width: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -1004,46 +1245,46 @@ class Button(Widget):
         *,
         activebackground: str = ...,
         activeforeground: str = ...,
-        anchor: _Anchor = ...,
+        anchor: _Anchor = "center",
         background: str = ...,
         bd: _ScreenUnits = ...,  # same as borderwidth
         bg: str = ...,  # same as background
-        bitmap: str = ...,
+        bitmap: str = "",
         border: _ScreenUnits = ...,  # same as borderwidth
         borderwidth: _ScreenUnits = ...,
-        command: _ButtonCommand = ...,
-        compound: _Compound = ...,
-        cursor: _Cursor = ...,
-        default: Literal["normal", "active", "disabled"] = ...,
+        command: _ButtonCommand = "",
+        compound: _Compound = "none",
+        cursor: _Cursor = "",
+        default: Literal["normal", "active", "disabled"] = "disabled",
         disabledforeground: str = ...,
         fg: str = ...,  # same as foreground
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
         # width and height must be int for buttons containing just text, but
         # ints are also valid _ScreenUnits
-        height: _ScreenUnits = ...,
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
-        image: _ImageSpec = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        highlightthickness: _ScreenUnits = 1,
+        image: _ImageSpec = "",
+        justify: Literal["left", "center", "right"] = "center",
         name: str = ...,
-        overrelief: _Relief = ...,
+        overrelief: _Relief | Literal[""] = "",
         padx: _ScreenUnits = ...,
         pady: _ScreenUnits = ...,
         relief: _Relief = ...,
         repeatdelay: int = ...,
         repeatinterval: int = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        text: float | str = ...,
+        state: Literal["normal", "active", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = "",
+        text: float | str = "",
         # We allow the textvariable to be any Variable, not necessarily
         # StringVar. This is useful for e.g. a button that displays the value
         # of an IntVar.
         textvariable: Variable = ...,
-        underline: int = ...,
-        width: _ScreenUnits = ...,
-        wraplength: _ScreenUnits = ...,
+        underline: int = -1,
+        width: _ScreenUnits = 0,
+        wraplength: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -1073,7 +1314,7 @@ class Button(Widget):
         highlightthickness: _ScreenUnits = ...,
         image: _ImageSpec = ...,
         justify: Literal["left", "center", "right"] = ...,
-        overrelief: _Relief = ...,
+        overrelief: _Relief | Literal[""] = ...,
         padx: _ScreenUnits = ...,
         pady: _ScreenUnits = ...,
         relief: _Relief = ...,
@@ -1100,13 +1341,13 @@ class Canvas(Widget, XView, YView):
         cnf: dict[str, Any] | None = {},
         *,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 0,
         bg: str = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
-        closeenough: float = ...,
-        confine: bool = ...,
-        cursor: _Cursor = ...,
+        border: _ScreenUnits = 0,
+        borderwidth: _ScreenUnits = 0,
+        closeenough: float = 1.0,
+        confine: bool = True,
+        cursor: _Cursor = "",
         # canvas manual page has a section named COORDINATES, and the first
         # part of it describes _ScreenUnits.
         height: _ScreenUnits = ...,
@@ -1114,27 +1355,27 @@ class Canvas(Widget, XView, YView):
         highlightcolor: str = ...,
         highlightthickness: _ScreenUnits = ...,
         insertbackground: str = ...,
-        insertborderwidth: _ScreenUnits = ...,
-        insertofftime: int = ...,
-        insertontime: int = ...,
-        insertwidth: _ScreenUnits = ...,
+        insertborderwidth: _ScreenUnits = 0,
+        insertofftime: int = 300,
+        insertontime: int = 600,
+        insertwidth: _ScreenUnits = 2,
         name: str = ...,
         offset=...,  # undocumented
-        relief: _Relief = ...,
+        relief: _Relief = "flat",
         # Setting scrollregion to None doesn't reset it back to empty,
         # but setting it to () does.
-        scrollregion: tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits] | tuple[()] = ...,
+        scrollregion: tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits] | tuple[()] = (),
         selectbackground: str = ...,
-        selectborderwidth: _ScreenUnits = ...,
+        selectborderwidth: _ScreenUnits = 1,
         selectforeground: str = ...,
         # man page says that state can be 'hidden', but it can't
-        state: Literal["normal", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
+        state: Literal["normal", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = "",
         width: _ScreenUnits = ...,
-        xscrollcommand: _XYScrollCommand = ...,
-        xscrollincrement: _ScreenUnits = ...,
-        yscrollcommand: _XYScrollCommand = ...,
-        yscrollincrement: _ScreenUnits = ...,
+        xscrollcommand: _XYScrollCommand = "",
+        xscrollincrement: _ScreenUnits = 0,
+        yscrollcommand: _XYScrollCommand = "",
+        yscrollincrement: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -1215,11 +1456,11 @@ class Canvas(Widget, XView, YView):
     def canvasx(self, screenx, gridspacing: Incomplete | None = None): ...
     def canvasy(self, screeny, gridspacing: Incomplete | None = None): ...
     @overload
-    def coords(self, __tagOrId: str | int) -> list[float]: ...
+    def coords(self, tagOrId: str | int, /) -> list[float]: ...
     @overload
-    def coords(self, __tagOrId: str | int, __args: list[int] | list[float] | tuple[float, ...]) -> None: ...
+    def coords(self, tagOrId: str | int, args: list[int] | list[float] | tuple[float, ...], /) -> None: ...
     @overload
-    def coords(self, __tagOrId: str | int, __x1: float, __y1: float, *args: float) -> None: ...
+    def coords(self, tagOrId: str | int, x1: float, y1: float, /, *args: float) -> None: ...
     # create_foo() methods accept coords as a list or tuple, or as separate arguments.
     # Lists and tuples can be flat as in [1, 2, 3, 4], or nested as in [(1, 2), (3, 4)].
     # Keyword arguments should be the same in all overloads of each method.
@@ -1229,10 +1470,11 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_line(
         self,
-        __x0: float,
-        __y0: float,
-        __x1: float,
-        __y1: float,
+        x0: float,
+        y0: float,
+        x1: float,
+        y1: float,
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1252,7 +1494,7 @@ class Canvas(Widget, XView, YView):
         offset: _ScreenUnits = ...,
         smooth: bool = ...,
         splinesteps: float = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1260,8 +1502,9 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_line(
         self,
-        __xy_pair_0: tuple[float, float],
-        __xy_pair_1: tuple[float, float],
+        xy_pair_0: tuple[float, float],
+        xy_pair_1: tuple[float, float],
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1281,7 +1524,7 @@ class Canvas(Widget, XView, YView):
         offset: _ScreenUnits = ...,
         smooth: bool = ...,
         splinesteps: float = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1289,7 +1532,7 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_line(
         self,
-        __coords: (
+        coords: (
             tuple[float, float, float, float]
             | tuple[tuple[float, float], tuple[float, float]]
             | list[int]
@@ -1297,6 +1540,7 @@ class Canvas(Widget, XView, YView):
             | list[tuple[int, int]]
             | list[tuple[float, float]]
         ),
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1316,7 +1560,7 @@ class Canvas(Widget, XView, YView):
         offset: _ScreenUnits = ...,
         smooth: bool = ...,
         splinesteps: float = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1324,10 +1568,11 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_oval(
         self,
-        __x0: float,
-        __y0: float,
-        __x1: float,
-        __y1: float,
+        x0: float,
+        y0: float,
+        x1: float,
+        y1: float,
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1348,7 +1593,7 @@ class Canvas(Widget, XView, YView):
         outline: str = ...,
         outlineoffset: _ScreenUnits = ...,
         outlinestipple: str = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1356,8 +1601,9 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_oval(
         self,
-        __xy_pair_0: tuple[float, float],
-        __xy_pair_1: tuple[float, float],
+        xy_pair_0: tuple[float, float],
+        xy_pair_1: tuple[float, float],
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1378,7 +1624,7 @@ class Canvas(Widget, XView, YView):
         outline: str = ...,
         outlineoffset: _ScreenUnits = ...,
         outlinestipple: str = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1386,7 +1632,7 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_oval(
         self,
-        __coords: (
+        coords: (
             tuple[float, float, float, float]
             | tuple[tuple[float, float], tuple[float, float]]
             | list[int]
@@ -1394,6 +1640,7 @@ class Canvas(Widget, XView, YView):
             | list[tuple[int, int]]
             | list[tuple[float, float]]
         ),
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1414,7 +1661,7 @@ class Canvas(Widget, XView, YView):
         outline: str = ...,
         outlineoffset: _ScreenUnits = ...,
         outlinestipple: str = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1422,10 +1669,11 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_polygon(
         self,
-        __x0: float,
-        __y0: float,
-        __x1: float,
-        __y1: float,
+        x0: float,
+        y0: float,
+        x1: float,
+        y1: float,
+        /,
         *xy_pairs: float,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1449,7 +1697,7 @@ class Canvas(Widget, XView, YView):
         outlinestipple: str = ...,
         smooth: bool = ...,
         splinesteps: float = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1457,8 +1705,9 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_polygon(
         self,
-        __xy_pair_0: tuple[float, float],
-        __xy_pair_1: tuple[float, float],
+        xy_pair_0: tuple[float, float],
+        xy_pair_1: tuple[float, float],
+        /,
         *xy_pairs: tuple[float, float],
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1482,7 +1731,7 @@ class Canvas(Widget, XView, YView):
         outlinestipple: str = ...,
         smooth: bool = ...,
         splinesteps: float = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1490,7 +1739,7 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_polygon(
         self,
-        __coords: (
+        coords: (
             tuple[float, ...]
             | tuple[tuple[float, float], ...]
             | list[int]
@@ -1498,6 +1747,7 @@ class Canvas(Widget, XView, YView):
             | list[tuple[int, int]]
             | list[tuple[float, float]]
         ),
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1521,7 +1771,7 @@ class Canvas(Widget, XView, YView):
         outlinestipple: str = ...,
         smooth: bool = ...,
         splinesteps: float = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1529,10 +1779,11 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_rectangle(
         self,
-        __x0: float,
-        __y0: float,
-        __x1: float,
-        __y1: float,
+        x0: float,
+        y0: float,
+        x1: float,
+        y1: float,
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1553,7 +1804,7 @@ class Canvas(Widget, XView, YView):
         outline: str = ...,
         outlineoffset: _ScreenUnits = ...,
         outlinestipple: str = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1561,8 +1812,9 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_rectangle(
         self,
-        __xy_pair_0: tuple[float, float],
-        __xy_pair_1: tuple[float, float],
+        xy_pair_0: tuple[float, float],
+        xy_pair_1: tuple[float, float],
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1583,7 +1835,7 @@ class Canvas(Widget, XView, YView):
         outline: str = ...,
         outlineoffset: _ScreenUnits = ...,
         outlinestipple: str = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1591,7 +1843,7 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_rectangle(
         self,
-        __coords: (
+        coords: (
             tuple[float, float, float, float]
             | tuple[tuple[float, float], tuple[float, float]]
             | list[int]
@@ -1599,6 +1851,7 @@ class Canvas(Widget, XView, YView):
             | list[tuple[int, int]]
             | list[tuple[float, float]]
         ),
+        /,
         *,
         activedash: str | int | list[int] | tuple[int, ...] = ...,
         activefill: str = ...,
@@ -1619,7 +1872,7 @@ class Canvas(Widget, XView, YView):
         outline: str = ...,
         outlineoffset: _ScreenUnits = ...,
         outlinestipple: str = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
@@ -1627,19 +1880,21 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_text(
         self,
-        __x: float,
-        __y: float,
+        x: float,
+        y: float,
+        /,
         *,
         activefill: str = ...,
         activestipple: str = ...,
         anchor: _Anchor = ...,
+        angle: float | str = ...,
         disabledfill: str = ...,
         disabledstipple: str = ...,
         fill: str = ...,
         font: _FontDescription = ...,
         justify: Literal["left", "center", "right"] = ...,
         offset: _ScreenUnits = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         text: float | str = ...,
@@ -1648,18 +1903,20 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_text(
         self,
-        __coords: tuple[float, float] | list[int] | list[float],
+        coords: tuple[float, float] | list[int] | list[float],
+        /,
         *,
         activefill: str = ...,
         activestipple: str = ...,
         anchor: _Anchor = ...,
+        angle: float | str = ...,
         disabledfill: str = ...,
         disabledstipple: str = ...,
         fill: str = ...,
         font: _FontDescription = ...,
         justify: Literal["left", "center", "right"] = ...,
         offset: _ScreenUnits = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         stipple: str = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         text: float | str = ...,
@@ -1668,12 +1925,13 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_window(
         self,
-        __x: float,
-        __y: float,
+        x: float,
+        y: float,
+        /,
         *,
         anchor: _Anchor = ...,
         height: _ScreenUnits = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
         window: Widget = ...,
@@ -1681,11 +1939,12 @@ class Canvas(Widget, XView, YView):
     @overload
     def create_window(
         self,
-        __coords: tuple[float, float] | list[int] | list[float],
+        coords: tuple[float, float] | list[int] | list[float],
+        /,
         *,
         anchor: _Anchor = ...,
         height: _ScreenUnits = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
+        state: Literal["normal", "hidden", "disabled"] = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
         width: _ScreenUnits = ...,
         window: Widget = ...,
@@ -1693,11 +1952,11 @@ class Canvas(Widget, XView, YView):
     def dchars(self, *args) -> None: ...
     def delete(self, *tagsOrCanvasIds: str | int) -> None: ...
     @overload
-    def dtag(self, __tag: str, __tag_to_delete: str | None = ...) -> None: ...
+    def dtag(self, tag: str, tag_to_delete: str | None = ..., /) -> None: ...
     @overload
-    def dtag(self, __id: int, __tag_to_delete: str) -> None: ...
+    def dtag(self, id: int, tag_to_delete: str, /) -> None: ...
     def focus(self, *args): ...
-    def gettags(self, __tagOrId: str | int) -> tuple[str, ...]: ...
+    def gettags(self, tagOrId: str | int, /) -> tuple[str, ...]: ...
     def icursor(self, *args) -> None: ...
     def index(self, *args): ...
     def insert(self, *args) -> None: ...
@@ -1708,21 +1967,21 @@ class Canvas(Widget, XView, YView):
     ) -> dict[str, tuple[str, str, str, str, str]] | None: ...
     itemconfig = itemconfigure
     def move(self, *args) -> None: ...
-    if sys.version_info >= (3, 8):
-        def moveto(self, tagOrId: str | int, x: Literal[""] | float = "", y: Literal[""] | float = "") -> None: ...
-
+    def moveto(self, tagOrId: str | int, x: Literal[""] | float = "", y: Literal[""] | float = "") -> None: ...
     def postscript(self, cnf={}, **kw): ...
     # tkinter does:
     #    lower = tag_lower
     #    lift = tkraise = tag_raise
     #
     # But mypy doesn't like aliasing here (maybe because Misc defines the same names)
-    def tag_lower(self, __first: str | int, __second: str | int | None = ...) -> None: ...
-    def lower(self, __first: str | int, __second: str | int | None = ...) -> None: ...  # type: ignore[override]
-    def tag_raise(self, __first: str | int, __second: str | int | None = ...) -> None: ...
-    def tkraise(self, __first: str | int, __second: str | int | None = ...) -> None: ...  # type: ignore[override]
-    def lift(self, __first: str | int, __second: str | int | None = ...) -> None: ...  # type: ignore[override]
-    def scale(self, *args) -> None: ...
+    def tag_lower(self, first: str | int, second: str | int | None = ..., /) -> None: ...
+    def lower(self, first: str | int, second: str | int | None = ..., /) -> None: ...  # type: ignore[override]
+    def tag_raise(self, first: str | int, second: str | int | None = ..., /) -> None: ...
+    def tkraise(self, first: str | int, second: str | int | None = ..., /) -> None: ...  # type: ignore[override]
+    def lift(self, first: str | int, second: str | int | None = ..., /) -> None: ...  # type: ignore[override]
+    def scale(
+        self, tagOrId: str | int, xOrigin: _ScreenUnits, yOrigin: _ScreenUnits, xScale: float, yScale: float, /
+    ) -> None: ...
     def scan_mark(self, x, y) -> None: ...
     def scan_dragto(self, x, y, gain: int = 10) -> None: ...
     def select_adjust(self, tagOrId, index) -> None: ...
@@ -1730,7 +1989,7 @@ class Canvas(Widget, XView, YView):
     def select_from(self, tagOrId, index) -> None: ...
     def select_item(self): ...
     def select_to(self, tagOrId, index) -> None: ...
-    def type(self, tagOrId): ...
+    def type(self, tagOrId: str | int) -> int | None: ...
 
 class Checkbutton(Widget):
     def __init__(
@@ -1740,27 +1999,27 @@ class Checkbutton(Widget):
         *,
         activebackground: str = ...,
         activeforeground: str = ...,
-        anchor: _Anchor = ...,
+        anchor: _Anchor = "center",
         background: str = ...,
         bd: _ScreenUnits = ...,
         bg: str = ...,
-        bitmap: str = ...,
+        bitmap: str = "",
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
-        command: _ButtonCommand = ...,
-        compound: _Compound = ...,
-        cursor: _Cursor = ...,
+        command: _ButtonCommand = "",
+        compound: _Compound = "none",
+        cursor: _Cursor = "",
         disabledforeground: str = ...,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
-        height: _ScreenUnits = ...,
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
-        image: _ImageSpec = ...,
-        indicatoron: bool = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        highlightthickness: _ScreenUnits = 1,
+        image: _ImageSpec = "",
+        indicatoron: bool = True,
+        justify: Literal["left", "center", "right"] = "center",
         name: str = ...,
         offrelief: _Relief = ...,
         # The checkbutton puts a value to its variable when it's checked or
@@ -1773,24 +2032,24 @@ class Checkbutton(Widget):
         # and list[int] are incompatible. Also, we would need a way to
         # specify "Checkbutton not associated with any variable", which is
         # done by setting variable to empty string (the default).
-        offvalue: Any = ...,
-        onvalue: Any = ...,
-        overrelief: _Relief = ...,
-        padx: _ScreenUnits = ...,
-        pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
+        offvalue: Any = 0,
+        onvalue: Any = 1,
+        overrelief: _Relief | Literal[""] = "",
+        padx: _ScreenUnits = 1,
+        pady: _ScreenUnits = 1,
+        relief: _Relief = "flat",
         selectcolor: str = ...,
-        selectimage: _ImageSpec = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        text: float | str = ...,
+        selectimage: _ImageSpec = "",
+        state: Literal["normal", "active", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = "",
+        text: float | str = "",
         textvariable: Variable = ...,
-        tristateimage: _ImageSpec = ...,
-        tristatevalue: Any = ...,
-        underline: int = ...,
+        tristateimage: _ImageSpec = "",
+        tristatevalue: Any = "",
+        underline: int = -1,
         variable: Variable | Literal[""] = ...,
-        width: _ScreenUnits = ...,
-        wraplength: _ScreenUnits = ...,
+        width: _ScreenUnits = 0,
+        wraplength: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -1823,7 +2082,7 @@ class Checkbutton(Widget):
         offrelief: _Relief = ...,
         offvalue: Any = ...,
         onvalue: Any = ...,
-        overrelief: _Relief = ...,
+        overrelief: _Relief | Literal[""] = ...,
         padx: _ScreenUnits = ...,
         pady: _ScreenUnits = ...,
         relief: _Relief = ...,
@@ -1849,8 +2108,6 @@ class Checkbutton(Widget):
     def select(self) -> None: ...
     def toggle(self) -> None: ...
 
-_EntryIndex: TypeAlias = str | int  # "INDICES" in manual page
-
 class Entry(Widget, XView):
     def __init__(
         self,
@@ -1862,39 +2119,39 @@ class Entry(Widget, XView):
         bg: str = ...,
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
-        cursor: _Cursor = ...,
+        cursor: _Cursor = "xterm",
         disabledbackground: str = ...,
         disabledforeground: str = ...,
-        exportselection: bool = ...,
+        exportselection: bool = True,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkTextFont",
         foreground: str = ...,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
         highlightthickness: _ScreenUnits = ...,
         insertbackground: str = ...,
-        insertborderwidth: _ScreenUnits = ...,
-        insertofftime: int = ...,
-        insertontime: int = ...,
+        insertborderwidth: _ScreenUnits = 0,
+        insertofftime: int = 300,
+        insertontime: int = 600,
         insertwidth: _ScreenUnits = ...,
-        invalidcommand: _EntryValidateCommand = ...,
-        invcmd: _EntryValidateCommand = ...,  # same as invalidcommand
-        justify: Literal["left", "center", "right"] = ...,
+        invalidcommand: _EntryValidateCommand = "",
+        invcmd: _EntryValidateCommand = "",  # same as invalidcommand
+        justify: Literal["left", "center", "right"] = "left",
         name: str = ...,
         readonlybackground: str = ...,
-        relief: _Relief = ...,
+        relief: _Relief = "sunken",
         selectbackground: str = ...,
         selectborderwidth: _ScreenUnits = ...,
         selectforeground: str = ...,
-        show: str = ...,
-        state: Literal["normal", "disabled", "readonly"] = ...,
-        takefocus: _TakeFocusValue = ...,
+        show: str = "",
+        state: Literal["normal", "disabled", "readonly"] = "normal",
+        takefocus: _TakeFocusValue = "",
         textvariable: Variable = ...,
-        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
-        validatecommand: _EntryValidateCommand = ...,
-        vcmd: _EntryValidateCommand = ...,  # same as validatecommand
-        width: int = ...,
-        xscrollcommand: _XYScrollCommand = ...,
+        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = "none",
+        validatecommand: _EntryValidateCommand = "",
+        vcmd: _EntryValidateCommand = "",  # same as validatecommand
+        width: int = 20,
+        xscrollcommand: _XYScrollCommand = "",
     ) -> None: ...
     @overload
     def configure(
@@ -1942,19 +2199,19 @@ class Entry(Widget, XView):
     @overload
     def configure(self, cnf: str) -> tuple[str, str, str, Any, Any]: ...
     config = configure
-    def delete(self, first: _EntryIndex, last: _EntryIndex | None = None) -> None: ...
+    def delete(self, first: str | int, last: str | int | None = None) -> None: ...
     def get(self) -> str: ...
-    def icursor(self, index: _EntryIndex) -> None: ...
-    def index(self, index: _EntryIndex) -> int: ...
-    def insert(self, index: _EntryIndex, string: str) -> None: ...
+    def icursor(self, index: str | int) -> None: ...
+    def index(self, index: str | int) -> int: ...
+    def insert(self, index: str | int, string: str) -> None: ...
     def scan_mark(self, x) -> None: ...
     def scan_dragto(self, x) -> None: ...
-    def selection_adjust(self, index: _EntryIndex) -> None: ...
+    def selection_adjust(self, index: str | int) -> None: ...
     def selection_clear(self) -> None: ...  # type: ignore[override]
-    def selection_from(self, index: _EntryIndex) -> None: ...
+    def selection_from(self, index: str | int) -> None: ...
     def selection_present(self) -> bool: ...
-    def selection_range(self, start: _EntryIndex, end: _EntryIndex) -> None: ...
-    def selection_to(self, index: _EntryIndex) -> None: ...
+    def selection_range(self, start: str | int, end: str | int) -> None: ...
+    def selection_to(self, index: str | int) -> None: ...
     select_adjust = selection_adjust
     select_clear = selection_clear
     select_from = selection_from
@@ -1969,25 +2226,25 @@ class Frame(Widget):
         cnf: dict[str, Any] | None = {},
         *,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 0,
         bg: str = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
-        class_: str = ...,  # can't be changed with configure()
-        colormap: Literal["new", ""] | Misc = ...,  # can't be changed with configure()
-        container: bool = ...,  # can't be changed with configure()
-        cursor: _Cursor = ...,
-        height: _ScreenUnits = ...,
+        border: _ScreenUnits = 0,
+        borderwidth: _ScreenUnits = 0,
+        class_: str = "Frame",  # can't be changed with configure()
+        colormap: Literal["new", ""] | Misc = "",  # can't be changed with configure()
+        container: bool = False,  # can't be changed with configure()
+        cursor: _Cursor = "",
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
+        highlightthickness: _ScreenUnits = 0,
         name: str = ...,
-        padx: _ScreenUnits = ...,
-        pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
-        takefocus: _TakeFocusValue = ...,
-        visual: str | tuple[str, int] = ...,  # can't be changed with configure()
-        width: _ScreenUnits = ...,
+        padx: _ScreenUnits = 0,
+        pady: _ScreenUnits = 0,
+        relief: _Relief = "flat",
+        takefocus: _TakeFocusValue = 0,
+        visual: str | tuple[str, int] = "",  # can't be changed with configure()
+        width: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -2022,36 +2279,36 @@ class Label(Widget):
         *,
         activebackground: str = ...,
         activeforeground: str = ...,
-        anchor: _Anchor = ...,
+        anchor: _Anchor = "center",
         background: str = ...,
         bd: _ScreenUnits = ...,
         bg: str = ...,
-        bitmap: str = ...,
+        bitmap: str = "",
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
-        compound: _Compound = ...,
-        cursor: _Cursor = ...,
+        compound: _Compound = "none",
+        cursor: _Cursor = "",
         disabledforeground: str = ...,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
-        height: _ScreenUnits = ...,
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
-        image: _ImageSpec = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        highlightthickness: _ScreenUnits = 0,
+        image: _ImageSpec = "",
+        justify: Literal["left", "center", "right"] = "center",
         name: str = ...,
-        padx: _ScreenUnits = ...,
-        pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        text: float | str = ...,
+        padx: _ScreenUnits = 1,
+        pady: _ScreenUnits = 1,
+        relief: _Relief = "flat",
+        state: Literal["normal", "active", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = 0,
+        text: float | str = "",
         textvariable: Variable = ...,
-        underline: int = ...,
-        width: _ScreenUnits = ...,
-        wraplength: _ScreenUnits = ...,
+        underline: int = -1,
+        width: _ScreenUnits = 0,
+        wraplength: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -2102,21 +2359,21 @@ class Listbox(Widget, XView, YView):
         *,
         activestyle: Literal["dotbox", "none", "underline"] = ...,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 1,
         bg: str = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
-        cursor: _Cursor = ...,
+        border: _ScreenUnits = 1,
+        borderwidth: _ScreenUnits = 1,
+        cursor: _Cursor = "",
         disabledforeground: str = ...,
-        exportselection: int = ...,
+        exportselection: bool | Literal[0, 1] = 1,
         fg: str = ...,
         font: _FontDescription = ...,
         foreground: str = ...,
-        height: int = ...,
+        height: int = 10,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
         highlightthickness: _ScreenUnits = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        justify: Literal["left", "center", "right"] = "left",
         # There's no tkinter.ListVar, but seems like bare tkinter.Variable
         # actually works for this:
         #
@@ -2130,20 +2387,21 @@ class Listbox(Widget, XView, YView):
         name: str = ...,
         relief: _Relief = ...,
         selectbackground: str = ...,
-        selectborderwidth: _ScreenUnits = ...,
+        selectborderwidth: _ScreenUnits = 0,
         selectforeground: str = ...,
         # from listbox man page: "The value of the [selectmode] option may be
-        # arbitrary, but the default bindings expect it to be ..."
+        # arbitrary, but the default bindings expect it to be either single,
+        # browse, multiple, or extended"
         #
         # I have never seen anyone setting this to something else than what
         # "the default bindings expect", but let's support it anyway.
-        selectmode: str = ...,
-        setgrid: bool = ...,
-        state: Literal["normal", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        width: int = ...,
-        xscrollcommand: _XYScrollCommand = ...,
-        yscrollcommand: _XYScrollCommand = ...,
+        selectmode: str | Literal["single", "browse", "multiple", "extended"] = "browse",  # noqa: Y051
+        setgrid: bool = False,
+        state: Literal["normal", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = "",
+        width: int = 20,
+        xscrollcommand: _XYScrollCommand = "",
+        yscrollcommand: _XYScrollCommand = "",
     ) -> None: ...
     @overload
     def configure(
@@ -2172,7 +2430,7 @@ class Listbox(Widget, XView, YView):
         selectbackground: str = ...,
         selectborderwidth: _ScreenUnits = ...,
         selectforeground: str = ...,
-        selectmode: str = ...,
+        selectmode: str | Literal["single", "browse", "multiple", "extended"] = ...,  # noqa: Y051
         setgrid: bool = ...,
         state: Literal["normal", "disabled"] = ...,
         takefocus: _TakeFocusValue = ...,
@@ -2221,23 +2479,23 @@ class Menu(Widget):
         bg: str = ...,
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
-        cursor: _Cursor = ...,
+        cursor: _Cursor = "arrow",
         disabledforeground: str = ...,
         fg: str = ...,
         font: _FontDescription = ...,
         foreground: str = ...,
         name: str = ...,
-        postcommand: Callable[[], object] | str = ...,
+        postcommand: Callable[[], object] | str = "",
         relief: _Relief = ...,
         selectcolor: str = ...,
-        takefocus: _TakeFocusValue = ...,
-        tearoff: int = ...,
+        takefocus: _TakeFocusValue = 0,
+        tearoff: bool | Literal[0, 1] = 1,
         # I guess tearoffcommand arguments are supposed to be widget objects,
         # but they are widget name strings. Use nametowidget() to handle the
         # arguments of tearoffcommand.
-        tearoffcommand: Callable[[str, str], object] | str = ...,
-        title: str = ...,
-        type: Literal["menubar", "tearoff", "normal"] = ...,
+        tearoffcommand: Callable[[str, str], object] | str = "",
+        title: str = "",
+        type: Literal["menubar", "tearoff", "normal"] = "normal",
     ) -> None: ...
     @overload
     def configure(
@@ -2489,35 +2747,35 @@ class Menubutton(Widget):
         background: str = ...,
         bd: _ScreenUnits = ...,
         bg: str = ...,
-        bitmap: str = ...,
+        bitmap: str = "",
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
-        compound: _Compound = ...,
-        cursor: _Cursor = ...,
-        direction: Literal["above", "below", "left", "right", "flush"] = ...,
+        compound: _Compound = "none",
+        cursor: _Cursor = "",
+        direction: Literal["above", "below", "left", "right", "flush"] = "below",
         disabledforeground: str = ...,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
-        height: _ScreenUnits = ...,
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
-        image: _ImageSpec = ...,
+        highlightthickness: _ScreenUnits = 0,
+        image: _ImageSpec = "",
         indicatoron: bool = ...,
         justify: Literal["left", "center", "right"] = ...,
         menu: Menu = ...,
         name: str = ...,
         padx: _ScreenUnits = ...,
         pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        text: float | str = ...,
+        relief: _Relief = "flat",
+        state: Literal["normal", "active", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = 0,
+        text: float | str = "",
         textvariable: Variable = ...,
-        underline: int = ...,
-        width: _ScreenUnits = ...,
-        wraplength: _ScreenUnits = ...,
+        underline: int = -1,
+        width: _ScreenUnits = 0,
+        wraplength: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -2569,30 +2827,30 @@ class Message(Widget):
         master: Misc | None = None,
         cnf: dict[str, Any] | None = {},
         *,
-        anchor: _Anchor = ...,
-        aspect: int = ...,
+        anchor: _Anchor = "center",
+        aspect: int = 150,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 1,
         bg: str = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
-        cursor: _Cursor = ...,
+        border: _ScreenUnits = 1,
+        borderwidth: _ScreenUnits = 1,
+        cursor: _Cursor = "",
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        highlightthickness: _ScreenUnits = 0,
+        justify: Literal["left", "center", "right"] = "left",
         name: str = ...,
         padx: _ScreenUnits = ...,
         pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
-        takefocus: _TakeFocusValue = ...,
-        text: float | str = ...,
+        relief: _Relief = "flat",
+        takefocus: _TakeFocusValue = 0,
+        text: float | str = "",
         textvariable: Variable = ...,
         # there's width but no height
-        width: _ScreenUnits = ...,
+        width: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -2634,46 +2892,46 @@ class Radiobutton(Widget):
         *,
         activebackground: str = ...,
         activeforeground: str = ...,
-        anchor: _Anchor = ...,
+        anchor: _Anchor = "center",
         background: str = ...,
         bd: _ScreenUnits = ...,
         bg: str = ...,
-        bitmap: str = ...,
+        bitmap: str = "",
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
-        command: _ButtonCommand = ...,
-        compound: _Compound = ...,
-        cursor: _Cursor = ...,
+        command: _ButtonCommand = "",
+        compound: _Compound = "none",
+        cursor: _Cursor = "",
         disabledforeground: str = ...,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
-        height: _ScreenUnits = ...,
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
-        image: _ImageSpec = ...,
-        indicatoron: bool = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        highlightthickness: _ScreenUnits = 1,
+        image: _ImageSpec = "",
+        indicatoron: bool = True,
+        justify: Literal["left", "center", "right"] = "center",
         name: str = ...,
         offrelief: _Relief = ...,
-        overrelief: _Relief = ...,
-        padx: _ScreenUnits = ...,
-        pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
+        overrelief: _Relief | Literal[""] = "",
+        padx: _ScreenUnits = 1,
+        pady: _ScreenUnits = 1,
+        relief: _Relief = "flat",
         selectcolor: str = ...,
-        selectimage: _ImageSpec = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        text: float | str = ...,
+        selectimage: _ImageSpec = "",
+        state: Literal["normal", "active", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = "",
+        text: float | str = "",
         textvariable: Variable = ...,
-        tristateimage: _ImageSpec = ...,
-        tristatevalue: Any = ...,
-        underline: int = ...,
-        value: Any = ...,
+        tristateimage: _ImageSpec = "",
+        tristatevalue: Any = "",
+        underline: int = -1,
+        value: Any = "",
         variable: Variable | Literal[""] = ...,
-        width: _ScreenUnits = ...,
-        wraplength: _ScreenUnits = ...,
+        width: _ScreenUnits = 0,
+        wraplength: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -2704,7 +2962,7 @@ class Radiobutton(Widget):
         indicatoron: bool = ...,
         justify: Literal["left", "center", "right"] = ...,
         offrelief: _Relief = ...,
-        overrelief: _Relief = ...,
+        overrelief: _Relief | Literal[""] = ...,
         padx: _ScreenUnits = ...,
         pady: _ScreenUnits = ...,
         relief: _Relief = ...,
@@ -2738,40 +2996,40 @@ class Scale(Widget):
         *,
         activebackground: str = ...,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 1,
         bg: str = ...,
-        bigincrement: float = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
+        bigincrement: float = 0.0,
+        border: _ScreenUnits = 1,
+        borderwidth: _ScreenUnits = 1,
         # don't know why the callback gets string instead of float
-        command: str | Callable[[str], object] = ...,
-        cursor: _Cursor = ...,
-        digits: int = ...,
+        command: str | Callable[[str], object] = "",
+        cursor: _Cursor = "",
+        digits: int = 0,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
-        from_: float = ...,
+        from_: float = 0.0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
         highlightthickness: _ScreenUnits = ...,
-        label: str = ...,
-        length: _ScreenUnits = ...,
+        label: str = "",
+        length: _ScreenUnits = 100,
         name: str = ...,
-        orient: Literal["horizontal", "vertical"] = ...,
-        relief: _Relief = ...,
-        repeatdelay: int = ...,
-        repeatinterval: int = ...,
-        resolution: float = ...,
-        showvalue: bool = ...,
-        sliderlength: _ScreenUnits = ...,
-        sliderrelief: _Relief = ...,
-        state: Literal["normal", "active", "disabled"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        tickinterval: float = ...,
-        to: float = ...,
+        orient: Literal["horizontal", "vertical"] = "vertical",
+        relief: _Relief = "flat",
+        repeatdelay: int = 300,
+        repeatinterval: int = 100,
+        resolution: float = 1.0,
+        showvalue: bool = True,
+        sliderlength: _ScreenUnits = 30,
+        sliderrelief: _Relief = "raised",
+        state: Literal["normal", "active", "disabled"] = "normal",
+        takefocus: _TakeFocusValue = "",
+        tickinterval: float = 0.0,
+        to: float = 100.0,
         troughcolor: str = ...,
         variable: IntVar | DoubleVar = ...,
-        width: _ScreenUnits = ...,
+        width: _ScreenUnits = 15,
     ) -> None: ...
     @overload
     def configure(
@@ -2828,7 +3086,7 @@ class Scrollbar(Widget):
         cnf: dict[str, Any] | None = {},
         *,
         activebackground: str = ...,
-        activerelief: _Relief = ...,
+        activerelief: _Relief = "raised",
         background: str = ...,
         bd: _ScreenUnits = ...,
         bg: str = ...,
@@ -2838,19 +3096,19 @@ class Scrollbar(Widget):
         # 'SCROLLING COMMANDS' in scrollbar man page. There doesn't seem to
         # be any way to specify an overloaded callback function, so we say
         # that it can take any args while it can't in reality.
-        command: Callable[..., tuple[float, float] | None] | str = ...,
-        cursor: _Cursor = ...,
-        elementborderwidth: _ScreenUnits = ...,
+        command: Callable[..., tuple[float, float] | None] | str = "",
+        cursor: _Cursor = "",
+        elementborderwidth: _ScreenUnits = -1,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
-        jump: bool = ...,
+        highlightthickness: _ScreenUnits = 0,
+        jump: bool = False,
         name: str = ...,
-        orient: Literal["horizontal", "vertical"] = ...,
+        orient: Literal["horizontal", "vertical"] = "vertical",
         relief: _Relief = ...,
-        repeatdelay: int = ...,
-        repeatinterval: int = ...,
-        takefocus: _TakeFocusValue = ...,
+        repeatdelay: int = 300,
+        repeatinterval: int = 100,
+        takefocus: _TakeFocusValue = "",
         troughcolor: str = ...,
         width: _ScreenUnits = ...,
     ) -> None: ...
@@ -2889,9 +3147,12 @@ class Scrollbar(Widget):
     def fraction(self, x: int, y: int) -> float: ...
     def identify(self, x: int, y: int) -> Literal["arrow1", "arrow2", "slider", "trough1", "trough2", ""]: ...
     def get(self) -> tuple[float, float, float, float] | tuple[float, float]: ...
-    def set(self, first: float, last: float) -> None: ...
+    def set(self, first: float | str, last: float | str) -> None: ...
 
 _TextIndex: TypeAlias = _tkinter.Tcl_Obj | str | float | Misc
+_WhatToCount: TypeAlias = Literal[
+    "chars", "displaychars", "displayindices", "displaylines", "indices", "lines", "xpixels", "ypixels"
+]
 
 class Text(Widget, XView, YView):
     def __init__(
@@ -2899,56 +3160,56 @@ class Text(Widget, XView, YView):
         master: Misc | None = None,
         cnf: dict[str, Any] | None = {},
         *,
-        autoseparators: bool = ...,
+        autoseparators: bool = True,
         background: str = ...,
         bd: _ScreenUnits = ...,
         bg: str = ...,
-        blockcursor: bool = ...,
+        blockcursor: bool = False,
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
-        cursor: _Cursor = ...,
-        endline: int | Literal[""] = ...,
-        exportselection: bool = ...,
+        cursor: _Cursor = "xterm",
+        endline: int | Literal[""] = "",
+        exportselection: bool = True,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkFixedFont",
         foreground: str = ...,
         # width is always int, but height is allowed to be ScreenUnits.
         # This doesn't make any sense to me, and this isn't documented.
         # The docs seem to say that both should be integers.
-        height: _ScreenUnits = ...,
+        height: _ScreenUnits = 24,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
         highlightthickness: _ScreenUnits = ...,
         inactiveselectbackground: str = ...,
         insertbackground: str = ...,
-        insertborderwidth: _ScreenUnits = ...,
-        insertofftime: int = ...,
-        insertontime: int = ...,
-        insertunfocussed: Literal["none", "hollow", "solid"] = ...,
+        insertborderwidth: _ScreenUnits = 0,
+        insertofftime: int = 300,
+        insertontime: int = 600,
+        insertunfocussed: Literal["none", "hollow", "solid"] = "none",
         insertwidth: _ScreenUnits = ...,
-        maxundo: int = ...,
+        maxundo: int = 0,
         name: str = ...,
-        padx: _ScreenUnits = ...,
-        pady: _ScreenUnits = ...,
+        padx: _ScreenUnits = 1,
+        pady: _ScreenUnits = 1,
         relief: _Relief = ...,
         selectbackground: str = ...,
         selectborderwidth: _ScreenUnits = ...,
         selectforeground: str = ...,
-        setgrid: bool = ...,
-        spacing1: _ScreenUnits = ...,
-        spacing2: _ScreenUnits = ...,
-        spacing3: _ScreenUnits = ...,
-        startline: int | Literal[""] = ...,
-        state: Literal["normal", "disabled"] = ...,
+        setgrid: bool = False,
+        spacing1: _ScreenUnits = 0,
+        spacing2: _ScreenUnits = 0,
+        spacing3: _ScreenUnits = 0,
+        startline: int | Literal[""] = "",
+        state: Literal["normal", "disabled"] = "normal",
         # Literal inside Tuple doesn't actually work
-        tabs: _ScreenUnits | str | tuple[_ScreenUnits | str, ...] = ...,
-        tabstyle: Literal["tabular", "wordprocessor"] = ...,
-        takefocus: _TakeFocusValue = ...,
-        undo: bool = ...,
-        width: int = ...,
-        wrap: Literal["none", "char", "word"] = ...,
-        xscrollcommand: _XYScrollCommand = ...,
-        yscrollcommand: _XYScrollCommand = ...,
+        tabs: _ScreenUnits | str | tuple[_ScreenUnits | str, ...] = "",
+        tabstyle: Literal["tabular", "wordprocessor"] = "tabular",
+        takefocus: _TakeFocusValue = "",
+        undo: bool = False,
+        width: int = 80,
+        wrap: Literal["none", "char", "word"] = "char",
+        xscrollcommand: _XYScrollCommand = "",
+        yscrollcommand: _XYScrollCommand = "",
     ) -> None: ...
     @overload
     def configure(
@@ -3006,7 +3267,133 @@ class Text(Widget, XView, YView):
     config = configure
     def bbox(self, index: _TextIndex) -> tuple[int, int, int, int] | None: ...  # type: ignore[override]
     def compare(self, index1: _TextIndex, op: Literal["<", "<=", "==", ">=", ">", "!="], index2: _TextIndex) -> bool: ...
-    def count(self, index1, index2, *args): ...  # TODO
+    if sys.version_info >= (3, 13):
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, *, return_ints: Literal[True]) -> int: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /, *, return_ints: Literal[True]
+        ) -> int: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: Literal["update"],
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[True],
+        ) -> int: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: Literal["update"],
+            /,
+            *,
+            return_ints: Literal[True],
+        ) -> int: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /, *, return_ints: Literal[True]
+        ) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+            return_ints: Literal[True],
+        ) -> tuple[int, ...]: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, *, return_ints: Literal[False] = False) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg: _WhatToCount | Literal["update"],
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: Literal["update"],
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> int | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: Literal["update"],
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> int | None: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount,
+            arg2: _WhatToCount,
+            /,
+            *,
+            return_ints: Literal[False] = False,
+        ) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+            return_ints: Literal[False] = False,
+        ) -> tuple[int, ...]: ...
+    else:
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex) -> tuple[int] | None: ...
+        @overload
+        def count(
+            self, index1: _TextIndex, index2: _TextIndex, arg: _WhatToCount | Literal["update"], /
+        ) -> tuple[int] | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: Literal["update"], arg2: _WhatToCount, /) -> int | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: Literal["update"], /) -> int | None: ...
+        @overload
+        def count(self, index1: _TextIndex, index2: _TextIndex, arg1: _WhatToCount, arg2: _WhatToCount, /) -> tuple[int, int]: ...
+        @overload
+        def count(
+            self,
+            index1: _TextIndex,
+            index2: _TextIndex,
+            arg1: _WhatToCount | Literal["update"],
+            arg2: _WhatToCount | Literal["update"],
+            arg3: _WhatToCount | Literal["update"],
+            /,
+            *args: _WhatToCount | Literal["update"],
+        ) -> tuple[int, ...]: ...
+
     @overload
     def debug(self, boolean: None = None) -> bool: ...
     @overload
@@ -3065,11 +3452,40 @@ class Text(Widget, XView, YView):
     def edit_separator(self) -> None: ...  # actually returns empty string
     def edit_undo(self) -> None: ...  # actually returns empty string
     def get(self, index1: _TextIndex, index2: _TextIndex | None = None) -> str: ...
-    # TODO: image_* methods
-    def image_cget(self, index, option): ...
-    def image_configure(self, index, cnf: Incomplete | None = None, **kw): ...
-    def image_create(self, index, cnf={}, **kw): ...
-    def image_names(self): ...
+    @overload
+    def image_cget(self, index: _TextIndex, option: Literal["image", "name"]) -> str: ...
+    @overload
+    def image_cget(self, index: _TextIndex, option: Literal["padx", "pady"]) -> int: ...
+    @overload
+    def image_cget(self, index: _TextIndex, option: Literal["align"]) -> Literal["baseline", "bottom", "center", "top"]: ...
+    @overload
+    def image_cget(self, index: _TextIndex, option: str) -> Any: ...
+    @overload
+    def image_configure(self, index: _TextIndex, cnf: str) -> tuple[str, str, str, str, str | int]: ...
+    @overload
+    def image_configure(
+        self,
+        index: _TextIndex,
+        cnf: dict[str, Any] | None = {},
+        *,
+        align: Literal["baseline", "bottom", "center", "top"] = ...,
+        image: _ImageSpec = ...,
+        name: str = ...,
+        padx: _ScreenUnits = ...,
+        pady: _ScreenUnits = ...,
+    ) -> dict[str, tuple[str, str, str, str, str | int]] | None: ...
+    def image_create(
+        self,
+        index: _TextIndex,
+        cnf: dict[str, Any] | None = {},
+        *,
+        align: Literal["baseline", "bottom", "center", "top"] = ...,
+        image: _ImageSpec = ...,
+        name: str = ...,
+        padx: _ScreenUnits = ...,
+        pady: _ScreenUnits = ...,
+    ) -> str: ...
+    def image_names(self) -> tuple[str, ...]: ...
     def index(self, index: _TextIndex) -> str: ...
     def insert(self, index: _TextIndex, chars: str, *args: str | list[str] | tuple[str, ...]) -> None: ...
     @overload
@@ -3154,7 +3570,7 @@ class Text(Widget, XView, YView):
     @overload
     def tag_configure(self, tagName: str, cnf: str) -> tuple[str, str, str, Any, Any]: ...
     tag_config = tag_configure
-    def tag_delete(self, __first_tag_name: str, *tagNames: str) -> None: ...  # error if no tag names given
+    def tag_delete(self, first_tag_name: str, /, *tagNames: str) -> None: ...  # error if no tag names given
     def tag_lower(self, tagName: str, belowThis: str | None = None) -> None: ...
     def tag_names(self, index: _TextIndex | None = None) -> tuple[str, ...]: ...
     def tag_nextrange(
@@ -3167,12 +3583,45 @@ class Text(Widget, XView, YView):
     def tag_ranges(self, tagName: str) -> tuple[_tkinter.Tcl_Obj, ...]: ...
     # tag_remove and tag_delete are different
     def tag_remove(self, tagName: str, index1: _TextIndex, index2: _TextIndex | None = None) -> None: ...
-    # TODO: window_* methods
-    def window_cget(self, index, option): ...
-    def window_configure(self, index, cnf: Incomplete | None = None, **kw): ...
+    @overload
+    def window_cget(self, index: _TextIndex, option: Literal["padx", "pady"]) -> int: ...
+    @overload
+    def window_cget(self, index: _TextIndex, option: Literal["stretch"]) -> bool: ...  # actually returns Literal[0, 1]
+    @overload
+    def window_cget(self, index: _TextIndex, option: Literal["align"]) -> Literal["baseline", "bottom", "center", "top"]: ...
+    @overload  # window is set to a widget, but read as the string name.
+    def window_cget(self, index: _TextIndex, option: Literal["create", "window"]) -> str: ...
+    @overload
+    def window_cget(self, index: _TextIndex, option: str) -> Any: ...
+    @overload
+    def window_configure(self, index: _TextIndex, cnf: str) -> tuple[str, str, str, str, str | int]: ...
+    @overload
+    def window_configure(
+        self,
+        index: _TextIndex,
+        cnf: dict[str, Any] | None = None,
+        *,
+        align: Literal["baseline", "bottom", "center", "top"] = ...,
+        create: str = ...,
+        padx: _ScreenUnits = ...,
+        pady: _ScreenUnits = ...,
+        stretch: bool | Literal[0, 1] = ...,
+        window: Misc | str = ...,
+    ) -> dict[str, tuple[str, str, str, str, str | int]] | None: ...
     window_config = window_configure
-    def window_create(self, index, cnf={}, **kw) -> None: ...
-    def window_names(self): ...
+    def window_create(
+        self,
+        index: _TextIndex,
+        cnf: dict[str, Any] | None = {},
+        *,
+        align: Literal["baseline", "bottom", "center", "top"] = ...,
+        create: str = ...,
+        padx: _ScreenUnits = ...,
+        pady: _ScreenUnits = ...,
+        stretch: bool | Literal[0, 1] = ...,
+        window: Misc | str = ...,
+    ) -> None: ...
+    def window_names(self) -> tuple[str, ...]: ...
     def yview_pickplace(self, *what): ...  # deprecated
 
 class _setit:
@@ -3196,11 +3645,14 @@ class OptionMenu(Menubutton):
     # configure, config, cget are inherited from Menubutton
     # destroy and __getitem__ are overridden, signature does not change
 
-# Marker to indicate that it is a valid bitmap/photo image. PIL implements compatible versions
-# which don't share a class hierarchy. The actual API is a __str__() which returns a valid name,
-# not something that type checkers can detect.
+# This matches tkinter's image classes (PhotoImage and BitmapImage)
+# and PIL's tkinter-compatible class (PIL.ImageTk.PhotoImage),
+# but not a plain PIL image that isn't tkinter compatible.
+# The reason is that PIL has width and height attributes, not methods.
 @type_check_only
-class _Image: ...
+class _Image(Protocol):
+    def width(self) -> int: ...
+    def height(self) -> int: ...
 
 @type_check_only
 class _BitmapImageLike(_Image): ...
@@ -3219,9 +3671,7 @@ class Image(_Image):
     def __getitem__(self, key): ...
     configure: Incomplete
     config: Incomplete
-    def height(self) -> int: ...
     def type(self): ...
-    def width(self) -> int: ...
 
 class PhotoImage(Image, _PhotoImageLike):
     # This should be kept in sync with PIL.ImageTK.PhotoImage.__init__()
@@ -3254,9 +3704,33 @@ class PhotoImage(Image, _PhotoImageLike):
     def blank(self) -> None: ...
     def cget(self, option: str) -> str: ...
     def __getitem__(self, key: str) -> str: ...  # always string: image['height'] can be '0'
-    def copy(self) -> PhotoImage: ...
-    def zoom(self, x: int, y: int | Literal[""] = "") -> PhotoImage: ...
-    def subsample(self, x: int, y: int | Literal[""] = "") -> PhotoImage: ...
+    if sys.version_info >= (3, 13):
+        def copy(
+            self,
+            *,
+            from_coords: Iterable[int] | None = None,
+            zoom: int | tuple[int, int] | list[int] | None = None,
+            subsample: int | tuple[int, int] | list[int] | None = None,
+        ) -> PhotoImage: ...
+        def subsample(self, x: int, y: Literal[""] = "", *, from_coords: Iterable[int] | None = None) -> PhotoImage: ...
+        def zoom(self, x: int, y: Literal[""] = "", *, from_coords: Iterable[int] | None = None) -> PhotoImage: ...
+        def copy_replace(
+            self,
+            sourceImage: PhotoImage | str,
+            *,
+            from_coords: Iterable[int] | None = None,
+            to: Iterable[int] | None = None,
+            shrink: bool = False,
+            zoom: int | tuple[int, int] | list[int] | None = None,
+            subsample: int | tuple[int, int] | list[int] | None = None,
+            # `None` defaults to overlay.
+            compositingrule: Literal["overlay", "set"] | None = None,
+        ) -> None: ...
+    else:
+        def copy(self) -> PhotoImage: ...
+        def zoom(self, x: int, y: int | Literal[""] = "") -> PhotoImage: ...
+        def subsample(self, x: int, y: int | Literal[""] = "") -> PhotoImage: ...
+
     def get(self, x: int, y: int) -> tuple[int, int, int]: ...
     def put(
         self,
@@ -3271,10 +3745,46 @@ class PhotoImage(Image, _PhotoImageLike):
         ),
         to: tuple[int, int] | None = None,
     ) -> None: ...
-    def write(self, filename: StrOrBytesPath, format: str | None = None, from_coords: tuple[int, int] | None = None) -> None: ...
-    if sys.version_info >= (3, 8):
-        def transparency_get(self, x: int, y: int) -> bool: ...
-        def transparency_set(self, x: int, y: int, boolean: bool) -> None: ...
+    if sys.version_info >= (3, 13):
+        def read(
+            self,
+            filename: StrOrBytesPath,
+            format: str | None = None,
+            *,
+            from_coords: Iterable[int] | None = None,
+            to: Iterable[int] | None = None,
+            shrink: bool = False,
+        ) -> None: ...
+        def write(
+            self,
+            filename: StrOrBytesPath,
+            format: str | None = None,
+            from_coords: Iterable[int] | None = None,
+            *,
+            background: str | None = None,
+            grayscale: bool = False,
+        ) -> None: ...
+        @overload
+        def data(
+            self, format: str, *, from_coords: Iterable[int] | None = None, background: str | None = None, grayscale: bool = False
+        ) -> bytes: ...
+        @overload
+        def data(
+            self,
+            format: None = None,
+            *,
+            from_coords: Iterable[int] | None = None,
+            background: str | None = None,
+            grayscale: bool = False,
+        ) -> tuple[str, ...]: ...
+
+    else:
+        def write(
+            self, filename: StrOrBytesPath, format: str | None = None, from_coords: tuple[int, int] | None = None
+        ) -> None: ...
+
+    def transparency_get(self, x: int, y: int) -> bool: ...
+    def transparency_set(self, x: int, y: int, boolean: bool) -> None: ...
 
 class BitmapImage(Image, _BitmapImageLike):
     # This should be kept in sync with PIL.ImageTK.BitmapImage.__init__()
@@ -3308,51 +3818,51 @@ class Spinbox(Widget, XView):
         border: _ScreenUnits = ...,
         borderwidth: _ScreenUnits = ...,
         buttonbackground: str = ...,
-        buttoncursor: _Cursor = ...,
+        buttoncursor: _Cursor = "",
         buttondownrelief: _Relief = ...,
         buttonuprelief: _Relief = ...,
         # percent substitutions don't seem to be supported, it's similar to Entry's validation stuff
-        command: Callable[[], object] | str | list[str] | tuple[str, ...] = ...,
-        cursor: _Cursor = ...,
+        command: Callable[[], object] | str | list[str] | tuple[str, ...] = "",
+        cursor: _Cursor = "xterm",
         disabledbackground: str = ...,
         disabledforeground: str = ...,
-        exportselection: bool = ...,
+        exportselection: bool = True,
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkTextFont",
         foreground: str = ...,
-        format: str = ...,
-        from_: float = ...,
+        format: str = "",
+        from_: float = 0.0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
         highlightthickness: _ScreenUnits = ...,
-        increment: float = ...,
+        increment: float = 1.0,
         insertbackground: str = ...,
-        insertborderwidth: _ScreenUnits = ...,
-        insertofftime: int = ...,
-        insertontime: int = ...,
+        insertborderwidth: _ScreenUnits = 0,
+        insertofftime: int = 300,
+        insertontime: int = 600,
         insertwidth: _ScreenUnits = ...,
-        invalidcommand: _EntryValidateCommand = ...,
-        invcmd: _EntryValidateCommand = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        invalidcommand: _EntryValidateCommand = "",
+        invcmd: _EntryValidateCommand = "",
+        justify: Literal["left", "center", "right"] = "left",
         name: str = ...,
         readonlybackground: str = ...,
-        relief: _Relief = ...,
-        repeatdelay: int = ...,
-        repeatinterval: int = ...,
+        relief: _Relief = "sunken",
+        repeatdelay: int = 400,
+        repeatinterval: int = 100,
         selectbackground: str = ...,
         selectborderwidth: _ScreenUnits = ...,
         selectforeground: str = ...,
-        state: Literal["normal", "disabled", "readonly"] = ...,
-        takefocus: _TakeFocusValue = ...,
+        state: Literal["normal", "disabled", "readonly"] = "normal",
+        takefocus: _TakeFocusValue = "",
         textvariable: Variable = ...,
-        to: float = ...,
-        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
-        validatecommand: _EntryValidateCommand = ...,
-        vcmd: _EntryValidateCommand = ...,
+        to: float = 0.0,
+        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = "none",
+        validatecommand: _EntryValidateCommand = "",
+        vcmd: _EntryValidateCommand = "",
         values: list[str] | tuple[str, ...] = ...,
-        width: int = ...,
-        wrap: bool = ...,
-        xscrollcommand: _XYScrollCommand = ...,
+        width: int = 20,
+        wrap: bool = False,
+        xscrollcommand: _XYScrollCommand = "",
     ) -> None: ...
     @overload
     def configure(
@@ -3418,8 +3928,8 @@ class Spinbox(Widget, XView):
     def get(self) -> str: ...
     def icursor(self, index): ...
     def identify(self, x: int, y: int) -> Literal["", "buttondown", "buttonup", "entry"]: ...
-    def index(self, index: _EntryIndex) -> int: ...
-    def insert(self, index: _EntryIndex, s: str) -> Literal[""]: ...
+    def index(self, index: str | int) -> int: ...
+    def insert(self, index: str | int, s: str) -> Literal[""]: ...
     # spinbox.invoke("asdf") gives error mentioning .invoke("none"), but it's not documented
     def invoke(self, element: Literal["none", "buttonup", "buttondown"]) -> Literal[""]: ...
     def scan(self, *args): ...
@@ -3427,13 +3937,12 @@ class Spinbox(Widget, XView):
     def scan_dragto(self, x): ...
     def selection(self, *args) -> tuple[int, ...]: ...
     def selection_adjust(self, index): ...
-    def selection_clear(self): ...
+    def selection_clear(self): ...  # type: ignore[override]
     def selection_element(self, element: Incomplete | None = None): ...
-    if sys.version_info >= (3, 8):
-        def selection_from(self, index: int) -> None: ...
-        def selection_present(self) -> None: ...
-        def selection_range(self, start: int, end: int) -> None: ...
-        def selection_to(self, index: int) -> None: ...
+    def selection_from(self, index: int) -> None: ...
+    def selection_present(self) -> None: ...
+    def selection_range(self, start: int, end: int) -> None: ...
+    def selection_to(self, index: int) -> None: ...
 
 class LabelFrame(Widget):
     def __init__(
@@ -3442,32 +3951,32 @@ class LabelFrame(Widget):
         cnf: dict[str, Any] | None = {},
         *,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 2,
         bg: str = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
-        class_: str = ...,  # can't be changed with configure()
-        colormap: Literal["new", ""] | Misc = ...,  # can't be changed with configure()
-        container: bool = ...,  # undocumented, can't be changed with configure()
-        cursor: _Cursor = ...,
+        border: _ScreenUnits = 2,
+        borderwidth: _ScreenUnits = 2,
+        class_: str = "Labelframe",  # can't be changed with configure()
+        colormap: Literal["new", ""] | Misc = "",  # can't be changed with configure()
+        container: bool = False,  # undocumented, can't be changed with configure()
+        cursor: _Cursor = "",
         fg: str = ...,
-        font: _FontDescription = ...,
+        font: _FontDescription = "TkDefaultFont",
         foreground: str = ...,
-        height: _ScreenUnits = ...,
+        height: _ScreenUnits = 0,
         highlightbackground: str = ...,
         highlightcolor: str = ...,
-        highlightthickness: _ScreenUnits = ...,
+        highlightthickness: _ScreenUnits = 0,
         # 'ne' and 'en' are valid labelanchors, but only 'ne' is a valid _Anchor.
-        labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ...,
+        labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = "nw",
         labelwidget: Misc = ...,
         name: str = ...,
-        padx: _ScreenUnits = ...,
-        pady: _ScreenUnits = ...,
-        relief: _Relief = ...,
-        takefocus: _TakeFocusValue = ...,
-        text: float | str = ...,
-        visual: str | tuple[str, int] = ...,  # can't be changed with configure()
-        width: _ScreenUnits = ...,
+        padx: _ScreenUnits = 0,
+        pady: _ScreenUnits = 0,
+        relief: _Relief = "groove",
+        takefocus: _TakeFocusValue = 0,
+        text: float | str = "",
+        visual: str | tuple[str, int] = "",  # can't be changed with configure()
+        width: _ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -3507,27 +4016,27 @@ class PanedWindow(Widget):
         cnf: dict[str, Any] | None = {},
         *,
         background: str = ...,
-        bd: _ScreenUnits = ...,
+        bd: _ScreenUnits = 1,
         bg: str = ...,
-        border: _ScreenUnits = ...,
-        borderwidth: _ScreenUnits = ...,
-        cursor: _Cursor = ...,
-        handlepad: _ScreenUnits = ...,
-        handlesize: _ScreenUnits = ...,
-        height: _ScreenUnits = ...,
+        border: _ScreenUnits = 1,
+        borderwidth: _ScreenUnits = 1,
+        cursor: _Cursor = "",
+        handlepad: _ScreenUnits = 8,
+        handlesize: _ScreenUnits = 8,
+        height: _ScreenUnits = "",
         name: str = ...,
-        opaqueresize: bool = ...,
-        orient: Literal["horizontal", "vertical"] = ...,
-        proxybackground: str = ...,
-        proxyborderwidth: _ScreenUnits = ...,
-        proxyrelief: _Relief = ...,
-        relief: _Relief = ...,
-        sashcursor: _Cursor = ...,
-        sashpad: _ScreenUnits = ...,
-        sashrelief: _Relief = ...,
-        sashwidth: _ScreenUnits = ...,
-        showhandle: bool = ...,
-        width: _ScreenUnits = ...,
+        opaqueresize: bool = True,
+        orient: Literal["horizontal", "vertical"] = "horizontal",
+        proxybackground: str = "",
+        proxyborderwidth: _ScreenUnits = 2,
+        proxyrelief: _Relief = "flat",
+        relief: _Relief = "flat",
+        sashcursor: _Cursor = "",
+        sashpad: _ScreenUnits = 0,
+        sashrelief: _Relief = "flat",
+        sashwidth: _ScreenUnits = 3,
+        showhandle: bool = False,
+        width: _ScreenUnits = "",
     ) -> None: ...
     @overload
     def configure(
diff --git a/mypy/typeshed/stdlib/tkinter/commondialog.pyi b/mypy/typeshed/stdlib/tkinter/commondialog.pyi
index eba3ab5be3bd..d06c08df5b76 100644
--- a/mypy/typeshed/stdlib/tkinter/commondialog.pyi
+++ b/mypy/typeshed/stdlib/tkinter/commondialog.pyi
@@ -10,5 +10,5 @@ class Dialog:
     command: ClassVar[str | None]
     master: Incomplete | None
     options: Mapping[str, Incomplete]
-    def __init__(self, master: Incomplete | None = None, **options: Incomplete) -> None: ...
-    def show(self, **options: Incomplete) -> Incomplete: ...
+    def __init__(self, master: Incomplete | None = None, **options) -> None: ...
+    def show(self, **options): ...
diff --git a/mypy/typeshed/stdlib/tkinter/constants.pyi b/mypy/typeshed/stdlib/tkinter/constants.pyi
index 1383b0f9bf4b..fbfe8b49b997 100644
--- a/mypy/typeshed/stdlib/tkinter/constants.pyi
+++ b/mypy/typeshed/stdlib/tkinter/constants.pyi
@@ -1,80 +1,80 @@
-from typing_extensions import Literal
+from typing import Final
 
 # These are not actually bools. See #4669
-NO: bool
-YES: bool
-TRUE: bool
-FALSE: bool
-ON: bool
-OFF: bool
-N: Literal["n"]
-S: Literal["s"]
-W: Literal["w"]
-E: Literal["e"]
-NW: Literal["nw"]
-SW: Literal["sw"]
-NE: Literal["ne"]
-SE: Literal["se"]
-NS: Literal["ns"]
-EW: Literal["ew"]
-NSEW: Literal["nsew"]
-CENTER: Literal["center"]
-NONE: Literal["none"]
-X: Literal["x"]
-Y: Literal["y"]
-BOTH: Literal["both"]
-LEFT: Literal["left"]
-TOP: Literal["top"]
-RIGHT: Literal["right"]
-BOTTOM: Literal["bottom"]
-RAISED: Literal["raised"]
-SUNKEN: Literal["sunken"]
-FLAT: Literal["flat"]
-RIDGE: Literal["ridge"]
-GROOVE: Literal["groove"]
-SOLID: Literal["solid"]
-HORIZONTAL: Literal["horizontal"]
-VERTICAL: Literal["vertical"]
-NUMERIC: Literal["numeric"]
-CHAR: Literal["char"]
-WORD: Literal["word"]
-BASELINE: Literal["baseline"]
-INSIDE: Literal["inside"]
-OUTSIDE: Literal["outside"]
-SEL: Literal["sel"]
-SEL_FIRST: Literal["sel.first"]
-SEL_LAST: Literal["sel.last"]
-END: Literal["end"]
-INSERT: Literal["insert"]
-CURRENT: Literal["current"]
-ANCHOR: Literal["anchor"]
-ALL: Literal["all"]
-NORMAL: Literal["normal"]
-DISABLED: Literal["disabled"]
-ACTIVE: Literal["active"]
-HIDDEN: Literal["hidden"]
-CASCADE: Literal["cascade"]
-CHECKBUTTON: Literal["checkbutton"]
-COMMAND: Literal["command"]
-RADIOBUTTON: Literal["radiobutton"]
-SEPARATOR: Literal["separator"]
-SINGLE: Literal["single"]
-BROWSE: Literal["browse"]
-MULTIPLE: Literal["multiple"]
-EXTENDED: Literal["extended"]
-DOTBOX: Literal["dotbox"]
-UNDERLINE: Literal["underline"]
-PIESLICE: Literal["pieslice"]
-CHORD: Literal["chord"]
-ARC: Literal["arc"]
-FIRST: Literal["first"]
-LAST: Literal["last"]
-BUTT: Literal["butt"]
-PROJECTING: Literal["projecting"]
-ROUND: Literal["round"]
-BEVEL: Literal["bevel"]
-MITER: Literal["miter"]
-MOVETO: Literal["moveto"]
-SCROLL: Literal["scroll"]
-UNITS: Literal["units"]
-PAGES: Literal["pages"]
+NO: Final[bool]
+YES: Final[bool]
+TRUE: Final[bool]
+FALSE: Final[bool]
+ON: Final[bool]
+OFF: Final[bool]
+N: Final = "n"
+S: Final = "s"
+W: Final = "w"
+E: Final = "e"
+NW: Final = "nw"
+SW: Final = "sw"
+NE: Final = "ne"
+SE: Final = "se"
+NS: Final = "ns"
+EW: Final = "ew"
+NSEW: Final = "nsew"
+CENTER: Final = "center"
+NONE: Final = "none"
+X: Final = "x"
+Y: Final = "y"
+BOTH: Final = "both"
+LEFT: Final = "left"
+TOP: Final = "top"
+RIGHT: Final = "right"
+BOTTOM: Final = "bottom"
+RAISED: Final = "raised"
+SUNKEN: Final = "sunken"
+FLAT: Final = "flat"
+RIDGE: Final = "ridge"
+GROOVE: Final = "groove"
+SOLID: Final = "solid"
+HORIZONTAL: Final = "horizontal"
+VERTICAL: Final = "vertical"
+NUMERIC: Final = "numeric"
+CHAR: Final = "char"
+WORD: Final = "word"
+BASELINE: Final = "baseline"
+INSIDE: Final = "inside"
+OUTSIDE: Final = "outside"
+SEL: Final = "sel"
+SEL_FIRST: Final = "sel.first"
+SEL_LAST: Final = "sel.last"
+END: Final = "end"
+INSERT: Final = "insert"
+CURRENT: Final = "current"
+ANCHOR: Final = "anchor"
+ALL: Final = "all"
+NORMAL: Final = "normal"
+DISABLED: Final = "disabled"
+ACTIVE: Final = "active"
+HIDDEN: Final = "hidden"
+CASCADE: Final = "cascade"
+CHECKBUTTON: Final = "checkbutton"
+COMMAND: Final = "command"
+RADIOBUTTON: Final = "radiobutton"
+SEPARATOR: Final = "separator"
+SINGLE: Final = "single"
+BROWSE: Final = "browse"
+MULTIPLE: Final = "multiple"
+EXTENDED: Final = "extended"
+DOTBOX: Final = "dotbox"
+UNDERLINE: Final = "underline"
+PIESLICE: Final = "pieslice"
+CHORD: Final = "chord"
+ARC: Final = "arc"
+FIRST: Final = "first"
+LAST: Final = "last"
+BUTT: Final = "butt"
+PROJECTING: Final = "projecting"
+ROUND: Final = "round"
+BEVEL: Final = "bevel"
+MITER: Final = "miter"
+MOVETO: Final = "moveto"
+SCROLL: Final = "scroll"
+UNITS: Final = "units"
+PAGES: Final = "pages"
diff --git a/mypy/typeshed/stdlib/tkinter/dialog.pyi b/mypy/typeshed/stdlib/tkinter/dialog.pyi
index 7bc77ac6d8b5..b7d74c0fa71e 100644
--- a/mypy/typeshed/stdlib/tkinter/dialog.pyi
+++ b/mypy/typeshed/stdlib/tkinter/dialog.pyi
@@ -2,15 +2,15 @@ import sys
 from _typeshed import Incomplete
 from collections.abc import Mapping
 from tkinter import Widget
-from typing import Any
+from typing import Any, Final
 
 if sys.version_info >= (3, 9):
     __all__ = ["Dialog"]
 
-DIALOG_ICON: str
+DIALOG_ICON: Final = "questhead"
 
 class Dialog(Widget):
     widgetName: str
     num: int
-    def __init__(self, master: Incomplete | None = None, cnf: Mapping[str, Any] = {}, **kw: Incomplete) -> None: ...
+    def __init__(self, master: Incomplete | None = None, cnf: Mapping[str, Any] = {}, **kw) -> None: ...
     def destroy(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/tkinter/dnd.pyi b/mypy/typeshed/stdlib/tkinter/dnd.pyi
index 4a6ab42b3e33..d806be74068e 100644
--- a/mypy/typeshed/stdlib/tkinter/dnd.pyi
+++ b/mypy/typeshed/stdlib/tkinter/dnd.pyi
@@ -6,7 +6,7 @@ if sys.version_info >= (3, 9):
     __all__ = ["dnd_start", "DndHandler"]
 
 class _DndSource(Protocol):
-    def dnd_end(self, target: Widget | None, event: Event[Misc] | None) -> None: ...
+    def dnd_end(self, target: Widget | None, event: Event[Misc] | None, /) -> None: ...
 
 class DndHandler:
     root: ClassVar[Tk | None]
@@ -15,5 +15,6 @@ class DndHandler:
     def finish(self, event: Event[Misc] | None, commit: int = 0) -> None: ...
     def on_motion(self, event: Event[Misc]) -> None: ...
     def on_release(self, event: Event[Misc]) -> None: ...
+    def __del__(self) -> None: ...
 
 def dnd_start(source: _DndSource, event: Event[Misc]) -> DndHandler | None: ...
diff --git a/mypy/typeshed/stdlib/tkinter/filedialog.pyi b/mypy/typeshed/stdlib/tkinter/filedialog.pyi
index 10b36e4d3c06..03f89cfbe3e6 100644
--- a/mypy/typeshed/stdlib/tkinter/filedialog.pyi
+++ b/mypy/typeshed/stdlib/tkinter/filedialog.pyi
@@ -2,8 +2,7 @@ import sys
 from _typeshed import Incomplete, StrOrBytesPath
 from collections.abc import Iterable
 from tkinter import Button, Entry, Frame, Listbox, Misc, Scrollbar, StringVar, Toplevel, commondialog
-from typing import IO, ClassVar
-from typing_extensions import Literal
+from typing import IO, ClassVar, Literal
 
 if sys.version_info >= (3, 9):
     __all__ = [
@@ -81,8 +80,8 @@ class Directory(commondialog.Dialog):
 # TODO: command kwarg available on macos
 def asksaveasfilename(
     *,
-    confirmoverwrite: bool | None = ...,
-    defaultextension: str | None = ...,
+    confirmoverwrite: bool | None = True,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -92,7 +91,7 @@ def asksaveasfilename(
 ) -> str: ...  # can be empty string
 def askopenfilename(
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -102,7 +101,7 @@ def askopenfilename(
 ) -> str: ...  # can be empty string
 def askopenfilenames(
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -111,15 +110,15 @@ def askopenfilenames(
     typevariable: StringVar | str | None = ...,
 ) -> Literal[""] | tuple[str, ...]: ...
 def askdirectory(
-    *, initialdir: StrOrBytesPath | None = ..., mustexist: bool | None = ..., parent: Misc | None = ..., title: str | None = ...
+    *, initialdir: StrOrBytesPath | None = ..., mustexist: bool | None = False, parent: Misc | None = ..., title: str | None = ...
 ) -> str: ...  # can be empty string
 
 # TODO: If someone actually uses these, overload to have the actual return type of open(..., mode)
 def asksaveasfile(
     mode: str = "w",
     *,
-    confirmoverwrite: bool | None = ...,
-    defaultextension: str | None = ...,
+    confirmoverwrite: bool | None = True,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -130,7 +129,7 @@ def asksaveasfile(
 def askopenfile(
     mode: str = "r",
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
@@ -141,7 +140,7 @@ def askopenfile(
 def askopenfiles(
     mode: str = "r",
     *,
-    defaultextension: str | None = ...,
+    defaultextension: str | None = "",
     filetypes: Iterable[tuple[str, str | list[str] | tuple[str, ...]]] | None = ...,
     initialdir: StrOrBytesPath | None = ...,
     initialfile: StrOrBytesPath | None = ...,
diff --git a/mypy/typeshed/stdlib/tkinter/font.pyi b/mypy/typeshed/stdlib/tkinter/font.pyi
index 0a557e921914..3b73f982c4ca 100644
--- a/mypy/typeshed/stdlib/tkinter/font.pyi
+++ b/mypy/typeshed/stdlib/tkinter/font.pyi
@@ -1,22 +1,26 @@
 import _tkinter
+import itertools
 import sys
 import tkinter
-from typing import Any, overload
-from typing_extensions import Literal, TypeAlias, TypedDict
+from typing import Any, ClassVar, Final, Literal, TypedDict, overload
+from typing_extensions import TypeAlias, Unpack
 
 if sys.version_info >= (3, 9):
     __all__ = ["NORMAL", "ROMAN", "BOLD", "ITALIC", "nametofont", "Font", "families", "names"]
 
-NORMAL: Literal["normal"]
-ROMAN: Literal["roman"]
-BOLD: Literal["bold"]
-ITALIC: Literal["italic"]
+NORMAL: Final = "normal"
+ROMAN: Final = "roman"
+BOLD: Final = "bold"
+ITALIC: Final = "italic"
 
 _FontDescription: TypeAlias = (
     str  # "Helvetica 12"
     | Font  # A font object constructed in Python
-    | list[Any]  # ("Helvetica", 12, BOLD)
-    | tuple[Any, ...]
+    | list[Any]  # ["Helvetica", 12, BOLD]
+    | tuple[str]  # ("Liberation Sans",) needs wrapping in tuple/list to handle spaces
+    # ("Liberation Sans", 12) or ("Liberation Sans", 12, "bold", "italic", "underline")
+    | tuple[str, int, Unpack[tuple[str, ...]]]  # Any number of trailing options is permitted
+    | tuple[str, int, list[str] | tuple[str, ...]]  # Options can also be passed as list/tuple
     | _tkinter.Tcl_Obj  # A font object constructed in Tcl
 )
 
@@ -37,6 +41,7 @@ class _MetricsDict(TypedDict):
 class Font:
     name: str
     delete_font: bool
+    counter: ClassVar[itertools.count[int]]  # undocumented
     def __init__(
         self,
         # In tkinter, 'root' refers to tkinter.Tk by convention, but the code
@@ -53,6 +58,7 @@ class Font:
         underline: bool = ...,
         overstrike: bool = ...,
     ) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __setitem__(self, key: str, value: Any) -> None: ...
     @overload
     def cget(self, option: Literal["family"]) -> str: ...
@@ -94,13 +100,14 @@ class Font:
     configure = config
     def copy(self) -> Font: ...
     @overload
-    def metrics(self, __option: Literal["ascent", "descent", "linespace"], *, displayof: tkinter.Misc | None = ...) -> int: ...
+    def metrics(self, option: Literal["ascent", "descent", "linespace"], /, *, displayof: tkinter.Misc | None = ...) -> int: ...
     @overload
-    def metrics(self, __option: Literal["fixed"], *, displayof: tkinter.Misc | None = ...) -> bool: ...
+    def metrics(self, option: Literal["fixed"], /, *, displayof: tkinter.Misc | None = ...) -> bool: ...
     @overload
     def metrics(self, *, displayof: tkinter.Misc | None = ...) -> _MetricsDict: ...
     def measure(self, text: str, displayof: tkinter.Misc | None = None) -> int: ...
     def __eq__(self, other: object) -> bool: ...
+    def __del__(self) -> None: ...
 
 def families(root: tkinter.Misc | None = None, displayof: tkinter.Misc | None = None) -> tuple[str, ...]: ...
 def names(root: tkinter.Misc | None = None) -> tuple[str, ...]: ...
diff --git a/mypy/typeshed/stdlib/tkinter/messagebox.pyi b/mypy/typeshed/stdlib/tkinter/messagebox.pyi
index 5a04b66d7866..5cdfe512f9b7 100644
--- a/mypy/typeshed/stdlib/tkinter/messagebox.pyi
+++ b/mypy/typeshed/stdlib/tkinter/messagebox.pyi
@@ -1,6 +1,6 @@
 import sys
 from tkinter.commondialog import Dialog
-from typing import ClassVar
+from typing import ClassVar, Final
 
 if sys.version_info >= (3, 9):
     __all__ = [
@@ -14,22 +14,22 @@ if sys.version_info >= (3, 9):
         "askretrycancel",
     ]
 
-ERROR: str
-INFO: str
-QUESTION: str
-WARNING: str
-ABORTRETRYIGNORE: str
-OK: str
-OKCANCEL: str
-RETRYCANCEL: str
-YESNO: str
-YESNOCANCEL: str
-ABORT: str
-RETRY: str
-IGNORE: str
-CANCEL: str
-YES: str
-NO: str
+ERROR: Final = "error"
+INFO: Final = "info"
+QUESTION: Final = "question"
+WARNING: Final = "warning"
+ABORTRETRYIGNORE: Final = "abortretryignore"
+OK: Final = "ok"
+OKCANCEL: Final = "okcancel"
+RETRYCANCEL: Final = "retrycancel"
+YESNO: Final = "yesno"
+YESNOCANCEL: Final = "yesnocancel"
+ABORT: Final = "abort"
+RETRY: Final = "retry"
+IGNORE: Final = "ignore"
+CANCEL: Final = "cancel"
+YES: Final = "yes"
+NO: Final = "no"
 
 class Message(Dialog):
     command: ClassVar[str]
diff --git a/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi b/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi
index 114f8c3de3ea..6f1abc714487 100644
--- a/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi
+++ b/mypy/typeshed/stdlib/tkinter/scrolledtext.pyi
@@ -1,4 +1,3 @@
-from _typeshed import Incomplete
 from tkinter import Frame, Misc, Scrollbar, Text
 
 __all__ = ["ScrolledText"]
@@ -7,4 +6,4 @@ __all__ = ["ScrolledText"]
 class ScrolledText(Text):
     frame: Frame
     vbar: Scrollbar
-    def __init__(self, master: Misc | None = None, **kwargs: Incomplete) -> None: ...
+    def __init__(self, master: Misc | None = None, **kwargs) -> None: ...
diff --git a/mypy/typeshed/stdlib/tkinter/tix.pyi b/mypy/typeshed/stdlib/tkinter/tix.pyi
index 672c5ab67403..7891364fa02c 100644
--- a/mypy/typeshed/stdlib/tkinter/tix.pyi
+++ b/mypy/typeshed/stdlib/tkinter/tix.pyi
@@ -1,39 +1,38 @@
 import tkinter
 from _typeshed import Incomplete
-from typing import Any
-from typing_extensions import Literal
-
-WINDOW: Literal["window"]
-TEXT: Literal["text"]
-STATUS: Literal["status"]
-IMMEDIATE: Literal["immediate"]
-IMAGE: Literal["image"]
-IMAGETEXT: Literal["imagetext"]
-BALLOON: Literal["balloon"]
-AUTO: Literal["auto"]
-ACROSSTOP: Literal["acrosstop"]
-
-ASCII: Literal["ascii"]
-CELL: Literal["cell"]
-COLUMN: Literal["column"]
-DECREASING: Literal["decreasing"]
-INCREASING: Literal["increasing"]
-INTEGER: Literal["integer"]
-MAIN: Literal["main"]
-MAX: Literal["max"]
-REAL: Literal["real"]
-ROW: Literal["row"]
-S_REGION: Literal["s-region"]
-X_REGION: Literal["x-region"]
-Y_REGION: Literal["y-region"]
+from typing import Any, Final
+
+WINDOW: Final = "window"
+TEXT: Final = "text"
+STATUS: Final = "status"
+IMMEDIATE: Final = "immediate"
+IMAGE: Final = "image"
+IMAGETEXT: Final = "imagetext"
+BALLOON: Final = "balloon"
+AUTO: Final = "auto"
+ACROSSTOP: Final = "acrosstop"
+
+ASCII: Final = "ascii"
+CELL: Final = "cell"
+COLUMN: Final = "column"
+DECREASING: Final = "decreasing"
+INCREASING: Final = "increasing"
+INTEGER: Final = "integer"
+MAIN: Final = "main"
+MAX: Final = "max"
+REAL: Final = "real"
+ROW: Final = "row"
+S_REGION: Final = "s-region"
+X_REGION: Final = "x-region"
+Y_REGION: Final = "y-region"
 
 # These should be kept in sync with _tkinter constants, except TCL_ALL_EVENTS which doesn't match ALL_EVENTS
-TCL_DONT_WAIT: Literal[2]
-TCL_WINDOW_EVENTS: Literal[4]
-TCL_FILE_EVENTS: Literal[8]
-TCL_TIMER_EVENTS: Literal[16]
-TCL_IDLE_EVENTS: Literal[32]
-TCL_ALL_EVENTS: Literal[0]
+TCL_DONT_WAIT: Final = 2
+TCL_WINDOW_EVENTS: Final = 4
+TCL_FILE_EVENTS: Final = 8
+TCL_TIMER_EVENTS: Final = 16
+TCL_IDLE_EVENTS: Final = 32
+TCL_ALL_EVENTS: Final = 0
 
 class tixCommand:
     def tix_addbitmapdir(self, directory: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/tkinter/ttk.pyi b/mypy/typeshed/stdlib/tkinter/ttk.pyi
index 009fdf51a440..ab3c010938be 100644
--- a/mypy/typeshed/stdlib/tkinter/ttk.pyi
+++ b/mypy/typeshed/stdlib/tkinter/ttk.pyi
@@ -1,11 +1,10 @@
 import _tkinter
-import sys
 import tkinter
-from _typeshed import Incomplete
+from _typeshed import Incomplete, MaybeNone
 from collections.abc import Callable
 from tkinter.font import _FontDescription
-from typing import Any, overload
-from typing_extensions import Literal, TypeAlias, TypedDict
+from typing import Any, Literal, TypedDict, overload
+from typing_extensions import TypeAlias
 
 __all__ = [
     "Button",
@@ -47,7 +46,7 @@ _Padding: TypeAlias = (
 )
 
 # from ttk_widget (aka ttk::widget) manual page, differs from tkinter._Compound
-_TtkCompound: TypeAlias = Literal["text", "image", tkinter._Compound]
+_TtkCompound: TypeAlias = Literal["", "text", "image", tkinter._Compound]
 
 class Style:
     master: Incomplete
@@ -79,21 +78,21 @@ class Button(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        command: tkinter._ButtonCommand = ...,
-        compound: _TtkCompound = ...,
-        cursor: tkinter._Cursor = ...,
-        default: Literal["normal", "active", "disabled"] = ...,
-        image: tkinter._ImageSpec = ...,
+        class_: str = "",
+        command: tkinter._ButtonCommand = "",
+        compound: _TtkCompound = "",
+        cursor: tkinter._Cursor = "",
+        default: Literal["normal", "active", "disabled"] = "normal",
+        image: tkinter._ImageSpec = "",
         name: str = ...,
         padding=...,  # undocumented
-        state: str = ...,
-        style: str = ...,
+        state: str = "normal",
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
-        text: float | str = ...,
+        text: float | str = "",
         textvariable: tkinter.Variable = ...,
-        underline: int = ...,
-        width: int | Literal[""] = ...,
+        underline: int = -1,
+        width: int | Literal[""] = "",
     ) -> None: ...
     @overload
     def configure(
@@ -124,26 +123,26 @@ class Checkbutton(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        command: tkinter._ButtonCommand = ...,
-        compound: _TtkCompound = ...,
-        cursor: tkinter._Cursor = ...,
-        image: tkinter._ImageSpec = ...,
+        class_: str = "",
+        command: tkinter._ButtonCommand = "",
+        compound: _TtkCompound = "",
+        cursor: tkinter._Cursor = "",
+        image: tkinter._ImageSpec = "",
         name: str = ...,
-        offvalue: Any = ...,
-        onvalue: Any = ...,
+        offvalue: Any = 0,
+        onvalue: Any = 1,
         padding=...,  # undocumented
-        state: str = ...,
-        style: str = ...,
+        state: str = "normal",
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
-        text: float | str = ...,
+        text: float | str = "",
         textvariable: tkinter.Variable = ...,
-        underline: int = ...,
+        underline: int = -1,
         # Seems like variable can be empty string, but actually setting it to
         # empty string segfaults before Tcl 8.6.9. Search for ttk::checkbutton
         # here: https://sourceforge.net/projects/tcl/files/Tcl/8.6.9/tcltk-release-notes-8.6.9.txt/view
         variable: tkinter.Variable = ...,
-        width: int | Literal[""] = ...,
+        width: int | Literal[""] = "",
     ) -> None: ...
     @overload
     def configure(
@@ -178,23 +177,23 @@ class Entry(Widget, tkinter.Entry):
         widget: str | None = None,
         *,
         background: str = ...,  # undocumented
-        class_: str = ...,
+        class_: str = "",
         cursor: tkinter._Cursor = ...,
-        exportselection: bool = ...,
-        font: _FontDescription = ...,
-        foreground: str = ...,
-        invalidcommand: tkinter._EntryValidateCommand = ...,
-        justify: Literal["left", "center", "right"] = ...,
+        exportselection: bool = True,
+        font: _FontDescription = "TkTextFont",
+        foreground: str = "",
+        invalidcommand: tkinter._EntryValidateCommand = "",
+        justify: Literal["left", "center", "right"] = "left",
         name: str = ...,
-        show: str = ...,
-        state: str = ...,
-        style: str = ...,
+        show: str = "",
+        state: str = "normal",
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
         textvariable: tkinter.Variable = ...,
-        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
-        validatecommand: tkinter._EntryValidateCommand = ...,
-        width: int = ...,
-        xscrollcommand: tkinter._XYScrollCommand = ...,
+        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = "none",
+        validatecommand: tkinter._EntryValidateCommand = "",
+        width: int = 20,
+        xscrollcommand: tkinter._XYScrollCommand = "",
     ) -> None: ...
     @overload  # type: ignore[override]
     def configure(
@@ -255,25 +254,25 @@ class Combobox(Entry):
         master: tkinter.Misc | None = None,
         *,
         background: str = ...,  # undocumented
-        class_: str = ...,
-        cursor: tkinter._Cursor = ...,
-        exportselection: bool = ...,
+        class_: str = "",
+        cursor: tkinter._Cursor = "",
+        exportselection: bool = True,
         font: _FontDescription = ...,  # undocumented
         foreground: str = ...,  # undocumented
-        height: int = ...,
+        height: int = 10,
         invalidcommand: tkinter._EntryValidateCommand = ...,  # undocumented
-        justify: Literal["left", "center", "right"] = ...,
+        justify: Literal["left", "center", "right"] = "left",
         name: str = ...,
-        postcommand: Callable[[], object] | str = ...,
+        postcommand: Callable[[], object] | str = "",
         show=...,  # undocumented
-        state: str = ...,
-        style: str = ...,
+        state: str = "normal",
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
         textvariable: tkinter.Variable = ...,
         validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,  # undocumented
         validatecommand: tkinter._EntryValidateCommand = ...,  # undocumented
         values: list[str] | tuple[str, ...] = ...,
-        width: int = ...,
+        width: int = 20,
         xscrollcommand: tkinter._XYScrollCommand = ...,  # undocumented
     ) -> None: ...
     @overload  # type: ignore[override]
@@ -335,21 +334,23 @@ class Combobox(Entry):
     def set(self, value: Any) -> None: ...
 
 class Frame(Widget):
+    # This should be kept in sync with tkinter.ttk.LabeledScale.__init__()
+    # (all of these keyword-only arguments are also present there)
     def __init__(
         self,
         master: tkinter.Misc | None = None,
         *,
         border: tkinter._ScreenUnits = ...,
         borderwidth: tkinter._ScreenUnits = ...,
-        class_: str = ...,
-        cursor: tkinter._Cursor = ...,
-        height: tkinter._ScreenUnits = ...,
+        class_: str = "",
+        cursor: tkinter._Cursor = "",
+        height: tkinter._ScreenUnits = 0,
         name: str = ...,
         padding: _Padding = ...,
         relief: tkinter._Relief = ...,
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
-        width: tkinter._ScreenUnits = ...,
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
+        width: tkinter._ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -376,26 +377,26 @@ class Label(Widget):
         master: tkinter.Misc | None = None,
         *,
         anchor: tkinter._Anchor = ...,
-        background: str = ...,
+        background: str = "",
         border: tkinter._ScreenUnits = ...,  # alias for borderwidth
         borderwidth: tkinter._ScreenUnits = ...,  # undocumented
-        class_: str = ...,
-        compound: _TtkCompound = ...,
-        cursor: tkinter._Cursor = ...,
+        class_: str = "",
+        compound: _TtkCompound = "",
+        cursor: tkinter._Cursor = "",
         font: _FontDescription = ...,
-        foreground: str = ...,
-        image: tkinter._ImageSpec = ...,
+        foreground: str = "",
+        image: tkinter._ImageSpec = "",
         justify: Literal["left", "center", "right"] = ...,
         name: str = ...,
         padding: _Padding = ...,
         relief: tkinter._Relief = ...,
-        state: str = ...,
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
-        text: float | str = ...,
+        state: str = "normal",
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
+        text: float | str = "",
         textvariable: tkinter.Variable = ...,
-        underline: int = ...,
-        width: int | Literal[""] = ...,
+        underline: int = -1,
+        width: int | Literal[""] = "",
         wraplength: tkinter._ScreenUnits = ...,
     ) -> None: ...
     @overload
@@ -435,19 +436,19 @@ class Labelframe(Widget):
         *,
         border: tkinter._ScreenUnits = ...,
         borderwidth: tkinter._ScreenUnits = ...,  # undocumented
-        class_: str = ...,
-        cursor: tkinter._Cursor = ...,
-        height: tkinter._ScreenUnits = ...,
+        class_: str = "",
+        cursor: tkinter._Cursor = "",
+        height: tkinter._ScreenUnits = 0,
         labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ...,
         labelwidget: tkinter.Misc = ...,
         name: str = ...,
         padding: _Padding = ...,
         relief: tkinter._Relief = ...,  # undocumented
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
-        text: float | str = ...,
-        underline: int = ...,
-        width: tkinter._ScreenUnits = ...,
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
+        text: float | str = "",
+        underline: int = -1,
+        width: tkinter._ScreenUnits = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -479,21 +480,21 @@ class Menubutton(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        compound: _TtkCompound = ...,
-        cursor: tkinter._Cursor = ...,
-        direction: Literal["above", "below", "left", "right", "flush"] = ...,
-        image: tkinter._ImageSpec = ...,
+        class_: str = "",
+        compound: _TtkCompound = "",
+        cursor: tkinter._Cursor = "",
+        direction: Literal["above", "below", "left", "right", "flush"] = "below",
+        image: tkinter._ImageSpec = "",
         menu: tkinter.Menu = ...,
         name: str = ...,
         padding=...,  # undocumented
-        state: str = ...,
-        style: str = ...,
+        state: str = "normal",
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
-        text: float | str = ...,
+        text: float | str = "",
         textvariable: tkinter.Variable = ...,
-        underline: int = ...,
-        width: int | Literal[""] = ...,
+        underline: int = -1,
+        width: int | Literal[""] = "",
     ) -> None: ...
     @overload
     def configure(
@@ -523,14 +524,14 @@ class Notebook(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        cursor: tkinter._Cursor = ...,
-        height: int = ...,
+        class_: str = "",
+        cursor: tkinter._Cursor = "",
+        height: int = 0,
         name: str = ...,
         padding: _Padding = ...,
-        style: str = ...,
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
-        width: int = ...,
+        width: int = 0,
     ) -> None: ...
     @overload
     def configure(
@@ -555,11 +556,13 @@ class Notebook(Widget):
         sticky: str = ...,  # consists of letters 'n', 's', 'w', 'e', no repeats, may be empty
         padding: _Padding = ...,
         text: str = ...,
-        image=...,  # Sequence of an image name, followed by zero or more (sequences of one or more state names followed by an image name)
+        # `image` is a sequence of an image name, followed by zero or more
+        # (sequences of one or more state names followed by an image name)
+        image=...,
         compound: tkinter._Compound = ...,
         underline: int = ...,
     ) -> None: ...
-    def forget(self, tab_id) -> None: ...
+    def forget(self, tab_id) -> None: ...  # type: ignore[override]
     def hide(self, tab_id) -> None: ...
     def identify(self, x: int, y: int) -> str: ...
     def index(self, tab_id): ...
@@ -574,15 +577,15 @@ class Panedwindow(Widget, tkinter.PanedWindow):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        cursor: tkinter._Cursor = ...,
+        class_: str = "",
+        cursor: tkinter._Cursor = "",
         # width and height for tkinter.ttk.Panedwindow are int but for tkinter.PanedWindow they are screen units
-        height: int = ...,
+        height: int = 0,
         name: str = ...,
-        orient: Literal["vertical", "horizontal"] = ...,  # can't be changed with configure()
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
-        width: int = ...,
+        orient: Literal["vertical", "horizontal"] = "vertical",  # can't be changed with configure()
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
+        width: int = 0,
     ) -> None: ...
     def add(self, child: tkinter.Widget, *, weight: int = ..., **kw) -> None: ...
     @overload  # type: ignore[override]
@@ -624,17 +627,17 @@ class Progressbar(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        cursor: tkinter._Cursor = ...,
-        length: tkinter._ScreenUnits = ...,
-        maximum: float = ...,
-        mode: Literal["determinate", "indeterminate"] = ...,
+        class_: str = "",
+        cursor: tkinter._Cursor = "",
+        length: tkinter._ScreenUnits = 100,
+        maximum: float = 100,
+        mode: Literal["determinate", "indeterminate"] = "determinate",
         name: str = ...,
-        orient: Literal["horizontal", "vertical"] = ...,
-        phase: int = ...,  # docs say read-only but assigning int to this works
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
-        value: float = ...,
+        orient: Literal["horizontal", "vertical"] = "horizontal",
+        phase: int = 0,  # docs say read-only but assigning int to this works
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
+        value: float = 0.0,
         variable: tkinter.IntVar | tkinter.DoubleVar = ...,
     ) -> None: ...
     @overload
@@ -665,22 +668,22 @@ class Radiobutton(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        command: tkinter._ButtonCommand = ...,
-        compound: _TtkCompound = ...,
-        cursor: tkinter._Cursor = ...,
-        image: tkinter._ImageSpec = ...,
+        class_: str = "",
+        command: tkinter._ButtonCommand = "",
+        compound: _TtkCompound = "",
+        cursor: tkinter._Cursor = "",
+        image: tkinter._ImageSpec = "",
         name: str = ...,
         padding=...,  # undocumented
-        state: str = ...,
-        style: str = ...,
+        state: str = "normal",
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
-        text: float | str = ...,
+        text: float | str = "",
         textvariable: tkinter.Variable = ...,
-        underline: int = ...,
-        value: Any = ...,
+        underline: int = -1,
+        value: Any = "1",
         variable: tkinter.Variable | Literal[""] = ...,
-        width: int | Literal[""] = ...,
+        width: int | Literal[""] = "",
     ) -> None: ...
     @overload
     def configure(
@@ -713,18 +716,18 @@ class Scale(Widget, tkinter.Scale):  # type: ignore[misc]
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        command: str | Callable[[str], object] = ...,
-        cursor: tkinter._Cursor = ...,
-        from_: float = ...,
-        length: tkinter._ScreenUnits = ...,
+        class_: str = "",
+        command: str | Callable[[str], object] = "",
+        cursor: tkinter._Cursor = "",
+        from_: float = 0,
+        length: tkinter._ScreenUnits = 100,
         name: str = ...,
-        orient: Literal["horizontal", "vertical"] = ...,
+        orient: Literal["horizontal", "vertical"] = "horizontal",
         state: str = ...,  # undocumented
-        style: str = ...,
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
-        to: float = ...,
-        value: float = ...,
+        to: float = 1.0,
+        value: float = 0,
         variable: tkinter.IntVar | tkinter.DoubleVar = ...,
     ) -> None: ...
     @overload  # type: ignore[override]
@@ -774,13 +777,13 @@ class Scrollbar(Widget, tkinter.Scrollbar):  # type: ignore[misc]
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        command: Callable[..., tuple[float, float] | None] | str = ...,
-        cursor: tkinter._Cursor = ...,
+        class_: str = "",
+        command: Callable[..., tuple[float, float] | None] | str = "",
+        cursor: tkinter._Cursor = "",
         name: str = ...,
-        orient: Literal["horizontal", "vertical"] = ...,
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
+        orient: Literal["horizontal", "vertical"] = "vertical",
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
     ) -> None: ...
     @overload  # type: ignore[override]
     def configure(
@@ -815,12 +818,12 @@ class Separator(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        cursor: tkinter._Cursor = ...,
+        class_: str = "",
+        cursor: tkinter._Cursor = "",
         name: str = ...,
-        orient: Literal["horizontal", "vertical"] = ...,
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
+        orient: Literal["horizontal", "vertical"] = "horizontal",
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
     ) -> None: ...
     @overload
     def configure(
@@ -841,11 +844,11 @@ class Sizegrip(Widget):
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
+        class_: str = "",
         cursor: tkinter._Cursor = ...,
         name: str = ...,
-        style: str = ...,
-        takefocus: tkinter._TakeFocusValue = ...,
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
     ) -> None: ...
     @overload
     def configure(
@@ -866,30 +869,30 @@ class Spinbox(Entry):
         master: tkinter.Misc | None = None,
         *,
         background: str = ...,  # undocumented
-        class_: str = ...,
-        command: Callable[[], object] | str | list[str] | tuple[str, ...] = ...,
-        cursor: tkinter._Cursor = ...,
+        class_: str = "",
+        command: Callable[[], object] | str | list[str] | tuple[str, ...] = "",
+        cursor: tkinter._Cursor = "",
         exportselection: bool = ...,  # undocumented
         font: _FontDescription = ...,  # undocumented
         foreground: str = ...,  # undocumented
-        format: str = ...,
-        from_: float = ...,
-        increment: float = ...,
+        format: str = "",
+        from_: float = 0,
+        increment: float = 1,
         invalidcommand: tkinter._EntryValidateCommand = ...,  # undocumented
         justify: Literal["left", "center", "right"] = ...,  # undocumented
         name: str = ...,
         show=...,  # undocumented
-        state: str = ...,
-        style: str = ...,
+        state: str = "normal",
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
         textvariable: tkinter.Variable = ...,  # undocumented
-        to: float = ...,
-        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ...,
-        validatecommand: tkinter._EntryValidateCommand = ...,
+        to: float = 0,
+        validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = "none",
+        validatecommand: tkinter._EntryValidateCommand = "",
         values: list[str] | tuple[str, ...] = ...,
         width: int = ...,  # undocumented
-        wrap: bool = ...,
-        xscrollcommand: tkinter._XYScrollCommand = ...,
+        wrap: bool = False,
+        xscrollcommand: tkinter._XYScrollCommand = "",
     ) -> None: ...
     @overload  # type: ignore[override]
     def configure(
@@ -953,39 +956,37 @@ class _TreeviewColumnDict(TypedDict):
     anchor: tkinter._Anchor
     id: str
 
-_TreeviewColumnId: TypeAlias = int | str  # manual page: "COLUMN IDENTIFIERS"
-
 class Treeview(Widget, tkinter.XView, tkinter.YView):
     def __init__(
         self,
         master: tkinter.Misc | None = None,
         *,
-        class_: str = ...,
-        columns: str | list[str] | tuple[str, ...] = ...,
-        cursor: tkinter._Cursor = ...,
-        displaycolumns: str | list[str] | tuple[str, ...] | list[int] | tuple[int, ...] = ...,
-        height: int = ...,
+        class_: str = "",
+        columns: str | list[str] | list[int] | list[str | int] | tuple[str | int, ...] = "",
+        cursor: tkinter._Cursor = "",
+        displaycolumns: str | int | list[str] | tuple[str, ...] | list[int] | tuple[int, ...] = ("#all",),
+        height: int = 10,
         name: str = ...,
         padding: _Padding = ...,
-        selectmode: Literal["extended", "browse", "none"] = ...,
+        selectmode: Literal["extended", "browse", "none"] = "extended",
         # list/tuple of Literal don't actually work in mypy
         #
         # 'tree headings' is same as ['tree', 'headings'], and I wouldn't be
         # surprised if someone is using it.
-        show: Literal["tree", "headings", "tree headings", ""] | list[str] | tuple[str, ...] = ...,
-        style: str = ...,
+        show: Literal["tree", "headings", "tree headings", ""] | list[str] | tuple[str, ...] = ("tree", "headings"),
+        style: str = "",
         takefocus: tkinter._TakeFocusValue = ...,
-        xscrollcommand: tkinter._XYScrollCommand = ...,
-        yscrollcommand: tkinter._XYScrollCommand = ...,
+        xscrollcommand: tkinter._XYScrollCommand = "",
+        yscrollcommand: tkinter._XYScrollCommand = "",
     ) -> None: ...
     @overload
     def configure(
         self,
         cnf: dict[str, Any] | None = None,
         *,
-        columns: str | list[str] | tuple[str, ...] = ...,
+        columns: str | list[str] | list[int] | list[str | int] | tuple[str | int, ...] = ...,
         cursor: tkinter._Cursor = ...,
-        displaycolumns: str | list[str] | tuple[str, ...] | list[int] | tuple[int, ...] = ...,
+        displaycolumns: str | int | list[str] | tuple[str, ...] | list[int] | tuple[int, ...] = ...,
         height: int = ...,
         padding: _Padding = ...,
         selectmode: Literal["extended", "browse", "none"] = ...,
@@ -998,23 +999,23 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
     @overload
     def configure(self, cnf: str) -> tuple[str, str, str, Any, Any]: ...
     config = configure
-    def bbox(self, item, column: _TreeviewColumnId | None = None) -> tuple[int, int, int, int] | Literal[""]: ...  # type: ignore[override]
-    def get_children(self, item: str | None = None) -> tuple[str, ...]: ...
-    def set_children(self, item: str, *newchildren: str) -> None: ...
+    def bbox(self, item: str | int, column: str | int | None = None) -> tuple[int, int, int, int] | Literal[""]: ...  # type: ignore[override]
+    def get_children(self, item: str | int | None = None) -> tuple[str, ...]: ...
+    def set_children(self, item: str | int, *newchildren: str | int) -> None: ...
     @overload
-    def column(self, column: _TreeviewColumnId, option: Literal["width", "minwidth"]) -> int: ...
+    def column(self, column: str | int, option: Literal["width", "minwidth"]) -> int: ...
     @overload
-    def column(self, column: _TreeviewColumnId, option: Literal["stretch"]) -> bool: ...  # actually 0 or 1
+    def column(self, column: str | int, option: Literal["stretch"]) -> bool: ...  # actually 0 or 1
     @overload
-    def column(self, column: _TreeviewColumnId, option: Literal["anchor"]) -> _tkinter.Tcl_Obj: ...
+    def column(self, column: str | int, option: Literal["anchor"]) -> _tkinter.Tcl_Obj: ...
     @overload
-    def column(self, column: _TreeviewColumnId, option: Literal["id"]) -> str: ...
+    def column(self, column: str | int, option: Literal["id"]) -> str: ...
     @overload
-    def column(self, column: _TreeviewColumnId, option: str) -> Any: ...
+    def column(self, column: str | int, option: str) -> Any: ...
     @overload
     def column(
         self,
-        column: _TreeviewColumnId,
+        column: str | int,
         option: None = None,
         *,
         width: int = ...,
@@ -1023,29 +1024,29 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
         anchor: tkinter._Anchor = ...,
         # id is read-only
     ) -> _TreeviewColumnDict | None: ...
-    def delete(self, *items: str) -> None: ...
-    def detach(self, *items: str) -> None: ...
-    def exists(self, item: str) -> bool: ...
+    def delete(self, *items: str | int) -> None: ...
+    def detach(self, *items: str | int) -> None: ...
+    def exists(self, item: str | int) -> bool: ...
     @overload  # type: ignore[override]
     def focus(self, item: None = None) -> str: ...  # can return empty string
     @overload
-    def focus(self, item: str) -> Literal[""]: ...
+    def focus(self, item: str | int) -> Literal[""]: ...
     @overload
-    def heading(self, column: _TreeviewColumnId, option: Literal["text"]) -> str: ...
+    def heading(self, column: str | int, option: Literal["text"]) -> str: ...
     @overload
-    def heading(self, column: _TreeviewColumnId, option: Literal["image"]) -> tuple[str] | str: ...
+    def heading(self, column: str | int, option: Literal["image"]) -> tuple[str] | str: ...
     @overload
-    def heading(self, column: _TreeviewColumnId, option: Literal["anchor"]) -> _tkinter.Tcl_Obj: ...
+    def heading(self, column: str | int, option: Literal["anchor"]) -> _tkinter.Tcl_Obj: ...
     @overload
-    def heading(self, column: _TreeviewColumnId, option: Literal["command"]) -> str: ...
+    def heading(self, column: str | int, option: Literal["command"]) -> str: ...
     @overload
-    def heading(self, column: _TreeviewColumnId, option: str) -> Any: ...
+    def heading(self, column: str | int, option: str) -> Any: ...
     @overload
-    def heading(self, column: _TreeviewColumnId, option: None = None) -> _TreeviewHeaderDict: ...  # type: ignore[misc]
+    def heading(self, column: str | int, option: None = None) -> _TreeviewHeaderDict: ...
     @overload
     def heading(
         self,
-        column: _TreeviewColumnId,
+        column: str | int,
         option: None = None,
         *,
         text: str = ...,
@@ -1053,19 +1054,20 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
         anchor: tkinter._Anchor = ...,
         command: str | Callable[[], object] = ...,
     ) -> None: ...
-    def identify(self, component, x, y): ...  # Internal Method. Leave untyped
+    # Internal Method. Leave untyped:
+    def identify(self, component, x, y): ...  # type: ignore[override]
     def identify_row(self, y: int) -> str: ...
     def identify_column(self, x: int) -> str: ...
     def identify_region(self, x: int, y: int) -> Literal["heading", "separator", "tree", "cell", "nothing"]: ...
     def identify_element(self, x: int, y: int) -> str: ...  # don't know what possible return values are
-    def index(self, item: str) -> int: ...
+    def index(self, item: str | int) -> int: ...
     def insert(
         self,
         parent: str,
         index: int | Literal["end"],
-        iid: str | None = None,
+        iid: str | int | None = None,
         *,
-        id: str = ...,  # same as iid
+        id: str | int = ...,  # same as iid
         text: str = ...,
         image: tkinter._ImageSpec = ...,
         values: list[Any] | tuple[Any, ...] = ...,
@@ -1073,23 +1075,23 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
         tags: str | list[str] | tuple[str, ...] = ...,
     ) -> str: ...
     @overload
-    def item(self, item: str, option: Literal["text"]) -> str: ...
+    def item(self, item: str | int, option: Literal["text"]) -> str: ...
     @overload
-    def item(self, item: str, option: Literal["image"]) -> tuple[str] | Literal[""]: ...
+    def item(self, item: str | int, option: Literal["image"]) -> tuple[str] | Literal[""]: ...
     @overload
-    def item(self, item: str, option: Literal["values"]) -> tuple[Any, ...] | Literal[""]: ...
+    def item(self, item: str | int, option: Literal["values"]) -> tuple[Any, ...] | Literal[""]: ...
     @overload
-    def item(self, item: str, option: Literal["open"]) -> bool: ...  # actually 0 or 1
+    def item(self, item: str | int, option: Literal["open"]) -> bool: ...  # actually 0 or 1
     @overload
-    def item(self, item: str, option: Literal["tags"]) -> tuple[str, ...] | Literal[""]: ...
+    def item(self, item: str | int, option: Literal["tags"]) -> tuple[str, ...] | Literal[""]: ...
     @overload
-    def item(self, item: str, option: str) -> Any: ...
+    def item(self, item: str | int, option: str) -> Any: ...
     @overload
-    def item(self, item: str, option: None = None) -> _TreeviewItemDict: ...  # type: ignore[misc]
+    def item(self, item: str | int, option: None = None) -> _TreeviewItemDict: ...
     @overload
     def item(
         self,
-        item: str,
+        item: str | int,
         option: None = None,
         *,
         text: str = ...,
@@ -1098,27 +1100,35 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
         open: bool = ...,
         tags: str | list[str] | tuple[str, ...] = ...,
     ) -> None: ...
-    def move(self, item: str, parent: str, index: int) -> None: ...
+    def move(self, item: str | int, parent: str, index: int | Literal["end"]) -> None: ...
     reattach = move
-    def next(self, item: str) -> str: ...  # returning empty string means last item
-    def parent(self, item: str) -> str: ...
-    def prev(self, item: str) -> str: ...  # returning empty string means first item
-    def see(self, item: str) -> None: ...
-    if sys.version_info >= (3, 8):
-        def selection(self) -> tuple[str, ...]: ...
-    else:
-        def selection(self, selop: Incomplete | None = ..., items: Incomplete | None = None) -> tuple[str, ...]: ...
-
-    def selection_set(self, items: str | list[str] | tuple[str, ...]) -> None: ...
-    def selection_add(self, items: str | list[str] | tuple[str, ...]) -> None: ...
-    def selection_remove(self, items: str | list[str] | tuple[str, ...]) -> None: ...
-    def selection_toggle(self, items: str | list[str] | tuple[str, ...]) -> None: ...
+    def next(self, item: str | int) -> str: ...  # returning empty string means last item
+    def parent(self, item: str | int) -> str: ...
+    def prev(self, item: str | int) -> str: ...  # returning empty string means first item
+    def see(self, item: str | int) -> None: ...
+    def selection(self) -> tuple[str, ...]: ...
+    @overload
+    def selection_set(self, items: list[str] | tuple[str, ...] | list[int] | tuple[int, ...], /) -> None: ...
+    @overload
+    def selection_set(self, *items: str | int) -> None: ...
+    @overload
+    def selection_add(self, items: list[str] | tuple[str, ...] | list[int] | tuple[int, ...], /) -> None: ...
+    @overload
+    def selection_add(self, *items: str | int) -> None: ...
+    @overload
+    def selection_remove(self, items: list[str] | tuple[str, ...] | list[int] | tuple[int, ...], /) -> None: ...
+    @overload
+    def selection_remove(self, *items: str | int) -> None: ...
     @overload
-    def set(self, item: str, column: None = None, value: None = None) -> dict[str, Any]: ...
+    def selection_toggle(self, items: list[str] | tuple[str, ...] | list[int] | tuple[int, ...], /) -> None: ...
     @overload
-    def set(self, item: str, column: _TreeviewColumnId, value: None = None) -> Any: ...
+    def selection_toggle(self, *items: str | int) -> None: ...
     @overload
-    def set(self, item: str, column: _TreeviewColumnId, value: Any) -> Literal[""]: ...
+    def set(self, item: str | int, column: None = None, value: None = None) -> dict[str, Any]: ...
+    @overload
+    def set(self, item: str | int, column: str | int, value: None = None) -> Any: ...
+    @overload
+    def set(self, item: str | int, column: str | int, value: Any) -> Literal[""]: ...
     # There's no tag_unbind() or 'add' argument for whatever reason.
     # Also, it's 'callback' instead of 'func' here.
     @overload
@@ -1146,16 +1156,17 @@ class Treeview(Widget, tkinter.XView, tkinter.YView):
         background: str = ...,
         font: _FontDescription = ...,
         image: tkinter._ImageSpec = ...,
-    ) -> _TreeviewTagDict | Any: ...  # can be None but annoying to check
+    ) -> _TreeviewTagDict | MaybeNone: ...  # can be None but annoying to check
     @overload
     def tag_has(self, tagname: str, item: None = None) -> tuple[str, ...]: ...
     @overload
-    def tag_has(self, tagname: str, item: str) -> bool: ...
+    def tag_has(self, tagname: str, item: str | int) -> bool: ...
 
 class LabeledScale(Frame):
-    label: Incomplete
-    scale: Incomplete
-    # TODO: don't any-type **kw. That goes to Frame.__init__.
+    label: Label
+    scale: Scale
+    # This should be kept in sync with tkinter.ttk.Frame.__init__()
+    # (all the keyword-only args except compound are from there)
     def __init__(
         self,
         master: tkinter.Misc | None = None,
@@ -1163,8 +1174,18 @@ class LabeledScale(Frame):
         from_: float = 0,
         to: float = 10,
         *,
-        compound: Literal["top", "bottom"] = ...,
-        **kw,
+        border: tkinter._ScreenUnits = ...,
+        borderwidth: tkinter._ScreenUnits = ...,
+        class_: str = "",
+        compound: Literal["top", "bottom"] = "top",
+        cursor: tkinter._Cursor = "",
+        height: tkinter._ScreenUnits = 0,
+        name: str = ...,
+        padding: _Padding = ...,
+        relief: tkinter._Relief = ...,
+        style: str = "",
+        takefocus: tkinter._TakeFocusValue = "",
+        width: tkinter._ScreenUnits = 0,
     ) -> None: ...
     # destroy is overridden, signature does not change
     value: Any
@@ -1172,15 +1193,15 @@ class LabeledScale(Frame):
 class OptionMenu(Menubutton):
     def __init__(
         self,
-        master,
-        variable,
+        master: tkinter.Misc | None,
+        variable: tkinter.StringVar,
         default: str | None = None,
         *values: str,
         # rest of these are keyword-only because *args syntax used above
-        style: str = ...,
-        direction: Literal["above", "below", "left", "right", "flush"] = ...,
-        command: Callable[[tkinter.StringVar], object] | None = ...,
+        style: str = "",
+        direction: Literal["above", "below", "left", "right", "flush"] = "below",
+        command: Callable[[tkinter.StringVar], object] | None = None,
     ) -> None: ...
     # configure, config, cget, destroy are inherited from Menubutton
     # destroy and __setitem__ are overridden, signature does not change
-    def set_menu(self, default: Incomplete | None = None, *values) -> None: ...
+    def set_menu(self, default: str | None = None, *values: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/token.pyi b/mypy/typeshed/stdlib/token.pyi
index fcd6ef87d217..741ce5b035b7 100644
--- a/mypy/typeshed/stdlib/token.pyi
+++ b/mypy/typeshed/stdlib/token.pyi
@@ -8,6 +8,7 @@ __all__ = [
     "CIRCUMFLEX",
     "CIRCUMFLEXEQUAL",
     "COLON",
+    "COLONEQUAL",
     "COMMA",
     "DEDENT",
     "DOT",
@@ -59,6 +60,8 @@ __all__ = [
     "STAREQUAL",
     "STRING",
     "TILDE",
+    "TYPE_COMMENT",
+    "TYPE_IGNORE",
     "VBAR",
     "VBAREQUAL",
     "tok_name",
@@ -66,13 +69,15 @@ __all__ = [
     "NL",
     "COMMENT",
 ]
-
-if sys.version_info >= (3, 8):
-    __all__ += ["ASYNC", "AWAIT", "COLONEQUAL", "TYPE_COMMENT", "TYPE_IGNORE"]
+if sys.version_info < (3, 13):
+    __all__ += ["ASYNC", "AWAIT"]
 
 if sys.version_info >= (3, 10):
     __all__ += ["SOFT_KEYWORD"]
 
+if sys.version_info >= (3, 12):
+    __all__ += ["EXCLAMATION", "FSTRING_END", "FSTRING_MIDDLE", "FSTRING_START", "EXACT_TOKEN_TYPES"]
+
 ENDMARKER: int
 NAME: int
 NUMBER: int
@@ -126,7 +131,7 @@ AT: int
 RARROW: int
 ELLIPSIS: int
 ATEQUAL: int
-if sys.version_info >= (3, 8):
+if sys.version_info < (3, 13):
     AWAIT: int
     ASYNC: int
 OP: int
@@ -137,14 +142,19 @@ tok_name: dict[int, str]
 COMMENT: int
 NL: int
 ENCODING: int
-if sys.version_info >= (3, 8):
-    TYPE_COMMENT: int
-    TYPE_IGNORE: int
-    COLONEQUAL: int
-    EXACT_TOKEN_TYPES: dict[str, int]
+TYPE_COMMENT: int
+TYPE_IGNORE: int
+COLONEQUAL: int
+EXACT_TOKEN_TYPES: dict[str, int]
 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 ba57402fb845..a1c4b412da83 100644
--- a/mypy/typeshed/stdlib/tokenize.pyi
+++ b/mypy/typeshed/stdlib/tokenize.pyi
@@ -3,7 +3,8 @@ from _typeshed import FileDescriptorOrPath
 from collections.abc import Callable, Generator, Iterable, Sequence
 from re import Pattern
 from token import *
-from typing import Any, NamedTuple, TextIO
+from token import EXACT_TOKEN_TYPES as EXACT_TOKEN_TYPES
+from typing import Any, NamedTuple, TextIO, type_check_only
 from typing_extensions import TypeAlias
 
 __all__ = [
@@ -14,6 +15,7 @@ __all__ = [
     "CIRCUMFLEX",
     "CIRCUMFLEXEQUAL",
     "COLON",
+    "COLONEQUAL",
     "COMMA",
     "COMMENT",
     "DEDENT",
@@ -68,31 +70,36 @@ __all__ = [
     "STAREQUAL",
     "STRING",
     "TILDE",
+    "TYPE_COMMENT",
+    "TYPE_IGNORE",
     "TokenInfo",
     "VBAR",
     "VBAREQUAL",
     "detect_encoding",
+    "generate_tokens",
     "tok_name",
     "tokenize",
     "untokenize",
 ]
-
-if sys.version_info >= (3, 8):
-    __all__ += ["ASYNC", "AWAIT", "COLONEQUAL", "generate_tokens", "TYPE_COMMENT", "TYPE_IGNORE"]
+if sys.version_info < (3, 13):
+    __all__ += ["ASYNC", "AWAIT"]
 
 if sys.version_info >= (3, 10):
     __all__ += ["SOFT_KEYWORD"]
 
-if sys.version_info >= (3, 8):
-    from token import EXACT_TOKEN_TYPES as EXACT_TOKEN_TYPES
-else:
-    EXACT_TOKEN_TYPES: dict[str, int]
+if sys.version_info >= (3, 12):
+    __all__ += ["EXCLAMATION", "FSTRING_END", "FSTRING_MIDDLE", "FSTRING_START", "EXACT_TOKEN_TYPES"]
+
+if sys.version_info >= (3, 13):
+    __all__ += ["TokenError", "open"]
 
 cookie_re: Pattern[str]
 blank_re: Pattern[bytes]
 
 _Position: TypeAlias = tuple[int, int]
 
+# This class is not exposed. It calls itself tokenize.TokenInfo.
+@type_check_only
 class _TokenInfo(NamedTuple):
     type: int
     string: str
@@ -108,7 +115,9 @@ class TokenInfo(_TokenInfo):
 _Token: TypeAlias = TokenInfo | Sequence[int | str | _Position]
 
 class TokenError(Exception): ...
-class StopTokenizing(Exception): ...  # undocumented
+
+if sys.version_info < (3, 13):
+    class StopTokenizing(Exception): ...  # undocumented
 
 class Untokenizer:
     tokens: list[str]
@@ -116,15 +125,19 @@ class Untokenizer:
     prev_col: int
     encoding: str | None
     def add_whitespace(self, start: _Position) -> None: ...
+    if sys.version_info >= (3, 13):
+        def add_backslash_continuation(self, start: _Position) -> None: ...
+
     def untokenize(self, iterable: Iterable[_Token]) -> str: ...
     def compat(self, token: Sequence[int | str], iterable: Iterable[_Token]) -> None: ...
+    if sys.version_info >= (3, 12):
+        def escape_brackets(self, token: str) -> str: ...
 
-# the docstring says "returns bytes" but is incorrect --
-# if the ENCODING token is missing, it skips the encode
-def untokenize(iterable: Iterable[_Token]) -> Any: ...
+# Returns str, unless the ENCODING token is present, in which case it returns bytes.
+def untokenize(iterable: Iterable[_Token]) -> str | Any: ...
 def detect_encoding(readline: Callable[[], bytes | bytearray]) -> tuple[str, Sequence[bytes]]: ...
 def tokenize(readline: Callable[[], bytes | bytearray]) -> Generator[TokenInfo, None, None]: ...
-def generate_tokens(readline: Callable[[], str]) -> Generator[TokenInfo, None, None]: ...  # undocumented
+def generate_tokens(readline: Callable[[], str]) -> Generator[TokenInfo, None, None]: ...
 def open(filename: FileDescriptorOrPath) -> TextIO: ...
 def group(*choices: str) -> str: ...  # undocumented
 def any(*choices: str) -> str: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/tomllib.pyi b/mypy/typeshed/stdlib/tomllib.pyi
index 3a6ce93f87e1..d559568b912b 100644
--- a/mypy/typeshed/stdlib/tomllib.pyi
+++ b/mypy/typeshed/stdlib/tomllib.pyi
@@ -6,5 +6,5 @@ __all__ = ("loads", "load", "TOMLDecodeError")
 
 class TOMLDecodeError(ValueError): ...
 
-def load(__fp: SupportsRead[bytes], *, parse_float: Callable[[str], Any] = ...) -> dict[str, Any]: ...
-def loads(__s: str, *, parse_float: Callable[[str], Any] = ...) -> dict[str, Any]: ...
+def load(fp: SupportsRead[bytes], /, *, parse_float: Callable[[str], Any] = ...) -> dict[str, Any]: ...
+def loads(s: str, /, *, parse_float: Callable[[str], Any] = ...) -> dict[str, Any]: ...
diff --git a/mypy/typeshed/stdlib/trace.pyi b/mypy/typeshed/stdlib/trace.pyi
index 3764a5b06024..04390f119195 100644
--- a/mypy/typeshed/stdlib/trace.pyi
+++ b/mypy/typeshed/stdlib/trace.pyi
@@ -1,7 +1,7 @@
 import sys
 import types
-from _typeshed import StrPath, TraceFunction
-from collections.abc import Callable, Mapping, Sequence
+from _typeshed import Incomplete, StrPath, TraceFunction
+from collections.abc import Callable, Iterable, Mapping, Sequence
 from typing import Any, TypeVar
 from typing_extensions import ParamSpec, TypeAlias
 
@@ -12,6 +12,12 @@ _P = ParamSpec("_P")
 _FileModuleFunction: TypeAlias = tuple[str, str | None, str]
 
 class CoverageResults:
+    counts: dict[tuple[str, int], int]
+    counter: dict[tuple[str, int], int]
+    calledfuncs: dict[_FileModuleFunction, int]
+    callers: dict[tuple[_FileModuleFunction, _FileModuleFunction], int]
+    inifile: StrPath | None
+    outfile: StrPath | None
     def __init__(
         self,
         counts: dict[tuple[str, int], int] | None = None,
@@ -21,13 +27,38 @@ class CoverageResults:
         outfile: StrPath | None = None,
     ) -> None: ...  # undocumented
     def update(self, other: CoverageResults) -> None: ...
-    def write_results(self, show_missing: bool = True, summary: bool = False, coverdir: StrPath | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def write_results(
+            self,
+            show_missing: bool = True,
+            summary: bool = False,
+            coverdir: StrPath | None = None,
+            *,
+            ignore_missing_files: bool = False,
+        ) -> None: ...
+    else:
+        def write_results(self, show_missing: bool = True, summary: bool = False, coverdir: StrPath | None = None) -> None: ...
+
     def write_results_file(
         self, path: StrPath, lines: Sequence[str], lnotab: Any, lines_hit: Mapping[int, int], encoding: str | None = None
     ) -> tuple[int, int]: ...
     def is_ignored_filename(self, filename: str) -> bool: ...  # undocumented
 
+class _Ignore:
+    def __init__(self, modules: Iterable[str] | None = None, dirs: Iterable[StrPath] | None = None) -> None: ...
+    def names(self, filename: str, modulename: str) -> int: ...
+
 class Trace:
+    inifile: StrPath | None
+    outfile: StrPath | None
+    ignore: _Ignore
+    counts: dict[str, int]
+    pathtobasename: dict[Incomplete, Incomplete]
+    donothing: int
+    trace: int
+    start_time: int | None
+    globaltrace: TraceFunction
+    localtrace: TraceFunction
     def __init__(
         self,
         count: int = 1,
@@ -45,7 +76,7 @@ class Trace:
         self, cmd: str | types.CodeType, globals: Mapping[str, Any] | None = None, locals: Mapping[str, Any] | None = None
     ) -> None: ...
     if sys.version_info >= (3, 9):
-        def runfunc(self, __func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs) -> _T: ...
+        def runfunc(self, func: Callable[_P, _T], /, *args: _P.args, **kw: _P.kwargs) -> _T: ...
     else:
         def runfunc(self, func: Callable[_P, _T], *args: _P.args, **kw: _P.kwargs) -> _T: ...
 
diff --git a/mypy/typeshed/stdlib/traceback.pyi b/mypy/typeshed/stdlib/traceback.pyi
index a6d6d3e168b3..4f132d51c617 100644
--- a/mypy/typeshed/stdlib/traceback.pyi
+++ b/mypy/typeshed/stdlib/traceback.pyi
@@ -1,9 +1,9 @@
 import sys
-from _typeshed import SupportsWrite
+from _typeshed import SupportsWrite, Unused
 from collections.abc import Generator, Iterable, Iterator, Mapping
 from types import FrameType, TracebackType
-from typing import Any, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import Any, ClassVar, Literal, overload
+from typing_extensions import Self, TypeAlias, deprecated
 
 __all__ = [
     "extract_stack",
@@ -27,14 +27,15 @@ __all__ = [
     "walk_tb",
 ]
 
-_PT: TypeAlias = tuple[str, int, str, str | None]
+_FrameSummaryTuple: TypeAlias = tuple[str, int, str, str | None]
 
 def print_tb(tb: TracebackType | None, limit: int | None = None, file: SupportsWrite[str] | None = None) -> None: ...
 
 if sys.version_info >= (3, 10):
     @overload
     def print_exception(
-        __exc: type[BaseException] | None,
+        exc: type[BaseException] | None,
+        /,
         value: BaseException | None = ...,
         tb: TracebackType | None = ...,
         limit: int | None = None,
@@ -43,18 +44,19 @@ if sys.version_info >= (3, 10):
     ) -> None: ...
     @overload
     def print_exception(
-        __exc: BaseException, *, limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True
+        exc: BaseException, /, *, limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True
     ) -> None: ...
     @overload
     def format_exception(
-        __exc: type[BaseException] | None,
+        exc: type[BaseException] | None,
+        /,
         value: BaseException | None = ...,
         tb: TracebackType | None = ...,
         limit: int | None = None,
         chain: bool = True,
     ) -> list[str]: ...
     @overload
-    def format_exception(__exc: BaseException, *, limit: int | None = None, chain: bool = True) -> list[str]: ...
+    def format_exception(exc: BaseException, /, *, limit: int | None = None, chain: bool = True) -> list[str]: ...
 
 else:
     def print_exception(
@@ -78,13 +80,22 @@ def print_last(limit: int | None = None, file: SupportsWrite[str] | None = None,
 def print_stack(f: FrameType | None = None, limit: int | None = None, file: SupportsWrite[str] | None = None) -> None: ...
 def extract_tb(tb: TracebackType | None, limit: int | None = None) -> StackSummary: ...
 def extract_stack(f: FrameType | None = None, limit: int | None = None) -> StackSummary: ...
-def format_list(extracted_list: list[FrameSummary]) -> list[str]: ...
+def format_list(extracted_list: Iterable[FrameSummary | _FrameSummaryTuple]) -> list[str]: ...
 
 # undocumented
-def print_list(extracted_list: list[FrameSummary], file: SupportsWrite[str] | None = None) -> None: ...
+def print_list(extracted_list: Iterable[FrameSummary | _FrameSummaryTuple], file: SupportsWrite[str] | None = None) -> None: ...
 
-if sys.version_info >= (3, 10):
-    def format_exception_only(__exc: type[BaseException] | None, value: BaseException | None = ...) -> list[str]: ...
+if sys.version_info >= (3, 13):
+    @overload
+    def format_exception_only(exc: BaseException | None, /, *, show_group: bool = False) -> list[str]: ...
+    @overload
+    def format_exception_only(exc: Unused, /, value: BaseException | None, *, show_group: bool = False) -> list[str]: ...
+
+elif sys.version_info >= (3, 10):
+    @overload
+    def format_exception_only(exc: BaseException | None, /) -> list[str]: ...
+    @overload
+    def format_exception_only(exc: Unused, /, value: BaseException | None) -> list[str]: ...
 
 else:
     def format_exception_only(etype: type[BaseException] | None, value: BaseException | None) -> list[str]: ...
@@ -102,17 +113,35 @@ if sys.version_info >= (3, 11):
         def emit(self, text_gen: str | Iterable[str], margin_char: str | None = None) -> Generator[str, None, None]: ...
 
 class TracebackException:
-    __cause__: TracebackException
-    __context__: TracebackException
+    __cause__: TracebackException | None
+    __context__: TracebackException | None
+    if sys.version_info >= (3, 11):
+        exceptions: list[TracebackException] | None
     __suppress_context__: bool
+    if sys.version_info >= (3, 11):
+        __notes__: list[str] | None
     stack: StackSummary
-    exc_type: type[BaseException]
+
+    # These fields only exist for `SyntaxError`s, but there is no way to express that in the type system.
     filename: str
-    lineno: int
+    lineno: str | None
+    if sys.version_info >= (3, 10):
+        end_lineno: str | None
     text: str
     offset: int
+    if sys.version_info >= (3, 10):
+        end_offset: int | None
     msg: str
-    if sys.version_info >= (3, 11):
+
+    if sys.version_info >= (3, 13):
+        @property
+        def exc_type_str(self) -> str: ...
+        @property
+        @deprecated("Deprecated in 3.13. Use exc_type_str instead.")
+        def exc_type(self) -> type[BaseException] | None: ...
+    else:
+        exc_type: type[BaseException]
+    if sys.version_info >= (3, 13):
         def __init__(
             self,
             exc_type: type[BaseException],
@@ -125,12 +154,15 @@ class TracebackException:
             compact: bool = False,
             max_group_width: int = 15,
             max_group_depth: int = 10,
+            save_exc_type: bool = True,
             _seen: set[int] | None = None,
         ) -> None: ...
-        @classmethod
-        def from_exception(
-            cls,
-            exc: BaseException,
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
             *,
             limit: int | None = None,
             lookup_lines: bool = True,
@@ -138,7 +170,8 @@ class TracebackException:
             compact: bool = False,
             max_group_width: int = 15,
             max_group_depth: int = 10,
-        ) -> Self: ...
+            _seen: set[int] | None = None,
+        ) -> None: ...
     elif sys.version_info >= (3, 10):
         def __init__(
             self,
@@ -152,6 +185,20 @@ class TracebackException:
             compact: bool = False,
             _seen: set[int] | None = None,
         ) -> None: ...
+    else:
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+
+    if sys.version_info >= (3, 11):
         @classmethod
         def from_exception(
             cls,
@@ -161,36 +208,42 @@ class TracebackException:
             lookup_lines: bool = True,
             capture_locals: bool = False,
             compact: bool = False,
+            max_group_width: int = 15,
+            max_group_depth: int = 10,
         ) -> Self: ...
-    else:
-        def __init__(
-            self,
-            exc_type: type[BaseException],
-            exc_value: BaseException,
-            exc_traceback: TracebackType | None,
+    elif sys.version_info >= (3, 10):
+        @classmethod
+        def from_exception(
+            cls,
+            exc: BaseException,
             *,
             limit: int | None = None,
             lookup_lines: bool = True,
             capture_locals: bool = False,
-            _seen: set[int] | None = None,
-        ) -> None: ...
+            compact: bool = False,
+        ) -> Self: ...
+    else:
         @classmethod
         def from_exception(
             cls, exc: BaseException, *, limit: int | None = None, lookup_lines: bool = True, capture_locals: bool = False
         ) -> Self: ...
 
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     if sys.version_info >= (3, 11):
         def format(self, *, chain: bool = True, _ctx: _ExceptionPrintContext | None = None) -> Generator[str, None, None]: ...
     else:
         def format(self, *, chain: bool = True) -> Generator[str, None, None]: ...
 
-    def format_exception_only(self) -> Generator[str, None, None]: ...
+    if sys.version_info >= (3, 13):
+        def format_exception_only(self, *, show_group: bool = False, _depth: int = 0) -> Generator[str, None, None]: ...
+    else:
+        def format_exception_only(self) -> Generator[str, None, None]: ...
 
     if sys.version_info >= (3, 11):
         def print(self, *, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
 
-class FrameSummary(Iterable[Any]):
+class FrameSummary:
     if sys.version_info >= (3, 11):
         def __init__(
             self,
@@ -235,10 +288,12 @@ class FrameSummary(Iterable[Any]):
     def __getitem__(self, pos: Literal[3]) -> str | None: ...
     @overload
     def __getitem__(self, pos: int) -> Any: ...
+    @overload
+    def __getitem__(self, pos: slice) -> tuple[Any, ...]: ...
     def __iter__(self) -> Iterator[Any]: ...
     def __eq__(self, other: object) -> bool: ...
-    if sys.version_info >= (3, 8):
-        def __len__(self) -> Literal[4]: ...
+    def __len__(self) -> Literal[4]: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class StackSummary(list[FrameSummary]):
     @classmethod
@@ -251,7 +306,7 @@ class StackSummary(list[FrameSummary]):
         capture_locals: bool = False,
     ) -> StackSummary: ...
     @classmethod
-    def from_list(cls, a_list: Iterable[FrameSummary | _PT]) -> StackSummary: ...
+    def from_list(cls, a_list: Iterable[FrameSummary | _FrameSummaryTuple]) -> StackSummary: ...
     if sys.version_info >= (3, 11):
         def format_frame_summary(self, frame_summary: FrameSummary) -> str: ...
 
diff --git a/mypy/typeshed/stdlib/tracemalloc.pyi b/mypy/typeshed/stdlib/tracemalloc.pyi
index 3dc8b8603fe5..e721e414138b 100644
--- a/mypy/typeshed/stdlib/tracemalloc.pyi
+++ b/mypy/typeshed/stdlib/tracemalloc.pyi
@@ -1,8 +1,8 @@
 import sys
 from _tracemalloc import *
 from collections.abc import Sequence
-from typing import Any, overload
-from typing_extensions import SupportsIndex, TypeAlias
+from typing import Any, SupportsIndex, overload
+from typing_extensions import TypeAlias
 
 def get_object_traceback(obj: object) -> Traceback | None: ...
 def take_snapshot() -> Snapshot: ...
@@ -37,6 +37,7 @@ class Statistic:
     traceback: Traceback
     def __init__(self, traceback: Traceback, size: int, count: int) -> None: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
 
 class StatisticDiff:
     count: int
@@ -46,6 +47,7 @@ class StatisticDiff:
     traceback: Traceback
     def __init__(self, traceback: Traceback, size: int, size_diff: int, count: int, count_diff: int) -> None: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
 
 _FrameTuple: TypeAlias = tuple[str, int]
 
@@ -56,6 +58,7 @@ class Frame:
     def lineno(self) -> int: ...
     def __init__(self, frame: _FrameTuple) -> None: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
     def __lt__(self, other: Frame) -> bool: ...
     if sys.version_info >= (3, 11):
         def __gt__(self, other: Frame) -> bool: ...
@@ -80,6 +83,7 @@ class Trace:
     def traceback(self) -> Traceback: ...
     def __init__(self, trace: _TraceTuple) -> None: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
 
 class Traceback(Sequence[Frame]):
     if sys.version_info >= (3, 9):
@@ -97,6 +101,7 @@ class Traceback(Sequence[Frame]):
     def __contains__(self, frame: Frame) -> bool: ...  # type: ignore[override]
     def __len__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
     def __lt__(self, other: Traceback) -> bool: ...
     if sys.version_info >= (3, 11):
         def __gt__(self, other: Traceback) -> bool: ...
diff --git a/mypy/typeshed/stdlib/tty.pyi b/mypy/typeshed/stdlib/tty.pyi
index 43f2e1cf9087..0611879cf1b2 100644
--- a/mypy/typeshed/stdlib/tty.pyi
+++ b/mypy/typeshed/stdlib/tty.pyi
@@ -1,19 +1,30 @@
 import sys
-from typing import IO
+import termios
+from typing import IO, Final
 from typing_extensions import TypeAlias
 
 if sys.platform != "win32":
     __all__ = ["setraw", "setcbreak"]
+    if sys.version_info >= (3, 12):
+        __all__ += ["cfmakeraw", "cfmakecbreak"]
+
+        _ModeSetterReturn: TypeAlias = termios._AttrReturn
+    else:
+        _ModeSetterReturn: TypeAlias = None
 
     _FD: TypeAlias = int | IO[str]
 
     # XXX: Undocumented integer constants
-    IFLAG: int
-    OFLAG: int
-    CFLAG: int
-    LFLAG: int
-    ISPEED: int
-    OSPEED: int
-    CC: int
-    def setraw(fd: _FD, when: int = 2) -> None: ...
-    def setcbreak(fd: _FD, when: int = 2) -> None: ...
+    IFLAG: Final[int]
+    OFLAG: Final[int]
+    CFLAG: Final[int]
+    LFLAG: Final[int]
+    ISPEED: Final[int]
+    OSPEED: Final[int]
+    CC: Final[int]
+    def setraw(fd: _FD, when: int = 2) -> _ModeSetterReturn: ...
+    def setcbreak(fd: _FD, when: int = 2) -> _ModeSetterReturn: ...
+
+    if sys.version_info >= (3, 12):
+        def cfmakeraw(mode: termios._Attr) -> None: ...
+        def cfmakecbreak(mode: termios._Attr) -> None: ...
diff --git a/mypy/typeshed/stdlib/turtle.pyi b/mypy/typeshed/stdlib/turtle.pyi
index 5df3e4b90cb5..a2ab728de943 100644
--- a/mypy/typeshed/stdlib/turtle.pyi
+++ b/mypy/typeshed/stdlib/turtle.pyi
@@ -1,6 +1,7 @@
+import sys
 from collections.abc import Callable, Sequence
 from tkinter import Canvas, Frame, Misc, PhotoImage, Scrollbar
-from typing import Any, ClassVar, overload
+from typing import Any, ClassVar, Literal, TypedDict, overload
 from typing_extensions import Self, TypeAlias
 
 __all__ = [
@@ -100,7 +101,6 @@ __all__ = [
     "setheading",
     "setpos",
     "setposition",
-    "settiltangle",
     "setundobuffer",
     "setx",
     "sety",
@@ -128,6 +128,12 @@ __all__ = [
     "Terminator",
 ]
 
+if sys.version_info >= (3, 12):
+    __all__ += ["teleport"]
+
+if sys.version_info < (3, 13):
+    __all__ += ["settiltangle"]
+
 # Note: '_Color' is the alias we use for arguments and _AnyColor is the
 # alias we use for return types. Really, these two aliases should be the
 # same, but as per the "no union returns" typeshed policy, we'll return
@@ -135,8 +141,18 @@ __all__ = [
 _Color: TypeAlias = str | tuple[float, float, float]
 _AnyColor: TypeAlias = Any
 
-# TODO: Replace this with a TypedDict once it becomes standardized.
-_PenState: TypeAlias = dict[str, Any]
+class _PenState(TypedDict):
+    shown: bool
+    pendown: bool
+    pencolor: _Color
+    fillcolor: _Color
+    pensize: int
+    speed: int
+    resizemode: Literal["auto", "user", "noresize"]
+    stretchfactor: tuple[float, float]
+    shearfactor: float
+    outline: int
+    tilt: float
 
 _Speed: TypeAlias = str | float
 _PolygonCoords: TypeAlias = Sequence[tuple[float, float]]
@@ -249,6 +265,9 @@ class TNavigator:
     def reset(self) -> None: ...
     def degrees(self, fullcircle: float = 360.0) -> None: ...
     def radians(self) -> None: ...
+    if sys.version_info >= (3, 12):
+        def teleport(self, x: float | None = None, y: float | None = None, *, fill_gap: bool = False) -> None: ...
+
     def forward(self, distance: float) -> None: ...
     def back(self, distance: float) -> None: ...
     def right(self, angle: float) -> None: ...
@@ -274,6 +293,7 @@ class TNavigator:
     def heading(self) -> float: ...
     def setheading(self, to_angle: float) -> None: ...
     def circle(self, radius: float, extent: float | None = None, steps: int | None = None) -> None: ...
+    def speed(self, s: int | None = 0) -> int | None: ...
     fd = forward
     bk = back
     backward = back
@@ -321,12 +341,15 @@ class TPen:
     def color(self, r: float, g: float, b: float) -> None: ...
     @overload
     def color(self, color1: _Color, color2: _Color) -> None: ...
+    if sys.version_info >= (3, 12):
+        def teleport(self, x: float | None = None, y: float | None = None, *, fill_gap: bool = False) -> None: ...
+
     def showturtle(self) -> None: ...
     def hideturtle(self) -> None: ...
     def isvisible(self) -> bool: ...
     # Note: signatures 1 and 2 overlap unsafely when no arguments are provided
     @overload
-    def pen(self) -> _PenState: ...  # type: ignore[misc]
+    def pen(self) -> _PenState: ...
     @overload
     def pen(
         self,
@@ -351,7 +374,7 @@ class TPen:
     st = showturtle
     ht = hideturtle
 
-class RawTurtle(TPen, TNavigator):
+class RawTurtle(TPen, TNavigator):  # type: ignore[misc]  # Conflicting methods in base classes
     screen: TurtleScreen
     screens: ClassVar[list[TurtleScreen]]
     def __init__(
@@ -372,7 +395,7 @@ class RawTurtle(TPen, TNavigator):
     def shape(self, name: str) -> None: ...
     # Unsafely overlaps when no arguments are provided
     @overload
-    def shapesize(self) -> tuple[float, float, float]: ...  # type: ignore[misc]
+    def shapesize(self) -> tuple[float, float, float]: ...
     @overload
     def shapesize(
         self, stretch_wid: float | None = None, stretch_len: float | None = None, outline: float | None = None
@@ -383,13 +406,16 @@ class RawTurtle(TPen, TNavigator):
     def shearfactor(self, shear: float) -> None: ...
     # Unsafely overlaps when no arguments are provided
     @overload
-    def shapetransform(self) -> tuple[float, float, float, float]: ...  # type: ignore[misc]
+    def shapetransform(self) -> tuple[float, float, float, float]: ...
     @overload
     def shapetransform(
         self, t11: float | None = None, t12: float | None = None, t21: float | None = None, t22: float | None = None
     ) -> None: ...
     def get_shapepoly(self) -> _PolygonCoords | None: ...
-    def settiltangle(self, angle: float) -> None: ...
+
+    if sys.version_info < (3, 13):
+        def settiltangle(self, angle: float) -> None: ...
+
     @overload
     def tiltangle(self, angle: None = None) -> float: ...
     @overload
@@ -607,7 +633,7 @@ def isvisible() -> bool: ...
 
 # Note: signatures 1 and 2 overlap unsafely when no arguments are provided
 @overload
-def pen() -> _PenState: ...  # type: ignore[misc]
+def pen() -> _PenState: ...
 @overload
 def pen(
     pen: _PenState | None = None,
@@ -641,9 +667,12 @@ def shape(name: None = None) -> str: ...
 @overload
 def shape(name: str) -> None: ...
 
+if sys.version_info >= (3, 12):
+    def teleport(x: float | None = None, y: float | None = None, *, fill_gap: bool = False) -> None: ...
+
 # Unsafely overlaps when no arguments are provided
 @overload
-def shapesize() -> tuple[float, float, float]: ...  # type: ignore[misc]
+def shapesize() -> tuple[float, float, float]: ...
 @overload
 def shapesize(stretch_wid: float | None = None, stretch_len: float | None = None, outline: float | None = None) -> None: ...
 @overload
@@ -653,13 +682,16 @@ def shearfactor(shear: float) -> None: ...
 
 # Unsafely overlaps when no arguments are provided
 @overload
-def shapetransform() -> tuple[float, float, float, float]: ...  # type: ignore[misc]
+def shapetransform() -> tuple[float, float, float, float]: ...
 @overload
 def shapetransform(
     t11: float | None = None, t12: float | None = None, t21: float | None = None, t22: float | None = None
 ) -> None: ...
 def get_shapepoly() -> _PolygonCoords | None: ...
-def settiltangle(angle: float) -> None: ...
+
+if sys.version_info < (3, 13):
+    def settiltangle(angle: float) -> None: ...
+
 @overload
 def tiltangle(angle: None = None) -> float: ...
 @overload
diff --git a/mypy/typeshed/stdlib/types.pyi b/mypy/typeshed/stdlib/types.pyi
index 43475d91279d..542979d4afc5 100644
--- a/mypy/typeshed/stdlib/types.pyi
+++ b/mypy/typeshed/stdlib/types.pyi
@@ -1,5 +1,6 @@
 import sys
-from _typeshed import SupportsKeysAndGetItem
+from _typeshed import MaybeNone, SupportsKeysAndGetItem
+from _typeshed.importlib import LoaderProtocol
 from collections.abc import (
     AsyncGenerator,
     Awaitable,
@@ -16,8 +17,8 @@ from collections.abc import (
 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 import Any, ClassVar, Literal, Mapping, TypeVar, final, overload  # noqa: Y022
+from typing_extensions import ParamSpec, Self, TypeAliasType, TypeVarTuple, deprecated
 
 __all__ = [
     "FunctionType",
@@ -45,11 +46,9 @@ __all__ = [
     "MethodWrapperType",
     "WrapperDescriptorType",
     "resolve_bases",
+    "CellType",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["CellType"]
-
 if sys.version_info >= (3, 9):
     __all__ += ["GenericAlias"]
 
@@ -59,29 +58,21 @@ if sys.version_info >= (3, 10):
 if sys.version_info >= (3, 12):
     __all__ += ["get_original_bases"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["CapsuleType"]
+
 # Note, all classes "defined" here require special handling.
 
 _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:
-    if sys.version_info >= (3, 8):
-        def __init__(self, __contents: object = ...) -> None: ...
-
-    __hash__: ClassVar[None]  # type: ignore[assignment]
-    cell_contents: Any
 
 # Make sure this class definition stays roughly in line with `builtins.function`
 @final
 class FunctionType:
     @property
-    def __closure__(self) -> tuple[_Cell, ...] | None: ...
+    def __closure__(self) -> tuple[CellType, ...] | None: ...
     __code__: CodeType
     __defaults__: tuple[Any, ...] | None
     __dict__: dict[str, Any]
@@ -90,36 +81,50 @@ class FunctionType:
     __name__: str
     __qualname__: str
     __annotations__: dict[str, Any]
-    __kwdefaults__: dict[str, Any]
+    __kwdefaults__: dict[str, Any] | None
     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__(
-        self,
-        code: CodeType,
-        globals: dict[str, Any],
-        name: str | None = ...,
-        argdefs: tuple[object, ...] | None = ...,
-        closure: tuple[_Cell, ...] | None = ...,
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __new__(
+            cls,
+            code: CodeType,
+            globals: dict[str, Any],
+            name: str | None = None,
+            argdefs: tuple[object, ...] | None = None,
+            closure: tuple[CellType, ...] | None = None,
+            kwdefaults: dict[str, object] | None = None,
+        ) -> Self: ...
+    else:
+        def __new__(
+            cls,
+            code: CodeType,
+            globals: dict[str, Any],
+            name: str | None = None,
+            argdefs: tuple[object, ...] | None = None,
+            closure: tuple[CellType, ...] | None = None,
+        ) -> Self: ...
+
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
     @overload
-    def __get__(self, __instance: None, __owner: type) -> FunctionType: ...
+    def __get__(self, instance: None, owner: type, /) -> FunctionType: ...
     @overload
-    def __get__(self, __instance: object, __owner: type | None = None) -> MethodType: ...
+    def __get__(self, instance: object, owner: type | None = None, /) -> MethodType: ...
 
 LambdaType = FunctionType
 
 @final
 class CodeType:
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
     @property
     def co_argcount(self) -> int: ...
-    if sys.version_info >= (3, 8):
-        @property
-        def co_posonlyargcount(self) -> int: ...
-
+    @property
+    def co_posonlyargcount(self) -> int: ...
     @property
     def co_kwonlyargcount(self) -> int: ...
     @property
@@ -142,8 +147,14 @@ class CodeType:
     def co_name(self) -> str: ...
     @property
     def co_firstlineno(self) -> int: ...
-    @property
-    def co_lnotab(self) -> bytes: ...
+    if sys.version_info >= (3, 10):
+        @property
+        @deprecated("Will be removed in Python 3.14. Use the co_lines() method instead.")
+        def co_lnotab(self) -> bytes: ...
+    else:
+        @property
+        def co_lnotab(self) -> bytes: ...
+
     @property
     def co_freevars(self) -> tuple[str, ...]: ...
     @property
@@ -160,86 +171,70 @@ class CodeType:
         def co_positions(self) -> Iterable[tuple[int | None, int | None, int | None, int | None]]: ...
 
     if sys.version_info >= (3, 11):
-        def __init__(
-            self,
-            __argcount: int,
-            __posonlyargcount: int,
-            __kwonlyargcount: int,
-            __nlocals: int,
-            __stacksize: int,
-            __flags: int,
-            __codestring: bytes,
-            __constants: tuple[object, ...],
-            __names: tuple[str, ...],
-            __varnames: tuple[str, ...],
-            __filename: str,
-            __name: str,
-            __qualname: str,
-            __firstlineno: int,
-            __linetable: bytes,
-            __exceptiontable: bytes,
-            __freevars: tuple[str, ...] = ...,
-            __cellvars: tuple[str, ...] = ...,
-        ) -> None: ...
+        def __new__(
+            cls,
+            argcount: int,
+            posonlyargcount: int,
+            kwonlyargcount: int,
+            nlocals: int,
+            stacksize: int,
+            flags: int,
+            codestring: bytes,
+            constants: tuple[object, ...],
+            names: tuple[str, ...],
+            varnames: tuple[str, ...],
+            filename: str,
+            name: str,
+            qualname: str,
+            firstlineno: int,
+            linetable: bytes,
+            exceptiontable: bytes,
+            freevars: tuple[str, ...] = ...,
+            cellvars: tuple[str, ...] = ...,
+            /,
+        ) -> Self: ...
     elif sys.version_info >= (3, 10):
-        def __init__(
-            self,
-            __argcount: int,
-            __posonlyargcount: int,
-            __kwonlyargcount: int,
-            __nlocals: int,
-            __stacksize: int,
-            __flags: int,
-            __codestring: bytes,
-            __constants: tuple[object, ...],
-            __names: tuple[str, ...],
-            __varnames: tuple[str, ...],
-            __filename: str,
-            __name: str,
-            __firstlineno: int,
-            __linetable: bytes,
-            __freevars: tuple[str, ...] = ...,
-            __cellvars: tuple[str, ...] = ...,
-        ) -> None: ...
-    elif sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            __argcount: int,
-            __posonlyargcount: int,
-            __kwonlyargcount: int,
-            __nlocals: int,
-            __stacksize: int,
-            __flags: int,
-            __codestring: bytes,
-            __constants: tuple[object, ...],
-            __names: tuple[str, ...],
-            __varnames: tuple[str, ...],
-            __filename: str,
-            __name: str,
-            __firstlineno: int,
-            __lnotab: bytes,
-            __freevars: tuple[str, ...] = ...,
-            __cellvars: tuple[str, ...] = ...,
-        ) -> None: ...
+        def __new__(
+            cls,
+            argcount: int,
+            posonlyargcount: int,
+            kwonlyargcount: int,
+            nlocals: int,
+            stacksize: int,
+            flags: int,
+            codestring: bytes,
+            constants: tuple[object, ...],
+            names: tuple[str, ...],
+            varnames: tuple[str, ...],
+            filename: str,
+            name: str,
+            firstlineno: int,
+            linetable: bytes,
+            freevars: tuple[str, ...] = ...,
+            cellvars: tuple[str, ...] = ...,
+            /,
+        ) -> Self: ...
     else:
-        def __init__(
-            self,
-            __argcount: int,
-            __kwonlyargcount: int,
-            __nlocals: int,
-            __stacksize: int,
-            __flags: int,
-            __codestring: bytes,
-            __constants: tuple[object, ...],
-            __names: tuple[str, ...],
-            __varnames: tuple[str, ...],
-            __filename: str,
-            __name: str,
-            __firstlineno: int,
-            __lnotab: bytes,
-            __freevars: tuple[str, ...] = ...,
-            __cellvars: tuple[str, ...] = ...,
-        ) -> None: ...
+        def __new__(
+            cls,
+            argcount: int,
+            posonlyargcount: int,
+            kwonlyargcount: int,
+            nlocals: int,
+            stacksize: int,
+            flags: int,
+            codestring: bytes,
+            constants: tuple[object, ...],
+            names: tuple[str, ...],
+            varnames: tuple[str, ...],
+            filename: str,
+            name: str,
+            firstlineno: int,
+            lnotab: bytes,
+            freevars: tuple[str, ...] = ...,
+            cellvars: tuple[str, ...] = ...,
+            /,
+        ) -> Self: ...
     if sys.version_info >= (3, 11):
         def replace(
             self,
@@ -262,7 +257,7 @@ class CodeType:
             co_qualname: str = ...,
             co_linetable: bytes = ...,
             co_exceptiontable: bytes = ...,
-        ) -> CodeType: ...
+        ) -> Self: ...
     elif sys.version_info >= (3, 10):
         def replace(
             self,
@@ -283,8 +278,8 @@ class CodeType:
             co_filename: str = ...,
             co_name: str = ...,
             co_linetable: bytes = ...,
-        ) -> CodeType: ...
-    elif sys.version_info >= (3, 8):
+        ) -> Self: ...
+    else:
         def replace(
             self,
             *,
@@ -304,45 +299,63 @@ class CodeType:
             co_filename: str = ...,
             co_name: str = ...,
             co_lnotab: bytes = ...,
-        ) -> CodeType: ...
+        ) -> Self: ...
+
+    if sys.version_info >= (3, 13):
+        __replace__ = replace
 
 @final
-class MappingProxyType(Mapping[_KT, _VT_co], Generic[_KT, _VT_co]):
+class MappingProxyType(Mapping[_KT, _VT_co]):
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __init__(self, mapping: SupportsKeysAndGetItem[_KT, _VT_co]) -> None: ...
-    def __getitem__(self, __key: _KT) -> _VT_co: ...
+    def __new__(cls, mapping: SupportsKeysAndGetItem[_KT, _VT_co]) -> Self: ...
+    def __getitem__(self, key: _KT, /) -> _VT_co: ...
     def __iter__(self) -> Iterator[_KT]: ...
     def __len__(self) -> int: ...
-    def __eq__(self, __value: object) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
     def copy(self) -> dict[_KT, _VT_co]: ...
     def keys(self) -> KeysView[_KT]: ...
     def values(self) -> ValuesView[_VT_co]: ...
     def items(self) -> ItemsView[_KT, _VT_co]: ...
+    @overload
+    def get(self, key: _KT, /) -> _VT_co | None: ...
+    @overload
+    def get(self, key: _KT, default: _VT_co | _T2, /) -> _VT_co | _T2: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
         def __reversed__(self) -> Iterator[_KT]: ...
-        def __or__(self, __value: Mapping[_T1, _T2]) -> dict[_KT | _T1, _VT_co | _T2]: ...
-        def __ror__(self, __value: Mapping[_T1, _T2]) -> dict[_KT | _T1, _VT_co | _T2]: ...
+        def __or__(self, value: Mapping[_T1, _T2], /) -> dict[_KT | _T1, _VT_co | _T2]: ...
+        def __ror__(self, value: Mapping[_T1, _T2], /) -> dict[_KT | _T1, _VT_co | _T2]: ...
 
 class SimpleNamespace:
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __init__(self, **kwargs: Any) -> None: ...
-    def __getattribute__(self, __name: str) -> Any: ...
-    def __setattr__(self, __name: str, __value: Any) -> None: ...
-    def __delattr__(self, __name: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(self, mapping_or_iterable: Mapping[str, Any] | Iterable[tuple[str, Any]] = (), /, **kwargs: Any) -> None: ...
+    else:
+        def __init__(self, **kwargs: Any) -> None: ...
 
-class _LoaderProtocol(Protocol):
-    def load_module(self, fullname: str) -> ModuleType: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __getattribute__(self, name: str, /) -> Any: ...
+    def __setattr__(self, name: str, value: Any, /) -> None: ...
+    def __delattr__(self, name: str, /) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, **kwargs: Any) -> Self: ...
 
 class ModuleType:
     __name__: str
     __file__: str | None
     @property
     def __dict__(self) -> dict[str, Any]: ...  # type: ignore[override]
-    __loader__: _LoaderProtocol | None
+    __loader__: LoaderProtocol | None
     __package__: str | None
     __path__: MutableSequence[str]
     __spec__: ModuleSpec | None
+    # N.B. Although this is the same type as `builtins.object.__doc__`,
+    # it is deliberately redeclared here. Most symbols declared in the namespace
+    # of `types.ModuleType` are available as "implicit globals" within a module's
+    # namespace, but this is not true for symbols declared in the namespace of `builtins.object`.
+    # Redeclaring `__doc__` here helps some type checkers understand that `__doc__` is available
+    # as an implicit global in all modules, similar to `__name__`, `__file__`, `__spec__`, etc.
+    __doc__: str | None
     def __init__(self, name: str, doc: str | None = ...) -> None: ...
     # __getattr__ doesn't exist at runtime,
     # but having it here in typeshed makes dynamic imports
@@ -350,91 +363,121 @@ class ModuleType:
     def __getattr__(self, name: str) -> Any: ...
 
 @final
-class GeneratorType(Generator[_T_co, _T_contra, _V_co]):
+class CellType:
+    def __new__(cls, contents: object = ..., /) -> Self: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    cell_contents: 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[_YieldT_co, _SendT_contra, _ReturnT_co]):
+    @property
+    def gi_code(self) -> CodeType: ...
+    @property
+    def gi_frame(self) -> FrameType: ...
+    @property
+    def gi_running(self) -> bool: ...
     @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: ...
+        self, typ: type[BaseException], val: BaseException | object = ..., tb: TracebackType | None = ..., /
+    ) -> _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: ...
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, item: Any, /) -> Any: ...
 
 @final
-class AsyncGeneratorType(AsyncGenerator[_T_co, _T_contra]):
+class AsyncGeneratorType(AsyncGenerator[_YieldT_co, _SendT_contra]):
     @property
     def ag_await(self) -> Awaitable[Any] | None: ...
+    @property
+    def ag_code(self) -> CodeType: ...
+    @property
+    def ag_frame(self) -> FrameType: ...
+    @property
+    def ag_running(self) -> bool: ...
     __name__: str
     __qualname__: str
-    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]: ...
+    if sys.version_info >= (3, 12):
+        @property
+        def ag_suspended(self) -> bool: ...
+
+    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: ...
+        self, typ: type[BaseException], val: BaseException | object = ..., tb: TracebackType | None = ..., /
+    ) -> _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: ...
+        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
+    def cr_await(self) -> Any | None: ...
+    @property
+    def cr_code(self) -> CodeType: ...
+    @property
+    def cr_frame(self) -> FrameType: ...
+    @property
+    def cr_running(self) -> bool: ...
+    @property
     def cr_origin(self) -> tuple[tuple[str, int, str], ...] | None: ...
     if sys.version_info >= (3, 11):
         @property
         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: ...
+        self, typ: type[BaseException], val: BaseException | object = ..., tb: TracebackType | None = ..., /
+    ) -> _YieldT_co: ...
     @overload
-    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = ...) -> _T_co: ...
-
-class _StaticFunctionType:
-    # Fictional type to correct the type of MethodType.__func__.
-    # FunctionType is a descriptor, so mypy follows the descriptor protocol and
-    # converts MethodType.__func__ back to MethodType (the return type of
-    # FunctionType.__get__). But this is actually a special case; MethodType is
-    # implemented in C and its attribute access doesn't go through
-    # __getattribute__.
-    # By wrapping FunctionType in _StaticFunctionType, we get the right result;
-    # similar to wrapping a function in staticmethod() at runtime to prevent it
-    # being bound as a method.
-    def __get__(self, obj: object, type: type | None) -> FunctionType: ...
+    def throw(self, typ: BaseException, val: None = None, tb: TracebackType | None = ..., /) -> _YieldT_co: ...
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, item: Any, /) -> Any: ...
 
 @final
 class MethodType:
     @property
-    def __closure__(self) -> tuple[_Cell, ...] | None: ...  # inherited from the added function
+    def __closure__(self) -> tuple[CellType, ...] | None: ...  # inherited from the added function
+    @property
+    def __code__(self) -> CodeType: ...  # inherited from the added function
     @property
     def __defaults__(self) -> tuple[Any, ...] | None: ...  # inherited from the added function
     @property
-    def __func__(self) -> _StaticFunctionType: ...
+    def __func__(self) -> Callable[..., Any]: ...
     @property
     def __self__(self) -> object: ...
     @property
     def __name__(self) -> str: ...  # inherited from the added function
     @property
     def __qualname__(self) -> str: ...  # inherited from the added function
-    def __init__(self, __func: Callable[..., Any], __obj: object) -> None: ...
+    def __new__(cls, func: Callable[..., Any], instance: object, /) -> Self: ...
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
 
 @final
 class BuiltinFunctionType:
@@ -445,6 +488,8 @@ class BuiltinFunctionType:
     @property
     def __qualname__(self) -> str: ...
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
 
 BuiltinMethodType = BuiltinFunctionType
 
@@ -457,7 +502,7 @@ class WrapperDescriptorType:
     @property
     def __objclass__(self) -> type: ...
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
-    def __get__(self, __instance: Any, __owner: type | None = None) -> Any: ...
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
 
 @final
 class MethodWrapperType:
@@ -470,8 +515,9 @@ class MethodWrapperType:
     @property
     def __objclass__(self) -> type: ...
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
-    def __eq__(self, __value: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
 
 @final
 class MethodDescriptorType:
@@ -482,7 +528,7 @@ class MethodDescriptorType:
     @property
     def __objclass__(self) -> type: ...
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
-    def __get__(self, __instance: Any, __owner: type | None = None) -> Any: ...
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
 
 @final
 class ClassMethodDescriptorType:
@@ -493,13 +539,13 @@ class ClassMethodDescriptorType:
     @property
     def __objclass__(self) -> type: ...
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
-    def __get__(self, __instance: Any, __owner: type | None = None) -> Any: ...
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
 
 @final
 class TracebackType:
-    def __init__(self, tb_next: TracebackType | None, tb_frame: FrameType, tb_lasti: int, tb_lineno: int) -> None: ...
+    def __new__(cls, tb_next: TracebackType | None, tb_frame: FrameType, tb_lasti: int, tb_lineno: int) -> Self: ...
     tb_next: TracebackType | None
-    # the rest are read-only even in 3.7
+    # the rest are read-only
     @property
     def tb_frame(self) -> FrameType: ...
     @property
@@ -521,9 +567,9 @@ class FrameType:
     def f_lasti(self) -> int: ...
     # see discussion in #6769: f_lineno *can* sometimes be None,
     # but you should probably file a bug report with CPython if you encounter it being None in the wild.
-    # An `int | None` annotation here causes too many false-positive errors.
+    # An `int | None` annotation here causes too many false-positive errors, so applying `int | Any`.
     @property
-    def f_lineno(self) -> int | Any: ...
+    def f_lineno(self) -> int | MaybeNone: ...
     @property
     def f_locals(self) -> dict[str, Any]: ...
     f_trace: Callable[[FrameType, str, Any], Any] | None
@@ -539,9 +585,9 @@ class GetSetDescriptorType:
     def __qualname__(self) -> str: ...
     @property
     def __objclass__(self) -> type: ...
-    def __get__(self, __instance: Any, __owner: type | None = None) -> Any: ...
-    def __set__(self, __instance: Any, __value: Any) -> None: ...
-    def __delete__(self, __instance: Any) -> None: ...
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
+    def __set__(self, instance: Any, value: Any, /) -> None: ...
+    def __delete__(self, instance: Any, /) -> None: ...
 
 @final
 class MemberDescriptorType:
@@ -551,9 +597,9 @@ class MemberDescriptorType:
     def __qualname__(self) -> str: ...
     @property
     def __objclass__(self) -> type: ...
-    def __get__(self, __instance: Any, __owner: type | None = None) -> Any: ...
-    def __set__(self, __instance: Any, __value: Any) -> None: ...
-    def __delete__(self, __instance: Any) -> None: ...
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
+    def __set__(self, instance: Any, value: Any, /) -> None: ...
+    def __delete__(self, instance: Any, /) -> None: ...
 
 def new_class(
     name: str,
@@ -567,40 +613,61 @@ def prepare_class(
 ) -> tuple[type, dict[str, Any], dict[str, Any]]: ...
 
 if sys.version_info >= (3, 12):
-    def get_original_bases(__cls: type) -> tuple[Any, ...]: ...
-
-# Actually a different type, but `property` is special and we want that too.
-DynamicClassAttribute = property
+    def get_original_bases(cls: type, /) -> tuple[Any, ...]: ...
+
+# Does not actually inherit from property, but saying it does makes sure that
+# pyright handles this class correctly.
+class DynamicClassAttribute(property):
+    fget: Callable[[Any], Any] | None
+    fset: Callable[[Any, Any], object] | None  # type: ignore[assignment]
+    fdel: Callable[[Any], object] | None  # type: ignore[assignment]
+    overwrite_doc: bool
+    __isabstractmethod__: bool
+    def __init__(
+        self,
+        fget: Callable[[Any], Any] | None = None,
+        fset: Callable[[Any, Any], object] | None = None,
+        fdel: Callable[[Any], object] | None = None,
+        doc: str | None = None,
+    ) -> None: ...
+    def __get__(self, instance: Any, ownerclass: type | None = None) -> Any: ...
+    def __set__(self, instance: Any, value: Any) -> None: ...
+    def __delete__(self, instance: Any) -> None: ...
+    def getter(self, fget: Callable[[Any], Any]) -> DynamicClassAttribute: ...
+    def setter(self, fset: Callable[[Any, Any], object]) -> DynamicClassAttribute: ...
+    def deleter(self, fdel: Callable[[Any], object]) -> DynamicClassAttribute: ...
 
 _Fn = TypeVar("_Fn", bound=Callable[..., object])
 _R = TypeVar("_R")
 _P = ParamSpec("_P")
 
 # it's not really an Awaitable, but can be used in an await expression. Real type: Generator & Awaitable
-# The type: ignore is due to overlapping overloads, not the use of ParamSpec
 @overload
-def coroutine(func: Callable[_P, Generator[Any, Any, _R]]) -> Callable[_P, Awaitable[_R]]: ...  # type: ignore[misc]
+def coroutine(func: Callable[_P, Generator[Any, Any, _R]]) -> Callable[_P, Awaitable[_R]]: ...
 @overload
 def coroutine(func: _Fn) -> _Fn: ...
 
-if sys.version_info >= (3, 8):
-    CellType = _Cell
-
 if sys.version_info >= (3, 9):
     class GenericAlias:
         @property
-        def __origin__(self) -> type: ...
+        def __origin__(self) -> type | TypeAliasType: ...
         @property
         def __args__(self) -> tuple[Any, ...]: ...
         @property
         def __parameters__(self) -> tuple[Any, ...]: ...
-        def __init__(self, origin: type, args: Any) -> None: ...
-        def __getitem__(self, __typeargs: Any) -> GenericAlias: ...
+        def __new__(cls, origin: type, args: Any, /) -> Self: ...
+        def __getitem__(self, typeargs: Any, /) -> GenericAlias: ...
+        def __eq__(self, value: object, /) -> bool: ...
+        def __hash__(self) -> int: ...
+        def __mro_entries__(self, bases: Iterable[object], /) -> tuple[type, ...]: ...
         if sys.version_info >= (3, 11):
             @property
             def __unpacked__(self) -> bool: ...
             @property
             def __typing_unpacked_tuple_args__(self) -> tuple[Any, ...] | None: ...
+        if sys.version_info >= (3, 10):
+            def __or__(self, value: Any, /) -> UnionType: ...
+            def __ror__(self, value: Any, /) -> UnionType: ...
 
         # GenericAlias delegates attr access to `__origin__`
         def __getattr__(self, name: str) -> Any: ...
@@ -609,7 +676,10 @@ if sys.version_info >= (3, 10):
     @final
     class NoneType:
         def __bool__(self) -> Literal[False]: ...
-    EllipsisType = ellipsis  # noqa: F821 from builtins
+
+    @final
+    class EllipsisType: ...
+
     from builtins import _NotImplementedType
 
     NotImplementedType = _NotImplementedType
@@ -617,5 +687,13 @@ if sys.version_info >= (3, 10):
     class UnionType:
         @property
         def __args__(self) -> tuple[Any, ...]: ...
-        def __or__(self, __value: Any) -> UnionType: ...
-        def __ror__(self, __value: Any) -> UnionType: ...
+        @property
+        def __parameters__(self) -> tuple[Any, ...]: ...
+        def __or__(self, value: Any, /) -> UnionType: ...
+        def __ror__(self, value: Any, /) -> UnionType: ...
+        def __eq__(self, value: object, /) -> bool: ...
+        def __hash__(self) -> int: ...
+
+if sys.version_info >= (3, 13):
+    @final
+    class CapsuleType: ...
diff --git a/mypy/typeshed/stdlib/typing.pyi b/mypy/typeshed/stdlib/typing.pyi
index db042dc440ae..bc8f342ef46b 100644
--- a/mypy/typeshed/stdlib/typing.pyi
+++ b/mypy/typeshed/stdlib/typing.pyi
@@ -1,15 +1,17 @@
-import collections  # Needed by aliases like DefaultDict, see mypy issue 2986
+# Since this module defines "overload" it is not recognized by Ruff as typing.overload
+# ruff: noqa: F811
+# TODO: The collections import is required, otherwise mypy crashes.
+# https://github.com/python/mypy/issues/16744
+import collections  # noqa: F401  # pyright: ignore[reportUnusedImport]
 import sys
 import typing_extensions
 from _collections_abc import dict_items, dict_keys, dict_values
-from _typeshed import IdentityFunction, Incomplete, ReadableBuffer, SupportsKeysAndGetItem
+from _typeshed import IdentityFunction, ReadableBuffer, SupportsKeysAndGetItem
 from abc import ABCMeta, abstractmethod
-from contextlib import AbstractAsyncContextManager, AbstractContextManager
 from re import Match as Match, Pattern as Pattern
 from types import (
     BuiltinFunctionType,
     CodeType,
-    FrameType,
     FunctionType,
     MethodDescriptorType,
     MethodType,
@@ -18,12 +20,12 @@ from types import (
     TracebackType,
     WrapperDescriptorType,
 )
-from typing_extensions import Never as _Never, ParamSpec as _ParamSpec, final as _final
+from typing_extensions import Never as _Never, ParamSpec as _ParamSpec, deprecated
 
-if sys.version_info >= (3, 10):
-    from types import UnionType
 if sys.version_info >= (3, 9):
     from types import GenericAlias
+if sys.version_info >= (3, 10):
+    from types import UnionType
 
 __all__ = [
     "AbstractSet",
@@ -46,6 +48,7 @@ __all__ = [
     "DefaultDict",
     "Deque",
     "Dict",
+    "Final",
     "FrozenSet",
     "Generator",
     "Generic",
@@ -55,6 +58,7 @@ __all__ = [
     "Iterator",
     "KeysView",
     "List",
+    "Literal",
     "Mapping",
     "MappingView",
     "MutableMapping",
@@ -63,6 +67,7 @@ __all__ = [
     "NamedTuple",
     "NewType",
     "Optional",
+    "Protocol",
     "Reversible",
     "Sequence",
     "Set",
@@ -71,38 +76,31 @@ __all__ = [
     "SupportsBytes",
     "SupportsComplex",
     "SupportsFloat",
+    "SupportsIndex",
     "SupportsInt",
     "SupportsRound",
     "Text",
     "Tuple",
     "Type",
     "TypeVar",
+    "TypedDict",
     "Union",
     "ValuesView",
     "TYPE_CHECKING",
     "cast",
+    "final",
+    "get_args",
+    "get_origin",
     "get_type_hints",
     "no_type_check",
     "no_type_check_decorator",
     "overload",
+    "runtime_checkable",
     "ForwardRef",
     "NoReturn",
     "OrderedDict",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += [
-        "Final",
-        "Literal",
-        "Protocol",
-        "SupportsIndex",
-        "TypedDict",
-        "final",
-        "get_args",
-        "get_origin",
-        "runtime_checkable",
-    ]
-
 if sys.version_info >= (3, 9):
     __all__ += ["Annotated", "BinaryIO", "IO", "Match", "Pattern", "TextIO"]
 
@@ -126,15 +124,17 @@ if sys.version_info >= (3, 11):
         "reveal_type",
     ]
 
-ContextManager = AbstractContextManager
-AsyncContextManager = AbstractAsyncContextManager
+if sys.version_info >= (3, 12):
+    __all__ += ["TypeAliasType", "override"]
 
-# This itself is only available during type checking
-def type_check_only(func_or_cls: _F) -> _F: ...
+if sys.version_info >= (3, 13):
+    __all__ += ["get_protocol_members", "is_protocol", "NoDefault", "TypeIs", "ReadOnly"]
 
-Any = object()
+class Any: ...
+class _Final: ...
 
-@_final
+def final(f: _T) -> _T: ...
+@final
 class TypeVar:
     @property
     def __name__(self) -> str: ...
@@ -149,15 +149,34 @@ class TypeVar:
     if sys.version_info >= (3, 12):
         @property
         def __infer_variance__(self) -> bool: ...
-        def __init__(
-            self,
+    if sys.version_info >= (3, 13):
+        @property
+        def __default__(self) -> Any: ...
+    if sys.version_info >= (3, 13):
+        def __new__(
+            cls,
+            name: str,
+            *constraints: Any,
+            bound: Any | None = None,
+            contravariant: bool = False,
+            covariant: bool = False,
+            infer_variance: bool = False,
+            default: Any = ...,
+        ) -> Self: ...
+    elif sys.version_info >= (3, 12):
+        def __new__(
+            cls,
             name: str,
             *constraints: Any,
             bound: Any | None = None,
             covariant: bool = False,
             contravariant: bool = False,
             infer_variance: bool = False,
-        ) -> None: ...
+        ) -> Self: ...
+    elif sys.version_info >= (3, 11):
+        def __new__(
+            cls, name: str, *constraints: Any, bound: Any | None = None, covariant: bool = False, contravariant: bool = False
+        ) -> Self: ...
     else:
         def __init__(
             self, name: str, *constraints: Any, bound: Any | None = None, covariant: bool = False, contravariant: bool = False
@@ -166,25 +185,22 @@ class TypeVar:
         def __or__(self, right: Any) -> _SpecialForm: ...
         def __ror__(self, left: Any) -> _SpecialForm: ...
     if sys.version_info >= (3, 11):
-        def __typing_subst__(self, arg: Incomplete) -> Incomplete: ...
+        def __typing_subst__(self, arg: Any) -> Any: ...
+    if sys.version_info >= (3, 13):
+        def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
+        def has_default(self) -> bool: ...
 
 # Used for an undocumented mypy feature. Does not exist at runtime.
 _promote = object()
 
 # N.B. Keep this definition in sync with typing_extensions._SpecialForm
-@_final
-class _SpecialForm:
+@final
+class _SpecialForm(_Final):
     def __getitem__(self, parameters: Any) -> object: ...
     if sys.version_info >= (3, 10):
         def __or__(self, other: Any) -> _SpecialForm: ...
         def __ror__(self, other: Any) -> _SpecialForm: ...
 
-_F = TypeVar("_F", bound=Callable[..., Any])
-_P = _ParamSpec("_P")
-_T = TypeVar("_T")
-
-def overload(func: _F) -> _F: ...
-
 Union: _SpecialForm
 Generic: _SpecialForm
 # Protocol is only present in 3.8 and later, but mypy needs it unconditionally
@@ -196,12 +212,10 @@ ClassVar: _SpecialForm
 
 Optional: _SpecialForm
 Tuple: _SpecialForm
-if sys.version_info >= (3, 8):
-    Final: _SpecialForm
-    def final(f: _T) -> _T: ...
-    Literal: _SpecialForm
-    # TypedDict is a (non-subscriptable) special form.
-    TypedDict: object
+Final: _SpecialForm
+
+Literal: _SpecialForm
+TypedDict: _SpecialForm
 
 if sys.version_info >= (3, 11):
     Self: _SpecialForm
@@ -211,29 +225,51 @@ if sys.version_info >= (3, 11):
     NotRequired: _SpecialForm
     LiteralString: _SpecialForm
 
-    @_final
+    @final
     class TypeVarTuple:
         @property
         def __name__(self) -> str: ...
-        def __init__(self, name: str) -> None: ...
+        if sys.version_info >= (3, 13):
+            @property
+            def __default__(self) -> Any: ...
+            def has_default(self) -> bool: ...
+        if sys.version_info >= (3, 13):
+            def __new__(cls, name: str, *, default: Any = ...) -> Self: ...
+        elif sys.version_info >= (3, 12):
+            def __new__(cls, name: str) -> Self: ...
+        else:
+            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: ...
+        def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
 
 if sys.version_info >= (3, 10):
-    @_final
+    @final
     class ParamSpecArgs:
         @property
         def __origin__(self) -> ParamSpec: ...
-        def __init__(self, origin: ParamSpec) -> None: ...
+        if sys.version_info >= (3, 12):
+            def __new__(cls, origin: ParamSpec) -> Self: ...
+        else:
+            def __init__(self, origin: ParamSpec) -> None: ...
 
-    @_final
+        def __eq__(self, other: object) -> bool: ...
+        __hash__: ClassVar[None]  # type: ignore[assignment]
+
+    @final
     class ParamSpecKwargs:
         @property
         def __origin__(self) -> ParamSpec: ...
-        def __init__(self, origin: ParamSpec) -> None: ...
+        if sys.version_info >= (3, 12):
+            def __new__(cls, origin: ParamSpec) -> Self: ...
+        else:
+            def __init__(self, origin: ParamSpec) -> None: ...
+
+        def __eq__(self, other: object) -> bool: ...
+        __hash__: ClassVar[None]  # type: ignore[assignment]
 
-    @_final
+    @final
     class ParamSpec:
         @property
         def __name__(self) -> str: ...
@@ -246,15 +282,34 @@ if sys.version_info >= (3, 10):
         if sys.version_info >= (3, 12):
             @property
             def __infer_variance__(self) -> bool: ...
-            def __init__(
-                self,
+        if sys.version_info >= (3, 13):
+            @property
+            def __default__(self) -> Any: ...
+        if sys.version_info >= (3, 13):
+            def __new__(
+                cls,
                 name: str,
                 *,
                 bound: Any | None = None,
                 contravariant: bool = False,
                 covariant: bool = False,
                 infer_variance: bool = False,
-            ) -> None: ...
+                default: Any = ...,
+            ) -> Self: ...
+        elif sys.version_info >= (3, 12):
+            def __new__(
+                cls,
+                name: str,
+                *,
+                bound: Any | None = None,
+                contravariant: bool = False,
+                covariant: bool = False,
+                infer_variance: bool = False,
+            ) -> Self: ...
+        elif sys.version_info >= (3, 11):
+            def __new__(
+                cls, name: str, *, bound: Any | None = None, contravariant: bool = False, covariant: bool = False
+            ) -> Self: ...
         else:
             def __init__(
                 self, name: str, *, bound: Any | None = None, contravariant: bool = False, covariant: bool = False
@@ -265,39 +320,55 @@ if sys.version_info >= (3, 10):
         @property
         def kwargs(self) -> ParamSpecKwargs: ...
         if sys.version_info >= (3, 11):
-            def __typing_subst__(self, arg: Incomplete) -> Incomplete: ...
-            def __typing_prepare_subst__(self, alias: Incomplete, args: Incomplete) -> Incomplete: ...
+            def __typing_subst__(self, arg: Any) -> Any: ...
+            def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
 
         def __or__(self, right: Any) -> _SpecialForm: ...
         def __ror__(self, left: Any) -> _SpecialForm: ...
+        if sys.version_info >= (3, 13):
+            def has_default(self) -> bool: ...
+
     Concatenate: _SpecialForm
     TypeAlias: _SpecialForm
     TypeGuard: _SpecialForm
 
     class NewType:
         def __init__(self, name: str, tp: Any) -> None: ...
-        def __call__(self, __x: _T) -> _T: ...
+        if sys.version_info >= (3, 11):
+            @staticmethod
+            def __call__(x: _T, /) -> _T: ...
+        else:
+            def __call__(self, x: _T) -> _T: ...
+
         def __or__(self, other: Any) -> _SpecialForm: ...
         def __ror__(self, other: Any) -> _SpecialForm: ...
-        __supertype__: type
+        __supertype__: type | NewType
 
 else:
     def NewType(name: str, tp: Any) -> Any: ...
 
+_F = TypeVar("_F", bound=Callable[..., Any])
+_P = _ParamSpec("_P")
+_T = TypeVar("_T")
+
+_FT = TypeVar("_FT", bound=Callable[..., Any] | type)
+
 # These type variables are used by the container types.
 _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])
+_TC = TypeVar("_TC", bound=type[object])
 
+def overload(func: _F) -> _F: ...
 def no_type_check(arg: _F) -> _F: ...
 def no_type_check_decorator(decorator: Callable[_P, _T]) -> Callable[_P, _T]: ...
 
+# This itself is only available during type checking
+def type_check_only(func_or_cls: _FT) -> _FT: ...
+
 # Type aliases and type constructors
 
 class _Alias:
@@ -321,9 +392,9 @@ if sys.version_info >= (3, 9):
 # Predefined type variables.
 AnyStr = TypeVar("AnyStr", str, bytes)  # noqa: Y001
 
-# Technically in 3.7 this inherited from GenericMeta. But let's not reflect that, since
-# type checkers tend to assume that Protocols all have the ABCMeta metaclass.
-class _ProtocolMeta(ABCMeta): ...
+class _ProtocolMeta(ABCMeta):
+    if sys.version_info >= (3, 12):
+        def __init__(cls, *args: Any, **kwargs: Any) -> None: ...
 
 # Abstract base classes.
 
@@ -348,11 +419,10 @@ class SupportsBytes(Protocol, metaclass=ABCMeta):
     @abstractmethod
     def __bytes__(self) -> bytes: ...
 
-if sys.version_info >= (3, 8):
-    @runtime_checkable
-    class SupportsIndex(Protocol, metaclass=ABCMeta):
-        @abstractmethod
-        def __index__(self) -> int: ...
+@runtime_checkable
+class SupportsIndex(Protocol, metaclass=ABCMeta):
+    @abstractmethod
+    def __index__(self) -> int: ...
 
 @runtime_checkable
 class SupportsAbs(Protocol[_T_co]):
@@ -366,7 +436,7 @@ class SupportsRound(Protocol[_T_co]):
     def __round__(self) -> int: ...
     @overload
     @abstractmethod
-    def __round__(self, __ndigits: int) -> _T_co: ...
+    def __round__(self, ndigits: int, /) -> _T_co: ...
 
 @runtime_checkable
 class Sized(Protocol, metaclass=ABCMeta):
@@ -397,55 +467,65 @@ 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, default=None)
+_ReturnT_co = TypeVar("_ReturnT_co", covariant=True, default=None)
+
+@runtime_checkable
+class Generator(Iterator[_YieldT_co], Protocol[_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: ...
+        self, typ: type[BaseException], val: BaseException | object = None, tb: TracebackType | None = None, /
+    ) -> _YieldT_co: ...
     @overload
     @abstractmethod
-    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> _T_co: ...
-    def close(self) -> None: ...
-    def __iter__(self) -> Generator[_T_co, _T_contra, _V_co]: ...
-    @property
-    def gi_code(self) -> CodeType: ...
-    @property
-    def gi_frame(self) -> FrameType: ...
-    @property
-    def gi_running(self) -> bool: ...
-    @property
-    def gi_yieldfrom(self) -> Generator[Any, Any, Any] | None: ...
+    def throw(self, typ: BaseException, val: None = None, tb: TracebackType | None = None, /) -> _YieldT_co: ...
+    if sys.version_info >= (3, 13):
+        def close(self) -> _ReturnT_co | None: ...
+    else:
+        def close(self) -> None: ...
+
+    def __iter__(self) -> Generator[_YieldT_co, _SendT_contra, _ReturnT_co]: ...
+
+# NOTE: Prior to Python 3.13 these aliases are lacking the second _ExitT_co parameter
+if sys.version_info >= (3, 13):
+    from contextlib import AbstractAsyncContextManager as AsyncContextManager, AbstractContextManager as ContextManager
+else:
+    from contextlib import AbstractAsyncContextManager, AbstractContextManager
+
+    @runtime_checkable
+    class ContextManager(AbstractContextManager[_T_co, bool | None], Protocol[_T_co]): ...
+
+    @runtime_checkable
+    class AsyncContextManager(AbstractAsyncContextManager[_T_co, bool | None], Protocol[_T_co]): ...
 
 @runtime_checkable
 class Awaitable(Protocol[_T_co]):
     @abstractmethod
-    def __await__(self) -> Generator[Any, None, _T_co]: ...
+    def __await__(self) -> Generator[Any, Any, _T_co]: ...
+
+# Non-default variations to accommodate couroutines, and `AwaitableGenerator` having a 4th type parameter.
+_SendT_nd_contra = TypeVar("_SendT_nd_contra", contravariant=True)
+_ReturnT_nd_co = TypeVar("_ReturnT_nd_co", covariant=True)
 
-class Coroutine(Awaitable[_V_co], Generic[_T_co, _T_contra, _V_co]):
+class Coroutine(Awaitable[_ReturnT_nd_co], Generic[_YieldT_co, _SendT_nd_contra, _ReturnT_nd_co]):
     __name__: str
     __qualname__: str
-    @property
-    def cr_await(self) -> Any | None: ...
-    @property
-    def cr_code(self) -> CodeType: ...
-    @property
-    def cr_frame(self) -> FrameType: ...
-    @property
-    def cr_running(self) -> bool: ...
+
     @abstractmethod
-    def send(self, __value: _T_contra) -> _T_co: ...
+    def send(self, value: _SendT_nd_contra, /) -> _YieldT_co: ...
     @overload
     @abstractmethod
     def throw(
-        self, __typ: Type[BaseException], __val: BaseException | object = None, __tb: TracebackType | None = None
-    ) -> _T_co: ...
+        self, typ: type[BaseException], val: BaseException | object = None, tb: TracebackType | None = None, /
+    ) -> _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 +533,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_nd_co],
+    Generator[_YieldT_co, _SendT_nd_contra, _ReturnT_nd_co],
+    Generic[_YieldT_co, _SendT_nd_contra, _ReturnT_nd_co, _S],
+    metaclass=ABCMeta,
 ): ...
 
 @runtime_checkable
@@ -467,33 +550,28 @@ 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]: ...
+@runtime_checkable
+class AsyncGenerator(AsyncIterator[_YieldT_co], Protocol[_YieldT_co, _SendT_contra]):
+    def __anext__(self) -> Coroutine[Any, Any, _YieldT_co]: ...
     @abstractmethod
-    def asend(self, __value: _T_contra) -> Awaitable[_T_co]: ...
+    def asend(self, value: _SendT_contra, /) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload
     @abstractmethod
     def athrow(
-        self, __typ: Type[BaseException], __val: BaseException | object = None, __tb: TracebackType | None = None
-    ) -> Awaitable[_T_co]: ...
+        self, typ: type[BaseException], val: BaseException | object = None, tb: TracebackType | None = None, /
+    ) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload
     @abstractmethod
-    def athrow(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> Awaitable[_T_co]: ...
-    def aclose(self) -> Awaitable[None]: ...
-    @property
-    def ag_await(self) -> Any: ...
-    @property
-    def ag_code(self) -> CodeType: ...
-    @property
-    def ag_frame(self) -> FrameType: ...
-    @property
-    def ag_running(self) -> bool: ...
+    def athrow(
+        self, typ: BaseException, val: None = None, tb: TracebackType | None = None, /
+    ) -> Coroutine[Any, Any, _YieldT_co]: ...
+    def aclose(self) -> Coroutine[Any, Any, None]: ...
 
 @runtime_checkable
 class Container(Protocol[_T_co]):
     # This is generic more on vibes than anything else
     @abstractmethod
-    def __contains__(self, __x: object) -> bool: ...
+    def __contains__(self, x: object, /) -> bool: ...
 
 @runtime_checkable
 class Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]):
@@ -501,7 +579,7 @@ class Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]):
     @abstractmethod
     def __len__(self) -> int: ...
 
-class Sequence(Collection[_T_co], Reversible[_T_co], Generic[_T_co]):
+class Sequence(Reversible[_T_co], Collection[_T_co]):
     @overload
     @abstractmethod
     def __getitem__(self, index: int) -> _T_co: ...
@@ -515,7 +593,7 @@ class Sequence(Collection[_T_co], Reversible[_T_co], Generic[_T_co]):
     def __iter__(self) -> Iterator[_T_co]: ...
     def __reversed__(self) -> Iterator[_T_co]: ...
 
-class MutableSequence(Sequence[_T], Generic[_T]):
+class MutableSequence(Sequence[_T]):
     @abstractmethod
     def insert(self, index: int, value: _T) -> None: ...
     @overload
@@ -545,7 +623,7 @@ class MutableSequence(Sequence[_T], Generic[_T]):
     def remove(self, value: _T) -> None: ...
     def __iadd__(self, values: Iterable[_T]) -> typing_extensions.Self: ...
 
-class AbstractSet(Collection[_T_co], Generic[_T_co]):
+class AbstractSet(Collection[_T_co]):
     @abstractmethod
     def __contains__(self, x: object) -> bool: ...
     def _hash(self) -> int: ...
@@ -558,9 +636,10 @@ class AbstractSet(Collection[_T_co], Generic[_T_co]):
     def __or__(self, other: AbstractSet[_T]) -> AbstractSet[_T_co | _T]: ...
     def __sub__(self, other: AbstractSet[Any]) -> AbstractSet[_T_co]: ...
     def __xor__(self, other: AbstractSet[_T]) -> AbstractSet[_T_co | _T]: ...
+    def __eq__(self, other: object) -> bool: ...
     def isdisjoint(self, other: Iterable[Any]) -> bool: ...
 
-class MutableSet(AbstractSet[_T], Generic[_T]):
+class MutableSet(AbstractSet[_T]):
     @abstractmethod
     def add(self, value: _T) -> None: ...
     @abstractmethod
@@ -584,9 +663,6 @@ class ItemsView(MappingView, AbstractSet[tuple[_KT_co, _VT_co]], Generic[_KT_co,
     def __rand__(self, other: Iterable[_T]) -> set[_T]: ...
     def __contains__(self, item: object) -> bool: ...
     def __iter__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...
-    if sys.version_info >= (3, 8):
-        def __reversed__(self) -> Iterator[tuple[_KT_co, _VT_co]]: ...
-
     def __or__(self, other: Iterable[_T]) -> set[tuple[_KT_co, _VT_co] | _T]: ...
     def __ror__(self, other: Iterable[_T]) -> set[tuple[_KT_co, _VT_co] | _T]: ...
     def __sub__(self, other: Iterable[Any]) -> set[tuple[_KT_co, _VT_co]]: ...
@@ -594,15 +670,12 @@ class ItemsView(MappingView, AbstractSet[tuple[_KT_co, _VT_co]], Generic[_KT_co,
     def __xor__(self, other: Iterable[_T]) -> set[tuple[_KT_co, _VT_co] | _T]: ...
     def __rxor__(self, other: Iterable[_T]) -> set[tuple[_KT_co, _VT_co] | _T]: ...
 
-class KeysView(MappingView, AbstractSet[_KT_co], Generic[_KT_co]):
+class KeysView(MappingView, AbstractSet[_KT_co]):
     def __init__(self, mapping: Mapping[_KT_co, Any]) -> None: ...  # undocumented
     def __and__(self, other: Iterable[Any]) -> set[_KT_co]: ...
     def __rand__(self, other: Iterable[_T]) -> set[_T]: ...
     def __contains__(self, key: object) -> bool: ...
     def __iter__(self) -> Iterator[_KT_co]: ...
-    if sys.version_info >= (3, 8):
-        def __reversed__(self) -> Iterator[_KT_co]: ...
-
     def __or__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
     def __ror__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
     def __sub__(self, other: Iterable[Any]) -> set[_KT_co]: ...
@@ -610,38 +683,39 @@ class KeysView(MappingView, AbstractSet[_KT_co], Generic[_KT_co]):
     def __xor__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
     def __rxor__(self, other: Iterable[_T]) -> set[_KT_co | _T]: ...
 
-class ValuesView(MappingView, Collection[_VT_co], Generic[_VT_co]):
+class ValuesView(MappingView, Collection[_VT_co]):
     def __init__(self, mapping: Mapping[Any, _VT_co]) -> None: ...  # undocumented
     def __contains__(self, value: object) -> bool: ...
     def __iter__(self) -> Iterator[_VT_co]: ...
-    if sys.version_info >= (3, 8):
-        def __reversed__(self) -> Iterator[_VT_co]: ...
 
 class Mapping(Collection[_KT], Generic[_KT, _VT_co]):
     # TODO: We wish the key type could also be covariant, but that doesn't work,
     # see discussion in https://github.com/python/typing/pull/273.
     @abstractmethod
-    def __getitem__(self, __key: _KT) -> _VT_co: ...
+    def __getitem__(self, key: _KT, /) -> _VT_co: ...
     # Mixin methods
     @overload
-    def get(self, __key: _KT) -> _VT_co | None: ...
+    def get(self, key: _KT, /) -> _VT_co | None: ...
     @overload
-    def get(self, __key: _KT, default: _VT_co | _T) -> _VT_co | _T: ...
+    def get(self, key: _KT, /, default: _VT_co | _T) -> _VT_co | _T: ...
     def items(self) -> ItemsView[_KT, _VT_co]: ...
     def keys(self) -> KeysView[_KT]: ...
     def values(self) -> ValuesView[_VT_co]: ...
-    def __contains__(self, __key: object) -> bool: ...
+    def __contains__(self, key: object, /) -> bool: ...
+    def __eq__(self, other: object, /) -> bool: ...
 
-class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]):
+class MutableMapping(Mapping[_KT, _VT]):
     @abstractmethod
-    def __setitem__(self, __key: _KT, __value: _VT) -> None: ...
+    def __setitem__(self, key: _KT, value: _VT, /) -> None: ...
     @abstractmethod
-    def __delitem__(self, __key: _KT) -> None: ...
+    def __delitem__(self, key: _KT, /) -> None: ...
     def clear(self) -> None: ...
     @overload
-    def pop(self, __key: _KT) -> _VT: ...
+    def pop(self, key: _KT, /) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, /, default: _VT) -> _VT: ...
     @overload
-    def pop(self, __key: _KT, default: _VT | _T) -> _VT | _T: ...
+    def pop(self, key: _KT, /, default: _T) -> _VT | _T: ...
     def popitem(self) -> tuple[_KT, _VT]: ...
     # This overload should be allowed only if the value type is compatible with None.
     #
@@ -650,9 +724,9 @@ class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]):
     # -- collections.ChainMap.setdefault
     # -- weakref.WeakKeyDictionary.setdefault
     @overload
-    def setdefault(self: MutableMapping[_KT, _T | None], __key: _KT, __default: None = None) -> _T | None: ...
+    def setdefault(self: MutableMapping[_KT, _T | None], key: _KT, default: None = None, /) -> _T | None: ...
     @overload
-    def setdefault(self, __key: _KT, __default: _VT) -> _VT: ...
+    def setdefault(self, key: _KT, default: _VT, /) -> _VT: ...
     # 'update' used to take a Union, but using overloading is better.
     # The second overloaded type here is a bit too general, because
     # Mapping[tuple[_KT, _VT], W] is a subclass of Iterable[tuple[_KT, _VT]],
@@ -674,27 +748,29 @@ class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]):
     # -- weakref.WeakValueDictionary.__ior__
     # -- weakref.WeakKeyDictionary.__ior__
     @overload
-    def update(self, __m: SupportsKeysAndGetItem[_KT, _VT], **kwargs: _VT) -> None: ...
+    def update(self, m: SupportsKeysAndGetItem[_KT, _VT], /, **kwargs: _VT) -> None: ...
     @overload
-    def update(self, __m: Iterable[tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+    def update(self, m: Iterable[tuple[_KT, _VT]], /, **kwargs: _VT) -> None: ...
     @overload
     def update(self, **kwargs: _VT) -> None: ...
 
 Text = str
 
-TYPE_CHECKING: bool
+TYPE_CHECKING: Final[bool]
 
 # In stubs, the arguments of the IO class are marked as positional-only.
 # This differs from runtime, but better reflects the fact that in reality
 # classes deriving from IO use different names for the arguments.
-class IO(Iterator[AnyStr], Generic[AnyStr]):
+class IO(Generic[AnyStr]):
     # At runtime these are all abstract properties,
     # but making them abstract in the stub is hugely disruptive, for not much gain.
     # See #8726
     @property
     def mode(self) -> str: ...
+    # Usually str, but may be bytes if a bytes path was passed to open(). See #10737.
+    # If PEP 696 becomes available, we may want to use a defaulted TypeVar here.
     @property
-    def name(self) -> str: ...
+    def name(self) -> str | Any: ...
     @abstractmethod
     def close(self) -> None: ...
     @property
@@ -706,41 +782,35 @@ class IO(Iterator[AnyStr], Generic[AnyStr]):
     @abstractmethod
     def isatty(self) -> bool: ...
     @abstractmethod
-    def read(self, __n: int = -1) -> AnyStr: ...
+    def read(self, n: int = -1, /) -> AnyStr: ...
     @abstractmethod
     def readable(self) -> bool: ...
     @abstractmethod
-    def readline(self, __limit: int = -1) -> AnyStr: ...
+    def readline(self, limit: int = -1, /) -> AnyStr: ...
     @abstractmethod
-    def readlines(self, __hint: int = -1) -> list[AnyStr]: ...
+    def readlines(self, hint: int = -1, /) -> list[AnyStr]: ...
     @abstractmethod
-    def seek(self, __offset: int, __whence: int = 0) -> int: ...
+    def seek(self, offset: int, whence: int = 0, /) -> int: ...
     @abstractmethod
     def seekable(self) -> bool: ...
     @abstractmethod
     def tell(self) -> int: ...
     @abstractmethod
-    def truncate(self, __size: int | None = None) -> int: ...
+    def truncate(self, size: int | None = None, /) -> int: ...
     @abstractmethod
     def writable(self) -> bool: ...
     @abstractmethod
     @overload
-    def write(self: IO[str], __s: str) -> int: ...
-    @abstractmethod
-    @overload
-    def write(self: IO[bytes], __s: ReadableBuffer) -> int: ...
-    @abstractmethod
-    @overload
-    def write(self, __s: AnyStr) -> int: ...
+    def write(self: IO[bytes], s: ReadableBuffer, /) -> int: ...
     @abstractmethod
     @overload
-    def writelines(self: IO[str], __lines: Iterable[str]) -> None: ...
+    def write(self, s: AnyStr, /) -> int: ...
     @abstractmethod
     @overload
-    def writelines(self: IO[bytes], __lines: Iterable[ReadableBuffer]) -> None: ...
+    def writelines(self: IO[bytes], lines: Iterable[ReadableBuffer], /) -> None: ...
     @abstractmethod
     @overload
-    def writelines(self, __lines: Iterable[AnyStr]) -> None: ...
+    def writelines(self, lines: Iterable[AnyStr], /) -> None: ...
     @abstractmethod
     def __next__(self) -> AnyStr: ...
     @abstractmethod
@@ -749,7 +819,7 @@ class IO(Iterator[AnyStr], Generic[AnyStr]):
     def __enter__(self) -> IO[AnyStr]: ...
     @abstractmethod
     def __exit__(
-        self, __type: Type[BaseException] | None, __value: BaseException | None, __traceback: TracebackType | None
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None, /
     ) -> None: ...
 
 class BinaryIO(IO[bytes]):
@@ -771,7 +841,8 @@ class TextIO(IO[str]):
     @abstractmethod
     def __enter__(self) -> TextIO: ...
 
-ByteString: typing_extensions.TypeAlias = bytes | bytearray | memoryview
+if sys.version_info < (3, 14):
+    ByteString: typing_extensions.TypeAlias = bytes | bytearray | memoryview
 
 # Functions
 
@@ -791,42 +862,43 @@ if sys.version_info >= (3, 9):
     def get_type_hints(
         obj: _get_type_hints_obj_allowed_types,
         globalns: dict[str, Any] | None = None,
-        localns: dict[str, Any] | None = None,
+        localns: Mapping[str, Any] | None = None,
         include_extras: bool = False,
     ) -> dict[str, Any]: ...
 
 else:
     def get_type_hints(
-        obj: _get_type_hints_obj_allowed_types, globalns: dict[str, Any] | None = None, localns: dict[str, Any] | None = None
+        obj: _get_type_hints_obj_allowed_types, globalns: dict[str, Any] | None = None, localns: Mapping[str, Any] | None = None
     ) -> dict[str, Any]: ...
 
-if sys.version_info >= (3, 8):
-    def get_args(tp: Any) -> tuple[Any, ...]: ...
+def get_args(tp: Any) -> tuple[Any, ...]: ...
 
-    if sys.version_info >= (3, 10):
-        @overload
-        def get_origin(tp: ParamSpecArgs | ParamSpecKwargs) -> ParamSpec: ...
-        @overload
-        def get_origin(tp: UnionType) -> type[UnionType]: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def get_origin(tp: GenericAlias) -> type: ...
-        @overload
-        def get_origin(tp: Any) -> Any | None: ...
-    else:
-        def get_origin(tp: Any) -> Any | None: ...
+if sys.version_info >= (3, 10):
+    @overload
+    def get_origin(tp: ParamSpecArgs | ParamSpecKwargs) -> ParamSpec: ...
+    @overload
+    def get_origin(tp: UnionType) -> type[UnionType]: ...
+
+if sys.version_info >= (3, 9):
+    @overload
+    def get_origin(tp: GenericAlias) -> type: ...
+    @overload
+    def get_origin(tp: Any) -> Any | None: ...
+
+else:
+    def get_origin(tp: Any) -> Any | None: ...
 
 @overload
-def cast(typ: Type[_T], val: Any) -> _T: ...
+def cast(typ: type[_T], val: Any) -> _T: ...
 @overload
 def cast(typ: str, val: Any) -> Any: ...
 @overload
 def cast(typ: object, val: Any) -> Any: ...
 
 if sys.version_info >= (3, 11):
-    def reveal_type(__obj: _T) -> _T: ...
-    def assert_never(__arg: Never) -> Never: ...
-    def assert_type(__val: _T, __typ: Any) -> _T: ...
+    def reveal_type(obj: _T, /) -> _T: ...
+    def assert_never(arg: Never, /) -> Never: ...
+    def assert_type(val: _T, typ: Any, /) -> _T: ...
     def clear_overloads() -> None: ...
     def get_overloads(func: Callable[..., object]) -> Sequence[Callable[..., object]]: ...
     def dataclass_transform(
@@ -842,9 +914,7 @@ if sys.version_info >= (3, 11):
 # Type constructors
 
 class NamedTuple(tuple[Any, ...]):
-    if sys.version_info < (3, 8):
-        _field_types: ClassVar[collections.OrderedDict[str, type]]
-    elif sys.version_info < (3, 9):
+    if sys.version_info < (3, 9):
         _field_types: ClassVar[dict[str, type]]
     _field_defaults: ClassVar[dict[str, Any]]
     _fields: ClassVar[tuple[str, ...]]
@@ -852,18 +922,20 @@ class NamedTuple(tuple[Any, ...]):
     # 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: ...
+    def __init__(self, typename: str, fields: Iterable[tuple[str, Any]], /) -> None: ...
     @overload
-    def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None: ...
+    @typing_extensions.deprecated(
+        "Creating a typing.NamedTuple using keyword arguments is deprecated and support will be removed in Python 3.15"
+    )
+    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):
-        def _asdict(self) -> dict[str, Any]: ...
-    else:
-        def _asdict(self) -> collections.OrderedDict[str, Any]: ...
-
+    def _asdict(self) -> dict[str, Any]: ...
     def _replace(self, **kwargs: Any) -> typing_extensions.Self: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, **kwargs: Any) -> typing_extensions.Self: ...
 
 # Internal mypy fallback type for all typed dicts (does not exist at runtime)
 # N.B. Keep this mostly in sync with typing_extensions._TypedDict/mypy_extensions._TypedDict
@@ -877,23 +949,35 @@ class _TypedDict(Mapping[str, object], metaclass=ABCMeta):
     # so we only add it to the stub on 3.12+
     if sys.version_info >= (3, 12):
         __orig_bases__: ClassVar[tuple[Any, ...]]
+    if sys.version_info >= (3, 13):
+        __readonly_keys__: ClassVar[frozenset[str]]
+        __mutable_keys__: ClassVar[frozenset[str]]
+
     def copy(self) -> typing_extensions.Self: ...
     # Using Never so that only calls using mypy plugin hook that specialize the signature
     # can go through.
     def setdefault(self, k: _Never, default: object) -> object: ...
     # Mypy plugin hook for 'pop' expects that 'default' has a type variable type.
     def pop(self, k: _Never, default: _T = ...) -> object: ...  # pyright: ignore[reportInvalidTypeVarUse]
-    def update(self: _T, __m: _T) -> None: ...
+    def update(self, m: typing_extensions.Self, /) -> None: ...
     def __delitem__(self, k: _Never) -> None: ...
     def items(self) -> dict_items[str, object]: ...
     def keys(self) -> dict_keys[str, object]: ...
     def values(self) -> dict_values[str, object]: ...
     if sys.version_info >= (3, 9):
-        def __or__(self, __value: typing_extensions.Self) -> typing_extensions.Self: ...
-        def __ior__(self, __value: typing_extensions.Self) -> typing_extensions.Self: ...
+        @overload
+        def __or__(self, value: typing_extensions.Self, /) -> typing_extensions.Self: ...
+        @overload
+        def __or__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        @overload
+        def __ror__(self, value: typing_extensions.Self, /) -> typing_extensions.Self: ...
+        @overload
+        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        # supposedly incompatible definitions of __or__ and __ior__
+        def __ior__(self, value: typing_extensions.Self, /) -> typing_extensions.Self: ...  # type: ignore[misc]
 
-@_final
-class ForwardRef:
+@final
+class ForwardRef(_Final):
     __forward_arg__: str
     __forward_code__: CodeType
     __forward_evaluated__: bool
@@ -907,14 +991,43 @@ class ForwardRef:
     else:
         def __init__(self, arg: str, is_argument: bool = True) -> None: ...
 
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 13):
+        @overload
+        @deprecated(
+            "Failing to pass a value to the 'type_params' parameter of ForwardRef._evaluate() is deprecated, "
+            "as it leads to incorrect behaviour when evaluating a stringified annotation "
+            "that references a PEP 695 type parameter. It will be disallowed in Python 3.15."
+        )
         def _evaluate(
-            self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None, recursive_guard: frozenset[str]
+            self, globalns: dict[str, Any] | None, localns: Mapping[str, Any] | None, *, recursive_guard: frozenset[str]
+        ) -> Any | None: ...
+        @overload
+        def _evaluate(
+            self,
+            globalns: dict[str, Any] | None,
+            localns: Mapping[str, Any] | None,
+            type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...],
+            *,
+            recursive_guard: frozenset[str],
+        ) -> Any | None: ...
+    elif sys.version_info >= (3, 12):
+        def _evaluate(
+            self,
+            globalns: dict[str, Any] | None,
+            localns: Mapping[str, Any] | None,
+            type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] | None = None,
+            *,
+            recursive_guard: frozenset[str],
+        ) -> Any | None: ...
+    elif sys.version_info >= (3, 9):
+        def _evaluate(
+            self, globalns: dict[str, Any] | None, localns: Mapping[str, Any] | None, recursive_guard: frozenset[str]
         ) -> Any | None: ...
     else:
-        def _evaluate(self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None) -> Any | None: ...
+        def _evaluate(self, globalns: dict[str, Any] | None, localns: Mapping[str, Any] | None) -> Any | None: ...
 
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
     if sys.version_info >= (3, 11):
         def __or__(self, other: Any) -> _SpecialForm: ...
         def __ror__(self, other: Any) -> _SpecialForm: ...
@@ -925,12 +1038,10 @@ if sys.version_info >= (3, 10):
 def _type_repr(obj: object) -> str: ...
 
 if sys.version_info >= (3, 12):
-    def override(__arg: _F) -> _F: ...
-    @_final
+    def override(method: _F, /) -> _F: ...
+    @final
     class TypeAliasType:
-        def __init__(
-            self, name: str, value: Any, *, type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] = ()
-        ) -> None: ...
+        def __new__(cls, name: str, value: Any, *, type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] = ()) -> Self: ...
         @property
         def __value__(self) -> Any: ...
         @property
@@ -942,7 +1053,16 @@ if sys.version_info >= (3, 12):
         # 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: ...
+        def __getitem__(self, parameters: Any) -> GenericAlias: ...
+        def __or__(self, right: Any) -> _SpecialForm: ...
+        def __ror__(self, left: Any) -> _SpecialForm: ...
+
+if sys.version_info >= (3, 13):
+    def is_protocol(tp: type, /) -> bool: ...
+    def get_protocol_members(tp: type, /) -> frozenset[str]: ...
+    @final
+    class _NoDefaultType: ...
+
+    NoDefault: _NoDefaultType
+    TypeIs: _SpecialForm
+    ReadOnly: _SpecialForm
diff --git a/mypy/typeshed/stdlib/typing_extensions.pyi b/mypy/typeshed/stdlib/typing_extensions.pyi
index 93087a45a108..f3b7b8ddf5b1 100644
--- a/mypy/typeshed/stdlib/typing_extensions.pyi
+++ b/mypy/typeshed/stdlib/typing_extensions.pyi
@@ -1,38 +1,66 @@
 import abc
-import collections
+import enum
 import sys
 import typing
 from _collections_abc import dict_items, dict_keys, dict_values
-from _typeshed import IdentityFunction, Incomplete
-from collections.abc import Iterable
-from typing import (  # noqa: Y022,Y039
+from _typeshed import IdentityFunction, Incomplete, Unused
+from contextlib import AbstractAsyncContextManager as AsyncContextManager, AbstractContextManager as ContextManager
+from types import ModuleType
+from typing import (  # noqa: Y022,Y037,Y038,Y039
+    IO as IO,
     TYPE_CHECKING as TYPE_CHECKING,
+    AbstractSet as AbstractSet,
     Any as Any,
-    AsyncContextManager as AsyncContextManager,
+    AnyStr as AnyStr,
     AsyncGenerator as AsyncGenerator,
     AsyncIterable as AsyncIterable,
     AsyncIterator as AsyncIterator,
     Awaitable as Awaitable,
-    Callable,
+    BinaryIO as BinaryIO,
+    Callable as Callable,
     ChainMap as ChainMap,
     ClassVar as ClassVar,
-    ContextManager as ContextManager,
+    Collection as Collection,
+    Container as Container,
     Coroutine as Coroutine,
     Counter as Counter,
     DefaultDict as DefaultDict,
     Deque as Deque,
-    Mapping,
+    Dict as Dict,
+    ForwardRef as ForwardRef,
+    FrozenSet as FrozenSet,
+    Generator as Generator,
+    Generic as Generic,
+    Hashable as Hashable,
+    ItemsView as ItemsView,
+    Iterable as Iterable,
+    Iterator as Iterator,
+    KeysView as KeysView,
+    List as List,
+    Mapping as Mapping,
+    MappingView as MappingView,
+    Match as Match,
+    MutableMapping as MutableMapping,
+    MutableSequence as MutableSequence,
+    MutableSet as MutableSet,
     NoReturn as NoReturn,
-    Sequence,
-    SupportsAbs as SupportsAbs,
-    SupportsBytes as SupportsBytes,
-    SupportsComplex as SupportsComplex,
-    SupportsFloat as SupportsFloat,
-    SupportsInt as SupportsInt,
-    SupportsRound as SupportsRound,
+    Optional as Optional,
+    Pattern as Pattern,
+    Reversible as Reversible,
+    Sequence as Sequence,
+    Set as Set,
+    Sized as Sized,
     Text as Text,
+    TextIO as TextIO,
+    Tuple as Tuple,
     Type as Type,
+    TypedDict as TypedDict,
+    Union as Union,
+    ValuesView as ValuesView,
     _Alias,
+    cast as cast,
+    no_type_check as no_type_check,
+    no_type_check_decorator as no_type_check_decorator,
     overload as overload,
     type_check_only,
 )
@@ -42,9 +70,10 @@ if sys.version_info >= (3, 10):
 if sys.version_info >= (3, 9):
     from types import GenericAlias
 
+# Please keep order the same as at runtime.
 __all__ = [
+    # Super-special typing primitives.
     "Any",
-    "Buffer",
     "ClassVar",
     "Concatenate",
     "Final",
@@ -57,13 +86,16 @@ __all__ = [
     "TypeVar",
     "TypeVarTuple",
     "Unpack",
+    # ABCs (from collections.abc).
     "Awaitable",
     "AsyncIterator",
     "AsyncIterable",
     "Coroutine",
     "AsyncGenerator",
     "AsyncContextManager",
+    "Buffer",
     "ChainMap",
+    # Concrete collection types.
     "ContextManager",
     "Counter",
     "Deque",
@@ -71,20 +103,34 @@ __all__ = [
     "NamedTuple",
     "OrderedDict",
     "TypedDict",
-    "SupportsIndex",
+    # Structural checks, a.k.a. protocols.
     "SupportsAbs",
-    "SupportsRound",
     "SupportsBytes",
     "SupportsComplex",
     "SupportsFloat",
+    "SupportsIndex",
     "SupportsInt",
+    "SupportsRound",
+    # One-off things.
     "Annotated",
     "assert_never",
     "assert_type",
+    "clear_overloads",
     "dataclass_transform",
     "deprecated",
+    "Doc",
+    "evaluate_forward_ref",
+    "get_overloads",
     "final",
+    "Format",
+    "get_annotations",
+    "get_args",
+    "get_origin",
+    "get_original_bases",
+    "get_protocol_members",
+    "get_type_hints",
     "IntVar",
+    "is_protocol",
     "is_typeddict",
     "Literal",
     "NewType",
@@ -97,26 +143,68 @@ __all__ = [
     "Text",
     "TypeAlias",
     "TypeAliasType",
+    "TypeForm",
     "TypeGuard",
+    "TypeIs",
     "TYPE_CHECKING",
     "Never",
     "NoReturn",
+    "ReadOnly",
     "Required",
     "NotRequired",
-    "clear_overloads",
-    "get_args",
-    "get_origin",
-    "get_original_bases",
-    "get_overloads",
-    "get_type_hints",
+    "NoDefault",
+    "NoExtraItems",
+    # Pure aliases, have always been in typing
+    "AbstractSet",
+    "AnyStr",
+    "BinaryIO",
+    "Callable",
+    "Collection",
+    "Container",
+    "Dict",
+    "ForwardRef",
+    "FrozenSet",
+    "Generator",
+    "Generic",
+    "Hashable",
+    "IO",
+    "ItemsView",
+    "Iterable",
+    "Iterator",
+    "KeysView",
+    "List",
+    "Mapping",
+    "MappingView",
+    "Match",
+    "MutableMapping",
+    "MutableSequence",
+    "MutableSet",
+    "Optional",
+    "Pattern",
+    "Reversible",
+    "Sequence",
+    "Set",
+    "Sized",
+    "TextIO",
+    "Tuple",
+    "Union",
+    "ValuesView",
+    "cast",
+    "no_type_check",
+    "no_type_check_decorator",
+    # Added dynamically
+    "CapsuleType",
 ]
 
 _T = typing.TypeVar("_T")
 _F = typing.TypeVar("_F", bound=Callable[..., Any])
-_TC = typing.TypeVar("_TC", bound=Type[object])
+_TC = typing.TypeVar("_TC", bound=type[object])
+_T_co = typing.TypeVar("_T_co", covariant=True)  # Any type covariant containers.
+
+class _Final: ...  # This should be imported from typing but that breaks pytype
 
 # unfortunately we have to duplicate this class definition from typing.pyi or we break pytype
-class _SpecialForm:
+class _SpecialForm(_Final):
     def __getitem__(self, parameters: Any) -> object: ...
     if sys.version_info >= (3, 10):
         def __or__(self, other: Any) -> _SpecialForm: ...
@@ -149,30 +237,42 @@ class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta):
     __optional_keys__: ClassVar[frozenset[str]]
     __total__: ClassVar[bool]
     __orig_bases__: ClassVar[tuple[Any, ...]]
+    # PEP 705
+    __readonly_keys__: ClassVar[frozenset[str]]
+    __mutable_keys__: ClassVar[frozenset[str]]
+    # PEP 728
+    __closed__: ClassVar[bool]
+    __extra_items__: ClassVar[Any]
     def copy(self) -> Self: ...
     # Using Never so that only calls using mypy plugin hook that specialize the signature
     # can go through.
     def setdefault(self, k: Never, default: object) -> object: ...
     # Mypy plugin hook for 'pop' expects that 'default' has a type variable type.
     def pop(self, k: Never, default: _T = ...) -> object: ...  # pyright: ignore[reportInvalidTypeVarUse]
-    def update(self: _T, __m: _T) -> None: ...
+    def update(self, m: Self, /) -> None: ...
     def items(self) -> dict_items[str, object]: ...
     def keys(self) -> dict_keys[str, object]: ...
     def values(self) -> dict_values[str, object]: ...
     def __delitem__(self, k: Never) -> None: ...
     if sys.version_info >= (3, 9):
-        def __or__(self, __value: Self) -> Self: ...
-        def __ior__(self, __value: Self) -> Self: ...
-
-# TypedDict is a (non-subscriptable) special form.
-TypedDict: object
+        @overload
+        def __or__(self, value: Self, /) -> Self: ...
+        @overload
+        def __or__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        @overload
+        def __ror__(self, value: Self, /) -> Self: ...
+        @overload
+        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]: ...
+        # supposedly incompatible definitions of `__ior__` and `__or__`:
+        # Since this module defines "Self" it is not recognized by Ruff as typing_extensions.Self
+        def __ior__(self, value: Self, /) -> Self: ...  # type: ignore[misc]
 
 OrderedDict = _Alias()
 
 def get_type_hints(
     obj: Callable[..., Any],
     globalns: dict[str, Any] | None = None,
-    localns: dict[str, Any] | None = None,
+    localns: Mapping[str, Any] | None = None,
     include_extras: bool = False,
 ) -> dict[str, Any]: ...
 def get_args(tp: Any) -> tuple[Any, ...]: ...
@@ -193,16 +293,10 @@ def get_origin(tp: Any) -> Any | None: ...
 Annotated: _SpecialForm
 _AnnotatedAlias: Any  # undocumented
 
-@runtime_checkable
-class SupportsIndex(Protocol, metaclass=abc.ABCMeta):
-    @abc.abstractmethod
-    def __index__(self) -> int: ...
-
 # 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,
@@ -227,18 +321,13 @@ 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
+# New and changed things in 3.11
 if sys.version_info >= (3, 11):
     from typing import (
         LiteralString as LiteralString,
         NamedTuple as NamedTuple,
         Never as Never,
+        NewType as NewType,
         NotRequired as NotRequired,
         Required as Required,
         Self as Self,
@@ -253,9 +342,9 @@ if sys.version_info >= (3, 11):
 else:
     Self: _SpecialForm
     Never: _SpecialForm
-    def reveal_type(__obj: _T) -> _T: ...
-    def assert_never(__arg: Never) -> Never: ...
-    def assert_type(__val: _T, __typ: Any) -> _T: ...
+    def reveal_type(obj: _T, /) -> _T: ...
+    def assert_never(arg: Never, /) -> Never: ...
+    def assert_type(val: _T, typ: Any, /) -> _T: ...
     def clear_overloads() -> None: ...
     def get_overloads(func: Callable[..., object]) -> Sequence[Callable[..., object]]: ...
 
@@ -275,9 +364,7 @@ else:
     ) -> IdentityFunction: ...
 
     class NamedTuple(tuple[Any, ...]):
-        if sys.version_info < (3, 8):
-            _field_types: ClassVar[collections.OrderedDict[str, type]]
-        elif sys.version_info < (3, 9):
+        if sys.version_info < (3, 9):
             _field_types: ClassVar[dict[str, type]]
         _field_defaults: ClassVar[dict[str, Any]]
         _fields: ClassVar[tuple[str, ...]]
@@ -288,118 +375,258 @@ else:
         def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None: ...
         @classmethod
         def _make(cls, iterable: Iterable[Any]) -> Self: ...
-        if sys.version_info >= (3, 8):
-            def _asdict(self) -> dict[str, Any]: ...
-        else:
-            def _asdict(self) -> collections.OrderedDict[str, Any]: ...
-
+        def _asdict(self) -> dict[str, Any]: ...
         def _replace(self, **kwargs: Any) -> Self: ...
 
-# 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 in 3.12 (PEP 695)
-# typing_extensions.override (PEP 698)
-@final
-class TypeVar:
-    @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,
-        *constraints: Any,
-        bound: Any | None = None,
-        covariant: bool = False,
-        contravariant: bool = False,
-        default: Any | None = None,
-        infer_variance: bool = False,
-    ) -> None: ...
-    if sys.version_info >= (3, 10):
-        def __or__(self, right: Any) -> _SpecialForm: ...
-        def __ror__(self, left: Any) -> _SpecialForm: ...
-    if sys.version_info >= (3, 11):
-        def __typing_subst__(self, arg: Incomplete) -> Incomplete: ...
-
-@final
-class ParamSpec:
-    @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,
-        *,
-        bound: None | type[Any] | str = None,
-        contravariant: bool = False,
-        covariant: bool = False,
-        default: type[Any] | str | None = None,
-    ) -> None: ...
-    @property
-    def args(self) -> ParamSpecArgs: ...
-    @property
-    def kwargs(self) -> ParamSpecKwargs: ...
-
-@final
-class TypeVarTuple:
-    @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 deprecated(__msg: str, *, category: type[Warning] | None = ..., stacklevel: int = 1) -> Callable[[_T], _T]: ...
+    class NewType:
+        def __init__(self, name: str, tp: Any) -> None: ...
+        def __call__(self, obj: _T, /) -> _T: ...
+        __supertype__: type | NewType
+        if sys.version_info >= (3, 10):
+            def __or__(self, other: Any) -> _SpecialForm: ...
+            def __ror__(self, other: Any) -> _SpecialForm: ...
 
 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
+    from typing import (
+        SupportsAbs as SupportsAbs,
+        SupportsBytes as SupportsBytes,
+        SupportsComplex as SupportsComplex,
+        SupportsFloat as SupportsFloat,
+        SupportsIndex as SupportsIndex,
+        SupportsInt as SupportsInt,
+        SupportsRound as SupportsRound,
+        override as override,
+    )
+else:
+    def override(arg: _F, /) -> _F: ...
+    def get_original_bases(cls: type, /) -> tuple[Any, ...]: ...
+
+    # mypy and pyright object to this being both ABC and Protocol.
+    # At runtime it inherits from ABC and is not a Protocol, but it is on the
+    # allowlist for use as a Protocol.
+    @runtime_checkable
+    class Buffer(Protocol, abc.ABC):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+        # 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: ...
+
+    @runtime_checkable
+    class SupportsInt(Protocol, metaclass=abc.ABCMeta):
+        @abc.abstractmethod
+        def __int__(self) -> int: ...
+
+    @runtime_checkable
+    class SupportsFloat(Protocol, metaclass=abc.ABCMeta):
+        @abc.abstractmethod
+        def __float__(self) -> float: ...
+
+    @runtime_checkable
+    class SupportsComplex(Protocol, metaclass=abc.ABCMeta):
+        @abc.abstractmethod
+        def __complex__(self) -> complex: ...
+
+    @runtime_checkable
+    class SupportsBytes(Protocol, metaclass=abc.ABCMeta):
+        @abc.abstractmethod
+        def __bytes__(self) -> bytes: ...
+
+    @runtime_checkable
+    class SupportsIndex(Protocol, metaclass=abc.ABCMeta):
+        @abc.abstractmethod
+        def __index__(self) -> int: ...
+
+    @runtime_checkable
+    class SupportsAbs(Protocol[_T_co]):
+        @abc.abstractmethod
+        def __abs__(self) -> _T_co: ...
+
+    @runtime_checkable
+    class SupportsRound(Protocol[_T_co]):
+        @overload
+        @abc.abstractmethod
+        def __round__(self) -> int: ...
+        @overload
+        @abc.abstractmethod
+        def __round__(self, ndigits: int, /) -> _T_co: ...
+
+if sys.version_info >= (3, 13):
+    from types import CapsuleType as CapsuleType
+    from typing import (
+        NoDefault as NoDefault,
+        ParamSpec as ParamSpec,
+        ReadOnly as ReadOnly,
+        TypeIs as TypeIs,
+        TypeVar as TypeVar,
+        TypeVarTuple as TypeVarTuple,
+        get_protocol_members as get_protocol_members,
+        is_protocol as is_protocol,
+    )
+    from warnings import deprecated as deprecated
+else:
+    def is_protocol(tp: type, /) -> bool: ...
+    def get_protocol_members(tp: type, /) -> frozenset[str]: ...
+    @final
+    class _NoDefaultType: ...
+
+    NoDefault: _NoDefaultType
+    @final
+    class CapsuleType: ...
+
+    class deprecated:
+        message: LiteralString
+        category: type[Warning] | None
+        stacklevel: int
+        def __init__(self, message: LiteralString, /, *, category: type[Warning] | None = ..., stacklevel: int = 1) -> None: ...
+        def __call__(self, arg: _T, /) -> _T: ...
+
+    @final
+    class TypeVar:
+        @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: ...
+        def __init__(
+            self,
+            name: str,
+            *constraints: Any,
+            bound: Any | None = None,
+            covariant: bool = False,
+            contravariant: bool = False,
+            default: Any = ...,
+            infer_variance: bool = False,
+        ) -> None: ...
+        def has_default(self) -> bool: ...
+        def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
+        if sys.version_info >= (3, 10):
+            def __or__(self, right: Any) -> _SpecialForm: ...
+            def __ror__(self, left: Any) -> _SpecialForm: ...
+        if sys.version_info >= (3, 11):
+            def __typing_subst__(self, arg: Any) -> Any: ...
+
+    @final
+    class ParamSpec:
+        @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: ...
+        def __init__(
+            self,
+            name: str,
+            *,
+            bound: None | type[Any] | str = None,
+            contravariant: bool = False,
+            covariant: bool = False,
+            default: Any = ...,
+        ) -> None: ...
+        @property
+        def args(self) -> ParamSpecArgs: ...
+        @property
+        def kwargs(self) -> ParamSpecKwargs: ...
+        def has_default(self) -> bool: ...
+        def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
+        if sys.version_info >= (3, 10):
+            def __or__(self, right: Any) -> _SpecialForm: ...
+            def __ror__(self, left: Any) -> _SpecialForm: ...
+
+    @final
+    class TypeVarTuple:
+        @property
+        def __name__(self) -> str: ...
+        @property
+        def __default__(self) -> Any: ...
+        def __init__(self, name: str, *, default: Any = ...) -> None: ...
+        def __iter__(self) -> Any: ...  # Unpack[Self]
+        def has_default(self) -> bool: ...
+        def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
+
+    ReadOnly: _SpecialForm
+    TypeIs: _SpecialForm
+
+# TypeAliasType was added in Python 3.12, but had significant changes in 3.14.
+if sys.version_info >= (3, 14):
+    from typing import TypeAliasType as TypeAliasType
 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: ...
+        ) -> None: ...  # value is a type expression
         @property
-        def __value__(self) -> Any: ...
+        def __value__(self) -> Any: ...  # a type expression
         @property
         def __type_params__(self) -> tuple[TypeVar | ParamSpec | TypeVarTuple, ...]: ...
         @property
-        def __parameters__(self) -> tuple[Any, ...]: ...
+        # `__parameters__` can include special forms if a `TypeVarTuple` was
+        # passed as a `type_params` element to the constructor method.
+        def __parameters__(self) -> tuple[TypeVar | ParamSpec | 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: ...
+        # Returns typing._GenericAlias, which isn't stubbed.
+        def __getitem__(self, parameters: Incomplete | tuple[Incomplete, ...]) -> Any: ...
+        def __init_subclass__(cls, *args: Unused, **kwargs: Unused) -> NoReturn: ...
         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: ...
+# PEP 727
+class Doc:
+    documentation: str
+    def __init__(self, documentation: str, /) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+
+# PEP 728
+class _NoExtraItemsType: ...
+
+NoExtraItems: _NoExtraItemsType
+
+# PEP 747
+TypeForm: _SpecialForm
+
+class Format(enum.IntEnum):
+    VALUE = 1
+    FORWARDREF = 2
+    STRING = 3
+
+# PEP 649/749
+def get_annotations(
+    obj: Callable[..., object] | type[object] | ModuleType,  # any callable, class, or module
+    *,
+    globals: Mapping[str, Any] | None = None,  # value types depend on the key
+    locals: Mapping[str, Any] | None = None,  # value types depend on the key
+    eval_str: bool = False,
+    format: Format = Format.VALUE,  # noqa: Y011
+) -> dict[str, Any]: ...  # values are type expressions
+def evaluate_forward_ref(
+    forward_ref: ForwardRef,
+    *,
+    owner: Callable[..., object] | type[object] | ModuleType | None = None,  # any callable, class, or module
+    globals: Mapping[str, Any] | None = None,  # value types depend on the key
+    locals: Mapping[str, Any] | None = None,  # value types depend on the key
+    type_params: Iterable[TypeVar | ParamSpec | TypeVarTuple] | None = None,
+    format: Format = Format.VALUE,  # noqa: Y011
+    _recursive_guard: Container[str] = ...,
+) -> Any: ...  # str if format is Format.STRING, otherwise a type expression
diff --git a/mypy/typeshed/stdlib/unicodedata.pyi b/mypy/typeshed/stdlib/unicodedata.pyi
index 5a1f7fe6638d..77d69edf06af 100644
--- a/mypy/typeshed/stdlib/unicodedata.pyi
+++ b/mypy/typeshed/stdlib/unicodedata.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import ReadOnlyBuffer
-from typing import Any, TypeVar, overload
-from typing_extensions import Literal, TypeAlias, final
+from typing import Any, Literal, TypeVar, final, overload
+from typing_extensions import TypeAlias
 
 ucd_3_2_0: UCD
 unidata_version: str
@@ -11,66 +11,63 @@ if sys.version_info < (3, 10):
 
 _T = TypeVar("_T")
 
-def bidirectional(__chr: str) -> str: ...
-def category(__chr: str) -> str: ...
-def combining(__chr: str) -> int: ...
+_NormalizationForm: TypeAlias = Literal["NFC", "NFD", "NFKC", "NFKD"]
+
+def bidirectional(chr: str, /) -> str: ...
+def category(chr: str, /) -> str: ...
+def combining(chr: str, /) -> int: ...
 @overload
-def decimal(__chr: str) -> int: ...
+def decimal(chr: str, /) -> int: ...
 @overload
-def decimal(__chr: str, __default: _T) -> int | _T: ...
-def decomposition(__chr: str) -> str: ...
+def decimal(chr: str, default: _T, /) -> int | _T: ...
+def decomposition(chr: str, /) -> str: ...
 @overload
-def digit(__chr: str) -> int: ...
+def digit(chr: str, /) -> int: ...
 @overload
-def digit(__chr: str, __default: _T) -> int | _T: ...
+def digit(chr: str, default: _T, /) -> int | _T: ...
 
 _EastAsianWidth: TypeAlias = Literal["F", "H", "W", "Na", "A", "N"]
 
-def east_asian_width(__chr: str) -> _EastAsianWidth: ...
-
-if sys.version_info >= (3, 8):
-    def is_normalized(__form: str, __unistr: str) -> bool: ...
-
-def lookup(__name: str | ReadOnlyBuffer) -> str: ...
-def mirrored(__chr: str) -> int: ...
+def east_asian_width(chr: str, /) -> _EastAsianWidth: ...
+def is_normalized(form: _NormalizationForm, unistr: str, /) -> bool: ...
+def lookup(name: str | ReadOnlyBuffer, /) -> str: ...
+def mirrored(chr: str, /) -> int: ...
 @overload
-def name(__chr: str) -> str: ...
+def name(chr: str, /) -> str: ...
 @overload
-def name(__chr: str, __default: _T) -> str | _T: ...
-def normalize(__form: str, __unistr: str) -> str: ...
+def name(chr: str, default: _T, /) -> str | _T: ...
+def normalize(form: _NormalizationForm, unistr: str, /) -> str: ...
 @overload
-def numeric(__chr: str) -> float: ...
+def numeric(chr: str, /) -> float: ...
 @overload
-def numeric(__chr: str, __default: _T) -> float | _T: ...
+def numeric(chr: str, default: _T, /) -> float | _T: ...
 @final
 class UCD:
     # The methods below are constructed from the same array in C
     # (unicodedata_functions) and hence identical to the functions above.
     unidata_version: str
-    def bidirectional(self, __chr: str) -> str: ...
-    def category(self, __chr: str) -> str: ...
-    def combining(self, __chr: str) -> int: ...
+    def bidirectional(self, chr: str, /) -> str: ...
+    def category(self, chr: str, /) -> str: ...
+    def combining(self, chr: str, /) -> int: ...
     @overload
-    def decimal(self, __chr: str) -> int: ...
+    def decimal(self, chr: str, /) -> int: ...
     @overload
-    def decimal(self, __chr: str, __default: _T) -> int | _T: ...
-    def decomposition(self, __chr: str) -> str: ...
+    def decimal(self, chr: str, default: _T, /) -> int | _T: ...
+    def decomposition(self, chr: str, /) -> str: ...
     @overload
-    def digit(self, __chr: str) -> int: ...
+    def digit(self, chr: str, /) -> int: ...
     @overload
-    def digit(self, __chr: str, __default: _T) -> int | _T: ...
-    def east_asian_width(self, __chr: str) -> _EastAsianWidth: ...
-    if sys.version_info >= (3, 8):
-        def is_normalized(self, __form: str, __unistr: str) -> bool: ...
-
-    def lookup(self, __name: str | ReadOnlyBuffer) -> str: ...
-    def mirrored(self, __chr: str) -> int: ...
+    def digit(self, chr: str, default: _T, /) -> int | _T: ...
+    def east_asian_width(self, chr: str, /) -> _EastAsianWidth: ...
+    def is_normalized(self, form: _NormalizationForm, unistr: str, /) -> bool: ...
+    def lookup(self, name: str | ReadOnlyBuffer, /) -> str: ...
+    def mirrored(self, chr: str, /) -> int: ...
     @overload
-    def name(self, __chr: str) -> str: ...
+    def name(self, chr: str, /) -> str: ...
     @overload
-    def name(self, __chr: str, __default: _T) -> str | _T: ...
-    def normalize(self, __form: str, __unistr: str) -> str: ...
+    def name(self, chr: str, default: _T, /) -> str | _T: ...
+    def normalize(self, form: _NormalizationForm, unistr: str, /) -> str: ...
     @overload
-    def numeric(self, __chr: str) -> float: ...
+    def numeric(self, chr: str, /) -> float: ...
     @overload
-    def numeric(self, __chr: str, __default: _T) -> float | _T: ...
+    def numeric(self, chr: str, default: _T, /) -> float | _T: ...
diff --git a/mypy/typeshed/stdlib/unittest/__init__.pyi b/mypy/typeshed/stdlib/unittest/__init__.pyi
index 33820c793fa5..546ea77bb4ca 100644
--- a/mypy/typeshed/stdlib/unittest/__init__.pyi
+++ b/mypy/typeshed/stdlib/unittest/__init__.pyi
@@ -1,21 +1,17 @@
 import sys
+from unittest.async_case import *
 
 from .case import (
     FunctionTestCase as FunctionTestCase,
     SkipTest as SkipTest,
     TestCase as TestCase,
+    addModuleCleanup as addModuleCleanup,
     expectedFailure as expectedFailure,
     skip as skip,
     skipIf as skipIf,
     skipUnless as skipUnless,
 )
-from .loader import (
-    TestLoader as TestLoader,
-    defaultTestLoader as defaultTestLoader,
-    findTestCases as findTestCases,
-    getTestCaseNames as getTestCaseNames,
-    makeSuite as makeSuite,
-)
+from .loader import TestLoader as TestLoader, defaultTestLoader as defaultTestLoader
 from .main import TestProgram as TestProgram, main as main
 from .result import TestResult as TestResult
 from .runner import TextTestResult as TextTestResult, TextTestRunner as TextTestRunner
@@ -27,15 +23,11 @@ from .signals import (
 )
 from .suite import BaseTestSuite as BaseTestSuite, TestSuite as TestSuite
 
-if sys.version_info >= (3, 8):
-    from unittest.async_case import *
-
-    from .case import addModuleCleanup as addModuleCleanup
-
 if sys.version_info >= (3, 11):
     from .case import doModuleCleanups as doModuleCleanups, enterModuleContext as enterModuleContext
 
 __all__ = [
+    "IsolatedAsyncioTestCase",
     "TestResult",
     "TestCase",
     "TestSuite",
@@ -54,16 +46,18 @@ __all__ = [
     "registerResult",
     "removeResult",
     "removeHandler",
-    "getTestCaseNames",
-    "makeSuite",
-    "findTestCases",
+    "addModuleCleanup",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["addModuleCleanup", "IsolatedAsyncioTestCase"]
+if sys.version_info < (3, 13):
+    from .loader import findTestCases as findTestCases, getTestCaseNames as getTestCaseNames, makeSuite as makeSuite
+
+    __all__ += ["getTestCaseNames", "makeSuite", "findTestCases"]
 
 if sys.version_info >= (3, 11):
     __all__ += ["enterModuleContext", "doModuleCleanups"]
 
-def load_tests(loader: TestLoader, tests: TestSuite, pattern: str | None) -> TestSuite: ...
+if sys.version_info < (3, 12):
+    def load_tests(loader: TestLoader, tests: TestSuite, pattern: str | None) -> TestSuite: ...
+
 def __dir__() -> set[str]: ...
diff --git a/mypy/typeshed/stdlib/unittest/_log.pyi b/mypy/typeshed/stdlib/unittest/_log.pyi
index 4de5d502e004..011a970d8bbc 100644
--- a/mypy/typeshed/stdlib/unittest/_log.pyi
+++ b/mypy/typeshed/stdlib/unittest/_log.pyi
@@ -2,7 +2,7 @@ import logging
 import sys
 from types import TracebackType
 from typing import ClassVar, Generic, NamedTuple, TypeVar
-from unittest.case import TestCase
+from unittest.case import TestCase, _BaseTestCaseContext
 
 _L = TypeVar("_L", None, _LoggingWatcher)
 
@@ -10,9 +10,8 @@ class _LoggingWatcher(NamedTuple):
     records: list[logging.LogRecord]
     output: list[str]
 
-class _AssertLogsContext(Generic[_L]):
+class _AssertLogsContext(_BaseTestCaseContext, Generic[_L]):
     LOGGING_FORMAT: ClassVar[str]
-    test_case: TestCase
     logger_name: str
     level: int
     msg: None
diff --git a/mypy/typeshed/stdlib/unittest/async_case.pyi b/mypy/typeshed/stdlib/unittest/async_case.pyi
index c1de205fbd55..565dd91c0fda 100644
--- a/mypy/typeshed/stdlib/unittest/async_case.pyi
+++ b/mypy/typeshed/stdlib/unittest/async_case.pyi
@@ -1,4 +1,5 @@
 import sys
+from asyncio.events import AbstractEventLoop
 from collections.abc import Awaitable, Callable
 from typing import TypeVar
 from typing_extensions import ParamSpec
@@ -12,8 +13,13 @@ _T = TypeVar("_T")
 _P = ParamSpec("_P")
 
 class IsolatedAsyncioTestCase(TestCase):
+    if sys.version_info >= (3, 13):
+        loop_factory: Callable[[], AbstractEventLoop] | None = None
+
     async def asyncSetUp(self) -> None: ...
     async def asyncTearDown(self) -> None: ...
-    def addAsyncCleanup(self, __func: Callable[_P, Awaitable[object]], *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+    def addAsyncCleanup(self, func: Callable[_P, Awaitable[object]], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
     if sys.version_info >= (3, 11):
         async def enterAsyncContext(self, cm: AbstractAsyncContextManager[_T]) -> _T: ...
+    if sys.version_info >= (3, 9):
+        def __del__(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/unittest/case.pyi b/mypy/typeshed/stdlib/unittest/case.pyi
index 45c39e3f3010..33cd556d2e3b 100644
--- a/mypy/typeshed/stdlib/unittest/case.pyi
+++ b/mypy/typeshed/stdlib/unittest/case.pyi
@@ -6,8 +6,21 @@ from collections.abc import Callable, Container, Iterable, Mapping, Sequence, Se
 from contextlib import AbstractContextManager
 from re import Pattern
 from types import TracebackType
-from typing import Any, AnyStr, ClassVar, Generic, NamedTuple, NoReturn, Protocol, SupportsAbs, SupportsRound, TypeVar, overload
-from typing_extensions import ParamSpec, Self, TypeAlias
+from typing import (
+    Any,
+    AnyStr,
+    ClassVar,
+    Final,
+    Generic,
+    NamedTuple,
+    NoReturn,
+    Protocol,
+    SupportsAbs,
+    SupportsRound,
+    TypeVar,
+    overload,
+)
+from typing_extensions import Never, ParamSpec, Self, TypeAlias
 from warnings import WarningMessage
 
 if sys.version_info >= (3, 9):
@@ -22,11 +35,29 @@ _E = TypeVar("_E", bound=BaseException)
 _FT = TypeVar("_FT", bound=Callable[..., Any])
 _P = ParamSpec("_P")
 
-DIFF_OMITTED: str
+DIFF_OMITTED: Final[str]
 
 class _BaseTestCaseContext:
+    test_case: TestCase
     def __init__(self, test_case: TestCase) -> None: ...
 
+class _AssertRaisesBaseContext(_BaseTestCaseContext):
+    expected: type[BaseException] | tuple[type[BaseException], ...]
+    expected_regex: Pattern[str] | None
+    obj_name: str | None
+    msg: str | None
+
+    def __init__(
+        self,
+        expected: type[BaseException] | tuple[type[BaseException], ...],
+        test_case: TestCase,
+        expected_regex: str | Pattern[str] | None = None,
+    ) -> None: ...
+
+    # This returns Self if args is the empty list, and None otherwise.
+    # but it's not possible to construct an overload which expresses that
+    def handle(self, name: str, args: list[Any], kwargs: dict[str, Any]) -> Any: ...
+
 if sys.version_info >= (3, 9):
     from unittest._log import _AssertLogsContext, _LoggingWatcher
 else:
@@ -41,7 +72,6 @@ else:
 
     class _AssertLogsContext(_BaseTestCaseContext, Generic[_L]):
         LOGGING_FORMAT: ClassVar[str]
-        test_case: TestCase
         logger_name: str
         level: int
         msg: None
@@ -51,9 +81,8 @@ else:
             self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
         ) -> bool | None: ...
 
-if sys.version_info >= (3, 8):
-    def addModuleCleanup(__function: Callable[_P, Any], *args: _P.args, **kwargs: _P.kwargs) -> None: ...
-    def doModuleCleanups() -> None: ...
+def addModuleCleanup(function: Callable[_P, object], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+def doModuleCleanups() -> None: ...
 
 if sys.version_info >= (3, 11):
     def enterModuleContext(cm: AbstractContextManager[_T]) -> _T: ...
@@ -86,6 +115,7 @@ class TestCase:
     _testMethodDoc: str
     def __init__(self, methodName: str = "runTest") -> None: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
     def setUp(self) -> None: ...
     def tearDown(self) -> None: ...
     @classmethod
@@ -125,9 +155,9 @@ class TestCase:
     @overload
     def assertLess(self, a: _T, b: SupportsDunderGT[_T], msg: Any = None) -> None: ...
     @overload
-    def assertLessEqual(self, a: SupportsDunderLT[_T], b: _T, msg: Any = None) -> None: ...
+    def assertLessEqual(self, a: SupportsDunderLE[_T], b: _T, msg: Any = None) -> None: ...
     @overload
-    def assertLessEqual(self, a: _T, b: SupportsDunderGT[_T], msg: Any = None) -> None: ...
+    def assertLessEqual(self, a: _T, b: SupportsDunderGE[_T], msg: Any = None) -> None: ...
     # `assertRaises`, `assertRaisesRegex`, and `assertRaisesRegexp`
     # are not using `ParamSpec` intentionally,
     # because they might be used with explicitly wrong arg types to raise some error in tests.
@@ -135,7 +165,7 @@ class TestCase:
     def assertRaises(
         self,
         expected_exception: type[BaseException] | tuple[type[BaseException], ...],
-        callable: Callable[..., Any],
+        callable: Callable[..., object],
         *args: Any,
         **kwargs: Any,
     ) -> None: ...
@@ -148,7 +178,7 @@ class TestCase:
         self,
         expected_exception: type[BaseException] | tuple[type[BaseException], ...],
         expected_regex: str | Pattern[str],
-        callable: Callable[..., Any],
+        callable: Callable[..., object],
         *args: Any,
         **kwargs: Any,
     ) -> None: ...
@@ -160,7 +190,7 @@ class TestCase:
     def assertWarns(
         self,
         expected_warning: type[Warning] | tuple[type[Warning], ...],
-        callable: Callable[_P, Any],
+        callable: Callable[_P, object],
         *args: _P.args,
         **kwargs: _P.kwargs,
     ) -> None: ...
@@ -173,7 +203,7 @@ class TestCase:
         self,
         expected_warning: type[Warning] | tuple[type[Warning], ...],
         expected_regex: str | Pattern[str],
-        callable: Callable[_P, Any],
+        callable: Callable[_P, object],
         *args: _P.args,
         **kwargs: _P.kwargs,
     ) -> None: ...
@@ -248,26 +278,24 @@ class TestCase:
     def assertListEqual(self, list1: list[Any], list2: list[Any], msg: Any = None) -> None: ...
     def assertTupleEqual(self, tuple1: tuple[Any, ...], tuple2: tuple[Any, ...], msg: Any = None) -> None: ...
     def assertSetEqual(self, set1: AbstractSet[object], set2: AbstractSet[object], msg: Any = None) -> None: ...
+    # assertDictEqual accepts only true dict instances. We can't use that here, since that would make
+    # assertDictEqual incompatible with TypedDict.
     def assertDictEqual(self, d1: Mapping[Any, object], d2: Mapping[Any, object], msg: Any = None) -> None: ...
     def fail(self, msg: Any = None) -> NoReturn: ...
     def countTestCases(self) -> int: ...
     def defaultTestResult(self) -> unittest.result.TestResult: ...
     def id(self) -> str: ...
     def shortDescription(self) -> str | None: ...
-    if sys.version_info >= (3, 8):
-        def addCleanup(self, __function: Callable[_P, Any], *args: _P.args, **kwargs: _P.kwargs) -> None: ...
-    else:
-        def addCleanup(self, function: Callable[_P, Any], *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+    def addCleanup(self, function: Callable[_P, object], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
 
     if sys.version_info >= (3, 11):
         def enterContext(self, cm: AbstractContextManager[_T]) -> _T: ...
 
     def doCleanups(self) -> None: ...
-    if sys.version_info >= (3, 8):
-        @classmethod
-        def addClassCleanup(cls, __function: Callable[_P, Any], *args: _P.args, **kwargs: _P.kwargs) -> None: ...
-        @classmethod
-        def doClassCleanups(cls) -> None: ...
+    @classmethod
+    def addClassCleanup(cls, function: Callable[_P, object], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+    @classmethod
+    def doClassCleanups(cls) -> None: ...
 
     if sys.version_info >= (3, 11):
         @classmethod
@@ -295,26 +323,32 @@ class TestCase:
             self, subset: Mapping[Any, Any], dictionary: Mapping[Any, Any], msg: object = None
         ) -> None: ...
 
+    if sys.version_info >= (3, 10):
+        # Runtime has *args, **kwargs, but will error if any are supplied
+        def __init_subclass__(cls, *args: Never, **kwargs: Never) -> None: ...
+
 class FunctionTestCase(TestCase):
     def __init__(
         self,
-        testFunc: Callable[[], Any],
-        setUp: Callable[[], Any] | None = None,
-        tearDown: Callable[[], Any] | None = None,
+        testFunc: Callable[[], object],
+        setUp: Callable[[], object] | None = None,
+        tearDown: Callable[[], object] | None = None,
         description: str | None = None,
     ) -> None: ...
     def runTest(self) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
 
-class _AssertRaisesContext(Generic[_E]):
+class _AssertRaisesContext(_AssertRaisesBaseContext, Generic[_E]):
     exception: _E
     def __enter__(self) -> Self: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
     ) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class _AssertWarnsContext:
+class _AssertWarnsContext(_AssertRaisesBaseContext):
     warning: WarningMessage
     filename: str
     lineno: int
diff --git a/mypy/typeshed/stdlib/unittest/loader.pyi b/mypy/typeshed/stdlib/unittest/loader.pyi
index f3850c939d07..598e3cd84a5e 100644
--- a/mypy/typeshed/stdlib/unittest/loader.pyi
+++ b/mypy/typeshed/stdlib/unittest/loader.pyi
@@ -1,15 +1,16 @@
+import sys
 import unittest.case
 import unittest.suite
 from collections.abc import Callable, Sequence
 from re import Pattern
 from types import ModuleType
-from typing import Any
-from typing_extensions import TypeAlias
+from typing import Any, Final
+from typing_extensions import TypeAlias, deprecated
 
 _SortComparisonMethod: TypeAlias = Callable[[str, str], int]
 _SuiteClass: TypeAlias = Callable[[list[unittest.case.TestCase]], unittest.suite.TestSuite]
 
-VALID_MODULE_NAME: Pattern[str]
+VALID_MODULE_NAME: Final[Pattern[str]]
 
 class TestLoader:
     errors: list[type[BaseException]]
@@ -18,7 +19,11 @@ class TestLoader:
     testNamePatterns: list[str] | None
     suiteClass: _SuiteClass
     def loadTestsFromTestCase(self, testCaseClass: type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ...
-    def loadTestsFromModule(self, module: ModuleType, *args: Any, pattern: Any = None) -> unittest.suite.TestSuite: ...
+    if sys.version_info >= (3, 12):
+        def loadTestsFromModule(self, module: ModuleType, *, pattern: str | None = None) -> unittest.suite.TestSuite: ...
+    else:
+        def loadTestsFromModule(self, module: ModuleType, *args: Any, pattern: str | None = None) -> unittest.suite.TestSuite: ...
+
     def loadTestsFromName(self, name: str, module: ModuleType | None = None) -> unittest.suite.TestSuite: ...
     def loadTestsFromNames(self, names: Sequence[str], module: ModuleType | None = None) -> unittest.suite.TestSuite: ...
     def getTestCaseNames(self, testCaseClass: type[unittest.case.TestCase]) -> Sequence[str]: ...
@@ -29,18 +34,22 @@ class TestLoader:
 
 defaultTestLoader: TestLoader
 
-def getTestCaseNames(
-    testCaseClass: type[unittest.case.TestCase],
-    prefix: str,
-    sortUsing: _SortComparisonMethod = ...,
-    testNamePatterns: list[str] | None = None,
-) -> Sequence[str]: ...
-def makeSuite(
-    testCaseClass: type[unittest.case.TestCase],
-    prefix: str = "test",
-    sortUsing: _SortComparisonMethod = ...,
-    suiteClass: _SuiteClass = ...,
-) -> unittest.suite.TestSuite: ...
-def findTestCases(
-    module: ModuleType, prefix: str = "test", sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
-) -> unittest.suite.TestSuite: ...
+if sys.version_info < (3, 13):
+    @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+    def getTestCaseNames(
+        testCaseClass: type[unittest.case.TestCase],
+        prefix: str,
+        sortUsing: _SortComparisonMethod = ...,
+        testNamePatterns: list[str] | None = None,
+    ) -> Sequence[str]: ...
+    @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+    def makeSuite(
+        testCaseClass: type[unittest.case.TestCase],
+        prefix: str = "test",
+        sortUsing: _SortComparisonMethod = ...,
+        suiteClass: _SuiteClass = ...,
+    ) -> unittest.suite.TestSuite: ...
+    @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+    def findTestCases(
+        module: ModuleType, prefix: str = "test", sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
+    ) -> unittest.suite.TestSuite: ...
diff --git a/mypy/typeshed/stdlib/unittest/main.pyi b/mypy/typeshed/stdlib/unittest/main.pyi
index 6d970c920096..22f2ec10634d 100644
--- a/mypy/typeshed/stdlib/unittest/main.pyi
+++ b/mypy/typeshed/stdlib/unittest/main.pyi
@@ -1,16 +1,18 @@
+import sys
 import unittest.case
 import unittest.loader
 import unittest.result
 import unittest.suite
 from collections.abc import Iterable
 from types import ModuleType
-from typing import Any, Protocol
+from typing import Any, Final, Protocol
+from typing_extensions import deprecated
 
-MAIN_EXAMPLES: str
-MODULE_EXAMPLES: str
+MAIN_EXAMPLES: Final[str]
+MODULE_EXAMPLES: Final[str]
 
 class _TestRunner(Protocol):
-    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> unittest.result.TestResult: ...
+    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase, /) -> unittest.result.TestResult: ...
 
 # not really documented
 class TestProgram:
@@ -23,23 +25,47 @@ class TestProgram:
     progName: str | None
     warnings: str | None
     testNamePatterns: list[str] | None
-    def __init__(
-        self,
-        module: None | str | ModuleType = "__main__",
-        defaultTest: str | Iterable[str] | None = None,
-        argv: list[str] | None = None,
-        testRunner: type[_TestRunner] | _TestRunner | None = None,
-        testLoader: unittest.loader.TestLoader = ...,
-        exit: bool = True,
-        verbosity: int = 1,
-        failfast: bool | None = None,
-        catchbreak: bool | None = None,
-        buffer: bool | None = None,
-        warnings: str | None = None,
-        *,
-        tb_locals: bool = False,
-    ) -> None: ...
-    def usageExit(self, msg: Any = None) -> None: ...
+    if sys.version_info >= (3, 12):
+        durations: unittest.result._DurationsType | None
+        def __init__(
+            self,
+            module: None | str | ModuleType = "__main__",
+            defaultTest: str | Iterable[str] | None = None,
+            argv: list[str] | None = None,
+            testRunner: type[_TestRunner] | _TestRunner | None = None,
+            testLoader: unittest.loader.TestLoader = ...,
+            exit: bool = True,
+            verbosity: int = 1,
+            failfast: bool | None = None,
+            catchbreak: bool | None = None,
+            buffer: bool | None = None,
+            warnings: str | None = None,
+            *,
+            tb_locals: bool = False,
+            durations: unittest.result._DurationsType | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            module: None | str | ModuleType = "__main__",
+            defaultTest: str | Iterable[str] | None = None,
+            argv: list[str] | None = None,
+            testRunner: type[_TestRunner] | _TestRunner | None = None,
+            testLoader: unittest.loader.TestLoader = ...,
+            exit: bool = True,
+            verbosity: int = 1,
+            failfast: bool | None = None,
+            catchbreak: bool | None = None,
+            buffer: bool | None = None,
+            warnings: str | None = None,
+            *,
+            tb_locals: bool = False,
+        ) -> None: ...
+
+    if sys.version_info < (3, 13):
+        @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+        def usageExit(self, msg: Any = None) -> None: ...
+
     def parseArgs(self, argv: list[str]) -> None: ...
     def createTests(self, from_discovery: bool = False, Loader: unittest.loader.TestLoader | None = None) -> None: ...
     def runTests(self) -> None: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/unittest/mock.pyi b/mypy/typeshed/stdlib/unittest/mock.pyi
index 1f554da52d5d..4b32f15095d6 100644
--- a/mypy/typeshed/stdlib/unittest/mock.pyi
+++ b/mypy/typeshed/stdlib/unittest/mock.pyi
@@ -2,16 +2,18 @@ import sys
 from collections.abc import Awaitable, Callable, Coroutine, Iterable, Mapping, Sequence
 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 import Any, ClassVar, Final, Generic, Literal, TypeVar, overload
+from typing_extensions import 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):
+if sys.version_info >= (3, 13):
+    # ThreadingMock added in 3.13
     __all__ = (
         "Mock",
         "MagicMock",
@@ -21,6 +23,7 @@ if sys.version_info >= (3, 8):
         "ANY",
         "call",
         "create_autospec",
+        "ThreadingMock",
         "AsyncMock",
         "FILTER_DIR",
         "NonCallableMock",
@@ -39,6 +42,7 @@ else:
         "ANY",
         "call",
         "create_autospec",
+        "AsyncMock",
         "FILTER_DIR",
         "NonCallableMock",
         "NonCallableMagicMock",
@@ -81,17 +85,16 @@ class _Call(tuple[Any, ...]):
         two: bool = False,
         from_kall: bool = True,
     ) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __eq__(self, other: object) -> bool: ...
-    def __ne__(self, __value: object) -> bool: ...
+    def __ne__(self, value: object, /) -> bool: ...
     def __call__(self, *args: Any, **kwargs: Any) -> _Call: ...
     def __getattr__(self, attr: str) -> Any: ...
     def __getattribute__(self, attr: str) -> Any: ...
-    if sys.version_info >= (3, 8):
-        @property
-        def args(self) -> tuple[Any, ...]: ...
-        @property
-        def kwargs(self) -> Mapping[str, Any]: ...
-
+    @property
+    def args(self) -> tuple[Any, ...]: ...
+    @property
+    def kwargs(self) -> Mapping[str, Any]: ...
     def call_list(self) -> Any: ...
 
 call: _Call
@@ -105,7 +108,25 @@ class Base:
 # We subclass with "Any" because mocks are explicitly designed to stand in for other types,
 # something that can't be expressed with our static type system.
 class NonCallableMock(Base, Any):
-    def __new__(__cls, *args: Any, **kw: Any) -> Self: ...
+    if sys.version_info >= (3, 12):
+        def __new__(
+            cls,
+            spec: list[str] | object | type[object] | None = None,
+            wraps: Any | None = None,
+            name: str | None = None,
+            spec_set: list[str] | object | type[object] | None = None,
+            parent: NonCallableMock | None = None,
+            _spec_state: Any | None = None,
+            _new_name: str = "",
+            _new_parent: NonCallableMock | None = None,
+            _spec_as_instance: bool = False,
+            _eat_self: bool | None = None,
+            unsafe: bool = False,
+            **kwargs: Any,
+        ) -> Self: ...
+    else:
+        def __new__(cls, /, *args: Any, **kw: Any) -> Self: ...
+
     def __init__(
         self,
         spec: list[str] | object | type[object] | None = None,
@@ -125,24 +146,12 @@ class NonCallableMock(Base, Any):
     def __delattr__(self, name: str) -> None: ...
     def __setattr__(self, name: str, value: Any) -> None: ...
     def __dir__(self) -> list[str]: ...
-    if sys.version_info >= (3, 8):
-        def _calls_repr(self, prefix: str = "Calls") -> str: ...
-        def assert_called_with(self, *args: Any, **kwargs: Any) -> None: ...
-        def assert_not_called(self) -> None: ...
-        def assert_called_once_with(self, *args: Any, **kwargs: Any) -> None: ...
-        def _format_mock_failure_message(self, args: Any, kwargs: Any, action: str = "call") -> str: ...
-    else:
-        def assert_called_with(_mock_self, *args: Any, **kwargs: Any) -> None: ...
-        def assert_not_called(_mock_self) -> None: ...
-        def assert_called_once_with(_mock_self, *args: Any, **kwargs: Any) -> None: ...
-        def _format_mock_failure_message(self, args: Any, kwargs: Any) -> str: ...
-    if sys.version_info >= (3, 8):
-        def assert_called(self) -> None: ...
-        def assert_called_once(self) -> None: ...
-    else:
-        def assert_called(_mock_self) -> None: ...
-        def assert_called_once(_mock_self) -> None: ...
-
+    def assert_called_with(self, *args: Any, **kwargs: Any) -> None: ...
+    def assert_not_called(self) -> None: ...
+    def assert_called_once_with(self, *args: Any, **kwargs: Any) -> None: ...
+    def _format_mock_failure_message(self, args: Any, kwargs: Any, action: str = "call") -> str: ...
+    def assert_called(self) -> None: ...
+    def assert_called_once(self) -> None: ...
     def reset_mock(self, visited: Any = None, *, return_value: bool = False, side_effect: bool = False) -> None: ...
     def _extract_mock_name(self) -> str: ...
     def _get_call_signature_from_name(self, name: str) -> Any: ...
@@ -162,6 +171,10 @@ class NonCallableMock(Base, Any):
     def _format_mock_call_signature(self, args: Any, kwargs: Any) -> str: ...
     def _call_matcher(self, _call: tuple[_Call, ...]) -> _Call: ...
     def _get_child_mock(self, **kw: Any) -> NonCallableMock: ...
+    if sys.version_info >= (3, 13):
+        def _calls_repr(self) -> str: ...
+    else:
+        def _calls_repr(self, prefix: str = "Calls") -> str: ...
 
 class CallableMixin(Base):
     side_effect: Any
@@ -179,10 +192,7 @@ class CallableMixin(Base):
         _new_parent: Any | None = None,
         **kwargs: Any,
     ) -> None: ...
-    if sys.version_info >= (3, 8):
-        def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
-    else:
-        def __call__(_mock_self, *args: Any, **kwargs: Any) -> Any: ...
+    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
 
 class Mock(CallableMixin, NonCallableMock): ...
 
@@ -203,7 +213,7 @@ class _patch(Generic[_T]):
     # but that's impossible with the current type system.
     if sys.version_info >= (3, 10):
         def __init__(
-            self: _patch[_T],
+            self: _patch[_T],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
             getter: Callable[[], Any],
             attribute: str,
             new: _T,
@@ -218,7 +228,7 @@ class _patch(Generic[_T]):
         ) -> None: ...
     else:
         def __init__(
-            self: _patch[_T],
+            self: _patch[_T],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
             getter: Callable[[], Any],
             attribute: str,
             new: _T,
@@ -233,29 +243,38 @@ class _patch(Generic[_T]):
     def copy(self) -> _patch[_T]: ...
     @overload
     def __call__(self, func: _TT) -> _TT: ...
+    # If new==DEFAULT, this should add a MagicMock parameter to the function
+    # arguments. See the _patch_default_new class below for this functionality.
     @overload
-    def __call__(self, func: Callable[..., _R]) -> Callable[..., _R]: ...
-    if sys.version_info >= (3, 8):
-        def decoration_helper(
-            self, patched: _patch[Any], args: Sequence[Any], keywargs: Any
-        ) -> _GeneratorContextManager[tuple[Sequence[Any], Any]]: ...
-
+    def __call__(self, func: Callable[_P, _R]) -> Callable[_P, _R]: ...
+    def decoration_helper(
+        self, patched: _patch[Any], args: Sequence[Any], keywargs: Any
+    ) -> _GeneratorContextManager[tuple[Sequence[Any], Any]]: ...
     def decorate_class(self, klass: _TT) -> _TT: ...
     def decorate_callable(self, func: Callable[..., _R]) -> Callable[..., _R]: ...
-    if sys.version_info >= (3, 8):
-        def decorate_async_callable(self, func: Callable[..., Awaitable[_R]]) -> Callable[..., Awaitable[_R]]: ...
-
+    def decorate_async_callable(self, func: Callable[..., Awaitable[_R]]) -> Callable[..., Awaitable[_R]]: ...
     def get_original(self) -> tuple[Any, bool]: ...
     target: Any
     temp_original: Any
     is_local: bool
     def __enter__(self) -> _T: ...
     def __exit__(
-        self, __exc_type: type[BaseException] | None, __exc_value: BaseException | None, __traceback: TracebackType | None
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
     ) -> None: ...
     def start(self) -> _T: ...
     def stop(self) -> None: ...
 
+# This class does not exist at runtime, it's a hack to make this work:
+#     @patch("foo")
+#     def bar(..., mock: MagicMock) -> None: ...
+class _patch_default_new(_patch[MagicMock | AsyncMock]):
+    @overload
+    def __call__(self, func: _TT) -> _TT: ...
+    # Can't use the following as ParamSpec is only allowed as last parameter:
+    #   def __call__(self, func: Callable[_P, _R]) -> Callable[Concatenate[_P, MagicMock], _R]: ...
+    @overload
+    def __call__(self, func: Callable[..., _R]) -> Callable[..., _R]: ...
+
 class _patch_dict:
     in_dict: Any
     values: Any
@@ -272,11 +291,8 @@ class _patch_dict:
     start: Any
     stop: Any
 
-if sys.version_info >= (3, 8):
-    _Mock: TypeAlias = MagicMock | AsyncMock
-else:
-    _Mock: TypeAlias = MagicMock
-
+# This class does not exist at runtime, it's a hack to add methods to the
+# patch() function.
 class _patcher:
     TEST_PREFIX: str
     dict: type[_patch_dict]
@@ -284,7 +300,7 @@ class _patcher:
     # Ideally we'd be able to add an overload for it so that the return type is _patch[MagicMock],
     # but that's impossible with the current type system.
     @overload
-    def __call__(  # type: ignore[misc]
+    def __call__(
         self,
         target: str,
         new: _T,
@@ -306,10 +322,10 @@ class _patcher:
         autospec: Any | None = ...,
         new_callable: Any | None = ...,
         **kwargs: Any,
-    ) -> _patch[_Mock]: ...
+    ) -> _patch_default_new: ...
     @overload
     @staticmethod
-    def object(  # type: ignore[misc]
+    def object(
         target: Any,
         attribute: str,
         new: _T,
@@ -332,7 +348,7 @@ class _patcher:
         autospec: Any | None = ...,
         new_callable: Any | None = ...,
         **kwargs: Any,
-    ) -> _patch[_Mock]: ...
+    ) -> _patch[MagicMock | AsyncMock]: ...
     @staticmethod
     def multiple(
         target: Any,
@@ -348,46 +364,47 @@ class _patcher:
 
 patch: _patcher
 
-class MagicMixin:
+class MagicMixin(Base):
     def __init__(self, *args: Any, **kw: Any) -> None: ...
 
 class NonCallableMagicMock(MagicMixin, NonCallableMock): ...
 class MagicMock(MagicMixin, Mock): ...
 
-if sys.version_info >= (3, 8):
-    class AsyncMockMixin(Base):
-        def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-        async def _execute_mock_call(self, *args: Any, **kwargs: Any) -> Any: ...
-        def assert_awaited(self) -> None: ...
-        def assert_awaited_once(self) -> None: ...
-        def assert_awaited_with(self, *args: Any, **kwargs: Any) -> None: ...
-        def assert_awaited_once_with(self, *args: Any, **kwargs: Any) -> None: ...
-        def assert_any_await(self, *args: Any, **kwargs: Any) -> None: ...
-        def assert_has_awaits(self, calls: Iterable[_Call], any_order: bool = False) -> None: ...
-        def assert_not_awaited(self) -> None: ...
-        def reset_mock(self, *args: Any, **kwargs: Any) -> None: ...
-        await_count: int
-        await_args: _Call | None
-        await_args_list: _CallList
-
-    class AsyncMagicMixin(MagicMixin):
-        def __init__(self, *args: Any, **kw: Any) -> None: ...
-
-    class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock): ...
-
-class MagicProxy:
+class AsyncMockMixin(Base):
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    async def _execute_mock_call(self, *args: Any, **kwargs: Any) -> Any: ...
+    def assert_awaited(self) -> None: ...
+    def assert_awaited_once(self) -> None: ...
+    def assert_awaited_with(self, *args: Any, **kwargs: Any) -> None: ...
+    def assert_awaited_once_with(self, *args: Any, **kwargs: Any) -> None: ...
+    def assert_any_await(self, *args: Any, **kwargs: Any) -> None: ...
+    def assert_has_awaits(self, calls: Iterable[_Call], any_order: bool = False) -> None: ...
+    def assert_not_awaited(self) -> None: ...
+    def reset_mock(self, *args: Any, **kwargs: Any) -> None: ...
+    await_count: int
+    await_args: _Call | None
+    await_args_list: _CallList
+
+class AsyncMagicMixin(MagicMixin):
+    def __init__(self, *args: Any, **kw: Any) -> None: ...
+
+class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock):
+    # Improving the `reset_mock` signature.
+    # It is defined on `AsyncMockMixin` with `*args, **kwargs`, which is not ideal.
+    # But, `NonCallableMock` super-class has the better version.
+    def reset_mock(self, visited: Any = None, *, return_value: bool = False, side_effect: bool = False) -> None: ...
+
+class MagicProxy(Base):
     name: str
     parent: Any
     def __init__(self, name: str, parent: Any) -> None: ...
-    if sys.version_info < (3, 8):
-        def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
-
     def create_mock(self) -> Any: ...
     def __get__(self, obj: Any, _type: Any | None = None) -> Any: ...
 
 class _ANY:
     def __eq__(self, other: object) -> Literal[True]: ...
     def __ne__(self, other: object) -> Literal[False]: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 ANY: Any
 
@@ -433,11 +450,19 @@ class _SpecState:
 def mock_open(mock: Any | None = None, read_data: Any = "") -> Any: ...
 
 class PropertyMock(Mock):
-    if sys.version_info >= (3, 8):
-        def __get__(self, obj: _T, obj_type: type[_T] | None = None) -> Self: ...
-    else:
-        def __get__(self, obj: _T, obj_type: type[_T] | None) -> Self: ...
-
+    def __get__(self, obj: _T, obj_type: type[_T] | None = None) -> Self: ...
     def __set__(self, obj: Any, val: Any) -> None: ...
 
+if sys.version_info >= (3, 13):
+    class ThreadingMixin(Base):
+        DEFAULT_TIMEOUT: Final[float | None] = None
+
+        def __init__(self, /, *args: Any, timeout: float | None | _SentinelObject = ..., **kwargs: Any) -> None: ...
+        # Same as `NonCallableMock.reset_mock.`
+        def reset_mock(self, visited: Any = None, *, return_value: bool = False, side_effect: bool = False) -> None: ...
+        def wait_until_called(self, *, timeout: float | None | _SentinelObject = ...) -> None: ...
+        def wait_until_any_call_with(self, *args: Any, **kwargs: Any) -> None: ...
+
+    class ThreadingMock(ThreadingMixin, MagicMixin, Mock): ...
+
 def seal(mock: Any) -> None: ...
diff --git a/mypy/typeshed/stdlib/unittest/result.pyi b/mypy/typeshed/stdlib/unittest/result.pyi
index 8d78bc0f7dcf..0761baaa2830 100644
--- a/mypy/typeshed/stdlib/unittest/result.pyi
+++ b/mypy/typeshed/stdlib/unittest/result.pyi
@@ -1,12 +1,15 @@
+import sys
 import unittest.case
 from _typeshed import OptExcInfo
 from collections.abc import Callable
-from typing import Any, TextIO, TypeVar
+from typing import Any, Final, TextIO, TypeVar
+from typing_extensions import TypeAlias
 
 _F = TypeVar("_F", bound=Callable[..., Any])
+_DurationsType: TypeAlias = list[tuple[str, float]]
 
-STDOUT_LINE: str
-STDERR_LINE: str
+STDOUT_LINE: Final[str]
+STDERR_LINE: Final[str]
 
 # undocumented
 def failfast(method: _F) -> _F: ...
@@ -22,6 +25,9 @@ class TestResult:
     buffer: bool
     failfast: bool
     tb_locals: bool
+    if sys.version_info >= (3, 12):
+        collectedDurations: _DurationsType
+
     def __init__(self, stream: TextIO | None = None, descriptions: bool | None = None, verbosity: int | None = None) -> None: ...
     def printErrors(self) -> None: ...
     def wasSuccessful(self) -> bool: ...
@@ -37,3 +43,5 @@ class TestResult:
     def addExpectedFailure(self, test: unittest.case.TestCase, err: OptExcInfo) -> None: ...
     def addUnexpectedSuccess(self, test: unittest.case.TestCase) -> None: ...
     def addSubTest(self, test: unittest.case.TestCase, subtest: unittest.case.TestCase, err: OptExcInfo | None) -> None: ...
+    if sys.version_info >= (3, 12):
+        def addDuration(self, test: unittest.case.TestCase, elapsed: float) -> None: ...
diff --git a/mypy/typeshed/stdlib/unittest/runner.pyi b/mypy/typeshed/stdlib/unittest/runner.pyi
index c0ddcdb49208..783764464a53 100644
--- a/mypy/typeshed/stdlib/unittest/runner.pyi
+++ b/mypy/typeshed/stdlib/unittest/runner.pyi
@@ -1,36 +1,91 @@
+import sys
 import unittest.case
 import unittest.result
 import unittest.suite
+from _typeshed import SupportsFlush, SupportsWrite
 from collections.abc import Callable, Iterable
-from typing import TextIO
-from typing_extensions import TypeAlias
+from typing import Any, Generic, Protocol, TypeVar
+from typing_extensions import Never, TypeAlias
+from warnings import _ActionKind
 
-_ResultClassType: TypeAlias = Callable[[TextIO, bool, int], unittest.result.TestResult]
+_ResultClassType: TypeAlias = Callable[[_TextTestStream, bool, int], TextTestResult[Any]]
 
-class TextTestResult(unittest.result.TestResult):
+class _SupportsWriteAndFlush(SupportsWrite[str], SupportsFlush, Protocol): ...
+
+# All methods used by unittest.runner.TextTestResult's stream
+class _TextTestStream(_SupportsWriteAndFlush, Protocol):
+    def writeln(self, arg: str | None = None, /) -> None: ...
+
+# _WritelnDecorator should have all the same attrs as its stream param.
+# But that's not feasible to do Generically
+# We can expand the attributes if requested
+class _WritelnDecorator:
+    def __init__(self, stream: _SupportsWriteAndFlush) -> None: ...
+    def writeln(self, arg: str | None = None) -> None: ...
+    def __getattr__(self, attr: str) -> Any: ...  # Any attribute from the stream type passed to __init__
+    # These attributes are prevented by __getattr__
+    stream: Never
+    __getstate__: Never
+    # Methods proxied from the wrapped stream object via __getattr__
+    def flush(self) -> object: ...
+    def write(self, s: str, /) -> object: ...
+
+_StreamT = TypeVar("_StreamT", bound=_TextTestStream, default=_WritelnDecorator)
+
+class TextTestResult(unittest.result.TestResult, Generic[_StreamT]):
     descriptions: bool  # undocumented
     dots: bool  # undocumented
     separator1: str
     separator2: str
     showAll: bool  # undocumented
-    stream: TextIO  # undocumented
-    def __init__(self, stream: TextIO, descriptions: bool, verbosity: int) -> None: ...
+    stream: _StreamT  # undocumented
+    if sys.version_info >= (3, 12):
+        durations: int | None
+        def __init__(self, stream: _StreamT, descriptions: bool, verbosity: int, *, durations: int | None = None) -> None: ...
+    else:
+        def __init__(self, stream: _StreamT, descriptions: bool, verbosity: int) -> None: ...
+
     def getDescription(self, test: unittest.case.TestCase) -> str: ...
     def printErrorList(self, flavour: str, errors: Iterable[tuple[unittest.case.TestCase, str]]) -> None: ...
 
 class TextTestRunner:
     resultclass: _ResultClassType
-    def __init__(
-        self,
-        stream: TextIO | None = None,
-        descriptions: bool = True,
-        verbosity: int = 1,
-        failfast: bool = False,
-        buffer: bool = False,
-        resultclass: _ResultClassType | None = None,
-        warnings: type[Warning] | None = None,
-        *,
-        tb_locals: bool = False,
-    ) -> None: ...
-    def _makeResult(self) -> unittest.result.TestResult: ...
-    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> unittest.result.TestResult: ...
+    stream: _WritelnDecorator
+    descriptions: bool
+    verbosity: int
+    failfast: bool
+    buffer: bool
+    warnings: _ActionKind | None
+    tb_locals: bool
+
+    if sys.version_info >= (3, 12):
+        durations: int | None
+        def __init__(
+            self,
+            stream: _SupportsWriteAndFlush | None = None,
+            descriptions: bool = True,
+            verbosity: int = 1,
+            failfast: bool = False,
+            buffer: bool = False,
+            resultclass: _ResultClassType | None = None,
+            warnings: _ActionKind | None = None,
+            *,
+            tb_locals: bool = False,
+            durations: int | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            stream: _SupportsWriteAndFlush | None = None,
+            descriptions: bool = True,
+            verbosity: int = 1,
+            failfast: bool = False,
+            buffer: bool = False,
+            resultclass: _ResultClassType | None = None,
+            warnings: str | None = None,
+            *,
+            tb_locals: bool = False,
+        ) -> None: ...
+
+    def _makeResult(self) -> TextTestResult: ...
+    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> TextTestResult: ...
diff --git a/mypy/typeshed/stdlib/unittest/suite.pyi b/mypy/typeshed/stdlib/unittest/suite.pyi
index c10cbc75d7fd..443396164b6f 100644
--- a/mypy/typeshed/stdlib/unittest/suite.pyi
+++ b/mypy/typeshed/stdlib/unittest/suite.pyi
@@ -1,11 +1,12 @@
 import unittest.case
 import unittest.result
 from collections.abc import Iterable, Iterator
+from typing import ClassVar
 from typing_extensions import TypeAlias
 
 _TestType: TypeAlias = unittest.case.TestCase | TestSuite
 
-class BaseTestSuite(Iterable[_TestType]):
+class BaseTestSuite:
     _tests: list[unittest.case.TestCase]
     _removed_tests: int
     def __init__(self, tests: Iterable[_TestType] = ()) -> None: ...
@@ -17,6 +18,7 @@ class BaseTestSuite(Iterable[_TestType]):
     def countTestCases(self) -> int: ...
     def __iter__(self) -> Iterator[_TestType]: ...
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class TestSuite(BaseTestSuite):
     def run(self, result: unittest.result.TestResult, debug: bool = False) -> unittest.result.TestResult: ...
diff --git a/mypy/typeshed/stdlib/unittest/util.pyi b/mypy/typeshed/stdlib/unittest/util.pyi
index 845accfebedd..945b0cecfed0 100644
--- a/mypy/typeshed/stdlib/unittest/util.pyi
+++ b/mypy/typeshed/stdlib/unittest/util.pyi
@@ -1,23 +1,23 @@
-from collections.abc import Sequence
-from typing import Any, TypeVar
+from collections.abc import MutableSequence, Sequence
+from typing import Any, Final, TypeVar
 from typing_extensions import TypeAlias
 
 _T = TypeVar("_T")
 _Mismatch: TypeAlias = tuple[_T, _T, int]
 
-_MAX_LENGTH: int
-_PLACEHOLDER_LEN: int
-_MIN_BEGIN_LEN: int
-_MIN_END_LEN: int
-_MIN_COMMON_LEN: int
-_MIN_DIFF_LEN: int
+_MAX_LENGTH: Final[int]
+_PLACEHOLDER_LEN: Final[int]
+_MIN_BEGIN_LEN: Final[int]
+_MIN_END_LEN: Final[int]
+_MIN_COMMON_LEN: Final[int]
+_MIN_DIFF_LEN: Final[int]
 
 def _shorten(s: str, prefixlen: int, suffixlen: int) -> str: ...
 def _common_shorten_repr(*args: str) -> tuple[str, ...]: ...
 def safe_repr(obj: object, short: bool = False) -> str: ...
 def strclass(cls: type) -> str: ...
 def sorted_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> tuple[list[_T], list[_T]]: ...
-def unorderable_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> tuple[list[_T], list[_T]]: ...
+def unorderable_list_difference(expected: MutableSequence[_T], actual: MutableSequence[_T]) -> tuple[list[_T], list[_T]]: ...
 def three_way_cmp(x: Any, y: Any) -> int: ...
 def _count_diff_all_purpose(actual: Sequence[_T], expected: Sequence[_T]) -> list[_Mismatch[_T]]: ...
 def _count_diff_hashable(actual: Sequence[_T], expected: Sequence[_T]) -> list[_Mismatch[_T]]: ...
diff --git a/mypy/typeshed/stdlib/urllib/parse.pyi b/mypy/typeshed/stdlib/urllib/parse.pyi
index 116754091d1a..785bb9678ec7 100644
--- a/mypy/typeshed/stdlib/urllib/parse.pyi
+++ b/mypy/typeshed/stdlib/urllib/parse.pyi
@@ -1,7 +1,7 @@
 import sys
 from collections.abc import Callable, Iterable, Mapping, Sequence
-from typing import Any, AnyStr, Generic, NamedTuple, TypeVar, overload
-from typing_extensions import Literal, TypeAlias
+from typing import Any, AnyStr, Generic, Literal, NamedTuple, TypeVar, overload
+from typing_extensions import TypeAlias
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -56,7 +56,7 @@ class _NetlocResultMixinBase(Generic[AnyStr]):
     @property
     def port(self) -> int | None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class _NetlocResultMixinStr(_NetlocResultMixinBase[str], _ResultMixinStr): ...
 class _NetlocResultMixinBytes(_NetlocResultMixinBase[bytes], _ResultMixinBytes): ...
@@ -198,13 +198,13 @@ else:
 
 # Requires an iterable of length 6
 @overload
-def urlunparse(components: Iterable[None]) -> Literal[b""]: ...
+def urlunparse(components: Iterable[None]) -> Literal[b""]: ...  # type: ignore[overload-overlap]
 @overload
 def urlunparse(components: Iterable[AnyStr | None]) -> AnyStr: ...
 
 # Requires an iterable of length 5
 @overload
-def urlunsplit(components: Iterable[None]) -> Literal[b""]: ...
+def urlunsplit(components: Iterable[None]) -> Literal[b""]: ...  # type: ignore[overload-overlap]
 @overload
 def urlunsplit(components: Iterable[AnyStr | None]) -> AnyStr: ...
 def unwrap(url: str) -> str: ...
diff --git a/mypy/typeshed/stdlib/urllib/request.pyi b/mypy/typeshed/stdlib/urllib/request.pyi
index 8f99c5837871..ad4f91fc31ae 100644
--- a/mypy/typeshed/stdlib/urllib/request.pyi
+++ b/mypy/typeshed/stdlib/urllib/request.pyi
@@ -52,16 +52,23 @@ _T = TypeVar("_T")
 _UrlopenRet: TypeAlias = Any
 _DataType: TypeAlias = ReadableBuffer | SupportsRead[bytes] | Iterable[bytes] | None
 
-def urlopen(
-    url: str | Request,
-    data: _DataType | None = None,
-    timeout: float | None = ...,
-    *,
-    cafile: str | None = None,
-    capath: str | None = None,
-    cadefault: bool = False,
-    context: ssl.SSLContext | None = None,
-) -> _UrlopenRet: ...
+if sys.version_info >= (3, 13):
+    def urlopen(
+        url: str | Request, data: _DataType | None = None, timeout: float | None = ..., *, context: ssl.SSLContext | None = None
+    ) -> _UrlopenRet: ...
+
+else:
+    def urlopen(
+        url: str | Request,
+        data: _DataType | None = None,
+        timeout: float | None = ...,
+        *,
+        cafile: str | None = None,
+        capath: str | None = None,
+        cadefault: bool = False,
+        context: ssl.SSLContext | None = None,
+    ) -> _UrlopenRet: ...
+
 def install_opener(opener: OpenerDirector) -> None: ...
 def build_opener(*handlers: BaseHandler | Callable[[], BaseHandler]) -> OpenerDirector: ...
 
@@ -72,6 +79,7 @@ else:
     def pathname2url(pathname: str) -> str: ...
 
 def getproxies() -> dict[str, str]: ...
+def getproxies_environment() -> dict[str, str]: ...
 def parse_http_list(s: str) -> list[str]: ...
 def parse_keqv_list(l: list[str]) -> dict[str, str]: ...
 
@@ -173,7 +181,7 @@ class HTTPPasswordMgr:
     def add_password(self, realm: str, uri: str | Sequence[str], user: str, passwd: str) -> None: ...
     def find_user_password(self, realm: str, authuri: str) -> tuple[str | None, str | None]: ...
     def is_suburi(self, base: str, test: str) -> bool: ...  # undocumented
-    def reduce_uri(self, uri: str, default_port: bool = True) -> str: ...  # undocumented
+    def reduce_uri(self, uri: str, default_port: bool = True) -> tuple[str, str]: ...  # undocumented
 
 class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr):
     def add_password(self, realm: str | None, uri: str | Sequence[str], user: str, passwd: str) -> None: ...
@@ -184,7 +192,7 @@ class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm):
         self, realm: str | None, uri: str | Sequence[str], user: str, passwd: str, is_authenticated: bool = False
     ) -> None: ...
     def update_authenticated(self, uri: str | Sequence[str], is_authenticated: bool = False) -> None: ...
-    def is_authenticated(self, authuri: str) -> bool: ...
+    def is_authenticated(self, authuri: str) -> bool | None: ...
 
 class AbstractBasicAuthHandler:
     rx: ClassVar[Pattern[str]]  # undocumented
@@ -212,7 +220,7 @@ class AbstractDigestAuthHandler:
     def http_error_auth_reqed(self, auth_header: str, host: str, req: Request, headers: HTTPMessage) -> None: ...
     def retry_http_digest_auth(self, req: Request, auth: str) -> _UrlopenRet | None: ...
     def get_cnonce(self, nonce: str) -> str: ...
-    def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str: ...
+    def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str | None: ...
     def get_algorithm_impls(self, algorithm: str) -> tuple[Callable[[str], str], Callable[[str, str], str]]: ...
     def get_entity_digest(self, data: ReadableBuffer | None, chal: Mapping[str, str]) -> str | None: ...
 
@@ -228,6 +236,8 @@ class _HTTPConnectionProtocol(Protocol):
     def __call__(
         self,
         host: str,
+        /,
+        *,
         port: int | None = ...,
         timeout: float = ...,
         source_address: tuple[str, int] | None = ...,
@@ -235,7 +245,11 @@ class _HTTPConnectionProtocol(Protocol):
     ) -> HTTPConnection: ...
 
 class AbstractHTTPHandler(BaseHandler):  # undocumented
-    def __init__(self, debuglevel: int = 0) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __init__(self, debuglevel: int | None = None) -> None: ...
+    else:
+        def __init__(self, debuglevel: int = 0) -> None: ...
+
     def set_http_debuglevel(self, level: int) -> None: ...
     def do_request_(self, request: Request) -> Request: ...
     def do_open(self, http_class: _HTTPConnectionProtocol, req: Request, **http_conn_args: Any) -> HTTPResponse: ...
@@ -245,9 +259,15 @@ class HTTPHandler(AbstractHTTPHandler):
     def http_request(self, request: Request) -> Request: ...  # undocumented
 
 class HTTPSHandler(AbstractHTTPHandler):
-    def __init__(
-        self, debuglevel: int = 0, context: ssl.SSLContext | None = None, check_hostname: bool | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self, debuglevel: int | None = None, context: ssl.SSLContext | None = None, check_hostname: bool | None = None
+        ) -> None: ...
+    else:
+        def __init__(
+            self, debuglevel: int = 0, context: ssl.SSLContext | None = None, check_hostname: bool | None = None
+        ) -> None: ...
+
     def https_open(self, req: Request) -> HTTPResponse: ...
     def https_request(self, request: Request) -> Request: ...  # undocumented
 
@@ -269,7 +289,7 @@ class ftpwrapper:  # undocumented
     def file_close(self) -> None: ...
     def init(self) -> None: ...
     def real_close(self) -> None: ...
-    def retrfile(self, file: str, type: str) -> tuple[addclosehook, int]: ...
+    def retrfile(self, file: str, type: str) -> tuple[addclosehook, int | None]: ...
 
 class FTPHandler(BaseHandler):
     def ftp_open(self, req: Request) -> addinfourl: ...
@@ -326,6 +346,7 @@ class URLopener:
     def open_https(self, url: str, data: ReadableBuffer | None = None) -> _UrlopenRet: ...  # undocumented
     def open_local_file(self, url: str) -> addinfourl: ...  # undocumented
     def open_unknown_proxy(self, proxy: str, fullurl: str, data: ReadableBuffer | None = None) -> None: ...  # undocumented
+    def __del__(self) -> None: ...
 
 class FancyURLopener(URLopener):
     def prompt_user_passwd(self, host: str, realm: str) -> tuple[str, str]: ...
diff --git a/mypy/typeshed/stdlib/urllib/response.pyi b/mypy/typeshed/stdlib/urllib/response.pyi
index 61ba687076b2..bbec4cacc750 100644
--- a/mypy/typeshed/stdlib/urllib/response.pyi
+++ b/mypy/typeshed/stdlib/urllib/response.pyi
@@ -1,39 +1,23 @@
 import sys
+import tempfile
 from _typeshed import ReadableBuffer
 from collections.abc import Callable, Iterable
 from email.message import Message
 from types import TracebackType
-from typing import IO, Any, BinaryIO
-from typing_extensions import Self
+from typing import IO, Any
 
 __all__ = ["addbase", "addclosehook", "addinfo", "addinfourl"]
 
-class addbase(BinaryIO):
+class addbase(tempfile._TemporaryFileWrapper[bytes]):
     fp: IO[bytes]
     def __init__(self, fp: IO[bytes]) -> None: ...
-    def __enter__(self) -> Self: ...
     def __exit__(
         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
     ) -> None: ...
-    def __iter__(self) -> Self: ...
-    def __next__(self) -> bytes: ...
-    def close(self) -> None: ...
     # These methods don't actually exist, but the class inherits at runtime from
     # tempfile._TemporaryFileWrapper, which uses __getattr__ to delegate to the
     # underlying file object. To satisfy the BinaryIO interface, we pretend that this
     # class has these additional methods.
-    def fileno(self) -> int: ...
-    def flush(self) -> None: ...
-    def isatty(self) -> bool: ...
-    def read(self, n: int = ...) -> bytes: ...
-    def readable(self) -> bool: ...
-    def readline(self, limit: int = ...) -> bytes: ...
-    def readlines(self, hint: int = ...) -> list[bytes]: ...
-    def seek(self, offset: int, whence: int = ...) -> int: ...
-    def seekable(self) -> bool: ...
-    def tell(self) -> int: ...
-    def truncate(self, size: int | None = ...) -> int: ...
-    def writable(self) -> bool: ...
     def write(self, s: ReadableBuffer) -> int: ...
     def writelines(self, lines: Iterable[ReadableBuffer]) -> None: ...
 
diff --git a/mypy/typeshed/stdlib/urllib/robotparser.pyi b/mypy/typeshed/stdlib/urllib/robotparser.pyi
index d218c3dc6c0f..14ceef550dab 100644
--- a/mypy/typeshed/stdlib/urllib/robotparser.pyi
+++ b/mypy/typeshed/stdlib/urllib/robotparser.pyi
@@ -1,4 +1,3 @@
-import sys
 from collections.abc import Iterable
 from typing import NamedTuple
 
@@ -18,5 +17,4 @@ class RobotFileParser:
     def modified(self) -> None: ...
     def crawl_delay(self, useragent: str) -> str | None: ...
     def request_rate(self, useragent: str) -> RequestRate | None: ...
-    if sys.version_info >= (3, 8):
-        def site_maps(self) -> list[str] | None: ...
+    def site_maps(self) -> list[str] | None: ...
diff --git a/mypy/typeshed/stdlib/uuid.pyi b/mypy/typeshed/stdlib/uuid.pyi
index 935e44e80dfa..1be7a5ef009f 100644
--- a/mypy/typeshed/stdlib/uuid.pyi
+++ b/mypy/typeshed/stdlib/uuid.pyi
@@ -1,70 +1,69 @@
+import builtins
 import sys
 from _typeshed import Unused
 from enum import Enum
 from typing_extensions import TypeAlias
 
-# Because UUID has properties called int and bytes we need to rename these temporarily.
-_Int: TypeAlias = int
-_Bytes: TypeAlias = bytes
 _FieldsType: TypeAlias = tuple[int, int, int, int, int, int]
 
 class SafeUUID(Enum):
-    safe: int
-    unsafe: int
-    unknown: None
+    safe = 0
+    unsafe = -1
+    unknown = None
 
 class UUID:
     def __init__(
         self,
         hex: str | None = None,
-        bytes: _Bytes | None = None,
-        bytes_le: _Bytes | None = None,
+        bytes: builtins.bytes | None = None,
+        bytes_le: builtins.bytes | None = None,
         fields: _FieldsType | None = None,
-        int: _Int | None = None,
-        version: _Int | None = None,
+        int: builtins.int | None = None,
+        version: builtins.int | None = None,
         *,
         is_safe: SafeUUID = ...,
     ) -> None: ...
     @property
     def is_safe(self) -> SafeUUID: ...
     @property
-    def bytes(self) -> _Bytes: ...
+    def bytes(self) -> builtins.bytes: ...
     @property
-    def bytes_le(self) -> _Bytes: ...
+    def bytes_le(self) -> builtins.bytes: ...
     @property
-    def clock_seq(self) -> _Int: ...
+    def clock_seq(self) -> builtins.int: ...
     @property
-    def clock_seq_hi_variant(self) -> _Int: ...
+    def clock_seq_hi_variant(self) -> builtins.int: ...
     @property
-    def clock_seq_low(self) -> _Int: ...
+    def clock_seq_low(self) -> builtins.int: ...
     @property
     def fields(self) -> _FieldsType: ...
     @property
     def hex(self) -> str: ...
     @property
-    def int(self) -> _Int: ...
+    def int(self) -> builtins.int: ...
     @property
-    def node(self) -> _Int: ...
+    def node(self) -> builtins.int: ...
     @property
-    def time(self) -> _Int: ...
+    def time(self) -> builtins.int: ...
     @property
-    def time_hi_version(self) -> _Int: ...
+    def time_hi_version(self) -> builtins.int: ...
     @property
-    def time_low(self) -> _Int: ...
+    def time_low(self) -> builtins.int: ...
     @property
-    def time_mid(self) -> _Int: ...
+    def time_mid(self) -> builtins.int: ...
     @property
     def urn(self) -> str: ...
     @property
     def variant(self) -> str: ...
     @property
-    def version(self) -> _Int | None: ...
-    def __int__(self) -> _Int: ...
+    def version(self) -> builtins.int | None: ...
+    def __int__(self) -> builtins.int: ...
     def __eq__(self, other: object) -> bool: ...
     def __lt__(self, other: UUID) -> bool: ...
     def __le__(self, other: UUID) -> bool: ...
     def __gt__(self, other: UUID) -> bool: ...
     def __ge__(self, other: UUID) -> bool: ...
+    def __hash__(self) -> builtins.int: ...
 
 if sys.version_info >= (3, 9):
     def getnode() -> int: ...
@@ -72,7 +71,7 @@ if sys.version_info >= (3, 9):
 else:
     def getnode(*, getters: Unused = None) -> int: ...  # undocumented
 
-def uuid1(node: _Int | None = None, clock_seq: _Int | None = None) -> UUID: ...
+def uuid1(node: int | None = None, clock_seq: int | None = None) -> UUID: ...
 
 if sys.version_info >= (3, 12):
     def uuid3(namespace: UUID, name: str | bytes) -> UUID: ...
@@ -96,3 +95,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/venv/__init__.pyi b/mypy/typeshed/stdlib/venv/__init__.pyi
index f184649f10f0..0490c35b44f2 100644
--- a/mypy/typeshed/stdlib/venv/__init__.pyi
+++ b/mypy/typeshed/stdlib/venv/__init__.pyi
@@ -1,7 +1,7 @@
 import logging
 import sys
 from _typeshed import StrOrBytesPath
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
 from types import SimpleNamespace
 
 logger: logging.Logger
@@ -17,7 +17,20 @@ class EnvBuilder:
     with_pip: bool
     prompt: str | None
 
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            system_site_packages: bool = False,
+            clear: bool = False,
+            symlinks: bool = False,
+            upgrade: bool = False,
+            with_pip: bool = False,
+            prompt: str | None = None,
+            upgrade_deps: bool = False,
+            *,
+            scm_ignore_files: Iterable[str] = ...,
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
         def __init__(
             self,
             system_site_packages: bool = False,
@@ -54,8 +67,23 @@ class EnvBuilder:
     def install_scripts(self, context: SimpleNamespace, path: str) -> None: ...
     if sys.version_info >= (3, 9):
         def upgrade_dependencies(self, context: SimpleNamespace) -> None: ...
+    if sys.version_info >= (3, 13):
+        def create_git_ignore_file(self, context: SimpleNamespace) -> None: ...
 
-if sys.version_info >= (3, 9):
+if sys.version_info >= (3, 13):
+    def create(
+        env_dir: StrOrBytesPath,
+        system_site_packages: bool = False,
+        clear: bool = False,
+        symlinks: bool = False,
+        with_pip: bool = False,
+        prompt: str | None = None,
+        upgrade_deps: bool = False,
+        *,
+        scm_ignore_files: Iterable[str] = ...,
+    ) -> None: ...
+
+elif sys.version_info >= (3, 9):
     def create(
         env_dir: StrOrBytesPath,
         system_site_packages: bool = False,
diff --git a/mypy/typeshed/stdlib/warnings.pyi b/mypy/typeshed/stdlib/warnings.pyi
index 6222eb65918a..49c98cb07540 100644
--- a/mypy/typeshed/stdlib/warnings.pyi
+++ b/mypy/typeshed/stdlib/warnings.pyi
@@ -1,9 +1,10 @@
+import re
 import sys
 from _warnings import warn as warn, warn_explicit as warn_explicit
 from collections.abc import Sequence
 from types import ModuleType, TracebackType
-from typing import Any, Generic, TextIO, TypeVar, overload
-from typing_extensions import Literal, TypeAlias
+from typing import Any, Generic, Literal, TextIO, overload
+from typing_extensions import LiteralString, TypeAlias, TypeVar
 
 __all__ = [
     "warn",
@@ -16,10 +17,17 @@ __all__ = [
     "catch_warnings",
 ]
 
-_W = TypeVar("_W", bound=list[WarningMessage] | None)
-_ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "module", "once"]
+if sys.version_info >= (3, 13):
+    __all__ += ["deprecated"]
 
-filters: Sequence[tuple[str, str | None, type[Warning], str | None, int]]  # undocumented, do not mutate
+_T = TypeVar("_T")
+_W_co = TypeVar("_W_co", bound=list[WarningMessage] | None, default=list[WarningMessage] | None, covariant=True)
+
+if sys.version_info >= (3, 14):
+    _ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "module", "once"]
+else:
+    _ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "all", "module", "once"]
+filters: Sequence[tuple[str, re.Pattern[str] | None, type[Warning], re.Pattern[str] | None, int]]  # undocumented, do not mutate
 
 def showwarning(
     message: Warning | str,
@@ -59,7 +67,7 @@ class WarningMessage:
         source: Any | None = None,
     ) -> None: ...
 
-class catch_warnings(Generic[_W]):
+class catch_warnings(Generic[_W_co]):
     if sys.version_info >= (3, 11):
         @overload
         def __init__(
@@ -85,7 +93,7 @@ class catch_warnings(Generic[_W]):
         ) -> None: ...
         @overload
         def __init__(
-            self: catch_warnings[list[WarningMessage] | None],
+            self,
             *,
             record: bool,
             module: ModuleType | None = None,
@@ -102,11 +110,17 @@ class catch_warnings(Generic[_W]):
             self: catch_warnings[list[WarningMessage]], *, record: Literal[True], module: ModuleType | None = None
         ) -> None: ...
         @overload
-        def __init__(
-            self: catch_warnings[list[WarningMessage] | None], *, record: bool, module: ModuleType | None = None
-        ) -> None: ...
+        def __init__(self, *, record: bool, module: ModuleType | None = None) -> None: ...
 
-    def __enter__(self) -> _W: ...
+    def __enter__(self) -> _W_co: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None: ...
+
+if sys.version_info >= (3, 13):
+    class deprecated:
+        message: LiteralString
+        category: type[Warning] | None
+        stacklevel: int
+        def __init__(self, message: LiteralString, /, *, category: type[Warning] | None = ..., stacklevel: int = 1) -> None: ...
+        def __call__(self, arg: _T, /) -> _T: ...
diff --git a/mypy/typeshed/stdlib/wave.pyi b/mypy/typeshed/stdlib/wave.pyi
index 0d004d6b2d8a..9319d5347c79 100644
--- a/mypy/typeshed/stdlib/wave.pyi
+++ b/mypy/typeshed/stdlib/wave.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import ReadableBuffer, Unused
-from typing import IO, Any, BinaryIO, NamedTuple, NoReturn, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Any, BinaryIO, Final, Literal, NamedTuple, NoReturn, overload
+from typing_extensions import Self, TypeAlias, deprecated
 
 if sys.version_info >= (3, 9):
     __all__ = ["open", "Error", "Wave_read", "Wave_write"]
@@ -12,7 +12,7 @@ _File: TypeAlias = str | IO[bytes]
 
 class Error(Exception): ...
 
-WAVE_FORMAT_PCM: Literal[1]
+WAVE_FORMAT_PCM: Final = 1
 
 class _wave_params(NamedTuple):
     nchannels: int
@@ -26,6 +26,7 @@ class Wave_read:
     def __init__(self, f: _File) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
+    def __del__(self) -> None: ...
     def getfp(self) -> BinaryIO | None: ...
     def rewind(self) -> None: ...
     def close(self) -> None: ...
@@ -37,7 +38,9 @@ class Wave_read:
     def getcomptype(self) -> str: ...
     def getcompname(self) -> str: ...
     def getparams(self) -> _wave_params: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
     def getmarkers(self) -> None: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
     def getmark(self, id: Any) -> NoReturn: ...
     def setpos(self, pos: int) -> None: ...
     def readframes(self, nframes: int) -> bytes: ...
@@ -46,6 +49,7 @@ class Wave_write:
     def __init__(self, f: _File) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
+    def __del__(self) -> None: ...
     def setnchannels(self, nchannels: int) -> None: ...
     def getnchannels(self) -> int: ...
     def setsampwidth(self, sampwidth: int) -> None: ...
@@ -59,8 +63,11 @@ class Wave_write:
     def getcompname(self) -> str: ...
     def setparams(self, params: _wave_params | tuple[int, int, int, int, str, str]) -> None: ...
     def getparams(self) -> _wave_params: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
     def setmark(self, id: Any, pos: Any, name: Any) -> NoReturn: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
     def getmark(self, id: Any) -> NoReturn: ...
+    @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
     def getmarkers(self) -> None: ...
     def tell(self) -> int: ...
     def writeframesraw(self, data: ReadableBuffer) -> None: ...
diff --git a/mypy/typeshed/stdlib/weakref.pyi b/mypy/typeshed/stdlib/weakref.pyi
index 13f48fe85a8d..05a7b2bcda66 100644
--- a/mypy/typeshed/stdlib/weakref.pyi
+++ b/mypy/typeshed/stdlib/weakref.pyi
@@ -1,19 +1,14 @@
 import sys
 from _typeshed import SupportsKeysAndGetItem
-from _weakref import (
-    CallableProxyType as CallableProxyType,
-    ProxyType as ProxyType,
-    ReferenceType as ReferenceType,
-    getweakrefcount as getweakrefcount,
-    getweakrefs as getweakrefs,
-    proxy as proxy,
-    ref as ref,
-)
+from _weakref import getweakrefcount as getweakrefcount, getweakrefs as getweakrefs, proxy as proxy
 from _weakrefset import WeakSet as WeakSet
 from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping
-from typing import Any, Generic, TypeVar, overload
+from typing import Any, ClassVar, Generic, TypeVar, final, overload
 from typing_extensions import ParamSpec, Self
 
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
 __all__ = [
     "ref",
     "proxy",
@@ -40,20 +35,61 @@ _P = ParamSpec("_P")
 
 ProxyTypes: tuple[type[Any], ...]
 
-class WeakMethod(ref[_CallableT], Generic[_CallableT]):
-    def __new__(cls, meth: _CallableT, callback: Callable[[Self], object] | None = None) -> Self: ...
+# These classes are implemented in C and imported from _weakref at runtime. However,
+# they consider themselves to live in the weakref module for sys.version_info >= (3, 11),
+# so defining their stubs here means we match their __module__ value.
+# Prior to 3.11 they did not declare a module for themselves and ended up looking like they
+# came from the builtin module at runtime, which was just wrong, and we won't attempt to
+# duplicate that.
+
+@final
+class CallableProxyType(Generic[_CallableT]):  # "weakcallableproxy"
+    def __eq__(self, value: object, /) -> bool: ...
+    def __getattr__(self, attr: str) -> Any: ...
+    __call__: _CallableT
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+@final
+class ProxyType(Generic[_T]):  # "weakproxy"
+    def __eq__(self, value: object, /) -> bool: ...
+    def __getattr__(self, attr: str) -> Any: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+class ReferenceType(Generic[_T]):  # "weakref"
+    __callback__: Callable[[Self], Any]
+    def __new__(cls, o: _T, callback: Callable[[Self], Any] | None = ..., /) -> Self: ...
+    def __call__(self) -> _T | None: ...
+    def __eq__(self, value: object, /) -> bool: ...
+    def __hash__(self) -> int: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+ref = ReferenceType
+
+# everything below here is implemented in weakref.py
+
+class WeakMethod(ref[_CallableT]):
+    def __new__(cls, meth: _CallableT, callback: Callable[[Self], Any] | None = None) -> Self: ...
     def __call__(self) -> _CallableT | None: ...
     def __eq__(self, other: object) -> bool: ...
     def __ne__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
 
 class WeakValueDictionary(MutableMapping[_KT, _VT]):
     @overload
     def __init__(self) -> None: ...
     @overload
-    def __init__(self: WeakValueDictionary[_KT, _VT], __other: Mapping[_KT, _VT] | Iterable[tuple[_KT, _VT]]) -> None: ...
+    def __init__(
+        self: WeakValueDictionary[_KT, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        other: Mapping[_KT, _VT] | Iterable[tuple[_KT, _VT]],
+        /,
+    ) -> None: ...
     @overload
     def __init__(
-        self: WeakValueDictionary[str, _VT], __other: Mapping[str, _VT] | Iterable[tuple[str, _VT]] = (), **kwargs: _VT
+        self: WeakValueDictionary[str, _VT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
+        other: Mapping[str, _VT] | Iterable[tuple[str, _VT]] = (),
+        /,
+        **kwargs: _VT,
     ) -> None: ...
     def __len__(self) -> int: ...
     def __getitem__(self, key: _KT) -> _VT: ...
@@ -64,17 +100,29 @@ class WeakValueDictionary(MutableMapping[_KT, _VT]):
     def copy(self) -> WeakValueDictionary[_KT, _VT]: ...
     __copy__ = copy
     def __deepcopy__(self, memo: Any) -> Self: ...
+    @overload
+    def get(self, key: _KT, default: None = None) -> _VT | None: ...
+    @overload
+    def get(self, key: _KT, default: _T) -> _VT | _T: ...
     # These are incompatible with Mapping
     def keys(self) -> Iterator[_KT]: ...  # type: ignore[override]
     def values(self) -> Iterator[_VT]: ...  # type: ignore[override]
     def items(self) -> Iterator[tuple[_KT, _VT]]: ...  # type: ignore[override]
     def itervaluerefs(self) -> Iterator[KeyedRef[_KT, _VT]]: ...
     def valuerefs(self) -> list[KeyedRef[_KT, _VT]]: ...
-    def setdefault(self, key: _KT, default: _VT) -> _VT: ...  # type: ignore[override]
+    def setdefault(self, key: _KT, default: _VT) -> _VT: ...
     @overload
     def pop(self, key: _KT) -> _VT: ...
     @overload
-    def pop(self, key: _KT, default: _VT | _T = ...) -> _VT | _T: ...
+    def pop(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _T) -> _VT | _T: ...
+    @overload
+    def update(self, other: SupportsKeysAndGetItem[_KT, _VT], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, other: Iterable[tuple[_KT, _VT]], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, other: None = None, /, **kwargs: _VT) -> None: ...
     if sys.version_info >= (3, 9):
         def __or__(self, other: Mapping[_T1, _T2]) -> WeakValueDictionary[_KT | _T1, _VT | _T2]: ...
         def __ror__(self, other: Mapping[_T1, _T2]) -> WeakValueDictionary[_KT | _T1, _VT | _T2]: ...
@@ -86,9 +134,8 @@ class WeakValueDictionary(MutableMapping[_KT, _VT]):
 
 class KeyedRef(ref[_T], Generic[_KT, _T]):
     key: _KT
-    # This __new__ method uses a non-standard name for the "cls" parameter
-    def __new__(type, ob: _T, callback: Callable[[_T], Any], key: _KT) -> Self: ...
-    def __init__(self, ob: _T, callback: Callable[[_T], Any], key: _KT) -> None: ...
+    def __new__(type, ob: _T, callback: Callable[[Self], Any], key: _KT) -> Self: ...
+    def __init__(self, ob: _T, callback: Callable[[Self], Any], key: _KT) -> None: ...
 
 class WeakKeyDictionary(MutableMapping[_KT, _VT]):
     @overload
@@ -104,6 +151,10 @@ class WeakKeyDictionary(MutableMapping[_KT, _VT]):
     def copy(self) -> WeakKeyDictionary[_KT, _VT]: ...
     __copy__ = copy
     def __deepcopy__(self, memo: Any) -> Self: ...
+    @overload
+    def get(self, key: _KT, default: None = None) -> _VT | None: ...
+    @overload
+    def get(self, key: _KT, default: _T) -> _VT | _T: ...
     # These are incompatible with Mapping
     def keys(self) -> Iterator[_KT]: ...  # type: ignore[override]
     def values(self) -> Iterator[_VT]: ...  # type: ignore[override]
@@ -117,7 +168,15 @@ class WeakKeyDictionary(MutableMapping[_KT, _VT]):
     @overload
     def pop(self, key: _KT) -> _VT: ...
     @overload
-    def pop(self, key: _KT, default: _VT | _T = ...) -> _VT | _T: ...
+    def pop(self, key: _KT, default: _VT) -> _VT: ...
+    @overload
+    def pop(self, key: _KT, default: _T) -> _VT | _T: ...
+    @overload
+    def update(self, dict: SupportsKeysAndGetItem[_KT, _VT], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, dict: Iterable[tuple[_KT, _VT]], /, **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, dict: None = None, /, **kwargs: _VT) -> None: ...
     if sys.version_info >= (3, 9):
         def __or__(self, other: Mapping[_T1, _T2]) -> WeakKeyDictionary[_KT | _T1, _VT | _T2]: ...
         def __ror__(self, other: Mapping[_T1, _T2]) -> WeakKeyDictionary[_KT | _T1, _VT | _T2]: ...
@@ -127,11 +186,11 @@ class WeakKeyDictionary(MutableMapping[_KT, _VT]):
         @overload
         def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...
 
-class finalize:  # TODO: This is a good candidate for to be a `Generic[_P, _T]` class
-    def __init__(self, __obj: object, __func: Callable[_P, Any], *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+class finalize(Generic[_P, _T]):
+    def __init__(self, obj: _T, func: Callable[_P, Any], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
     def __call__(self, _: Any = None) -> Any | None: ...
-    def detach(self) -> tuple[Any, Any, tuple[Any, ...], dict[str, Any]] | None: ...
-    def peek(self) -> tuple[Any, Any, tuple[Any, ...], dict[str, Any]] | None: ...
+    def detach(self) -> tuple[_T, Callable[_P, Any], tuple[Any, ...], dict[str, Any]] | None: ...
+    def peek(self) -> tuple[_T, Callable[_P, Any], tuple[Any, ...], dict[str, Any]] | None: ...
     @property
     def alive(self) -> bool: ...
     atexit: bool
diff --git a/mypy/typeshed/stdlib/webbrowser.pyi b/mypy/typeshed/stdlib/webbrowser.pyi
index 02edd42e7d59..773786c24821 100644
--- a/mypy/typeshed/stdlib/webbrowser.pyi
+++ b/mypy/typeshed/stdlib/webbrowser.pyi
@@ -1,7 +1,8 @@
 import sys
 from abc import abstractmethod
 from collections.abc import Callable, Sequence
-from typing_extensions import Literal
+from typing import Literal
+from typing_extensions import deprecated
 
 __all__ = ["Error", "open", "open_new", "open_new_tab", "get", "register"]
 
@@ -43,8 +44,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,16 +58,16 @@ 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: ...
 
 if sys.platform == "darwin":
-    class MacOSX(BaseBrowser):
-        def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
+    if sys.version_info < (3, 13):
+        @deprecated("Deprecated in 3.11, to be removed in 3.13.")
+        class MacOSX(BaseBrowser):
+            def __init__(self, name: str) -> None: ...
+            def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
 
     class MacOSXOSAScript(BaseBrowser):  # In runtime this class does not have `name` and `basename`
         if sys.version_info >= (3, 11):
diff --git a/mypy/typeshed/stdlib/winreg.pyi b/mypy/typeshed/stdlib/winreg.pyi
index 70ea6a1ced11..d4d04817d7e0 100644
--- a/mypy/typeshed/stdlib/winreg.pyi
+++ b/mypy/typeshed/stdlib/winreg.pyi
@@ -1,35 +1,64 @@
 import sys
+from _typeshed import ReadableBuffer, Unused
 from types import TracebackType
-from typing import Any
-from typing_extensions import Literal, Self, TypeAlias, final
+from typing import Any, Final, Literal, final, overload
+from typing_extensions import Self, TypeAlias
 
 if sys.platform == "win32":
     _KeyType: TypeAlias = HKEYType | int
-    def CloseKey(__hkey: _KeyType) -> None: ...
-    def ConnectRegistry(__computer_name: str | None, __key: _KeyType) -> HKEYType: ...
-    def CreateKey(__key: _KeyType, __sub_key: str | None) -> HKEYType: ...
+    def CloseKey(hkey: _KeyType, /) -> None: ...
+    def ConnectRegistry(computer_name: str | None, key: _KeyType, /) -> HKEYType: ...
+    def CreateKey(key: _KeyType, sub_key: str | None, /) -> HKEYType: ...
     def CreateKeyEx(key: _KeyType, sub_key: str | None, reserved: int = 0, access: int = 131078) -> HKEYType: ...
-    def DeleteKey(__key: _KeyType, __sub_key: str) -> None: ...
+    def DeleteKey(key: _KeyType, sub_key: str, /) -> None: ...
     def DeleteKeyEx(key: _KeyType, sub_key: str, access: int = 256, reserved: int = 0) -> None: ...
-    def DeleteValue(__key: _KeyType, __value: str) -> None: ...
-    def EnumKey(__key: _KeyType, __index: int) -> str: ...
-    def EnumValue(__key: _KeyType, __index: int) -> tuple[str, Any, int]: ...
-    def ExpandEnvironmentStrings(__string: str) -> str: ...
-    def FlushKey(__key: _KeyType) -> None: ...
-    def LoadKey(__key: _KeyType, __sub_key: str, __file_name: str) -> None: ...
+    def DeleteValue(key: _KeyType, value: str, /) -> None: ...
+    def EnumKey(key: _KeyType, index: int, /) -> str: ...
+    def EnumValue(key: _KeyType, index: int, /) -> tuple[str, Any, int]: ...
+    def ExpandEnvironmentStrings(string: str, /) -> str: ...
+    def FlushKey(key: _KeyType, /) -> None: ...
+    def LoadKey(key: _KeyType, sub_key: str, file_name: str, /) -> None: ...
     def OpenKey(key: _KeyType, sub_key: str, reserved: int = 0, access: int = 131097) -> HKEYType: ...
     def OpenKeyEx(key: _KeyType, sub_key: str, reserved: int = 0, access: int = 131097) -> HKEYType: ...
-    def QueryInfoKey(__key: _KeyType) -> tuple[int, int, int]: ...
-    def QueryValue(__key: _KeyType, __sub_key: str | None) -> str: ...
-    def QueryValueEx(__key: _KeyType, __name: str) -> tuple[Any, int]: ...
-    def SaveKey(__key: _KeyType, __file_name: str) -> None: ...
-    def SetValue(__key: _KeyType, __sub_key: str, __type: int, __value: str) -> None: ...
+    def QueryInfoKey(key: _KeyType, /) -> tuple[int, int, int]: ...
+    def QueryValue(key: _KeyType, sub_key: str | None, /) -> str: ...
+    def QueryValueEx(key: _KeyType, name: str, /) -> tuple[Any, int]: ...
+    def SaveKey(key: _KeyType, file_name: str, /) -> None: ...
+    def SetValue(key: _KeyType, sub_key: str, type: int, value: str, /) -> None: ...
+    @overload  # type=REG_DWORD|REG_QWORD
     def SetValueEx(
-        __key: _KeyType, __value_name: str | None, __reserved: Any, __type: int, __value: str | int
-    ) -> None: ...  # reserved is ignored
-    def DisableReflectionKey(__key: _KeyType) -> None: ...
-    def EnableReflectionKey(__key: _KeyType) -> None: ...
-    def QueryReflectionKey(__key: _KeyType) -> bool: ...
+        key: _KeyType, value_name: str | None, reserved: Unused, type: Literal[4, 5], value: int | None, /
+    ) -> None: ...
+    @overload  # type=REG_SZ|REG_EXPAND_SZ
+    def SetValueEx(
+        key: _KeyType, value_name: str | None, reserved: Unused, type: Literal[1, 2], value: str | None, /
+    ) -> None: ...
+    @overload  # type=REG_MULTI_SZ
+    def SetValueEx(
+        key: _KeyType, value_name: str | None, reserved: Unused, type: Literal[7], value: list[str] | None, /
+    ) -> None: ...
+    @overload  # type=REG_BINARY and everything else
+    def SetValueEx(
+        key: _KeyType,
+        value_name: str | None,
+        reserved: Unused,
+        type: Literal[0, 3, 8, 9, 10, 11],
+        value: ReadableBuffer | None,
+        /,
+    ) -> None: ...
+    @overload  # Unknown or undocumented
+    def SetValueEx(
+        key: _KeyType,
+        value_name: str | None,
+        reserved: Unused,
+        type: int,
+        value: int | str | list[str] | ReadableBuffer | None,
+        /,
+    ) -> None: ...
+    def DisableReflectionKey(key: _KeyType, /) -> None: ...
+    def EnableReflectionKey(key: _KeyType, /) -> None: ...
+    def QueryReflectionKey(key: _KeyType, /) -> bool: ...
+
     HKEY_CLASSES_ROOT: int
     HKEY_CURRENT_USER: int
     HKEY_LOCAL_MACHINE: int
@@ -38,52 +67,52 @@ if sys.platform == "win32":
     HKEY_CURRENT_CONFIG: int
     HKEY_DYN_DATA: int
 
-    KEY_ALL_ACCESS: Literal[983103]
-    KEY_WRITE: Literal[131078]
-    KEY_READ: Literal[131097]
-    KEY_EXECUTE: Literal[131097]
-    KEY_QUERY_VALUE: Literal[1]
-    KEY_SET_VALUE: Literal[2]
-    KEY_CREATE_SUB_KEY: Literal[4]
-    KEY_ENUMERATE_SUB_KEYS: Literal[8]
-    KEY_NOTIFY: Literal[16]
-    KEY_CREATE_LINK: Literal[32]
+    KEY_ALL_ACCESS: Final = 983103
+    KEY_WRITE: Final = 131078
+    KEY_READ: Final = 131097
+    KEY_EXECUTE: Final = 131097
+    KEY_QUERY_VALUE: Final = 1
+    KEY_SET_VALUE: Final = 2
+    KEY_CREATE_SUB_KEY: Final = 4
+    KEY_ENUMERATE_SUB_KEYS: Final = 8
+    KEY_NOTIFY: Final = 16
+    KEY_CREATE_LINK: Final = 32
 
-    KEY_WOW64_64KEY: Literal[256]
-    KEY_WOW64_32KEY: Literal[512]
+    KEY_WOW64_64KEY: Final = 256
+    KEY_WOW64_32KEY: Final = 512
 
-    REG_BINARY: Literal[3]
-    REG_DWORD: Literal[4]
-    REG_DWORD_LITTLE_ENDIAN: Literal[4]
-    REG_DWORD_BIG_ENDIAN: Literal[5]
-    REG_EXPAND_SZ: Literal[2]
-    REG_LINK: Literal[6]
-    REG_MULTI_SZ: Literal[7]
-    REG_NONE: Literal[0]
-    REG_QWORD: Literal[11]
-    REG_QWORD_LITTLE_ENDIAN: Literal[11]
-    REG_RESOURCE_LIST: Literal[8]
-    REG_FULL_RESOURCE_DESCRIPTOR: Literal[9]
-    REG_RESOURCE_REQUIREMENTS_LIST: Literal[10]
-    REG_SZ: Literal[1]
+    REG_BINARY: Final = 3
+    REG_DWORD: Final = 4
+    REG_DWORD_LITTLE_ENDIAN: Final = 4
+    REG_DWORD_BIG_ENDIAN: Final = 5
+    REG_EXPAND_SZ: Final = 2
+    REG_LINK: Final = 6
+    REG_MULTI_SZ: Final = 7
+    REG_NONE: Final = 0
+    REG_QWORD: Final = 11
+    REG_QWORD_LITTLE_ENDIAN: Final = 11
+    REG_RESOURCE_LIST: Final = 8
+    REG_FULL_RESOURCE_DESCRIPTOR: Final = 9
+    REG_RESOURCE_REQUIREMENTS_LIST: Final = 10
+    REG_SZ: Final = 1
 
-    REG_CREATED_NEW_KEY: int  # undocumented
-    REG_LEGAL_CHANGE_FILTER: int  # undocumented
-    REG_LEGAL_OPTION: int  # undocumented
-    REG_NOTIFY_CHANGE_ATTRIBUTES: int  # undocumented
-    REG_NOTIFY_CHANGE_LAST_SET: int  # undocumented
-    REG_NOTIFY_CHANGE_NAME: int  # undocumented
-    REG_NOTIFY_CHANGE_SECURITY: int  # undocumented
-    REG_NO_LAZY_FLUSH: int  # undocumented
-    REG_OPENED_EXISTING_KEY: int  # undocumented
-    REG_OPTION_BACKUP_RESTORE: int  # undocumented
-    REG_OPTION_CREATE_LINK: int  # undocumented
-    REG_OPTION_NON_VOLATILE: int  # undocumented
-    REG_OPTION_OPEN_LINK: int  # undocumented
-    REG_OPTION_RESERVED: int  # undocumented
-    REG_OPTION_VOLATILE: int  # undocumented
-    REG_REFRESH_HIVE: int  # undocumented
-    REG_WHOLE_HIVE_VOLATILE: int  # undocumented
+    REG_CREATED_NEW_KEY: Final = 1  # undocumented
+    REG_LEGAL_CHANGE_FILTER: Final = 268435471  # undocumented
+    REG_LEGAL_OPTION: Final = 31  # undocumented
+    REG_NOTIFY_CHANGE_ATTRIBUTES: Final = 2  # undocumented
+    REG_NOTIFY_CHANGE_LAST_SET: Final = 4  # undocumented
+    REG_NOTIFY_CHANGE_NAME: Final = 1  # undocumented
+    REG_NOTIFY_CHANGE_SECURITY: Final = 8  # undocumented
+    REG_NO_LAZY_FLUSH: Final = 4  # undocumented
+    REG_OPENED_EXISTING_KEY: Final = 2  # undocumented
+    REG_OPTION_BACKUP_RESTORE: Final = 4  # undocumented
+    REG_OPTION_CREATE_LINK: Final = 2  # undocumented
+    REG_OPTION_NON_VOLATILE: Final = 0  # undocumented
+    REG_OPTION_OPEN_LINK: Final = 8  # undocumented
+    REG_OPTION_RESERVED: Final = 0  # undocumented
+    REG_OPTION_VOLATILE: Final = 1  # undocumented
+    REG_REFRESH_HIVE: Final = 2  # undocumented
+    REG_WHOLE_HIVE_VOLATILE: Final = 1  # undocumented
 
     error = OSError
 
@@ -98,3 +127,6 @@ if sys.platform == "win32":
         ) -> bool | None: ...
         def Close(self) -> None: ...
         def Detach(self) -> int: ...
+        def __hash__(self) -> int: ...
+        @property
+        def handle(self) -> int: ...
diff --git a/mypy/typeshed/stdlib/winsound.pyi b/mypy/typeshed/stdlib/winsound.pyi
index 9b2b57a38986..a20e81f94f98 100644
--- a/mypy/typeshed/stdlib/winsound.pyi
+++ b/mypy/typeshed/stdlib/winsound.pyi
@@ -1,24 +1,24 @@
 import sys
 from _typeshed import ReadableBuffer
-from typing import overload
-from typing_extensions import Literal
+from typing import Final, Literal, overload
 
 if sys.platform == "win32":
-    SND_FILENAME: Literal[131072]
-    SND_ALIAS: Literal[65536]
-    SND_LOOP: Literal[8]
-    SND_MEMORY: Literal[4]
-    SND_PURGE: Literal[64]
-    SND_ASYNC: Literal[1]
-    SND_NODEFAULT: Literal[2]
-    SND_NOSTOP: Literal[16]
-    SND_NOWAIT: Literal[8192]
+    SND_APPLICATION: Final = 128
+    SND_FILENAME: Final = 131072
+    SND_ALIAS: Final = 65536
+    SND_LOOP: Final = 8
+    SND_MEMORY: Final = 4
+    SND_PURGE: Final = 64
+    SND_ASYNC: Final = 1
+    SND_NODEFAULT: Final = 2
+    SND_NOSTOP: Final = 16
+    SND_NOWAIT: Final = 8192
 
-    MB_ICONASTERISK: Literal[64]
-    MB_ICONEXCLAMATION: Literal[48]
-    MB_ICONHAND: Literal[16]
-    MB_ICONQUESTION: Literal[32]
-    MB_OK: Literal[0]
+    MB_ICONASTERISK: Final = 64
+    MB_ICONEXCLAMATION: Final = 48
+    MB_ICONHAND: Final = 16
+    MB_ICONQUESTION: Final = 32
+    MB_OK: Final = 0
     def Beep(frequency: int, duration: int) -> None: ...
     # Can actually accept anything ORed with 4, and if not it's definitely str, but that's inexpressible
     @overload
diff --git a/mypy/typeshed/stdlib/wsgiref/types.pyi b/mypy/typeshed/stdlib/wsgiref/types.pyi
index 4e8f47264f3a..57276fd05ea8 100644
--- a/mypy/typeshed/stdlib/wsgiref/types.pyi
+++ b/mypy/typeshed/stdlib/wsgiref/types.pyi
@@ -1,5 +1,5 @@
+from _typeshed import OptExcInfo
 from collections.abc import Callable, Iterable, Iterator
-from sys import _OptExcInfo
 from typing import Any, Protocol
 from typing_extensions import TypeAlias
 
@@ -7,26 +7,26 @@ __all__ = ["StartResponse", "WSGIEnvironment", "WSGIApplication", "InputStream",
 
 class StartResponse(Protocol):
     def __call__(
-        self, __status: str, __headers: list[tuple[str, str]], __exc_info: _OptExcInfo | None = ...
+        self, status: str, headers: list[tuple[str, str]], exc_info: OptExcInfo | None = ..., /
     ) -> Callable[[bytes], object]: ...
 
 WSGIEnvironment: TypeAlias = dict[str, Any]
 WSGIApplication: TypeAlias = Callable[[WSGIEnvironment, StartResponse], Iterable[bytes]]
 
 class InputStream(Protocol):
-    def read(self, __size: int = ...) -> bytes: ...
-    def readline(self, __size: int = ...) -> bytes: ...
-    def readlines(self, __hint: int = ...) -> list[bytes]: ...
+    def read(self, size: int = ..., /) -> bytes: ...
+    def readline(self, size: int = ..., /) -> bytes: ...
+    def readlines(self, hint: int = ..., /) -> list[bytes]: ...
     def __iter__(self) -> Iterator[bytes]: ...
 
 class ErrorStream(Protocol):
     def flush(self) -> object: ...
-    def write(self, __s: str) -> object: ...
-    def writelines(self, __seq: list[str]) -> object: ...
+    def write(self, s: str, /) -> object: ...
+    def writelines(self, seq: list[str], /) -> object: ...
 
 class _Readable(Protocol):
-    def read(self, __size: int = ...) -> bytes: ...
+    def read(self, size: int = ..., /) -> bytes: ...
     # Optional: def close(self) -> object: ...
 
 class FileWrapper(Protocol):
-    def __call__(self, __file: _Readable, __block_size: int = ...) -> Iterable[bytes]: ...
+    def __call__(self, file: _Readable, block_size: int = ..., /) -> Iterable[bytes]: ...
diff --git a/mypy/typeshed/stdlib/wsgiref/util.pyi b/mypy/typeshed/stdlib/wsgiref/util.pyi
index 962fac2c5a22..3966e17b0d28 100644
--- a/mypy/typeshed/stdlib/wsgiref/util.pyi
+++ b/mypy/typeshed/stdlib/wsgiref/util.pyi
@@ -4,6 +4,8 @@ from collections.abc import Callable
 from typing import IO, Any
 
 __all__ = ["FileWrapper", "guess_scheme", "application_uri", "request_uri", "shift_path_info", "setup_testing_defaults"]
+if sys.version_info >= (3, 13):
+    __all__ += ["is_hop_by_hop"]
 
 class FileWrapper:
     filelike: IO[bytes]
diff --git a/mypy/typeshed/stdlib/xml/__init__.pyi b/mypy/typeshed/stdlib/xml/__init__.pyi
index a487d2467f41..7a240965136e 100644
--- a/mypy/typeshed/stdlib/xml/__init__.pyi
+++ b/mypy/typeshed/stdlib/xml/__init__.pyi
@@ -1 +1,3 @@
-from xml import parsers as parsers
+# At runtime, listing submodules in __all__ without them being imported is
+# valid, and causes them to be included in a star import. See #6523
+__all__ = ["dom", "parsers", "sax", "etree"]  # noqa: F822  # pyright: ignore[reportUnsupportedDunderAll]
diff --git a/mypy/typeshed/stdlib/xml/dom/NodeFilter.pyi b/mypy/typeshed/stdlib/xml/dom/NodeFilter.pyi
index 80fb73d23433..007df982e06a 100644
--- a/mypy/typeshed/stdlib/xml/dom/NodeFilter.pyi
+++ b/mypy/typeshed/stdlib/xml/dom/NodeFilter.pyi
@@ -1,7 +1,10 @@
+from typing import Literal
+from xml.dom.minidom import Node
+
 class NodeFilter:
-    FILTER_ACCEPT: int
-    FILTER_REJECT: int
-    FILTER_SKIP: int
+    FILTER_ACCEPT: Literal[1]
+    FILTER_REJECT: Literal[2]
+    FILTER_SKIP: Literal[3]
 
     SHOW_ALL: int
     SHOW_ELEMENT: int
@@ -16,4 +19,4 @@ class NodeFilter:
     SHOW_DOCUMENT_TYPE: int
     SHOW_DOCUMENT_FRAGMENT: int
     SHOW_NOTATION: int
-    def acceptNode(self, node) -> int: ...
+    def acceptNode(self, node: Node) -> int: ...
diff --git a/mypy/typeshed/stdlib/xml/dom/__init__.pyi b/mypy/typeshed/stdlib/xml/dom/__init__.pyi
index e5b91bf2a795..d9615f9aacfe 100644
--- a/mypy/typeshed/stdlib/xml/dom/__init__.pyi
+++ b/mypy/typeshed/stdlib/xml/dom/__init__.pyi
@@ -1,69 +1,100 @@
-from typing import Any
+from typing import Any, Final, Literal
 
 from .domreg import getDOMImplementation as getDOMImplementation, registerDOMImplementation as registerDOMImplementation
 
 class Node:
-    ELEMENT_NODE: int
-    ATTRIBUTE_NODE: int
-    TEXT_NODE: int
-    CDATA_SECTION_NODE: int
-    ENTITY_REFERENCE_NODE: int
-    ENTITY_NODE: int
-    PROCESSING_INSTRUCTION_NODE: int
-    COMMENT_NODE: int
-    DOCUMENT_NODE: int
-    DOCUMENT_TYPE_NODE: int
-    DOCUMENT_FRAGMENT_NODE: int
-    NOTATION_NODE: int
+    ELEMENT_NODE: Literal[1]
+    ATTRIBUTE_NODE: Literal[2]
+    TEXT_NODE: Literal[3]
+    CDATA_SECTION_NODE: Literal[4]
+    ENTITY_REFERENCE_NODE: Literal[5]
+    ENTITY_NODE: Literal[6]
+    PROCESSING_INSTRUCTION_NODE: Literal[7]
+    COMMENT_NODE: Literal[8]
+    DOCUMENT_NODE: Literal[9]
+    DOCUMENT_TYPE_NODE: Literal[10]
+    DOCUMENT_FRAGMENT_NODE: Literal[11]
+    NOTATION_NODE: Literal[12]
 
 # ExceptionCode
-INDEX_SIZE_ERR: int
-DOMSTRING_SIZE_ERR: int
-HIERARCHY_REQUEST_ERR: int
-WRONG_DOCUMENT_ERR: int
-INVALID_CHARACTER_ERR: int
-NO_DATA_ALLOWED_ERR: int
-NO_MODIFICATION_ALLOWED_ERR: int
-NOT_FOUND_ERR: int
-NOT_SUPPORTED_ERR: int
-INUSE_ATTRIBUTE_ERR: int
-INVALID_STATE_ERR: int
-SYNTAX_ERR: int
-INVALID_MODIFICATION_ERR: int
-NAMESPACE_ERR: int
-INVALID_ACCESS_ERR: int
-VALIDATION_ERR: int
+INDEX_SIZE_ERR: Final = 1
+DOMSTRING_SIZE_ERR: Final = 2
+HIERARCHY_REQUEST_ERR: Final = 3
+WRONG_DOCUMENT_ERR: Final = 4
+INVALID_CHARACTER_ERR: Final = 5
+NO_DATA_ALLOWED_ERR: Final = 6
+NO_MODIFICATION_ALLOWED_ERR: Final = 7
+NOT_FOUND_ERR: Final = 8
+NOT_SUPPORTED_ERR: Final = 9
+INUSE_ATTRIBUTE_ERR: Final = 10
+INVALID_STATE_ERR: Final = 11
+SYNTAX_ERR: Final = 12
+INVALID_MODIFICATION_ERR: Final = 13
+NAMESPACE_ERR: Final = 14
+INVALID_ACCESS_ERR: Final = 15
+VALIDATION_ERR: Final = 16
 
 class DOMException(Exception):
     code: int
     def __init__(self, *args: Any, **kw: Any) -> None: ...
     def _get_code(self) -> int: ...
 
-class IndexSizeErr(DOMException): ...
-class DomstringSizeErr(DOMException): ...
-class HierarchyRequestErr(DOMException): ...
-class WrongDocumentErr(DOMException): ...
-class InvalidCharacterErr(DOMException): ...
-class NoDataAllowedErr(DOMException): ...
-class NoModificationAllowedErr(DOMException): ...
-class NotFoundErr(DOMException): ...
-class NotSupportedErr(DOMException): ...
-class InuseAttributeErr(DOMException): ...
-class InvalidStateErr(DOMException): ...
-class SyntaxErr(DOMException): ...
-class InvalidModificationErr(DOMException): ...
-class NamespaceErr(DOMException): ...
-class InvalidAccessErr(DOMException): ...
-class ValidationErr(DOMException): ...
+class IndexSizeErr(DOMException):
+    code: Literal[1]
+
+class DomstringSizeErr(DOMException):
+    code: Literal[2]
+
+class HierarchyRequestErr(DOMException):
+    code: Literal[3]
+
+class WrongDocumentErr(DOMException):
+    code: Literal[4]
+
+class InvalidCharacterErr(DOMException):
+    code: Literal[5]
+
+class NoDataAllowedErr(DOMException):
+    code: Literal[6]
+
+class NoModificationAllowedErr(DOMException):
+    code: Literal[7]
+
+class NotFoundErr(DOMException):
+    code: Literal[8]
+
+class NotSupportedErr(DOMException):
+    code: Literal[9]
+
+class InuseAttributeErr(DOMException):
+    code: Literal[10]
+
+class InvalidStateErr(DOMException):
+    code: Literal[11]
+
+class SyntaxErr(DOMException):
+    code: Literal[12]
+
+class InvalidModificationErr(DOMException):
+    code: Literal[13]
+
+class NamespaceErr(DOMException):
+    code: Literal[14]
+
+class InvalidAccessErr(DOMException):
+    code: Literal[15]
+
+class ValidationErr(DOMException):
+    code: Literal[16]
 
 class UserDataHandler:
-    NODE_CLONED: int
-    NODE_IMPORTED: int
-    NODE_DELETED: int
-    NODE_RENAMED: int
-
-XML_NAMESPACE: str
-XMLNS_NAMESPACE: str
-XHTML_NAMESPACE: str
-EMPTY_NAMESPACE: None
-EMPTY_PREFIX: None
+    NODE_CLONED: Literal[1]
+    NODE_IMPORTED: Literal[2]
+    NODE_DELETED: Literal[3]
+    NODE_RENAMED: Literal[4]
+
+XML_NAMESPACE: Final = "http://www.w3.org/XML/1998/namespace"
+XMLNS_NAMESPACE: Final = "http://www.w3.org/2000/xmlns/"
+XHTML_NAMESPACE: Final = "http://www.w3.org/1999/xhtml"
+EMPTY_NAMESPACE: Final[None]
+EMPTY_PREFIX: Final[None]
diff --git a/mypy/typeshed/stdlib/xml/dom/expatbuilder.pyi b/mypy/typeshed/stdlib/xml/dom/expatbuilder.pyi
index 45f0af7aa979..228ad07e15ad 100644
--- a/mypy/typeshed/stdlib/xml/dom/expatbuilder.pyi
+++ b/mypy/typeshed/stdlib/xml/dom/expatbuilder.pyi
@@ -1,7 +1,11 @@
-from _typeshed import Incomplete, ReadableBuffer, SupportsRead
+from _typeshed import ReadableBuffer, SupportsRead
 from typing import Any, NoReturn
-from xml.dom.minidom import Document, DOMImplementation, Node, TypeInfo
+from typing_extensions import TypeAlias
+from xml.dom.minidom import Document, DocumentFragment, DOMImplementation, Element, Node, TypeInfo
 from xml.dom.xmlbuilder import DOMBuilderFilter, Options
+from xml.parsers.expat import XMLParserType
+
+_Model: TypeAlias = tuple[int, int, str | None, tuple[Any, ...]]  # same as in pyexpat
 
 TEXT_NODE = Node.TEXT_NODE
 CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE
@@ -10,45 +14,56 @@ FILTER_ACCEPT = DOMBuilderFilter.FILTER_ACCEPT
 FILTER_REJECT = DOMBuilderFilter.FILTER_REJECT
 FILTER_SKIP = DOMBuilderFilter.FILTER_SKIP
 FILTER_INTERRUPT = DOMBuilderFilter.FILTER_INTERRUPT
-theDOMImplementation: DOMImplementation | None
+theDOMImplementation: DOMImplementation
 
 class ElementInfo:
-    tagName: Incomplete
-    def __init__(self, tagName, model: Incomplete | None = None) -> None: ...
-    def getAttributeType(self, aname) -> TypeInfo: ...
-    def getAttributeTypeNS(self, namespaceURI, localName) -> TypeInfo: ...
+    tagName: str
+    def __init__(self, tagName: str, model: _Model | None = None) -> None: ...
+    def getAttributeType(self, aname: str) -> TypeInfo: ...
+    def getAttributeTypeNS(self, namespaceURI: str | None, localName: str) -> TypeInfo: ...
     def isElementContent(self) -> bool: ...
     def isEmpty(self) -> bool: ...
-    def isId(self, aname) -> bool: ...
-    def isIdNS(self, euri, ename, auri, aname) -> bool: ...
+    def isId(self, aname: str) -> bool: ...
+    def isIdNS(self, euri: str, ename: str, auri: str, aname: str) -> bool: ...
 
 class ExpatBuilder:
     document: Document  # Created in self.reset()
-    curNode: Incomplete  # Created in self.reset()
+    curNode: DocumentFragment | Element | Document  # Created in self.reset()
     def __init__(self, options: Options | None = None) -> None: ...
-    def createParser(self): ...
-    def getParser(self): ...
+    def createParser(self) -> XMLParserType: ...
+    def getParser(self) -> XMLParserType: ...
     def reset(self) -> None: ...
-    def install(self, parser) -> None: ...
+    def install(self, parser: XMLParserType) -> None: ...
     def parseFile(self, file: SupportsRead[ReadableBuffer | str]) -> Document: ...
     def parseString(self, string: str | ReadableBuffer) -> Document: ...
-    def start_doctype_decl_handler(self, doctypeName, systemId, publicId, has_internal_subset) -> None: ...
+    def start_doctype_decl_handler(
+        self, doctypeName: str, systemId: str | None, publicId: str | None, has_internal_subset: bool
+    ) -> None: ...
     def end_doctype_decl_handler(self) -> None: ...
-    def pi_handler(self, target, data) -> None: ...
-    def character_data_handler_cdata(self, data) -> None: ...
-    def character_data_handler(self, data) -> None: ...
+    def pi_handler(self, target: str, data: str) -> None: ...
+    def character_data_handler_cdata(self, data: str) -> None: ...
+    def character_data_handler(self, data: str) -> None: ...
     def start_cdata_section_handler(self) -> None: ...
     def end_cdata_section_handler(self) -> None: ...
-    def entity_decl_handler(self, entityName, is_parameter_entity, value, base, systemId, publicId, notationName) -> None: ...
-    def notation_decl_handler(self, notationName, base, systemId, publicId) -> None: ...
-    def comment_handler(self, data) -> None: ...
-    def external_entity_ref_handler(self, context, base, systemId, publicId) -> int: ...
-    def first_element_handler(self, name, attributes) -> None: ...
-    def start_element_handler(self, name, attributes) -> None: ...
-    def end_element_handler(self, name) -> None: ...
-    def element_decl_handler(self, name, model) -> None: ...
-    def attlist_decl_handler(self, elem, name, type, default, required) -> None: ...
-    def xml_decl_handler(self, version, encoding, standalone) -> None: ...
+    def entity_decl_handler(
+        self,
+        entityName: str,
+        is_parameter_entity: bool,
+        value: str | None,
+        base: str | None,
+        systemId: str,
+        publicId: str | None,
+        notationName: str | None,
+    ) -> None: ...
+    def notation_decl_handler(self, notationName: str, base: str | None, systemId: str, publicId: str | None) -> None: ...
+    def comment_handler(self, data: str) -> None: ...
+    def external_entity_ref_handler(self, context: str, base: str | None, systemId: str | None, publicId: str | None) -> int: ...
+    def first_element_handler(self, name: str, attributes: list[str]) -> None: ...
+    def start_element_handler(self, name: str, attributes: list[str]) -> None: ...
+    def end_element_handler(self, name: str) -> None: ...
+    def element_decl_handler(self, name: str, model: _Model) -> None: ...
+    def attlist_decl_handler(self, elem: str, name: str, type: str, default: str | None, required: bool) -> None: ...
+    def xml_decl_handler(self, version: str, encoding: str | None, standalone: int) -> None: ...
 
 class FilterVisibilityController:
     filter: DOMBuilderFilter
@@ -57,7 +72,7 @@ class FilterVisibilityController:
     def acceptNode(self, node: Node) -> int: ...
 
 class FilterCrutch:
-    def __init__(self, builder) -> None: ...
+    def __init__(self, builder: ExpatBuilder) -> None: ...
 
 class Rejecter(FilterCrutch):
     def start_element_handler(self, *args: Any) -> None: ...
@@ -68,33 +83,39 @@ class Skipper(FilterCrutch):
     def end_element_handler(self, *args: Any) -> None: ...
 
 class FragmentBuilder(ExpatBuilder):
-    fragment: Incomplete | None
-    originalDocument: Incomplete
-    context: Incomplete
-    def __init__(self, context, options: Options | None = None) -> None: ...
+    fragment: DocumentFragment | None
+    originalDocument: Document
+    context: Node
+    def __init__(self, context: Node, options: Options | None = None) -> None: ...
+    def reset(self) -> None: ...
+    def parseFile(self, file: SupportsRead[ReadableBuffer | str]) -> DocumentFragment: ...  # type: ignore[override]
+    def parseString(self, string: ReadableBuffer | str) -> DocumentFragment: ...  # type: ignore[override]
+    def external_entity_ref_handler(self, context: str, base: str | None, systemId: str | None, publicId: str | None) -> int: ...
 
 class Namespaces:
-    def createParser(self): ...
-    def install(self, parser) -> None: ...
-    def start_namespace_decl_handler(self, prefix, uri) -> None: ...
-    def start_element_handler(self, name, attributes) -> None: ...
-    def end_element_handler(self, name) -> None: ...
+    def createParser(self) -> XMLParserType: ...
+    def install(self, parser: XMLParserType) -> None: ...
+    def start_namespace_decl_handler(self, prefix: str | None, uri: str) -> None: ...
+    def start_element_handler(self, name: str, attributes: list[str]) -> None: ...
+    def end_element_handler(self, name: str) -> None: ...  # only exists if __debug__
 
 class ExpatBuilderNS(Namespaces, ExpatBuilder): ...
 class FragmentBuilderNS(Namespaces, FragmentBuilder): ...
 class ParseEscape(Exception): ...
 
 class InternalSubsetExtractor(ExpatBuilder):
-    subset: Any | None
-    def getSubset(self) -> Any | None: ...
+    subset: str | list[str] | None = None
+    def getSubset(self) -> str: ...
     def parseFile(self, file: SupportsRead[ReadableBuffer | str]) -> None: ...  # type: ignore[override]
     def parseString(self, string: str | ReadableBuffer) -> None: ...  # type: ignore[override]
-    def start_doctype_decl_handler(self, name, publicId, systemId, has_internal_subset) -> None: ...  # type: ignore[override]
+    def start_doctype_decl_handler(  # type: ignore[override]
+        self, name: str, publicId: str | None, systemId: str | None, has_internal_subset: bool
+    ) -> None: ...
     def end_doctype_decl_handler(self) -> NoReturn: ...
-    def start_element_handler(self, name, attrs) -> NoReturn: ...
+    def start_element_handler(self, name: str, attrs: list[str]) -> NoReturn: ...
 
-def parse(file: str | SupportsRead[ReadableBuffer | str], namespaces: bool = True): ...
-def parseString(string: str | ReadableBuffer, namespaces: bool = True): ...
-def parseFragment(file, context, namespaces: bool = True): ...
-def parseFragmentString(string: str, context, namespaces: bool = True): ...
+def parse(file: str | SupportsRead[ReadableBuffer | str], namespaces: bool = True) -> Document: ...
+def parseString(string: str | ReadableBuffer, namespaces: bool = True) -> Document: ...
+def parseFragment(file: str | SupportsRead[ReadableBuffer | str], context: Node, namespaces: bool = True) -> DocumentFragment: ...
+def parseFragmentString(string: str | ReadableBuffer, context: Node, namespaces: bool = True) -> DocumentFragment: ...
 def makeBuilder(options: Options) -> ExpatBuilderNS | ExpatBuilder: ...
diff --git a/mypy/typeshed/stdlib/xml/dom/minicompat.pyi b/mypy/typeshed/stdlib/xml/dom/minicompat.pyi
index 4d83bef025d9..162f60254a58 100644
--- a/mypy/typeshed/stdlib/xml/dom/minicompat.pyi
+++ b/mypy/typeshed/stdlib/xml/dom/minicompat.pyi
@@ -1,6 +1,5 @@
 from collections.abc import Iterable
-from typing import Any, TypeVar
-from typing_extensions import Literal
+from typing import Any, Literal, TypeVar
 
 __all__ = ["NodeList", "EmptyNodeList", "StringTypes", "defproperty"]
 
diff --git a/mypy/typeshed/stdlib/xml/dom/minidom.pyi b/mypy/typeshed/stdlib/xml/dom/minidom.pyi
index ec17f0a41497..51bbf4993657 100644
--- a/mypy/typeshed/stdlib/xml/dom/minidom.pyi
+++ b/mypy/typeshed/stdlib/xml/dom/minidom.pyi
@@ -1,33 +1,92 @@
 import sys
 import xml.dom
+from _collections_abc import dict_keys, dict_values
 from _typeshed import Incomplete, ReadableBuffer, SupportsRead, SupportsWrite
-from typing import NoReturn, TypeVar, overload
-from typing_extensions import Literal, Self
-from xml.dom.minicompat import NodeList
+from collections.abc import Iterable, Sequence
+from types import TracebackType
+from typing import Any, ClassVar, Generic, Literal, NoReturn, Protocol, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+from xml.dom.minicompat import EmptyNodeList, NodeList
 from xml.dom.xmlbuilder import DocumentLS, DOMImplementationLS
 from xml.sax.xmlreader import XMLReader
 
+_NSName: TypeAlias = tuple[str | None, str]
+
+# Entity can also have children, but it's not implemented the same way as the
+# others, so is deliberately omitted here.
+_NodesWithChildren: TypeAlias = DocumentFragment | Attr | Element | Document
+_NodesThatAreChildren: TypeAlias = CDATASection | Comment | DocumentType | Element | Notation | ProcessingInstruction | Text
+
+_AttrChildren: TypeAlias = Text  # Also EntityReference, but we don't implement it
+_ElementChildren: TypeAlias = Element | ProcessingInstruction | Comment | Text | CDATASection
+_EntityChildren: TypeAlias = Text  # I think; documentation is a little unclear
+_DocumentFragmentChildren: TypeAlias = Element | Text | CDATASection | ProcessingInstruction | Comment | Notation
+_DocumentChildren: TypeAlias = Comment | DocumentType | Element | ProcessingInstruction
+
 _N = TypeVar("_N", bound=Node)
+_ChildNodeVar = TypeVar("_ChildNodeVar", bound=_NodesThatAreChildren)
+_ChildNodePlusFragmentVar = TypeVar("_ChildNodePlusFragmentVar", bound=_NodesThatAreChildren | DocumentFragment)
+_DocumentChildrenVar = TypeVar("_DocumentChildrenVar", bound=_DocumentChildren)
+_ImportableNodeVar = TypeVar(
+    "_ImportableNodeVar",
+    bound=DocumentFragment
+    | Attr
+    | Element
+    | ProcessingInstruction
+    | CharacterData
+    | Text
+    | Comment
+    | CDATASection
+    | Entity
+    | Notation,
+)
+
+class _DOMErrorHandler(Protocol):
+    def handleError(self, error: Exception) -> bool: ...
+
+class _UserDataHandler(Protocol):
+    def handle(self, operation: int, key: str, data: Any, src: Node, dst: Node) -> None: ...
 
 def parse(
     file: str | SupportsRead[ReadableBuffer | str], parser: XMLReader | None = None, bufsize: int | None = None
 ) -> Document: ...
 def parseString(string: str | ReadableBuffer, parser: XMLReader | None = None) -> Document: ...
-def getDOMImplementation(features=None) -> DOMImplementation | None: ...
+@overload
+def getDOMImplementation(features: None = None) -> DOMImplementation: ...
+@overload
+def getDOMImplementation(features: str | Iterable[tuple[str, str | None]]) -> DOMImplementation | None: ...
 
 class Node(xml.dom.Node):
-    namespaceURI: str | None
-    parentNode: Incomplete
-    ownerDocument: Incomplete
-    nextSibling: Incomplete
-    previousSibling: Incomplete
-    prefix: Incomplete
+    parentNode: _NodesWithChildren | Entity | None
+    ownerDocument: Document | None
+    nextSibling: _NodesThatAreChildren | None
+    previousSibling: _NodesThatAreChildren | None
+    namespaceURI: str | None  # non-null only for Element and Attr
+    prefix: str | None  # non-null only for NS Element and Attr
+
+    # These aren't defined on Node, but they exist on all Node subclasses
+    # and various methods of Node require them to exist.
+    childNodes: (
+        NodeList[_DocumentFragmentChildren]
+        | NodeList[_AttrChildren]
+        | NodeList[_ElementChildren]
+        | NodeList[_DocumentChildren]
+        | NodeList[_EntityChildren]
+        | EmptyNodeList
+    )
+    nodeType: ClassVar[Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]
+    nodeName: str | None  # only possibly None on DocumentType
+
+    # Not defined on Node, but exist on all Node subclasses.
+    nodeValue: str | None  # non-null for Attr, ProcessingInstruction, Text, Comment, and CDATASection
+    attributes: NamedNodeMap | None  # non-null only for Element
+
     @property
-    def firstChild(self) -> Node | None: ...
+    def firstChild(self) -> _NodesThatAreChildren | None: ...
     @property
-    def lastChild(self) -> Node | None: ...
+    def lastChild(self) -> _NodesThatAreChildren | None: ...
     @property
-    def localName(self) -> str | None: ...
+    def localName(self) -> str | None: ...  # non-null only for Element and Attr
     def __bool__(self) -> Literal[True]: ...
     if sys.version_info >= (3, 9):
         @overload
@@ -95,292 +154,509 @@ class Node(xml.dom.Node):
         ) -> bytes: ...
 
     def hasChildNodes(self) -> bool: ...
-    def insertBefore(self, newChild, refChild): ...
-    def appendChild(self, node: _N) -> _N: ...
-    def replaceChild(self, newChild, oldChild): ...
-    def removeChild(self, oldChild): ...
-    def normalize(self) -> None: ...
-    def cloneNode(self, deep): ...
-    def isSupported(self, feature, version): ...
-    def isSameNode(self, other): ...
-    def getInterface(self, feature): ...
-    def getUserData(self, key): ...
-    def setUserData(self, key, data, handler): ...
-    childNodes: Incomplete
+    def insertBefore(  # type: ignore[misc]
+        self: _NodesWithChildren,  # pyright: ignore[reportGeneralTypeIssues]
+        newChild: _ChildNodePlusFragmentVar,
+        refChild: _NodesThatAreChildren | None,
+    ) -> _ChildNodePlusFragmentVar: ...
+    def appendChild(  # type: ignore[misc]
+        self: _NodesWithChildren, node: _ChildNodePlusFragmentVar  # pyright: ignore[reportGeneralTypeIssues]
+    ) -> _ChildNodePlusFragmentVar: ...
+    @overload
+    def replaceChild(  # type: ignore[misc]
+        self: _NodesWithChildren, newChild: DocumentFragment, oldChild: _ChildNodeVar
+    ) -> _ChildNodeVar | DocumentFragment: ...
+    @overload
+    def replaceChild(  # type: ignore[misc]
+        self: _NodesWithChildren, newChild: _NodesThatAreChildren, oldChild: _ChildNodeVar
+    ) -> _ChildNodeVar | None: ...
+    def removeChild(self: _NodesWithChildren, oldChild: _ChildNodeVar) -> _ChildNodeVar: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    def normalize(self: _NodesWithChildren) -> None: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    def cloneNode(self, deep: bool) -> Self | None: ...
+    def isSupported(self, feature: str, version: str | None) -> bool: ...
+    def isSameNode(self, other: Node) -> bool: ...
+    def getInterface(self, feature: str) -> Self | None: ...
+    def getUserData(self, key: str) -> Any | None: ...
+    def setUserData(self, key: str, data: Any, handler: _UserDataHandler) -> Any: ...
     def unlink(self) -> None: ...
     def __enter__(self) -> Self: ...
-    def __exit__(self, et, ev, tb) -> None: ...
+    def __exit__(self, et: type[BaseException] | None, ev: BaseException | None, tb: TracebackType | None) -> None: ...
+
+_DFChildrenVar = TypeVar("_DFChildrenVar", bound=_DocumentFragmentChildren)
+_DFChildrenPlusFragment = TypeVar("_DFChildrenPlusFragment", bound=_DocumentFragmentChildren | DocumentFragment)
 
 class DocumentFragment(Node):
-    nodeType: int
-    nodeName: str
-    nodeValue: Incomplete
-    attributes: Incomplete
-    parentNode: Incomplete
-    childNodes: Incomplete
+    nodeType: ClassVar[Literal[11]]
+    nodeName: Literal["#document-fragment"]
+    nodeValue: None
+    attributes: None
+
+    parentNode: None
+    nextSibling: None
+    previousSibling: None
+    childNodes: NodeList[_DocumentFragmentChildren]
+    @property
+    def firstChild(self) -> _DocumentFragmentChildren | None: ...
+    @property
+    def lastChild(self) -> _DocumentFragmentChildren | None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
     def __init__(self) -> None: ...
+    def insertBefore(  # type: ignore[override]
+        self, newChild: _DFChildrenPlusFragment, refChild: _DocumentFragmentChildren | None
+    ) -> _DFChildrenPlusFragment: ...
+    def appendChild(self, node: _DFChildrenPlusFragment) -> _DFChildrenPlusFragment: ...  # type: ignore[override]
+    @overload  # type: ignore[override]
+    def replaceChild(self, newChild: DocumentFragment, oldChild: _DFChildrenVar) -> _DFChildrenVar | DocumentFragment: ...
+    @overload
+    def replaceChild(self, newChild: _DocumentFragmentChildren, oldChild: _DFChildrenVar) -> _DFChildrenVar | None: ...  # type: ignore[override]
+    def removeChild(self, oldChild: _DFChildrenVar) -> _DFChildrenVar: ...  # type: ignore[override]
+
+_AttrChildrenVar = TypeVar("_AttrChildrenVar", bound=_AttrChildren)
+_AttrChildrenPlusFragment = TypeVar("_AttrChildrenPlusFragment", bound=_AttrChildren | DocumentFragment)
 
 class Attr(Node):
-    name: str
-    nodeType: int
-    attributes: Incomplete
-    specified: bool
-    ownerElement: Incomplete
+    nodeType: ClassVar[Literal[2]]
+    nodeName: str  # same as Attr.name
+    nodeValue: str  # same as Attr.value
+    attributes: None
+
+    parentNode: None
+    nextSibling: None
+    previousSibling: None
+    childNodes: NodeList[_AttrChildren]
+    @property
+    def firstChild(self) -> _AttrChildren | None: ...
+    @property
+    def lastChild(self) -> _AttrChildren | None: ...
+
     namespaceURI: str | None
-    childNodes: Incomplete
-    nodeName: Incomplete
-    nodeValue: str
+    prefix: str | None
+    @property
+    def localName(self) -> str: ...
+
+    name: str
     value: str
-    prefix: Incomplete
+    specified: bool
+    ownerElement: Element | None
+
     def __init__(
-        self, qName: str, namespaceURI: str | None = None, localName: str | None = None, prefix: Incomplete | None = None
+        self, qName: str, namespaceURI: str | None = None, localName: str | None = None, prefix: str | None = None
     ) -> None: ...
     def unlink(self) -> None: ...
     @property
     def isId(self) -> bool: ...
     @property
-    def schemaType(self): ...
+    def schemaType(self) -> TypeInfo: ...
+    def insertBefore(self, newChild: _AttrChildrenPlusFragment, refChild: _AttrChildren | None) -> _AttrChildrenPlusFragment: ...  # type: ignore[override]
+    def appendChild(self, node: _AttrChildrenPlusFragment) -> _AttrChildrenPlusFragment: ...  # type: ignore[override]
+    @overload  # type: ignore[override]
+    def replaceChild(self, newChild: DocumentFragment, oldChild: _AttrChildrenVar) -> _AttrChildrenVar | DocumentFragment: ...
+    @overload
+    def replaceChild(self, newChild: _AttrChildren, oldChild: _AttrChildrenVar) -> _AttrChildrenVar | None: ...  # type: ignore[override]
+    def removeChild(self, oldChild: _AttrChildrenVar) -> _AttrChildrenVar: ...  # type: ignore[override]
 
+# In the DOM, this interface isn't specific to Attr, but our implementation is
+# because that's the only place we use it.
 class NamedNodeMap:
-    def __init__(self, attrs, attrsNS, ownerElement) -> None: ...
-    def item(self, index): ...
-    def items(self): ...
-    def itemsNS(self): ...
-    def __contains__(self, key): ...
-    def keys(self): ...
-    def keysNS(self): ...
-    def values(self): ...
-    def get(self, name: str, value: Incomplete | None = None): ...
+    def __init__(self, attrs: dict[str, Attr], attrsNS: dict[_NSName, Attr], ownerElement: Element) -> None: ...
+    @property
+    def length(self) -> int: ...
+    def item(self, index: int) -> Node | None: ...
+    def items(self) -> list[tuple[str, str]]: ...
+    def itemsNS(self) -> list[tuple[_NSName, str]]: ...
+    def __contains__(self, key: str | _NSName) -> bool: ...
+    def keys(self) -> dict_keys[str, Attr]: ...
+    def keysNS(self) -> dict_keys[_NSName, Attr]: ...
+    def values(self) -> dict_values[str, Attr]: ...
+    def get(self, name: str, value: Attr | None = None) -> Attr | None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __len__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...
     def __ge__(self, other: NamedNodeMap) -> bool: ...
     def __gt__(self, other: NamedNodeMap) -> bool: ...
     def __le__(self, other: NamedNodeMap) -> bool: ...
     def __lt__(self, other: NamedNodeMap) -> bool: ...
-    def __getitem__(self, attname_or_tuple: tuple[str, str | None] | str): ...
+    def __getitem__(self, attname_or_tuple: _NSName | str) -> Attr: ...
     def __setitem__(self, attname: str, value: Attr | str) -> None: ...
     def getNamedItem(self, name: str) -> Attr | None: ...
-    def getNamedItemNS(self, namespaceURI: str, localName: str | None) -> Attr | None: ...
+    def getNamedItemNS(self, namespaceURI: str | None, localName: str) -> Attr | None: ...
     def removeNamedItem(self, name: str) -> Attr: ...
-    def removeNamedItemNS(self, namespaceURI: str, localName: str | None): ...
-    def setNamedItem(self, node: Attr) -> Attr: ...
-    def setNamedItemNS(self, node: Attr) -> Attr: ...
-    def __delitem__(self, attname_or_tuple: tuple[str, str | None] | str) -> None: ...
-    @property
-    def length(self) -> int: ...
+    def removeNamedItemNS(self, namespaceURI: str | None, localName: str) -> Attr: ...
+    def setNamedItem(self, node: Attr) -> Attr | None: ...
+    def setNamedItemNS(self, node: Attr) -> Attr | None: ...
+    def __delitem__(self, attname_or_tuple: _NSName | str) -> None: ...
 
 AttributeList = NamedNodeMap
 
 class TypeInfo:
-    namespace: Incomplete | None
-    name: str
-    def __init__(self, namespace: Incomplete | None, name: str) -> None: ...
+    namespace: str | None
+    name: str | None
+    def __init__(self, namespace: Incomplete | None, name: str | None) -> None: ...
+
+_ElementChildrenVar = TypeVar("_ElementChildrenVar", bound=_ElementChildren)
+_ElementChildrenPlusFragment = TypeVar("_ElementChildrenPlusFragment", bound=_ElementChildren | DocumentFragment)
 
 class Element(Node):
-    nodeType: int
-    nodeValue: Incomplete
-    schemaType: Incomplete
-    parentNode: Incomplete
-    tagName: str
-    nodeName: str
-    prefix: Incomplete
+    nodeType: ClassVar[Literal[1]]
+    nodeName: str  # same as Element.tagName
+    nodeValue: None
+    @property
+    def attributes(self) -> NamedNodeMap: ...  # type: ignore[override]
+
+    parentNode: Document | Element | DocumentFragment | None
+    nextSibling: _DocumentChildren | _ElementChildren | _DocumentFragmentChildren | None
+    previousSibling: _DocumentChildren | _ElementChildren | _DocumentFragmentChildren | None
+    childNodes: NodeList[_ElementChildren]
+    @property
+    def firstChild(self) -> _ElementChildren | None: ...
+    @property
+    def lastChild(self) -> _ElementChildren | None: ...
+
     namespaceURI: str | None
-    childNodes: Incomplete
-    nextSibling: Incomplete
+    prefix: str | None
+    @property
+    def localName(self) -> str: ...
+
+    schemaType: TypeInfo
+    tagName: str
+
     def __init__(
-        self, tagName, namespaceURI: str | None = None, prefix: Incomplete | None = None, localName: Incomplete | None = None
+        self, tagName: str, namespaceURI: str | None = None, prefix: str | None = None, localName: str | None = None
     ) -> None: ...
     def unlink(self) -> None: ...
     def getAttribute(self, attname: str) -> str: ...
-    def getAttributeNS(self, namespaceURI: str, localName): ...
+    def getAttributeNS(self, namespaceURI: str | None, localName: str) -> str: ...
     def setAttribute(self, attname: str, value: str) -> None: ...
-    def setAttributeNS(self, namespaceURI: str, qualifiedName: str, value) -> None: ...
-    def getAttributeNode(self, attrname: str): ...
-    def getAttributeNodeNS(self, namespaceURI: str, localName): ...
-    def setAttributeNode(self, attr): ...
-    setAttributeNodeNS: Incomplete
+    def setAttributeNS(self, namespaceURI: str | None, qualifiedName: str, value: str) -> None: ...
+    def getAttributeNode(self, attrname: str) -> Attr | None: ...
+    def getAttributeNodeNS(self, namespaceURI: str | None, localName: str) -> Attr | None: ...
+    def setAttributeNode(self, attr: Attr) -> Attr | None: ...
+    setAttributeNodeNS = setAttributeNode
     def removeAttribute(self, name: str) -> None: ...
-    def removeAttributeNS(self, namespaceURI: str, localName) -> None: ...
-    def removeAttributeNode(self, node): ...
-    removeAttributeNodeNS: Incomplete
+    def removeAttributeNS(self, namespaceURI: str | None, localName: str) -> None: ...
+    def removeAttributeNode(self, node: Attr) -> Attr: ...
+    removeAttributeNodeNS = removeAttributeNode
     def hasAttribute(self, name: str) -> bool: ...
-    def hasAttributeNS(self, namespaceURI: str, localName) -> bool: ...
+    def hasAttributeNS(self, namespaceURI: str | None, localName: str) -> bool: ...
     def getElementsByTagName(self, name: str) -> NodeList[Element]: ...
-    def getElementsByTagNameNS(self, namespaceURI: str, localName: str) -> NodeList[Element]: ...
+    def getElementsByTagNameNS(self, namespaceURI: str | None, localName: str) -> NodeList[Element]: ...
     def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
     def hasAttributes(self) -> bool: ...
-    def setIdAttribute(self, name) -> None: ...
-    def setIdAttributeNS(self, namespaceURI: str, localName) -> None: ...
-    def setIdAttributeNode(self, idAttr) -> None: ...
-    @property
-    def attributes(self) -> NamedNodeMap: ...
+    def setIdAttribute(self, name: str) -> None: ...
+    def setIdAttributeNS(self, namespaceURI: str | None, localName: str) -> None: ...
+    def setIdAttributeNode(self, idAttr: Attr) -> None: ...
+    def insertBefore(  # type: ignore[override]
+        self, newChild: _ElementChildrenPlusFragment, refChild: _ElementChildren | None
+    ) -> _ElementChildrenPlusFragment: ...
+    def appendChild(self, node: _ElementChildrenPlusFragment) -> _ElementChildrenPlusFragment: ...  # type: ignore[override]
+    @overload  # type: ignore[override]
+    def replaceChild(
+        self, newChild: DocumentFragment, oldChild: _ElementChildrenVar
+    ) -> _ElementChildrenVar | DocumentFragment: ...
+    @overload
+    def replaceChild(self, newChild: _ElementChildren, oldChild: _ElementChildrenVar) -> _ElementChildrenVar | None: ...  # type: ignore[override]
+    def removeChild(self, oldChild: _ElementChildrenVar) -> _ElementChildrenVar: ...  # type: ignore[override]
 
 class Childless:
-    attributes: Incomplete
-    childNodes: Incomplete
-    firstChild: Incomplete
-    lastChild: Incomplete
-    def appendChild(self, node) -> NoReturn: ...
-    def hasChildNodes(self) -> bool: ...
-    def insertBefore(self, newChild, refChild) -> NoReturn: ...
-    def removeChild(self, oldChild) -> NoReturn: ...
+    attributes: None
+    childNodes: EmptyNodeList
+    @property
+    def firstChild(self) -> None: ...
+    @property
+    def lastChild(self) -> None: ...
+    def appendChild(self, node: _NodesThatAreChildren | DocumentFragment) -> NoReturn: ...
+    def hasChildNodes(self) -> Literal[False]: ...
+    def insertBefore(
+        self, newChild: _NodesThatAreChildren | DocumentFragment, refChild: _NodesThatAreChildren | None
+    ) -> NoReturn: ...
+    def removeChild(self, oldChild: _NodesThatAreChildren) -> NoReturn: ...
     def normalize(self) -> None: ...
-    def replaceChild(self, newChild, oldChild) -> NoReturn: ...
+    def replaceChild(self, newChild: _NodesThatAreChildren | DocumentFragment, oldChild: _NodesThatAreChildren) -> NoReturn: ...
 
 class ProcessingInstruction(Childless, Node):
-    nodeType: int
-    target: Incomplete
-    data: Incomplete
-    def __init__(self, target, data) -> None: ...
-    nodeValue: Incomplete
-    nodeName: Incomplete
+    nodeType: ClassVar[Literal[7]]
+    nodeName: str  # same as ProcessingInstruction.target
+    nodeValue: str  # same as ProcessingInstruction.data
+    attributes: None
+
+    parentNode: Document | Element | DocumentFragment | None
+    nextSibling: _DocumentChildren | _ElementChildren | _DocumentFragmentChildren | None
+    previousSibling: _DocumentChildren | _ElementChildren | _DocumentFragmentChildren | None
+    childNodes: EmptyNodeList
+    @property
+    def firstChild(self) -> None: ...
+    @property
+    def lastChild(self) -> None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
+
+    target: str
+    data: str
+
+    def __init__(self, target: str, data: str) -> None: ...
     def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
 class CharacterData(Childless, Node):
-    ownerDocument: Incomplete
-    previousSibling: Incomplete
+    nodeValue: str
+    attributes: None
+
+    childNodes: EmptyNodeList
+    nextSibling: _NodesThatAreChildren | None
+    previousSibling: _NodesThatAreChildren | None
+
+    @property
+    def localName(self) -> None: ...
+
+    ownerDocument: Document | None
+    data: str
+
     def __init__(self) -> None: ...
+    @property
+    def length(self) -> int: ...
     def __len__(self) -> int: ...
-    data: str
-    nodeValue: Incomplete
     def substringData(self, offset: int, count: int) -> str: ...
     def appendData(self, arg: str) -> None: ...
     def insertData(self, offset: int, arg: str) -> None: ...
     def deleteData(self, offset: int, count: int) -> None: ...
     def replaceData(self, offset: int, count: int, arg: str) -> None: ...
-    @property
-    def length(self) -> int: ...
 
 class Text(CharacterData):
-    nodeType: int
-    nodeName: str
-    attributes: Incomplete
-    data: Incomplete
-    def splitText(self, offset): ...
+    nodeType: ClassVar[Literal[3]]
+    nodeName: Literal["#text"]
+    nodeValue: str  # same as CharacterData.data, the content of the text node
+    attributes: None
+
+    parentNode: Attr | Element | DocumentFragment | None
+    nextSibling: _DocumentFragmentChildren | _ElementChildren | _AttrChildren | None
+    previousSibling: _DocumentFragmentChildren | _ElementChildren | _AttrChildren | None
+    childNodes: EmptyNodeList
+    @property
+    def firstChild(self) -> None: ...
+    @property
+    def lastChild(self) -> None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
+
+    data: str
+    def splitText(self, offset: int) -> Self: ...
     def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
-    def replaceWholeText(self, content): ...
+    def replaceWholeText(self, content: str) -> Self | None: ...
     @property
     def isWhitespaceInElementContent(self) -> bool: ...
     @property
     def wholeText(self) -> str: ...
 
 class Comment(CharacterData):
-    nodeType: int
-    nodeName: str
-    def __init__(self, data) -> None: ...
+    nodeType: ClassVar[Literal[8]]
+    nodeName: Literal["#comment"]
+    nodeValue: str  # same as CharacterData.data, the content of the comment
+    attributes: None
+
+    parentNode: Document | Element | DocumentFragment | None
+    nextSibling: _DocumentChildren | _ElementChildren | _DocumentFragmentChildren | None
+    previousSibling: _DocumentChildren | _ElementChildren | _DocumentFragmentChildren | None
+    childNodes: EmptyNodeList
+    @property
+    def firstChild(self) -> None: ...
+    @property
+    def lastChild(self) -> None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
+    def __init__(self, data: str) -> None: ...
     def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
 class CDATASection(Text):
-    nodeType: int
-    nodeName: str
+    nodeType: ClassVar[Literal[4]]  # type: ignore[assignment]
+    nodeName: Literal["#cdata-section"]  # type: ignore[assignment]
+    nodeValue: str  # same as CharacterData.data, the content of the CDATA Section
+    attributes: None
+
+    parentNode: Element | DocumentFragment | None
+    nextSibling: _DocumentFragmentChildren | _ElementChildren | None
+    previousSibling: _DocumentFragmentChildren | _ElementChildren | None
+
     def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
-class ReadOnlySequentialNamedNodeMap:
-    def __init__(self, seq=()) -> None: ...
+class ReadOnlySequentialNamedNodeMap(Generic[_N]):
+    def __init__(self, seq: Sequence[_N] = ()) -> None: ...
     def __len__(self) -> int: ...
-    def getNamedItem(self, name): ...
-    def getNamedItemNS(self, namespaceURI: str, localName): ...
-    def __getitem__(self, name_or_tuple): ...
-    def item(self, index): ...
-    def removeNamedItem(self, name) -> None: ...
-    def removeNamedItemNS(self, namespaceURI: str, localName) -> None: ...
-    def setNamedItem(self, node) -> None: ...
-    def setNamedItemNS(self, node) -> None: ...
+    def getNamedItem(self, name: str) -> _N | None: ...
+    def getNamedItemNS(self, namespaceURI: str | None, localName: str) -> _N | None: ...
+    def __getitem__(self, name_or_tuple: str | _NSName) -> _N | None: ...
+    def item(self, index: int) -> _N | None: ...
+    def removeNamedItem(self, name: str) -> NoReturn: ...
+    def removeNamedItemNS(self, namespaceURI: str | None, localName: str) -> NoReturn: ...
+    def setNamedItem(self, node: Node) -> NoReturn: ...
+    def setNamedItemNS(self, node: Node) -> NoReturn: ...
     @property
     def length(self) -> int: ...
 
 class Identified:
-    publicId: Incomplete
-    systemId: Incomplete
+    publicId: str | None
+    systemId: str | None
 
 class DocumentType(Identified, Childless, Node):
-    nodeType: int
-    nodeValue: Incomplete
-    name: Incomplete
-    internalSubset: Incomplete
-    entities: Incomplete
-    notations: Incomplete
-    nodeName: Incomplete
-    def __init__(self, qualifiedName: str) -> None: ...
-    def cloneNode(self, deep): ...
+    nodeType: ClassVar[Literal[10]]
+    nodeName: str | None  # same as DocumentType.name
+    nodeValue: None
+    attributes: None
+
+    parentNode: Document | None
+    nextSibling: _DocumentChildren | None
+    previousSibling: _DocumentChildren | None
+    childNodes: EmptyNodeList
+    @property
+    def firstChild(self) -> None: ...
+    @property
+    def lastChild(self) -> None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
+
+    name: str | None
+    internalSubset: str | None
+    entities: ReadOnlySequentialNamedNodeMap[Entity]
+    notations: ReadOnlySequentialNamedNodeMap[Notation]
+
+    def __init__(self, qualifiedName: str | None) -> None: ...
+    def cloneNode(self, deep: bool) -> DocumentType | None: ...
     def writexml(self, writer: SupportsWrite[str], indent: str = "", addindent: str = "", newl: str = "") -> None: ...
 
 class Entity(Identified, Node):
-    attributes: Incomplete
-    nodeType: int
-    nodeValue: Incomplete
-    actualEncoding: Incomplete
-    encoding: Incomplete
-    version: Incomplete
-    nodeName: Incomplete
-    notationName: Incomplete
-    childNodes: Incomplete
-    def __init__(self, name, publicId, systemId, notation) -> None: ...
-    def appendChild(self, newChild) -> NoReturn: ...
-    def insertBefore(self, newChild, refChild) -> NoReturn: ...
-    def removeChild(self, oldChild) -> NoReturn: ...
-    def replaceChild(self, newChild, oldChild) -> NoReturn: ...
+    nodeType: ClassVar[Literal[6]]
+    nodeName: str  # entity name
+    nodeValue: None
+    attributes: None
+
+    parentNode: None
+    nextSibling: None
+    previousSibling: None
+    childNodes: NodeList[_EntityChildren]
+    @property
+    def firstChild(self) -> _EntityChildren | None: ...
+    @property
+    def lastChild(self) -> _EntityChildren | None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
+
+    actualEncoding: str | None
+    encoding: str | None
+    version: str | None
+    notationName: str | None
+
+    def __init__(self, name: str, publicId: str | None, systemId: str | None, notation: str | None) -> None: ...
+    def appendChild(self, newChild: _EntityChildren) -> NoReturn: ...  # type: ignore[override]
+    def insertBefore(self, newChild: _EntityChildren, refChild: _EntityChildren | None) -> NoReturn: ...  # type: ignore[override]
+    def removeChild(self, oldChild: _EntityChildren) -> NoReturn: ...  # type: ignore[override]
+    def replaceChild(self, newChild: _EntityChildren, oldChild: _EntityChildren) -> NoReturn: ...  # type: ignore[override]
 
 class Notation(Identified, Childless, Node):
-    nodeType: int
-    nodeValue: Incomplete
-    nodeName: Incomplete
-    def __init__(self, name, publicId, systemId) -> None: ...
+    nodeType: ClassVar[Literal[12]]
+    nodeName: str  # notation name
+    nodeValue: None
+    attributes: None
+
+    parentNode: DocumentFragment | None
+    nextSibling: _DocumentFragmentChildren | None
+    previousSibling: _DocumentFragmentChildren | None
+    childNodes: EmptyNodeList
+    @property
+    def firstChild(self) -> None: ...
+    @property
+    def lastChild(self) -> None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
+    def __init__(self, name: str, publicId: str | None, systemId: str | None) -> None: ...
 
 class DOMImplementation(DOMImplementationLS):
     def hasFeature(self, feature: str, version: str | None) -> bool: ...
     def createDocument(self, namespaceURI: str | None, qualifiedName: str | None, doctype: DocumentType | None) -> Document: ...
-    def createDocumentType(self, qualifiedName: str | None, publicId: str, systemId: str) -> DocumentType: ...
+    def createDocumentType(self, qualifiedName: str | None, publicId: str | None, systemId: str | None) -> DocumentType: ...
     def getInterface(self, feature: str) -> Self | None: ...
 
 class ElementInfo:
-    tagName: Incomplete
-    def __init__(self, name) -> None: ...
-    def getAttributeType(self, aname): ...
-    def getAttributeTypeNS(self, namespaceURI: str, localName): ...
-    def isElementContent(self): ...
-    def isEmpty(self): ...
-    def isId(self, aname): ...
-    def isIdNS(self, namespaceURI: str, localName): ...
+    tagName: str
+    def __init__(self, name: str) -> None: ...
+    def getAttributeType(self, aname: str) -> TypeInfo: ...
+    def getAttributeTypeNS(self, namespaceURI: str | None, localName: str) -> TypeInfo: ...
+    def isElementContent(self) -> bool: ...
+    def isEmpty(self) -> bool: ...
+    def isId(self, aname: str) -> bool: ...
+    def isIdNS(self, namespaceURI: str | None, localName: str) -> bool: ...
+
+_DocumentChildrenPlusFragment = TypeVar("_DocumentChildrenPlusFragment", bound=_DocumentChildren | DocumentFragment)
 
 class Document(Node, DocumentLS):
-    implementation: Incomplete
-    nodeType: int
-    nodeName: str
-    nodeValue: Incomplete
-    attributes: Incomplete
-    parentNode: Incomplete
-    previousSibling: Incomplete
-    nextSibling: Incomplete
-    actualEncoding: Incomplete
+    nodeType: ClassVar[Literal[9]]
+    nodeName: Literal["#document"]
+    nodeValue: None
+    attributes: None
+
+    parentNode: None
+    previousSibling: None
+    nextSibling: None
+    childNodes: NodeList[_DocumentChildren]
+    @property
+    def firstChild(self) -> _DocumentChildren | None: ...
+    @property
+    def lastChild(self) -> _DocumentChildren | None: ...
+
+    namespaceURI: None
+    prefix: None
+    @property
+    def localName(self) -> None: ...
+
+    implementation: DOMImplementation
+    actualEncoding: str | None
     encoding: str | None
     standalone: bool | None
-    version: Incomplete
+    version: str | None
     strictErrorChecking: bool
-    errorHandler: Incomplete
-    documentURI: Incomplete
+    errorHandler: _DOMErrorHandler | None
+    documentURI: str | None
     doctype: DocumentType | None
-    childNodes: Incomplete
+    documentElement: Element | None
+
     def __init__(self) -> None: ...
-    def appendChild(self, node: _N) -> _N: ...
-    documentElement: Incomplete
-    def removeChild(self, oldChild): ...
+    def appendChild(self, node: _DocumentChildrenVar) -> _DocumentChildrenVar: ...  # type: ignore[override]
+    def removeChild(self, oldChild: _DocumentChildrenVar) -> _DocumentChildrenVar: ...  # type: ignore[override]
     def unlink(self) -> None: ...
-    def cloneNode(self, deep): ...
+    def cloneNode(self, deep: bool) -> Document | None: ...
     def createDocumentFragment(self) -> DocumentFragment: ...
     def createElement(self, tagName: str) -> Element: ...
     def createTextNode(self, data: str) -> Text: ...
     def createCDATASection(self, data: str) -> CDATASection: ...
     def createComment(self, data: str) -> Comment: ...
-    def createProcessingInstruction(self, target, data): ...
-    def createAttribute(self, qName) -> Attr: ...
-    def createElementNS(self, namespaceURI: str, qualifiedName: str): ...
-    def createAttributeNS(self, namespaceURI: str, qualifiedName: str) -> Attr: ...
+    def createProcessingInstruction(self, target: str, data: str) -> ProcessingInstruction: ...
+    def createAttribute(self, qName: str) -> Attr: ...
+    def createElementNS(self, namespaceURI: str | None, qualifiedName: str) -> Element: ...
+    def createAttributeNS(self, namespaceURI: str | None, qualifiedName: str) -> Attr: ...
     def getElementById(self, id: str) -> Element | None: ...
     def getElementsByTagName(self, name: str) -> NodeList[Element]: ...
-    def getElementsByTagNameNS(self, namespaceURI: str, localName: str) -> NodeList[Element]: ...
+    def getElementsByTagNameNS(self, namespaceURI: str | None, localName: str) -> NodeList[Element]: ...
     def isSupported(self, feature: str, version: str | None) -> bool: ...
-    def importNode(self, node, deep): ...
+    def importNode(self, node: _ImportableNodeVar, deep: bool) -> _ImportableNodeVar: ...
     if sys.version_info >= (3, 9):
         def writexml(
             self,
@@ -401,4 +677,18 @@ class Document(Node, DocumentLS):
             encoding: Incomplete | None = None,
         ) -> None: ...
 
-    def renameNode(self, n, namespaceURI: str, name): ...
+    @overload
+    def renameNode(self, n: Element, namespaceURI: str, name: str) -> Element: ...
+    @overload
+    def renameNode(self, n: Attr, namespaceURI: str, name: str) -> Attr: ...
+    @overload
+    def renameNode(self, n: Element | Attr, namespaceURI: str, name: str) -> Element | Attr: ...
+    def insertBefore(
+        self, newChild: _DocumentChildrenPlusFragment, refChild: _DocumentChildren | None  # type: ignore[override]
+    ) -> _DocumentChildrenPlusFragment: ...
+    @overload  # type: ignore[override]
+    def replaceChild(
+        self, newChild: DocumentFragment, oldChild: _DocumentChildrenVar
+    ) -> _DocumentChildrenVar | DocumentFragment: ...
+    @overload
+    def replaceChild(self, newChild: _DocumentChildren, oldChild: _DocumentChildrenVar) -> _DocumentChildrenVar | None: ...
diff --git a/mypy/typeshed/stdlib/xml/dom/pulldom.pyi b/mypy/typeshed/stdlib/xml/dom/pulldom.pyi
index 920905160e43..d9458654c185 100644
--- a/mypy/typeshed/stdlib/xml/dom/pulldom.pyi
+++ b/mypy/typeshed/stdlib/xml/dom/pulldom.pyi
@@ -1,93 +1,109 @@
 import sys
-from _typeshed import Incomplete, SupportsRead
-from collections.abc import Sequence
-from typing_extensions import Literal, TypeAlias
-from xml.dom.minidom import Document, DOMImplementation, Element, Text
+from _typeshed import Incomplete, Unused
+from collections.abc import MutableSequence, Sequence
+from typing import Final, Literal, NoReturn
+from typing_extensions import Self, TypeAlias
+from xml.dom.minidom import Comment, Document, DOMImplementation, Element, ProcessingInstruction, Text
+from xml.sax import _SupportsReadClose
 from xml.sax.handler import ContentHandler
-from xml.sax.xmlreader import XMLReader
+from xml.sax.xmlreader import AttributesImpl, AttributesNSImpl, Locator, XMLReader
 
-START_ELEMENT: Literal["START_ELEMENT"]
-END_ELEMENT: Literal["END_ELEMENT"]
-COMMENT: Literal["COMMENT"]
-START_DOCUMENT: Literal["START_DOCUMENT"]
-END_DOCUMENT: Literal["END_DOCUMENT"]
-PROCESSING_INSTRUCTION: Literal["PROCESSING_INSTRUCTION"]
-IGNORABLE_WHITESPACE: Literal["IGNORABLE_WHITESPACE"]
-CHARACTERS: Literal["CHARACTERS"]
+START_ELEMENT: Final = "START_ELEMENT"
+END_ELEMENT: Final = "END_ELEMENT"
+COMMENT: Final = "COMMENT"
+START_DOCUMENT: Final = "START_DOCUMENT"
+END_DOCUMENT: Final = "END_DOCUMENT"
+PROCESSING_INSTRUCTION: Final = "PROCESSING_INSTRUCTION"
+IGNORABLE_WHITESPACE: Final = "IGNORABLE_WHITESPACE"
+CHARACTERS: Final = "CHARACTERS"
 
+_NSName: TypeAlias = tuple[str | None, str]
 _DocumentFactory: TypeAlias = DOMImplementation | None
-_Node: TypeAlias = Document | Element | Text
 
-_Event: TypeAlias = tuple[
-    Literal[
-        Literal["START_ELEMENT"],
-        Literal["END_ELEMENT"],
-        Literal["COMMENT"],
-        Literal["START_DOCUMENT"],
-        Literal["END_DOCUMENT"],
-        Literal["PROCESSING_INSTRUCTION"],
-        Literal["IGNORABLE_WHITESPACE"],
-        Literal["CHARACTERS"],
-    ],
-    _Node,
-]
+_Event: TypeAlias = (
+    tuple[Literal["START_ELEMENT"], Element]
+    | tuple[Literal["END_ELEMENT"], Element]
+    | tuple[Literal["COMMENT"], Comment]
+    | tuple[Literal["START_DOCUMENT"], Document]
+    | tuple[Literal["END_DOCUMENT"], Document]
+    | tuple[Literal["PROCESSING_INSTRUCTION"], ProcessingInstruction]
+    | tuple[Literal["IGNORABLE_WHITESPACE"], Text]
+    | tuple[Literal["CHARACTERS"], Text]
+)
 
 class PullDOM(ContentHandler):
     document: Document | None
     documentFactory: _DocumentFactory
-    firstEvent: Incomplete
-    lastEvent: Incomplete
-    elementStack: Sequence[Incomplete]
-    pending_events: Sequence[Incomplete]
+
+    # firstEvent is a list of length 2
+    # firstEvent[0] is always None
+    # firstEvent[1] is None prior to any events, after which it's a
+    # list of length 2, where the first item is of type _Event
+    # and the second item is None.
+    firstEvent: list[Incomplete]
+
+    # lastEvent is also a list of length 2. The second item is always None,
+    # and the first item is of type _Event
+    # This is a slight lie: The second item is sometimes temporarily what was just
+    # described for the type of lastEvent, after which lastEvent is always updated
+    # with `self.lastEvent = self.lastEvent[1]`.
+    lastEvent: list[Incomplete]
+
+    elementStack: MutableSequence[Element | Document]
+    pending_events: (
+        list[Sequence[tuple[Literal["COMMENT"], str] | tuple[Literal["PROCESSING_INSTRUCTION"], str, str] | None]] | None
+    )
     def __init__(self, documentFactory: _DocumentFactory = None) -> None: ...
-    def pop(self) -> Element: ...
-    def setDocumentLocator(self, locator) -> None: ...
-    def startPrefixMapping(self, prefix, uri) -> None: ...
-    def endPrefixMapping(self, prefix) -> None: ...
-    def startElementNS(self, name, tagName, attrs) -> None: ...
-    def endElementNS(self, name, tagName) -> None: ...
-    def startElement(self, name, attrs) -> None: ...
-    def endElement(self, name) -> None: ...
-    def comment(self, s) -> None: ...
-    def processingInstruction(self, target, data) -> None: ...
-    def ignorableWhitespace(self, chars) -> None: ...
-    def characters(self, chars) -> None: ...
+    def pop(self) -> Element | Document: ...
+    def setDocumentLocator(self, locator: Locator) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElementNS(self, name: _NSName, tagName: str | None, attrs: AttributesNSImpl) -> None: ...
+    def endElementNS(self, name: _NSName, tagName: str | None) -> None: ...
+    def startElement(self, name: str, attrs: AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def comment(self, s: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def ignorableWhitespace(self, chars: str) -> None: ...
+    def characters(self, chars: str) -> None: ...
     def startDocument(self) -> None: ...
-    def buildDocument(self, uri, tagname): ...
+    def buildDocument(self, uri: str | None, tagname: str | None) -> Element: ...
     def endDocument(self) -> None: ...
     def clear(self) -> None: ...
 
 class ErrorHandler:
-    def warning(self, exception) -> None: ...
-    def error(self, exception) -> None: ...
-    def fatalError(self, exception) -> None: ...
+    def warning(self, exception: BaseException) -> None: ...
+    def error(self, exception: BaseException) -> NoReturn: ...
+    def fatalError(self, exception: BaseException) -> NoReturn: ...
 
 class DOMEventStream:
-    stream: SupportsRead[bytes] | SupportsRead[str]
-    parser: XMLReader
+    stream: _SupportsReadClose[bytes] | _SupportsReadClose[str]
+    parser: XMLReader  # Set to none after .clear() is called
     bufsize: int
-    def __init__(self, stream: SupportsRead[bytes] | SupportsRead[str], parser: XMLReader, bufsize: int) -> None: ...
-    pulldom: Incomplete
+    pulldom: PullDOM
+    def __init__(self, stream: _SupportsReadClose[bytes] | _SupportsReadClose[str], parser: XMLReader, bufsize: int) -> None: ...
     if sys.version_info < (3, 11):
-        def __getitem__(self, pos): ...
+        def __getitem__(self, pos: Unused) -> _Event: ...
 
-    def __next__(self): ...
-    def __iter__(self): ...
-    def getEvent(self) -> _Event: ...
-    def expandNode(self, node: _Node) -> None: ...
+    def __next__(self) -> _Event: ...
+    def __iter__(self) -> Self: ...
+    def getEvent(self) -> _Event | None: ...
+    def expandNode(self, node: Document) -> None: ...
     def reset(self) -> None: ...
     def clear(self) -> None: ...
 
 class SAX2DOM(PullDOM):
-    def startElementNS(self, name, tagName, attrs) -> None: ...
-    def startElement(self, name, attrs) -> None: ...
-    def processingInstruction(self, target, data) -> None: ...
-    def ignorableWhitespace(self, chars) -> None: ...
-    def characters(self, chars) -> None: ...
+    def startElementNS(self, name: _NSName, tagName: str | None, attrs: AttributesNSImpl) -> None: ...
+    def startElement(self, name: str, attrs: AttributesImpl) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def ignorableWhitespace(self, chars: str) -> None: ...
+    def characters(self, chars: str) -> None: ...
 
 default_bufsize: int
 
 def parse(
-    stream_or_string: str | SupportsRead[bytes] | SupportsRead[str], parser: XMLReader | None = None, bufsize: int | None = None
+    stream_or_string: str | _SupportsReadClose[bytes] | _SupportsReadClose[str],
+    parser: XMLReader | None = None,
+    bufsize: int | None = None,
 ) -> DOMEventStream: ...
 def parseString(string: str, parser: XMLReader | None = None) -> DOMEventStream: ...
diff --git a/mypy/typeshed/stdlib/xml/dom/xmlbuilder.pyi b/mypy/typeshed/stdlib/xml/dom/xmlbuilder.pyi
index c07e4ba2465e..6fb18bbc4eda 100644
--- a/mypy/typeshed/stdlib/xml/dom/xmlbuilder.pyi
+++ b/mypy/typeshed/stdlib/xml/dom/xmlbuilder.pyi
@@ -1,32 +1,9 @@
-from _typeshed import Incomplete, Unused
-from typing import Any, NoReturn
-from typing_extensions import Literal, TypeAlias
-from urllib.request import OpenerDirector
-from xml.dom.expatbuilder import ExpatBuilder, ExpatBuilderNS
-from xml.dom.minidom import Node
+from _typeshed import SupportsRead
+from typing import Any, Literal, NoReturn
+from xml.dom.minidom import Document, Node, _DOMErrorHandler
 
 __all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"]
 
-# UNKNOWN TYPES:
-# - `Options.errorHandler`.
-#       The same as `_DOMBuilderErrorHandlerType`?
-#       Maybe `xml.sax.handler.ErrorHandler`?
-# - Return type of DOMBuilder.getFeature().
-#       We could get rid of the `Incomplete` if we knew more
-#       about `Options.errorHandler`.
-
-# ALIASES REPRESENTING MORE UNKNOWN TYPES:
-
-# probably the same as `Options.errorHandler`?
-# Maybe `xml.sax.handler.ErrorHandler`?
-_DOMBuilderErrorHandlerType: TypeAlias = Incomplete | None
-# probably some kind of IO...
-_DOMInputSourceCharacterStreamType: TypeAlias = Incomplete | None
-# probably a string??
-_DOMInputSourceStringDataType: TypeAlias = Incomplete | None
-# probably a string??
-_DOMInputSourceEncodingType: TypeAlias = Incomplete | None
-
 class Options:
     namespaces: int
     namespace_declarations: bool
@@ -45,37 +22,35 @@ class Options:
     charset_overrides_xml_encoding: bool
     infoset: bool
     supported_mediatypes_only: bool
-    errorHandler: Any | None
-    filter: DOMBuilderFilter | None  # a guess, but seems likely
+    errorHandler: _DOMErrorHandler | None
+    filter: DOMBuilderFilter | None
 
 class DOMBuilder:
-    entityResolver: DOMEntityResolver | None  # a guess, but seems likely
-    errorHandler: _DOMBuilderErrorHandlerType
-    filter: DOMBuilderFilter | None  # a guess, but seems likely
+    entityResolver: DOMEntityResolver | None
+    errorHandler: _DOMErrorHandler | None
+    filter: DOMBuilderFilter | None
     ACTION_REPLACE: Literal[1]
     ACTION_APPEND_AS_CHILDREN: Literal[2]
     ACTION_INSERT_AFTER: Literal[3]
     ACTION_INSERT_BEFORE: Literal[4]
+    def __init__(self) -> None: ...
     def setFeature(self, name: str, state: int) -> None: ...
     def supportsFeature(self, name: str) -> bool: ...
-    def canSetFeature(self, name: str, state: int) -> bool: ...
+    def canSetFeature(self, name: str, state: Literal[1, 0]) -> bool: ...
     # getFeature could return any attribute from an instance of `Options`
-    def getFeature(self, name: str) -> Incomplete: ...
-    def parseURI(self, uri: str) -> ExpatBuilder | ExpatBuilderNS: ...
-    def parse(self, input: DOMInputSource) -> ExpatBuilder | ExpatBuilderNS: ...
-    # `input` and `cnode` argtypes for `parseWithContext` are unknowable
-    # as the function does nothing with them, and always raises an exception.
-    # But `input` is *probably* `DOMInputSource`?
-    def parseWithContext(self, input: Unused, cnode: Unused, action: Literal[1, 2, 3, 4]) -> NoReturn: ...
+    def getFeature(self, name: str) -> Any: ...
+    def parseURI(self, uri: str) -> Document: ...
+    def parse(self, input: DOMInputSource) -> Document: ...
+    def parseWithContext(self, input: DOMInputSource, cnode: Node, action: Literal[1, 2, 3, 4]) -> NoReturn: ...
 
 class DOMEntityResolver:
     def resolveEntity(self, publicId: str | None, systemId: str) -> DOMInputSource: ...
 
 class DOMInputSource:
-    byteStream: OpenerDirector | None
-    characterStream: _DOMInputSourceCharacterStreamType
-    stringData: _DOMInputSourceStringDataType
-    encoding: _DOMInputSourceEncodingType
+    byteStream: SupportsRead[bytes] | None
+    characterStream: SupportsRead[str] | None
+    stringData: str | None
+    encoding: str | None
     publicId: str | None
     systemId: str | None
     baseURI: str | None
@@ -86,18 +61,14 @@ class DOMBuilderFilter:
     FILTER_SKIP: Literal[3]
     FILTER_INTERRUPT: Literal[4]
     whatToShow: int
-    def acceptNode(self, element: Unused) -> Literal[1]: ...
-    def startContainer(self, element: Unused) -> Literal[1]: ...
+    def acceptNode(self, element: Node) -> Literal[1, 2, 3, 4]: ...
+    def startContainer(self, element: Node) -> Literal[1, 2, 3, 4]: ...
 
 class DocumentLS:
     async_: bool
     def abort(self) -> NoReturn: ...
-    # `load()` and `loadXML()` always raise exceptions
-    # so the argtypes of `uri` and `source` are unknowable.
-    # `source` is *probably* `DOMInputSource`?
-    # `uri` is *probably* a str? (see DOMBuilder.parseURI())
-    def load(self, uri: Unused) -> NoReturn: ...
-    def loadXML(self, source: Unused) -> NoReturn: ...
+    def load(self, uri: str) -> NoReturn: ...
+    def loadXML(self, source: str) -> NoReturn: ...
     def saveXML(self, snode: Node | None) -> str: ...
 
 class DOMImplementationLS:
diff --git a/mypy/typeshed/stdlib/xml/etree/ElementInclude.pyi b/mypy/typeshed/stdlib/xml/etree/ElementInclude.pyi
index cbba15dd3ebe..10c305826453 100644
--- a/mypy/typeshed/stdlib/xml/etree/ElementInclude.pyi
+++ b/mypy/typeshed/stdlib/xml/etree/ElementInclude.pyi
@@ -1,28 +1,32 @@
 import sys
 from _typeshed import FileDescriptorOrPath
-from collections.abc import Callable
+from typing import Final, Literal, Protocol, overload
 from xml.etree.ElementTree import Element
 
-XINCLUDE: str
-XINCLUDE_INCLUDE: str
-XINCLUDE_FALLBACK: str
+class _Loader(Protocol):
+    @overload
+    def __call__(self, href: FileDescriptorOrPath, parse: Literal["xml"], encoding: str | None = None) -> Element: ...
+    @overload
+    def __call__(self, href: FileDescriptorOrPath, parse: Literal["text"], encoding: str | None = None) -> str: ...
+
+XINCLUDE: Final[str]
+XINCLUDE_INCLUDE: Final[str]
+XINCLUDE_FALLBACK: Final[str]
 
 if sys.version_info >= (3, 9):
-    DEFAULT_MAX_INCLUSION_DEPTH: int
+    DEFAULT_MAX_INCLUSION_DEPTH: Final = 6
 
 class FatalIncludeError(SyntaxError): ...
 
-def default_loader(href: FileDescriptorOrPath, parse: str, encoding: str | None = None) -> str | Element: ...
+@overload
+def default_loader(href: FileDescriptorOrPath, parse: Literal["xml"], encoding: str | None = None) -> Element: ...
+@overload
+def default_loader(href: FileDescriptorOrPath, parse: Literal["text"], encoding: str | None = None) -> str: ...
 
-# TODO: loader is of type default_loader ie it takes a callable that has the
-# same signature as default_loader. But default_loader has a keyword argument
-# Which can't be represented using Callable...
 if sys.version_info >= (3, 9):
-    def include(
-        elem: Element, loader: Callable[..., str | Element] | None = None, base_url: str | None = None, max_depth: int | None = 6
-    ) -> None: ...
+    def include(elem: Element, loader: _Loader | None = None, base_url: str | None = None, max_depth: int | None = 6) -> None: ...
 
     class LimitedRecursiveIncludeError(FatalIncludeError): ...
 
 else:
-    def include(elem: Element, loader: Callable[..., str | Element] | None = None) -> None: ...
+    def include(elem: Element, loader: _Loader | None = None) -> None: ...
diff --git a/mypy/typeshed/stdlib/xml/etree/ElementPath.pyi b/mypy/typeshed/stdlib/xml/etree/ElementPath.pyi
index c3f6207ea241..ebfb4f1ffbb9 100644
--- a/mypy/typeshed/stdlib/xml/etree/ElementPath.pyi
+++ b/mypy/typeshed/stdlib/xml/etree/ElementPath.pyi
@@ -1,6 +1,6 @@
-from collections.abc import Callable, Generator
+from collections.abc import Callable, Generator, Iterable
 from re import Pattern
-from typing import TypeVar
+from typing import Any, Literal, TypeVar, overload
 from typing_extensions import TypeAlias
 from xml.etree.ElementTree import Element
 
@@ -8,27 +8,34 @@ xpath_tokenizer_re: Pattern[str]
 
 _Token: TypeAlias = tuple[str, str]
 _Next: TypeAlias = Callable[[], _Token]
-_Callback: TypeAlias = Callable[[_SelectorContext, list[Element]], Generator[Element, None, None]]
+_Callback: TypeAlias = Callable[[_SelectorContext, Iterable[Element]], Generator[Element, None, None]]
+_T = TypeVar("_T")
 
 def xpath_tokenizer(pattern: str, namespaces: dict[str, str] | None = None) -> Generator[_Token, None, None]: ...
 def get_parent_map(context: _SelectorContext) -> dict[Element, Element]: ...
 def prepare_child(next: _Next, token: _Token) -> _Callback: ...
 def prepare_star(next: _Next, token: _Token) -> _Callback: ...
 def prepare_self(next: _Next, token: _Token) -> _Callback: ...
-def prepare_descendant(next: _Next, token: _Token) -> _Callback: ...
+def prepare_descendant(next: _Next, token: _Token) -> _Callback | None: ...
 def prepare_parent(next: _Next, token: _Token) -> _Callback: ...
-def prepare_predicate(next: _Next, token: _Token) -> _Callback: ...
+def prepare_predicate(next: _Next, token: _Token) -> _Callback | None: ...
 
-ops: dict[str, Callable[[_Next, _Token], _Callback]]
+ops: dict[str, Callable[[_Next, _Token], _Callback | None]]
 
 class _SelectorContext:
     parent_map: dict[Element, Element] | None
     root: Element
     def __init__(self, root: Element) -> None: ...
 
-_T = TypeVar("_T")
-
-def iterfind(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
-def find(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
-def findall(elem: Element, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
-def findtext(elem: Element, path: str, default: _T | None = None, namespaces: dict[str, str] | None = None) -> _T | str: ...
+@overload
+def iterfind(  # type: ignore[overload-overlap]
+    elem: Element[Any], path: Literal[""], namespaces: dict[str, str] | None = None
+) -> None: ...
+@overload
+def iterfind(elem: Element[Any], path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
+def find(elem: Element[Any], path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
+def findall(elem: Element[Any], path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+@overload
+def findtext(elem: Element[Any], path: str, default: None = None, namespaces: dict[str, str] | None = None) -> str | None: ...
+@overload
+def findtext(elem: Element[Any], path: str, default: _T, namespaces: dict[str, str] | None = None) -> _T | str: ...
diff --git a/mypy/typeshed/stdlib/xml/etree/ElementTree.pyi b/mypy/typeshed/stdlib/xml/etree/ElementTree.pyi
index 2cf8dbbe7025..4a9113868d7e 100644
--- a/mypy/typeshed/stdlib/xml/etree/ElementTree.pyi
+++ b/mypy/typeshed/stdlib/xml/etree/ElementTree.pyi
@@ -2,14 +2,17 @@ import sys
 from _collections_abc import dict_keys
 from _typeshed import FileDescriptorOrPath, ReadableBuffer, SupportsRead, SupportsWrite
 from collections.abc import Callable, Generator, ItemsView, Iterable, Iterator, Mapping, Sequence
-from typing import Any, TypeVar, overload
-from typing_extensions import Literal, SupportsIndex, TypeAlias, TypeGuard
+from typing import Any, Final, Generic, Literal, Protocol, SupportsIndex, TypeVar, overload, type_check_only
+from typing_extensions import TypeAlias, TypeGuard, deprecated
+from xml.parsers.expat import XMLParserType
 
 __all__ = [
+    "C14NWriterTarget",
     "Comment",
     "dump",
     "Element",
     "ElementTree",
+    "canonicalize",
     "fromstring",
     "fromstringlist",
     "iselement",
@@ -31,9 +34,6 @@ __all__ = [
     "register_namespace",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["C14NWriterTarget", "canonicalize"]
-
 if sys.version_info >= (3, 9):
     __all__ += ["indent"]
 
@@ -42,7 +42,7 @@ _FileRead: TypeAlias = FileDescriptorOrPath | SupportsRead[bytes] | SupportsRead
 _FileWriteC14N: TypeAlias = FileDescriptorOrPath | SupportsWrite[bytes]
 _FileWrite: TypeAlias = _FileWriteC14N | SupportsWrite[str]
 
-VERSION: str
+VERSION: Final[str]
 
 class ParseError(SyntaxError):
     code: int
@@ -50,46 +50,53 @@ class ParseError(SyntaxError):
 
 # In reality it works based on `.tag` attribute duck typing.
 def iselement(element: object) -> TypeGuard[Element]: ...
+@overload
+def canonicalize(
+    xml_data: str | ReadableBuffer | None = None,
+    *,
+    out: None = None,
+    from_file: _FileRead | None = None,
+    with_comments: bool = False,
+    strip_text: bool = False,
+    rewrite_prefixes: bool = False,
+    qname_aware_tags: Iterable[str] | None = None,
+    qname_aware_attrs: Iterable[str] | None = None,
+    exclude_attrs: Iterable[str] | None = None,
+    exclude_tags: Iterable[str] | None = None,
+) -> str: ...
+@overload
+def canonicalize(
+    xml_data: str | ReadableBuffer | None = None,
+    *,
+    out: SupportsWrite[str],
+    from_file: _FileRead | None = None,
+    with_comments: bool = False,
+    strip_text: bool = False,
+    rewrite_prefixes: bool = False,
+    qname_aware_tags: Iterable[str] | None = None,
+    qname_aware_attrs: Iterable[str] | None = None,
+    exclude_attrs: Iterable[str] | None = None,
+    exclude_tags: Iterable[str] | None = None,
+) -> None: ...
 
-if sys.version_info >= (3, 8):
-    @overload
-    def canonicalize(
-        xml_data: str | ReadableBuffer | None = None,
-        *,
-        out: None = None,
-        from_file: _FileRead | None = None,
-        with_comments: bool = False,
-        strip_text: bool = False,
-        rewrite_prefixes: bool = False,
-        qname_aware_tags: Iterable[str] | None = None,
-        qname_aware_attrs: Iterable[str] | None = None,
-        exclude_attrs: Iterable[str] | None = None,
-        exclude_tags: Iterable[str] | None = None,
-    ) -> str: ...
-    @overload
-    def canonicalize(
-        xml_data: str | ReadableBuffer | None = None,
-        *,
-        out: SupportsWrite[str],
-        from_file: _FileRead | None = None,
-        with_comments: bool = False,
-        strip_text: bool = False,
-        rewrite_prefixes: bool = False,
-        qname_aware_tags: Iterable[str] | None = None,
-        qname_aware_attrs: Iterable[str] | None = None,
-        exclude_attrs: Iterable[str] | None = None,
-        exclude_tags: Iterable[str] | None = None,
-    ) -> None: ...
+# The tag for Element can be set to the Comment or ProcessingInstruction
+# functions defined in this module. _ElementCallable could be a recursive
+# type, but defining it that way uncovered a bug in pytype.
+_ElementCallable: TypeAlias = Callable[..., Element[Any]]
+_CallableElement: TypeAlias = Element[_ElementCallable]
+
+_Tag = TypeVar("_Tag", default=str, bound=str | _ElementCallable)
+_OtherTag = TypeVar("_OtherTag", default=str, bound=str | _ElementCallable)
 
-class Element:
-    tag: str
+class Element(Generic[_Tag]):
+    tag: _Tag
     attrib: dict[str, str]
     text: str | None
     tail: str | None
-    def __init__(self, tag: str | Callable[..., Element], attrib: dict[str, str] = ..., **extra: str) -> None: ...
-    def append(self, __subelement: Element) -> None: ...
+    def __init__(self, tag: _Tag, attrib: dict[str, str] = {}, **extra: str) -> None: ...
+    def append(self, subelement: Element[Any], /) -> None: ...
     def clear(self) -> None: ...
-    def extend(self, __elements: Iterable[Element]) -> None: ...
+    def extend(self, elements: Iterable[Element], /) -> None: ...
     def find(self, path: str, namespaces: dict[str, str] | None = None) -> Element | None: ...
     def findall(self, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
     @overload
@@ -100,39 +107,46 @@ class Element:
     def get(self, key: str, default: None = None) -> str | None: ...
     @overload
     def get(self, key: str, default: _T) -> str | _T: ...
-    def insert(self, __index: int, __subelement: Element) -> None: ...
+    def insert(self, index: int, subelement: Element, /) -> None: ...
     def items(self) -> ItemsView[str, str]: ...
     def iter(self, tag: str | None = None) -> Generator[Element, None, None]: ...
+    @overload
+    def iterfind(self, path: Literal[""], namespaces: dict[str, str] | None = None) -> None: ...  # type: ignore[overload-overlap]
+    @overload
     def iterfind(self, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
     def itertext(self) -> Generator[str, None, None]: ...
     def keys(self) -> dict_keys[str, str]: ...
     # makeelement returns the type of self in Python impl, but not in C impl
-    def makeelement(self, __tag: str, __attrib: dict[str, str]) -> Element: ...
-    def remove(self, __subelement: Element) -> None: ...
-    def set(self, __key: str, __value: str) -> None: ...
-    def __copy__(self) -> Element: ...  # returns the type of self in Python impl, but not in C impl
-    def __deepcopy__(self, __memo: Any) -> Element: ...  # Only exists in C impl
-    def __delitem__(self, __key: SupportsIndex | slice) -> None: ...
+    def makeelement(self, tag: _OtherTag, attrib: dict[str, str], /) -> Element[_OtherTag]: ...
+    def remove(self, subelement: Element, /) -> None: ...
+    def set(self, key: str, value: str, /) -> None: ...
+    def __copy__(self) -> Element[_Tag]: ...  # returns the type of self in Python impl, but not in C impl
+    def __deepcopy__(self, memo: Any, /) -> Element: ...  # Only exists in C impl
+    def __delitem__(self, key: SupportsIndex | slice, /) -> None: ...
     @overload
-    def __getitem__(self, __key: SupportsIndex) -> Element: ...
+    def __getitem__(self, key: SupportsIndex, /) -> Element: ...
     @overload
-    def __getitem__(self, __key: slice) -> list[Element]: ...
+    def __getitem__(self, key: slice, /) -> list[Element]: ...
     def __len__(self) -> int: ...
     # Doesn't actually exist at runtime, but instance of the class are indeed iterable due to __getitem__.
     def __iter__(self) -> Iterator[Element]: ...
     @overload
-    def __setitem__(self, __key: SupportsIndex, __value: Element) -> None: ...
+    def __setitem__(self, key: SupportsIndex, value: Element, /) -> None: ...
     @overload
-    def __setitem__(self, __key: slice, __value: Iterable[Element]) -> None: ...
+    def __setitem__(self, key: slice, value: Iterable[Element], /) -> None: ...
+
+    # Doesn't really exist in earlier versions, where __len__ is called implicitly instead
+    @deprecated("Testing an element's truth value is deprecated.")
+    def __bool__(self) -> bool: ...
     if sys.version_info < (3, 9):
         def getchildren(self) -> list[Element]: ...
         def getiterator(self, tag: str | None = None) -> list[Element]: ...
 
 def SubElement(parent: Element, tag: str, attrib: dict[str, str] = ..., **extra: str) -> Element: ...
-def Comment(text: str | None = None) -> Element: ...
-def ProcessingInstruction(target: str, text: str | None = None) -> Element: ...
+def Comment(text: str | None = None) -> _CallableElement: ...
+def ProcessingInstruction(target: str, text: str | None = None) -> _CallableElement: ...
 
-PI: Callable[..., Element]
+PI = ProcessingInstruction
 
 class QName:
     text: str
@@ -142,10 +156,13 @@ class QName:
     def __gt__(self, other: QName | str) -> bool: ...
     def __ge__(self, other: QName | str) -> bool: ...
     def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
 
-class ElementTree:
+_Root = TypeVar("_Root", Element, Element | None, default=Element | None)
+
+class ElementTree(Generic[_Root]):
     def __init__(self, element: Element | None = None, file: _FileRead | None = None) -> None: ...
-    def getroot(self) -> Element | Any: ...
+    def getroot(self) -> _Root: ...
     def parse(self, source: _FileRead, parser: XMLParser | None = None) -> Element: ...
     def iter(self, tag: str | None = None) -> Generator[Element, None, None]: ...
     if sys.version_info < (3, 9):
@@ -157,6 +174,9 @@ class ElementTree:
     @overload
     def findtext(self, path: str, default: _T, namespaces: dict[str, str] | None = None) -> _T | str: ...
     def findall(self, path: str, namespaces: dict[str, str] | None = None) -> list[Element]: ...
+    @overload
+    def iterfind(self, path: Literal[""], namespaces: dict[str, str] | None = None) -> None: ...  # type: ignore[overload-overlap]
+    @overload
     def iterfind(self, path: str, namespaces: dict[str, str] | None = None) -> Generator[Element, None, None]: ...
     def write(
         self,
@@ -164,117 +184,101 @@ class ElementTree:
         encoding: str | None = None,
         xml_declaration: bool | None = None,
         default_namespace: str | None = None,
-        method: str | None = None,
+        method: Literal["xml", "html", "text", "c14n"] | None = None,
         *,
         short_empty_elements: bool = True,
     ) -> None: ...
     def write_c14n(self, file: _FileWriteC14N) -> None: ...
 
+HTML_EMPTY: set[str]
+
 def register_namespace(prefix: str, uri: str) -> None: ...
+@overload
+def tostring(
+    element: Element,
+    encoding: None = None,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> bytes: ...
+@overload
+def tostring(
+    element: Element,
+    encoding: Literal["unicode"],
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> str: ...
+@overload
+def tostring(
+    element: Element,
+    encoding: str,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> Any: ...
+@overload
+def tostringlist(
+    element: Element,
+    encoding: None = None,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[bytes]: ...
+@overload
+def tostringlist(
+    element: Element,
+    encoding: Literal["unicode"],
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[str]: ...
+@overload
+def tostringlist(
+    element: Element,
+    encoding: str,
+    method: Literal["xml", "html", "text", "c14n"] | None = None,
+    *,
+    xml_declaration: bool | None = None,
+    default_namespace: str | None = None,
+    short_empty_elements: bool = True,
+) -> list[Any]: ...
+def dump(elem: Element | ElementTree[Any]) -> None: ...
 
-if sys.version_info >= (3, 8):
-    @overload
-    def tostring(
-        element: Element,
-        encoding: None = None,
-        method: str | None = None,
-        *,
-        xml_declaration: bool | None = None,
-        default_namespace: str | None = None,
-        short_empty_elements: bool = True,
-    ) -> bytes: ...
-    @overload
-    def tostring(
-        element: Element,
-        encoding: Literal["unicode"],
-        method: str | None = None,
-        *,
-        xml_declaration: bool | None = None,
-        default_namespace: str | None = None,
-        short_empty_elements: bool = True,
-    ) -> str: ...
-    @overload
-    def tostring(
-        element: Element,
-        encoding: str,
-        method: str | None = None,
-        *,
-        xml_declaration: bool | None = None,
-        default_namespace: str | None = None,
-        short_empty_elements: bool = True,
-    ) -> Any: ...
-    @overload
-    def tostringlist(
-        element: Element,
-        encoding: None = None,
-        method: str | None = None,
-        *,
-        xml_declaration: bool | None = None,
-        default_namespace: str | None = None,
-        short_empty_elements: bool = True,
-    ) -> list[bytes]: ...
-    @overload
-    def tostringlist(
-        element: Element,
-        encoding: Literal["unicode"],
-        method: str | None = None,
-        *,
-        xml_declaration: bool | None = None,
-        default_namespace: str | None = None,
-        short_empty_elements: bool = True,
-    ) -> list[str]: ...
-    @overload
-    def tostringlist(
-        element: Element,
-        encoding: str,
-        method: str | None = None,
-        *,
-        xml_declaration: bool | None = None,
-        default_namespace: str | None = None,
-        short_empty_elements: bool = True,
-    ) -> list[Any]: ...
+if sys.version_info >= (3, 9):
+    def indent(tree: Element | ElementTree[Any], space: str = "  ", level: int = 0) -> None: ...
 
-else:
-    @overload
-    def tostring(
-        element: Element, encoding: None = None, method: str | None = None, *, short_empty_elements: bool = True
-    ) -> bytes: ...
-    @overload
-    def tostring(
-        element: Element, encoding: Literal["unicode"], method: str | None = None, *, short_empty_elements: bool = True
-    ) -> str: ...
-    @overload
-    def tostring(element: Element, encoding: str, method: str | None = None, *, short_empty_elements: bool = True) -> Any: ...
-    @overload
-    def tostringlist(
-        element: Element, encoding: None = None, method: str | None = None, *, short_empty_elements: bool = True
-    ) -> list[bytes]: ...
-    @overload
-    def tostringlist(
-        element: Element, encoding: Literal["unicode"], method: str | None = None, *, short_empty_elements: bool = True
-    ) -> list[str]: ...
-    @overload
-    def tostringlist(
-        element: Element, encoding: str, method: str | None = None, *, short_empty_elements: bool = True
-    ) -> list[Any]: ...
+def parse(source: _FileRead, parser: XMLParser[Any] | None = None) -> ElementTree[Element]: ...
 
-def dump(elem: Element) -> None: ...
+# This class is defined inside the body of iterparse
+@type_check_only
+class _IterParseIterator(Iterator[tuple[str, Element]], Protocol):
+    def __next__(self) -> tuple[str, Element]: ...
+    if sys.version_info >= (3, 13):
+        def close(self) -> None: ...
+    if sys.version_info >= (3, 11):
+        def __del__(self) -> None: ...
 
-if sys.version_info >= (3, 9):
-    def indent(tree: Element | ElementTree, space: str = "  ", level: int = 0) -> None: ...
+def iterparse(source: _FileRead, events: Sequence[str] | None = None, parser: XMLParser | None = None) -> _IterParseIterator: ...
 
-def parse(source: _FileRead, parser: XMLParser | None = None) -> ElementTree: ...
-def iterparse(
-    source: _FileRead, events: Sequence[str] | None = None, parser: XMLParser | None = None
-) -> Iterator[tuple[str, Any]]: ...
+_EventQueue: TypeAlias = tuple[str] | tuple[str, tuple[str, str]] | tuple[str, None]
 
-class XMLPullParser:
-    def __init__(self, events: Sequence[str] | None = None, *, _parser: XMLParser | None = None) -> None: ...
+class XMLPullParser(Generic[_E]):
+    def __init__(self, events: Sequence[str] | None = None, *, _parser: XMLParser[_E] | None = None) -> None: ...
     def feed(self, data: str | ReadableBuffer) -> None: ...
     def close(self) -> None: ...
-    # Second element in the tuple could be `Element`, `tuple[str, str]` or `None`.
-    # Use `Any` to avoid false-positive errors.
-    def read_events(self) -> Iterator[tuple[str, Any]]: ...
+    def read_events(self) -> Iterator[_EventQueue | tuple[str, _E]]: ...
+    def flush(self) -> None: ...
 
 def XML(text: str | ReadableBuffer, parser: XMLParser | None = None) -> Element: ...
 def XMLID(text: str | ReadableBuffer, parser: XMLParser | None = None) -> tuple[Element, dict[str, Element]]: ...
@@ -296,65 +300,76 @@ def fromstringlist(sequence: Sequence[str | ReadableBuffer], parser: XMLParser |
 _ElementFactory: TypeAlias = Callable[[Any, dict[Any, Any]], Element]
 
 class TreeBuilder:
-    if sys.version_info >= (3, 8):
-        # comment_factory can take None because passing None to Comment is not an error
-        def __init__(
-            self,
-            element_factory: _ElementFactory | None = ...,
-            *,
-            comment_factory: Callable[[str | None], Element] | None = ...,
-            pi_factory: Callable[[str, str | None], Element] | None = ...,
-            insert_comments: bool = ...,
-            insert_pis: bool = ...,
-        ) -> None: ...
-        insert_comments: bool
-        insert_pis: bool
-    else:
-        def __init__(self, element_factory: _ElementFactory | None = ...) -> None: ...
+    # comment_factory can take None because passing None to Comment is not an error
+    def __init__(
+        self,
+        element_factory: _ElementFactory | None = None,
+        *,
+        comment_factory: Callable[[str | None], Element[Any]] | None = None,
+        pi_factory: Callable[[str, str | None], Element[Any]] | None = None,
+        insert_comments: bool = False,
+        insert_pis: bool = False,
+    ) -> None: ...
+    insert_comments: bool
+    insert_pis: bool
 
     def close(self) -> Element: ...
-    def data(self, __data: str) -> None: ...
+    def data(self, data: str, /) -> None: ...
     # tag and attrs are passed to the element_factory, so they could be anything
     # depending on what the particular factory supports.
-    def start(self, __tag: Any, __attrs: dict[Any, Any]) -> Element: ...
-    def end(self, __tag: str) -> Element: ...
-    if sys.version_info >= (3, 8):
-        # These two methods have pos-only parameters in the C implementation
-        def comment(self, __text: str | None) -> Element: ...
-        def pi(self, __target: str, __text: str | None = None) -> Element: ...
-
-if sys.version_info >= (3, 8):
-    class C14NWriterTarget:
-        def __init__(
-            self,
-            write: Callable[[str], object],
-            *,
-            with_comments: bool = False,
-            strip_text: bool = False,
-            rewrite_prefixes: bool = False,
-            qname_aware_tags: Iterable[str] | None = None,
-            qname_aware_attrs: Iterable[str] | None = None,
-            exclude_attrs: Iterable[str] | None = None,
-            exclude_tags: Iterable[str] | None = None,
-        ) -> None: ...
-        def data(self, data: str) -> None: ...
-        def start_ns(self, prefix: str, uri: str) -> None: ...
-        def start(self, tag: str, attrs: Mapping[str, str]) -> None: ...
-        def end(self, tag: str) -> None: ...
-        def comment(self, text: str) -> None: ...
-        def pi(self, target: str, data: str) -> None: ...
-
-class XMLParser:
-    parser: Any
-    target: Any
+    def start(self, tag: Any, attrs: dict[Any, Any], /) -> Element: ...
+    def end(self, tag: str, /) -> Element: ...
+    # These two methods have pos-only parameters in the C implementation
+    def comment(self, text: str | None, /) -> Element[Any]: ...
+    def pi(self, target: str, text: str | None = None, /) -> Element[Any]: ...
+
+class C14NWriterTarget:
+    def __init__(
+        self,
+        write: Callable[[str], object],
+        *,
+        with_comments: bool = False,
+        strip_text: bool = False,
+        rewrite_prefixes: bool = False,
+        qname_aware_tags: Iterable[str] | None = None,
+        qname_aware_attrs: Iterable[str] | None = None,
+        exclude_attrs: Iterable[str] | None = None,
+        exclude_tags: Iterable[str] | None = None,
+    ) -> None: ...
+    def data(self, data: str) -> None: ...
+    def start_ns(self, prefix: str, uri: str) -> None: ...
+    def start(self, tag: str, attrs: Mapping[str, str]) -> None: ...
+    def end(self, tag: str) -> None: ...
+    def comment(self, text: str) -> None: ...
+    def pi(self, target: str, data: str) -> None: ...
+
+# The target type is tricky, because the implementation doesn't
+# require any particular attribute to be present. This documents the attributes
+# that can be present, but uncommenting any of them would require them.
+class _Target(Protocol):
+    # start: Callable[str, dict[str, str], Any] | None
+    # end: Callable[[str], Any] | None
+    # start_ns: Callable[[str, str], Any] | None
+    # end_ns: Callable[[str], Any] | None
+    # data: Callable[[str], Any] | None
+    # comment: Callable[[str], Any]
+    # pi: Callable[[str, str], Any] | None
+    # close: Callable[[], Any] | None
+    ...
+
+_E = TypeVar("_E", default=Element)
+
+# This is generic because the return type of close() depends on the target.
+# The default target is TreeBuilder, which returns Element.
+# C14NWriterTarget does not implement a close method, so using it results
+# in a type of XMLParser[None].
+class XMLParser(Generic[_E]):
+    parser: XMLParserType
+    target: _Target
     # TODO-what is entity used for???
-    entity: Any
+    entity: dict[str, str]
     version: str
-    if sys.version_info >= (3, 8):
-        def __init__(self, *, target: Any = ..., encoding: str | None = ...) -> None: ...
-    else:
-        def __init__(self, html: int = ..., target: Any = ..., encoding: str | None = ...) -> None: ...
-        def doctype(self, __name: str, __pubid: str, __system: str) -> None: ...
-
-    def close(self) -> Any: ...
-    def feed(self, __data: str | ReadableBuffer) -> None: ...
+    def __init__(self, *, target: _Target | None = None, encoding: str | None = None) -> None: ...
+    def close(self) -> _E: ...
+    def feed(self, data: str | ReadableBuffer, /) -> None: ...
+    def flush(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/xml/parsers/expat/__init__.pyi b/mypy/typeshed/stdlib/xml/parsers/expat/__init__.pyi
index 73f3758c61ec..d9b7ea536999 100644
--- a/mypy/typeshed/stdlib/xml/parsers/expat/__init__.pyi
+++ b/mypy/typeshed/stdlib/xml/parsers/expat/__init__.pyi
@@ -1 +1,7 @@
 from pyexpat import *
+
+# This is actually implemented in the C module pyexpat, but considers itself to live here.
+class ExpatError(Exception):
+    code: int
+    lineno: int
+    offset: int
diff --git a/mypy/typeshed/stdlib/xml/sax/__init__.pyi b/mypy/typeshed/stdlib/xml/sax/__init__.pyi
index 8bcf902df8d8..a2eecc5a7864 100644
--- a/mypy/typeshed/stdlib/xml/sax/__init__.pyi
+++ b/mypy/typeshed/stdlib/xml/sax/__init__.pyi
@@ -1,47 +1,25 @@
-import sys
 from _typeshed import ReadableBuffer, StrPath, SupportsRead, _T_co
 from collections.abc import Iterable
-from typing import Any, NoReturn, Protocol
+from typing import Protocol
+from typing_extensions import TypeAlias
+from xml.sax._exceptions import (
+    SAXException as SAXException,
+    SAXNotRecognizedException as SAXNotRecognizedException,
+    SAXNotSupportedException as SAXNotSupportedException,
+    SAXParseException as SAXParseException,
+    SAXReaderNotAvailable as SAXReaderNotAvailable,
+)
 from xml.sax.handler import ContentHandler as ContentHandler, ErrorHandler as ErrorHandler
-from xml.sax.xmlreader import Locator, XMLReader
+from xml.sax.xmlreader import XMLReader
 
 class _SupportsReadClose(SupportsRead[_T_co], Protocol[_T_co]):
     def close(self) -> None: ...
 
-class SAXException(Exception):
-    def __init__(self, msg: str, exception: Exception | None = None) -> None: ...
-    def getMessage(self) -> str: ...
-    def getException(self) -> Exception: ...
-    def __getitem__(self, ix: Any) -> NoReturn: ...
-
-class SAXParseException(SAXException):
-    def __init__(self, msg: str, exception: Exception | None, locator: Locator) -> None: ...
-    def getColumnNumber(self) -> int: ...
-    def getLineNumber(self) -> int: ...
-    def getPublicId(self): ...
-    def getSystemId(self): ...
-
-class SAXNotRecognizedException(SAXException): ...
-class SAXNotSupportedException(SAXException): ...
-class SAXReaderNotAvailable(SAXNotSupportedException): ...
+_Source: TypeAlias = StrPath | _SupportsReadClose[bytes] | _SupportsReadClose[str]
 
 default_parser_list: list[str]
 
-if sys.version_info >= (3, 8):
-    def make_parser(parser_list: Iterable[str] = ()) -> XMLReader: ...
-    def parse(
-        source: StrPath | _SupportsReadClose[bytes] | _SupportsReadClose[str],
-        handler: ContentHandler,
-        errorHandler: ErrorHandler = ...,
-    ) -> None: ...
-
-else:
-    def make_parser(parser_list: list[str] = []) -> XMLReader: ...
-    def parse(
-        source: str | _SupportsReadClose[bytes] | _SupportsReadClose[str],
-        handler: ContentHandler,
-        errorHandler: ErrorHandler = ...,
-    ) -> None: ...
-
+def make_parser(parser_list: Iterable[str] = ()) -> XMLReader: ...
+def parse(source: _Source, handler: ContentHandler, errorHandler: ErrorHandler = ...) -> None: ...
 def parseString(string: ReadableBuffer | str, handler: ContentHandler, errorHandler: ErrorHandler | None = ...) -> None: ...
 def _create_parser(parser_name: str) -> XMLReader: ...
diff --git a/mypy/typeshed/stdlib/xml/sax/_exceptions.pyi b/mypy/typeshed/stdlib/xml/sax/_exceptions.pyi
new file mode 100644
index 000000000000..e9cc8856a9c8
--- /dev/null
+++ b/mypy/typeshed/stdlib/xml/sax/_exceptions.pyi
@@ -0,0 +1,19 @@
+from typing import NoReturn
+from xml.sax.xmlreader import Locator
+
+class SAXException(Exception):
+    def __init__(self, msg: str, exception: Exception | None = None) -> None: ...
+    def getMessage(self) -> str: ...
+    def getException(self) -> Exception | None: ...
+    def __getitem__(self, ix: object) -> NoReturn: ...
+
+class SAXParseException(SAXException):
+    def __init__(self, msg: str, exception: Exception | None, locator: Locator) -> None: ...
+    def getColumnNumber(self) -> int | None: ...
+    def getLineNumber(self) -> int | None: ...
+    def getPublicId(self) -> str | None: ...
+    def getSystemId(self) -> str | None: ...
+
+class SAXNotRecognizedException(SAXException): ...
+class SAXNotSupportedException(SAXException): ...
+class SAXReaderNotAvailable(SAXNotSupportedException): ...
diff --git a/mypy/typeshed/stdlib/xml/sax/expatreader.pyi b/mypy/typeshed/stdlib/xml/sax/expatreader.pyi
new file mode 100644
index 000000000000..6a68f52f0e99
--- /dev/null
+++ b/mypy/typeshed/stdlib/xml/sax/expatreader.pyi
@@ -0,0 +1,82 @@
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Mapping
+from typing import Any, Literal, overload
+from typing_extensions import TypeAlias
+from xml.sax import _Source, xmlreader
+from xml.sax.handler import _ContentHandlerProtocol
+
+if sys.version_info >= (3, 10):
+    from xml.sax.handler import LexicalHandler
+
+_BoolType: TypeAlias = Literal[0, 1] | bool
+
+version: str
+AttributesImpl = xmlreader.AttributesImpl
+AttributesNSImpl = xmlreader.AttributesNSImpl
+
+class _ClosedParser:
+    ErrorColumnNumber: int
+    ErrorLineNumber: int
+
+class ExpatLocator(xmlreader.Locator):
+    def __init__(self, parser: ExpatParser) -> None: ...
+    def getColumnNumber(self) -> int | None: ...
+    def getLineNumber(self) -> int: ...
+    def getPublicId(self) -> str | None: ...
+    def getSystemId(self) -> str | None: ...
+
+class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
+    def __init__(self, namespaceHandling: _BoolType = 0, bufsize: int = 65516) -> None: ...
+    def parse(self, source: xmlreader.InputSource | _Source) -> None: ...
+    def prepareParser(self, source: xmlreader.InputSource) -> None: ...
+    def setContentHandler(self, handler: _ContentHandlerProtocol) -> None: ...
+    def getFeature(self, name: str) -> _BoolType: ...
+    def setFeature(self, name: str, state: _BoolType) -> None: ...
+    if sys.version_info >= (3, 10):
+        @overload
+        def getProperty(self, name: Literal["http://xml.org/sax/properties/lexical-handler"]) -> LexicalHandler | None: ...
+
+    @overload
+    def getProperty(self, name: Literal["http://www.python.org/sax/properties/interning-dict"]) -> dict[str, Any] | None: ...
+    @overload
+    def getProperty(self, name: Literal["http://xml.org/sax/properties/xml-string"]) -> bytes | None: ...
+    @overload
+    def getProperty(self, name: str) -> object: ...
+    if sys.version_info >= (3, 10):
+        @overload
+        def setProperty(self, name: Literal["http://xml.org/sax/properties/lexical-handler"], value: LexicalHandler) -> None: ...
+
+    @overload
+    def setProperty(
+        self, name: Literal["http://www.python.org/sax/properties/interning-dict"], value: dict[str, Any]
+    ) -> None: ...
+    @overload
+    def setProperty(self, name: str, value: object) -> None: ...
+    if sys.version_info >= (3, 9):
+        def feed(self, data: str | ReadableBuffer, isFinal: bool = False) -> None: ...
+    else:
+        def feed(self, data: str | ReadableBuffer, isFinal: _BoolType = 0) -> None: ...
+
+    def flush(self) -> None: ...
+    def close(self) -> None: ...
+    def reset(self) -> None: ...
+    def getColumnNumber(self) -> int | None: ...
+    def getLineNumber(self) -> int: ...
+    def getPublicId(self) -> str | None: ...
+    def getSystemId(self) -> str | None: ...
+    def start_element(self, name: str, attrs: Mapping[str, str]) -> None: ...
+    def end_element(self, name: str) -> None: ...
+    def start_element_ns(self, name: str, attrs: Mapping[str, str]) -> None: ...
+    def end_element_ns(self, name: str) -> None: ...
+    def processing_instruction(self, target: str, data: str) -> None: ...
+    def character_data(self, data: str) -> None: ...
+    def start_namespace_decl(self, prefix: str | None, uri: str) -> None: ...
+    def end_namespace_decl(self, prefix: str | None) -> None: ...
+    def start_doctype_decl(self, name: str, sysid: str | None, pubid: str | None, has_internal_subset: bool) -> None: ...
+    def unparsed_entity_decl(self, name: str, base: str | None, sysid: str, pubid: str | None, notation_name: str) -> None: ...
+    def notation_decl(self, name: str, base: str | None, sysid: str, pubid: str | None) -> None: ...
+    def external_entity_ref(self, context: str, base: str | None, sysid: str, pubid: str | None) -> int: ...
+    def skipped_entity_handler(self, name: str, is_pe: bool) -> None: ...
+
+def create_parser(namespaceHandling: int = 0, bufsize: int = 65516) -> ExpatParser: ...
diff --git a/mypy/typeshed/stdlib/xml/sax/handler.pyi b/mypy/typeshed/stdlib/xml/sax/handler.pyi
index 63b725bd6da6..550911734596 100644
--- a/mypy/typeshed/stdlib/xml/sax/handler.pyi
+++ b/mypy/typeshed/stdlib/xml/sax/handler.pyi
@@ -1,34 +1,66 @@
 import sys
-from typing import NoReturn
+from typing import Literal, NoReturn, Protocol, type_check_only
+from xml.sax import xmlreader
 
 version: str
 
+@type_check_only
+class _ErrorHandlerProtocol(Protocol):  # noqa: Y046  # Protocol is not used
+    def error(self, exception: BaseException) -> NoReturn: ...
+    def fatalError(self, exception: BaseException) -> NoReturn: ...
+    def warning(self, exception: BaseException) -> None: ...
+
 class ErrorHandler:
     def error(self, exception: BaseException) -> NoReturn: ...
     def fatalError(self, exception: BaseException) -> NoReturn: ...
     def warning(self, exception: BaseException) -> None: ...
 
+@type_check_only
+class _ContentHandlerProtocol(Protocol):  # noqa: Y046  # Protocol is not used
+    def setDocumentLocator(self, locator: xmlreader.Locator) -> None: ...
+    def startDocument(self) -> None: ...
+    def endDocument(self) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def startElementNS(self, name: tuple[str | None, str], qname: str | None, attrs: xmlreader.AttributesNSImpl) -> None: ...
+    def endElementNS(self, name: tuple[str | None, str], qname: str | None) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def ignorableWhitespace(self, whitespace: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def skippedEntity(self, name: str) -> None: ...
+
 class ContentHandler:
-    def setDocumentLocator(self, locator): ...
-    def startDocument(self): ...
-    def endDocument(self): ...
-    def startPrefixMapping(self, prefix, uri): ...
-    def endPrefixMapping(self, prefix): ...
-    def startElement(self, name, attrs): ...
-    def endElement(self, name): ...
-    def startElementNS(self, name, qname, attrs): ...
-    def endElementNS(self, name, qname): ...
-    def characters(self, content): ...
-    def ignorableWhitespace(self, whitespace): ...
-    def processingInstruction(self, target, data): ...
-    def skippedEntity(self, name): ...
+    def setDocumentLocator(self, locator: xmlreader.Locator) -> None: ...
+    def startDocument(self) -> None: ...
+    def endDocument(self) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def startElementNS(self, name: tuple[str | None, str], qname: str | None, attrs: xmlreader.AttributesNSImpl) -> None: ...
+    def endElementNS(self, name: tuple[str | None, str], qname: str | None) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def ignorableWhitespace(self, whitespace: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def skippedEntity(self, name: str) -> None: ...
+
+@type_check_only
+class _DTDHandlerProtocol(Protocol):  # noqa: Y046  # Protocol is not used
+    def notationDecl(self, name: str, publicId: str | None, systemId: str) -> None: ...
+    def unparsedEntityDecl(self, name: str, publicId: str | None, systemId: str, ndata: str) -> None: ...
 
 class DTDHandler:
-    def notationDecl(self, name, publicId, systemId): ...
-    def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
+    def notationDecl(self, name: str, publicId: str | None, systemId: str) -> None: ...
+    def unparsedEntityDecl(self, name: str, publicId: str | None, systemId: str, ndata: str) -> None: ...
+
+@type_check_only
+class _EntityResolverProtocol(Protocol):  # noqa: Y046  # Protocol is not used
+    def resolveEntity(self, publicId: str | None, systemId: str) -> str: ...
 
 class EntityResolver:
-    def resolveEntity(self, publicId, systemId): ...
+    def resolveEntity(self, publicId: str | None, systemId: str) -> str: ...
 
 feature_namespaces: str
 feature_namespace_prefixes: str
@@ -37,18 +69,18 @@ feature_validation: str
 feature_external_ges: str
 feature_external_pes: str
 all_features: list[str]
-property_lexical_handler: str
-property_declaration_handler: str
-property_dom_node: str
-property_xml_string: str
-property_encoding: str
-property_interning_dict: str
+property_lexical_handler: Literal["http://xml.org/sax/properties/lexical-handler"]
+property_declaration_handler: Literal["http://xml.org/sax/properties/declaration-handler"]
+property_dom_node: Literal["http://xml.org/sax/properties/dom-node"]
+property_xml_string: Literal["http://xml.org/sax/properties/xml-string"]
+property_encoding: Literal["http://www.python.org/sax/properties/encoding"]
+property_interning_dict: Literal["http://www.python.org/sax/properties/interning-dict"]
 all_properties: list[str]
 
 if sys.version_info >= (3, 10):
     class LexicalHandler:
-        def comment(self, content: str) -> object: ...
-        def startDTD(self, name: str, public_id: str | None, system_id: str | None) -> object: ...
-        def endDTD(self) -> object: ...
-        def startCDATA(self) -> object: ...
-        def endCDATA(self) -> object: ...
+        def comment(self, content: str) -> None: ...
+        def startDTD(self, name: str, public_id: str | None, system_id: str | None) -> None: ...
+        def endDTD(self) -> None: ...
+        def startCDATA(self) -> None: ...
+        def endCDATA(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/xml/sax/saxutils.pyi b/mypy/typeshed/stdlib/xml/sax/saxutils.pyi
index 0d9223770c6a..a29588faae2a 100644
--- a/mypy/typeshed/stdlib/xml/sax/saxutils.pyi
+++ b/mypy/typeshed/stdlib/xml/sax/saxutils.pyi
@@ -2,7 +2,8 @@ from _typeshed import SupportsWrite
 from codecs import StreamReaderWriter, StreamWriter
 from collections.abc import Mapping
 from io import RawIOBase, TextIOBase
-from xml.sax import handler, xmlreader
+from typing import Literal, NoReturn
+from xml.sax import _Source, handler, xmlreader
 
 def escape(data: str, entities: Mapping[str, str] = {}) -> str: ...
 def unescape(data: str, entities: Mapping[str, str] = {}) -> str: ...
@@ -11,50 +12,57 @@ def quoteattr(data: str, entities: Mapping[str, str] = {}) -> str: ...
 class XMLGenerator(handler.ContentHandler):
     def __init__(
         self,
-        out: TextIOBase | RawIOBase | StreamWriter | StreamReaderWriter | SupportsWrite[str] | None = None,
+        out: TextIOBase | RawIOBase | StreamWriter | StreamReaderWriter | SupportsWrite[bytes] | None = None,
         encoding: str = "iso-8859-1",
         short_empty_elements: bool = False,
     ) -> None: ...
-    def startDocument(self): ...
-    def endDocument(self): ...
-    def startPrefixMapping(self, prefix, uri): ...
-    def endPrefixMapping(self, prefix): ...
-    def startElement(self, name, attrs): ...
-    def endElement(self, name): ...
-    def startElementNS(self, name, qname, attrs): ...
-    def endElementNS(self, name, qname): ...
-    def characters(self, content): ...
-    def ignorableWhitespace(self, content): ...
-    def processingInstruction(self, target, data): ...
+    def _qname(self, name: tuple[str | None, str]) -> str: ...
+    def startDocument(self) -> None: ...
+    def endDocument(self) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def startElementNS(self, name: tuple[str | None, str], qname: str | None, attrs: xmlreader.AttributesNSImpl) -> None: ...
+    def endElementNS(self, name: tuple[str | None, str], qname: str | None) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def ignorableWhitespace(self, content: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
 
 class XMLFilterBase(xmlreader.XMLReader):
     def __init__(self, parent: xmlreader.XMLReader | None = None) -> None: ...
-    def error(self, exception): ...
-    def fatalError(self, exception): ...
-    def warning(self, exception): ...
-    def setDocumentLocator(self, locator): ...
-    def startDocument(self): ...
-    def endDocument(self): ...
-    def startPrefixMapping(self, prefix, uri): ...
-    def endPrefixMapping(self, prefix): ...
-    def startElement(self, name, attrs): ...
-    def endElement(self, name): ...
-    def startElementNS(self, name, qname, attrs): ...
-    def endElementNS(self, name, qname): ...
-    def characters(self, content): ...
-    def ignorableWhitespace(self, chars): ...
-    def processingInstruction(self, target, data): ...
-    def skippedEntity(self, name): ...
-    def notationDecl(self, name, publicId, systemId): ...
-    def unparsedEntityDecl(self, name, publicId, systemId, ndata): ...
-    def resolveEntity(self, publicId, systemId): ...
-    def parse(self, source): ...
-    def setLocale(self, locale): ...
-    def getFeature(self, name): ...
-    def setFeature(self, name, state): ...
-    def getProperty(self, name): ...
-    def setProperty(self, name, value): ...
-    def getParent(self): ...
-    def setParent(self, parent): ...
+    # ErrorHandler methods
+    def error(self, exception: BaseException) -> NoReturn: ...
+    def fatalError(self, exception: BaseException) -> NoReturn: ...
+    def warning(self, exception: BaseException) -> None: ...
+    # ContentHandler methods
+    def setDocumentLocator(self, locator: xmlreader.Locator) -> None: ...
+    def startDocument(self) -> None: ...
+    def endDocument(self) -> None: ...
+    def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
+    def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
+    def endElement(self, name: str) -> None: ...
+    def startElementNS(self, name: tuple[str | None, str], qname: str | None, attrs: xmlreader.AttributesNSImpl) -> None: ...
+    def endElementNS(self, name: tuple[str | None, str], qname: str | None) -> None: ...
+    def characters(self, content: str) -> None: ...
+    def ignorableWhitespace(self, chars: str) -> None: ...
+    def processingInstruction(self, target: str, data: str) -> None: ...
+    def skippedEntity(self, name: str) -> None: ...
+    # DTDHandler methods
+    def notationDecl(self, name: str, publicId: str | None, systemId: str) -> None: ...
+    def unparsedEntityDecl(self, name: str, publicId: str | None, systemId: str, ndata: str) -> None: ...
+    # EntityResolver methods
+    def resolveEntity(self, publicId: str | None, systemId: str) -> str: ...
+    # XMLReader methods
+    def parse(self, source: xmlreader.InputSource | _Source) -> None: ...
+    def setLocale(self, locale: str) -> None: ...
+    def getFeature(self, name: str) -> Literal[1, 0] | bool: ...
+    def setFeature(self, name: str, state: Literal[1, 0] | bool) -> None: ...
+    def getProperty(self, name: str) -> object: ...
+    def setProperty(self, name: str, value: object) -> None: ...
+    # XMLFilter methods
+    def getParent(self) -> xmlreader.XMLReader | None: ...
+    def setParent(self, parent: xmlreader.XMLReader) -> None: ...
 
-def prepare_input_source(source, base=""): ...
+def prepare_input_source(source: xmlreader.InputSource | _Source, base: str = "") -> xmlreader.InputSource: ...
diff --git a/mypy/typeshed/stdlib/xml/sax/xmlreader.pyi b/mypy/typeshed/stdlib/xml/sax/xmlreader.pyi
index 0bf167b04a37..e7d04ddeadb8 100644
--- a/mypy/typeshed/stdlib/xml/sax/xmlreader.pyi
+++ b/mypy/typeshed/stdlib/xml/sax/xmlreader.pyi
@@ -1,71 +1,90 @@
+from _typeshed import ReadableBuffer
 from collections.abc import Mapping
+from typing import Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+from xml.sax import _Source, _SupportsReadClose
+from xml.sax.handler import _ContentHandlerProtocol, _DTDHandlerProtocol, _EntityResolverProtocol, _ErrorHandlerProtocol
 
 class XMLReader:
-    def parse(self, source): ...
-    def getContentHandler(self): ...
-    def setContentHandler(self, handler): ...
-    def getDTDHandler(self): ...
-    def setDTDHandler(self, handler): ...
-    def getEntityResolver(self): ...
-    def setEntityResolver(self, resolver): ...
-    def getErrorHandler(self): ...
-    def setErrorHandler(self, handler): ...
-    def setLocale(self, locale): ...
-    def getFeature(self, name): ...
-    def setFeature(self, name, state): ...
-    def getProperty(self, name): ...
-    def setProperty(self, name, value): ...
+    def parse(self, source: InputSource | _Source) -> None: ...
+    def getContentHandler(self) -> _ContentHandlerProtocol: ...
+    def setContentHandler(self, handler: _ContentHandlerProtocol) -> None: ...
+    def getDTDHandler(self) -> _DTDHandlerProtocol: ...
+    def setDTDHandler(self, handler: _DTDHandlerProtocol) -> None: ...
+    def getEntityResolver(self) -> _EntityResolverProtocol: ...
+    def setEntityResolver(self, resolver: _EntityResolverProtocol) -> None: ...
+    def getErrorHandler(self) -> _ErrorHandlerProtocol: ...
+    def setErrorHandler(self, handler: _ErrorHandlerProtocol) -> None: ...
+    def setLocale(self, locale: str) -> None: ...
+    def getFeature(self, name: str) -> Literal[0, 1] | bool: ...
+    def setFeature(self, name: str, state: Literal[0, 1] | bool) -> None: ...
+    def getProperty(self, name: str) -> object: ...
+    def setProperty(self, name: str, value: object) -> None: ...
 
 class IncrementalParser(XMLReader):
     def __init__(self, bufsize: int = 65536) -> None: ...
-    def parse(self, source): ...
-    def feed(self, data): ...
-    def prepareParser(self, source): ...
-    def close(self): ...
-    def reset(self): ...
+    def parse(self, source: InputSource | _Source) -> None: ...
+    def feed(self, data: str | ReadableBuffer) -> None: ...
+    def prepareParser(self, source: InputSource) -> None: ...
+    def close(self) -> None: ...
+    def reset(self) -> None: ...
 
 class Locator:
-    def getColumnNumber(self): ...
-    def getLineNumber(self): ...
-    def getPublicId(self): ...
-    def getSystemId(self): ...
+    def getColumnNumber(self) -> int | None: ...
+    def getLineNumber(self) -> int | None: ...
+    def getPublicId(self) -> str | None: ...
+    def getSystemId(self) -> str | None: ...
 
 class InputSource:
     def __init__(self, system_id: str | None = None) -> None: ...
-    def setPublicId(self, public_id): ...
-    def getPublicId(self): ...
-    def setSystemId(self, system_id): ...
-    def getSystemId(self): ...
-    def setEncoding(self, encoding): ...
-    def getEncoding(self): ...
-    def setByteStream(self, bytefile): ...
-    def getByteStream(self): ...
-    def setCharacterStream(self, charfile): ...
-    def getCharacterStream(self): ...
+    def setPublicId(self, public_id: str | None) -> None: ...
+    def getPublicId(self) -> str | None: ...
+    def setSystemId(self, system_id: str | None) -> None: ...
+    def getSystemId(self) -> str | None: ...
+    def setEncoding(self, encoding: str | None) -> None: ...
+    def getEncoding(self) -> str | None: ...
+    def setByteStream(self, bytefile: _SupportsReadClose[bytes] | None) -> None: ...
+    def getByteStream(self) -> _SupportsReadClose[bytes] | None: ...
+    def setCharacterStream(self, charfile: _SupportsReadClose[str] | None) -> None: ...
+    def getCharacterStream(self) -> _SupportsReadClose[str] | None: ...
 
-class AttributesImpl:
-    def __init__(self, attrs: Mapping[str, str]) -> None: ...
-    def getLength(self): ...
-    def getType(self, name): ...
-    def getValue(self, name): ...
-    def getValueByQName(self, name): ...
-    def getNameByQName(self, name): ...
-    def getQNameByName(self, name): ...
-    def getNames(self): ...
-    def getQNames(self): ...
+_AttrKey = TypeVar("_AttrKey", default=str)
+
+class AttributesImpl(Generic[_AttrKey]):
+    def __init__(self, attrs: Mapping[_AttrKey, str]) -> None: ...
+    def getLength(self) -> int: ...
+    def getType(self, name: str) -> str: ...
+    def getValue(self, name: _AttrKey) -> str: ...
+    def getValueByQName(self, name: str) -> str: ...
+    def getNameByQName(self, name: str) -> _AttrKey: ...
+    def getQNameByName(self, name: _AttrKey) -> str: ...
+    def getNames(self) -> list[_AttrKey]: ...
+    def getQNames(self) -> list[str]: ...
     def __len__(self) -> int: ...
-    def __getitem__(self, name): ...
-    def keys(self): ...
-    def __contains__(self, name): ...
-    def get(self, name, alternative=None): ...
-    def copy(self): ...
-    def items(self): ...
-    def values(self): ...
+    def __getitem__(self, name: _AttrKey) -> str: ...
+    def keys(self) -> list[_AttrKey]: ...
+    def __contains__(self, name: _AttrKey) -> bool: ...
+    @overload
+    def get(self, name: _AttrKey, alternative: None = None) -> str | None: ...
+    @overload
+    def get(self, name: _AttrKey, alternative: str) -> str: ...
+    def copy(self) -> Self: ...
+    def items(self) -> list[tuple[_AttrKey, str]]: ...
+    def values(self) -> list[str]: ...
+
+_NSName: TypeAlias = tuple[str | None, str]
 
-class AttributesNSImpl(AttributesImpl):
-    def __init__(self, attrs: Mapping[tuple[str, str], str], qnames: Mapping[tuple[str, str], str]) -> None: ...
-    def getValueByQName(self, name): ...
-    def getNameByQName(self, name): ...
-    def getQNameByName(self, name): ...
-    def getQNames(self): ...
-    def copy(self): ...
+class AttributesNSImpl(AttributesImpl[_NSName]):
+    def __init__(self, attrs: Mapping[_NSName, str], qnames: Mapping[_NSName, str]) -> None: ...
+    def getValue(self, name: _NSName) -> str: ...
+    def getNameByQName(self, name: str) -> _NSName: ...
+    def getQNameByName(self, name: _NSName) -> str: ...
+    def getNames(self) -> list[_NSName]: ...
+    def __getitem__(self, name: _NSName) -> str: ...
+    def keys(self) -> list[_NSName]: ...
+    def __contains__(self, name: _NSName) -> bool: ...
+    @overload
+    def get(self, name: _NSName, alternative: None = None) -> str | None: ...
+    @overload
+    def get(self, name: _NSName, alternative: str) -> str: ...
+    def items(self) -> list[tuple[_NSName, str]]: ...
diff --git a/mypy/typeshed/stdlib/xmlrpc/client.pyi b/mypy/typeshed/stdlib/xmlrpc/client.pyi
index 79969359f091..6cc4361f4a09 100644
--- a/mypy/typeshed/stdlib/xmlrpc/client.pyi
+++ b/mypy/typeshed/stdlib/xmlrpc/client.pyi
@@ -1,14 +1,13 @@
 import gzip
 import http.client
-import sys
 import time
 from _typeshed import ReadableBuffer, SizedBuffer, SupportsRead, SupportsWrite
 from collections.abc import Callable, Iterable, Mapping
 from datetime import datetime
 from io import BytesIO
 from types import TracebackType
-from typing import Any, Protocol, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import Any, ClassVar, Final, Literal, Protocol, overload
+from typing_extensions import Self, TypeAlias
 
 class _SupportsTimeTuple(Protocol):
     def timetuple(self) -> time.struct_time: ...
@@ -35,22 +34,22 @@ _HostType: TypeAlias = tuple[str, dict[str, str]] | str
 
 def escape(s: str) -> str: ...  # undocumented
 
-MAXINT: int  # undocumented
-MININT: int  # undocumented
+MAXINT: Final[int]  # undocumented
+MININT: Final[int]  # undocumented
 
-PARSE_ERROR: int  # undocumented
-SERVER_ERROR: int  # undocumented
-APPLICATION_ERROR: int  # undocumented
-SYSTEM_ERROR: int  # undocumented
-TRANSPORT_ERROR: int  # undocumented
+PARSE_ERROR: Final[int]  # undocumented
+SERVER_ERROR: Final[int]  # undocumented
+APPLICATION_ERROR: Final[int]  # undocumented
+SYSTEM_ERROR: Final[int]  # undocumented
+TRANSPORT_ERROR: Final[int]  # undocumented
 
-NOT_WELLFORMED_ERROR: int  # undocumented
-UNSUPPORTED_ENCODING: int  # undocumented
-INVALID_ENCODING_CHAR: int  # undocumented
-INVALID_XMLRPC: int  # undocumented
-METHOD_NOT_FOUND: int  # undocumented
-INVALID_METHOD_PARAMS: int  # undocumented
-INTERNAL_ERROR: int  # undocumented
+NOT_WELLFORMED_ERROR: Final[int]  # undocumented
+UNSUPPORTED_ENCODING: Final[int]  # undocumented
+INVALID_ENCODING_CHAR: Final[int]  # undocumented
+INVALID_XMLRPC: Final[int]  # undocumented
+METHOD_NOT_FOUND: Final[int]  # undocumented
+INVALID_METHOD_PARAMS: Final[int]  # undocumented
+INTERNAL_ERROR: Final[int]  # undocumented
 
 class Error(Exception): ...
 
@@ -77,6 +76,7 @@ def _strftime(value: _XMLDate) -> str: ...  # undocumented
 class DateTime:
     value: str  # undocumented
     def __init__(self, value: int | str | datetime | time.struct_time | tuple[int, ...] = 0) -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def __lt__(self, other: _DateTimeComparable) -> bool: ...
     def __le__(self, other: _DateTimeComparable) -> bool: ...
     def __gt__(self, other: _DateTimeComparable) -> bool: ...
@@ -96,10 +96,11 @@ class Binary:
     def decode(self, data: ReadableBuffer) -> None: ...
     def encode(self, out: SupportsWrite[str]) -> None: ...
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 def _binary(data: ReadableBuffer) -> Binary: ...  # undocumented
 
-WRAPPERS: tuple[type[DateTime], type[Binary]]  # undocumented
+WRAPPERS: Final[tuple[type[DateTime], type[Binary]]]  # undocumented
 
 class ExpatParser:  # undocumented
     def __init__(self, target: Unmarshaller) -> None: ...
@@ -109,8 +110,7 @@ class ExpatParser:  # undocumented
 _WriteCallback: TypeAlias = Callable[[str], object]
 
 class Marshaller:
-    # TODO: Replace 'Any' with some kind of binding
-    dispatch: dict[type[Any], Callable[[Marshaller, Any, _WriteCallback], None]]
+    dispatch: dict[type[_Marshallable] | Literal["_arbitrary_instance"], Callable[[Marshaller, Any, _WriteCallback], None]]
     memo: dict[Any, None]
     data: None
     encoding: str | None
@@ -201,7 +201,7 @@ def dumps(
     allow_none: bool = False,
 ) -> str: ...
 def loads(
-    data: str, use_datetime: bool = False, use_builtin_types: bool = False
+    data: str | ReadableBuffer, use_datetime: bool = False, use_builtin_types: bool = False
 ) -> tuple[tuple[_Marshallable, ...], str | None]: ...
 def gzip_encode(data: ReadableBuffer) -> bytes: ...  # undocumented
 def gzip_decode(data: ReadableBuffer, max_decode: int = 20971520) -> bytes: ...  # undocumented
@@ -228,13 +228,9 @@ class Transport:
     _headers: list[tuple[str, str]]
     _extra_headers: list[tuple[str, str]]
 
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self, use_datetime: bool = False, use_builtin_types: bool = False, *, headers: Iterable[tuple[str, str]] = ()
-        ) -> None: ...
-    else:
-        def __init__(self, use_datetime: bool = False, use_builtin_types: bool = False) -> None: ...
-
+    def __init__(
+        self, use_datetime: bool = False, use_builtin_types: bool = False, *, headers: Iterable[tuple[str, str]] = ()
+    ) -> None: ...
     def request(
         self, host: _HostType, handler: str, request_body: SizedBuffer, verbose: bool = False
     ) -> tuple[_Marshallable, ...]: ...
@@ -253,20 +249,14 @@ class Transport:
     def parse_response(self, response: http.client.HTTPResponse) -> tuple[_Marshallable, ...]: ...
 
 class SafeTransport(Transport):
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            use_datetime: bool = False,
-            use_builtin_types: bool = False,
-            *,
-            headers: Iterable[tuple[str, str]] = (),
-            context: Any | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self, use_datetime: bool = False, use_builtin_types: bool = False, *, context: Any | None = None
-        ) -> None: ...
-
+    def __init__(
+        self,
+        use_datetime: bool = False,
+        use_builtin_types: bool = False,
+        *,
+        headers: Iterable[tuple[str, str]] = (),
+        context: Any | None = None,
+    ) -> None: ...
     def make_connection(self, host: _HostType) -> http.client.HTTPSConnection: ...
 
 class ServerProxy:
@@ -277,34 +267,19 @@ class ServerProxy:
     __verbose: bool
     __allow_none: bool
 
-    if sys.version_info >= (3, 8):
-        def __init__(
-            self,
-            uri: str,
-            transport: Transport | None = None,
-            encoding: str | None = None,
-            verbose: bool = False,
-            allow_none: bool = False,
-            use_datetime: bool = False,
-            use_builtin_types: bool = False,
-            *,
-            headers: Iterable[tuple[str, str]] = (),
-            context: Any | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            uri: str,
-            transport: Transport | None = None,
-            encoding: str | None = None,
-            verbose: bool = False,
-            allow_none: bool = False,
-            use_datetime: bool = False,
-            use_builtin_types: bool = False,
-            *,
-            context: Any | None = None,
-        ) -> None: ...
-
+    def __init__(
+        self,
+        uri: str,
+        transport: Transport | None = None,
+        encoding: str | None = None,
+        verbose: bool = False,
+        allow_none: bool = False,
+        use_datetime: bool = False,
+        use_builtin_types: bool = False,
+        *,
+        headers: Iterable[tuple[str, str]] = (),
+        context: Any | None = None,
+    ) -> None: ...
     def __getattr__(self, name: str) -> _Method: ...
     @overload
     def __call__(self, attr: Literal["close"]) -> Callable[[], None]: ...
diff --git a/mypy/typeshed/stdlib/xmlrpc/server.pyi b/mypy/typeshed/stdlib/xmlrpc/server.pyi
index 832fe265e0a5..5f497aa7190e 100644
--- a/mypy/typeshed/stdlib/xmlrpc/server.pyi
+++ b/mypy/typeshed/stdlib/xmlrpc/server.pyi
@@ -1,6 +1,7 @@
 import http.server
 import pydoc
 import socketserver
+from _typeshed import ReadableBuffer
 from collections.abc import Callable, Iterable, Mapping
 from re import Pattern
 from typing import Any, ClassVar, Protocol
@@ -12,17 +13,17 @@ class _DispatchArity0(Protocol):
     def __call__(self) -> _Marshallable: ...
 
 class _DispatchArity1(Protocol):
-    def __call__(self, __arg1: _Marshallable) -> _Marshallable: ...
+    def __call__(self, arg1: _Marshallable, /) -> _Marshallable: ...
 
 class _DispatchArity2(Protocol):
-    def __call__(self, __arg1: _Marshallable, __arg2: _Marshallable) -> _Marshallable: ...
+    def __call__(self, arg1: _Marshallable, arg2: _Marshallable, /) -> _Marshallable: ...
 
 class _DispatchArity3(Protocol):
-    def __call__(self, __arg1: _Marshallable, __arg2: _Marshallable, __arg3: _Marshallable) -> _Marshallable: ...
+    def __call__(self, arg1: _Marshallable, arg2: _Marshallable, arg3: _Marshallable, /) -> _Marshallable: ...
 
 class _DispatchArity4(Protocol):
     def __call__(
-        self, __arg1: _Marshallable, __arg2: _Marshallable, __arg3: _Marshallable, __arg4: _Marshallable
+        self, arg1: _Marshallable, arg2: _Marshallable, arg3: _Marshallable, arg4: _Marshallable, /
     ) -> _Marshallable: ...
 
 class _DispatchArityN(Protocol):
@@ -48,8 +49,8 @@ class SimpleXMLRPCDispatcher:  # undocumented
     def register_multicall_functions(self) -> None: ...
     def _marshaled_dispatch(
         self,
-        data: str,
-        dispatch_method: Callable[[str | None, tuple[_Marshallable, ...]], Fault | tuple[_Marshallable, ...]] | None = None,
+        data: str | ReadableBuffer,
+        dispatch_method: Callable[[str, tuple[_Marshallable, ...]], Fault | tuple[_Marshallable, ...]] | None = None,
         path: Any | None = None,
     ) -> str: ...  # undocumented
     def system_listMethods(self) -> list[str]: ...  # undocumented
diff --git a/mypy/typeshed/stdlib/xxlimited.pyi b/mypy/typeshed/stdlib/xxlimited.pyi
index b2fb72ad2c0b..78a50b85f405 100644
--- a/mypy/typeshed/stdlib/xxlimited.pyi
+++ b/mypy/typeshed/stdlib/xxlimited.pyi
@@ -1,21 +1,24 @@
 import sys
-from typing import Any
-from typing_extensions import final
+from typing import Any, ClassVar, final
 
-class Str: ...
+class Str(str): ...
 
 @final
 class Xxo:
     def demo(self) -> None: ...
+    if sys.version_info >= (3, 11) and sys.platform != "win32":
+        x_exports: int
 
-def foo(__i: int, __j: int) -> Any: ...
+def foo(i: int, j: int, /) -> Any: ...
 def new() -> Xxo: ...
 
 if sys.version_info >= (3, 10):
-    class Error: ...
+    class Error(Exception): ...
 
 else:
-    class error: ...
-    class Null: ...
+    class error(Exception): ...
 
-    def roj(__b: Any) -> None: ...
+    class Null:
+        __hash__: ClassVar[None]  # type: ignore[assignment]
+
+    def roj(b: Any, /) -> None: ...
diff --git a/mypy/typeshed/stdlib/zipfile.pyi b/mypy/typeshed/stdlib/zipfile/__init__.pyi
similarity index 63%
rename from mypy/typeshed/stdlib/zipfile.pyi
rename to mypy/typeshed/stdlib/zipfile/__init__.pyi
index abda7a3b9625..91bc051df686 100644
--- a/mypy/typeshed/stdlib/zipfile.pyi
+++ b/mypy/typeshed/stdlib/zipfile/__init__.pyi
@@ -2,14 +2,16 @@ import io
 import sys
 from _typeshed import SizedBuffer, StrOrBytesPath, StrPath
 from collections.abc import Callable, Iterable, Iterator
+from io import TextIOWrapper
 from os import PathLike
 from types import TracebackType
-from typing import IO, Any, Protocol, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing import IO, Final, Literal, Protocol, overload
+from typing_extensions import Self, TypeAlias
 
 __all__ = [
     "BadZipFile",
     "BadZipfile",
+    "Path",
     "error",
     "ZIP_STORED",
     "ZIP_DEFLATED",
@@ -22,13 +24,13 @@ __all__ = [
     "LargeZipFile",
 ]
 
-if sys.version_info >= (3, 8):
-    __all__ += ["Path"]
+# TODO: use TypeAlias for these two when mypy bugs are fixed
+# https://github.com/python/mypy/issues/16581
+_DateTuple = tuple[int, int, int, int, int, int]  # noqa: Y026
+_ZipFileMode = Literal["r", "w", "x", "a"]  # noqa: Y026
 
-_DateTuple: TypeAlias = tuple[int, int, int, int, int, int]
 _ReadWriteMode: TypeAlias = Literal["r", "w"]
 _ReadWriteBinaryMode: TypeAlias = Literal["r", "w", "rb", "wb"]
-_ZipFileMode: TypeAlias = Literal["r", "w", "x", "a"]
 
 class BadZipFile(Exception): ...
 
@@ -38,16 +40,16 @@ error = BadZipfile
 class LargeZipFile(Exception): ...
 
 class _ZipStream(Protocol):
-    def read(self, __n: int) -> bytes: ...
+    def read(self, n: int, /) -> bytes: ...
     # The following methods are optional:
     # def seekable(self) -> bool: ...
     # def tell(self) -> int: ...
-    # def seek(self, __n: int) -> object: ...
+    # def seek(self, n: int, /) -> object: ...
 
 # Stream shape as required by _EndRecData() and _EndRecData64().
 class _SupportsReadSeekTell(Protocol):
-    def read(self, __n: int = ...) -> bytes: ...
-    def seek(self, __cookie: int, __whence: int) -> object: ...
+    def read(self, n: int = ..., /) -> bytes: ...
+    def seek(self, cookie: int, whence: int, /) -> object: ...
     def tell(self) -> int: ...
 
 class _ClosableZipStream(_ZipStream, Protocol):
@@ -90,7 +92,21 @@ class ZipExtFile(io.BufferedIOBase):
     def seek(self, offset: int, whence: int = 0) -> int: ...
 
 class _Writer(Protocol):
-    def write(self, __s: str) -> object: ...
+    def write(self, s: str, /) -> object: ...
+
+class _ZipReadable(Protocol):
+    def seek(self, offset: int, whence: int = 0, /) -> int: ...
+    def read(self, n: int = -1, /) -> bytes: ...
+
+class _ZipTellable(Protocol):
+    def tell(self) -> int: ...
+
+class _ZipReadableTellable(_ZipReadable, _ZipTellable, Protocol): ...
+
+class _ZipWritable(Protocol):
+    def flush(self) -> None: ...
+    def close(self) -> None: ...
+    def write(self, b: bytes, /) -> int: ...
 
 class ZipFile:
     filename: str | None
@@ -104,24 +120,38 @@ class ZipFile:
     compresslevel: int | None  # undocumented
     mode: _ZipFileMode  # undocumented
     pwd: bytes | None  # undocumented
+    # metadata_encoding is new in 3.11
     if sys.version_info >= (3, 11):
         @overload
         def __init__(
             self,
             file: StrPath | IO[bytes],
+            mode: _ZipFileMode = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+            metadata_encoding: str | None = None,
+        ) -> None: ...
+        # metadata_encoding is only allowed for read mode
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipReadable,
             mode: Literal["r"] = "r",
             compression: int = 0,
             allowZip64: bool = True,
             compresslevel: int | None = None,
             *,
             strict_timestamps: bool = True,
-            metadata_encoding: str | None,
+            metadata_encoding: str | None = None,
         ) -> None: ...
         @overload
         def __init__(
             self,
-            file: StrPath | IO[bytes],
-            mode: _ZipFileMode = "r",
+            file: StrPath | _ZipWritable,
+            mode: Literal["w", "x"] = ...,
             compression: int = 0,
             allowZip64: bool = True,
             compresslevel: int | None = None,
@@ -129,18 +159,20 @@ class ZipFile:
             strict_timestamps: bool = True,
             metadata_encoding: None = None,
         ) -> None: ...
-    elif sys.version_info >= (3, 8):
+        @overload
         def __init__(
             self,
-            file: StrPath | IO[bytes],
-            mode: _ZipFileMode = "r",
+            file: StrPath | _ZipReadableTellable,
+            mode: Literal["a"] = ...,
             compression: int = 0,
             allowZip64: bool = True,
             compresslevel: int | None = None,
             *,
             strict_timestamps: bool = True,
+            metadata_encoding: None = None,
         ) -> None: ...
     else:
+        @overload
         def __init__(
             self,
             file: StrPath | IO[bytes],
@@ -148,6 +180,41 @@ class ZipFile:
             compression: int = 0,
             allowZip64: bool = True,
             compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipReadable,
+            mode: Literal["r"] = "r",
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipWritable,
+            mode: Literal["w", "x"] = ...,
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            file: StrPath | _ZipReadableTellable,
+            mode: Literal["a"] = ...,
+            compression: int = 0,
+            allowZip64: bool = True,
+            compresslevel: int | None = None,
+            *,
+            strict_timestamps: bool = True,
         ) -> None: ...
 
     def __enter__(self) -> Self: ...
@@ -186,6 +253,8 @@ class ZipFile:
     if sys.version_info >= (3, 11):
         def mkdir(self, zinfo_or_directory_name: str | ZipInfo, mode: int = 0o777) -> None: ...
 
+    def __del__(self) -> None: ...
+
 class PyZipFile(ZipFile):
     def __init__(
         self, file: str | IO[bytes], mode: _ZipFileMode = "r", compression: int = 0, allowZip64: bool = True, optimize: int = -1
@@ -211,23 +280,32 @@ class ZipInfo:
     compress_size: int
     file_size: int
     orig_filename: str  # undocumented
-    def __init__(self, filename: str = "NoName", date_time: _DateTuple = (1980, 1, 1, 0, 0, 0)) -> None: ...
-    if sys.version_info >= (3, 8):
-        @classmethod
-        def from_file(cls, filename: StrPath, arcname: StrPath | None = None, *, strict_timestamps: bool = True) -> Self: ...
-    else:
-        @classmethod
-        def from_file(cls, filename: StrPath, arcname: StrPath | None = None) -> Self: ...
+    if sys.version_info >= (3, 13):
+        compress_level: int | None
 
+    def __init__(self, filename: str = "NoName", date_time: _DateTuple = (1980, 1, 1, 0, 0, 0)) -> None: ...
+    @classmethod
+    def from_file(cls, filename: StrPath, arcname: StrPath | None = None, *, strict_timestamps: bool = True) -> Self: ...
     def is_dir(self) -> bool: ...
     def FileHeader(self, zip64: bool | None = None) -> bytes: ...
 
-if sys.version_info >= (3, 8):
-    if sys.version_info < (3, 9):
-        class _PathOpenProtocol(Protocol):
-            def __call__(self, mode: _ReadWriteMode = "r", pwd: bytes | None = ..., *, force_zip64: bool = ...) -> IO[bytes]: ...
+if sys.version_info >= (3, 12):
+    from zipfile._path import CompleteDirs as CompleteDirs, Path as Path
+
+else:
+    class CompleteDirs(ZipFile):
+        def resolve_dir(self, name: str) -> str: ...
+        @overload
+        @classmethod
+        def make(cls, source: ZipFile) -> CompleteDirs: ...
+        @overload
+        @classmethod
+        def make(cls, source: StrPath | IO[bytes]) -> Self: ...
 
     class Path:
+        root: CompleteDirs
+        at: str
+        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
         @property
         def name(self) -> str: ...
         @property
@@ -243,21 +321,31 @@ if sys.version_info >= (3, 8):
             @property
             def stem(self) -> str: ...
 
-        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
         if sys.version_info >= (3, 9):
+            @overload
             def open(
                 self,
-                mode: _ReadWriteBinaryMode = "r",
+                mode: Literal["r", "w"] = "r",
                 encoding: str | None = None,
-                *args: Any,
+                errors: str | None = None,
+                newline: str | None = None,
+                line_buffering: bool = ...,
+                write_through: bool = ...,
+                *,
                 pwd: bytes | None = None,
-                **kwargs: Any,
+            ) -> TextIOWrapper: ...
+            @overload
+            def open(self, mode: Literal["rb", "wb"], *, pwd: bytes | None = None) -> IO[bytes]: ...
+        else:
+            def open(
+                self, mode: _ReadWriteBinaryMode = "r", pwd: bytes | None = None, *, force_zip64: bool = False
             ) -> IO[bytes]: ...
+
+        if sys.version_info >= (3, 10):
+            def iterdir(self) -> Iterator[Self]: ...
         else:
-            @property
-            def open(self) -> _PathOpenProtocol: ...
+            def iterdir(self) -> Iterator[Path]: ...
 
-        def iterdir(self) -> Iterator[Path]: ...
         def is_dir(self) -> bool: ...
         def is_file(self) -> bool: ...
         def exists(self) -> bool: ...
@@ -279,10 +367,10 @@ if sys.version_info >= (3, 8):
 
 def is_zipfile(filename: StrOrBytesPath | _SupportsReadSeekTell) -> bool: ...
 
-ZIP_STORED: int
-ZIP_DEFLATED: int
-ZIP64_LIMIT: int
-ZIP_FILECOUNT_LIMIT: int
-ZIP_MAX_COMMENT: int
-ZIP_BZIP2: int
-ZIP_LZMA: int
+ZIP_STORED: Final[int]
+ZIP_DEFLATED: Final[int]
+ZIP64_LIMIT: Final[int]
+ZIP_FILECOUNT_LIMIT: Final[int]
+ZIP_MAX_COMMENT: Final[int]
+ZIP_BZIP2: Final[int]
+ZIP_LZMA: Final[int]
diff --git a/mypy/typeshed/stdlib/zipfile/_path/__init__.pyi b/mypy/typeshed/stdlib/zipfile/_path/__init__.pyi
new file mode 100644
index 000000000000..4c7b39ec4c6c
--- /dev/null
+++ b/mypy/typeshed/stdlib/zipfile/_path/__init__.pyi
@@ -0,0 +1,83 @@
+import sys
+from _typeshed import StrPath
+from collections.abc import Iterator, Sequence
+from io import TextIOWrapper
+from os import PathLike
+from typing import IO, Literal, TypeVar, overload
+from typing_extensions import Self
+from zipfile import ZipFile
+
+_ZF = TypeVar("_ZF", bound=ZipFile)
+
+if sys.version_info >= (3, 12):
+    __all__ = ["Path"]
+
+    class InitializedState:
+        def __init__(self, *args: object, **kwargs: object) -> None: ...
+        def __getstate__(self) -> tuple[list[object], dict[object, object]]: ...
+        def __setstate__(self, state: Sequence[tuple[list[object], dict[object, object]]]) -> None: ...
+
+    class CompleteDirs(InitializedState, ZipFile):
+        def resolve_dir(self, name: str) -> str: ...
+        @overload
+        @classmethod
+        def make(cls, source: ZipFile) -> CompleteDirs: ...
+        @overload
+        @classmethod
+        def make(cls, source: StrPath | IO[bytes]) -> Self: ...
+        if sys.version_info >= (3, 13):
+            @classmethod
+            def inject(cls, zf: _ZF) -> _ZF: ...
+
+    class Path:
+        root: CompleteDirs
+        at: str
+        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
+        @property
+        def name(self) -> str: ...
+        @property
+        def parent(self) -> PathLike[str]: ...  # undocumented
+        @property
+        def filename(self) -> PathLike[str]: ...  # undocumented
+        @property
+        def suffix(self) -> str: ...
+        @property
+        def suffixes(self) -> list[str]: ...
+        @property
+        def stem(self) -> str: ...
+        @overload
+        def open(
+            self,
+            mode: Literal["r", "w"] = "r",
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+            line_buffering: bool = ...,
+            write_through: bool = ...,
+            *,
+            pwd: bytes | None = None,
+        ) -> TextIOWrapper: ...
+        @overload
+        def open(self, mode: Literal["rb", "wb"], *, pwd: bytes | None = None) -> IO[bytes]: ...
+        def iterdir(self) -> Iterator[Self]: ...
+        def is_dir(self) -> bool: ...
+        def is_file(self) -> bool: ...
+        def exists(self) -> bool: ...
+        def read_text(
+            self,
+            encoding: str | None = ...,
+            errors: str | None = ...,
+            newline: str | None = ...,
+            line_buffering: bool = ...,
+            write_through: bool = ...,
+        ) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        def joinpath(self, *other: StrPath) -> Path: ...
+        def glob(self, pattern: str) -> Iterator[Self]: ...
+        def rglob(self, pattern: str) -> Iterator[Self]: ...
+        def is_symlink(self) -> Literal[False]: ...
+        def relative_to(self, other: Path, *extra: StrPath) -> str: ...
+        def match(self, path_pattern: str) -> bool: ...
+        def __eq__(self, other: object) -> bool: ...
+        def __hash__(self) -> int: ...
+        def __truediv__(self, add: StrPath) -> Path: ...
diff --git a/mypy/typeshed/stdlib/zipfile/_path/glob.pyi b/mypy/typeshed/stdlib/zipfile/_path/glob.pyi
new file mode 100644
index 000000000000..f25ae71725c0
--- /dev/null
+++ b/mypy/typeshed/stdlib/zipfile/_path/glob.pyi
@@ -0,0 +1,22 @@
+import sys
+from collections.abc import Iterator
+from re import Match
+
+if sys.version_info >= (3, 13):
+    class Translator:
+        def __init__(self, seps: str = ...) -> None: ...
+        def translate(self, pattern: str) -> str: ...
+        def extend(self, pattern: str) -> str: ...
+        def match_dirs(self, pattern: str) -> str: ...
+        def translate_core(self, pattern: str) -> str: ...
+        def replace(self, match: Match[str]) -> str: ...
+        def restrict_rglob(self, pattern: str) -> None: ...
+        def star_not_empty(self, pattern: str) -> str: ...
+
+else:
+    def translate(pattern: str) -> str: ...
+    def match_dirs(pattern: str) -> str: ...
+    def translate_core(pattern: str) -> str: ...
+    def replace(match: Match[str]) -> str: ...
+
+def separate(pattern: str) -> Iterator[Match[str]]: ...
diff --git a/mypy/typeshed/stdlib/zipimport.pyi b/mypy/typeshed/stdlib/zipimport.pyi
index ee97faace379..3e94c681b7a2 100644
--- a/mypy/typeshed/stdlib/zipimport.pyi
+++ b/mypy/typeshed/stdlib/zipimport.pyi
@@ -3,13 +3,18 @@ from _typeshed import StrOrBytesPath
 from importlib.abc import ResourceReader
 from importlib.machinery import ModuleSpec
 from types import CodeType, ModuleType
+from typing_extensions import deprecated
 
-if sys.version_info >= (3, 8):
-    __all__ = ["ZipImportError", "zipimporter"]
+if sys.version_info >= (3, 10):
+    from _frozen_importlib_external import _LoaderBasics
+else:
+    _LoaderBasics = object
+
+__all__ = ["ZipImportError", "zipimporter"]
 
 class ZipImportError(ImportError): ...
 
-class zipimporter:
+class zipimporter(_LoaderBasics):
     archive: str
     prefix: str
     if sys.version_info >= (3, 11):
@@ -17,15 +22,20 @@ 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: ...
     def get_resource_reader(self, fullname: str) -> ResourceReader | None: ...  # undocumented
     def get_source(self, fullname: str) -> str | None: ...
     def is_package(self, fullname: str) -> bool: ...
+    @deprecated("Deprecated since 3.10; use exec_module() instead")
     def load_module(self, fullname: str) -> ModuleType: ...
     if sys.version_info >= (3, 10):
+        def exec_module(self, module: ModuleType) -> None: ...
+        def create_module(self, spec: ModuleSpec) -> None: ...
         def find_spec(self, fullname: str, target: ModuleType | None = None) -> ModuleSpec | None: ...
         def invalidate_caches(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/zlib.pyi b/mypy/typeshed/stdlib/zlib.pyi
index c3419af0de3f..7cafb44b34a7 100644
--- a/mypy/typeshed/stdlib/zlib.pyi
+++ b/mypy/typeshed/stdlib/zlib.pyi
@@ -1,56 +1,70 @@
 import sys
 from _typeshed import ReadableBuffer
-from typing_extensions import Literal
+from typing import Any, Final, final, type_check_only
+from typing_extensions import Self
 
-DEFLATED: Literal[8]
+DEFLATED: Final = 8
 DEF_MEM_LEVEL: int  # can change
-DEF_BUF_SIZE: Literal[16384]
+DEF_BUF_SIZE: Final = 16384
 MAX_WBITS: int
 ZLIB_VERSION: str  # can change
 ZLIB_RUNTIME_VERSION: str  # can change
-Z_NO_COMPRESSION: Literal[0]
-Z_PARTIAL_FLUSH: Literal[1]
-Z_BEST_COMPRESSION: Literal[9]
-Z_BEST_SPEED: Literal[1]
-Z_BLOCK: Literal[5]
-Z_DEFAULT_COMPRESSION: Literal[-1]
-Z_DEFAULT_STRATEGY: Literal[0]
-Z_FILTERED: Literal[1]
-Z_FINISH: Literal[4]
-Z_FIXED: Literal[4]
-Z_FULL_FLUSH: Literal[3]
-Z_HUFFMAN_ONLY: Literal[2]
-Z_NO_FLUSH: Literal[0]
-Z_RLE: Literal[3]
-Z_SYNC_FLUSH: Literal[2]
-Z_TREES: Literal[6]
+Z_NO_COMPRESSION: Final = 0
+Z_PARTIAL_FLUSH: Final = 1
+Z_BEST_COMPRESSION: Final = 9
+Z_BEST_SPEED: Final = 1
+Z_BLOCK: Final = 5
+Z_DEFAULT_COMPRESSION: Final = -1
+Z_DEFAULT_STRATEGY: Final = 0
+Z_FILTERED: Final = 1
+Z_FINISH: Final = 4
+Z_FIXED: Final = 4
+Z_FULL_FLUSH: Final = 3
+Z_HUFFMAN_ONLY: Final = 2
+Z_NO_FLUSH: Final = 0
+Z_RLE: Final = 3
+Z_SYNC_FLUSH: Final = 2
+Z_TREES: Final = 6
 
 class error(Exception): ...
 
+# This class is not exposed at runtime. It calls itself zlib.Compress.
+@final
+@type_check_only
 class _Compress:
-    def compress(self, data: ReadableBuffer) -> bytes: ...
-    def flush(self, mode: int = ...) -> bytes: ...
+    def __copy__(self) -> Self: ...
+    def __deepcopy__(self, memo: Any, /) -> Self: ...
+    def compress(self, data: ReadableBuffer, /) -> bytes: ...
+    def flush(self, mode: int = 4, /) -> bytes: ...
     def copy(self) -> _Compress: ...
 
+# This class is not exposed at runtime. It calls itself zlib.Decompress.
+@final
+@type_check_only
 class _Decompress:
-    unused_data: bytes
-    unconsumed_tail: bytes
-    eof: bool
-    def decompress(self, data: ReadableBuffer, max_length: int = ...) -> bytes: ...
-    def flush(self, length: int = ...) -> bytes: ...
+    @property
+    def unused_data(self) -> bytes: ...
+    @property
+    def unconsumed_tail(self) -> bytes: ...
+    @property
+    def eof(self) -> bool: ...
+    def __copy__(self) -> Self: ...
+    def __deepcopy__(self, memo: Any, /) -> Self: ...
+    def decompress(self, data: ReadableBuffer, /, max_length: int = 0) -> bytes: ...
+    def flush(self, length: int = 16384, /) -> bytes: ...
     def copy(self) -> _Decompress: ...
 
-def adler32(__data: ReadableBuffer, __value: int = 1) -> int: ...
+def adler32(data: ReadableBuffer, value: int = 1, /) -> int: ...
 
 if sys.version_info >= (3, 11):
-    def compress(__data: ReadableBuffer, level: int = -1, wbits: int = 15) -> bytes: ...
+    def compress(data: ReadableBuffer, /, level: int = -1, wbits: int = 15) -> bytes: ...
 
 else:
-    def compress(__data: ReadableBuffer, level: int = -1) -> bytes: ...
+    def compress(data: ReadableBuffer, /, level: int = -1) -> bytes: ...
 
 def compressobj(
     level: int = -1, method: int = 8, wbits: int = 15, memLevel: int = 8, strategy: int = 0, zdict: ReadableBuffer | None = None
 ) -> _Compress: ...
-def crc32(__data: ReadableBuffer, __value: int = 0) -> int: ...
-def decompress(__data: ReadableBuffer, wbits: int = 15, bufsize: int = 16384) -> bytes: ...
+def crc32(data: ReadableBuffer, value: int = 0, /) -> int: ...
+def decompress(data: ReadableBuffer, /, wbits: int = 15, bufsize: int = 16384) -> bytes: ...
 def decompressobj(wbits: int = 15, zdict: ReadableBuffer = b"") -> _Decompress: ...
diff --git a/mypy/typeshed/stdlib/zoneinfo/__init__.pyi b/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
index fe994be3e8ff..fb21b00c45dc 100644
--- a/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
+++ b/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
@@ -1,38 +1,35 @@
-from _typeshed import StrPath
-from collections.abc import Iterable, Sequence
+import sys
+from collections.abc import Iterable
 from datetime import datetime, timedelta, tzinfo
-from typing import Any, Protocol
 from typing_extensions import Self
 
-__all__ = ["ZoneInfo", "reset_tzpath", "available_timezones", "TZPATH", "ZoneInfoNotFoundError", "InvalidTZPathWarning"]
+# TODO: remove this version check
+# In theory we shouldn't need this version check. Pyright complains about the imports
+# from zoneinfo.* when run on 3.8 and 3.7 without this. Updates to typeshed's
+# pyright test script are probably needed, see #11189
+if sys.version_info >= (3, 9):
+    from zoneinfo._common import ZoneInfoNotFoundError as ZoneInfoNotFoundError, _IOBytes
+    from zoneinfo._tzpath import (
+        TZPATH as TZPATH,
+        InvalidTZPathWarning as InvalidTZPathWarning,
+        available_timezones as available_timezones,
+        reset_tzpath as reset_tzpath,
+    )
 
-class _IOBytes(Protocol):
-    def read(self, __size: int) -> bytes: ...
-    def seek(self, __size: int, __whence: int = ...) -> Any: ...
+    __all__ = ["ZoneInfo", "reset_tzpath", "available_timezones", "TZPATH", "ZoneInfoNotFoundError", "InvalidTZPathWarning"]
 
-class ZoneInfo(tzinfo):
-    @property
-    def key(self) -> str: ...
-    def __init__(self, key: str) -> None: ...
-    @classmethod
-    def no_cache(cls, key: str) -> Self: ...
-    @classmethod
-    def from_file(cls, __fobj: _IOBytes, key: str | None = ...) -> Self: ...
-    @classmethod
-    def clear_cache(cls, *, only_keys: Iterable[str] | 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: ...
+    class ZoneInfo(tzinfo):
+        @property
+        def key(self) -> str: ...
+        def __new__(cls, key: str) -> Self: ...
+        @classmethod
+        def no_cache(cls, key: str) -> Self: ...
+        @classmethod
+        def from_file(cls, fobj: _IOBytes, /, key: str | None = None) -> Self: ...
+        @classmethod
+        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: ...
 
-# Note: Both here and in clear_cache, the types allow the use of `str` where
-# a sequence of strings is required. This should be remedied if a solution
-# to this typing bug is found: https://github.com/python/typing/issues/256
-def reset_tzpath(to: Sequence[StrPath] | None = None) -> None: ...
-def available_timezones() -> set[str]: ...
-
-TZPATH: Sequence[str]
-
-class ZoneInfoNotFoundError(KeyError): ...
-class InvalidTZPathWarning(RuntimeWarning): ...
-
-def __dir__() -> list[str]: ...
+    def __dir__() -> list[str]: ...
diff --git a/mypy/typeshed/stdlib/zoneinfo/_common.pyi b/mypy/typeshed/stdlib/zoneinfo/_common.pyi
new file mode 100644
index 000000000000..a2f29f2d14f0
--- /dev/null
+++ b/mypy/typeshed/stdlib/zoneinfo/_common.pyi
@@ -0,0 +1,13 @@
+import io
+from typing import Any, Protocol
+
+class _IOBytes(Protocol):
+    def read(self, size: int, /) -> bytes: ...
+    def seek(self, size: int, whence: int = ..., /) -> Any: ...
+
+def load_tzdata(key: str) -> io.BufferedReader: ...
+def load_data(
+    fobj: _IOBytes,
+) -> tuple[tuple[int, ...], tuple[int, ...], tuple[int, ...], tuple[int, ...], tuple[str, ...], bytes | None]: ...
+
+class ZoneInfoNotFoundError(KeyError): ...
diff --git a/mypy/typeshed/stdlib/zoneinfo/_tzpath.pyi b/mypy/typeshed/stdlib/zoneinfo/_tzpath.pyi
new file mode 100644
index 000000000000..0ef78d03e5f4
--- /dev/null
+++ b/mypy/typeshed/stdlib/zoneinfo/_tzpath.pyi
@@ -0,0 +1,13 @@
+from _typeshed import StrPath
+from collections.abc import Sequence
+
+# Note: Both here and in clear_cache, the types allow the use of `str` where
+# a sequence of strings is required. This should be remedied if a solution
+# to this typing bug is found: https://github.com/python/typing/issues/256
+def reset_tzpath(to: Sequence[StrPath] | None = None) -> None: ...
+def find_tzfile(key: str) -> str | None: ...
+def available_timezones() -> set[str]: ...
+
+TZPATH: tuple[str, ...]
+
+class InvalidTZPathWarning(RuntimeWarning): ...
diff --git a/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi b/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
index 40e24645fb77..b6358a0022f3 100644
--- a/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
+++ b/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
@@ -146,3 +146,73 @@ 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: ...
+
+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/mypy/typestate.py b/mypy/typestate.py
index 9f65481e5e94..574618668477 100644
--- a/mypy/typestate.py
+++ b/mypy/typestate.py
@@ -5,26 +5,26 @@
 
 from __future__ import annotations
 
-from typing import Dict, Set, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Final
+from typing_extensions import TypeAlias as _TypeAlias
 
-from mypy.nodes import TypeInfo
+from mypy.nodes import VARIANCE_NOT_READY, TypeInfo
 from mypy.server.trigger import make_trigger
-from mypy.types import Instance, Type, TypeVarId, get_proper_type
+from mypy.types import Instance, Type, TypeVarId, TypeVarType, get_proper_type
 
 MAX_NEGATIVE_CACHE_TYPES: Final = 1000
 MAX_NEGATIVE_CACHE_ENTRIES: Final = 10000
 
 # Represents that the 'left' instance is a subtype of the 'right' instance
-SubtypeRelationship: _TypeAlias = Tuple[Instance, Instance]
+SubtypeRelationship: _TypeAlias = tuple[Instance, Instance]
 
 # A tuple encoding the specific conditions under which we performed the subtype check.
 # (e.g. did we want a proper subtype? A regular subtype while ignoring variance?)
-SubtypeKind: _TypeAlias = Tuple[bool, ...]
+SubtypeKind: _TypeAlias = tuple[bool, ...]
 
 # A cache that keeps track of whether the given TypeInfo is a part of a particular
 # subtype relationship
-SubtypeCache: _TypeAlias = Dict[TypeInfo, Dict[SubtypeKind, Set[SubtypeRelationship]]]
+SubtypeCache: _TypeAlias = dict[TypeInfo, dict[SubtypeKind, set[SubtypeRelationship]]]
 
 
 class TypeState:
@@ -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):
@@ -188,7 +192,13 @@ def record_subtype_cache_entry(
             # These are unlikely to match, due to the large space of
             # possible values.  Avoid uselessly increasing cache sizes.
             return
-        cache = self._subtype_caches.setdefault(right.type, dict())
+        if any(
+            (isinstance(tv, TypeVarType) and tv.variance == VARIANCE_NOT_READY)
+            for tv in right.type.defn.type_vars
+        ):
+            # Variance indeterminate -- don't know the result
+            return
+        cache = self._subtype_caches.setdefault(right.type, {})
         cache.setdefault(kind, set()).add((left, right))
 
     def record_negative_subtype_cache_entry(
@@ -200,7 +210,7 @@ def record_negative_subtype_cache_entry(
             return
         if len(self._negative_subtype_caches) > MAX_NEGATIVE_CACHE_TYPES:
             self._negative_subtype_caches.clear()
-        cache = self._negative_subtype_caches.setdefault(right.type, dict())
+        cache = self._negative_subtype_caches.setdefault(right.type, {})
         subcache = cache.setdefault(kind, set())
         if len(subcache) > MAX_NEGATIVE_CACHE_ENTRIES:
             subcache.clear()
@@ -311,7 +321,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/mypy/typetraverser.py b/mypy/typetraverser.py
index d9ab54871f4a..cc6d4b637d2e 100644
--- a/mypy/typetraverser.py
+++ b/mypy/typetraverser.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable
+from collections.abc import Iterable
 
 from mypy_extensions import trait
 
@@ -42,101 +42,107 @@ class TypeTraverserVisitor(SyntheticTypeVisitor[None]):
 
     # Atomic types
 
-    def visit_any(self, t: AnyType) -> None:
+    def visit_any(self, t: AnyType, /) -> None:
         pass
 
-    def visit_uninhabited_type(self, t: UninhabitedType) -> None:
+    def visit_uninhabited_type(self, t: UninhabitedType, /) -> None:
         pass
 
-    def visit_none_type(self, t: NoneType) -> None:
+    def visit_none_type(self, t: NoneType, /) -> None:
         pass
 
-    def visit_erased_type(self, t: ErasedType) -> None:
+    def visit_erased_type(self, t: ErasedType, /) -> None:
         pass
 
-    def visit_deleted_type(self, t: DeletedType) -> None:
+    def visit_deleted_type(self, t: DeletedType, /) -> None:
         pass
 
-    def visit_type_var(self, t: TypeVarType) -> None:
+    def visit_type_var(self, t: TypeVarType, /) -> None:
         # Note that type variable values and upper bound aren't treated as
         # components, since they are components of the type variable
         # definition. We want to traverse everything just once.
-        pass
+        t.default.accept(self)
 
-    def visit_param_spec(self, t: ParamSpecType) -> None:
-        pass
+    def visit_param_spec(self, t: ParamSpecType, /) -> None:
+        t.default.accept(self)
 
-    def visit_parameters(self, t: Parameters) -> None:
+    def visit_parameters(self, t: Parameters, /) -> None:
         self.traverse_types(t.arg_types)
 
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
-        pass
+    def visit_type_var_tuple(self, t: TypeVarTupleType, /) -> None:
+        t.default.accept(self)
 
-    def visit_literal_type(self, t: LiteralType) -> None:
+    def visit_literal_type(self, t: LiteralType, /) -> None:
         t.fallback.accept(self)
 
     # Composite types
 
-    def visit_instance(self, t: Instance) -> None:
+    def visit_instance(self, t: Instance, /) -> None:
         self.traverse_types(t.args)
 
-    def visit_callable_type(self, t: CallableType) -> None:
+    def visit_callable_type(self, t: CallableType, /) -> None:
         # FIX generics
         self.traverse_types(t.arg_types)
         t.ret_type.accept(self)
         t.fallback.accept(self)
 
-    def visit_tuple_type(self, t: TupleType) -> None:
+        if t.type_guard is not None:
+            t.type_guard.accept(self)
+
+        if t.type_is is not None:
+            t.type_is.accept(self)
+
+    def visit_tuple_type(self, t: TupleType, /) -> None:
         self.traverse_types(t.items)
         t.partial_fallback.accept(self)
 
-    def visit_typeddict_type(self, t: TypedDictType) -> None:
+    def visit_typeddict_type(self, t: TypedDictType, /) -> None:
         self.traverse_types(t.items.values())
         t.fallback.accept(self)
 
-    def visit_union_type(self, t: UnionType) -> None:
+    def visit_union_type(self, t: UnionType, /) -> None:
         self.traverse_types(t.items)
 
-    def visit_overloaded(self, t: Overloaded) -> None:
+    def visit_overloaded(self, t: Overloaded, /) -> None:
         self.traverse_types(t.items)
 
-    def visit_type_type(self, t: TypeType) -> None:
+    def visit_type_type(self, t: TypeType, /) -> None:
         t.item.accept(self)
 
     # Special types (not real types)
 
-    def visit_callable_argument(self, t: CallableArgument) -> None:
+    def visit_callable_argument(self, t: CallableArgument, /) -> None:
         t.typ.accept(self)
 
-    def visit_unbound_type(self, t: UnboundType) -> None:
+    def visit_unbound_type(self, t: UnboundType, /) -> None:
         self.traverse_types(t.args)
 
-    def visit_type_list(self, t: TypeList) -> None:
+    def visit_type_list(self, t: TypeList, /) -> None:
         self.traverse_types(t.items)
 
-    def visit_ellipsis_type(self, t: EllipsisType) -> None:
+    def visit_ellipsis_type(self, t: EllipsisType, /) -> None:
         pass
 
-    def visit_placeholder_type(self, t: PlaceholderType) -> None:
+    def visit_placeholder_type(self, t: PlaceholderType, /) -> None:
         self.traverse_types(t.args)
 
-    def visit_partial_type(self, t: PartialType) -> None:
+    def visit_partial_type(self, t: PartialType, /) -> None:
         pass
 
-    def visit_raw_expression_type(self, t: RawExpressionType) -> None:
+    def visit_raw_expression_type(self, t: RawExpressionType, /) -> None:
         pass
 
-    def visit_type_alias_type(self, t: TypeAliasType) -> None:
+    def visit_type_alias_type(self, t: TypeAliasType, /) -> None:
         # TODO: sometimes we want to traverse target as well
         # We need to find a way to indicate explicitly the intent,
         # maybe make this method abstract (like for TypeTranslator)?
         self.traverse_types(t.args)
 
-    def visit_unpack_type(self, t: UnpackType) -> None:
+    def visit_unpack_type(self, t: UnpackType, /) -> None:
         t.type.accept(self)
 
     # Helpers
 
-    def traverse_types(self, types: Iterable[Type]) -> None:
+    def traverse_types(self, types: Iterable[Type], /) -> None:
         for typ in types:
             typ.accept(self)
diff --git a/mypy/typevars.py b/mypy/typevars.py
index 027a8e3f7fc5..e871973104a2 100644
--- a/mypy/typevars.py
+++ b/mypy/typevars.py
@@ -3,9 +3,9 @@
 from mypy.erasetype import erase_typevars
 from mypy.nodes import TypeInfo
 from mypy.types import (
-    AnyType,
     Instance,
     ParamSpecType,
+    ProperType,
     TupleType,
     Type,
     TypeOfAny,
@@ -14,6 +14,7 @@
     TypeVarType,
     UnpackType,
 )
+from mypy.typevartuples import erased_vars
 
 
 def fill_typevars(typ: TypeInfo) -> Instance | TupleType:
@@ -55,6 +56,7 @@ def fill_typevars(typ: TypeInfo) -> Instance | TupleType:
             )
         tvs.append(tv)
     inst = Instance(typ, tvs)
+    # TODO: do we need to also handle typeddict_type here and below?
     if typ.tuple_type is None:
         return inst
     return typ.tuple_type.copy_modified(fallback=inst)
@@ -62,10 +64,14 @@ def fill_typevars(typ: TypeInfo) -> Instance | TupleType:
 
 def fill_typevars_with_any(typ: TypeInfo) -> Instance | TupleType:
     """Apply a correct number of Any's as type arguments to a type."""
-    inst = Instance(typ, [AnyType(TypeOfAny.special_form)] * len(typ.defn.type_vars))
+    inst = Instance(typ, erased_vars(typ.defn.type_vars, TypeOfAny.special_form))
     if typ.tuple_type is None:
         return inst
-    return typ.tuple_type.copy_modified(fallback=inst)
+    erased_tuple_type = erase_typevars(typ.tuple_type, {tv.id for tv in typ.defn.type_vars})
+    assert isinstance(erased_tuple_type, ProperType)
+    if isinstance(erased_tuple_type, TupleType):
+        return typ.tuple_type.copy_modified(fallback=inst)
+    return inst
 
 
 def has_no_typevars(typ: Type) -> bool:
diff --git a/mypy/typevartuples.py b/mypy/typevartuples.py
index ac5f4e43c3bf..1bf1a59f7d3f 100644
--- a/mypy/typevartuples.py
+++ b/mypy/typevartuples.py
@@ -2,34 +2,19 @@
 
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
-from mypy.nodes import ARG_POS, ARG_STAR
 from mypy.types import (
-    CallableType,
+    AnyType,
     Instance,
-    ProperType,
     Type,
+    TypeVarLikeType,
+    TypeVarTupleType,
     UnpackType,
-    get_proper_type,
     split_with_prefix_and_suffix,
 )
 
 
-def find_unpack_in_list(items: Sequence[Type]) -> int | None:
-    unpack_index: int | None = None
-    for i, item in enumerate(items):
-        if isinstance(item, UnpackType):
-            # We cannot fail here, so we must check this in an earlier
-            # semanal phase.
-            # Funky code here avoids mypyc narrowing the type of unpack_index.
-            old_index = unpack_index
-            assert old_index is None
-            # Don't return so that we can also sanity check there is only one.
-            unpack_index = i
-    return unpack_index
-
-
 def split_with_instance(
     typ: Instance,
 ) -> tuple[tuple[Type, ...], tuple[Type, ...], tuple[Type, ...]]:
@@ -40,159 +25,12 @@ def split_with_instance(
     )
 
 
-def split_with_mapped_and_template(
-    mapped: tuple[Type, ...],
-    mapped_prefix_len: int | None,
-    mapped_suffix_len: int | None,
-    template: tuple[Type, ...],
-    template_prefix_len: int,
-    template_suffix_len: int,
-) -> (
-    tuple[
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-    ]
-    | None
-):
-    split_result = fully_split_with_mapped_and_template(
-        mapped,
-        mapped_prefix_len,
-        mapped_suffix_len,
-        template,
-        template_prefix_len,
-        template_suffix_len,
-    )
-    if split_result is None:
-        return None
-
-    (
-        mapped_prefix,
-        mapped_middle_prefix,
-        mapped_middle_middle,
-        mapped_middle_suffix,
-        mapped_suffix,
-        template_prefix,
-        template_middle_prefix,
-        template_middle_middle,
-        template_middle_suffix,
-        template_suffix,
-    ) = split_result
-
-    return (
-        mapped_prefix + mapped_middle_prefix,
-        mapped_middle_middle,
-        mapped_middle_suffix + mapped_suffix,
-        template_prefix + template_middle_prefix,
-        template_middle_middle,
-        template_middle_suffix + template_suffix,
-    )
-
-
-def fully_split_with_mapped_and_template(
-    mapped: tuple[Type, ...],
-    mapped_prefix_len: int | None,
-    mapped_suffix_len: int | None,
-    template: tuple[Type, ...],
-    template_prefix_len: int,
-    template_suffix_len: int,
-) -> (
-    tuple[
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-        tuple[Type, ...],
-    ]
-    | None
-):
-    if mapped_prefix_len is not None:
-        assert mapped_suffix_len is not None
-        mapped_prefix, mapped_middle, mapped_suffix = split_with_prefix_and_suffix(
-            tuple(mapped), mapped_prefix_len, mapped_suffix_len
-        )
-    else:
-        mapped_prefix = tuple()
-        mapped_suffix = tuple()
-        mapped_middle = mapped
-
-    template_prefix, template_middle, template_suffix = split_with_prefix_and_suffix(
-        tuple(template), template_prefix_len, template_suffix_len
-    )
-
-    unpack_prefix = find_unpack_in_list(template_middle)
-    if unpack_prefix is None:
-        return (
-            mapped_prefix,
-            (),
-            mapped_middle,
-            (),
-            mapped_suffix,
-            template_prefix,
-            (),
-            template_middle,
-            (),
-            template_suffix,
-        )
-
-    unpack_suffix = len(template_middle) - unpack_prefix - 1
-    # mapped_middle is too short to do the unpack
-    if unpack_prefix + unpack_suffix > len(mapped_middle):
-        return None
-
-    (
-        mapped_middle_prefix,
-        mapped_middle_middle,
-        mapped_middle_suffix,
-    ) = split_with_prefix_and_suffix(mapped_middle, unpack_prefix, unpack_suffix)
-    (
-        template_middle_prefix,
-        template_middle_middle,
-        template_middle_suffix,
-    ) = split_with_prefix_and_suffix(template_middle, unpack_prefix, unpack_suffix)
-
-    return (
-        mapped_prefix,
-        mapped_middle_prefix,
-        mapped_middle_middle,
-        mapped_middle_suffix,
-        mapped_suffix,
-        template_prefix,
-        template_middle_prefix,
-        template_middle_middle,
-        template_middle_suffix,
-        template_suffix,
-    )
-
-
-def extract_unpack(types: Sequence[Type]) -> ProperType | None:
-    """Given a list of types, extracts either a single type from an unpack, or returns None."""
-    if len(types) == 1:
-        if isinstance(types[0], UnpackType):
-            return get_proper_type(types[0].type)
-    return None
-
-
-def replace_starargs(callable: CallableType, types: list[Type]) -> CallableType:
-    star_index = callable.arg_kinds.index(ARG_STAR)
-    arg_kinds = (
-        callable.arg_kinds[:star_index]
-        + [ARG_POS] * len(types)
-        + callable.arg_kinds[star_index + 1 :]
-    )
-    arg_names = (
-        callable.arg_names[:star_index]
-        + [None] * len(types)
-        + callable.arg_names[star_index + 1 :]
-    )
-    arg_types = callable.arg_types[:star_index] + types + callable.arg_types[star_index + 1 :]
-
-    return callable.copy_modified(arg_types=arg_types, arg_names=arg_names, arg_kinds=arg_kinds)
+def erased_vars(type_vars: Sequence[TypeVarLikeType], type_of_any: int) -> list[Type]:
+    args: list[Type] = []
+    for tv in type_vars:
+        # Valid erasure for *Ts is *tuple[Any, ...], not just Any.
+        if isinstance(tv, TypeVarTupleType):
+            args.append(UnpackType(tv.tuple_fallback.copy_modified(args=[AnyType(type_of_any)])))
+        else:
+            args.append(AnyType(type_of_any))
+    return args
diff --git a/mypy/util.py b/mypy/util.py
index 2c225c7fe651..d3f49f74bbae 100644
--- a/mypy/util.py
+++ b/mypy/util.py
@@ -4,20 +4,25 @@
 
 import hashlib
 import io
+import json
 import os
-import pathlib
 import re
 import shutil
 import sys
 import time
+from collections.abc import Container, Iterable, Sequence, Sized
 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, Any, Callable, Final, Literal, TypeVar
 
+orjson: Any
 try:
-    import curses
+    import orjson  # type: ignore[import-not-found, no-redef, unused-ignore]
+except ImportError:
+    orjson = None
 
+try:
     import _curses  # noqa: F401
+    import curses
 
     CURSES_ENABLED = True
 except ImportError:
@@ -25,15 +30,7 @@
 
 T = TypeVar("T")
 
-if sys.version_info >= (3, 9):
-    TYPESHED_DIR: Final = str(importlib_resources.files("mypy") / "typeshed")
-else:
-    with importlib_resources.path(
-        "mypy",  # mypy-c doesn't support __package__
-        "py.typed",  # a marker file for type information, we assume typeshed to live in the same dir
-    ) as _resource:
-        TYPESHED_DIR = str(_resource.parent / "typeshed")
-
+TYPESHED_DIR: Final = str(importlib_resources.files("mypy") / "typeshed")
 
 ENCODING_RE: Final = re.compile(rb"([ \t\v]*#.*(\r\n?|\n))??[ \t\v]*#.*coding[:=][ \t]*([-\w.]+)")
 
@@ -196,7 +193,7 @@ def trim_source_line(line: str, max_len: int, col: int, min_width: int) -> tuple
     A typical result looks like this:
         ...some_variable = function_to_call(one_arg, other_arg) or...
 
-    Return the trimmed string and the column offset to to adjust error location.
+    Return the trimmed string and the column offset to adjust error location.
     """
     if max_len < 2 * min_width + 1:
         # In case the window is too tiny it is better to still show something.
@@ -234,50 +231,91 @@ def get_mypy_comments(source: str) -> list[tuple[int, str]]:
     return results
 
 
-PASS_TEMPLATE: Final = """<?xml version="1.0" encoding="utf-8"?>
-<testsuite errors="0" failures="0" name="mypy" skips="0" tests="1" time="{time:.3f}">
-  <testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
-  </testcase>
-</testsuite>
+JUNIT_HEADER_TEMPLATE: Final = """<?xml version="1.0" encoding="utf-8"?>
+<testsuite errors="{errors}" failures="{failures}" name="mypy" skips="0" tests="{tests}" time="{time:.3f}">
 """
 
-FAIL_TEMPLATE: Final = """<?xml version="1.0" encoding="utf-8"?>
-<testsuite errors="0" failures="1" name="mypy" skips="0" tests="1" time="{time:.3f}">
-  <testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
+JUNIT_TESTCASE_FAIL_TEMPLATE: Final = """  <testcase classname="mypy" file="{filename}" line="1" name="{name}" time="{time:.3f}">
     <failure message="mypy produced messages">{text}</failure>
   </testcase>
-</testsuite>
 """
 
-ERROR_TEMPLATE: Final = """<?xml version="1.0" encoding="utf-8"?>
-<testsuite errors="1" failures="0" name="mypy" skips="0" tests="1" time="{time:.3f}">
-  <testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
+JUNIT_ERROR_TEMPLATE: Final = """  <testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
     <error message="mypy produced errors">{text}</error>
   </testcase>
-</testsuite>
 """
 
+JUNIT_TESTCASE_PASS_TEMPLATE: Final = """  <testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
+  </testcase>
+"""
 
-def write_junit_xml(
-    dt: float, serious: bool, messages: list[str], path: str, version: str, platform: str
-) -> None:
+JUNIT_FOOTER: Final = """</testsuite>
+"""
+
+
+def _generate_junit_contents(
+    dt: float,
+    serious: bool,
+    messages_by_file: dict[str | None, list[str]],
+    version: str,
+    platform: str,
+) -> str:
     from xml.sax.saxutils import escape
 
-    if not messages and not serious:
-        xml = PASS_TEMPLATE.format(time=dt, ver=version, platform=platform)
-    elif not serious:
-        xml = FAIL_TEMPLATE.format(
-            text=escape("\n".join(messages)), time=dt, ver=version, platform=platform
-        )
+    if serious:
+        failures = 0
+        errors = len(messages_by_file)
     else:
-        xml = ERROR_TEMPLATE.format(
-            text=escape("\n".join(messages)), time=dt, ver=version, platform=platform
-        )
+        failures = len(messages_by_file)
+        errors = 0
+
+    xml = JUNIT_HEADER_TEMPLATE.format(
+        errors=errors,
+        failures=failures,
+        time=dt,
+        # If there are no messages, we still write one "test" indicating success.
+        tests=len(messages_by_file) or 1,
+    )
 
-    # checks for a directory structure in path and creates folders if needed
+    if not messages_by_file:
+        xml += JUNIT_TESTCASE_PASS_TEMPLATE.format(time=dt, ver=version, platform=platform)
+    else:
+        for filename, messages in messages_by_file.items():
+            if filename is not None:
+                xml += JUNIT_TESTCASE_FAIL_TEMPLATE.format(
+                    text=escape("\n".join(messages)),
+                    filename=filename,
+                    time=dt,
+                    name="mypy-py{ver}-{platform} {filename}".format(
+                        ver=version, platform=platform, filename=filename
+                    ),
+                )
+            else:
+                xml += JUNIT_TESTCASE_FAIL_TEMPLATE.format(
+                    text=escape("\n".join(messages)),
+                    filename="mypy",
+                    time=dt,
+                    name=f"mypy-py{version}-{platform}",
+                )
+
+    xml += JUNIT_FOOTER
+
+    return xml
+
+
+def write_junit_xml(
+    dt: float,
+    serious: bool,
+    messages_by_file: dict[str | None, list[str]],
+    path: str,
+    version: str,
+    platform: str,
+) -> None:
+    xml = _generate_junit_contents(dt, serious, messages_by_file, version, platform)
+
+    # creates folders if needed
     xml_dirs = os.path.dirname(os.path.abspath(path))
-    if not os.path.isdir(xml_dirs):
-        os.makedirs(xml_dirs)
+    os.makedirs(xml_dirs, exist_ok=True)
 
     with open(path, "wb") as f:
         f.write(xml.encode("utf-8"))
@@ -308,17 +346,6 @@ def get_prefix(fullname: str) -> str:
     return fullname.rsplit(".", 1)[0]
 
 
-def get_top_two_prefixes(fullname: str) -> tuple[str, str]:
-    """Return one and two component prefixes of a fully qualified name.
-
-    Given 'a.b.c.d', return ('a', 'a.b').
-
-    If fullname has only one component, return (fullname, fullname).
-    """
-    components = fullname.split(".", 3)
-    return components[0], ".".join(components[:2])
-
-
 def correct_relative_import(
     cur_mod_id: str, relative: int, target: str, is_cur_package_init_file: bool
 ) -> tuple[str, bool]:
@@ -382,9 +409,43 @@ def replace_object_state(
             pass
 
 
-def is_sub_path(path1: str, path2: str) -> bool:
-    """Given two paths, return if path1 is a sub-path of path2."""
-    return pathlib.Path(path2) in pathlib.Path(path1).parents
+def is_sub_path_normabs(path: str, dir: str) -> bool:
+    """Given two paths, return if path is a sub-path of dir.
+
+    Moral equivalent of: Path(dir) in Path(path).parents
+
+    Similar to the pathlib version:
+    - Treats paths case-sensitively
+    - Does not fully handle unnormalised paths (e.g. paths with "..")
+    - Does not handle a mix of absolute and relative paths
+    Unlike the pathlib version:
+    - Fast
+    - On Windows, assumes input has been slash normalised
+    - Handles even fewer unnormalised paths (e.g. paths with "." and "//")
+
+    As a result, callers should ensure that inputs have had os.path.abspath called on them
+    (note that os.path.abspath will normalise)
+    """
+    if not dir.endswith(os.sep):
+        dir += os.sep
+    return path.startswith(dir)
+
+
+if sys.platform == "linux" or sys.platform == "darwin":
+
+    def os_path_join(path: str, b: str) -> str:
+        # Based off of os.path.join, but simplified to str-only, 2 args and mypyc can compile it.
+        if b.startswith("/") or not path:
+            return b
+        elif path.endswith("/"):
+            return path + b
+        else:
+            return path + "/" + b
+
+else:
+
+    def os_path_join(a: str, p: str) -> str:
+        return os.path.join(a, p)
 
 
 def hard_exit(status: int = 0) -> None:
@@ -421,10 +482,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, 9):  # noqa: UP036, RUF100
         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.8 or lower is not supported; "
+            "please upgrade to 3.9 or newer".format(name=program)
         )
 
 
@@ -505,15 +566,12 @@ def hash_digest(data: bytes) -> str:
     accidental collision, but we don't really care about any of the
     cryptographic properties.
     """
-    # Once we drop Python 3.5 support, we should consider using
-    # blake2b, which is faster.
-    return hashlib.sha256(data).hexdigest()
+    return hashlib.sha1(data).hexdigest()
 
 
 def parse_gray_color(cup: bytes) -> str:
     """Reproduce a gray color in ANSI escape sequence"""
-    if sys.platform == "win32":
-        assert False, "curses is not available on Windows"
+    assert sys.platform != "win32", "curses is not available on Windows"
     set_color = "".join([cup[:-1].decode(), "m"])
     gray = curses.tparm(set_color.encode("utf-8"), 1, 9).decode()
     return gray
@@ -533,8 +591,12 @@ class FancyFormatter:
     This currently only works on Linux and Mac.
     """
 
-    def __init__(self, f_out: IO[str], f_err: IO[str], hide_error_codes: bool) -> None:
+    def __init__(
+        self, f_out: IO[str], f_err: IO[str], hide_error_codes: bool, hide_success: bool = False
+    ) -> None:
         self.hide_error_codes = hide_error_codes
+        self.hide_success = hide_success
+
         # Check if we are in a human-facing terminal on a supported platform.
         if sys.platform not in ("linux", "darwin", "win32", "emscripten"):
             self.dummy_term = True
@@ -576,8 +638,7 @@ def initialize_win_colors(self) -> bool:
         # Windows ANSI escape sequences are only supported on Threshold 2 and above.
         # we check with an assert at runtime and an if check for mypy, as asserts do not
         # yet narrow platform
-        assert sys.platform == "win32"
-        if sys.platform == "win32":
+        if sys.platform == "win32":  # needed to find win specific sys apis
             winver = sys.getwindowsversion()
             if (
                 winver.major < MINIMUM_WINDOWS_MAJOR_VT100
@@ -599,11 +660,12 @@ def initialize_win_colors(self) -> bool:
             )
             self.initialize_vt100_colors()
             return True
-        return False
+        assert False, "Running not on Windows"
 
     def initialize_unix_colors(self) -> bool:
         """Return True if initialization was successful and we can use colors, False otherwise"""
-        if sys.platform == "win32" or not CURSES_ENABLED:
+        is_win = sys.platform == "win32"
+        if is_win or not CURSES_ENABLED:
             return False
         try:
             # setupterm wants a fd to potentially write an "initialization sequence".
@@ -763,6 +825,9 @@ def format_success(self, n_sources: int, use_color: bool = True) -> str:
         n_sources is total number of files passed directly on command line,
         i.e. excluding stubs and followed imports.
         """
+        if self.hide_success:
+            return ""
+
         msg = f"Success: no issues found in {n_sources} source file{plural_s(n_sources)}"
         if not use_color:
             return msg
@@ -796,6 +861,18 @@ def is_typeshed_file(typeshed_dir: str | None, file: str) -> bool:
         return False
 
 
+def is_stdlib_file(typeshed_dir: str | None, file: str) -> bool:
+    if "stdlib" not in file:
+        # Fast path
+        return False
+    typeshed_dir = typeshed_dir if typeshed_dir is not None else TYPESHED_DIR
+    stdlib_dir = os.path.join(typeshed_dir, "stdlib")
+    try:
+        return os.path.commonpath((stdlib_dir, os.path.abspath(file))) == stdlib_dir
+    except ValueError:  # Different drives on Windows
+        return False
+
+
 def is_stub_package_file(file: str) -> bool:
     # Use hacky heuristics to check whether file is part of a PEP 561 stub package.
     if not file.endswith(".pyi"):
@@ -820,3 +897,48 @@ def plural_s(s: int | Sized) -> str:
         return "s"
     else:
         return ""
+
+
+def quote_docstring(docstr: str) -> str:
+    """Returns docstring correctly encapsulated in a single or double quoted form."""
+    # Uses repr to get hint on the correct quotes and escape everything properly.
+    # Creating multiline string for prettier output.
+    docstr_repr = "\n".join(re.split(r"(?<=[^\\])\\n", repr(docstr)))
+
+    if docstr_repr.startswith("'"):
+        # Enforce double quotes when it's safe to do so.
+        # That is when double quotes are not in the string
+        # or when it doesn't end with a single quote.
+        if '"' not in docstr_repr[1:-1] and docstr_repr[-2] != "'":
+            return f'"""{docstr_repr[1:-1]}"""'
+        return f"''{docstr_repr}''"
+    else:
+        return f'""{docstr_repr}""'
+
+
+def json_dumps(obj: object, debug: bool = False) -> bytes:
+    if orjson is not None:
+        if debug:
+            dumps_option = orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS
+        else:
+            # TODO: If we don't sort keys here, testIncrementalInternalScramble fails
+            # We should document exactly what is going on there
+            dumps_option = orjson.OPT_SORT_KEYS
+
+        try:
+            return orjson.dumps(obj, option=dumps_option)  # type: ignore[no-any-return]
+        except TypeError as e:
+            if str(e) != "Integer exceeds 64-bit range":
+                raise
+
+    if debug:
+        return json.dumps(obj, indent=2, sort_keys=True).encode("utf-8")
+    else:
+        # See above for sort_keys comment
+        return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode("utf-8")
+
+
+def json_loads(data: bytes) -> Any:
+    if orjson is not None:
+        return orjson.loads(data)
+    return json.loads(data)
diff --git a/mypy/version.py b/mypy/version.py
index 826ba0020100..34fb2f642c5e 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.16.0"
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
diff --git a/mypy/visitor.py b/mypy/visitor.py
index c5aa3caa8295..d1b2ca416410 100644
--- a/mypy/visitor.py
+++ b/mypy/visitor.py
@@ -20,179 +20,179 @@
 @mypyc_attr(allow_interpreted_subclasses=True)
 class ExpressionVisitor(Generic[T]):
     @abstractmethod
-    def visit_int_expr(self, o: mypy.nodes.IntExpr) -> T:
+    def visit_int_expr(self, o: mypy.nodes.IntExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_str_expr(self, o: mypy.nodes.StrExpr) -> T:
+    def visit_str_expr(self, o: mypy.nodes.StrExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_bytes_expr(self, o: mypy.nodes.BytesExpr) -> T:
+    def visit_bytes_expr(self, o: mypy.nodes.BytesExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_float_expr(self, o: mypy.nodes.FloatExpr) -> T:
+    def visit_float_expr(self, o: mypy.nodes.FloatExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_complex_expr(self, o: mypy.nodes.ComplexExpr) -> T:
+    def visit_complex_expr(self, o: mypy.nodes.ComplexExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_ellipsis(self, o: mypy.nodes.EllipsisExpr) -> T:
+    def visit_ellipsis(self, o: mypy.nodes.EllipsisExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_star_expr(self, o: mypy.nodes.StarExpr) -> T:
+    def visit_star_expr(self, o: mypy.nodes.StarExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_name_expr(self, o: mypy.nodes.NameExpr) -> T:
+    def visit_name_expr(self, o: mypy.nodes.NameExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_member_expr(self, o: mypy.nodes.MemberExpr) -> T:
+    def visit_member_expr(self, o: mypy.nodes.MemberExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_yield_from_expr(self, o: mypy.nodes.YieldFromExpr) -> T:
+    def visit_yield_from_expr(self, o: mypy.nodes.YieldFromExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_yield_expr(self, o: mypy.nodes.YieldExpr) -> T:
+    def visit_yield_expr(self, o: mypy.nodes.YieldExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_call_expr(self, o: mypy.nodes.CallExpr) -> T:
+    def visit_call_expr(self, o: mypy.nodes.CallExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_op_expr(self, o: mypy.nodes.OpExpr) -> T:
+    def visit_op_expr(self, o: mypy.nodes.OpExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_comparison_expr(self, o: mypy.nodes.ComparisonExpr) -> T:
+    def visit_comparison_expr(self, o: mypy.nodes.ComparisonExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_cast_expr(self, o: mypy.nodes.CastExpr) -> T:
+    def visit_cast_expr(self, o: mypy.nodes.CastExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_assert_type_expr(self, o: mypy.nodes.AssertTypeExpr) -> T:
+    def visit_assert_type_expr(self, o: mypy.nodes.AssertTypeExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_reveal_expr(self, o: mypy.nodes.RevealExpr) -> T:
+    def visit_reveal_expr(self, o: mypy.nodes.RevealExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_super_expr(self, o: mypy.nodes.SuperExpr) -> T:
+    def visit_super_expr(self, o: mypy.nodes.SuperExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_unary_expr(self, o: mypy.nodes.UnaryExpr) -> T:
+    def visit_unary_expr(self, o: mypy.nodes.UnaryExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_assignment_expr(self, o: mypy.nodes.AssignmentExpr) -> T:
+    def visit_assignment_expr(self, o: mypy.nodes.AssignmentExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_list_expr(self, o: mypy.nodes.ListExpr) -> T:
+    def visit_list_expr(self, o: mypy.nodes.ListExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_dict_expr(self, o: mypy.nodes.DictExpr) -> T:
+    def visit_dict_expr(self, o: mypy.nodes.DictExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_tuple_expr(self, o: mypy.nodes.TupleExpr) -> T:
+    def visit_tuple_expr(self, o: mypy.nodes.TupleExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_set_expr(self, o: mypy.nodes.SetExpr) -> T:
+    def visit_set_expr(self, o: mypy.nodes.SetExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_index_expr(self, o: mypy.nodes.IndexExpr) -> T:
+    def visit_index_expr(self, o: mypy.nodes.IndexExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_application(self, o: mypy.nodes.TypeApplication) -> T:
+    def visit_type_application(self, o: mypy.nodes.TypeApplication, /) -> T:
         pass
 
     @abstractmethod
-    def visit_lambda_expr(self, o: mypy.nodes.LambdaExpr) -> T:
+    def visit_lambda_expr(self, o: mypy.nodes.LambdaExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_list_comprehension(self, o: mypy.nodes.ListComprehension) -> T:
+    def visit_list_comprehension(self, o: mypy.nodes.ListComprehension, /) -> T:
         pass
 
     @abstractmethod
-    def visit_set_comprehension(self, o: mypy.nodes.SetComprehension) -> T:
+    def visit_set_comprehension(self, o: mypy.nodes.SetComprehension, /) -> T:
         pass
 
     @abstractmethod
-    def visit_dictionary_comprehension(self, o: mypy.nodes.DictionaryComprehension) -> T:
+    def visit_dictionary_comprehension(self, o: mypy.nodes.DictionaryComprehension, /) -> T:
         pass
 
     @abstractmethod
-    def visit_generator_expr(self, o: mypy.nodes.GeneratorExpr) -> T:
+    def visit_generator_expr(self, o: mypy.nodes.GeneratorExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_slice_expr(self, o: mypy.nodes.SliceExpr) -> T:
+    def visit_slice_expr(self, o: mypy.nodes.SliceExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_conditional_expr(self, o: mypy.nodes.ConditionalExpr) -> T:
+    def visit_conditional_expr(self, o: mypy.nodes.ConditionalExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_var_expr(self, o: mypy.nodes.TypeVarExpr) -> T:
+    def visit_type_var_expr(self, o: mypy.nodes.TypeVarExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_paramspec_expr(self, o: mypy.nodes.ParamSpecExpr) -> T:
+    def visit_paramspec_expr(self, o: mypy.nodes.ParamSpecExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_var_tuple_expr(self, o: mypy.nodes.TypeVarTupleExpr) -> T:
+    def visit_type_var_tuple_expr(self, o: mypy.nodes.TypeVarTupleExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_type_alias_expr(self, o: mypy.nodes.TypeAliasExpr) -> T:
+    def visit_type_alias_expr(self, o: mypy.nodes.TypeAliasExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_namedtuple_expr(self, o: mypy.nodes.NamedTupleExpr) -> T:
+    def visit_namedtuple_expr(self, o: mypy.nodes.NamedTupleExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_enum_call_expr(self, o: mypy.nodes.EnumCallExpr) -> T:
+    def visit_enum_call_expr(self, o: mypy.nodes.EnumCallExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_typeddict_expr(self, o: mypy.nodes.TypedDictExpr) -> T:
+    def visit_typeddict_expr(self, o: mypy.nodes.TypedDictExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_newtype_expr(self, o: mypy.nodes.NewTypeExpr) -> T:
+    def visit_newtype_expr(self, o: mypy.nodes.NewTypeExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit__promote_expr(self, o: mypy.nodes.PromoteExpr) -> T:
+    def visit__promote_expr(self, o: mypy.nodes.PromoteExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_await_expr(self, o: mypy.nodes.AwaitExpr) -> T:
+    def visit_await_expr(self, o: mypy.nodes.AwaitExpr, /) -> T:
         pass
 
     @abstractmethod
-    def visit_temp_node(self, o: mypy.nodes.TempNode) -> T:
+    def visit_temp_node(self, o: mypy.nodes.TempNode, /) -> T:
         pass
 
 
@@ -202,111 +202,115 @@ class StatementVisitor(Generic[T]):
     # Definitions
 
     @abstractmethod
-    def visit_assignment_stmt(self, o: mypy.nodes.AssignmentStmt) -> T:
+    def visit_assignment_stmt(self, o: mypy.nodes.AssignmentStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_for_stmt(self, o: mypy.nodes.ForStmt) -> T:
+    def visit_for_stmt(self, o: mypy.nodes.ForStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_with_stmt(self, o: mypy.nodes.WithStmt) -> T:
+    def visit_with_stmt(self, o: mypy.nodes.WithStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_del_stmt(self, o: mypy.nodes.DelStmt) -> T:
+    def visit_del_stmt(self, o: mypy.nodes.DelStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_func_def(self, o: mypy.nodes.FuncDef) -> T:
+    def visit_func_def(self, o: mypy.nodes.FuncDef, /) -> T:
         pass
 
     @abstractmethod
-    def visit_overloaded_func_def(self, o: mypy.nodes.OverloadedFuncDef) -> T:
+    def visit_overloaded_func_def(self, o: mypy.nodes.OverloadedFuncDef, /) -> T:
         pass
 
     @abstractmethod
-    def visit_class_def(self, o: mypy.nodes.ClassDef) -> T:
+    def visit_class_def(self, o: mypy.nodes.ClassDef, /) -> T:
         pass
 
     @abstractmethod
-    def visit_global_decl(self, o: mypy.nodes.GlobalDecl) -> T:
+    def visit_global_decl(self, o: mypy.nodes.GlobalDecl, /) -> T:
         pass
 
     @abstractmethod
-    def visit_nonlocal_decl(self, o: mypy.nodes.NonlocalDecl) -> T:
+    def visit_nonlocal_decl(self, o: mypy.nodes.NonlocalDecl, /) -> T:
         pass
 
     @abstractmethod
-    def visit_decorator(self, o: mypy.nodes.Decorator) -> T:
+    def visit_decorator(self, o: mypy.nodes.Decorator, /) -> T:
         pass
 
     # Module structure
 
     @abstractmethod
-    def visit_import(self, o: mypy.nodes.Import) -> T:
+    def visit_import(self, o: mypy.nodes.Import, /) -> T:
         pass
 
     @abstractmethod
-    def visit_import_from(self, o: mypy.nodes.ImportFrom) -> T:
+    def visit_import_from(self, o: mypy.nodes.ImportFrom, /) -> T:
         pass
 
     @abstractmethod
-    def visit_import_all(self, o: mypy.nodes.ImportAll) -> T:
+    def visit_import_all(self, o: mypy.nodes.ImportAll, /) -> T:
         pass
 
     # Statements
 
     @abstractmethod
-    def visit_block(self, o: mypy.nodes.Block) -> T:
+    def visit_block(self, o: mypy.nodes.Block, /) -> T:
         pass
 
     @abstractmethod
-    def visit_expression_stmt(self, o: mypy.nodes.ExpressionStmt) -> T:
+    def visit_expression_stmt(self, o: mypy.nodes.ExpressionStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_operator_assignment_stmt(self, o: mypy.nodes.OperatorAssignmentStmt) -> T:
+    def visit_operator_assignment_stmt(self, o: mypy.nodes.OperatorAssignmentStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_while_stmt(self, o: mypy.nodes.WhileStmt) -> T:
+    def visit_while_stmt(self, o: mypy.nodes.WhileStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_return_stmt(self, o: mypy.nodes.ReturnStmt) -> T:
+    def visit_return_stmt(self, o: mypy.nodes.ReturnStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_assert_stmt(self, o: mypy.nodes.AssertStmt) -> T:
+    def visit_assert_stmt(self, o: mypy.nodes.AssertStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_if_stmt(self, o: mypy.nodes.IfStmt) -> T:
+    def visit_if_stmt(self, o: mypy.nodes.IfStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_break_stmt(self, o: mypy.nodes.BreakStmt) -> T:
+    def visit_break_stmt(self, o: mypy.nodes.BreakStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_continue_stmt(self, o: mypy.nodes.ContinueStmt) -> T:
+    def visit_continue_stmt(self, o: mypy.nodes.ContinueStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_pass_stmt(self, o: mypy.nodes.PassStmt) -> T:
+    def visit_pass_stmt(self, o: mypy.nodes.PassStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_raise_stmt(self, o: mypy.nodes.RaiseStmt) -> T:
+    def visit_raise_stmt(self, o: mypy.nodes.RaiseStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_try_stmt(self, o: mypy.nodes.TryStmt) -> T:
+    def visit_try_stmt(self, o: mypy.nodes.TryStmt, /) -> T:
         pass
 
     @abstractmethod
-    def visit_match_stmt(self, o: mypy.nodes.MatchStmt) -> T:
+    def visit_match_stmt(self, o: mypy.nodes.MatchStmt, /) -> T:
+        pass
+
+    @abstractmethod
+    def visit_type_alias_stmt(self, o: mypy.nodes.TypeAliasStmt, /) -> T:
         pass
 
 
@@ -314,35 +318,35 @@ def visit_match_stmt(self, o: mypy.nodes.MatchStmt) -> T:
 @mypyc_attr(allow_interpreted_subclasses=True)
 class PatternVisitor(Generic[T]):
     @abstractmethod
-    def visit_as_pattern(self, o: mypy.patterns.AsPattern) -> T:
+    def visit_as_pattern(self, o: mypy.patterns.AsPattern, /) -> T:
         pass
 
     @abstractmethod
-    def visit_or_pattern(self, o: mypy.patterns.OrPattern) -> T:
+    def visit_or_pattern(self, o: mypy.patterns.OrPattern, /) -> T:
         pass
 
     @abstractmethod
-    def visit_value_pattern(self, o: mypy.patterns.ValuePattern) -> T:
+    def visit_value_pattern(self, o: mypy.patterns.ValuePattern, /) -> T:
         pass
 
     @abstractmethod
-    def visit_singleton_pattern(self, o: mypy.patterns.SingletonPattern) -> T:
+    def visit_singleton_pattern(self, o: mypy.patterns.SingletonPattern, /) -> T:
         pass
 
     @abstractmethod
-    def visit_sequence_pattern(self, o: mypy.patterns.SequencePattern) -> T:
+    def visit_sequence_pattern(self, o: mypy.patterns.SequencePattern, /) -> T:
         pass
 
     @abstractmethod
-    def visit_starred_pattern(self, o: mypy.patterns.StarredPattern) -> T:
+    def visit_starred_pattern(self, o: mypy.patterns.StarredPattern, /) -> T:
         pass
 
     @abstractmethod
-    def visit_mapping_pattern(self, o: mypy.patterns.MappingPattern) -> T:
+    def visit_mapping_pattern(self, o: mypy.patterns.MappingPattern, /) -> T:
         pass
 
     @abstractmethod
-    def visit_class_pattern(self, o: mypy.patterns.ClassPattern) -> T:
+    def visit_class_pattern(self, o: mypy.patterns.ClassPattern, /) -> T:
         pass
 
 
@@ -352,270 +356,270 @@ class NodeVisitor(Generic[T], ExpressionVisitor[T], StatementVisitor[T], Pattern
     """Empty base class for parse tree node visitors.
 
     The T type argument specifies the return type of the visit
-    methods. As all methods defined here return None by default,
+    methods. As all methods defined here raise by default,
     subclasses do not always need to override all the methods.
-
-    TODO: make the default return value explicit, then turn on
-          empty body checking in mypy_self_check.ini.
     """
 
     # Not in superclasses:
 
-    def visit_mypy_file(self, o: mypy.nodes.MypyFile) -> T:
-        pass
+    def visit_mypy_file(self, o: mypy.nodes.MypyFile, /) -> T:
+        raise NotImplementedError()
 
     # TODO: We have a visit_var method, but no visit_typeinfo or any
     # other non-Statement SymbolNode (accepting those will raise a
     # runtime error). Maybe this should be resolved in some direction.
-    def visit_var(self, o: mypy.nodes.Var) -> T:
-        pass
+    def visit_var(self, o: mypy.nodes.Var, /) -> T:
+        raise NotImplementedError()
 
     # Module structure
 
-    def visit_import(self, o: mypy.nodes.Import) -> T:
-        pass
+    def visit_import(self, o: mypy.nodes.Import, /) -> T:
+        raise NotImplementedError()
 
-    def visit_import_from(self, o: mypy.nodes.ImportFrom) -> T:
-        pass
+    def visit_import_from(self, o: mypy.nodes.ImportFrom, /) -> T:
+        raise NotImplementedError()
 
-    def visit_import_all(self, o: mypy.nodes.ImportAll) -> T:
-        pass
+    def visit_import_all(self, o: mypy.nodes.ImportAll, /) -> T:
+        raise NotImplementedError()
 
     # Definitions
 
-    def visit_func_def(self, o: mypy.nodes.FuncDef) -> T:
-        pass
+    def visit_func_def(self, o: mypy.nodes.FuncDef, /) -> T:
+        raise NotImplementedError()
 
-    def visit_overloaded_func_def(self, o: mypy.nodes.OverloadedFuncDef) -> T:
-        pass
+    def visit_overloaded_func_def(self, o: mypy.nodes.OverloadedFuncDef, /) -> T:
+        raise NotImplementedError()
 
-    def visit_class_def(self, o: mypy.nodes.ClassDef) -> T:
-        pass
+    def visit_class_def(self, o: mypy.nodes.ClassDef, /) -> T:
+        raise NotImplementedError()
 
-    def visit_global_decl(self, o: mypy.nodes.GlobalDecl) -> T:
-        pass
+    def visit_global_decl(self, o: mypy.nodes.GlobalDecl, /) -> T:
+        raise NotImplementedError()
 
-    def visit_nonlocal_decl(self, o: mypy.nodes.NonlocalDecl) -> T:
-        pass
+    def visit_nonlocal_decl(self, o: mypy.nodes.NonlocalDecl, /) -> T:
+        raise NotImplementedError()
 
-    def visit_decorator(self, o: mypy.nodes.Decorator) -> T:
-        pass
+    def visit_decorator(self, o: mypy.nodes.Decorator, /) -> T:
+        raise NotImplementedError()
 
-    def visit_type_alias(self, o: mypy.nodes.TypeAlias) -> T:
-        pass
+    def visit_type_alias(self, o: mypy.nodes.TypeAlias, /) -> T:
+        raise NotImplementedError()
 
-    def visit_placeholder_node(self, o: mypy.nodes.PlaceholderNode) -> T:
-        pass
+    def visit_placeholder_node(self, o: mypy.nodes.PlaceholderNode, /) -> T:
+        raise NotImplementedError()
 
     # Statements
 
-    def visit_block(self, o: mypy.nodes.Block) -> T:
-        pass
+    def visit_block(self, o: mypy.nodes.Block, /) -> T:
+        raise NotImplementedError()
 
-    def visit_expression_stmt(self, o: mypy.nodes.ExpressionStmt) -> T:
-        pass
+    def visit_expression_stmt(self, o: mypy.nodes.ExpressionStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_assignment_stmt(self, o: mypy.nodes.AssignmentStmt) -> T:
-        pass
+    def visit_assignment_stmt(self, o: mypy.nodes.AssignmentStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_operator_assignment_stmt(self, o: mypy.nodes.OperatorAssignmentStmt) -> T:
-        pass
+    def visit_operator_assignment_stmt(self, o: mypy.nodes.OperatorAssignmentStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_while_stmt(self, o: mypy.nodes.WhileStmt) -> T:
-        pass
+    def visit_while_stmt(self, o: mypy.nodes.WhileStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_for_stmt(self, o: mypy.nodes.ForStmt) -> T:
-        pass
+    def visit_for_stmt(self, o: mypy.nodes.ForStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_return_stmt(self, o: mypy.nodes.ReturnStmt) -> T:
-        pass
+    def visit_return_stmt(self, o: mypy.nodes.ReturnStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_assert_stmt(self, o: mypy.nodes.AssertStmt) -> T:
-        pass
+    def visit_assert_stmt(self, o: mypy.nodes.AssertStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_del_stmt(self, o: mypy.nodes.DelStmt) -> T:
-        pass
+    def visit_del_stmt(self, o: mypy.nodes.DelStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_if_stmt(self, o: mypy.nodes.IfStmt) -> T:
-        pass
+    def visit_if_stmt(self, o: mypy.nodes.IfStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_break_stmt(self, o: mypy.nodes.BreakStmt) -> T:
-        pass
+    def visit_break_stmt(self, o: mypy.nodes.BreakStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_continue_stmt(self, o: mypy.nodes.ContinueStmt) -> T:
-        pass
+    def visit_continue_stmt(self, o: mypy.nodes.ContinueStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_pass_stmt(self, o: mypy.nodes.PassStmt) -> T:
-        pass
+    def visit_pass_stmt(self, o: mypy.nodes.PassStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_raise_stmt(self, o: mypy.nodes.RaiseStmt) -> T:
-        pass
+    def visit_raise_stmt(self, o: mypy.nodes.RaiseStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_try_stmt(self, o: mypy.nodes.TryStmt) -> T:
-        pass
+    def visit_try_stmt(self, o: mypy.nodes.TryStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_with_stmt(self, o: mypy.nodes.WithStmt) -> T:
-        pass
+    def visit_with_stmt(self, o: mypy.nodes.WithStmt, /) -> T:
+        raise NotImplementedError()
 
-    def visit_match_stmt(self, o: mypy.nodes.MatchStmt) -> T:
-        pass
+    def visit_match_stmt(self, o: mypy.nodes.MatchStmt, /) -> T:
+        raise NotImplementedError()
+
+    def visit_type_alias_stmt(self, o: mypy.nodes.TypeAliasStmt, /) -> T:
+        raise NotImplementedError()
 
     # Expressions (default no-op implementation)
 
-    def visit_int_expr(self, o: mypy.nodes.IntExpr) -> T:
-        pass
+    def visit_int_expr(self, o: mypy.nodes.IntExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_str_expr(self, o: mypy.nodes.StrExpr) -> T:
-        pass
+    def visit_str_expr(self, o: mypy.nodes.StrExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_bytes_expr(self, o: mypy.nodes.BytesExpr) -> T:
-        pass
+    def visit_bytes_expr(self, o: mypy.nodes.BytesExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_float_expr(self, o: mypy.nodes.FloatExpr) -> T:
-        pass
+    def visit_float_expr(self, o: mypy.nodes.FloatExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_complex_expr(self, o: mypy.nodes.ComplexExpr) -> T:
-        pass
+    def visit_complex_expr(self, o: mypy.nodes.ComplexExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_ellipsis(self, o: mypy.nodes.EllipsisExpr) -> T:
-        pass
+    def visit_ellipsis(self, o: mypy.nodes.EllipsisExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_star_expr(self, o: mypy.nodes.StarExpr) -> T:
-        pass
+    def visit_star_expr(self, o: mypy.nodes.StarExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_name_expr(self, o: mypy.nodes.NameExpr) -> T:
-        pass
+    def visit_name_expr(self, o: mypy.nodes.NameExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_member_expr(self, o: mypy.nodes.MemberExpr) -> T:
-        pass
+    def visit_member_expr(self, o: mypy.nodes.MemberExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_yield_from_expr(self, o: mypy.nodes.YieldFromExpr) -> T:
-        pass
+    def visit_yield_from_expr(self, o: mypy.nodes.YieldFromExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_yield_expr(self, o: mypy.nodes.YieldExpr) -> T:
-        pass
+    def visit_yield_expr(self, o: mypy.nodes.YieldExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_call_expr(self, o: mypy.nodes.CallExpr) -> T:
-        pass
+    def visit_call_expr(self, o: mypy.nodes.CallExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_op_expr(self, o: mypy.nodes.OpExpr) -> T:
-        pass
+    def visit_op_expr(self, o: mypy.nodes.OpExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_comparison_expr(self, o: mypy.nodes.ComparisonExpr) -> T:
-        pass
+    def visit_comparison_expr(self, o: mypy.nodes.ComparisonExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_cast_expr(self, o: mypy.nodes.CastExpr) -> T:
-        pass
+    def visit_cast_expr(self, o: mypy.nodes.CastExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_assert_type_expr(self, o: mypy.nodes.AssertTypeExpr) -> T:
-        pass
+    def visit_assert_type_expr(self, o: mypy.nodes.AssertTypeExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_reveal_expr(self, o: mypy.nodes.RevealExpr) -> T:
-        pass
+    def visit_reveal_expr(self, o: mypy.nodes.RevealExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_super_expr(self, o: mypy.nodes.SuperExpr) -> T:
-        pass
+    def visit_super_expr(self, o: mypy.nodes.SuperExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_assignment_expr(self, o: mypy.nodes.AssignmentExpr) -> T:
-        pass
+    def visit_assignment_expr(self, o: mypy.nodes.AssignmentExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_unary_expr(self, o: mypy.nodes.UnaryExpr) -> T:
-        pass
+    def visit_unary_expr(self, o: mypy.nodes.UnaryExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_list_expr(self, o: mypy.nodes.ListExpr) -> T:
-        pass
+    def visit_list_expr(self, o: mypy.nodes.ListExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_dict_expr(self, o: mypy.nodes.DictExpr) -> T:
-        pass
+    def visit_dict_expr(self, o: mypy.nodes.DictExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_tuple_expr(self, o: mypy.nodes.TupleExpr) -> T:
-        pass
+    def visit_tuple_expr(self, o: mypy.nodes.TupleExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_set_expr(self, o: mypy.nodes.SetExpr) -> T:
-        pass
+    def visit_set_expr(self, o: mypy.nodes.SetExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_index_expr(self, o: mypy.nodes.IndexExpr) -> T:
-        pass
+    def visit_index_expr(self, o: mypy.nodes.IndexExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_type_application(self, o: mypy.nodes.TypeApplication) -> T:
-        pass
+    def visit_type_application(self, o: mypy.nodes.TypeApplication, /) -> T:
+        raise NotImplementedError()
 
-    def visit_lambda_expr(self, o: mypy.nodes.LambdaExpr) -> T:
-        pass
+    def visit_lambda_expr(self, o: mypy.nodes.LambdaExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_list_comprehension(self, o: mypy.nodes.ListComprehension) -> T:
-        pass
+    def visit_list_comprehension(self, o: mypy.nodes.ListComprehension, /) -> T:
+        raise NotImplementedError()
 
-    def visit_set_comprehension(self, o: mypy.nodes.SetComprehension) -> T:
-        pass
+    def visit_set_comprehension(self, o: mypy.nodes.SetComprehension, /) -> T:
+        raise NotImplementedError()
 
-    def visit_dictionary_comprehension(self, o: mypy.nodes.DictionaryComprehension) -> T:
-        pass
+    def visit_dictionary_comprehension(self, o: mypy.nodes.DictionaryComprehension, /) -> T:
+        raise NotImplementedError()
 
-    def visit_generator_expr(self, o: mypy.nodes.GeneratorExpr) -> T:
-        pass
+    def visit_generator_expr(self, o: mypy.nodes.GeneratorExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_slice_expr(self, o: mypy.nodes.SliceExpr) -> T:
-        pass
+    def visit_slice_expr(self, o: mypy.nodes.SliceExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_conditional_expr(self, o: mypy.nodes.ConditionalExpr) -> T:
-        pass
+    def visit_conditional_expr(self, o: mypy.nodes.ConditionalExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_type_var_expr(self, o: mypy.nodes.TypeVarExpr) -> T:
-        pass
+    def visit_type_var_expr(self, o: mypy.nodes.TypeVarExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_paramspec_expr(self, o: mypy.nodes.ParamSpecExpr) -> T:
-        pass
+    def visit_paramspec_expr(self, o: mypy.nodes.ParamSpecExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_type_var_tuple_expr(self, o: mypy.nodes.TypeVarTupleExpr) -> T:
-        pass
+    def visit_type_var_tuple_expr(self, o: mypy.nodes.TypeVarTupleExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_type_alias_expr(self, o: mypy.nodes.TypeAliasExpr) -> T:
-        pass
+    def visit_type_alias_expr(self, o: mypy.nodes.TypeAliasExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_namedtuple_expr(self, o: mypy.nodes.NamedTupleExpr) -> T:
-        pass
+    def visit_namedtuple_expr(self, o: mypy.nodes.NamedTupleExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_enum_call_expr(self, o: mypy.nodes.EnumCallExpr) -> T:
-        pass
+    def visit_enum_call_expr(self, o: mypy.nodes.EnumCallExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_typeddict_expr(self, o: mypy.nodes.TypedDictExpr) -> T:
-        pass
+    def visit_typeddict_expr(self, o: mypy.nodes.TypedDictExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_newtype_expr(self, o: mypy.nodes.NewTypeExpr) -> T:
-        pass
+    def visit_newtype_expr(self, o: mypy.nodes.NewTypeExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit__promote_expr(self, o: mypy.nodes.PromoteExpr) -> T:
-        pass
+    def visit__promote_expr(self, o: mypy.nodes.PromoteExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_await_expr(self, o: mypy.nodes.AwaitExpr) -> T:
-        pass
+    def visit_await_expr(self, o: mypy.nodes.AwaitExpr, /) -> T:
+        raise NotImplementedError()
 
-    def visit_temp_node(self, o: mypy.nodes.TempNode) -> T:
-        pass
+    def visit_temp_node(self, o: mypy.nodes.TempNode, /) -> T:
+        raise NotImplementedError()
 
     # Patterns
 
-    def visit_as_pattern(self, o: mypy.patterns.AsPattern) -> T:
-        pass
+    def visit_as_pattern(self, o: mypy.patterns.AsPattern, /) -> T:
+        raise NotImplementedError()
 
-    def visit_or_pattern(self, o: mypy.patterns.OrPattern) -> T:
-        pass
+    def visit_or_pattern(self, o: mypy.patterns.OrPattern, /) -> T:
+        raise NotImplementedError()
 
-    def visit_value_pattern(self, o: mypy.patterns.ValuePattern) -> T:
-        pass
+    def visit_value_pattern(self, o: mypy.patterns.ValuePattern, /) -> T:
+        raise NotImplementedError()
 
-    def visit_singleton_pattern(self, o: mypy.patterns.SingletonPattern) -> T:
-        pass
+    def visit_singleton_pattern(self, o: mypy.patterns.SingletonPattern, /) -> T:
+        raise NotImplementedError()
 
-    def visit_sequence_pattern(self, o: mypy.patterns.SequencePattern) -> T:
-        pass
+    def visit_sequence_pattern(self, o: mypy.patterns.SequencePattern, /) -> T:
+        raise NotImplementedError()
 
-    def visit_starred_pattern(self, o: mypy.patterns.StarredPattern) -> T:
-        pass
+    def visit_starred_pattern(self, o: mypy.patterns.StarredPattern, /) -> T:
+        raise NotImplementedError()
 
-    def visit_mapping_pattern(self, o: mypy.patterns.MappingPattern) -> T:
-        pass
+    def visit_mapping_pattern(self, o: mypy.patterns.MappingPattern, /) -> T:
+        raise NotImplementedError()
 
-    def visit_class_pattern(self, o: mypy.patterns.ClassPattern) -> T:
-        pass
+    def visit_class_pattern(self, o: mypy.patterns.ClassPattern, /) -> T:
+        raise NotImplementedError()
diff --git a/mypy_bootstrap.ini b/mypy_bootstrap.ini
index c680990fbd9e..6e82f23b0530 100644
--- a/mypy_bootstrap.ini
+++ b/mypy_bootstrap.ini
@@ -1,16 +1,6 @@
 [mypy]
-disallow_untyped_calls = True
-disallow_untyped_defs = True
-disallow_incomplete_defs = True
-check_untyped_defs = True
-disallow_subclassing_any = True
-warn_no_return = True
-strict_optional = True
-no_implicit_optional = True
-disallow_any_generics = True
-disallow_any_unimported = True
-warn_redundant_casts = True
-warn_unused_configs = True
+strict = True
+warn_unused_ignores = False
 show_traceback = True
 always_true = MYPYC
 
diff --git a/mypy_self_check.ini b/mypy_self_check.ini
index d20fcd60a9cb..8bf7a514f481 100644
--- a/mypy_self_check.ini
+++ b/mypy_self_check.ini
@@ -1,15 +1,18 @@
 [mypy]
 
 strict = True
+local_partial_types = True
 disallow_any_unimported = True
 show_traceback = True
 pretty = True
 always_false = MYPYC
-plugins = misc/proper_plugin.py
-python_version = 3.7
+plugins = mypy.plugins.proper_plugin
+python_version = 3.9
 exclude = mypy/typeshed/|mypyc/test-data/|mypyc/lib-rt/
 enable_error_code = ignore-without-code,redundant-expr
+enable_incomplete_feature = PreciseTupleTypes
+show_error_code_links = True
 
-[mypy-mypy.visitor]
-# See docstring for NodeVisitor for motivation.
-disable_error_code = empty-body
+[mypy-mypy.*]
+# TODO: enable for `mypyc` and other files as well
+warn_unreachable = True
diff --git a/mypyc/.readthedocs.yaml b/mypyc/.readthedocs.yaml
new file mode 100644
index 000000000000..90831dfd7069
--- /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
diff --git a/mypyc/README.md b/mypyc/README.md
index cb6cf5bf225c..720e64875735 100644
--- a/mypyc/README.md
+++ b/mypyc/README.md
@@ -1,133 +1,12 @@
 mypyc: Mypy to Python C Extension Compiler
 ==========================================
 
-**NOTE: We are in the process of moving the mypyc README to the**
-**[mypyc repository](https://github.com/mypyc/mypyc)**
+For the mypyc README, refer to the [mypyc repository](https://github.com/mypyc/mypyc). The mypyc
+repository also contains the mypyc issue tracker. All mypyc code lives
+here in the mypy repository.
 
-**This may be out of date!**
+Source code for the mypyc user documentation lives under
+[mypyc/doc](./doc).
 
-Mypyc is a compiler that compiles mypy-annotated, statically typed
-Python modules into CPython C extensions. Currently our primary focus
-is on making mypy faster through compilation -- the default mypy wheels
-are compiled with mypyc.  Compiled mypy is about 4x faster than
-without compilation.
-
-Mypyc compiles what is essentially a Python language variant using "strict"
-semantics. This means (among some other things):
-
- * Most type annotations are enforced at runtime (raising ``TypeError`` on mismatch)
-
- * Classes are compiled into extension classes without ``__dict__``
-   (much, but not quite, like if they used ``__slots__``)
-
- * Monkey patching doesn't work
-
- * Instance attributes won't fall back to class attributes if undefined
-
- * Also there are still a bunch of bad bugs and unsupported features :)
-
-Compiled modules can import arbitrary Python modules, and compiled modules
-can be used from other Python modules.  Typically mypyc is used to only
-compile modules that contain performance bottlenecks.
-
-You can run compiled modules also as normal, interpreted Python
-modules, since mypyc targets valid Python code. This means that
-all Python developer tools and debuggers can be used.
-
-macOS Requirements
-------------------
-
-* macOS Sierra or later
-
-* Xcode command line tools
-
-* Python 3.5+ from python.org (other versions are untested)
-
-Linux Requirements
-------------------
-
-* A recent enough C/C++ build environment
-
-* Python 3.5+
-
-Windows Requirements
---------------------
-
-* Windows has been tested with Windows 10 and MSVC 2017.
-
-* Python 3.5+
-
-Quick Start for Contributors
-----------------------------
-
-First clone the mypy git repository:
-
-    $ git clone https://github.com/python/mypy.git
-    $ cd mypy
-
-Optionally create a virtualenv (recommended):
-
-    $ python3 -m venv <directory>
-    $ source <directory>/bin/activate
-
-Then install the dependencies:
-
-    $ python3 -m pip install -r test-requirements.txt
-
-Now you can run the tests:
-
-    $ pytest -q mypyc
-
-Look at the [issue tracker](https://github.com/mypyc/mypyc/issues)
-for things to work on. Please express your interest in working on an
-issue by adding a comment before doing any significant work, since
-there is a risk of duplicate work.
-
-Note that the issue tracker is hosted on the mypyc GitHub project, not
-with mypy itself.
-
-Documentation
--------------
-
-We have some [developer documentation](doc/dev-intro.md).
-
-Development Status and Roadmap
-------------------------------
-
-These are the current planned major milestones:
-
-1. [DONE] Support a smallish but useful Python subset. Focus on compiling
-   single modules, while the rest of the program is interpreted and does not
-   need to be type checked.
-
-2. [DONE] Support compiling multiple modules as a single compilation unit (or
-   dynamic linking of compiled modules).  Without this inter-module
-   calls will use slower Python-level objects, wrapper functions and
-   Python namespaces.
-
-3. [DONE] Mypyc can compile mypy.
-
-4. [DONE] Optimize some important performance bottlenecks.
-
-5. [PARTIALLY DONE] Generate useful errors for code that uses unsupported Python
-   features instead of crashing or generating bad code.
-
-6. [DONE] Release a version of mypy that includes a compiled mypy.
-
-7.
-    1. More feature/compatibility work. (100% compatibility with Python is distinctly
-       an anti-goal, but more than we have now is a good idea.)
-    2. [DONE] Support compiling Black, which is a prominent tool that could benefit
-       and has maintainer buy-in.
-       (Let us know if you maintain another Python tool or library and are
-       interested in working with us on this!)
-    3. More optimization! Code size reductions in particular are likely to
-       be valuable and will speed up mypyc compilation.
-
-8.  We'll see! Adventure is out there!
-
-Future
-------
-
-We have some ideas for
-[future improvements and optimizations](doc/future.md).
+Mypyc welcomes new contributors! Refer to our
+[developer documentation](./doc/dev-intro.md) for more information.
diff --git a/mypyc/__main__.py b/mypyc/__main__.py
index a3b9d21bc65a..653199e0fb55 100644
--- a/mypyc/__main__.py
+++ b/mypyc/__main__.py
@@ -24,7 +24,7 @@
 from mypyc.build import mypycify
 
 setup(name='mypyc_output',
-      ext_modules=mypycify({}, opt_level="{}", debug_level="{}"),
+      ext_modules=mypycify({}, opt_level="{}", debug_level="{}", strict_dunder_typing={}),
 )
 """
 
@@ -38,10 +38,11 @@ def main() -> None:
 
     opt_level = os.getenv("MYPYC_OPT_LEVEL", "3")
     debug_level = os.getenv("MYPYC_DEBUG_LEVEL", "1")
+    strict_dunder_typing = bool(int(os.getenv("MYPYC_STRICT_DUNDER_TYPING", "0")))
 
     setup_file = os.path.join(build_dir, "setup.py")
     with open(setup_file, "w") as f:
-        f.write(setup_format.format(sys.argv[1:], opt_level, debug_level))
+        f.write(setup_format.format(sys.argv[1:], opt_level, debug_level, strict_dunder_typing))
 
     # We don't use run_setup (like we do in the test suite) because it throws
     # away the error code from distutils, and we don't care about the slight
diff --git a/mypyc/analysis/attrdefined.py b/mypyc/analysis/attrdefined.py
index 02e02a82a4f9..896527bdcf14 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
 
 from mypyc.analysis.dataflow import (
     CFG,
@@ -177,7 +176,7 @@ def analyze_always_defined_attrs_in_class(cl: ClassIR, seen: set[ClassIR]) -> No
         m.blocks, self_reg, maybe_defined, dirty
     )
 
-    mark_attr_initialiation_ops(m.blocks, self_reg, maybe_defined, dirty)
+    mark_attr_initialization_ops(m.blocks, self_reg, maybe_defined, dirty)
 
     # Check if __init__ can run unpredictable code (leak 'self').
     any_dirty = False
@@ -261,7 +260,7 @@ def find_sometimes_defined_attributes(
     return attrs
 
 
-def mark_attr_initialiation_ops(
+def mark_attr_initialization_ops(
     blocks: list[BasicBlock],
     self_reg: Register,
     maybe_defined: AnalysisResult[str],
@@ -280,7 +279,7 @@ def mark_attr_initialiation_ops(
                     op.mark_as_initializer()
 
 
-GenAndKill = Tuple[Set[str], Set[str]]
+GenAndKill = tuple[set[str], set[str]]
 
 
 def attributes_initialized_by_init_call(op: Call) -> set[str]:
@@ -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/analysis/dataflow.py b/mypyc/analysis/dataflow.py
index ee2ff06b0f03..db62ef1700fa 100644
--- a/mypyc/analysis/dataflow.py
+++ b/mypyc/analysis/dataflow.py
@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import Dict, Generic, Iterable, Iterator, Set, Tuple, TypeVar
+from collections.abc import Iterable, Iterator
+from typing import Generic, TypeVar
 
-from mypyc.ir.func_ir import all_values
 from mypyc.ir.ops import (
     Assign,
     AssignMulti,
@@ -17,6 +17,7 @@
     Cast,
     ComparisonOp,
     ControlOp,
+    DecRef,
     Extend,
     Float,
     FloatComparisonOp,
@@ -25,6 +26,7 @@
     GetAttr,
     GetElementPtr,
     Goto,
+    IncRef,
     InitStatic,
     Integer,
     IntOp,
@@ -38,6 +40,7 @@
     MethodCall,
     Op,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     RegisterOp,
     Return,
@@ -46,6 +49,7 @@
     Truncate,
     TupleGet,
     TupleSet,
+    Unborrow,
     Unbox,
     Unreachable,
     Value,
@@ -71,19 +75,15 @@ def __init__(
         self.exits = exits
 
     def __str__(self) -> str:
-        lines = []
-        lines.append("exits: %s" % sorted(self.exits, key=lambda e: int(e.label)))
-        lines.append("succ: %s" % self.succ)
-        lines.append("pred: %s" % self.pred)
-        return "\n".join(lines)
+        exits = sorted(self.exits, key=lambda e: int(e.label))
+        return f"exits: {exits}\nsucc: {self.succ}\npred: {self.pred}"
 
 
-def get_cfg(blocks: list[BasicBlock]) -> CFG:
+def get_cfg(blocks: list[BasicBlock], *, use_yields: bool = False) -> CFG:
     """Calculate basic block control-flow graph.
 
-    The result is a dictionary like this:
-
-         basic block index -> (successors blocks, predecesssor blocks)
+    If use_yields is set, then we treat returns inserted by yields as gotos
+    instead of exits.
     """
     succ_map = {}
     pred_map: dict[BasicBlock, list[BasicBlock]] = {}
@@ -93,7 +93,10 @@ def get_cfg(blocks: list[BasicBlock]) -> CFG:
             isinstance(op, ControlOp) for op in block.ops[:-1]
         ), "Control-flow ops must be at the end of blocks"
 
-        succ = list(block.terminator.targets())
+        if use_yields and isinstance(block.terminator, Return) and block.terminator.yield_target:
+            succ = [block.terminator.yield_target]
+        else:
+            succ = list(block.terminator.targets())
         if not succ:
             exits.add(block)
 
@@ -156,7 +159,7 @@ def cleanup_cfg(blocks: list[BasicBlock]) -> None:
 
 T = TypeVar("T")
 
-AnalysisDict = Dict[Tuple[BasicBlock, int], Set[T]]
+AnalysisDict = dict[tuple[BasicBlock, int], set[T]]
 
 
 class AnalysisResult(Generic[T]):
@@ -168,7 +171,7 @@ def __str__(self) -> str:
         return f"before: {self.before}\nafter: {self.after}\n"
 
 
-GenAndKill = Tuple[Set[T], Set[T]]
+GenAndKill = tuple[set[T], set[T]]
 
 
 class BaseAnalysisVisitor(OpVisitor[GenAndKill[T]]):
@@ -236,6 +239,9 @@ def visit_raise_standard_error(self, op: RaiseStandardError) -> GenAndKill[T]:
     def visit_call_c(self, op: CallC) -> GenAndKill[T]:
         return self.visit_register_op(op)
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
     def visit_truncate(self, op: Truncate) -> GenAndKill[T]:
         return self.visit_register_op(op)
 
@@ -272,6 +278,9 @@ def visit_load_address(self, op: LoadAddress) -> GenAndKill[T]:
     def visit_keep_alive(self, op: KeepAlive) -> GenAndKill[T]:
         return self.visit_register_op(op)
 
+    def visit_unborrow(self, op: Unborrow) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
 
 class DefinedVisitor(BaseAnalysisVisitor[Value]):
     """Visitor for finding defined registers.
@@ -432,27 +441,6 @@ def visit_set_mem(self, op: SetMem) -> GenAndKill[Value]:
         return set(), set()
 
 
-def analyze_undefined_regs(
-    blocks: list[BasicBlock], cfg: CFG, initial_defined: set[Value]
-) -> AnalysisResult[Value]:
-    """Calculate potentially undefined registers at each CFG location.
-
-    A register is undefined if there is some path from initial block
-    where it has an undefined value.
-
-    Function arguments are assumed to be always defined.
-    """
-    initial_undefined = set(all_values([], blocks)) - initial_defined
-    return run_analysis(
-        blocks=blocks,
-        cfg=cfg,
-        gen_and_kill=UndefinedVisitor(),
-        initial=initial_undefined,
-        backward=False,
-        kind=MAYBE_ANALYSIS,
-    )
-
-
 def non_trivial_sources(op: Op) -> set[Value]:
     result = set()
     for source in op.sources():
@@ -490,6 +478,12 @@ def visit_assign_multi(self, op: AssignMulti) -> GenAndKill[Value]:
     def visit_set_mem(self, op: SetMem) -> GenAndKill[Value]:
         return non_trivial_sources(op), set()
 
+    def visit_inc_ref(self, op: IncRef) -> GenAndKill[Value]:
+        return set(), set()
+
+    def visit_dec_ref(self, op: DecRef) -> GenAndKill[Value]:
+        return set(), set()
+
 
 def analyze_live_regs(blocks: list[BasicBlock], cfg: CFG) -> AnalysisResult[Value]:
     """Calculate live registers at each CFG location.
@@ -558,7 +552,7 @@ def run_analysis(
     # Set up initial state for worklist algorithm.
     worklist = list(blocks)
     if not backward:
-        worklist = worklist[::-1]  # Reverse for a small performance improvement
+        worklist.reverse()  # Reverse for a small performance improvement
     workset = set(worklist)
     before: dict[BasicBlock, set[T]] = {}
     after: dict[BasicBlock, set[T]] = {}
diff --git a/mypyc/analysis/ircheck.py b/mypyc/analysis/ircheck.py
index 2e6b7320e898..88737ac208de 100644
--- a/mypyc/analysis/ircheck.py
+++ b/mypyc/analysis/ircheck.py
@@ -1,4 +1,5 @@
 """Utilities for checking that internal ir is valid and consistent."""
+
 from __future__ import annotations
 
 from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncIR
@@ -36,6 +37,7 @@
     MethodCall,
     Op,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
     Return,
@@ -44,6 +46,7 @@
     Truncate,
     TupleGet,
     TupleSet,
+    Unborrow,
     Unbox,
     Unreachable,
     Value,
@@ -379,6 +382,9 @@ def visit_raise_standard_error(self, op: RaiseStandardError) -> None:
     def visit_call_c(self, op: CallC) -> None:
         pass
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> None:
+        pass
+
     def visit_truncate(self, op: Truncate) -> None:
         pass
 
@@ -422,3 +428,6 @@ def visit_load_address(self, op: LoadAddress) -> None:
 
     def visit_keep_alive(self, op: KeepAlive) -> None:
         pass
+
+    def visit_unborrow(self, op: Unborrow) -> None:
+        pass
diff --git a/mypyc/analysis/selfleaks.py b/mypyc/analysis/selfleaks.py
index 288c366e50e5..4d3a7c87c5d1 100644
--- a/mypyc/analysis/selfleaks.py
+++ b/mypyc/analysis/selfleaks.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Set, Tuple
-
 from mypyc.analysis.dataflow import CFG, MAYBE_ANALYSIS, AnalysisResult, run_analysis
 from mypyc.ir.ops import (
     Assign,
@@ -31,6 +29,7 @@
     LoadStatic,
     MethodCall,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
     RegisterOp,
@@ -40,12 +39,13 @@
     Truncate,
     TupleGet,
     TupleSet,
+    Unborrow,
     Unbox,
     Unreachable,
 )
 from mypyc.ir.rtypes import RInstance
 
-GenAndKill = Tuple[Set[None], Set[None]]
+GenAndKill = tuple[set[None], set[None]]
 
 CLEAN: GenAndKill = (set(), set())
 DIRTY: GenAndKill = ({None}, {None})
@@ -148,6 +148,9 @@ def visit_raise_standard_error(self, op: RaiseStandardError) -> GenAndKill:
     def visit_call_c(self, op: CallC) -> GenAndKill:
         return self.check_register_op(op)
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> GenAndKill:
+        return self.check_register_op(op)
+
     def visit_truncate(self, op: Truncate) -> GenAndKill:
         return CLEAN
 
@@ -184,6 +187,9 @@ def visit_load_address(self, op: LoadAddress) -> GenAndKill:
     def visit_keep_alive(self, op: KeepAlive) -> GenAndKill:
         return CLEAN
 
+    def visit_unborrow(self, op: Unborrow) -> GenAndKill:
+        return CLEAN
+
     def check_register_op(self, op: RegisterOp) -> GenAndKill:
         if any(src is self.self_reg for src in op.sources()):
             return DIRTY
diff --git a/mypyc/annotate.py b/mypyc/annotate.py
new file mode 100644
index 000000000000..6736ca63c9e8
--- /dev/null
+++ b/mypyc/annotate.py
@@ -0,0 +1,471 @@
+"""Generate source code formatted as HTML, with bottlenecks annotated and highlighted.
+
+Various heuristics are used to detect common issues that cause slower than
+expected performance.
+"""
+
+from __future__ import annotations
+
+import os.path
+import sys
+from html import escape
+from typing import Final
+
+from mypy.build import BuildResult
+from mypy.nodes import (
+    AssignmentStmt,
+    CallExpr,
+    ClassDef,
+    Decorator,
+    DictionaryComprehension,
+    Expression,
+    ForStmt,
+    FuncDef,
+    GeneratorExpr,
+    IndexExpr,
+    LambdaExpr,
+    MemberExpr,
+    MypyFile,
+    NamedTupleExpr,
+    NameExpr,
+    NewTypeExpr,
+    Node,
+    OpExpr,
+    RefExpr,
+    TupleExpr,
+    TypedDictExpr,
+    TypeInfo,
+    TypeVarExpr,
+    Var,
+    WithStmt,
+)
+from mypy.traverser import TraverserVisitor
+from mypy.types import AnyType, Instance, ProperType, Type, TypeOfAny, get_proper_type
+from mypy.util import FancyFormatter
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.module_ir import ModuleIR
+from mypyc.ir.ops import CallC, LoadLiteral, LoadStatic, Value
+from mypyc.irbuild.mapper import Mapper
+
+
+class Annotation:
+    """HTML annotation for compiled source code"""
+
+    def __init__(self, message: str, priority: int = 1) -> None:
+        # Message as HTML that describes an issue and/or how to fix it.
+        # Multiple messages on a line may be concatenated.
+        self.message = message
+        # If multiple annotations are generated for a single line, only report
+        # the highest-priority ones. Some use cases generate multiple annotations,
+        # and this can be used to reduce verbosity by hiding the lower-priority
+        # ones.
+        self.priority = priority
+
+
+op_hints: Final = {
+    "PyNumber_Add": Annotation('Generic "+" operation.'),
+    "PyNumber_Subtract": Annotation('Generic "-" operation.'),
+    "PyNumber_Multiply": Annotation('Generic "*" operation.'),
+    "PyNumber_TrueDivide": Annotation('Generic "/" operation.'),
+    "PyNumber_FloorDivide": Annotation('Generic "//" operation.'),
+    "PyNumber_Positive": Annotation('Generic unary "+" operation.'),
+    "PyNumber_Negative": Annotation('Generic unary "-" operation.'),
+    "PyNumber_And": Annotation('Generic "&" operation.'),
+    "PyNumber_Or": Annotation('Generic "|" operation.'),
+    "PyNumber_Xor": Annotation('Generic "^" operation.'),
+    "PyNumber_Lshift": Annotation('Generic "<<" operation.'),
+    "PyNumber_Rshift": Annotation('Generic ">>" operation.'),
+    "PyNumber_Invert": Annotation('Generic "~" operation.'),
+    "PyObject_Call": Annotation("Generic call operation."),
+    "PyObject_RichCompare": Annotation("Generic comparison operation."),
+    "PyObject_GetItem": Annotation("Generic indexing operation."),
+    "PyObject_SetItem": Annotation("Generic indexed assignment."),
+}
+
+stdlib_hints: Final = {
+    "functools.partial": Annotation(
+        '"functools.partial" is inefficient in compiled code.', priority=3
+    ),
+    "itertools.chain": Annotation(
+        '"itertools.chain" is inefficient in compiled code (hint: replace with for loops).',
+        priority=3,
+    ),
+    "itertools.groupby": Annotation(
+        '"itertools.groupby" is inefficient in compiled code.', priority=3
+    ),
+    "itertools.islice": Annotation(
+        '"itertools.islice" is inefficient in compiled code (hint: replace with for loop over index range).',
+        priority=3,
+    ),
+    "copy.deepcopy": Annotation(
+        '"copy.deepcopy" tends to be slow. Make a shallow copy if possible.', priority=2
+    ),
+}
+
+CSS = """\
+.collapsible {
+    cursor: pointer;
+}
+
+.content {
+    display: block;
+    margin-top: 10px;
+    margin-bottom: 10px;
+}
+
+.hint {
+    display: inline;
+    border: 1px solid #ccc;
+    padding: 5px;
+}
+"""
+
+JS = """\
+document.querySelectorAll('.collapsible').forEach(function(collapsible) {
+    collapsible.addEventListener('click', function() {
+        const content = this.nextElementSibling;
+        if (content.style.display === 'none') {
+            content.style.display = 'block';
+        } else {
+            content.style.display = 'none';
+        }
+    });
+});
+"""
+
+
+class AnnotatedSource:
+    """Annotations for a single compiled source file."""
+
+    def __init__(self, path: str, annotations: dict[int, list[Annotation]]) -> None:
+        self.path = path
+        self.annotations = annotations
+
+
+def generate_annotated_html(
+    html_fnam: str, result: BuildResult, modules: dict[str, ModuleIR], mapper: Mapper
+) -> None:
+    annotations = []
+    for mod, mod_ir in modules.items():
+        path = result.graph[mod].path
+        tree = result.graph[mod].tree
+        assert tree is not None
+        annotations.append(
+            generate_annotations(path or "<source>", tree, mod_ir, result.types, mapper)
+        )
+    html = generate_html_report(annotations)
+    with open(html_fnam, "w") as f:
+        f.write(html)
+
+    formatter = FancyFormatter(sys.stdout, sys.stderr, False)
+    formatted = formatter.style(os.path.abspath(html_fnam), "none", underline=True, bold=True)
+    print(f"\nWrote {formatted} -- open in browser to view\n")
+
+
+def generate_annotations(
+    path: str, tree: MypyFile, ir: ModuleIR, type_map: dict[Expression, Type], mapper: Mapper
+) -> AnnotatedSource:
+    anns = {}
+    for func_ir in ir.functions:
+        anns.update(function_annotations(func_ir, tree))
+    visitor = ASTAnnotateVisitor(type_map, mapper)
+    for defn in tree.defs:
+        defn.accept(visitor)
+    anns.update(visitor.anns)
+    for line in visitor.ignored_lines:
+        if line in anns:
+            del anns[line]
+    return AnnotatedSource(path, anns)
+
+
+def function_annotations(func_ir: FuncIR, tree: MypyFile) -> dict[int, list[Annotation]]:
+    """Generate annotations based on mypyc IR."""
+    # TODO: check if func_ir.line is -1
+    anns: dict[int, list[Annotation]] = {}
+    for block in func_ir.blocks:
+        for op in block.ops:
+            if isinstance(op, CallC):
+                name = op.function_name
+                ann: str | Annotation | None = None
+                if name == "CPyObject_GetAttr":
+                    attr_name = get_str_literal(op.args[1])
+                    if attr_name in ("__prepare__", "GeneratorExit", "StopIteration"):
+                        # These attributes are internal to mypyc/CPython, and/or accessed
+                        # implicitly in generated code. The user has little control over
+                        # them.
+                        ann = None
+                    elif attr_name:
+                        ann = f'Get non-native attribute "{attr_name}".'
+                    else:
+                        ann = "Dynamic attribute lookup."
+                elif name == "PyObject_SetAttr":
+                    attr_name = get_str_literal(op.args[1])
+                    if attr_name == "__mypyc_attrs__":
+                        # This is set implicitly and can't be avoided.
+                        ann = None
+                    elif attr_name:
+                        ann = f'Set non-native attribute "{attr_name}".'
+                    else:
+                        ann = "Dynamic attribute set."
+                elif name == "PyObject_VectorcallMethod":
+                    method_name = get_str_literal(op.args[0])
+                    if method_name:
+                        ann = f'Call non-native method "{method_name}" (it may be defined in a non-native class, or decorated).'
+                    else:
+                        ann = "Dynamic method call."
+                elif name in op_hints:
+                    ann = op_hints[name]
+                elif name in ("CPyDict_GetItem", "CPyDict_SetItem"):
+                    if (
+                        isinstance(op.args[0], LoadStatic)
+                        and isinstance(op.args[1], LoadLiteral)
+                        and func_ir.name != "__top_level__"
+                    ):
+                        load = op.args[0]
+                        name = str(op.args[1].value)
+                        sym = tree.names.get(name)
+                        if (
+                            sym
+                            and sym.node
+                            and load.namespace == "static"
+                            and load.identifier == "globals"
+                        ):
+                            if sym.node.fullname in stdlib_hints:
+                                ann = stdlib_hints[sym.node.fullname]
+                            elif isinstance(sym.node, Var):
+                                ann = (
+                                    f'Access global "{name}" through namespace '
+                                    + "dictionary (hint: access is faster if you can make it Final)."
+                                )
+                            else:
+                                ann = f'Access "{name}" through global namespace dictionary.'
+                if ann:
+                    if isinstance(ann, str):
+                        ann = Annotation(ann)
+                    anns.setdefault(op.line, []).append(ann)
+    return anns
+
+
+class ASTAnnotateVisitor(TraverserVisitor):
+    """Generate annotations from mypy AST and inferred types."""
+
+    def __init__(self, type_map: dict[Expression, Type], mapper: Mapper) -> None:
+        self.anns: dict[int, list[Annotation]] = {}
+        self.ignored_lines: set[int] = set()
+        self.func_depth = 0
+        self.type_map = type_map
+        self.mapper = mapper
+
+    def visit_func_def(self, o: FuncDef, /) -> None:
+        if self.func_depth > 0:
+            self.annotate(
+                o,
+                "A nested function object is allocated each time statement is executed. "
+                + "A module-level function would be faster.",
+            )
+        self.func_depth += 1
+        super().visit_func_def(o)
+        self.func_depth -= 1
+
+    def visit_for_stmt(self, o: ForStmt, /) -> None:
+        self.check_iteration([o.expr], "For loop")
+        super().visit_for_stmt(o)
+
+    def visit_dictionary_comprehension(self, o: DictionaryComprehension, /) -> None:
+        self.check_iteration(o.sequences, "Comprehension")
+        super().visit_dictionary_comprehension(o)
+
+    def visit_generator_expr(self, o: GeneratorExpr, /) -> None:
+        self.check_iteration(o.sequences, "Comprehension or generator")
+        super().visit_generator_expr(o)
+
+    def check_iteration(self, expressions: list[Expression], kind: str) -> None:
+        for expr in expressions:
+            typ = self.get_type(expr)
+            if isinstance(typ, AnyType):
+                self.annotate(expr, f'{kind} uses generic operations (iterable has type "Any").')
+            elif isinstance(typ, Instance) and typ.type.fullname in (
+                "typing.Iterable",
+                "typing.Iterator",
+                "typing.Sequence",
+                "typing.MutableSequence",
+            ):
+                self.annotate(
+                    expr,
+                    f'{kind} uses generic operations (iterable has the abstract type "{typ.type.fullname}").',
+                )
+
+    def visit_class_def(self, o: ClassDef, /) -> None:
+        super().visit_class_def(o)
+        if self.func_depth == 0:
+            # Don't complain about base classes at top level
+            for base in o.base_type_exprs:
+                self.ignored_lines.add(base.line)
+
+            for s in o.defs.body:
+                if isinstance(s, AssignmentStmt):
+                    # Don't complain about attribute initializers
+                    self.ignored_lines.add(s.line)
+                elif isinstance(s, Decorator):
+                    # Don't complain about decorator definitions that generate some
+                    # dynamic operations. This is a bit heavy-handed.
+                    self.ignored_lines.add(s.func.line)
+
+    def visit_with_stmt(self, o: WithStmt, /) -> None:
+        for expr in o.expr:
+            if isinstance(expr, CallExpr) and isinstance(expr.callee, RefExpr):
+                node = expr.callee.node
+                if isinstance(node, Decorator):
+                    if any(
+                        isinstance(d, RefExpr)
+                        and d.node
+                        and d.node.fullname == "contextlib.contextmanager"
+                        for d in node.decorators
+                    ):
+                        self.annotate(
+                            expr,
+                            f'"{node.name}" uses @contextmanager, which is slow '
+                            + "in compiled code. Use a native class with "
+                            + '"__enter__" and "__exit__" methods instead.',
+                            priority=3,
+                        )
+        super().visit_with_stmt(o)
+
+    def visit_assignment_stmt(self, o: AssignmentStmt, /) -> None:
+        special_form = False
+        if self.func_depth == 0:
+            analyzed: Expression | None = o.rvalue
+            if isinstance(o.rvalue, (CallExpr, IndexExpr, OpExpr)):
+                analyzed = o.rvalue.analyzed
+            if o.is_alias_def or isinstance(
+                analyzed, (TypeVarExpr, NamedTupleExpr, TypedDictExpr, NewTypeExpr)
+            ):
+                special_form = True
+            if special_form:
+                # TODO: Ignore all lines if multi-line
+                self.ignored_lines.add(o.line)
+        super().visit_assignment_stmt(o)
+
+    def visit_name_expr(self, o: NameExpr, /) -> None:
+        if ann := stdlib_hints.get(o.fullname):
+            self.annotate(o, ann)
+
+    def visit_member_expr(self, o: MemberExpr, /) -> None:
+        super().visit_member_expr(o)
+        if ann := stdlib_hints.get(o.fullname):
+            self.annotate(o, ann)
+
+    def visit_call_expr(self, o: CallExpr, /) -> None:
+        super().visit_call_expr(o)
+        if (
+            isinstance(o.callee, RefExpr)
+            and o.callee.fullname == "builtins.isinstance"
+            and len(o.args) == 2
+        ):
+            arg = o.args[1]
+            self.check_isinstance_arg(arg)
+        elif isinstance(o.callee, RefExpr) and isinstance(o.callee.node, TypeInfo):
+            info = o.callee.node
+            class_ir = self.mapper.type_to_ir.get(info)
+            if (class_ir and not class_ir.is_ext_class) or (
+                class_ir is None and not info.fullname.startswith("builtins.")
+            ):
+                self.annotate(
+                    o, f'Creating an instance of non-native class "{info.name}" ' + "is slow.", 2
+                )
+            elif class_ir and class_ir.is_augmented:
+                self.annotate(
+                    o,
+                    f'Class "{info.name}" is only partially native, and '
+                    + "constructing an instance is slow.",
+                    2,
+                )
+        elif isinstance(o.callee, RefExpr) and isinstance(o.callee.node, Decorator):
+            decorator = o.callee.node
+            if self.mapper.is_native_ref_expr(o.callee):
+                self.annotate(
+                    o,
+                    f'Calling a decorated function ("{decorator.name}") is inefficient, even if it\'s native.',
+                    2,
+                )
+
+    def check_isinstance_arg(self, arg: Expression) -> None:
+        if isinstance(arg, RefExpr):
+            if isinstance(arg.node, TypeInfo) and arg.node.is_protocol:
+                self.annotate(
+                    arg, f'Expensive isinstance() check against protocol "{arg.node.name}".'
+                )
+        elif isinstance(arg, TupleExpr):
+            for item in arg.items:
+                self.check_isinstance_arg(item)
+
+    def visit_lambda_expr(self, o: LambdaExpr, /) -> None:
+        self.annotate(
+            o,
+            "A new object is allocated for lambda each time it is evaluated. "
+            + "A module-level function would be faster.",
+        )
+        super().visit_lambda_expr(o)
+
+    def annotate(self, o: Node, ann: str | Annotation, priority: int = 1) -> None:
+        if isinstance(ann, str):
+            ann = Annotation(ann, priority=priority)
+        self.anns.setdefault(o.line, []).append(ann)
+
+    def get_type(self, e: Expression) -> ProperType:
+        t = self.type_map.get(e)
+        if t:
+            return get_proper_type(t)
+        return AnyType(TypeOfAny.unannotated)
+
+
+def get_str_literal(v: Value) -> str | None:
+    if isinstance(v, LoadLiteral) and isinstance(v.value, str):
+        return v.value
+    return None
+
+
+def get_max_prio(anns: list[Annotation]) -> list[Annotation]:
+    max_prio = max(a.priority for a in anns)
+    return [a for a in anns if a.priority == max_prio]
+
+
+def generate_html_report(sources: list[AnnotatedSource]) -> str:
+    html = []
+    html.append("<html>\n<head>\n")
+    html.append(f"<style>\n{CSS}\n</style>")
+    html.append("</head>\n")
+    html.append("<body>\n")
+    for src in sources:
+        html.append(f"<h2><tt>{src.path}</tt></h2>\n")
+        html.append("<pre>")
+        src_anns = src.annotations
+        with open(src.path) as f:
+            lines = f.readlines()
+        for i, s in enumerate(lines):
+            s = escape(s)
+            line = i + 1
+            linenum = "%5d" % line
+            if line in src_anns:
+                anns = get_max_prio(src_anns[line])
+                ann_strs = [a.message for a in anns]
+                hint = " ".join(ann_strs)
+                s = colorize_line(linenum, s, hint_html=hint)
+            else:
+                s = linenum + "  " + s
+            html.append(s)
+        html.append("</pre>")
+
+    html.append("<script>")
+    html.append(JS)
+    html.append("</script>")
+
+    html.append("</body></html>\n")
+    return "".join(html)
+
+
+def colorize_line(linenum: str, s: str, hint_html: str) -> str:
+    hint_prefix = " " * len(linenum) + "  "
+    line_span = f'<div class="collapsible" style="background-color: #fcc">{linenum}  {s}</div>'
+    hint_div = f'<div class="content">{hint_prefix}<div class="hint">{hint_html}</div></div>'
+    return f"<span>{line_span}{hint_div}</span>"
diff --git a/mypyc/build.py b/mypyc/build.py
index 5fc041e2dcf2..3bc38cb4dd90 100644
--- a/mypyc/build.py
+++ b/mypyc/build.py
@@ -25,7 +25,8 @@
 import re
 import sys
 import time
-from typing import TYPE_CHECKING, Any, Dict, Iterable, NoReturn, Union, cast
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, NoReturn, Union, cast
 
 from mypy.build import BuildSource
 from mypy.errors import CompileError
@@ -33,6 +34,7 @@
 from mypy.main import process_options
 from mypy.options import Options
 from mypy.util import write_junit_xml
+from mypyc.annotate import generate_annotated_html
 from mypyc.codegen import emitmodule
 from mypyc.common import RUNTIME_C_FILES, shared_lib_name
 from mypyc.errors import Errors
@@ -40,23 +42,28 @@
 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
-
-    from setuptools import Extension as _setuptools_Extension
-
-    Extension: TypeAlias = Union[_setuptools_Extension, _distutils_Extension]
-
-
 try:
     # Import setuptools so that it monkey-patch overrides distutils
     import setuptools
 except ImportError:
+    pass
+
+if TYPE_CHECKING:
     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
+    else:
+        from distutils.core import Extension as _distutils_Extension
+        from typing_extensions import TypeAlias
+
+        from setuptools import Extension as _setuptools_Extension
+
+        Extension: TypeAlias = Union[_setuptools_Extension, _distutils_Extension]
+
+if sys.version_info >= (3, 12):
+    # From setuptools' monkeypatch
+    from distutils import ccompiler, sysconfig  # type: ignore[import-not-found]
+else:
+    from distutils import ccompiler, sysconfig
 
 
 def get_extension() -> type[Extension]:
@@ -65,11 +72,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
@@ -80,7 +89,7 @@ def setup_mypycify_vars() -> None:
     # There has to be a better approach to this.
 
     # The vars can contain ints but we only work with str ones
-    vars = cast(Dict[str, str], sysconfig.get_config_vars())
+    vars = cast(dict[str, str], sysconfig.get_config_vars())
     if sys.platform == "darwin":
         # Disable building 32-bit binaries, since we generate too much code
         # for a 32-bit Mach-O object. There has to be a better way to do this.
@@ -98,7 +107,14 @@ def emit_messages(options: Options, messages: list[str], dt: float, serious: boo
     # ... you know, just in case.
     if options.junit_xml:
         py_version = f"{options.python_version[0]}_{options.python_version[1]}"
-        write_junit_xml(dt, serious, messages, options.junit_xml, py_version, options.platform)
+        write_junit_xml(
+            dt,
+            serious,
+            {None: messages} if messages else {},
+            options.junit_xml,
+            py_version,
+            options.platform,
+        )
     if messages:
         print("\n".join(messages))
 
@@ -226,7 +242,7 @@ def generate_c(
         print(f"Parsed and typechecked in {t1 - t0:.3f}s")
 
     errors = Errors(options)
-    modules, ctext = emitmodule.compile_modules_to_c(
+    modules, ctext, mapper = emitmodule.compile_modules_to_c(
         result, compiler_options=compiler_options, errors=errors, groups=groups
     )
     t2 = time.time()
@@ -238,6 +254,9 @@ def generate_c(
     if compiler_options.verbose:
         print(f"Compiled to C in {t2 - t1:.3f}s")
 
+    if options.mypyc_annotation_file:
+        generate_annotated_html(options.mypyc_annotation_file, result, modules, mapper)
+
     return ctext, "\n".join(format_modules(modules))
 
 
@@ -433,7 +452,8 @@ def mypyc_build(
         cfilenames = []
         for cfile, ctext in cfiles:
             cfile = os.path.join(compiler_options.target_dir, cfile)
-            write_file(cfile, ctext)
+            if not options.mypyc_skip_c_generation:
+                write_file(cfile, ctext)
             if os.path.splitext(cfile)[1] == ".c":
                 cfilenames.append(cfile)
 
@@ -456,6 +476,7 @@ def mypycify(
     skip_cgen_input: Any | None = None,
     target_dir: str | None = None,
     include_runtime_files: bool | None = None,
+    strict_dunder_typing: bool = False,
 ) -> list[Extension]:
     """Main entry point to building using mypyc.
 
@@ -495,6 +516,9 @@ def mypycify(
                                should be directly #include'd instead of linked
                                separately in order to reduce compiler invocations.
                                Defaults to False in multi_file mode, True otherwise.
+        strict_dunder_typing: If True, force dunder methods to have the return type
+                              of the method strictly, which can lead to more
+                              optimization opportunities. Defaults to False.
     """
 
     # Figure out our configuration
@@ -505,6 +529,7 @@ def mypycify(
         separate=separate is not False,
         target_dir=target_dir,
         include_runtime_files=include_runtime_files,
+        strict_dunder_typing=strict_dunder_typing,
     )
 
     # Generate all the actual important C code
diff --git a/mypyc/codegen/cstring.py b/mypyc/codegen/cstring.py
index e006f12e09ec..853787f8161d 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 a2e3d9849dca..d7d7d9c7abda 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -5,19 +5,18 @@
 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 (
     ATTR_PREFIX,
     BITMAP_BITS,
     FAST_ISINSTANCE_MAX_SUBCLASSES,
+    HAVE_IMMORTAL,
     NATIVE_PREFIX,
     REG_PREFIX,
     STATIC_PREFIX,
     TYPE_PREFIX,
-    use_vectorcall,
 )
 from mypyc.ir.class_ir import ClassIR, all_concrete_classes
 from mypyc.ir.func_ir import FuncDecl
@@ -35,6 +34,8 @@
     is_dict_rprimitive,
     is_fixed_width_rtype,
     is_float_rprimitive,
+    is_frozenset_rprimitive,
+    is_int16_rprimitive,
     is_int32_rprimitive,
     is_int64_rprimitive,
     is_int_rprimitive,
@@ -47,6 +48,7 @@
     is_short_int_rprimitive,
     is_str_rprimitive,
     is_tuple_rprimitive,
+    is_uint8_rprimitive,
     object_rprimitive,
     optional_value_type,
 )
@@ -194,7 +196,7 @@ def attr(self, name: str) -> str:
         return ATTR_PREFIX + name
 
     def object_annotation(self, obj: object, line: str) -> str:
-        """Build a C comment with an object's string represention.
+        """Build a C comment with an object's string representation.
 
         If the comment exceeds the line length limit, it's wrapped into a
         multiline string (with the extra lines indented to be aligned with
@@ -345,12 +347,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("")
 
@@ -402,9 +398,6 @@ def _emit_attr_bitmap_update(
         if value:
             self.emit_line("}")
 
-    def use_vectorcall(self) -> bool:
-        return use_vectorcall(self.capi_version)
-
     def emit_undefined_attr_check(
         self,
         rtype: RType,
@@ -470,23 +463,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
 
@@ -519,8 +509,11 @@ def emit_inc_ref(self, dest: str, rtype: RType, *, rare: bool = False) -> None:
             for i, item_type in enumerate(rtype.types):
                 self.emit_inc_ref(f"{dest}.f{i}", item_type)
         elif not rtype.is_unboxed:
-            # Always inline, since this is a simple op
-            self.emit_line("CPy_INCREF(%s);" % dest)
+            # Always inline, since this is a simple but very hot op
+            if rtype.may_be_immortal or not HAVE_IMMORTAL:
+                self.emit_line("CPy_INCREF(%s);" % dest)
+            else:
+                self.emit_line("CPy_INCREF_NO_IMM(%s);" % dest)
         # Otherwise assume it's an unboxed, pointerless value and do nothing.
 
     def emit_dec_ref(
@@ -548,7 +541,10 @@ def emit_dec_ref(
                 self.emit_line(f"CPy_{x}DecRef({dest});")
             else:
                 # Inlined
-                self.emit_line(f"CPy_{x}DECREF({dest});")
+                if rtype.may_be_immortal or not HAVE_IMMORTAL:
+                    self.emit_line(f"CPy_{x}DECREF({dest});")
+                else:
+                    self.emit_line(f"CPy_{x}DECREF_NO_IMM({dest});")
         # Otherwise assume it's an unboxed, pointerless value and do nothing.
 
     def pretty_name(self, typ: RType) -> str:
@@ -614,6 +610,7 @@ def emit_cast(
             is_list_rprimitive(typ)
             or is_dict_rprimitive(typ)
             or is_set_rprimitive(typ)
+            or is_frozenset_rprimitive(typ)
             or is_str_rprimitive(typ)
             or is_range_rprimitive(typ)
             or is_float_rprimitive(typ)
@@ -630,6 +627,8 @@ def emit_cast(
                 prefix = "PyDict"
             elif is_set_rprimitive(typ):
                 prefix = "PySet"
+            elif is_frozenset_rprimitive(typ):
+                prefix = "PyFrozenSet"
             elif is_str_rprimitive(typ):
                 prefix = "PyUnicode"
             elif is_range_rprimitive(typ):
@@ -694,7 +693,7 @@ def emit_cast(
             if likely:
                 check = f"(likely{check})"
             self.emit_arg_check(src, dest, typ, check, optional)
-            self.emit_lines(f"    {dest} = {src};".format(dest, src), "else {")
+            self.emit_lines(f"    {dest} = {src};", "else {")
             self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
             self.emit_line("}")
         elif is_none_rprimitive(typ):
@@ -909,28 +908,43 @@ 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_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:
-                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()) {{", 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:
@@ -1015,7 +1029,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) 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});")
@@ -1027,7 +1041,7 @@ def emit_box(
             self.emit_line(f"if (unlikely({dest} == NULL))")
             self.emit_line("    CPyError_OutOfMemory();")
             # TODO: Fail if dest is None
-            for i in range(0, len(typ.types)):
+            for i in range(len(typ.types)):
                 if not typ.is_unboxed:
                     self.emit_line(f"PyTuple_SET_ITEM({dest}, {i}, {src}.f{i}")
                 else:
@@ -1146,6 +1160,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/codegen/emitclass.py b/mypyc/codegen/emitclass.py
index 6a272d1aee2b..c5191e5fb939 100644
--- a/mypyc/codegen/emitclass.py
+++ b/mypyc/codegen/emitclass.py
@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import Callable, Mapping, Tuple
+from collections.abc import Mapping
+from typing import Callable
 
 from mypyc.codegen.emit import Emitter, HeaderDeclaration, ReturnHandler
 from mypyc.codegen.emitfunc import native_function_header
@@ -18,7 +19,7 @@
     generate_richcompare_wrapper,
     generate_set_del_item_wrapper,
 )
-from mypyc.common import BITMAP_BITS, BITMAP_TYPE, NATIVE_PREFIX, PREFIX, REG_PREFIX, use_fastcall
+from mypyc.common import BITMAP_BITS, BITMAP_TYPE, NATIVE_PREFIX, PREFIX, REG_PREFIX
 from mypyc.ir.class_ir import ClassIR, VTableEntries
 from mypyc.ir.func_ir import FUNC_CLASSMETHOD, FUNC_STATICMETHOD, FuncDecl, FuncIR
 from mypyc.ir.rtypes import RTuple, RType, object_rprimitive
@@ -30,16 +31,12 @@ def native_slot(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     return f"{NATIVE_PREFIX}{fn.cname(emitter.names)}"
 
 
-def wrapper_slot(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
-    return f"{PREFIX}{fn.cname(emitter.names)}"
-
-
 # We maintain a table from dunder function names to struct slots they
 # correspond to and functions that generate a wrapper (if necessary)
 # and return the function name to stick in the slot.
 # TODO: Add remaining dunder methods
 SlotGenerator = Callable[[ClassIR, FuncIR, Emitter], str]
-SlotTable = Mapping[str, Tuple[str, SlotGenerator]]
+SlotTable = Mapping[str, tuple[str, SlotGenerator]]
 
 SLOT_DEFS: SlotTable = {
     "__init__": ("tp_init", lambda c, t, e: generate_init_for_class(c, t, e)),
@@ -136,12 +133,7 @@ def wrapper_slot(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
 
 
 def generate_call_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
-    if emitter.use_vectorcall():
-        # Use vectorcall wrapper if supported (PEP 590).
-        return "PyVectorcall_Call"
-    else:
-        # On older Pythons use the legacy wrapper.
-        return wrapper_slot(cl, fn, emitter)
+    return "PyVectorcall_Call"
 
 
 def slot_key(attr: str) -> str:
@@ -204,6 +196,7 @@ def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
 
     setup_name = f"{name_prefix}_setup"
     new_name = f"{name_prefix}_new"
+    finalize_name = f"{name_prefix}_finalize"
     members_name = f"{name_prefix}_members"
     getseters_name = f"{name_prefix}_getseters"
     vtable_name = f"{name_prefix}_vtable"
@@ -213,11 +206,10 @@ def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
     methods_name = f"{name_prefix}_methods"
     vtable_setup_name = f"{name_prefix}_trait_vtable_setup"
 
-    fields: dict[str, str] = {}
-    fields["tp_name"] = f'"{name}"'
+    fields: dict[str, str] = {"tp_name": f'"{name}"'}
 
     generate_full = not cl.is_trait and not cl.builtin_base
-    needs_getseters = cl.needs_getseters or not cl.is_generated
+    needs_getseters = cl.needs_getseters or not cl.is_generated or cl.has_dict
 
     if not cl.builtin_base:
         fields["tp_new"] = new_name
@@ -226,6 +218,10 @@ def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
         fields["tp_dealloc"] = f"(destructor){name_prefix}_dealloc"
         fields["tp_traverse"] = f"(traverseproc){name_prefix}_traverse"
         fields["tp_clear"] = f"(inquiry){name_prefix}_clear"
+    # Populate .tp_finalize and generate a finalize method only if __del__ is defined for this class.
+    del_method = next((e.method for e in cl.vtable_entries if e.name == "__del__"), None)
+    if del_method:
+        fields["tp_finalize"] = f"(destructor){finalize_name}"
     if needs_getseters:
         fields["tp_getset"] = getseters_name
     fields["tp_methods"] = methods_name
@@ -270,7 +266,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 *)"
@@ -284,8 +280,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
 
@@ -305,8 +302,11 @@ def emit_line() -> None:
         emit_line()
         generate_clear_for_class(cl, clear_name, emitter)
         emit_line()
-        generate_dealloc_for_class(cl, dealloc_name, clear_name, emitter)
+        generate_dealloc_for_class(cl, dealloc_name, clear_name, bool(del_method), emitter)
         emit_line()
+        if del_method:
+            generate_finalize_for_class(del_method, finalize_name, emitter)
+            emit_line()
 
         if cl.allow_interpreted_subclasses:
             shadow_vtable_name: str | None = generate_vtables(
@@ -332,7 +332,7 @@ def emit_line() -> None:
     flags = ["Py_TPFLAGS_DEFAULT", "Py_TPFLAGS_HEAPTYPE", "Py_TPFLAGS_BASETYPE"]
     if generate_full:
         flags.append("Py_TPFLAGS_HAVE_GC")
-    if cl.has_method("__call__") and emitter.use_vectorcall():
+    if cl.has_method("__call__"):
         fields["tp_vectorcall_offset"] = "offsetof({}, vectorcall)".format(
             cl.struct_name(emitter.names)
         )
@@ -341,6 +341,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_ = {{")
@@ -378,7 +380,7 @@ def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
     seen_attrs: set[tuple[str, RType]] = set()
     lines: list[str] = []
     lines += ["typedef struct {", "PyObject_HEAD", "CPyVTableItem *vtable;"]
-    if cl.has_method("__call__") and emitter.use_vectorcall():
+    if cl.has_method("__call__"):
         lines.append("vectorcallfunc vectorcall;")
     bitmap_attrs = []
     for base in reversed(cl.base_mro):
@@ -568,17 +570,23 @@ def generate_setup_for_class(
         emitter.emit_line("}")
     else:
         emitter.emit_line(f"self->vtable = {vtable_name};")
+
     for i in range(0, len(cl.bitmap_attrs), BITMAP_BITS):
         field = emitter.bitmap_field(i)
         emitter.emit_line(f"self->{field} = 0;")
 
-    if cl.has_method("__call__") and emitter.use_vectorcall():
+    if cl.has_method("__call__"):
         name = cl.method_decl("__call__").cname(emitter.names)
         emitter.emit_line(f"self->vectorcall = {PREFIX}{name};")
 
     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:
@@ -725,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(
@@ -746,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(
@@ -761,11 +773,19 @@ def generate_clear_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -> N
 
 
 def generate_dealloc_for_class(
-    cl: ClassIR, dealloc_func_name: str, clear_func_name: str, emitter: Emitter
+    cl: ClassIR,
+    dealloc_func_name: str,
+    clear_func_name: str,
+    has_tp_finalize: bool,
+    emitter: Emitter,
 ) -> None:
     emitter.emit_line("static void")
     emitter.emit_line(f"{dealloc_func_name}({cl.struct_name(emitter.names)} *self)")
     emitter.emit_line("{")
+    if has_tp_finalize:
+        emitter.emit_line("if (!PyObject_GC_IsFinalized((PyObject *)self)) {")
+        emitter.emit_line("Py_TYPE(self)->tp_finalize((PyObject *)self);")
+        emitter.emit_line("}")
     emitter.emit_line("PyObject_GC_UnTrack(self);")
     # The trashcan is needed to handle deep recursive deallocations
     emitter.emit_line(f"CPy_TRASHCAN_BEGIN(self, {dealloc_func_name})")
@@ -775,6 +795,39 @@ def generate_dealloc_for_class(
     emitter.emit_line("}")
 
 
+def generate_finalize_for_class(
+    del_method: FuncIR, finalize_func_name: str, emitter: Emitter
+) -> None:
+    emitter.emit_line("static void")
+    emitter.emit_line(f"{finalize_func_name}(PyObject *self)")
+    emitter.emit_line("{")
+    emitter.emit_line("PyObject *type, *value, *traceback;")
+    emitter.emit_line("PyErr_Fetch(&type, &value, &traceback);")
+    emitter.emit_line(
+        "{}{}{}(self);".format(
+            emitter.get_group_prefix(del_method.decl),
+            NATIVE_PREFIX,
+            del_method.cname(emitter.names),
+        )
+    )
+    emitter.emit_line("if (PyErr_Occurred() != NULL) {")
+    emitter.emit_line('PyObject *del_str = PyUnicode_FromString("__del__");')
+    emitter.emit_line(
+        "PyObject *del_method = (del_str == NULL) ? NULL : _PyType_Lookup(Py_TYPE(self), del_str);"
+    )
+    # CPython interpreter uses PyErr_WriteUnraisable: https://docs.python.org/3/c-api/exceptions.html#c.PyErr_WriteUnraisable
+    # However, the message is slightly different due to the way mypyc compiles classes.
+    # CPython interpreter prints: Exception ignored in: <function F.__del__ at 0x100aed940>
+    # mypyc prints: Exception ignored in: <slot wrapper '__del__' of 'F' objects>
+    emitter.emit_line("PyErr_WriteUnraisable(del_method);")
+    emitter.emit_line("Py_XDECREF(del_method);")
+    emitter.emit_line("Py_XDECREF(del_str);")
+    emitter.emit_line("}")
+    # PyErr_Restore also clears exception raised in __del__.
+    emitter.emit_line("PyErr_Restore(type, value, traceback);")
+    emitter.emit_line("}")
+
+
 def generate_methods_table(cl: ClassIR, name: str, emitter: Emitter) -> None:
     emitter.emit_line(f"static PyMethodDef {name}[] = {{")
     for fn in cl.methods.values():
@@ -782,11 +835,7 @@ def generate_methods_table(cl: ClassIR, name: str, emitter: Emitter) -> None:
             continue
         emitter.emit_line(f'{{"{fn.name}",')
         emitter.emit_line(f" (PyCFunction){PREFIX}{fn.cname(emitter.names)},")
-        if use_fastcall(emitter.capi_version):
-            flags = ["METH_FASTCALL"]
-        else:
-            flags = ["METH_VARARGS"]
-        flags.append("METH_KEYWORDS")
+        flags = ["METH_FASTCALL", "METH_KEYWORDS"]
         if fn.decl.kind == FUNC_STATICMETHOD:
             flags.append("METH_STATIC")
         elif fn.decl.kind == FUNC_CLASSMETHOD:
@@ -878,6 +927,9 @@ def generate_getseters_table(cl: ClassIR, name: str, emitter: Emitter) -> None:
         else:
             emitter.emit_line("NULL, NULL, NULL},")
 
+    if cl.has_dict:
+        emitter.emit_line('{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},')
+
     emitter.emit_line("{NULL}  /* Sentinel */")
     emitter.emit_line("};")
 
@@ -1035,3 +1087,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"
+    )
diff --git a/mypyc/codegen/emitfunc.py b/mypyc/codegen/emitfunc.py
index 7e6d775d74b4..c854516825af 100644
--- a/mypyc/codegen/emitfunc.py
+++ b/mypyc/codegen/emitfunc.py
@@ -2,11 +2,19 @@
 
 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
-from mypyc.common import MODULE_PREFIX, NATIVE_PREFIX, REG_PREFIX, STATIC_PREFIX, TYPE_PREFIX
+from mypyc.common import (
+    HAVE_IMMORTAL,
+    MODULE_PREFIX,
+    NATIVE_PREFIX,
+    REG_PREFIX,
+    STATIC_PREFIX,
+    TYPE_PREFIX,
+    TYPE_VAR_PREFIX,
+)
 from mypyc.ir.class_ir import ClassIR
 from mypyc.ir.func_ir import FUNC_CLASSMETHOD, FUNC_STATICMETHOD, FuncDecl, FuncIR, all_values
 from mypyc.ir.ops import (
@@ -14,6 +22,7 @@
     NAMESPACE_MODULE,
     NAMESPACE_STATIC,
     NAMESPACE_TYPE,
+    NAMESPACE_TYPE_VAR,
     Assign,
     AssignMulti,
     BasicBlock,
@@ -47,6 +56,7 @@
     MethodCall,
     Op,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
     Return,
@@ -55,6 +65,7 @@
     Truncate,
     TupleGet,
     TupleSet,
+    Unborrow,
     Unbox,
     Unreachable,
     Value,
@@ -62,12 +73,15 @@
 from mypyc.ir.pprint import generate_names_for_ir
 from mypyc.ir.rtypes import (
     RArray,
+    RInstance,
     RStruct,
     RTuple,
     RType,
+    is_bool_rprimitive,
     is_int32_rprimitive,
     is_int64_rprimitive,
     is_int_rprimitive,
+    is_none_rprimitive,
     is_pointer_rprimitive,
     is_tagged,
 )
@@ -138,7 +152,7 @@ def generate_native_function(
             # generates them will add instructions between the branch and the
             # next label, causing the label to be wrongly removed. A better
             # solution would be to change the IR so that it adds a basic block
-            # inbetween the calls.
+            # in between the calls.
             is_problematic_op = isinstance(terminator, Branch) and any(
                 isinstance(s, GetAttr) for s in terminator.sources()
             )
@@ -260,7 +274,6 @@ def visit_tuple_set(self, op: TupleSet) -> None:
         else:
             for i, item in enumerate(op.items):
                 self.emit_line(f"{dest}.f{i} = {self.reg(item)};")
-        self.emit_inc_ref(dest, tuple_type)
 
     def visit_assign(self, op: Assign) -> None:
         dest = self.reg(op.dest)
@@ -353,20 +366,23 @@ def visit_get_attr(self, op: GetAttr) -> None:
         prefer_method = cl.is_trait and attr_rtype.error_overlap
         if cl.get_method(op.attr, prefer_method=prefer_method):
             # Properties are essentially methods, so use vtable access for them.
-            version = "_TRAIT" if cl.is_trait else ""
-            self.emit_line(
-                "%s = CPY_GET_ATTR%s(%s, %s, %d, %s, %s); /* %s */"
-                % (
-                    dest,
-                    version,
-                    obj,
-                    self.emitter.type_struct_name(rtype.class_ir),
-                    rtype.getter_index(op.attr),
-                    rtype.struct_name(self.names),
-                    self.ctype(rtype.attr_type(op.attr)),
-                    op.attr,
+            if cl.is_method_final(op.attr):
+                self.emit_method_call(f"{dest} = ", op.obj, op.attr, [])
+            else:
+                version = "_TRAIT" if cl.is_trait else ""
+                self.emit_line(
+                    "%s = CPY_GET_ATTR%s(%s, %s, %d, %s, %s); /* %s */"
+                    % (
+                        dest,
+                        version,
+                        obj,
+                        self.emitter.type_struct_name(rtype.class_ir),
+                        rtype.getter_index(op.attr),
+                        rtype.struct_name(self.names),
+                        self.ctype(rtype.attr_type(op.attr)),
+                        op.attr,
+                    )
                 )
-            )
         else:
             # Otherwise, use direct or offset struct access.
             attr_expr = self.get_attr_expr(obj, op, decl_cl)
@@ -476,6 +492,7 @@ def visit_set_attr(self, op: SetAttr) -> None:
         NAMESPACE_STATIC: STATIC_PREFIX,
         NAMESPACE_TYPE: TYPE_PREFIX,
         NAMESPACE_MODULE: MODULE_PREFIX,
+        NAMESPACE_TYPE_VAR: TYPE_VAR_PREFIX,
     }
 
     def visit_load_static(self, op: LoadStatic) -> None:
@@ -499,7 +516,8 @@ def visit_tuple_get(self, op: TupleGet) -> None:
         dest = self.reg(op)
         src = self.reg(op.src)
         self.emit_line(f"{dest} = {src}.f{op.index};")
-        self.emit_inc_ref(dest, op.type)
+        if not op.is_borrowed:
+            self.emit_inc_ref(dest, op.type)
 
     def get_dest_assign(self, dest: Value) -> str:
         if not dest.is_void:
@@ -518,11 +536,13 @@ def visit_call(self, op: Call) -> None:
     def visit_method_call(self, op: MethodCall) -> None:
         """Call native method."""
         dest = self.get_dest_assign(op)
-        obj = self.reg(op.obj)
+        self.emit_method_call(dest, op.obj, op.method, op.args)
 
-        rtype = op.receiver_type
+    def emit_method_call(self, dest: str, op_obj: Value, name: str, op_args: list[Value]) -> None:
+        obj = self.reg(op_obj)
+        rtype = op_obj.type
+        assert isinstance(rtype, RInstance)
         class_ir = rtype.class_ir
-        name = op.method
         method = rtype.class_ir.get_method(name)
         assert method is not None
 
@@ -534,11 +554,9 @@ def visit_method_call(self, op: MethodCall) -> None:
         obj_args = (
             []
             if method.decl.kind == FUNC_STATICMETHOD
-            else [f"(PyObject *)Py_TYPE({obj})"]
-            if method.decl.kind == FUNC_CLASSMETHOD
-            else [obj]
+            else [f"(PyObject *)Py_TYPE({obj})"] if method.decl.kind == FUNC_CLASSMETHOD else [obj]
         )
-        args = ", ".join(obj_args + [self.reg(arg) for arg in op.args])
+        args = ", ".join(obj_args + [self.reg(arg) for arg in op_args])
         mtype = native_function_type(method, self.emitter)
         version = "_TRAIT" if rtype.class_ir.is_trait else ""
         if is_direct:
@@ -558,11 +576,26 @@ def visit_method_call(self, op: MethodCall) -> None:
                     rtype.struct_name(self.names),
                     mtype,
                     args,
-                    op.method,
+                    name,
                 )
             )
 
     def visit_inc_ref(self, op: IncRef) -> None:
+        if (
+            isinstance(op.src, Box)
+            and (is_none_rprimitive(op.src.src.type) or is_bool_rprimitive(op.src.src.type))
+            and HAVE_IMMORTAL
+        ):
+            # On Python 3.12+, None/True/False are immortal, and we can skip inc ref
+            return
+
+        if isinstance(op.src, LoadLiteral) and HAVE_IMMORTAL:
+            value = op.src.value
+            # We can skip inc ref for immortal literals on Python 3.12+
+            if type(value) is int and -5 <= value <= 256:
+                # Small integers are immortal
+                return
+
         src = self.reg(op.src)
         self.emit_inc_ref(src, op.src.type)
 
@@ -630,6 +663,11 @@ def visit_call_c(self, op: CallC) -> None:
         args = ", ".join(self.reg(arg) for arg in op.args)
         self.emitter.emit_line(f"{dest}{op.function_name}({args});")
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> None:
+        raise RuntimeError(
+            f"unexpected PrimitiveOp {op.desc.name}: they must be lowered before codegen"
+        )
+
     def visit_truncate(self, op: Truncate) -> None:
         dest = self.reg(op)
         value = self.reg(op.src)
@@ -686,10 +724,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 +738,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)
@@ -746,6 +784,12 @@ def visit_keep_alive(self, op: KeepAlive) -> None:
         # This is a no-op.
         pass
 
+    def visit_unborrow(self, op: Unborrow) -> None:
+        # This is a no-op that propagates the source value.
+        dest = self.reg(op)
+        src = self.reg(op.src)
+        self.emit_line(f"{dest} = {src};")
+
     # Helpers
 
     def label(self, label: BasicBlock) -> str:
diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py
index 0e80ff6da1f2..b8a19ac1d669 100644
--- a/mypyc/codegen/emitmodule.py
+++ b/mypyc/codegen/emitmodule.py
@@ -7,7 +7,8 @@
 
 import json
 import os
-from typing import Iterable, List, Optional, Tuple, TypeVar
+from collections.abc import Iterable
+from typing import Optional, TypeVar
 
 from mypy.build import (
     BuildResult,
@@ -24,7 +25,7 @@
 from mypy.nodes import MypyFile
 from mypy.options import Options
 from mypy.plugin import Plugin, ReportConfigContext
-from mypy.util import hash_digest
+from mypy.util import hash_digest, json_dumps
 from mypyc.codegen.cstring import c_string_initializer
 from mypyc.codegen.emit import Emitter, EmitterContext, HeaderDeclaration, c_array_initializer
 from mypyc.codegen.emitclass import generate_class, generate_class_type_decl
@@ -41,24 +42,26 @@
     PREFIX,
     RUNTIME_C_FILES,
     TOP_LEVEL_NAME,
+    TYPE_VAR_PREFIX,
     shared_lib_name,
     short_id_from_name,
-    use_fastcall,
-    use_vectorcall,
 )
 from mypyc.errors import Errors
-from mypyc.ir.class_ir import ClassIR
 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
 from mypyc.namegen import NameGenerator, exported_name
 from mypyc.options import CompilerOptions
+from mypyc.transform.copy_propagation import do_copy_propagation
 from mypyc.transform.exceptions import insert_exception_handling
+from mypyc.transform.flag_elimination import do_flag_elimination
+from mypyc.transform.lower import lower_ir
 from mypyc.transform.refcount import insert_ref_count_opcodes
+from mypyc.transform.spill import insert_spills
 from mypyc.transform.uninit import insert_uninit_checks
 
 # All of the modules being compiled are divided into "groups". A group
@@ -81,11 +84,11 @@
 # its modules along with the name of the group. (Which can be None
 # only if we are compiling only a single group with a single file in it
 # and not using shared libraries).
-Group = Tuple[List[BuildSource], Optional[str]]
-Groups = List[Group]
+Group = tuple[list[BuildSource], Optional[str]]
+Groups = list[Group]
 
 # A list of (file name, file contents) pairs.
-FileContents = List[Tuple[str, str]]
+FileContents = list[tuple[str, str]]
 
 
 class MarkedDeclaration:
@@ -151,7 +154,7 @@ def report_config_data(self, ctx: ReportConfigContext) -> tuple[str | None, list
         ir_data = json.loads(ir_json)
 
         # Check that the IR cache matches the metadata cache
-        if compute_hash(meta_json) != ir_data["meta_hash"]:
+        if hash_digest(meta_json) != ir_data["meta_hash"]:
             return None
 
         # Check that all of the source files are present and as
@@ -226,19 +229,30 @@ def compile_scc_to_ir(
     if errors.num_errors > 0:
         return modules
 
-    # Insert uninit checks.
+    env_user_functions = {}
     for module in modules.values():
-        for fn in module.functions:
-            insert_uninit_checks(fn)
-    # Insert exception handling.
+        for cls in module.classes:
+            if cls.env_user_function:
+                env_user_functions[cls.env_user_function] = cls
+
     for module in modules.values():
         for fn in module.functions:
+            # Insert uninit checks.
+            insert_uninit_checks(fn)
+            # Insert exception handling.
             insert_exception_handling(fn)
-    # Insert refcount handling.
-    for module in modules.values():
-        for fn in module.functions:
+            # Insert refcount handling.
             insert_ref_count_opcodes(fn)
 
+            if fn in env_user_functions:
+                insert_spills(fn, env_user_functions[fn])
+
+            # Switch to lower abstraction level IR.
+            lower_ir(fn, compiler_options)
+            # Perform optimizations.
+            do_copy_propagation(fn, compiler_options)
+            do_flag_elimination(fn, compiler_options)
+
     return modules
 
 
@@ -365,11 +379,11 @@ def write_cache(
         newpath = get_state_ir_cache_name(st)
         ir_data = {
             "ir": module.serialize(),
-            "meta_hash": compute_hash(meta_data),
+            "meta_hash": hash_digest(meta_data),
             "src_hashes": hashes[group_map[id]],
         }
 
-        result.manager.metastore.write(newpath, json.dumps(ir_data, separators=(",", ":")))
+        result.manager.metastore.write(newpath, json_dumps(ir_data))
 
     result.manager.metastore.commit()
 
@@ -394,7 +408,7 @@ def load_scc_from_cache(
 
 def compile_modules_to_c(
     result: BuildResult, compiler_options: CompilerOptions, errors: Errors, groups: Groups
-) -> tuple[ModuleIRs, list[FileContents]]:
+) -> tuple[ModuleIRs, list[FileContents], Mapper]:
     """Compile Python module(s) to the source of Python C extension modules.
 
     This generates the source code for the "shared library" module
@@ -423,12 +437,13 @@ def compile_modules_to_c(
     )
 
     modules = compile_modules_to_ir(result, mapper, compiler_options, errors)
-    ctext = compile_ir_to_c(groups, modules, result, mapper, compiler_options)
+    if errors.num_errors > 0:
+        return {}, [], Mapper({})
 
-    if errors.num_errors == 0:
-        write_cache(modules, result, group_map, ctext)
+    ctext = compile_ir_to_c(groups, modules, result, mapper, compiler_options)
+    write_cache(modules, result, group_map, ctext)
 
-    return modules, [ctext[name] for _, name in groups]
+    return modules, [ctext[name] for _, name in groups], mapper
 
 
 def generate_function_declaration(fn: FuncIR, emitter: Emitter) -> None:
@@ -586,6 +601,7 @@ def generate_c_for_modules(self) -> list[tuple[str, str]]:
             self.declare_finals(module_name, module.final_names, declarations)
             for cl in module.classes:
                 generate_class_type_decl(cl, emitter, ext_declarations, declarations)
+            self.declare_type_vars(module_name, module.type_var_names, declarations)
             for fn in module.functions:
                 generate_function_declaration(fn, declarations)
 
@@ -994,7 +1010,7 @@ def _toposort_visit(name: str) -> None:
             result.append(decl.declaration)
             decl.mark = True
 
-        for name, marked_declaration in marked_declarations.items():
+        for name in marked_declarations:
             _toposort_visit(name)
 
         return result
@@ -1052,30 +1068,21 @@ 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:
         symbol = emitter.static_name(identifier, None)
         self.declare_global("PyObject *", symbol)
 
-
-def sort_classes(classes: list[tuple[str, ClassIR]]) -> list[tuple[str, ClassIR]]:
-    mod_name = {ir: name for name, ir in classes}
-    irs = [ir for _, ir in classes]
-    deps: dict[ClassIR, set[ClassIR]] = {}
-    for ir in irs:
-        if ir not in deps:
-            deps[ir] = set()
-        if ir.base:
-            deps[ir].add(ir.base)
-        deps[ir].update(ir.traits)
-    sorted_irs = toposort(deps)
-    return [(mod_name[ir], ir) for ir in sorted_irs]
+    def declare_type_vars(self, module: str, type_var_names: list[str], emitter: Emitter) -> None:
+        for name in type_var_names:
+            static_name = emitter.static_name(name, module, prefix=TYPE_VAR_PREFIX)
+            emitter.context.declarations[static_name] = HeaderDeclaration(
+                f"PyObject *{static_name};",
+                [f"PyObject *{static_name} = NULL;"],
+                needs_export=False,
+            )
 
 
 T = TypeVar("T")
@@ -1109,10 +1116,10 @@ def is_fastcall_supported(fn: FuncIR, capi_version: tuple[int, int]) -> bool:
     if fn.class_name is not None:
         if fn.name == "__call__":
             # We can use vectorcalls (PEP 590) when supported
-            return use_vectorcall(capi_version)
+            return True
         # TODO: Support fastcall for __init__.
-        return use_fastcall(capi_version) and fn.name != "__init__"
-    return use_fastcall(capi_version)
+        return fn.name != "__init__"
+    return True
 
 
 def collect_literals(fn: FuncIR, literals: Literals) -> None:
diff --git a/mypyc/codegen/emitwrapper.py b/mypyc/codegen/emitwrapper.py
index 791e856c274a..1918c946772c 100644
--- a/mypyc/codegen/emitwrapper.py
+++ b/mypyc/codegen/emitwrapper.py
@@ -12,7 +12,7 @@
 
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 from mypy.nodes import ARG_NAMED, ARG_NAMED_OPT, ARG_OPT, ARG_POS, ARG_STAR, ARG_STAR2, ArgKind
 from mypy.operators import op_methods_to_symbols, reverse_op_method_names, reverse_op_methods
@@ -24,7 +24,6 @@
     NATIVE_PREFIX,
     PREFIX,
     bitmap_name,
-    use_vectorcall,
 )
 from mypyc.ir.class_ir import ClassIR
 from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncIR, RuntimeArg
@@ -145,7 +144,7 @@ def generate_wrapper_function(
     real_args = list(fn.args)
     if fn.sig.num_bitmap_args:
         real_args = real_args[: -fn.sig.num_bitmap_args]
-    if fn.class_name and not fn.decl.kind == FUNC_STATICMETHOD:
+    if fn.class_name and fn.decl.kind != FUNC_STATICMETHOD:
         arg = real_args.pop(0)
         emitter.emit_line(f"PyObject *obj_{arg.name} = self;")
 
@@ -173,7 +172,7 @@ def generate_wrapper_function(
         arg_ptrs += [f"&obj_{groups[ARG_STAR2][0].name}" if groups[ARG_STAR2] else "NULL"]
     arg_ptrs += [f"&obj_{arg.name}" for arg in reordered_args]
 
-    if fn.name == "__call__" and use_vectorcall(emitter.capi_version):
+    if fn.name == "__call__":
         nargs = "PyVectorcall_NARGS(nargs)"
     else:
         nargs = "nargs"
@@ -238,7 +237,7 @@ def generate_legacy_wrapper_function(
     real_args = list(fn.args)
     if fn.sig.num_bitmap_args:
         real_args = real_args[: -fn.sig.num_bitmap_args]
-    if fn.class_name and not fn.decl.kind == FUNC_STATICMETHOD:
+    if fn.class_name and fn.decl.kind != FUNC_STATICMETHOD:
         arg = real_args.pop(0)
         emitter.emit_line(f"PyObject *obj_{arg.name} = self;")
 
diff --git a/mypyc/codegen/literals.py b/mypyc/codegen/literals.py
index 8f84089221c3..4cd41e0f4d32 100644
--- a/mypyc/codegen/literals.py
+++ b/mypyc/codegen/literals.py
@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from typing import FrozenSet, List, Tuple, Union
-from typing_extensions import Final, TypeGuard
+from typing import Final, 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.
 LiteralValue = Union[
-    str, bytes, int, bool, float, complex, Tuple[object, ...], FrozenSet[object], None
+    str, bytes, int, bool, float, complex, tuple[object, ...], frozenset[object], None
 ]
 
 
@@ -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(
@@ -230,7 +230,7 @@ def format_int(n: int) -> bytes:
 
 
 def format_str_literal(s: str) -> bytes:
-    utf8 = s.encode("utf-8")
+    utf8 = s.encode("utf-8", errors="surrogatepass")
     return format_int(len(utf8)) + utf8
 
 
diff --git a/mypyc/common.py b/mypyc/common.py
index 05e13370cb98..992376472086 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, Final
 
 from mypy.util import unnamed_function
 
@@ -14,6 +13,7 @@
 STATIC_PREFIX: Final = "CPyStatic_"  # Static variables (for literals etc.)
 TYPE_PREFIX: Final = "CPyType_"  # Type object struct
 MODULE_PREFIX: Final = "CPyModule_"  # Cached modules
+TYPE_VAR_PREFIX: Final = "CPyTypeVar_"  # Type variables when using new-style Python 3.12 syntax
 ATTR_PREFIX: Final = "_"  # Attributes
 
 ENV_ATTR_NAME: Final = "__mypyc_env__"
@@ -79,10 +79,17 @@
     "exc_ops.c",
     "misc_ops.c",
     "generic_ops.c",
+    "pythonsupport.c",
 ]
 
+# Python 3.12 introduced immortal objects, specified via a special reference count
+# value. The reference counts of immortal objects are normally not modified, but it's
+# not strictly wrong to modify them. See PEP 683 for more information, but note that
+# some details in the PEP are out of date.
+HAVE_IMMORTAL: Final = sys.version_info >= (3, 12)
 
-JsonDict = Dict[str, Any]
+
+JsonDict = dict[str, Any]
 
 
 def shared_lib_name(group_name: str) -> str:
@@ -99,21 +106,6 @@ def short_name(name: str) -> str:
     return name
 
 
-def use_fastcall(capi_version: tuple[int, int]) -> bool:
-    # We can use METH_FASTCALL for faster wrapper functions on Python 3.7+.
-    return capi_version >= (3, 7)
-
-
-def use_vectorcall(capi_version: tuple[int, int]) -> bool:
-    # We can use vectorcalls to make calls on Python 3.8+ (PEP 590).
-    return capi_version >= (3, 8)
-
-
-def use_method_vectorcall(capi_version: tuple[int, int]) -> bool:
-    # We can use a dedicated vectorcall API to call methods on Python 3.9+.
-    return capi_version >= (3, 9)
-
-
 def get_id_from_name(name: str, fullname: str, line: int) -> str:
     """Create a unique id for a function.
 
diff --git a/mypyc/crash.py b/mypyc/crash.py
index 19136ea2f1de..1227aa8978af 100644
--- a/mypyc/crash.py
+++ b/mypyc/crash.py
@@ -2,8 +2,9 @@
 
 import sys
 import traceback
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator, NoReturn
+from typing import NoReturn
 
 
 @contextmanager
diff --git a/mypyc/doc/bytes_operations.rst b/mypyc/doc/bytes_operations.rst
new file mode 100644
index 000000000000..038da6391949
--- /dev/null
+++ b/mypyc/doc/bytes_operations.rst
@@ -0,0 +1,46 @@
+.. _bytes-ops:
+
+Native bytes operations
+========================
+
+These ``bytes`` operations have fast, optimized implementations. Other
+bytes operations use generic implementations that are often slower.
+
+Construction
+------------
+
+* Bytes literal
+* ``bytes(x: list)``
+
+Operators
+---------
+
+* Concatenation (``b1 + b2``)
+* Indexing (``b[n]``)
+* Slicing (``b[n:m]``, ``b[n:]``, ``b[:m]``)
+* Comparisons (``==``, ``!=``)
+
+.. _bytes-methods:
+
+Methods
+-------
+
+* ``b.decode()``
+* ``b.decode(encoding: str)``
+* ``b.decode(encoding: str, errors: str)``
+* ``b.join(x: Iterable)``
+
+.. note::
+
+    :ref:`str.encode() <str-methods>` is also optimized.
+
+Formatting
+----------
+
+A subset of % formatting operations are optimized (``b"..." % (...)``).
+
+Functions
+---------
+
+* ``len(b: bytes)``
+* ``ord(b: bytes)``
diff --git a/mypyc/doc/conf.py b/mypyc/doc/conf.py
index da887e0d8267..fdd98c12a221 100644
--- a/mypyc/doc/conf.py
+++ b/mypyc/doc/conf.py
@@ -36,7 +36,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 = []  # type: ignore[var-annotated]
+extensions: list[str] = []
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["_templates"]
diff --git a/mypyc/doc/dev-intro.md b/mypyc/doc/dev-intro.md
index d11df7068e91..5b248214a3eb 100644
--- a/mypyc/doc/dev-intro.md
+++ b/mypyc/doc/dev-intro.md
@@ -4,6 +4,14 @@ This is a short introduction aimed at anybody who is interested in
 contributing to mypyc, or anybody who is curious to understand how
 mypyc works internally.
 
+## Developer Documentation in the Wiki
+
+We have more mypyc developer documentation in our
+[wiki](https://github.com/python/mypy/wiki/Developer-Guides).
+
+For basic information common to both mypy and mypyc development, refer
+to the [mypy wiki home page](https://github.com/python/mypy/wiki).
+
 ## Key Differences from Python
 
 Code compiled using mypyc is often much faster than CPython since it
@@ -51,11 +59,9 @@ good error message.
 
 Here are some major things that aren't yet supported in compiled code:
 
-* Many dunder methods (only some work, such as `__init__` and `__eq__`)
+* Some dunder methods (most work though)
 * Monkey patching compiled functions or classes
 * General multiple inheritance (a limited form is supported)
-* Named tuple defined using the class-based syntax
-* Defining protocols
 
 We are generally happy to accept contributions that implement new Python
 features.
@@ -73,16 +79,16 @@ compiled code. For example, you may want to do interactive testing or
 to run benchmarks. This is also handy if you want to inspect the
 generated C code (see Inspecting Generated C).
 
-Run `mypyc` to compile a module to a C extension using your
+Run `python -m mypyc` to compile a module to a C extension using your
 development version of mypyc:
 
 ```
-$ mypyc program.py
+$ python -m mypyc program.py
 ```
 
 This will generate a C extension for `program` in the current working
-directory.  For example, on a Linux system the generated file may be
-called `program.cpython-37m-x86_64-linux-gnu.so`.
+directory.  For example, on a macOS system the generated file may be
+called `program.cpython-313-darwin.so`.
 
 Since C extensions can't be run as programs, use `python3 -c` to run
 the compiled module as a program:
@@ -95,7 +101,7 @@ Note that `__name__` in `program.py` will now be `program`, not
 `__main__`!
 
 You can manually delete the C extension to get back to an interpreted
-version (this example works on Linux):
+version (this example works on macOS or Linux):
 
 ```
 $ rm program.*.so
@@ -114,9 +120,9 @@ extensions) in compiled code.
 
 Mypyc will only make compiled code faster. To see a significant
 speedup, you must make sure that most of the time is spent in compiled
-code -- and not in libraries, for example.
+code, and not in libraries or I/O.
 
-Mypyc has these passes:
+Mypyc has these main passes:
 
 * Type check the code using mypy and infer types for variables and
   expressions.  This produces a mypy AST (defined in `mypy.nodes`) and
@@ -193,15 +199,19 @@ information. See the test cases in
 `mypyc/test-data/irbuild-basic.test` for examples of what the IR looks
 like in a pretty-printed form.
 
-## Testing overview
+## Testing Overview
 
 Most mypyc test cases are defined in the same format (`.test`) as used
 for test cases for mypy. Look at mypy developer documentation for a
 general overview of how things work. Test cases live under
 `mypyc/test-data/`, and you can run all mypyc tests via `pytest
--q mypyc`. If you don't make changes to code under `mypy/`, it's not
+ mypyc`. If you don't make changes to code under `mypy/`, it's not
 important to regularly run mypy tests during development.
 
+You can use `python runtests.py mypyc-fast` to run a subset of mypyc
+tests that covers most functionality but runs significantly quicker
+than the entire test suite.
+
 When you create a PR, we have Continuous Integration jobs set up that
 compile mypy using mypyc and run the mypy test suite using the
 compiled mypy. This will sometimes catch additional issues not caught
@@ -219,12 +229,12 @@ pretty-printed IR into `build/ops.txt`. This is the final IR that
 includes the output from exception and reference count handling
 insertion passes.
 
-We also have tests that verify the generate IR
+We also have tests that verify the generated IR
 (`mypyc/test-data/irbuild-*.text`).
 
 ## Type-checking Mypyc
 
-`./runtests.py self` type checks mypy and mypyc. This is pretty slow,
+`./runtests.py self` type checks mypy and mypyc. This is a little slow,
 however, since it's using an uncompiled mypy.
 
 Installing a released version of mypy using `pip` (which is compiled)
@@ -280,12 +290,28 @@ under `mypyc/lib-rt`.
 
 ## Inspecting Generated C
 
-It's often useful to inspect the C code genenerate by mypyc to debug
+It's often useful to inspect the C code generated by mypyc to debug
 issues.  Mypyc stores the generated C code as `build/__native.c`.
 Compiled native functions have the prefix `CPyDef_`, while wrapper
 functions used for calling functions from interpreted Python code have
 the `CPyPy_` prefix.
 
+When running a test, the first test failure will copy generated C code
+into the `.mypyc_test_output` directory. You will see something like
+this in the test output:
+
+```
+...
+---------------------------- Captured stderr call -----------------------------
+
+Generated files: /Users/me/src/mypy/.mypyc_test_output (for first failure only)
+
+...
+```
+
+You can also run pytest with `--mypyc-showc` to display C code on every
+test failure.
+
 ## Other Important Limitations
 
 All of these limitations will likely be fixed in the future:
@@ -307,7 +333,7 @@ number of components at once, insensitive to the particular details of
 the IR), but there really is no substitute for running code. You can
 also write tests that test the generated IR, however.
 
-### Tests that compile and run code
+### Tests That Compile and Run Code
 
 Test cases that compile and run code are located in
 `mypyc/test-data/run*.test` and the test runner is in
@@ -360,7 +386,74 @@ Test cases can also have a `[out]` section, which specifies the
 expected contents of stdout the test case should produce. New test
 cases should prefer assert statements to `[out]` sections.
 
-### IR tests
+### Adding Debug Prints and Editing Generated C
+
+Sometimes it's helpful to add some debug prints or other debugging helpers
+to the generated C code. You can run mypyc using `--skip-c-gen` to skip the C
+generation step, so all manual changes to C files are preserved. Here is
+an example of how to use the workflow:
+
+* Compile some file you want to debug: `python -m mypyc foo.py`.
+* Add debug prints to the generated C in `build/__native.c`.
+* Run the same compilation command line again, but add `--skip-c-gen`:
+  `python -m mypyc --skip-c-gen foo.py`. This will only rebuild the
+  binaries.
+* Run the compiled code, including your changes: `python -c 'import foo'`.
+  You should now see the output from the debug prints you added.
+
+This can also be helpful if you want to quickly experiment with different
+implementation techniques, without having to first figure out how to
+modify mypyc to generate the desired C code.
+
+### Debugging Segfaults
+
+If you experience a segfault, it's recommended to use a debugger that supports
+C, such as gdb or lldb, to look into the segfault.
+
+If a test case segfaults, you can run tests using the debugger, so
+you can inspect the stack. Example of inspecting the C stack when a
+test case segfaults (user input after `$` and `(gdb)` prompts):
+
+```
+$ pytest mypyc -n0 -s --mypyc-debug=gdb -k <name-of-test>
+...
+(gdb) r
+...
+Program received signal SIGSEGV, Segmentation fault.
+...
+(gdb) bt
+#0  0x00005555556ed1a2 in _PyObject_HashFast (op=0x0) at ./Include/object.h:336
+#1  PyDict_GetItemWithError (op=0x7ffff6c894c0, key=0x0) at Objects/dictobject.c:2394
+...
+```
+
+You must use `-n0 -s` to enable interactive input to the debugger.
+Instead of `gdb`, you can also try `lldb` (especially on macOS).
+
+To get better C stack tracebacks and more assertions in the Python
+runtime, you can build Python in debug mode and use that to run tests,
+or to manually run the debugger outside the test framework.
+
+**Note:** You may need to build Python yourself on macOS, as official
+Python builds may not have sufficient entitlements to use a debugger.
+
+Here are some hints about building a debug version of CPython that may
+help (for Ubuntu, macOS is mostly similar except for installing build
+dependencies):
+
+```
+$ sudo apt install gdb build-essential libncursesw5-dev libssl-dev libgdbm-dev libc6-dev libsqlite3-dev libbz2-dev libffi-dev libgdbm-compat-dev
+$ <download Python tarball and extract it>
+$ cd Python-3.XX.Y
+$ ./configure --with-pydebug
+$ make -s -j16
+$ ./python -m venv ~/<venv-location>  # Use ./python.exe -m venv ... on macOS
+$ source ~/<venv-location>/bin/activate
+$ cd <mypy-repo-dir>
+$ pip install -r test-requirements.txt
+```
+
+### IR Tests
 
 If the specifics of the generated IR of a change is important
 (because, for example, you want to make sure a particular optimization
@@ -368,7 +461,7 @@ is triggering), you should add a `mypyc.irbuild` test as well.  Test
 cases are located in `mypyc/test-data/irbuild-*.test` and the test
 driver is in `mypyc.test.test_irbuild`. IR build tests do a direct
 comparison of the IR output, so try to make the test as targeted as
-possible so as to capture only the important details.  (Many of our
+possible so as to capture only the important details.  (Some of our
 existing IR build tests do not follow this advice, unfortunately!)
 
 If you pass the `--update-data` flag to pytest, it will automatically
diff --git a/mypyc/doc/dict_operations.rst b/mypyc/doc/dict_operations.rst
index e3104172133a..6858cd33e8a7 100644
--- a/mypyc/doc/dict_operations.rst
+++ b/mypyc/doc/dict_operations.rst
@@ -50,6 +50,8 @@ Methods
 * ``d.items()``
 * ``d.copy()``
 * ``d.clear()``
+* ``d.setdefault(key)``
+* ``d.setdefault(key, value)``
 * ``d1.update(d2: dict)``
 * ``d.update(x: Iterable)``
 
diff --git a/mypyc/doc/differences_from_python.rst b/mypyc/doc/differences_from_python.rst
index 16faae60303f..65ad709677af 100644
--- a/mypyc/doc/differences_from_python.rst
+++ b/mypyc/doc/differences_from_python.rst
@@ -107,7 +107,7 @@ performance.
 integer values. A side effect of this is that the exact runtime type of
 ``int`` values is lost. For example, consider this simple function::
 
-    def first_int(x: List[int]) -> int:
+    def first_int(x: list[int]) -> int:
         return x[0]
 
     print(first_int([True]))  # Output is 1, instead of True!
@@ -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/float_operations.rst b/mypyc/doc/float_operations.rst
index 915c184ae8e7..feae5a806c70 100644
--- a/mypyc/doc/float_operations.rst
+++ b/mypyc/doc/float_operations.rst
@@ -14,6 +14,8 @@ Construction
 * ``float(x: int)``
 * ``float(x: i64)``
 * ``float(x: i32)``
+* ``float(x: i16)``
+* ``float(x: u8)``
 * ``float(x: str)``
 * ``float(x: float)`` (no-op)
 
@@ -28,8 +30,10 @@ 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)
+* ``u8(f)`` (convert to 8-bit unsigned integer)
 * ``abs(f)``
 * ``math.sin(f)``
 * ``math.cos(f)``
diff --git a/mypyc/doc/frozenset_operations.rst b/mypyc/doc/frozenset_operations.rst
new file mode 100644
index 000000000000..3d946a8fa9a3
--- /dev/null
+++ b/mypyc/doc/frozenset_operations.rst
@@ -0,0 +1,29 @@
+.. _frozenset-ops:
+
+Native frozenset operations
+===========================
+
+These ``frozenset`` operations have fast, optimized implementations. Other
+frozenset operations use generic implementations that are often slower.
+
+Construction
+------------
+
+Construct empty frozenset:
+
+* ``frozenset()``
+
+Construct frozenset from iterable:
+
+* ``frozenset(x: Iterable)``
+
+
+Operators
+---------
+
+* ``item in s``
+
+Functions
+---------
+
+* ``len(s: set)``
diff --git a/mypyc/doc/getting_started.rst b/mypyc/doc/getting_started.rst
index 2db8aae149ec..f85981f08d02 100644
--- a/mypyc/doc/getting_started.rst
+++ b/mypyc/doc/getting_started.rst
@@ -38,17 +38,17 @@ Installation
 ------------
 
 Mypyc is shipped as part of the mypy distribution. Install mypy like
-this (you need Python 3.5 or later):
+this (you need Python 3.9 or later):
 
 .. code-block::
 
-    $ python3 -m pip install -U mypy
+    $ python3 -m pip install -U 'mypy[mypyc]'
 
 On some systems you need to use this instead:
 
 .. code-block::
 
-    $ python -m pip install -U mypy
+    $ python -m pip install -U 'mypy[mypyc]'
 
 Example program
 ---------------
diff --git a/mypyc/doc/index.rst b/mypyc/doc/index.rst
index 5b1cc48fab3d..094e0f8cd9b8 100644
--- a/mypyc/doc/index.rst
+++ b/mypyc/doc/index.rst
@@ -36,10 +36,12 @@ generate fast code.
    bool_operations
    float_operations
    str_operations
+   bytes_operations
    list_operations
    dict_operations
    set_operations
    tuple_operations
+   frozenset_operations
 
 .. toctree::
    :maxdepth: 2
diff --git a/mypyc/doc/int_operations.rst b/mypyc/doc/int_operations.rst
index 058fdbd511dd..eb875f5c9452 100644
--- a/mypyc/doc/int_operations.rst
+++ b/mypyc/doc/int_operations.rst
@@ -8,14 +8,17 @@ Mypyc supports these integer types:
 * ``int`` (arbitrary-precision integer)
 * ``i64`` (64-bit signed integer)
 * ``i32`` (32-bit signed integer)
+* ``i16`` (16-bit signed integer)
+* ``u8`` (8-bit unsigned integer)
 
-``i64`` and ``i32`` 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.
+``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
+require range or bounds checks.
 
 Operations on integers that are listed here have fast, optimized
 implementations. Other integer operations use generic implementations
@@ -31,6 +34,8 @@ Construction
 * ``int(x: float)``
 * ``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)
@@ -39,19 +44,34 @@ 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:
+
+* ``i16(x: int)``
+* ``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)``
 
 Conversions from ``int`` to a native integer type raise
 ``OverflowError`` if the value is too large or small. Conversions from
@@ -65,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
@@ -92,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/list_operations.rst b/mypyc/doc/list_operations.rst
index 5993c0a656bd..bb4681266cab 100644
--- a/mypyc/doc/list_operations.rst
+++ b/mypyc/doc/list_operations.rst
@@ -32,7 +32,8 @@ Operators
 
 * ``lst[n]`` (get item by integer index)
 * ``lst[n:m]``, ``lst[n:]``, ``lst[:m]``, ``lst[:]`` (slicing)
-* ``lst * n``, ``n * lst``
+* ``lst1 + lst2``, ``lst += iter``
+* ``lst * n``, ``n * lst``, ``lst *= n``
 * ``obj in lst``
 
 Statements
diff --git a/mypyc/doc/native_classes.rst b/mypyc/doc/native_classes.rst
index 2b4a0892b790..dbcf238b78d5 100644
--- a/mypyc/doc/native_classes.rst
+++ b/mypyc/doc/native_classes.rst
@@ -48,15 +48,17 @@ can be assigned to (similar to using ``__slots__``)::
 Inheritance
 -----------
 
-Only single inheritance is supported (except for :ref:`traits
-<trait-types>`). Most non-native classes can't be used as base
-classes.
+Only single inheritance is supported from native classes (except for
+:ref:`traits <trait-types>`). Most non-native extension classes can't
+be used as base classes, but regular Python classes can be used as
+base classes unless they use unsupported metaclasses (see below for
+more about this).
 
-These non-native classes can be used as base classes of native
+These non-native extension classes can be used as base classes of native
 classes:
 
 * ``object``
-* ``dict`` (and ``Dict[k, v]``)
+* ``dict`` (and ``dict[k, v]``)
 * ``BaseException``
 * ``Exception``
 * ``ValueError``
@@ -87,6 +89,15 @@ You need to install ``mypy-extensions`` to use ``@mypyc_attr``:
 
     pip install --upgrade mypy-extensions
 
+Additionally, mypyc recognizes these base classes as special, and
+understands how they alter the behavior of classes (including native
+classes) that subclass them:
+
+* ``typing.NamedTuple``
+* ``typing.Generic``
+* ``typing.Protocol``
+* ``enum.Enum``
+
 Class variables
 ---------------
 
@@ -104,6 +115,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
 ----------------------
 
@@ -138,7 +154,8 @@ behavior is too dynamic. You can use these metaclasses, however:
 .. note::
 
    If a class definition uses an unsupported metaclass, *mypyc
-   compiles the class into a regular Python class*.
+   compiles the class into a regular Python class* (non-native
+   class).
 
 Class decorators
 ----------------
@@ -150,14 +167,71 @@ 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::
 
    If a class definition uses an unsupported class decorator, *mypyc
-   compiles the class into a regular Python class*.
+   compiles the class into a regular Python class* (non-native class).
+
+Defining non-native classes
+---------------------------
+
+You can use the ``@mypy_extensions.mypyc_attr(...)`` class decorator
+with an argument ``native_class=False`` to explicitly define normal
+Python classes (non-native classes)::
+
+    from mypy_extensions import mypyc_attr
+
+    @mypyc_attr(native_class=False)
+    class NonNative:
+        def __init__(self) -> None:
+            self.attr = 1
+
+    setattr(NonNative, "extra", 1)  # Ok
+
+This only has an effect in classes compiled using mypyc. Non-native
+classes are significantly less efficient than native classes, but they
+are sometimes necessary to work around the limitations of native classes.
+
+Non-native classes can use arbitrary metaclasses and class decorators,
+and they support flexible multiple inheritance.  Mypyc will still
+generate a compile-time error if you try to assign to a method, or an
+attribute that is not defined in a class body, since these are static
+type errors detected by mypy::
+
+    o = NonNative()
+    o.extra = "x"  # Static type error: "extra" not defined
+
+However, these operations still work at runtime, including in modules
+that are not compiled using mypyc. You can also use ``setattr`` and
+``getattr`` for dynamic access of arbitrary attributes. Expressions
+with an ``Any`` type are also not type checked statically, allowing
+access to arbitrary attributes::
+
+    a: Any = o
+    a.extra = "x"  # Ok
+
+    setattr(o, "extra", "y")  # Also ok
+
+Implicit non-native classes
+---------------------------
+
+If a compiled class uses an unsupported metaclass or an unsupported
+class decorator, it will implicitly be a non-native class, as
+discussed above. You can still use ``@mypyc_attr(native_class=False)``
+to explicitly mark it as a non-native class.
+
+Explicit native classes
+-----------------------
+
+You can use ``@mypyc_attr(native_class=True)`` to explicitly declare a
+class as a native class. It will be a compile-time error if mypyc
+can't compile the class as a native class. You can use this to avoid
+accidentally defining implicit non-native classes.
 
 Deleting attributes
 -------------------
diff --git a/mypyc/doc/native_operations.rst b/mypyc/doc/native_operations.rst
index 2587e982feac..3255dbedd98a 100644
--- a/mypyc/doc/native_operations.rst
+++ b/mypyc/doc/native_operations.rst
@@ -36,6 +36,7 @@ Functions
 * ``delattr(obj, name)``
 * ``slice(start, stop, step)``
 * ``globals()``
+* ``sorted(obj)``
 
 Method decorators
 -----------------
diff --git a/mypyc/doc/performance_tips_and_tricks.rst b/mypyc/doc/performance_tips_and_tricks.rst
index ae0b2950814c..5b3c1cb42cd7 100644
--- a/mypyc/doc/performance_tips_and_tricks.rst
+++ b/mypyc/doc/performance_tips_and_tricks.rst
@@ -57,12 +57,11 @@ here we call ``acme.get_items()``, but it has no type annotation. We
 can use an explicit type annotation for the variable to which we
 assign the result::
 
-    from typing import List, Tuple
     import acme
 
     def work() -> None:
         # Annotate "items" to help mypyc
-        items: List[Tuple[int, str]] = acme.get_items()
+        items: list[tuple[int, str]] = acme.get_items()
         for item in items:
             ...  # Do some work here
 
@@ -140,7 +139,7 @@ Similarly, caching a frequently called method in a local variable can
 help in CPython, but it can slow things down in compiled code, since
 the code won't use :ref:`early binding <early-binding>`::
 
-    def squares(n: int) -> List[int]:
+    def squares(n: int) -> list[int]:
         a = []
         append = a.append  # Not a good idea in compiled code!
         for i in range(n):
diff --git a/mypyc/doc/str_operations.rst b/mypyc/doc/str_operations.rst
index 5420c8af7d31..4a7aff00f2ad 100644
--- a/mypyc/doc/str_operations.rst
+++ b/mypyc/doc/str_operations.rst
@@ -12,6 +12,8 @@ Construction
 * String literal
 * ``str(x: int)``
 * ``str(x: object)``
+* ``repr(x: int)``
+* ``repr(x: object)``
 
 Operators
 ---------
@@ -21,15 +23,63 @@ Operators
 * Slicing (``s[n:m]``, ``s[n:]``, ``s[:m]``)
 * Comparisons (``==``, ``!=``)
 * Augmented assignment (``s1 += s2``)
+* Containment (``s1 in s2``)
+
+.. _str-methods:
 
 Methods
 -------
 
+* ``s.encode()``
+* ``s.encode(encoding: str)``
+* ``s.encode(encoding: str, errors: str)``
 * ``s1.endswith(s2: str)``
+* ``s1.endswith(t: tuple[str, ...])``
+* ``s1.find(s2: str)``
+* ``s1.find(s2: str, start: int)``
+* ``s1.find(s2: str, start: int, end: int)``
 * ``s.join(x: Iterable)``
+* ``s.lstrip()``
+* ``s.lstrip(chars: str)``
+* ``s.partition(sep: str)``
+* ``s.removeprefix(prefix: str)``
+* ``s.removesuffix(suffix: str)``
 * ``s.replace(old: str, new: str)``
 * ``s.replace(old: str, new: str, count: int)``
+* ``s1.rfind(s2: str)``
+* ``s1.rfind(s2: str, start: int)``
+* ``s1.rfind(s2: str, start: int, end: int)``
+* ``s.rpartition(sep: str)``
+* ``s.rsplit()``
+* ``s.rsplit(sep: str)``
+* ``s.rsplit(sep: str, maxsplit: int)``
+* ``s.rstrip()``
+* ``s.rstrip(chars: str)``
 * ``s.split()``
 * ``s.split(sep: str)``
 * ``s.split(sep: str, maxsplit: int)``
+* ``s.splitlines()``
+* ``s.splitlines(keepends: bool)``
 * ``s1.startswith(s2: str)``
+* ``s1.startswith(t: tuple[str, ...])``
+* ``s.strip()``
+* ``s.strip(chars: str)``
+
+.. note::
+
+    :ref:`bytes.decode() <bytes-methods>` is also optimized.
+
+Formatting
+----------
+
+A subset of these common string formatting expressions are optimized:
+
+* F-strings
+* ``"...".format(...)``
+* ``"..." % (...)``
+
+Functions
+---------
+
+* ``len(s: str)``
+* ``ord(s: str)``
diff --git a/mypyc/doc/tuple_operations.rst b/mypyc/doc/tuple_operations.rst
index fca9e63fc210..4c9da9b894af 100644
--- a/mypyc/doc/tuple_operations.rst
+++ b/mypyc/doc/tuple_operations.rst
@@ -21,6 +21,8 @@ Operators
 
 * ``tup[n]`` (integer index)
 * ``tup[n:m]``, ``tup[n:]``, ``tup[:m]`` (slicing)
+* ``tup1 + tup2``
+* ``tup * n``, ``n * tup``
 
 Statements
 ----------
diff --git a/mypyc/doc/using_type_annotations.rst b/mypyc/doc/using_type_annotations.rst
index 6c9277786751..dc0b04a974fd 100644
--- a/mypyc/doc/using_type_annotations.rst
+++ b/mypyc/doc/using_type_annotations.rst
@@ -32,13 +32,15 @@ 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>`)
+* ``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>`)
-* ``List[T]`` (:ref:`native operations <list-ops>`)
-* ``Dict[K, V]`` (:ref:`native operations <dict-ops>`)
-* ``Set[T]`` (:ref:`native operations <set-ops>`)
-* ``Tuple[T, ...]`` (variable-length tuple; :ref:`native operations <tuple-ops>`)
+* ``list[T]`` (:ref:`native operations <list-ops>`)
+* ``dict[K, V]`` (:ref:`native operations <dict-ops>`)
+* ``set[T]`` (:ref:`native operations <set-ops>`)
+* ``tuple[T, ...]`` (variable-length tuple; :ref:`native operations <tuple-ops>`)
 * ``None``
 
 The link after each type lists all supported native, optimized
@@ -59,10 +61,10 @@ variable. For example, here we have a runtime type error on the final
 line of ``example`` (the ``Any`` type means an arbitrary, unchecked
 value)::
 
-    from typing import List, Any
+    from typing import Any
 
-    def example(a: List[Any]) -> None:
-        b: List[int] = a  # No error -- items are not checked
+    def example(a: list[Any]) -> None:
+        b: list[int] = a  # No error -- items are not checked
         print(b[0])  # Error here -- got str, but expected int
 
     example(["x"])
@@ -124,7 +126,7 @@ Tuple types
 
 Fixed-length
 `tuple types <https://mypy.readthedocs.io/en/stable/kinds_of_types.html#tuple-types>`_
-such as ``Tuple[int, str]`` are represented
+such as ``tuple[int, str]`` are represented
 as :ref:`value types <value-and-heap-types>` when stored in variables,
 passed as arguments, or returned from functions. Value types are
 allocated in the low-level machine stack or in CPU registers, as
@@ -193,8 +195,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
@@ -342,11 +344,12 @@ 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
+You can use the native integer types ``i64`` (64-bit signed integer),
+``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. ``i32`` may also use less memory than ``int``
+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``).
 
diff --git a/mypyc/external/googletest/src/gtest.cc b/mypyc/external/googletest/src/gtest.cc
index d882ab2e36a1..4df3bd6b418a 100644
--- a/mypyc/external/googletest/src/gtest.cc
+++ b/mypyc/external/googletest/src/gtest.cc
@@ -1784,7 +1784,7 @@ std::string CodePointToUtf8(UInt32 code_point) {
   return str;
 }
 
-// The following two functions only make sense if the the system
+// The following two functions only make sense if the system
 // uses UTF-16 for wide string encoding. All supported systems
 // with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16.
 
diff --git a/mypyc/ir/class_ir.py b/mypyc/ir/class_ir.py
index a5ac2133ce13..c88b9b0c7afc 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 NamedTuple
 
 from mypyc.common import PROPSET_PREFIX, JsonDict
 from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature
@@ -70,13 +70,13 @@
 
 
 class VTableMethod(NamedTuple):
-    cls: "ClassIR"
+    cls: "ClassIR"  # noqa: UP037
     name: str
     method: FuncIR
-    shadow_method: Optional[FuncIR]
+    shadow_method: FuncIR | None
 
 
-VTableEntries = List[VTableMethod]
+VTableEntries = list[VTableMethod]
 
 
 class ClassIR:
@@ -93,6 +93,7 @@ def __init__(
         is_generated: bool = False,
         is_abstract: bool = False,
         is_ext_class: bool = True,
+        is_final_class: bool = False,
     ) -> None:
         self.name = name
         self.module_name = module_name
@@ -100,6 +101,7 @@ def __init__(
         self.is_generated = is_generated
         self.is_abstract = is_abstract
         self.is_ext_class = is_ext_class
+        self.is_final_class = is_final_class
         # An augmented class has additional methods separate from what mypyc generates.
         # Right now the only one is dataclasses.
         self.is_augmented = False
@@ -178,7 +180,12 @@ def __init__(
         self.attrs_with_defaults: set[str] = set()
 
         # Attributes that are always initialized in __init__ or class body
-        # (inferred in mypyc.analysis.attrdefined using interprocedural analysis)
+        # (inferred in mypyc.analysis.attrdefined using interprocedural analysis).
+        # These can never raise AttributeError when accessed. If an attribute
+        # is *not* always initialized, we normally use the error value for
+        # an undefined value. If the attribute byte has an overlapping error value
+        # (the error_overlap attribute is true for the RType), we use a bitmap
+        # to track if the attribute is defined instead (see bitmap_attrs).
         self._always_initialized_attrs: set[str] = set()
 
         # Attributes that are sometimes initialized in __init__
@@ -189,17 +196,21 @@ def __init__(
 
         # Definedness of these attributes is backed by a bitmap. Index in the list
         # indicates the bit number. Includes inherited attributes. We need the
-        # 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
+        # bitmap for types such as native ints (i64 etc.) 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] = []
+
+        # If this is a generator environment class, what is the actual method for it
+        self.env_user_function: FuncIR | None = None
 
     def __repr__(self) -> str:
         return (
             "ClassIR("
             "name={self.name}, module_name={self.module_name}, "
             "is_trait={self.is_trait}, is_generated={self.is_generated}, "
-            "is_abstract={self.is_abstract}, is_ext_class={self.is_ext_class}"
+            "is_abstract={self.is_abstract}, is_ext_class={self.is_ext_class}, "
+            "is_final_class={self.is_final_class}"
             ")".format(self=self)
         )
 
@@ -248,8 +259,7 @@ def has_method(self, name: str) -> bool:
     def is_method_final(self, name: str) -> bool:
         subs = self.subclasses()
         if subs is None:
-            # TODO: Look at the final attribute!
-            return False
+            return self.is_final_class
 
         if self.has_method(name):
             method_decl = self.method_decl(name)
@@ -349,6 +359,7 @@ def serialize(self) -> JsonDict:
             "is_abstract": self.is_abstract,
             "is_generated": self.is_generated,
             "is_augmented": self.is_augmented,
+            "is_final_class": self.is_final_class,
             "inherits_python": self.inherits_python,
             "has_dict": self.has_dict,
             "allow_interpreted_subclasses": self.allow_interpreted_subclasses,
@@ -383,14 +394,15 @@ def serialize(self) -> JsonDict:
             "traits": [cir.fullname for cir in self.traits],
             "mro": [cir.fullname for cir in self.mro],
             "base_mro": [cir.fullname for cir in self.base_mro],
-            "children": [cir.fullname for cir in self.children]
-            if self.children is not None
-            else None,
+            "children": (
+                [cir.fullname for cir in self.children] if self.children is not None else None
+            ),
             "deletable": self.deletable,
             "attrs_with_defaults": sorted(self.attrs_with_defaults),
             "_always_initialized_attrs": sorted(self._always_initialized_attrs),
             "_sometimes_initialized_attrs": sorted(self._sometimes_initialized_attrs),
             "init_self_leak": self.init_self_leak,
+            "env_user_function": self.env_user_function.id if self.env_user_function else None,
         }
 
     @classmethod
@@ -404,6 +416,7 @@ def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> ClassIR:
         ir.is_abstract = data["is_abstract"]
         ir.is_ext_class = data["is_ext_class"]
         ir.is_augmented = data["is_augmented"]
+        ir.is_final_class = data["is_final_class"]
         ir.inherits_python = data["inherits_python"]
         ir.has_dict = data["has_dict"]
         ir.allow_interpreted_subclasses = data["allow_interpreted_subclasses"]
@@ -442,6 +455,9 @@ def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> ClassIR:
         ir._always_initialized_attrs = set(data["_always_initialized_attrs"])
         ir._sometimes_initialized_attrs = set(data["_sometimes_initialized_attrs"])
         ir.init_self_leak = data["init_self_leak"]
+        ir.env_user_function = (
+            ctx.functions[data["env_user_function"]] if data["env_user_function"] else None
+        )
 
         return ir
 
diff --git a/mypyc/ir/func_ir.py b/mypyc/ir/func_ir.py
index dbb45fc7ec29..bf21816fb07a 100644
--- a/mypyc/ir/func_ir.py
+++ b/mypyc/ir/func_ir.py
@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 
-from typing import Sequence
-from typing_extensions import Final
+from collections.abc import Sequence
+from typing import Final
 
 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 +86,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/module_ir.py b/mypyc/ir/module_ir.py
index dcf6f8768547..7d95b48e197e 100644
--- a/mypyc/ir/module_ir.py
+++ b/mypyc/ir/module_ir.py
@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from typing import Dict
-
 from mypyc.common import JsonDict
 from mypyc.ir.class_ir import ClassIR
 from mypyc.ir.func_ir import FuncDecl, FuncIR
@@ -21,12 +19,17 @@ def __init__(
         functions: list[FuncIR],
         classes: list[ClassIR],
         final_names: list[tuple[str, RType]],
+        type_var_names: list[str],
     ) -> None:
         self.fullname = fullname
         self.imports = imports.copy()
         self.functions = functions
         self.classes = classes
         self.final_names = final_names
+        # Names of C statics used for Python 3.12 type variable objects.
+        # These are only visible in the module that defined them, so no need
+        # to serialize.
+        self.type_var_names = type_var_names
 
     def serialize(self) -> JsonDict:
         return {
@@ -45,6 +48,7 @@ def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> ModuleIR:
             [ctx.functions[FuncDecl.get_id_from_json(f)] for f in data["functions"]],
             [ClassIR.deserialize(c, ctx) for c in data["classes"]],
             [(k, deserialize_type(t, ctx)) for k, t in data["final_names"]],
+            [],
         )
 
 
@@ -85,4 +89,4 @@ def deserialize_modules(data: dict[str, JsonDict], ctx: DeserMaps) -> dict[str,
 
 # ModulesIRs should also always be an *OrderedDict*, but if we
 # declared it that way we would need to put it in quotes everywhere...
-ModuleIRs = Dict[str, ModuleIR]
+ModuleIRs = dict[str, ModuleIR]
diff --git a/mypyc/ir/ops.py b/mypyc/ir/ops.py
index 6007f8a4ce04..eec9c34a965e 100644
--- a/mypyc/ir/ops.py
+++ b/mypyc/ir/ops.py
@@ -12,8 +12,8 @@
 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 collections.abc import Sequence
+from typing import TYPE_CHECKING, Final, Generic, NamedTuple, TypeVar, Union
 
 from mypy_extensions import trait
 
@@ -236,6 +236,10 @@ def can_raise(self) -> bool:
     def sources(self) -> list[Value]:
         """All the values the op may read."""
 
+    @abstractmethod
+    def set_sources(self, new: list[Value]) -> None:
+        """Rewrite the sources of an op"""
+
     def stolen(self) -> list[Value]:
         """Return arguments that have a reference count stolen by this op"""
         return []
@@ -272,6 +276,9 @@ def __init__(self, dest: Register, src: Value, line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def stolen(self) -> list[Value]:
         return [self.src]
 
@@ -302,6 +309,9 @@ def __init__(self, dest: Register, src: list[Value], line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return self.src.copy()
 
+    def set_sources(self, new: list[Value]) -> None:
+        self.src = new[:]
+
     def stolen(self) -> list[Value]:
         return []
 
@@ -343,6 +353,9 @@ def __repr__(self) -> str:
     def sources(self) -> list[Value]:
         return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_goto(self)
 
@@ -403,6 +416,9 @@ def set_target(self, i: int, new: BasicBlock) -> None:
     def sources(self) -> list[Value]:
         return [self.value]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.value,) = new
+
     def invert(self) -> None:
         self.negated = not self.negated
 
@@ -415,13 +431,23 @@ class Return(ControlOp):
 
     error_kind = ERR_NEVER
 
-    def __init__(self, value: Value, line: int = -1) -> None:
+    def __init__(
+        self, value: Value, line: int = -1, *, yield_target: BasicBlock | None = None
+    ) -> None:
         super().__init__(line)
         self.value = value
+        # If this return is created by a yield, keep track of the next
+        # basic block. This doesn't affect the code we generate but
+        # can feed into analysis that need to understand the
+        # *original* CFG.
+        self.yield_target = yield_target
 
     def sources(self) -> list[Value]:
         return [self.value]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.value,) = new
+
     def stolen(self) -> list[Value]:
         return [self.value]
 
@@ -453,6 +479,9 @@ def __init__(self, line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_unreachable(self)
 
@@ -495,6 +524,9 @@ def __init__(self, src: Value, line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_inc_ref(self)
 
@@ -520,6 +552,9 @@ def __repr__(self) -> str:
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_dec_ref(self)
 
@@ -545,6 +580,9 @@ def __init__(self, fn: FuncDecl, args: Sequence[Value], line: int) -> None:
     def sources(self) -> list[Value]:
         return list(self.args.copy())
 
+    def set_sources(self, new: list[Value]) -> None:
+        self.args = new[:]
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_call(self)
 
@@ -573,10 +611,102 @@ def __init__(self, obj: Value, method: str, args: list[Value], line: int = -1) -
     def sources(self) -> list[Value]:
         return self.args.copy() + [self.obj]
 
+    def set_sources(self, new: list[Value]) -> None:
+        *self.args, self.obj = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_method_call(self)
 
 
+class PrimitiveDescription:
+    """Description of a primitive op.
+
+    Primitives get lowered into lower-level ops before code generation.
+
+    If c_function_name is provided, a primitive will be lowered into a CallC op.
+    Otherwise custom logic will need to be implemented to transform the
+    primitive into lower-level ops.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        arg_types: list[RType],
+        return_type: RType,  # TODO: What about generic?
+        var_arg_type: RType | None,
+        truncated_type: RType | None,
+        c_function_name: str | None,
+        error_kind: int,
+        steals: StealsDescription,
+        is_borrowed: bool,
+        ordering: list[int] | None,
+        extra_int_constants: list[tuple[int, RType]],
+        priority: int,
+        is_pure: bool,
+    ) -> None:
+        # Each primitive much have a distinct name, but otherwise they are arbitrary.
+        self.name: Final = name
+        self.arg_types: Final = arg_types
+        self.return_type: Final = return_type
+        self.var_arg_type: Final = var_arg_type
+        self.truncated_type: Final = truncated_type
+        # If non-None, this will map to a call of a C helper function; if None,
+        # there must be a custom handler function that gets invoked during the lowering
+        # pass to generate low-level IR for the primitive (in the mypyc.lower package)
+        self.c_function_name: Final = c_function_name
+        self.error_kind: Final = error_kind
+        self.steals: Final = steals
+        self.is_borrowed: Final = is_borrowed
+        self.ordering: Final = ordering
+        self.extra_int_constants: Final = extra_int_constants
+        self.priority: Final = priority
+        # Pure primitives have no side effects, take immutable arguments, and
+        # never fail. They support additional optimizations.
+        self.is_pure: Final = is_pure
+        if is_pure:
+            assert error_kind == ERR_NEVER
+
+    def __repr__(self) -> str:
+        return f"<PrimitiveDescription {self.name!r}: {self.arg_types}>"
+
+
+class PrimitiveOp(RegisterOp):
+    """A higher-level primitive operation.
+
+    Some of these have special compiler support. These will be lowered
+    (transformed) into lower-level IR ops before code generation, and after
+    reference counting op insertion. Others will be transformed into CallC
+    ops.
+
+    Tagged integer equality is a typical primitive op with non-trivial
+    lowering. It gets transformed into a tag check, followed by different
+    code paths for short and long representations.
+    """
+
+    def __init__(self, args: list[Value], desc: PrimitiveDescription, line: int = -1) -> None:
+        self.args = args
+        self.type = desc.return_type
+        self.error_kind = desc.error_kind
+        self.desc = desc
+
+    def sources(self) -> list[Value]:
+        return self.args
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.args = new[:]
+
+    def stolen(self) -> list[Value]:
+        steals = self.desc.steals
+        if isinstance(steals, list):
+            assert len(steals) == len(self.args)
+            return [arg for arg, steal in zip(self.args, steals) if steal]
+        else:
+            return [] if not steals else self.sources()
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_primitive_op(self)
+
+
 class LoadErrorValue(RegisterOp):
     """Load an error value.
 
@@ -600,6 +730,9 @@ def __init__(
     def sources(self) -> list[Value]:
         return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_load_error_value(self)
 
@@ -632,6 +765,9 @@ def __init__(self, value: LiteralValue, rtype: RType) -> None:
     def sources(self) -> list[Value]:
         return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_load_literal(self)
 
@@ -656,6 +792,9 @@ def __init__(self, obj: Value, attr: str, line: int, *, borrow: bool = False) ->
     def sources(self) -> list[Value]:
         return [self.obj]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.obj,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_get_attr(self)
 
@@ -688,6 +827,9 @@ def mark_as_initializer(self) -> None:
     def sources(self) -> list[Value]:
         return [self.obj, self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        self.obj, self.src = new
+
     def stolen(self) -> list[Value]:
         return [self.src]
 
@@ -704,6 +846,9 @@ def accept(self, visitor: OpVisitor[T]) -> T:
 # Namespace for modules
 NAMESPACE_MODULE: Final = "module"
 
+# Namespace for Python 3.12 type variable objects (implicitly created TypeVar instances, etc.)
+NAMESPACE_TYPE_VAR: Final = "typevar"
+
 
 class LoadStatic(RegisterOp):
     """Load a static name (name :: static).
@@ -738,6 +883,9 @@ def __init__(
     def sources(self) -> list[Value]:
         return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_load_static(self)
 
@@ -767,6 +915,9 @@ def __init__(
     def sources(self) -> list[Value]:
         return [self.value]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.value,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_init_static(self)
 
@@ -793,6 +944,12 @@ def __init__(self, items: list[Value], line: int) -> None:
     def sources(self) -> list[Value]:
         return self.items.copy()
 
+    def stolen(self) -> list[Value]:
+        return self.items.copy()
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.items = new[:]
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_tuple_set(self)
 
@@ -802,17 +959,21 @@ class TupleGet(RegisterOp):
 
     error_kind = ERR_NEVER
 
-    def __init__(self, src: Value, index: int, line: int = -1) -> None:
+    def __init__(self, src: Value, index: int, line: int = -1, *, borrow: bool = False) -> None:
         super().__init__(line)
         self.src = src
         self.index = index
         assert isinstance(src.type, RTuple), "TupleGet only operates on tuples"
         assert index >= 0
         self.type = src.type.types[index]
+        self.is_borrowed = borrow
 
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_tuple_get(self)
 
@@ -836,6 +997,9 @@ def __init__(self, src: Value, typ: RType, line: int, *, borrow: bool = False) -
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def stolen(self) -> list[Value]:
         if self.is_borrowed:
             return []
@@ -869,6 +1033,9 @@ def __init__(self, src: Value, line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def stolen(self) -> list[Value]:
         return [self.src]
 
@@ -895,6 +1062,9 @@ def __init__(self, src: Value, typ: RType, line: int) -> None:
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_unbox(self)
 
@@ -927,12 +1097,15 @@ def __init__(self, class_name: str, value: str | Value | None, line: int) -> Non
     def sources(self) -> list[Value]:
         return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_raise_standard_error(self)
 
 
 # True steals all arguments, False steals none, a list steals those in matching positions
-StealsDescription = Union[bool, List[bool]]
+StealsDescription = Union[bool, list[bool]]
 
 
 class CallC(RegisterOp):
@@ -953,6 +1126,8 @@ def __init__(
         error_kind: int,
         line: int,
         var_arg_idx: int = -1,
+        *,
+        is_pure: bool = False,
     ) -> None:
         self.error_kind = error_kind
         super().__init__(line)
@@ -963,9 +1138,18 @@ def __init__(
         self.is_borrowed = is_borrowed
         # The position of the first variable argument in args (if >= 0)
         self.var_arg_idx = var_arg_idx
+        # Is the function pure? Pure functions have no side effects
+        # and all the arguments are immutable. Pure functions support
+        # additional optimizations. Pure functions never fail.
+        self.is_pure = is_pure
+        if is_pure:
+            assert error_kind == ERR_NEVER
 
     def sources(self) -> list[Value]:
-        return self.args
+        return self.args[:]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.args = new[:]
 
     def stolen(self) -> list[Value]:
         if isinstance(self.steals, list):
@@ -998,6 +1182,9 @@ def __init__(self, src: Value, dst_type: RType, line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def stolen(self) -> list[Value]:
         return []
 
@@ -1029,6 +1216,9 @@ def __init__(self, src: Value, dst_type: RType, signed: bool, line: int = -1) ->
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def stolen(self) -> list[Value]:
         return []
 
@@ -1056,6 +1246,9 @@ def __init__(self, type: RType, identifier: str, line: int = -1, ann: object = N
     def sources(self) -> list[Value]:
         return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_load_global(self)
 
@@ -1112,6 +1305,9 @@ def __init__(self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1)
     def sources(self) -> list[Value]:
         return [self.lhs, self.rhs]
 
+    def set_sources(self, new: list[Value]) -> None:
+        self.lhs, self.rhs = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_int_op(self)
 
@@ -1163,6 +1359,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)
@@ -1174,6 +1371,9 @@ def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return [self.lhs, self.rhs]
 
+    def set_sources(self, new: list[Value]) -> None:
+        self.lhs, self.rhs = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_comparison_op(self)
 
@@ -1204,10 +1404,13 @@ 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 set_sources(self, new: list[Value]) -> None:
+        (self.lhs, self.rhs) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_float_op(self)
 
 
@@ -1226,10 +1429,13 @@ 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 set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_float_neg(self)
 
 
@@ -1254,10 +1460,13 @@ 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 set_sources(self, new: list[Value]) -> None:
+        (self.lhs, self.rhs) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_float_comparison_op(self)
 
 
@@ -1288,6 +1497,9 @@ def __init__(self, type: RType, src: Value, line: int = -1) -> None:
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_load_mem(self)
 
@@ -1313,6 +1525,9 @@ def __init__(self, type: RType, dest: Value, src: Value, line: int = -1) -> None
     def sources(self) -> list[Value]:
         return [self.src, self.dest]
 
+    def set_sources(self, new: list[Value]) -> None:
+        self.src, self.dest = new
+
     def stolen(self) -> list[Value]:
         return [self.src]
 
@@ -1339,6 +1554,9 @@ def __init__(self, src: Value, src_type: RType, field: str, line: int = -1) -> N
     def sources(self) -> list[Value]:
         return [self.src]
 
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_get_element_ptr(self)
 
@@ -1367,6 +1585,12 @@ def sources(self) -> list[Value]:
         else:
             return []
 
+    def set_sources(self, new: list[Value]) -> None:
+        if new:
+            assert isinstance(new[0], Register)
+            assert len(new) == 1
+            self.src = new[0]
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_load_address(self)
 
@@ -1387,21 +1611,83 @@ class KeepAlive(RegisterOp):
     If we didn't have "keep_alive x", x could be freed immediately
     after taking the address of 'item', resulting in a read after free
     on the second line.
+
+    If 'steal' is true, the value is considered to be stolen at
+    this op, i.e. it won't be decref'd. You need to ensure that
+    the value is freed otherwise, perhaps by using borrowing
+    followed by Unborrow.
+
+    Be careful with steal=True -- this can cause memory leaks.
     """
 
     error_kind = ERR_NEVER
 
-    def __init__(self, src: list[Value]) -> None:
+    def __init__(self, src: list[Value], *, steal: bool = False) -> None:
         assert src
         self.src = src
+        self.steal = steal
 
     def sources(self) -> list[Value]:
         return self.src.copy()
 
+    def stolen(self) -> list[Value]:
+        if self.steal:
+            return self.src.copy()
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.src = new[:]
+
     def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_keep_alive(self)
 
 
+class Unborrow(RegisterOp):
+    """A no-op op to create a regular reference from a borrowed one.
+
+    Borrowed references can only be used temporarily and the reference
+    counts won't be managed. This value will be refcounted normally.
+
+    This is mainly useful if you split an aggregate value, such as
+    a tuple, into components using borrowed values (to avoid increfs),
+    and want to treat the components as sharing the original managed
+    reference. You'll also need to use KeepAlive with steal=True to
+    "consume" the original tuple reference:
+
+      # t is a 2-tuple
+      r0 = borrow t[0]
+      r1 = borrow t[1]
+      keep_alive steal t
+      r2 = unborrow r0
+      r3 = unborrow r1
+      # now (r2, r3) represent the tuple as separate items, that are
+      # managed again. (Note we need to steal before unborrow, to avoid
+      # refcount briefly touching zero if r2 or r3 are unused.)
+
+    Be careful with this -- this can easily cause double freeing.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, line: int = -1) -> None:
+        super().__init__(line)
+        assert src.is_borrowed
+        self.src = src
+        self.type = src.type
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        return []
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_unborrow(self)
+
+
 @trait
 class OpVisitor(Generic[T]):
     """Generic visitor over ops (uses the visitor design pattern)."""
@@ -1496,6 +1782,10 @@ def visit_raise_standard_error(self, op: RaiseStandardError) -> T:
     def visit_call_c(self, op: CallC) -> T:
         raise NotImplementedError
 
+    @abstractmethod
+    def visit_primitive_op(self, op: PrimitiveOp) -> T:
+        raise NotImplementedError
+
     @abstractmethod
     def visit_truncate(self, op: Truncate) -> T:
         raise NotImplementedError
@@ -1548,6 +1838,10 @@ def visit_load_address(self, op: LoadAddress) -> T:
     def visit_keep_alive(self, op: KeepAlive) -> T:
         raise NotImplementedError
 
+    @abstractmethod
+    def visit_unborrow(self, op: Unborrow) -> T:
+        raise NotImplementedError
+
 
 # TODO: Should the following definition live somewhere else?
 
@@ -1575,5 +1869,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 4d10a91835ca..ac0e791290ab 100644
--- a/mypyc/ir/pprint.py
+++ b/mypyc/ir/pprint.py
@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, Sequence, Union
-from typing_extensions import Final
+from collections.abc import Sequence
+from typing import Any, Final, Union
 
 from mypyc.common import short_name
 from mypyc.ir.func_ir import FuncIR, all_values_full
@@ -44,6 +44,7 @@
     MethodCall,
     Op,
     OpVisitor,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
     Return,
@@ -52,6 +53,7 @@
     Truncate,
     TupleGet,
     TupleSet,
+    Unborrow,
     Unbox,
     Unreachable,
     Value,
@@ -154,7 +156,7 @@ def visit_init_static(self, op: InitStatic) -> str:
         return self.format("%s = %r :: %s", name, op.value, op.namespace)
 
     def visit_tuple_get(self, op: TupleGet) -> str:
-        return self.format("%r = %r[%d]", op, op.src, op.index)
+        return self.format("%r = %s%r[%d]", op, self.borrow_prefix(op), op.src, op.index)
 
     def visit_tuple_set(self, op: TupleSet) -> str:
         item_str = ", ".join(self.format("%r", item) for item in op.items)
@@ -217,6 +219,25 @@ def visit_call_c(self, op: CallC) -> str:
         else:
             return self.format("%r = %s(%s)", op, op.function_name, args_str)
 
+    def visit_primitive_op(self, op: PrimitiveOp) -> str:
+        args = []
+        arg_index = 0
+        type_arg_index = 0
+        for arg_type in zip(op.desc.arg_types):
+            if arg_type:
+                args.append(self.format("%r", op.args[arg_index]))
+                arg_index += 1
+            else:
+                assert op.type_args
+                args.append(self.format("%r", op.type_args[type_arg_index]))
+                type_arg_index += 1
+
+        args_str = ", ".join(args)
+        if op.is_void:
+            return self.format("%s %s", op.desc.name, args_str)
+        else:
+            return self.format("%r = %s %s", op, op.desc.name, args_str)
+
     def visit_truncate(self, op: Truncate) -> str:
         return self.format("%r = truncate %r: %t to %t", op, op.src, op.src_type, op.type)
 
@@ -275,7 +296,16 @@ def visit_load_address(self, op: LoadAddress) -> str:
             return self.format("%r = load_address %s", op, op.src)
 
     def visit_keep_alive(self, op: KeepAlive) -> str:
-        return self.format("keep_alive %s" % ", ".join(self.format("%r", v) for v in op.src))
+        if op.steal:
+            steal = "steal "
+        else:
+            steal = ""
+        return self.format(
+            "keep_alive {}{}".format(steal, ", ".join(self.format("%r", v) for v in op.src))
+        )
+
+    def visit_unborrow(self, op: Unborrow) -> str:
+        return self.format("%r = unborrow %r", op, op.src)
 
     # Helpers
 
diff --git a/mypyc/ir/rtypes.py b/mypyc/ir/rtypes.py
index 7ff82ac9b297..60a56065006f 100644
--- a/mypyc/ir/rtypes.py
+++ b/mypyc/ir/rtypes.py
@@ -23,10 +23,10 @@
 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 typing_extensions import TypeGuard
 
-from mypyc.common import IS_32_BIT_PLATFORM, PLATFORM_SIZE, JsonDict, short_name
+from mypyc.common import HAVE_IMMORTAL, IS_32_BIT_PLATFORM, PLATFORM_SIZE, JsonDict, short_name
 from mypyc.namegen import NameGenerator
 
 if TYPE_CHECKING:
@@ -58,17 +58,35 @@ class RType:
     # to checking for error value as the return value of a function.
     #
     # For example, no i64 value can be reserved for error value, so we
-    # pick an arbitrary value (e.g. -113) to signal error, but this is
-    # also a valid non-error value.
+    # pick an arbitrary value (-113) to signal error, but this is
+    # also a valid non-error value. The chosen value is rare as a
+    # normal, non-error value, so most of the time we can avoid calling
+    # PyErr_Occurred() when checking for errors raised by called
+    # functions.
+    #
+    # This also means that if an attribute with this type might be
+    # undefined, we can't just rely on the error value to signal this.
+    # Instead, we add a bitfield to keep track whether attributes with
+    # "error overlap" have a value. If there is no value, AttributeError
+    # is raised on attribute read. Parameters with default values also
+    # use the bitfield trick to indicate whether the caller passed a
+    # value. (If we can determine that an attribute is "always defined",
+    # we never raise an AttributeError and don't need the bitfield
+    # entry.)
     error_overlap = False
 
     @abstractmethod
     def accept(self, visitor: RTypeVisitor[T]) -> T:
-        raise NotImplementedError
+        raise NotImplementedError()
 
     def short_name(self) -> str:
         return short_name(self.name)
 
+    @property
+    @abstractmethod
+    def may_be_immortal(self) -> bool:
+        raise NotImplementedError
+
     def __str__(self) -> str:
         return short_name(self.name)
 
@@ -109,31 +127,31 @@ class RTypeVisitor(Generic[T]):
     """Generic visitor over RTypes (uses the visitor design pattern)."""
 
     @abstractmethod
-    def visit_rprimitive(self, typ: RPrimitive) -> T:
+    def visit_rprimitive(self, typ: RPrimitive, /) -> T:
         raise NotImplementedError
 
     @abstractmethod
-    def visit_rinstance(self, typ: RInstance) -> T:
+    def visit_rinstance(self, typ: RInstance, /) -> T:
         raise NotImplementedError
 
     @abstractmethod
-    def visit_runion(self, typ: RUnion) -> T:
+    def visit_runion(self, typ: RUnion, /) -> T:
         raise NotImplementedError
 
     @abstractmethod
-    def visit_rtuple(self, typ: RTuple) -> T:
+    def visit_rtuple(self, typ: RTuple, /) -> T:
         raise NotImplementedError
 
     @abstractmethod
-    def visit_rstruct(self, typ: RStruct) -> T:
+    def visit_rstruct(self, typ: RStruct, /) -> T:
         raise NotImplementedError
 
     @abstractmethod
-    def visit_rarray(self, typ: RArray) -> T:
+    def visit_rarray(self, typ: RArray, /) -> T:
         raise NotImplementedError
 
     @abstractmethod
-    def visit_rvoid(self, typ: RVoid) -> T:
+    def visit_rvoid(self, typ: RVoid, /) -> T:
         raise NotImplementedError
 
 
@@ -151,6 +169,10 @@ class RVoid(RType):
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_rvoid(self)
 
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
     def serialize(self) -> str:
         return "void"
 
@@ -193,6 +215,7 @@ def __init__(
         ctype: str = "PyObject *",
         size: int = PLATFORM_SIZE,
         error_overlap: bool = False,
+        may_be_immortal: bool = True,
     ) -> None:
         RPrimitive.primitive_map[name] = self
 
@@ -204,15 +227,15 @@ def __init__(
         self._ctype = ctype
         self.size = size
         self.error_overlap = error_overlap
+        self._may_be_immortal = may_be_immortal and HAVE_IMMORTAL
         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"
-        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.
@@ -223,12 +246,18 @@ 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
 
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_rprimitive(self)
 
+    @property
+    def may_be_immortal(self) -> bool:
+        return self._may_be_immortal
+
     def serialize(self) -> str:
         return self.name
 
@@ -290,8 +319,18 @@ def __hash__(self) -> int:
 
 # Low level integer types (correspond to C integer types)
 
+int16_rprimitive: Final = RPrimitive(
+    "i16",
+    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",
+    "i32",
     is_unboxed=True,
     is_refcounted=False,
     is_native_int=True,
@@ -301,7 +340,7 @@ def __hash__(self) -> int:
     error_overlap=True,
 )
 int64_rprimitive: Final = RPrimitive(
-    "int64",
+    "i64",
     is_unboxed=True,
     is_refcounted=False,
     is_native_int=True,
@@ -310,23 +349,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
@@ -396,8 +461,12 @@ def __hash__(self) -> int:
     "builtins.None", is_unboxed=True, is_refcounted=False, ctype="char", size=1
 )
 
-# Python list object (or an instance of a subclass of list).
-list_rprimitive: Final = RPrimitive("builtins.list", is_unboxed=False, is_refcounted=True)
+# Python list object (or an instance of a subclass of list). These could be
+# immortal, but since this is expected to be very rare, and the immortality checks
+# can be pretty expensive for lists, we treat lists as non-immortal.
+list_rprimitive: Final = RPrimitive(
+    "builtins.list", is_unboxed=False, is_refcounted=True, may_be_immortal=False
+)
 
 # Python dict object (or an instance of a subclass of dict).
 dict_rprimitive: Final = RPrimitive("builtins.dict", is_unboxed=False, is_refcounted=True)
@@ -405,6 +474,11 @@ def __hash__(self) -> int:
 # Python set object (or an instance of a subclass of set).
 set_rprimitive: Final = RPrimitive("builtins.set", is_unboxed=False, is_refcounted=True)
 
+# Python frozenset object (or an instance of a subclass of frozenset).
+frozenset_rprimitive: Final = RPrimitive(
+    "builtins.frozenset", is_unboxed=False, is_refcounted=True
+)
+
 # Python str object. At the C layer, str is referred to as unicode
 # (PyUnicode).
 str_rprimitive: Final = RPrimitive("builtins.str", is_unboxed=False, is_refcounted=True)
@@ -432,7 +506,11 @@ def is_short_int_rprimitive(rtype: RType) -> bool:
     return rtype is short_int_rprimitive
 
 
-def is_int32_rprimitive(rtype: RType) -> bool:
+def is_int16_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is int16_rprimitive
+
+
+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"
     )
@@ -444,8 +522,17 @@ 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)
+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:
@@ -496,6 +583,10 @@ def is_set_rprimitive(rtype: RType) -> bool:
     return isinstance(rtype, RPrimitive) and rtype.name == "builtins.set"
 
 
+def is_frozenset_rprimitive(rtype: RType) -> bool:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.frozenset"
+
+
 def is_str_rprimitive(rtype: RType) -> bool:
     return isinstance(rtype, RPrimitive) and rtype.name == "builtins.str"
 
@@ -536,6 +627,10 @@ 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 == "uint8_t":
+            return "U1"  # "1 byte unsigned integer"
         elif t._ctype == "double":
             return "F"
         assert not t.is_unboxed, f"{t} unexpected unboxed type"
@@ -588,6 +683,10 @@ def __init__(self, types: list[RType]) -> None:
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_rtuple(self)
 
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
     def __str__(self) -> str:
         return "tuple[%s]" % ", ".join(str(typ) for typ in self.types)
 
@@ -709,6 +808,10 @@ def __init__(self, name: str, names: list[str], types: list[RType]) -> None:
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_rstruct(self)
 
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
     def __str__(self) -> str:
         # if not tuple(unnamed structs)
         return "{}{{{}}}".format(
@@ -769,6 +872,10 @@ def __init__(self, class_ir: ClassIR) -> None:
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_rinstance(self)
 
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
     def struct_name(self, names: NameGenerator) -> str:
         return self.class_ir.struct_name(names)
 
@@ -829,6 +936,10 @@ def make_simplified_union(items: list[RType]) -> RType:
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_runion(self)
 
+    @property
+    def may_be_immortal(self) -> bool:
+        return any(item.may_be_immortal for item in self.items)
+
     def __repr__(self) -> str:
         return "<RUnion %s>" % ", ".join(str(item) for item in self.items)
 
@@ -899,6 +1010,10 @@ def __init__(self, item_type: RType, length: int) -> None:
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_rarray(self)
 
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
     def __str__(self) -> str:
         return f"{self.item_type}[{self.length}]"
 
@@ -970,3 +1085,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/ast_helpers.py b/mypyc/irbuild/ast_helpers.py
index 1af1ad611a89..3b0f50514594 100644
--- a/mypyc/irbuild/ast_helpers.py
+++ b/mypyc/irbuild/ast_helpers.py
@@ -62,6 +62,7 @@ def maybe_process_conditional_comparison(
     do nothing and return False.
 
     Args:
+        self: IR form Builder
         e: Arbitrary expression
         true: Branch target if comparison is true
         false: Branch target if comparison is false
@@ -93,7 +94,9 @@ def maybe_process_conditional_comparison(
         self.add_bool_branch(reg, true, false)
     else:
         # "left op right" for two tagged integers
-        self.builder.compare_tagged_condition(left, right, op, true, false, e.line)
+        reg = self.builder.binary_op(left, right, op, e.line)
+        self.flush_keep_alives()
+        self.add_bool_branch(reg, true, false)
     return True
 
 
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
index 26aa17071974..72a5ff4099df 100644
--- a/mypyc/irbuild/builder.py
+++ b/mypyc/irbuild/builder.py
@@ -1,20 +1,13 @@
-"""Builder class used to transform a mypy AST to the IR form.
+"""Builder class to transform a mypy AST to the IR form.
 
-The IRBuilder class maintains transformation state and provides access
-to various helpers used to implement the transform.
-
-The top-level transform control logic is in mypyc.irbuild.main.
-
-mypyc.irbuild.visitor.IRBuilderVisitor is used to dispatch based on mypy
-AST node type to code that actually does the bulk of the work. For
-example, expressions are transformed in mypyc.irbuild.expression and
-functions are transformed in mypyc.irbuild.function.
+See the docstring of class IRBuilder for more information.
 """
+
 from __future__ import annotations
 
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
-from typing import Any, Callable, Iterator, Sequence, Union
-from typing_extensions import Final, overload
+from typing import Any, Callable, Final, Union, overload
 
 from mypy.build import Graph
 from mypy.maptype import map_instance_to_supertype
@@ -23,6 +16,9 @@
     ARG_POS,
     GDEF,
     LDEF,
+    PARAM_SPEC_KIND,
+    TYPE_VAR_KIND,
+    TYPE_VAR_TUPLE_KIND,
     ArgKind,
     CallExpr,
     Decorator,
@@ -43,6 +39,7 @@
     TupleExpr,
     TypeAlias,
     TypeInfo,
+    TypeParam,
     UnaryExpr,
     Var,
 )
@@ -55,11 +52,12 @@
     Type,
     TypedDictType,
     TypeOfAny,
+    TypeVarLikeType,
     UninhabitedType,
     UnionType,
     get_proper_type,
 )
-from mypy.util import split_target
+from mypy.util import module_prefix, split_target
 from mypy.visitor import ExpressionVisitor, StatementVisitor
 from mypyc.common import BITMAP_BITS, SELF_NAME, TEMP_ATTR_NAME
 from mypyc.crash import catch_errors
@@ -68,6 +66,7 @@
 from mypyc.ir.func_ir import INVALID_FUNC_DEF, FuncDecl, FuncIR, FuncSignature, RuntimeArg
 from mypyc.ir.ops import (
     NAMESPACE_MODULE,
+    NAMESPACE_TYPE_VAR,
     Assign,
     BasicBlock,
     Branch,
@@ -78,6 +77,7 @@
     IntOp,
     LoadStatic,
     Op,
+    PrimitiveDescription,
     RaiseStandardError,
     Register,
     SetAttr,
@@ -147,6 +147,30 @@ class UnsupportedException(Exception):
 
 
 class IRBuilder:
+    """Builder class used to construct mypyc IR from a mypy AST.
+
+    The IRBuilder class maintains IR transformation state and provides access
+    to various helpers used to implement the transform.
+
+    mypyc.irbuild.visitor.IRBuilderVisitor is used to dispatch based on mypy
+    AST node type to code that actually does the bulk of the work. For
+    example, expressions are transformed in mypyc.irbuild.expression and
+    functions are transformed in mypyc.irbuild.function.
+
+    Use the "accept()" method to translate individual mypy AST nodes to IR.
+    Other methods are used to generate IR for various lower-level operations.
+
+    This class wraps the lower-level LowLevelIRBuilder class, an instance
+    of which is available through the "builder" attribute. The low-level
+    builder class doesn't have any knowledge of the mypy AST. Wrappers for
+    some LowLevelIRBuilder method are provided for convenience, but others
+    can also be accessed via the "builder" attribute.
+
+    See also:
+     * The mypyc IR is defined in the mypyc.ir package.
+     * The top-level IR transform control logic is in mypyc.irbuild.main.
+    """
+
     def __init__(
         self,
         current_module: str,
@@ -159,12 +183,15 @@ def __init__(
         options: CompilerOptions,
         singledispatch_impls: dict[FuncDef, list[RegisterImplInfo]],
     ) -> None:
-        self.builder = LowLevelIRBuilder(current_module, mapper, options)
+        self.builder = LowLevelIRBuilder(errors, options)
         self.builders = [self.builder]
         self.symtables: list[dict[SymbolNode, SymbolTarget]] = [{}]
         self.runtime_args: list[list[RuntimeArg]] = [[]]
         self.function_name_stack: list[str] = []
         self.class_ir_stack: list[ClassIR] = []
+        # Keep track of whether the next statement in a block is reachable
+        # or not, separately for each block nesting level
+        self.block_reachable_stack: list[bool] = [True]
 
         self.current_module = current_module
         self.mapper = mapper
@@ -172,8 +199,10 @@ def __init__(
         self.graph = graph
         self.ret_types: list[RType] = []
         self.functions: list[FuncIR] = []
+        self.function_names: set[tuple[str | None, str]] = set()
         self.classes: list[ClassIR] = []
         self.final_names: list[tuple[str, RType]] = []
+        self.type_var_names: list[str] = []
         self.callable_class_names: set[str] = set()
         self.options = options
 
@@ -224,14 +253,13 @@ 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:
-        ...
+    def accept(self, node: Expression, *, can_borrow: bool = False) -> Value: ...
 
     @overload
-    def accept(self, node: Statement) -> None:
-        ...
+    def accept(self, node: Statement) -> None: ...
 
     def accept(self, node: Statement | Expression, *, can_borrow: bool = False) -> Value | None:
         """Transform an expression or a statement.
@@ -371,12 +399,18 @@ def load_module(self, name: str) -> Value:
     def call_c(self, desc: CFunctionDescription, args: list[Value], line: int) -> Value:
         return self.builder.call_c(desc, args, line)
 
+    def primitive_op(
+        self,
+        desc: PrimitiveDescription,
+        args: list[Value],
+        line: int,
+        result_type: RType | None = None,
+    ) -> Value:
+        return self.builder.primitive_op(desc, args, line, result_type)
+
     def int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int) -> Value:
         return self.builder.int_op(type, lhs, rhs, op, line)
 
-    def compare_tagged(self, lhs: Value, rhs: Value, op: str, line: int) -> Value:
-        return self.builder.compare_tagged(lhs, rhs, op, line)
-
     def compare_tuples(self, lhs: Value, rhs: Value, op: str, line: int) -> Value:
         return self.builder.compare_tuples(lhs, rhs, op, line)
 
@@ -386,6 +420,9 @@ def builtin_len(self, val: Value, line: int) -> Value:
     def new_tuple(self, items: list[Value], line: int) -> Value:
         return self.builder.new_tuple(items, line)
 
+    def debug_print(self, toprint: str | Value) -> None:
+        return self.builder.debug_print(toprint)
+
     # Helpers for IR building
 
     def add_to_non_ext_dict(
@@ -393,7 +430,7 @@ def add_to_non_ext_dict(
     ) -> None:
         # Add an attribute entry into the class dict of a non-extension class.
         key_unicode = self.load_str(key)
-        self.call_c(dict_set_item_op, [non_ext.dict, key_unicode, val], line)
+        self.primitive_op(dict_set_item_op, [non_ext.dict, key_unicode, val], line)
 
     def gen_import(self, id: str, line: int) -> None:
         self.imports[id] = None
@@ -424,7 +461,7 @@ def get_module(self, module: str, line: int) -> Value:
         # Python 3.7 has a nice 'PyImport_GetModule' function that we can't use :(
         mod_dict = self.call_c(get_module_dict_op, [], line)
         # Get module object from modules dict.
-        return self.call_c(dict_get_item_op, [mod_dict, self.load_str(module)], line)
+        return self.primitive_op(dict_get_item_op, [mod_dict, self.load_str(module)], line)
 
     def get_module_attr(self, module: str, attr: str, line: int) -> Value:
         """Look up an attribute of a module without storing it in the local namespace.
@@ -501,6 +538,11 @@ def non_function_scope(self) -> bool:
         # Currently the stack always has at least two items: dummy and top-level.
         return len(self.fn_infos) <= 2
 
+    def top_level_fn_info(self) -> FuncInfo | None:
+        if self.non_function_scope():
+            return None
+        return self.fn_infos[2]
+
     def init_final_static(
         self,
         lvalue: Lvalue,
@@ -535,16 +577,29 @@ 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 init_type_var(self, value: Value, name: str, line: int) -> None:
+        unique_name = name + "___" + str(line)
+        self.type_var_names.append(unique_name)
+        self.add(InitStatic(value, unique_name, self.module_name, namespace=NAMESPACE_TYPE_VAR))
+
+    def load_type_var(self, name: str, line: int) -> Value:
+        return self.add(
+            LoadStatic(
+                object_rprimitive,
+                name + "___" + str(line),
+                self.module_name,
+                namespace=NAMESPACE_TYPE_VAR,
+            )
+        )
+
+    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 +607,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
@@ -567,7 +624,7 @@ def get_assignment_target(
             if isinstance(symbol, Decorator):
                 symbol = symbol.func
             if symbol is None:
-                # New semantic analyzer doesn't create ad-hoc Vars for special forms.
+                # Semantic analyzer doesn't create ad-hoc Vars for special forms.
                 assert lvalue.is_special_form
                 symbol = Var(lvalue.name)
             if not for_read and isinstance(symbol, Var) and symbol.is_cls:
@@ -664,7 +721,7 @@ def assign(self, target: Register | AssignmentTarget, rvalue_reg: Value, line: i
             else:
                 key = self.load_str(target.attr)
                 boxed_reg = self.builder.box(rvalue_reg)
-                self.call_c(py_setattr_op, [target.obj, key, boxed_reg], line)
+                self.primitive_op(py_setattr_op, [target.obj, key, boxed_reg], line)
         elif isinstance(target, AssignmentTargetIndex):
             target_reg2 = self.gen_method_call(
                 target.base, "__setitem__", [target.index, rvalue_reg], None, line
@@ -712,7 +769,7 @@ def process_sequence_assignment(
             item = target.items[i]
             index = self.builder.load_int(i)
             if is_list_rprimitive(rvalue.type):
-                item_value = self.call_c(list_get_item_unsafe_op, [rvalue, index], line)
+                item_value = self.primitive_op(list_get_item_unsafe_op, [rvalue, index], line)
             else:
                 item_value = self.builder.gen_method_call(
                     rvalue, "__getitem__", [index], item.type, line
@@ -741,7 +798,7 @@ def process_iterator_tuple_assignment_helper(
     def process_iterator_tuple_assignment(
         self, target: AssignmentTargetTuple, rvalue_reg: Value, line: int
     ) -> None:
-        iterator = self.call_c(iter_op, [rvalue_reg], line)
+        iterator = self.primitive_op(iter_op, [rvalue_reg], line)
 
         # This may be the whole lvalue list if there is no starred value
         split_idx = target.star_idx if target.star_idx is not None else len(target.items)
@@ -767,7 +824,7 @@ def process_iterator_tuple_assignment(
         # Assign the starred value and all values after it
         if target.star_idx is not None:
             post_star_vals = target.items[split_idx + 1 :]
-            iter_list = self.call_c(to_list, [iterator], line)
+            iter_list = self.primitive_op(to_list, [iterator], line)
             iter_list_len = self.builtin_len(iter_list, line)
             post_star_len = Integer(len(post_star_vals))
             condition = self.binary_op(post_star_len, iter_list_len, "<=", line)
@@ -786,7 +843,7 @@ def process_iterator_tuple_assignment(
             self.activate_block(ok_block)
 
             for litem in reversed(post_star_vals):
-                ritem = self.call_c(list_pop_last, [iter_list], line)
+                ritem = self.primitive_op(list_pop_last, [iter_list], line)
                 self.assign(litem, ritem, line)
 
             # Assign the starred value
@@ -879,49 +936,66 @@ def get_sequence_type_from_type(self, target_type: Type) -> RType:
             return RUnion.make_simplified_union(
                 [self.get_sequence_type_from_type(item) for item in target_type.items]
             )
-        assert isinstance(target_type, Instance), target_type
-        if target_type.type.fullname == "builtins.str":
-            return str_rprimitive
-        else:
-            return self.type_to_rtype(target_type.args[0])
+        elif isinstance(target_type, Instance):
+            if target_type.type.fullname == "builtins.str":
+                return str_rprimitive
+            else:
+                return self.type_to_rtype(target_type.args[0])
+        # This elif-blocks are needed for iterating over classes derived from NamedTuple.
+        elif isinstance(target_type, TypeVarLikeType):
+            return self.get_sequence_type_from_type(target_type.upper_bound)
+        elif isinstance(target_type, TupleType):
+            # Tuple might have elements of different types.
+            rtypes = {self.mapper.type_to_rtype(item) for item in target_type.items}
+            if len(rtypes) == 1:
+                return rtypes.pop()
+            else:
+                return RUnion.make_simplified_union(list(rtypes))
+        assert False, target_type
 
     def get_dict_base_type(self, expr: Expression) -> list[Instance]:
         """Find dict type of a dict-like expression.
 
         This is useful for dict subclasses like SymbolTable.
         """
-        target_type = get_proper_type(self.types[expr])
+        return self.get_dict_base_type_from_type(self.types[expr])
+
+    def get_dict_base_type_from_type(self, target_type: Type) -> list[Instance]:
+        target_type = get_proper_type(target_type)
         if isinstance(target_type, UnionType):
-            types = [get_proper_type(item) for item in target_type.items]
+            return [
+                inner
+                for item in target_type.items
+                for inner in self.get_dict_base_type_from_type(item)
+            ]
+        if isinstance(target_type, TypeVarLikeType):
+            # Match behaviour of self.node_type
+            # We can only reach this point if `target_type` was a TypeVar(bound=dict[...])
+            # or a ParamSpec.
+            return self.get_dict_base_type_from_type(target_type.upper_bound)
+
+        if isinstance(target_type, TypedDictType):
+            target_type = target_type.fallback
+            dict_base = next(
+                base for base in target_type.type.mro if base.fullname == "typing.Mapping"
+            )
+        elif isinstance(target_type, Instance):
+            dict_base = next(
+                base for base in target_type.type.mro if base.fullname == "builtins.dict"
+            )
         else:
-            types = [target_type]
-
-        dict_types = []
-        for t in types:
-            if isinstance(t, TypedDictType):
-                t = t.fallback
-                dict_base = next(base for base in t.type.mro if base.fullname == "typing.Mapping")
-            else:
-                assert isinstance(t, Instance), t
-                dict_base = next(base for base in t.type.mro if base.fullname == "builtins.dict")
-            dict_types.append(map_instance_to_supertype(t, dict_base))
-        return dict_types
+            assert False, f"Failed to extract dict base from {target_type}"
+        return [map_instance_to_supertype(target_type, dict_base)]
 
     def get_dict_key_type(self, expr: Expression) -> RType:
         dict_base_types = self.get_dict_base_type(expr)
-        if len(dict_base_types) == 1:
-            return self.type_to_rtype(dict_base_types[0].args[0])
-        else:
-            rtypes = [self.type_to_rtype(t.args[0]) for t in dict_base_types]
-            return RUnion.make_simplified_union(rtypes)
+        rtypes = [self.type_to_rtype(t.args[0]) for t in dict_base_types]
+        return RUnion.make_simplified_union(rtypes)
 
     def get_dict_value_type(self, expr: Expression) -> RType:
         dict_base_types = self.get_dict_base_type(expr)
-        if len(dict_base_types) == 1:
-            return self.type_to_rtype(dict_base_types[0].args[1])
-        else:
-            rtypes = [self.type_to_rtype(t.args[1]) for t in dict_base_types]
-            return RUnion.make_simplified_union(rtypes)
+        rtypes = [self.type_to_rtype(t.args[1]) for t in dict_base_types]
+        return RUnion.make_simplified_union(rtypes)
 
     def get_dict_item_type(self, expr: Expression) -> RType:
         key_type = self.get_dict_key_type(expr)
@@ -952,17 +1026,13 @@ def _analyze_iterable_item_type(self, expr: Expression) -> Type:
 
     def is_native_module(self, module: str) -> bool:
         """Is the given module one compiled by mypyc?"""
-        return module in self.mapper.group_map
+        return self.mapper.is_native_module(module)
 
     def is_native_ref_expr(self, expr: RefExpr) -> bool:
-        if expr.node is None:
-            return False
-        if "." in expr.node.fullname:
-            return self.is_native_module(expr.node.fullname.rpartition(".")[0])
-        return True
+        return self.mapper.is_native_ref_expr(expr)
 
     def is_native_module_ref_expr(self, expr: RefExpr) -> bool:
-        return self.is_native_ref_expr(expr) and expr.kind == GDEF
+        return self.mapper.is_native_module_ref_expr(expr)
 
     def is_synthetic_type(self, typ: TypeInfo) -> bool:
         """Is a type something other than just a class we've created?"""
@@ -1013,8 +1083,8 @@ 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)
-        elif native:
+            return self.load_literal_value(final_var.final_value)
+        elif native and module_prefix(self.graph, fullname):
             return self.load_final_static(fullname, self.mapper.type_to_rtype(typ), line, name)
         else:
             return None
@@ -1028,9 +1098,9 @@ def call_refexpr_with_args(
         # Handle data-driven special-cased primitive call ops.
         if callee.fullname and expr.arg_kinds == [ARG_POS] * len(arg_values):
             fullname = get_call_target_fullname(callee)
-            call_c_ops_candidates = function_ops.get(fullname, [])
-            target = self.builder.matching_call_c(
-                call_c_ops_candidates, arg_values, expr.line, self.node_type(expr)
+            primitive_candidates = function_ops.get(fullname, [])
+            target = self.builder.matching_primitive_op(
+                primitive_candidates, arg_values, expr.line, self.node_type(expr)
             )
             if target:
                 return target
@@ -1099,16 +1169,17 @@ def flatten_classes(self, arg: RefExpr | TupleExpr) -> list[ClassIR] | None:
                     return None
             return res
 
-    def enter(self, fn_info: FuncInfo | str = "") -> None:
+    def enter(self, fn_info: FuncInfo | str = "", *, ret_type: RType = none_rprimitive) -> 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.errors, self.options)
+        self.builder.set_module(self.module_name, self.module_path)
         self.builders.append(self.builder)
         self.symtables.append({})
         self.runtime_args.append([])
         self.fn_info = fn_info
         self.fn_infos.append(self.fn_info)
-        self.ret_types.append(none_rprimitive)
+        self.ret_types.append(ret_type)
         if fn_info.is_generator:
             self.nonlocal_control.append(GeneratorNonlocalControl())
         else:
@@ -1148,10 +1219,9 @@ def enter_method(
             self_type: If not None, override default type of the implicit 'self'
                 argument (by default, derive type from class_ir)
         """
-        self.enter(fn_info)
+        self.enter(fn_info, ret_type=ret_type)
         self.function_name_stack.append(name)
         self.class_ir_stack.append(class_ir)
-        self.ret_types[-1] = ret_type
         if self_type is None:
             self_type = RInstance(class_ir)
         self.add_argument(SELF_NAME, self_type)
@@ -1234,14 +1304,15 @@ def add_var_to_env_class(
     ) -> AssignmentTarget:
         # First, define the variable name as an attribute of the environment class, and then
         # construct a target for that attribute.
-        self.fn_info.env_class.attributes[var.name] = rtype
-        attr_target = AssignmentTargetAttr(base.curr_env_reg, var.name)
+        name = remangle_redefinition_name(var.name)
+        self.fn_info.env_class.attributes[name] = rtype
+        attr_target = AssignmentTargetAttr(base.curr_env_reg, name)
 
         if reassign:
             # Read the local definition of the variable, and set the corresponding attribute of
             # the environment class' variable to be that value.
             reg = self.read(self.lookup(var), self.fn_info.fitem.line)
-            self.add(SetAttr(base.curr_env_reg, var.name, reg, self.fn_info.fitem.line))
+            self.add(SetAttr(base.curr_env_reg, name, reg, self.fn_info.fitem.line))
 
         # Override the local definition of the variable to instead point at the variable in
         # the environment class.
@@ -1273,7 +1344,7 @@ def load_global(self, expr: NameExpr) -> Value:
     def load_global_str(self, name: str, line: int) -> Value:
         _globals = self.load_globals_dict()
         reg = self.load_str(name)
-        return self.call_c(dict_get_item_op, [_globals, reg], line)
+        return self.primitive_op(dict_get_item_op, [_globals, reg], line)
 
     def load_globals_dict(self) -> Value:
         return self.add(LoadStatic(dict_rprimitive, "globals", self.module_name))
@@ -1293,6 +1364,14 @@ def is_native_attr_ref(self, expr: MemberExpr) -> bool:
             and not obj_rtype.class_ir.get_method(expr.name)
         )
 
+    def mark_block_unreachable(self) -> None:
+        """Mark statements in the innermost block being processed as unreachable.
+
+        This should be called after a statement that unconditionally leaves the
+        block, such as 'break' or 'return'.
+        """
+        self.block_reachable_stack[-1] = False
+
     # Lacks a good type because there wasn't a reasonable type in 3.5 :(
     def catch_errors(self, line: int) -> Any:
         return catch_errors(self.module_path, line)
@@ -1306,6 +1385,14 @@ def error(self, msg: str, line: int) -> None:
     def note(self, msg: str, line: int) -> None:
         self.errors.note(msg, self.module_path, line)
 
+    def add_function(self, func_ir: FuncIR, line: int) -> None:
+        name = (func_ir.class_name, func_ir.name)
+        if name in self.function_names:
+            self.error(f'Duplicate definition of "{name[1]}" not supported by mypyc', line)
+            return
+        self.function_names.add(name)
+        self.functions.append(func_ir)
+
 
 def gen_arg_defaults(builder: IRBuilder) -> None:
     """Generate blocks for arguments that have default values.
@@ -1368,3 +1455,72 @@ def get_call_target_fullname(ref: RefExpr) -> str:
         if isinstance(target, Instance):
             return target.type.fullname
     return ref.fullname
+
+
+def create_type_params(
+    builder: IRBuilder, typing_mod: Value, type_args: list[TypeParam], line: int
+) -> list[Value]:
+    """Create objects representing various kinds of Python 3.12 type parameters.
+
+    The "typing_mod" argument is the "_typing" module object. The type objects
+    are looked up from it.
+
+    The returned list has one item for each "type_args" item, in the same order.
+    Each item is either a TypeVar, TypeVarTuple or ParamSpec instance.
+    """
+    tvs = []
+    type_var_imported: Value | None = None
+    for type_param in type_args:
+        if type_param.kind == TYPE_VAR_KIND:
+            if type_var_imported:
+                # Reuse previously imported value as a minor optimization
+                tvt = type_var_imported
+            else:
+                tvt = builder.py_get_attr(typing_mod, "TypeVar", line)
+                type_var_imported = tvt
+        elif type_param.kind == TYPE_VAR_TUPLE_KIND:
+            tvt = builder.py_get_attr(typing_mod, "TypeVarTuple", line)
+        else:
+            assert type_param.kind == PARAM_SPEC_KIND
+            tvt = builder.py_get_attr(typing_mod, "ParamSpec", line)
+        if type_param.kind != TYPE_VAR_TUPLE_KIND:
+            # To match runtime semantics, pass infer_variance=True
+            tv = builder.py_call(
+                tvt,
+                [builder.load_str(type_param.name), builder.true()],
+                line,
+                arg_kinds=[ARG_POS, ARG_NAMED],
+                arg_names=[None, "infer_variance"],
+            )
+        else:
+            tv = builder.py_call(tvt, [builder.load_str(type_param.name)], line)
+        builder.init_type_var(tv, type_param.name, line)
+        tvs.append(tv)
+    return tvs
+
+
+def calculate_arg_defaults(
+    builder: IRBuilder,
+    fn_info: FuncInfo,
+    func_reg: Value | None,
+    symtable: dict[SymbolNode, SymbolTarget],
+) -> None:
+    """Calculate default argument values and store them.
+
+    They are stored in statics for top level functions and in
+    the function objects for nested functions (while constants are
+    still stored computed on demand).
+    """
+    fitem = fn_info.fitem
+    for arg in fitem.arguments:
+        # Constant values don't get stored but just recomputed
+        if arg.initializer and not is_constant(arg.initializer):
+            value = builder.coerce(
+                builder.accept(arg.initializer), symtable[arg.variable].type, arg.line
+            )
+            if not fn_info.is_nested:
+                name = fitem.fullname + "." + arg.variable.name
+                builder.add(InitStatic(value, name, builder.module_name))
+            else:
+                assert func_reg is not None
+                builder.add(SetAttr(func_reg, arg.variable.name, value, arg.line))
diff --git a/mypyc/irbuild/callable_class.py b/mypyc/irbuild/callable_class.py
index d3ee54a208cd..599dbb81f767 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/classdef.py b/mypyc/irbuild/classdef.py
index 59b1c05a0ddb..1e53df92fcfe 100644
--- a/mypyc/irbuild/classdef.py
+++ b/mypyc/irbuild/classdef.py
@@ -3,14 +3,16 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import Callable
-from typing_extensions import Final
+from typing import Callable, Final
 
 from mypy.nodes import (
+    EXCLUDED_ENUM_ATTRIBUTES,
+    TYPE_VAR_TUPLE_KIND,
     AssignmentStmt,
     CallExpr,
     ClassDef,
     Decorator,
+    EllipsisExpr,
     ExpressionStmt,
     FuncDef,
     Lvalue,
@@ -22,9 +24,10 @@
     StrExpr,
     TempNode,
     TypeInfo,
+    TypeParam,
     is_class_var,
 )
-from mypy.types import ENUM_REMOVED_PROPS, Instance, UnboundType, get_proper_type
+from mypy.types import Instance, UnboundType, get_proper_type
 from mypyc.common import PROPSET_PREFIX
 from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
 from mypyc.ir.func_ir import FuncDecl, FuncSignature
@@ -53,7 +56,7 @@
     is_optional_type,
     object_rprimitive,
 )
-from mypyc.irbuild.builder import IRBuilder
+from mypyc.irbuild.builder import IRBuilder, create_type_params
 from mypyc.irbuild.function import (
     gen_property_getter_ir,
     gen_property_setter_ir,
@@ -63,14 +66,22 @@
 )
 from mypyc.irbuild.util import dataclass_type, get_func_def, is_constant, is_dataclass_decorator
 from mypyc.primitives.dict_ops import dict_new_op, dict_set_item_op
-from mypyc.primitives.generic_ops import py_hasattr_op, py_setattr_op
+from mypyc.primitives.generic_ops import (
+    iter_op,
+    next_op,
+    py_get_item_op,
+    py_hasattr_op,
+    py_setattr_op,
+)
 from mypyc.primitives.misc_ops import (
     dataclass_sleight_of_hand,
+    import_op,
     not_implemented_op,
     py_calc_meta_op,
     pytype_from_template_op,
     type_object_op,
 )
+from mypyc.subtype import is_subtype
 
 
 def transform_class_def(builder: IRBuilder, cdef: ClassDef) -> None:
@@ -85,6 +96,10 @@ def transform_class_def(builder: IRBuilder, cdef: ClassDef) -> None:
 
     This is the main entry point to this module.
     """
+    if cdef.info not in builder.mapper.type_to_ir:
+        builder.error("Nested class definitions not supported", cdef.line)
+        return
+
     ir = builder.mapper.type_to_ir[cdef.info]
 
     # We do this check here because the base field of parent
@@ -136,7 +151,9 @@ def transform_class_def(builder: IRBuilder, cdef: ClassDef) -> None:
                 continue
             with builder.catch_errors(stmt.line):
                 cls_builder.add_method(get_func_def(stmt))
-        elif isinstance(stmt, PassStmt):
+        elif isinstance(stmt, PassStmt) or (
+            isinstance(stmt, ExpressionStmt) and isinstance(stmt.expr, EllipsisExpr)
+        ):
             continue
         elif isinstance(stmt, AssignmentStmt):
             if len(stmt.lvalues) != 1:
@@ -242,7 +259,7 @@ def finalize(self, ir: ClassIR) -> None:
         )
 
         # Add the non-extension class to the dict
-        self.builder.call_c(
+        self.builder.primitive_op(
             dict_set_item_op,
             [
                 self.builder.load_globals_dict(),
@@ -278,7 +295,7 @@ def add_attr(self, lvalue: NameExpr, stmt: AssignmentStmt) -> None:
             return
         typ = self.builder.load_native_type_object(self.cdef.fullname)
         value = self.builder.accept(stmt.rvalue)
-        self.builder.call_c(
+        self.builder.primitive_op(
             py_setattr_op, [typ, self.builder.load_str(lvalue.name), value], stmt.line
         )
         if self.builder.non_function_scope() and stmt.is_final_def:
@@ -363,9 +380,10 @@ def finalize(self, ir: ClassIR) -> None:
         dec = self.builder.accept(
             next(d for d in self.cdef.decorators if is_dataclass_decorator(d))
         )
+        dataclass_type_val = self.builder.load_str(dataclass_type(self.cdef) or "unknown")
         self.builder.call_c(
             dataclass_sleight_of_hand,
-            [dec, self.type_obj, self.non_ext.dict, self.non_ext.anns],
+            [dec, self.type_obj, self.non_ext.dict, self.non_ext.anns, dataclass_type_val],
             self.cdef.line,
         )
 
@@ -405,8 +423,14 @@ def get_type_annotation(self, stmt: AssignmentStmt) -> TypeInfo | None:
 def allocate_class(builder: IRBuilder, cdef: ClassDef) -> Value:
     # OK AND NOW THE FUN PART
     base_exprs = cdef.base_type_exprs + cdef.removed_base_type_exprs
-    if base_exprs:
-        bases = [builder.accept(x) for x in base_exprs]
+    new_style_type_args = cdef.type_args
+    if new_style_type_args:
+        bases = [make_generic_base_class(builder, cdef.fullname, new_style_type_args, cdef.line)]
+    else:
+        bases = []
+
+    if base_exprs or new_style_type_args:
+        bases.extend([builder.accept(x) for x in base_exprs])
         tp_bases = builder.new_tuple(bases, cdef.line)
     else:
         tp_bases = builder.add(LoadErrorValue(object_rprimitive, is_borrowed=True))
@@ -432,7 +456,7 @@ def allocate_class(builder: IRBuilder, cdef: ClassDef) -> Value:
             )
         )
     # Populate a '__mypyc_attrs__' field containing the list of attrs
-    builder.call_c(
+    builder.primitive_op(
         py_setattr_op,
         [
             tp,
@@ -446,13 +470,37 @@ def allocate_class(builder: IRBuilder, cdef: ClassDef) -> Value:
     builder.add(InitStatic(tp, cdef.name, builder.module_name, NAMESPACE_TYPE))
 
     # Add it to the dict
-    builder.call_c(
+    builder.primitive_op(
         dict_set_item_op, [builder.load_globals_dict(), builder.load_str(cdef.name), tp], cdef.line
     )
 
     return tp
 
 
+def make_generic_base_class(
+    builder: IRBuilder, fullname: str, type_args: list[TypeParam], line: int
+) -> Value:
+    """Construct Generic[...] base class object for a new-style generic class (Python 3.12)."""
+    mod = builder.call_c(import_op, [builder.load_str("_typing")], line)
+    tvs = create_type_params(builder, mod, type_args, line)
+    args = []
+    for tv, type_param in zip(tvs, type_args):
+        if type_param.kind == TYPE_VAR_TUPLE_KIND:
+            # Evaluate *Ts for a TypeVarTuple
+            it = builder.primitive_op(iter_op, [tv], line)
+            tv = builder.call_c(next_op, [it], line)
+        args.append(tv)
+
+    gent = builder.py_get_attr(mod, "Generic", line)
+    if len(args) == 1:
+        arg = args[0]
+    else:
+        arg = builder.new_tuple(args, line)
+
+    base = builder.primitive_op(py_get_item_op, [gent, arg], line)
+    return base
+
+
 # Mypy uses these internally as base classes of TypedDict classes. These are
 # lies and don't have any runtime equivalent.
 MAGIC_TYPED_DICT_CLASSES: Final[tuple[str, ...]] = (
@@ -469,7 +517,7 @@ def populate_non_ext_bases(builder: IRBuilder, cdef: ClassDef) -> Value:
     is_named_tuple = cdef.info.is_named_tuple
     ir = builder.mapper.type_to_ir[cdef.info]
     bases = []
-    for cls in cdef.info.mro[1:]:
+    for cls in (b.type for b in cdef.info.bases):
         if cls.fullname == "builtins.object":
             continue
         if is_named_tuple and cls.fullname in (
@@ -493,21 +541,10 @@ def populate_non_ext_bases(builder: IRBuilder, cdef: ClassDef) -> Value:
             # HAX: Mypy internally represents TypedDict classes differently from what
             #      should happen at runtime. Replace with something that works.
             module = "typing"
-            if builder.options.capi_version < (3, 9):
-                name = "TypedDict"
-                if builder.options.capi_version < (3, 8):
-                    # TypedDict was added to typing in Python 3.8.
-                    module = "typing_extensions"
-            else:
-                # In Python 3.9 TypedDict is not a real type.
-                name = "_TypedDict"
+            name = "_TypedDict"
             base = builder.get_module_attr(module, name, cdef.line)
         elif is_named_tuple and cls.fullname == "builtins.tuple":
-            if builder.options.capi_version < (3, 9):
-                name = "NamedTuple"
-            else:
-                # This was changed in Python 3.9.
-                name = "_NamedTuple"
+            name = "_NamedTuple"
             base = builder.get_module_attr("typing", name, cdef.line)
         else:
             cls_module = cls.fullname.rsplit(".", 1)[0]
@@ -551,7 +588,7 @@ def setup_non_ext_dict(
     This class dictionary is passed to the metaclass constructor.
     """
     # Check if the metaclass defines a __prepare__ method, and if so, call it.
-    has_prepare = builder.call_c(
+    has_prepare = builder.primitive_op(
         py_hasattr_op, [metaclass, builder.load_str("__prepare__")], cdef.line
     )
 
@@ -588,7 +625,16 @@ def add_non_ext_class_attr_ann(
     if get_type_info is not None:
         type_info = get_type_info(stmt)
         if type_info:
-            typ = load_type(builder, type_info, stmt.line)
+            # NOTE: Using string type information is similar to using
+            # `from __future__ import annotations` in standard python.
+            # NOTE: For string types we need to use the fullname since it
+            # includes the module. If string type doesn't have the module,
+            # @dataclass will try to get the current module and fail since the
+            # current module is not in sys.modules.
+            if builder.current_module == type_info.module_name and stmt.line < type_info.line:
+                typ = builder.load_str(type_info.fullname)
+            else:
+                typ = load_type(builder, type_info, stmt.unanalyzed_type, stmt.line)
 
     if typ is None:
         # FIXME: if get_type_info is not provided, don't fall back to stmt.type?
@@ -604,12 +650,12 @@ def add_non_ext_class_attr_ann(
             # actually a forward reference due to the __annotations__ future?
             typ = builder.load_str(stmt.unanalyzed_type.original_str_expr)
         elif isinstance(ann_type, Instance):
-            typ = load_type(builder, ann_type.type, stmt.line)
+            typ = load_type(builder, ann_type.type, stmt.unanalyzed_type, stmt.line)
         else:
             typ = builder.add(LoadAddress(type_object_op.type, type_object_op.src, stmt.line))
 
     key = builder.load_str(lvalue.name)
-    builder.call_c(dict_set_item_op, [non_ext.anns, key, typ], stmt.line)
+    builder.primitive_op(dict_set_item_op, [non_ext.anns, key, typ], stmt.line)
 
 
 def add_non_ext_class_attr(
@@ -630,9 +676,10 @@ def add_non_ext_class_attr(
         # are final.
         if (
             cdef.info.bases
-            and cdef.info.bases[0].type.fullname == "enum.Enum"
+            # Enum class must be the last parent class.
+            and cdef.info.bases[-1].type.is_enum
             # Skip these since Enum will remove it
-            and lvalue.name not in ENUM_REMOVED_PROPS
+            and lvalue.name not in EXCLUDED_ENUM_ATTRIBUTES
         ):
             # Enum values are always boxed, so use object_rprimitive.
             attr_to_cache.append((lvalue, object_rprimitive))
@@ -751,30 +798,42 @@ def create_ne_from_eq(builder: IRBuilder, cdef: ClassDef) -> None:
 
 def gen_glue_ne_method(builder: IRBuilder, cls: ClassIR, line: int) -> None:
     """Generate a "__ne__" method from a "__eq__" method."""
-    with builder.enter_method(cls, "__ne__", object_rprimitive):
-        rhs_arg = builder.add_argument("rhs", object_rprimitive)
-
-        # If __eq__ returns NotImplemented, then __ne__ should also
-        not_implemented_block, regular_block = BasicBlock(), BasicBlock()
+    func_ir = cls.get_method("__eq__")
+    assert func_ir
+    eq_sig = func_ir.decl.sig
+    strict_typing = builder.options.strict_dunders_typing
+    with builder.enter_method(cls, "__ne__", eq_sig.ret_type):
+        rhs_type = eq_sig.args[0].type if strict_typing else object_rprimitive
+        rhs_arg = builder.add_argument("rhs", rhs_type)
         eqval = builder.add(MethodCall(builder.self(), "__eq__", [rhs_arg], line))
-        not_implemented = builder.add(
-            LoadAddress(not_implemented_op.type, not_implemented_op.src, line)
-        )
-        builder.add(
-            Branch(
-                builder.translate_is_op(eqval, not_implemented, "is", line),
-                not_implemented_block,
-                regular_block,
-                Branch.BOOL,
-            )
-        )
 
-        builder.activate_block(regular_block)
-        retval = builder.coerce(builder.unary_op(eqval, "not", line), object_rprimitive, line)
-        builder.add(Return(retval))
+        can_return_not_implemented = is_subtype(not_implemented_op.type, eq_sig.ret_type)
+        return_bool = is_subtype(eq_sig.ret_type, bool_rprimitive)
 
-        builder.activate_block(not_implemented_block)
-        builder.add(Return(not_implemented))
+        if not strict_typing or can_return_not_implemented:
+            # If __eq__ returns NotImplemented, then __ne__ should also
+            not_implemented_block, regular_block = BasicBlock(), BasicBlock()
+            not_implemented = builder.add(
+                LoadAddress(not_implemented_op.type, not_implemented_op.src, line)
+            )
+            builder.add(
+                Branch(
+                    builder.translate_is_op(eqval, not_implemented, "is", line),
+                    not_implemented_block,
+                    regular_block,
+                    Branch.BOOL,
+                )
+            )
+            builder.activate_block(regular_block)
+            rettype = bool_rprimitive if return_bool and strict_typing else object_rprimitive
+            retval = builder.coerce(builder.unary_op(eqval, "not", line), rettype, line)
+            builder.add(Return(retval))
+            builder.activate_block(not_implemented_block)
+            builder.add(Return(not_implemented))
+        else:
+            rettype = bool_rprimitive if return_bool and strict_typing else object_rprimitive
+            retval = builder.coerce(builder.unary_op(eqval, "not", line), rettype, line)
+            builder.add(Return(retval))
 
 
 def load_non_ext_class(
diff --git a/mypyc/irbuild/constant_fold.py b/mypyc/irbuild/constant_fold.py
index bc71052f5418..12a4b15dd40c 100644
--- a/mypyc/irbuild/constant_fold.py
+++ b/mypyc/irbuild/constant_fold.py
@@ -10,16 +10,12 @@
 
 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_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 +27,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 +41,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/context.py b/mypyc/irbuild/context.py
index 676afb507504..a740f0b821d9 100644
--- a/mypyc/irbuild/context.py
+++ b/mypyc/irbuild/context.py
@@ -22,6 +22,7 @@ def __init__(
         contains_nested: bool = False,
         is_decorated: bool = False,
         in_non_ext: bool = False,
+        add_nested_funcs_to_env: bool = False,
     ) -> None:
         self.fitem = fitem
         self.name = name
@@ -47,6 +48,7 @@ def __init__(
         self.contains_nested = contains_nested
         self.is_decorated = is_decorated
         self.in_non_ext = in_non_ext
+        self.add_nested_funcs_to_env = add_nested_funcs_to_env
 
         # TODO: add field for ret_type: RType = none_rprimitive
 
diff --git a/mypyc/irbuild/env_class.py b/mypyc/irbuild/env_class.py
index ded8072deb63..ab786fe71dda 100644
--- a/mypyc/irbuild/env_class.py
+++ b/mypyc/irbuild/env_class.py
@@ -107,7 +107,7 @@ def load_env_registers(builder: IRBuilder) -> None:
         load_outer_envs(builder, fn_info.callable_class)
         # If this is a FuncDef, then make sure to load the FuncDef into its own environment
         # class so that the function can be called recursively.
-        if isinstance(fitem, FuncDef):
+        if isinstance(fitem, FuncDef) and fn_info.add_nested_funcs_to_env:
             setup_func_for_recursive_call(builder, fitem, fn_info.callable_class)
 
 
@@ -191,6 +191,41 @@ def add_args_to_env(
                 builder.add_var_to_env_class(arg.variable, rtype, base, reassign=reassign)
 
 
+def add_vars_to_env(builder: IRBuilder) -> None:
+    """Add relevant local variables and nested functions to the environment class.
+
+    Add all variables and functions that are declared/defined within current
+    function and are referenced in functions nested within this one to this
+    function's environment class so the nested functions can reference
+    them even if they are declared after the nested function's definition.
+    Note that this is done before visiting the body of the function.
+    """
+    env_for_func: FuncInfo | ImplicitClass = builder.fn_info
+    if builder.fn_info.is_generator:
+        env_for_func = builder.fn_info.generator_class
+    elif builder.fn_info.is_nested or builder.fn_info.in_non_ext:
+        env_for_func = builder.fn_info.callable_class
+
+    if builder.fn_info.fitem in builder.free_variables:
+        # Sort the variables to keep things deterministic
+        for var in sorted(builder.free_variables[builder.fn_info.fitem], key=lambda x: x.name):
+            if isinstance(var, Var):
+                rtype = builder.type_to_rtype(var.type)
+                builder.add_var_to_env_class(var, rtype, env_for_func, reassign=False)
+
+    if builder.fn_info.fitem in builder.encapsulating_funcs:
+        for nested_fn in builder.encapsulating_funcs[builder.fn_info.fitem]:
+            if isinstance(nested_fn, FuncDef):
+                # The return type is 'object' instead of an RInstance of the
+                # callable class because differently defined functions with
+                # the same name and signature across conditional blocks
+                # will generate different callable classes, so the callable
+                # class that gets instantiated must be generic.
+                builder.add_var_to_env_class(
+                    nested_fn, object_rprimitive, env_for_func, reassign=False
+                )
+
+
 def setup_func_for_recursive_call(builder: IRBuilder, fdef: FuncDef, base: ImplicitClass) -> None:
     """Enable calling a nested function (with a callable class) recursively.
 
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py
index 4ebc422ed535..c8c67cae309b 100644
--- a/mypyc/irbuild/expression.py
+++ b/mypyc/irbuild/expression.py
@@ -7,9 +7,11 @@
 from __future__ import annotations
 
 import math
-from typing import Callable, Sequence
+from collections.abc import Sequence
+from typing import Callable
 
 from mypy.nodes import (
+    ARG_NAMED,
     ARG_POS,
     LDEF,
     AssertTypeExpr,
@@ -44,6 +46,7 @@
     TupleExpr,
     TypeApplication,
     TypeInfo,
+    TypeVarLikeExpr,
     UnaryExpr,
     Var,
 )
@@ -55,10 +58,10 @@
     Assign,
     BasicBlock,
     ComparisonOp,
-    Float,
     Integer,
     LoadAddress,
     LoadLiteral,
+    PrimitiveDescription,
     RaiseStandardError,
     Register,
     TupleGet,
@@ -81,6 +84,7 @@
 from mypyc.irbuild.constant_fold import constant_fold_expr
 from mypyc.irbuild.for_helpers import (
     comprehension_helper,
+    raise_error_if_contains_unreachable_names,
     translate_list_comprehension,
     translate_set_comprehension,
 )
@@ -92,14 +96,12 @@
     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
-from mypyc.primitives.int_ops import int_comparison_op_mapping
 from mypyc.primitives.list_ops import list_append_op, list_extend_op, list_slice_op
 from mypyc.primitives.misc_ops import ellipsis_op, get_module_dict_op, new_slice_op, type_op
-from mypyc.primitives.registry import CFunctionDescription, builtin_names
+from mypyc.primitives.registry import builtin_names
 from mypyc.primitives.set_ops import set_add_op, set_in_op, set_update_op
 from mypyc.primitives.str_ops import str_slice_op
 from mypyc.primitives.tuple_ops import list_tuple_op, tuple_slice_op
@@ -108,6 +110,10 @@
 
 
 def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
+    if isinstance(expr.node, TypeVarLikeExpr) and expr.node.is_new_style:
+        # Reference to Python 3.12 implicit TypeVar/TupleVarTuple/... object.
+        # These are stored in C statics and not visible in Python namespaces.
+        return builder.load_type_var(expr.node.name, expr.node.line)
     if expr.node is None:
         builder.add(
             RaiseStandardError(
@@ -128,6 +134,8 @@ def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
         return builder.true()
     if fullname == "builtins.False":
         return builder.false()
+    if fullname in ("typing.TYPE_CHECKING", "typing_extensions.TYPE_CHECKING"):
+        return builder.false()
 
     math_literal = transform_math_literal(builder, fullname)
     if math_literal is not None:
@@ -176,7 +184,7 @@ def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
             # AST doesn't include a Var node for the module. We
             # instead load the module separately on each access.
             mod_dict = builder.call_c(get_module_dict_op, [], expr.line)
-            obj = builder.call_c(
+            obj = builder.primitive_op(
                 dict_get_item_op, [mod_dict, builder.load_str(expr.node.fullname)], expr.line
             )
             return obj
@@ -187,6 +195,10 @@ def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
 
 
 def transform_member_expr(builder: IRBuilder, expr: MemberExpr) -> Value:
+    # Special Cases
+    if expr.fullname in ("typing.TYPE_CHECKING", "typing_extensions.TYPE_CHECKING"):
+        return builder.false()
+
     # First check if this is maybe a final attribute.
     final = builder.get_final_ref(expr)
     if final is not None:
@@ -346,6 +358,7 @@ def translate_method_call(builder: IRBuilder, expr: CallExpr, callee: MemberExpr
         and isinstance(callee.expr.node, TypeInfo)
         and callee.expr.node in builder.mapper.type_to_ir
         and builder.mapper.type_to_ir[callee.expr.node].has_method(callee.name)
+        and all(kind in (ARG_POS, ARG_NAMED) for kind in expr.arg_kinds)
     ):
         # Call a method via the *class*
         assert isinstance(callee.expr.node, TypeInfo)
@@ -467,7 +480,7 @@ def translate_super_method_call(builder: IRBuilder, expr: CallExpr, callee: Supe
         # Grab first argument
         vself: Value = builder.self()
         if decl.kind == FUNC_CLASSMETHOD:
-            vself = builder.call_c(type_op, [vself], expr.line)
+            vself = builder.primitive_op(type_op, [vself], expr.line)
         elif builder.fn_info.is_generator:
             # For generator classes, the self target is the 6th value
             # in the symbol table (which is an ordered dict). This is sort
@@ -575,12 +588,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 +671,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 +690,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)
@@ -760,7 +764,7 @@ def transform_comparison_expr(builder: IRBuilder, e: ComparisonExpr) -> Value:
         set_literal = precompute_set_literal(builder, e.operands[1])
         if set_literal is not None:
             lhs = e.operands[0]
-            result = builder.builder.call_c(
+            result = builder.builder.primitive_op(
                 set_in_op, [builder.accept(lhs), set_literal], e.line, bool_rprimitive
             )
             if first_op == "not in":
@@ -782,7 +786,7 @@ def transform_comparison_expr(builder: IRBuilder, e: ComparisonExpr) -> Value:
                     borrow_left = is_borrow_friendly_expr(builder, right_expr)
                     left = builder.accept(left_expr, can_borrow=borrow_left)
                     right = builder.accept(right_expr, can_borrow=True)
-                    return builder.compare_tagged(left, right, first_op, e.line)
+                    return builder.binary_op(left, right, first_op, e.line)
 
     # TODO: Don't produce an expression when used in conditional context
     # All of the trickiness here is due to support for chained conditionals
@@ -818,29 +822,32 @@ def translate_is_none(builder: IRBuilder, expr: Expression, negated: bool) -> Va
 def transform_basic_comparison(
     builder: IRBuilder, op: str, left: Value, right: Value, line: int
 ) -> Value:
-    if (
-        is_int_rprimitive(left.type)
-        and is_int_rprimitive(right.type)
-        and op in int_comparison_op_mapping
-    ):
-        return builder.compare_tagged(left, right, op, line)
-    if is_fixed_width_rtype(left.type) and op in int_comparison_op_mapping:
+    if is_fixed_width_rtype(left.type) and op in ComparisonOp.signed_ops:
         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 op in ComparisonOp.signed_ops
         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
@@ -950,7 +957,7 @@ def transform_tuple_expr(builder: IRBuilder, expr: TupleExpr) -> Value:
 def _visit_tuple_display(builder: IRBuilder, expr: TupleExpr) -> Value:
     """Create a list, then turn it into a tuple."""
     val_as_list = _visit_list_display(builder, expr.items, expr.line)
-    return builder.call_c(list_tuple_op, [val_as_list], expr.line)
+    return builder.primitive_op(list_tuple_op, [val_as_list], expr.line)
 
 
 def transform_dict_expr(builder: IRBuilder, expr: DictExpr) -> Value:
@@ -974,8 +981,8 @@ def _visit_display(
     builder: IRBuilder,
     items: list[Expression],
     constructor_op: Callable[[list[Value], int], Value],
-    append_op: CFunctionDescription,
-    extend_op: CFunctionDescription,
+    append_op: PrimitiveDescription,
+    extend_op: PrimitiveDescription,
     line: int,
     is_list: bool,
 ) -> Value:
@@ -996,7 +1003,7 @@ def _visit_display(
         if result is None:
             result = constructor_op(initial_items, line)
 
-        builder.call_c(extend_op if starred else append_op, [result, value], line)
+        builder.primitive_op(extend_op if starred else append_op, [result, value], line)
 
     if result is None:
         result = constructor_op(initial_items, line)
@@ -1016,13 +1023,16 @@ def transform_set_comprehension(builder: IRBuilder, o: SetComprehension) -> Valu
 
 
 def transform_dictionary_comprehension(builder: IRBuilder, o: DictionaryComprehension) -> Value:
+    if raise_error_if_contains_unreachable_names(builder, o):
+        return builder.none()
+
     d = builder.maybe_spill(builder.call_c(dict_new_op, [], o.line))
     loop_params = list(zip(o.indices, o.sequences, o.condlists, o.is_async))
 
     def gen_inner_stmts() -> None:
         k = builder.accept(o.key)
         v = builder.accept(o.value)
-        builder.call_c(dict_set_item_op, [builder.read(d), k, v], o.line)
+        builder.primitive_op(dict_set_item_op, [builder.read(d), k, v], o.line)
 
     comprehension_helper(builder, loop_params, gen_inner_stmts, o.line)
     return builder.read(d)
@@ -1039,12 +1049,12 @@ def get_arg(arg: Expression | None) -> Value:
             return builder.accept(arg)
 
     args = [get_arg(expr.begin_index), get_arg(expr.end_index), get_arg(expr.stride)]
-    return builder.call_c(new_slice_op, args, expr.line)
+    return builder.primitive_op(new_slice_op, args, expr.line)
 
 
 def transform_generator_expr(builder: IRBuilder, o: GeneratorExpr) -> Value:
     builder.warning("Treating generator comprehension as list", o.line)
-    return builder.call_c(iter_op, [translate_list_comprehension(builder, o)], o.line)
+    return builder.primitive_op(iter_op, [translate_list_comprehension(builder, o)], o.line)
 
 
 def transform_assignment_expr(builder: IRBuilder, o: AssignmentExpr) -> Value:
diff --git a/mypyc/irbuild/for_helpers.py b/mypyc/irbuild/for_helpers.py
index 61dbbe960eb2..c5b1d1273bef 100644
--- a/mypyc/irbuild/for_helpers.py
+++ b/mypyc/irbuild/for_helpers.py
@@ -12,10 +12,12 @@
 from mypy.nodes import (
     ARG_POS,
     CallExpr,
+    DictionaryComprehension,
     Expression,
     GeneratorExpr,
     Lvalue,
     MemberExpr,
+    NameExpr,
     RefExpr,
     SetExpr,
     TupleExpr,
@@ -28,6 +30,7 @@
     IntOp,
     LoadAddress,
     LoadMem,
+    RaiseStandardError,
     Register,
     TupleGet,
     TupleSet,
@@ -229,6 +232,9 @@ def set_item(item_index: Value) -> None:
 
 
 def translate_list_comprehension(builder: IRBuilder, gen: GeneratorExpr) -> Value:
+    if raise_error_if_contains_unreachable_names(builder, gen):
+        return builder.none()
+
     # Try simplest list comprehension, otherwise fall back to general one
     val = sequence_from_generator_preallocate_helper(
         builder,
@@ -245,19 +251,42 @@ def translate_list_comprehension(builder: IRBuilder, gen: GeneratorExpr) -> Valu
 
     def gen_inner_stmts() -> None:
         e = builder.accept(gen.left_expr)
-        builder.call_c(list_append_op, [builder.read(list_ops), e], gen.line)
+        builder.primitive_op(list_append_op, [builder.read(list_ops), e], gen.line)
 
     comprehension_helper(builder, loop_params, gen_inner_stmts, gen.line)
     return builder.read(list_ops)
 
 
+def raise_error_if_contains_unreachable_names(
+    builder: IRBuilder, gen: GeneratorExpr | DictionaryComprehension
+) -> bool:
+    """Raise a runtime error and return True if generator contains unreachable names.
+
+    False is returned if the generator can be safely transformed without crashing.
+    (It may still be unreachable!)
+    """
+    if any(isinstance(s, NameExpr) and s.node is None for s in gen.indices):
+        error = RaiseStandardError(
+            RaiseStandardError.RUNTIME_ERROR,
+            "mypyc internal error: should be unreachable",
+            gen.line,
+        )
+        builder.add(error)
+        return True
+
+    return False
+
+
 def translate_set_comprehension(builder: IRBuilder, gen: GeneratorExpr) -> Value:
+    if raise_error_if_contains_unreachable_names(builder, gen):
+        return builder.none()
+
     set_ops = builder.maybe_spill(builder.new_set_op([], gen.line))
     loop_params = list(zip(gen.indices, gen.sequences, gen.condlists, gen.is_async))
 
     def gen_inner_stmts() -> None:
         e = builder.accept(gen.left_expr)
-        builder.call_c(set_add_op, [builder.read(set_ops), e], gen.line)
+        builder.primitive_op(set_add_op, [builder.read(set_ops), e], gen.line)
 
     comprehension_helper(builder, loop_params, gen_inner_stmts, gen.line)
     return builder.read(set_ops)
@@ -557,7 +586,7 @@ def init(self, expr_reg: Value, target_type: RType) -> None:
         # for the for-loop. If we are inside of a generator function, spill these into the
         # environment class.
         builder = self.builder
-        iter_reg = builder.call_c(iter_op, [expr_reg], self.line)
+        iter_reg = builder.primitive_op(iter_op, [expr_reg], self.line)
         builder.maybe_spill(expr_reg)
         self.iter_target = builder.maybe_spill(iter_reg)
         self.target_type = target_type
@@ -664,7 +693,7 @@ def unsafe_index(builder: IRBuilder, target: Value, index: Value, line: int) ->
     # since we want to use __getitem__ if we don't have an unsafe version,
     # so we just check manually.
     if is_list_rprimitive(target.type):
-        return builder.call_c(list_get_item_unsafe_op, [target, index], line)
+        return builder.primitive_op(list_get_item_unsafe_op, [target, index], line)
     else:
         return builder.gen_method_call(target, "__getitem__", [index], None, line)
 
@@ -956,7 +985,6 @@ def init(self) -> None:
         zero = Integer(0)
         self.index_reg = builder.maybe_spill_assignable(zero)
         self.index_target: Register | AssignmentTarget = builder.get_assignment_target(self.index)
-        builder.assign(self.index_target, zero, self.line)
 
     def gen_step(self) -> None:
         builder = self.builder
@@ -968,7 +996,9 @@ def gen_step(self) -> None:
             short_int_rprimitive, builder.read(self.index_reg, line), Integer(1), IntOp.ADD, line
         )
         builder.assign(self.index_reg, new_val, line)
-        builder.assign(self.index_target, new_val, line)
+
+    def begin_body(self) -> None:
+        self.builder.assign(self.index_target, self.builder.read(self.index_reg), self.line)
 
 
 class ForEnumerate(ForGenerator):
diff --git a/mypyc/irbuild/format_str_tokenizer.py b/mypyc/irbuild/format_str_tokenizer.py
index 480c683aa164..eaa4027ed768 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,
@@ -146,12 +146,12 @@ def convert_format_expr_to_str(
             if is_str_rprimitive(node_type):
                 var_str = builder.accept(x)
             elif is_int_rprimitive(node_type) or is_short_int_rprimitive(node_type):
-                var_str = builder.call_c(int_to_str_op, [builder.accept(x)], line)
+                var_str = builder.primitive_op(int_to_str_op, [builder.accept(x)], line)
             else:
-                var_str = builder.call_c(str_op, [builder.accept(x)], line)
+                var_str = builder.primitive_op(str_op, [builder.accept(x)], line)
         elif format_op == FormatOp.INT:
             if is_int_rprimitive(node_type) or is_short_int_rprimitive(node_type):
-                var_str = builder.call_c(int_to_str_op, [builder.accept(x)], line)
+                var_str = builder.primitive_op(int_to_str_op, [builder.accept(x)], line)
             else:
                 return None
         else:
diff --git a/mypyc/irbuild/function.py b/mypyc/irbuild/function.py
index 822350ea829b..cb9a1a3dc4a3 100644
--- a/mypyc/irbuild/function.py
+++ b/mypyc/irbuild/function.py
@@ -13,21 +13,22 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import NamedTuple, Sequence
+from collections.abc import Sequence
+from typing import NamedTuple
 
 from mypy.nodes import (
     ArgKind,
     ClassDef,
     Decorator,
+    FuncBase,
     FuncDef,
     FuncItem,
     LambdaExpr,
     OverloadedFuncDef,
-    SymbolNode,
     TypeInfo,
     Var,
 )
-from mypy.types import CallableType, get_proper_type
+from mypy.types import CallableType, Type, UnboundType, get_proper_type
 from mypyc.common import LAMBDA_NAME, PROPSET_PREFIX, SELF_NAME
 from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
 from mypyc.ir.func_ir import (
@@ -42,7 +43,6 @@
 from mypyc.ir.ops import (
     BasicBlock,
     GetAttr,
-    InitStatic,
     Integer,
     LoadAddress,
     LoadLiteral,
@@ -60,31 +60,22 @@
     int_rprimitive,
     object_rprimitive,
 )
-from mypyc.irbuild.builder import IRBuilder, SymbolTarget, gen_arg_defaults
+from mypyc.irbuild.builder import IRBuilder, calculate_arg_defaults, gen_arg_defaults
 from mypyc.irbuild.callable_class import (
     add_call_to_callable_class,
     add_get_to_callable_class,
     instantiate_callable_class,
     setup_callable_class,
 )
-from mypyc.irbuild.context import FuncInfo, ImplicitClass
+from mypyc.irbuild.context import FuncInfo
 from mypyc.irbuild.env_class import (
+    add_vars_to_env,
     finalize_env_class,
     load_env_registers,
-    load_outer_envs,
     setup_env_class,
-    setup_func_for_recursive_call,
-)
-from mypyc.irbuild.generator import (
-    add_methods_to_generator_class,
-    add_raise_exception_blocks_to_generator_class,
-    create_switch_for_generator_class,
-    gen_generator_func,
-    populate_switch_for_generator_class,
-    setup_env_for_generator_class,
 )
+from mypyc.irbuild.generator import gen_generator_func, gen_generator_func_body
 from mypyc.irbuild.targets import AssignmentTarget
-from mypyc.irbuild.util import is_constant
 from mypyc.primitives.dict_ops import dict_get_method_with_none, dict_new_op, dict_set_item_op
 from mypyc.primitives.generic_ops import py_setattr_op
 from mypyc.primitives.misc_ops import register_function
@@ -95,14 +86,15 @@
 
 
 def transform_func_def(builder: IRBuilder, fdef: FuncDef) -> None:
-    func_ir, func_reg = gen_func_item(builder, fdef, fdef.name, builder.mapper.fdef_to_sig(fdef))
+    sig = builder.mapper.fdef_to_sig(fdef, builder.options.strict_dunders_typing)
+    func_ir, func_reg = gen_func_item(builder, fdef, fdef.name, sig)
 
     # If the function that was visited was a nested function, then either look it up in our
     # current environment or define it if it was not already defined.
     if func_reg:
         builder.assign(get_func_target(builder, fdef), func_reg, fdef.line)
     maybe_insert_into_registry_dict(builder, fdef)
-    builder.functions.append(func_ir)
+    builder.add_function(func_ir, fdef.line)
 
 
 def transform_overloaded_func_def(builder: IRBuilder, o: OverloadedFuncDef) -> None:
@@ -112,9 +104,8 @@ def transform_overloaded_func_def(builder: IRBuilder, o: OverloadedFuncDef) -> N
 
 
 def transform_decorator(builder: IRBuilder, dec: Decorator) -> None:
-    func_ir, func_reg = gen_func_item(
-        builder, dec.func, dec.func.name, builder.mapper.fdef_to_sig(dec.func)
-    )
+    sig = builder.mapper.fdef_to_sig(dec.func, builder.options.strict_dunders_typing)
+    func_ir, func_reg = gen_func_item(builder, dec.func, dec.func.name, sig)
     decorated_func: Value | None = None
     if func_reg:
         decorated_func = load_decorated_func(builder, dec.func, func_reg)
@@ -132,7 +123,7 @@ def transform_decorator(builder: IRBuilder, dec: Decorator) -> None:
 
     if decorated_func is not None:
         # Set the callable object representing the decorated function as a global.
-        builder.call_c(
+        builder.primitive_op(
             dict_set_item_op,
             [builder.load_globals_dict(), builder.load_str(dec.func.name), decorated_func],
             decorated_func.line,
@@ -222,6 +213,7 @@ def c() -> None:
     is_decorated = fitem in builder.fdefs_to_decorators
     is_singledispatch = fitem in builder.singledispatch_impls
     in_non_ext = False
+    add_nested_funcs_to_env = has_nested_func_self_reference(builder, fitem)
     class_name = None
     if cdef:
         ir = builder.mapper.type_to_ir[cdef.info]
@@ -232,116 +224,92 @@ def c() -> None:
         func_name = singledispatch_main_func_name(name)
     else:
         func_name = name
-    builder.enter(
-        FuncInfo(
-            fitem,
-            func_name,
-            class_name,
-            gen_func_ns(builder),
-            is_nested,
-            contains_nested,
-            is_decorated,
-            in_non_ext,
-        )
+
+    fn_info = FuncInfo(
+        fitem=fitem,
+        name=func_name,
+        class_name=class_name,
+        namespace=gen_func_ns(builder),
+        is_nested=is_nested,
+        contains_nested=contains_nested,
+        is_decorated=is_decorated,
+        in_non_ext=in_non_ext,
+        add_nested_funcs_to_env=add_nested_funcs_to_env,
     )
+    is_generator = fn_info.is_generator
+    builder.enter(fn_info, ret_type=sig.ret_type)
 
     # Functions that contain nested functions need an environment class to store variables that
     # are free in their nested functions. Generator functions need an environment class to
     # store a variable denoting the next instruction to be executed when the __next__ function
     # is called, along with all the variables inside the function itself.
-    if builder.fn_info.contains_nested or builder.fn_info.is_generator:
+    if contains_nested or is_generator:
         setup_env_class(builder)
 
-    if builder.fn_info.is_nested or builder.fn_info.in_non_ext:
+    if is_nested or in_non_ext:
         setup_callable_class(builder)
 
-    if builder.fn_info.is_generator:
-        # Do a first-pass and generate a function that just returns a generator object.
-        gen_generator_func(builder)
-        args, _, blocks, ret_type, fn_info = builder.leave()
-        func_ir, func_reg = gen_func_ir(
-            builder, args, blocks, sig, fn_info, cdef, is_singledispatch
+    if is_generator:
+        # First generate a function that just constructs and returns a generator object.
+        func_ir, func_reg = gen_generator_func(
+            builder,
+            lambda args, blocks, fn_info: gen_func_ir(
+                builder, args, blocks, sig, fn_info, cdef, is_singledispatch
+            ),
         )
 
         # Re-enter the FuncItem and visit the body of the function this time.
-        builder.enter(fn_info)
-        setup_env_for_generator_class(builder)
-        load_outer_envs(builder, builder.fn_info.generator_class)
-        if builder.fn_info.is_nested and isinstance(fitem, FuncDef):
-            setup_func_for_recursive_call(builder, fitem, builder.fn_info.generator_class)
-        create_switch_for_generator_class(builder)
-        add_raise_exception_blocks_to_generator_class(builder, fitem.line)
+        gen_generator_func_body(builder, fn_info, sig, func_reg)
     else:
-        load_env_registers(builder)
-        gen_arg_defaults(builder)
+        func_ir, func_reg = gen_func_body(builder, sig, cdef, is_singledispatch)
 
-    if builder.fn_info.contains_nested and not builder.fn_info.is_generator:
-        finalize_env_class(builder)
+    if is_singledispatch:
+        # add the generated main singledispatch function
+        builder.functions.append(func_ir)
+        # create the dispatch function
+        assert isinstance(fitem, FuncDef)
+        return gen_dispatch_func_ir(builder, fitem, fn_info.name, name, sig)
 
-    builder.ret_types[-1] = sig.ret_type
+    return func_ir, func_reg
 
-    # Add all variables and functions that are declared/defined within this
-    # function and are referenced in functions nested within this one to this
-    # function's environment class so the nested functions can reference
-    # them even if they are declared after the nested function's definition.
-    # Note that this is done before visiting the body of this function.
-
-    env_for_func: FuncInfo | ImplicitClass = builder.fn_info
-    if builder.fn_info.is_generator:
-        env_for_func = builder.fn_info.generator_class
-    elif builder.fn_info.is_nested or builder.fn_info.in_non_ext:
-        env_for_func = builder.fn_info.callable_class
-
-    if builder.fn_info.fitem in builder.free_variables:
-        # Sort the variables to keep things deterministic
-        for var in sorted(builder.free_variables[builder.fn_info.fitem], key=lambda x: x.name):
-            if isinstance(var, Var):
-                rtype = builder.type_to_rtype(var.type)
-                builder.add_var_to_env_class(var, rtype, env_for_func, reassign=False)
-
-    if builder.fn_info.fitem in builder.encapsulating_funcs:
-        for nested_fn in builder.encapsulating_funcs[builder.fn_info.fitem]:
-            if isinstance(nested_fn, FuncDef):
-                # The return type is 'object' instead of an RInstance of the
-                # callable class because differently defined functions with
-                # the same name and signature across conditional blocks
-                # will generate different callable classes, so the callable
-                # class that gets instantiated must be generic.
-                builder.add_var_to_env_class(
-                    nested_fn, object_rprimitive, env_for_func, reassign=False
-                )
 
-    builder.accept(fitem.body)
+def gen_func_body(
+    builder: IRBuilder, sig: FuncSignature, cdef: ClassDef | None, is_singledispatch: bool
+) -> tuple[FuncIR, Value | None]:
+    load_env_registers(builder)
+    gen_arg_defaults(builder)
+    if builder.fn_info.contains_nested:
+        finalize_env_class(builder)
+    add_vars_to_env(builder)
+    builder.accept(builder.fn_info.fitem.body)
     builder.maybe_add_implicit_return()
 
-    if builder.fn_info.is_generator:
-        populate_switch_for_generator_class(builder)
-
     # Hang on to the local symbol table for a while, since we use it
     # to calculate argument defaults below.
     symtable = builder.symtables[-1]
 
     args, _, blocks, ret_type, fn_info = builder.leave()
 
-    if fn_info.is_generator:
-        add_methods_to_generator_class(builder, fn_info, sig, args, blocks, fitem.is_coroutine)
-    else:
-        func_ir, func_reg = gen_func_ir(
-            builder, args, blocks, sig, fn_info, cdef, is_singledispatch
-        )
+    func_ir, func_reg = gen_func_ir(builder, args, blocks, sig, fn_info, cdef, is_singledispatch)
 
     # Evaluate argument defaults in the surrounding scope, since we
     # calculate them *once* when the function definition is evaluated.
     calculate_arg_defaults(builder, fn_info, func_reg, symtable)
+    return func_ir, func_reg
 
-    if is_singledispatch:
-        # add the generated main singledispatch function
-        builder.functions.append(func_ir)
-        # create the dispatch function
-        assert isinstance(fitem, FuncDef)
-        return gen_dispatch_func_ir(builder, fitem, fn_info.name, name, sig)
 
-    return func_ir, func_reg
+def has_nested_func_self_reference(builder: IRBuilder, fitem: FuncItem) -> bool:
+    """Does a nested function contain a self-reference in its body?
+
+    If a nested function only has references in the surrounding function,
+    we don't need to add it to the environment.
+    """
+    if any(isinstance(sym, FuncBase) for sym in builder.free_variables.get(fitem, set())):
+        return True
+    return any(
+        has_nested_func_self_reference(builder, nested)
+        for nested in builder.encapsulating_funcs.get(fitem, [])
+    )
 
 
 def gen_func_ir(
@@ -393,7 +361,8 @@ def handle_ext_method(builder: IRBuilder, cdef: ClassDef, fdef: FuncDef) -> None
     # Perform the function of visit_method for methods inside extension classes.
     name = fdef.name
     class_ir = builder.mapper.type_to_ir[cdef.info]
-    func_ir, func_reg = gen_func_item(builder, fdef, name, builder.mapper.fdef_to_sig(fdef), cdef)
+    sig = builder.mapper.fdef_to_sig(fdef, builder.options.strict_dunders_typing)
+    func_ir, func_reg = gen_func_item(builder, fdef, name, sig, cdef)
     builder.functions.append(func_ir)
 
     if is_decorated(builder, fdef):
@@ -409,7 +378,9 @@ def handle_ext_method(builder: IRBuilder, cdef: ClassDef, fdef: FuncDef) -> None
 
         # Set the callable object representing the decorated method as an attribute of the
         # extension class.
-        builder.call_c(py_setattr_op, [typ, builder.load_str(name), decorated_func], fdef.line)
+        builder.primitive_op(
+            py_setattr_op, [typ, builder.load_str(name), decorated_func], fdef.line
+        )
 
     if fdef.is_property:
         # If there is a property setter, it will be processed after the getter,
@@ -458,7 +429,8 @@ def handle_non_ext_method(
 ) -> None:
     # Perform the function of visit_method for methods inside non-extension classes.
     name = fdef.name
-    func_ir, func_reg = gen_func_item(builder, fdef, name, builder.mapper.fdef_to_sig(fdef), cdef)
+    sig = builder.mapper.fdef_to_sig(fdef, builder.options.strict_dunders_typing)
+    func_ir, func_reg = gen_func_item(builder, fdef, name, sig, cdef)
     assert func_reg is not None
     builder.functions.append(func_ir)
 
@@ -483,33 +455,6 @@ def handle_non_ext_method(
     builder.add_to_non_ext_dict(non_ext, name, func_reg, fdef.line)
 
 
-def calculate_arg_defaults(
-    builder: IRBuilder,
-    fn_info: FuncInfo,
-    func_reg: Value | None,
-    symtable: dict[SymbolNode, SymbolTarget],
-) -> None:
-    """Calculate default argument values and store them.
-
-    They are stored in statics for top level functions and in
-    the function objects for nested functions (while constants are
-    still stored computed on demand).
-    """
-    fitem = fn_info.fitem
-    for arg in fitem.arguments:
-        # Constant values don't get stored but just recomputed
-        if arg.initializer and not is_constant(arg.initializer):
-            value = builder.coerce(
-                builder.accept(arg.initializer), symtable[arg.variable].type, arg.line
-            )
-            if not fn_info.is_nested:
-                name = fitem.fullname + "." + arg.variable.name
-                builder.add(InitStatic(value, name, builder.module_name))
-            else:
-                assert func_reg is not None
-                builder.add(SetAttr(func_reg, arg.variable.name, value, arg.line))
-
-
 def gen_func_ns(builder: IRBuilder) -> str:
     """Generate a namespace for a nested function using its outer function names."""
     return "_".join(
@@ -768,19 +713,58 @@ def get_func_target(builder: IRBuilder, fdef: FuncDef) -> AssignmentTarget:
         # Get the target associated with the previously defined FuncDef.
         return builder.lookup(fdef.original_def)
 
-    if builder.fn_info.is_generator or builder.fn_info.contains_nested:
+    if builder.fn_info.is_generator or builder.fn_info.add_nested_funcs_to_env:
         return builder.lookup(fdef)
 
     return builder.add_local_reg(fdef, object_rprimitive)
 
 
-def load_type(builder: IRBuilder, typ: TypeInfo, line: int) -> Value:
+# This function still does not support the following imports.
+# import json as _json
+# from json import decoder
+# Using either _json.JSONDecoder or decoder.JSONDecoder as a type hint for a dataclass field will fail.
+# See issue mypyc/mypyc#1099.
+def load_type(builder: IRBuilder, typ: TypeInfo, unbounded_type: Type | None, line: int) -> Value:
+    # typ.fullname contains the module where the class object was defined. However, it is possible
+    # that the class object's module was not imported in the file currently being compiled. So, we
+    # use unbounded_type.name (if provided by caller) to load the class object through one of the
+    # imported modules.
+    # Example: for `json.JSONDecoder`, typ.fullname is `json.decoder.JSONDecoder` but the Python
+    # file may import `json` not `json.decoder`.
+    # Another corner case: The Python file being compiled imports mod1 and has a type hint
+    # `mod1.OuterClass.InnerClass`. But, mod1/__init__.py might import OuterClass like this:
+    # `from mod2.mod3 import OuterClass`. In this case, typ.fullname is
+    # `mod2.mod3.OuterClass.InnerClass` and `unbounded_type.name` is `mod1.OuterClass.InnerClass`.
+    # So, we must use unbounded_type.name to load the class object.
+    # See issue mypyc/mypyc#1087.
+    load_attr_path = (
+        unbounded_type.name if isinstance(unbounded_type, UnboundType) else typ.fullname
+    ).removesuffix(f".{typ.name}")
     if typ in builder.mapper.type_to_ir:
         class_ir = builder.mapper.type_to_ir[typ]
         class_obj = builder.builder.get_native_type(class_ir)
     elif typ.fullname in builtin_names:
         builtin_addr_type, src = builtin_names[typ.fullname]
         class_obj = builder.add(LoadAddress(builtin_addr_type, src, line))
+    # This elif-condition finds the longest import that matches the load_attr_path.
+    elif module_name := max(
+        (i for i in builder.imports if load_attr_path == i or load_attr_path.startswith(f"{i}.")),
+        default="",
+        key=len,
+    ):
+        # Load the imported module.
+        loaded_module = builder.load_module(module_name)
+        # Recursively load attributes of the imported module. These may be submodules, classes or
+        # any other object.
+        for attr in (
+            load_attr_path.removeprefix(f"{module_name}.").split(".")
+            if load_attr_path != module_name
+            else []
+        ):
+            loaded_module = builder.py_get_attr(loaded_module, attr, line)
+        class_obj = builder.builder.get_attr(
+            loaded_module, typ.name, object_rprimitive, line, borrow=False
+        )
     else:
         class_obj = builder.load_global_str(typ.name, line)
 
@@ -817,7 +801,7 @@ def generate_singledispatch_dispatch_function(
         dispatch_func_obj, "dispatch_cache", dict_rprimitive, line
     )
     call_find_impl, use_cache, call_func = BasicBlock(), BasicBlock(), BasicBlock()
-    get_result = builder.call_c(dict_get_method_with_none, [dispatch_cache, arg_type], line)
+    get_result = builder.primitive_op(dict_get_method_with_none, [dispatch_cache, arg_type], line)
     is_not_none = builder.translate_is_op(get_result, builder.none_object(), "is not", line)
     impl_to_use = Register(object_rprimitive)
     builder.add_bool_branch(is_not_none, use_cache, call_find_impl)
@@ -830,7 +814,7 @@ def generate_singledispatch_dispatch_function(
     find_impl = builder.load_module_attr_by_fullname("functools._find_impl", line)
     registry = load_singledispatch_registry(builder, dispatch_func_obj, line)
     uncached_impl = builder.py_call(find_impl, [arg_type, registry], line)
-    builder.call_c(dict_set_item_op, [dispatch_cache, arg_type, uncached_impl], line)
+    builder.primitive_op(dict_set_item_op, [dispatch_cache, arg_type, uncached_impl], line)
     builder.assign(impl_to_use, uncached_impl, line)
     builder.goto(call_func)
 
@@ -866,9 +850,8 @@ def gen_native_func_call_and_return(fdef: FuncDef) -> None:
         call_impl, next_impl = BasicBlock(), BasicBlock()
 
         current_id = builder.load_int(i)
-        builder.builder.compare_tagged_condition(
-            passed_id, current_id, "==", call_impl, next_impl, line
-        )
+        cond = builder.binary_op(passed_id, current_id, "==", line)
+        builder.add_bool_branch(cond, call_impl, next_impl)
 
         # Call the registered implementation
         builder.activate_block(call_impl)
@@ -944,7 +927,7 @@ def generate_singledispatch_callable_class_ctor(builder: IRBuilder) -> None:
         cache_dict = builder.call_c(dict_new_op, [], line)
         dispatch_cache_str = builder.load_str("dispatch_cache")
         # use the py_setattr_op instead of SetAttr so that it also gets added to our __dict__
-        builder.call_c(py_setattr_op, [builder.self(), dispatch_cache_str, cache_dict], line)
+        builder.primitive_op(py_setattr_op, [builder.self(), dispatch_cache_str, cache_dict], line)
         # the generated C code seems to expect that __init__ returns a char, so just return 1
         builder.add(Return(Integer(1, bool_rprimitive, line), line))
 
@@ -966,10 +949,6 @@ def singledispatch_main_func_name(orig_name: str) -> str:
     return f"__mypyc_singledispatch_main_function_{orig_name}__"
 
 
-def get_registry_identifier(fitem: FuncDef) -> str:
-    return f"__mypyc_singledispatch_registry_{fitem.fullname}__"
-
-
 def maybe_insert_into_registry_dict(builder: IRBuilder, fitem: FuncDef) -> None:
     line = fitem.line
     is_singledispatch_main_func = fitem in builder.singledispatch_impls
@@ -991,7 +970,7 @@ def maybe_insert_into_registry_dict(builder: IRBuilder, fitem: FuncDef) -> None:
         registry_dict = builder.builder.make_dict([(loaded_object_type, main_func_obj)], line)
 
         dispatch_func_obj = builder.load_global_str(fitem.name, line)
-        builder.call_c(
+        builder.primitive_op(
             py_setattr_op, [dispatch_func_obj, builder.load_str("registry"), registry_dict], line
         )
 
@@ -1011,8 +990,8 @@ def maybe_insert_into_registry_dict(builder: IRBuilder, fitem: FuncDef) -> None:
         )
         registry = load_singledispatch_registry(builder, dispatch_func_obj, line)
         for typ in types:
-            loaded_type = load_type(builder, typ, line)
-            builder.call_c(dict_set_item_op, [registry, loaded_type, to_insert], line)
+            loaded_type = load_type(builder, typ, None, line)
+            builder.primitive_op(dict_set_item_op, [registry, loaded_type, to_insert], line)
         dispatch_cache = builder.builder.get_attr(
             dispatch_func_obj, "dispatch_cache", dict_rprimitive, line
         )
diff --git a/mypyc/irbuild/generator.py b/mypyc/irbuild/generator.py
index 92f9abff467c..74c8d27a6324 100644
--- a/mypyc/irbuild/generator.py
+++ b/mypyc/irbuild/generator.py
@@ -10,7 +10,9 @@
 
 from __future__ import annotations
 
-from mypy.nodes import ARG_OPT, Var
+from typing import Callable
+
+from mypy.nodes import ARG_OPT, FuncDef, Var
 from mypyc.common import ENV_ATTR_NAME, NEXT_LABEL_ATTR_NAME, SELF_NAME
 from mypyc.ir.class_ir import ClassIR
 from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature, RuntimeArg
@@ -31,13 +33,16 @@
     Value,
 )
 from mypyc.ir.rtypes import RInstance, int_rprimitive, object_rprimitive
-from mypyc.irbuild.builder import IRBuilder, gen_arg_defaults
+from mypyc.irbuild.builder import IRBuilder, calculate_arg_defaults, gen_arg_defaults
 from mypyc.irbuild.context import FuncInfo, GeneratorClass
 from mypyc.irbuild.env_class import (
     add_args_to_env,
+    add_vars_to_env,
     finalize_env_class,
     load_env_registers,
     load_outer_env,
+    load_outer_envs,
+    setup_func_for_recursive_call,
 )
 from mypyc.irbuild.nonlocalcontrol import ExceptNonlocalControl
 from mypyc.primitives.exc_ops import (
@@ -49,13 +54,69 @@
 )
 
 
-def gen_generator_func(builder: IRBuilder) -> None:
+def gen_generator_func(
+    builder: IRBuilder,
+    gen_func_ir: Callable[
+        [list[Register], list[BasicBlock], FuncInfo], tuple[FuncIR, Value | None]
+    ],
+) -> tuple[FuncIR, Value | None]:
+    """Generate IR for generator function that returns generator object."""
     setup_generator_class(builder)
     load_env_registers(builder)
     gen_arg_defaults(builder)
     finalize_env_class(builder)
     builder.add(Return(instantiate_generator_class(builder)))
 
+    args, _, blocks, ret_type, fn_info = builder.leave()
+    func_ir, func_reg = gen_func_ir(args, blocks, fn_info)
+    return func_ir, func_reg
+
+
+def gen_generator_func_body(
+    builder: IRBuilder, fn_info: FuncInfo, sig: FuncSignature, func_reg: Value | None
+) -> None:
+    """Generate IR based on the body of a generator function.
+
+    Add "__next__", "__iter__" and other generator methods to the generator
+    class that implements the function (each function gets a separate class).
+
+    Return the symbol table for the body.
+    """
+    builder.enter(fn_info, ret_type=sig.ret_type)
+    setup_env_for_generator_class(builder)
+
+    load_outer_envs(builder, builder.fn_info.generator_class)
+    top_level = builder.top_level_fn_info()
+    fitem = fn_info.fitem
+    if (
+        builder.fn_info.is_nested
+        and isinstance(fitem, FuncDef)
+        and top_level
+        and top_level.add_nested_funcs_to_env
+    ):
+        setup_func_for_recursive_call(builder, fitem, builder.fn_info.generator_class)
+    create_switch_for_generator_class(builder)
+    add_raise_exception_blocks_to_generator_class(builder, fitem.line)
+
+    add_vars_to_env(builder)
+
+    builder.accept(fitem.body)
+    builder.maybe_add_implicit_return()
+
+    populate_switch_for_generator_class(builder)
+
+    # Hang on to the local symbol table, since the caller will use it
+    # to calculate argument defaults.
+    symtable = builder.symtables[-1]
+
+    args, _, blocks, ret_type, fn_info = builder.leave()
+
+    add_methods_to_generator_class(builder, fn_info, sig, args, blocks, fitem.is_coroutine)
+
+    # Evaluate argument defaults in the surrounding scope, since we
+    # calculate them *once* when the function definition is evaluated.
+    calculate_arg_defaults(builder, fn_info, func_reg, symtable)
+
 
 def instantiate_generator_class(builder: IRBuilder) -> Value:
     fitem = builder.fn_info.fitem
@@ -181,6 +242,8 @@ def add_helper_to_generator_class(
     )
     fn_info.generator_class.ir.methods["__mypyc_generator_helper__"] = helper_fn_ir
     builder.functions.append(helper_fn_ir)
+    fn_info.env_class.env_user_function = helper_fn_ir
+
     return helper_fn_decl
 
 
diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py
index aa152d32a144..6bc1eb9d0493 100644
--- a/mypyc/irbuild/ll_builder.py
+++ b/mypyc/irbuild/ll_builder.py
@@ -1,21 +1,17 @@
 """A "low-level" IR builder class.
 
-LowLevelIRBuilder provides core abstractions we use for constructing
-IR as well as a number of higher-level ones (accessing attributes,
-calling functions and methods, and coercing between types, for
-example). The core principle of the low-level IR builder is that all
-of its facilities operate solely on the IR level and not the AST
-level---it has *no knowledge* of mypy types or expressions.
+See the docstring of class LowLevelIRBuilder for more information.
+
 """
 
 from __future__ import annotations
 
-from typing import Callable, Optional, Sequence, Tuple
-from typing_extensions import Final
+from collections.abc import Sequence
+from typing import Callable, Final, Optional
 
 from mypy.argmap import map_actuals_to_formals
 from mypy.nodes import ARG_POS, ARG_STAR, ARG_STAR2, ArgKind
-from mypy.operators import op_methods
+from mypy.operators import op_methods, unary_op_methods
 from mypy.types import AnyType, TypeOfAny
 from mypyc.common import (
     BITMAP_BITS,
@@ -25,9 +21,8 @@
     MIN_LITERAL_SHORT_INT,
     MIN_SHORT_INT,
     PLATFORM_SIZE,
-    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 (
@@ -63,9 +58,10 @@
     LoadStatic,
     MethodCall,
     Op,
+    PrimitiveDescription,
+    PrimitiveOp,
     RaiseStandardError,
     Register,
-    SetMem,
     Truncate,
     TupleGet,
     TupleSet,
@@ -77,10 +73,8 @@
     int_op_to_id,
 )
 from mypyc.ir.rtypes import (
-    PyListObject,
     PyObject,
     PySetObject,
-    PyVarObject,
     RArray,
     RInstance,
     RPrimitive,
@@ -95,6 +89,7 @@
     c_pointer_rprimitive,
     c_pyssize_t_rprimitive,
     c_size_t_rprimitive,
+    check_native_int_range,
     dict_rprimitive,
     float_rprimitive,
     int_rprimitive,
@@ -104,6 +99,8 @@
     is_dict_rprimitive,
     is_fixed_width_rtype,
     is_float_rprimitive,
+    is_frozenset_rprimitive,
+    is_int16_rprimitive,
     is_int32_rprimitive,
     is_int64_rprimitive,
     is_int_rprimitive,
@@ -114,6 +111,7 @@
     is_str_rprimitive,
     is_tagged,
     is_tuple_rprimitive,
+    is_uint8_rprimitive,
     list_rprimitive,
     none_rprimitive,
     object_pointer_rprimitive,
@@ -123,7 +121,6 @@
     short_int_rprimitive,
     str_rprimitive,
 )
-from mypyc.irbuild.mapper import Mapper
 from mypyc.irbuild.util import concrete_arg_kind
 from mypyc.options import CompilerOptions
 from mypyc.primitives.bytes_ops import bytes_compare
@@ -146,19 +143,30 @@
     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,
     int64_divide_op,
     int64_mod_op,
     int64_to_int_op,
-    int_comparison_op_mapping,
     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, list_items, new_list_op
+from mypyc.primitives.misc_ops import (
+    bool_op,
+    buf_init_item,
+    debug_print_op,
+    fast_isinstance_op,
+    none_object_op,
+    not_implemented_op,
+    var_object_size,
 )
-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
 from mypyc.primitives.registry import (
     ERR_NEG_INT,
     CFunctionDescription,
@@ -173,7 +181,7 @@
 from mypyc.sametype import is_same_type
 from mypyc.subtype import is_subtype
 
-DictEntry = Tuple[Optional[Value], Value]
+DictEntry = tuple[Optional[Value], Value]
 
 # If the number of items is less than the threshold when initializing
 # a list, we would inline the generate IR using SetMem and expanded
@@ -213,9 +221,24 @@
 
 
 class LowLevelIRBuilder:
-    def __init__(self, current_module: str, mapper: Mapper, options: CompilerOptions) -> None:
-        self.current_module = current_module
-        self.mapper = mapper
+    """A "low-level" IR builder class.
+
+    LowLevelIRBuilder provides core abstractions we use for constructing
+    IR as well as a number of higher-level ones (accessing attributes,
+    calling functions and methods, and coercing between types, for
+    example).
+
+    The core principle of the low-level IR builder is that all of its
+    facilities operate solely on the mypyc IR level and not the mypy AST
+    level---it has *no knowledge* of mypy types or expressions.
+
+    The mypyc.irbuilder.builder.IRBuilder class wraps an instance of this
+    class and provides additional functionality to transform mypy AST nodes
+    to IR.
+    """
+
+    def __init__(self, errors: Errors | None, options: CompilerOptions) -> None:
+        self.errors = errors
         self.options = options
         self.args: list[Register] = []
         self.blocks: list[BasicBlock] = []
@@ -225,6 +248,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:
@@ -251,6 +279,9 @@ def goto_and_activate(self, block: BasicBlock) -> None:
         self.goto(block)
         self.activate_block(block)
 
+    def keep_alive(self, values: list[Value], *, steal: bool = False) -> None:
+        self.add(KeepAlive(values, steal=steal))
+
     def push_error_handler(self, handler: BasicBlock | None) -> None:
         self.error_handlers.append(handler)
 
@@ -269,6 +300,11 @@ def flush_keep_alives(self) -> None:
             self.add(KeepAlive(self.keep_alives.copy()))
             self.keep_alives = []
 
+    def debug_print(self, toprint: str | Value) -> None:
+        if isinstance(toprint, str):
+            toprint = self.load_str(toprint)
+        self.primitive_op(debug_print_op, [toprint], -1)
+
     # Type conversions
 
     def box(self, src: Value) -> Value:
@@ -320,7 +356,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)
@@ -407,13 +445,19 @@ def coerce_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -
 
         size = target_type.size
         if size < int_rprimitive.size:
-            # Add a range check when the target type is smaller than the source tyoe
+            # Add a range check when the target type is smaller than the source type
             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(
@@ -456,6 +500,14 @@ 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())
+        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
 
@@ -463,15 +515,21 @@ def coerce_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -
         return res
 
     def coerce_short_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -> Value:
-        if is_int64_rprimitive(target_type):
+        if is_int64_rprimitive(target_type) or (
+            PLATFORM_SIZE == 4 and is_int32_rprimitive(target_type)
+        ):
             return self.int_op(target_type, src, Integer(1, target_type), IntOp.RIGHT_SHIFT, line)
-        # TODO: i32
-        assert False, (src.type, target_type)
+        # TODO: i32 on 64-bit platform
+        assert False, (src.type, target_type, PLATFORM_SIZE)
 
     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)
+            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,
@@ -582,7 +640,7 @@ def py_get_attr(self, obj: Value, attr: str, line: int) -> Value:
         Prefer get_attr() which generates optimized code for native classes.
         """
         key = self.load_str(attr)
-        return self.call_c(py_getattr_op, [obj, key], line)
+        return self.primitive_op(py_getattr_op, [obj, key], line)
 
     # isinstance() checks
 
@@ -618,7 +676,9 @@ def isinstance_native(self, obj: Value, class_ir: ClassIR, line: int) -> Value:
         """
         concrete = all_concrete_classes(class_ir)
         if concrete is None or len(concrete) > FAST_ISINSTANCE_MAX_SUBCLASSES + 1:
-            return self.call_c(fast_isinstance_op, [obj, self.get_native_type(class_ir)], line)
+            return self.primitive_op(
+                fast_isinstance_op, [obj, self.get_native_type(class_ir)], line
+            )
         if not concrete:
             # There can't be any concrete instance that matches this.
             return self.false()
@@ -722,7 +782,7 @@ def _construct_varargs(
             if kind == ARG_STAR:
                 if star_result is None:
                     star_result = self.new_list_op(star_values, line)
-                self.call_c(list_extend_op, [star_result, value], line)
+                self.primitive_op(list_extend_op, [star_result, value], line)
             elif kind == ARG_STAR2:
                 if star2_result is None:
                     star2_result = self._create_dict(star2_keys, star2_values, line)
@@ -819,7 +879,7 @@ def _construct_varargs(
             if star_result is None:
                 star_result = self.new_tuple(star_values, line)
             else:
-                star_result = self.call_c(list_tuple_op, [star_result], line)
+                star_result = self.primitive_op(list_tuple_op, [star_result], line)
         if has_star2 and star2_result is None:
             star2_result = self._create_dict(star2_keys, star2_values, line)
 
@@ -837,11 +897,9 @@ def py_call(
 
         Use py_call_op or py_call_with_kwargs_op for Python function call.
         """
-        if use_vectorcall(self.options.capi_version):
-            # More recent Python versions support faster vectorcalls.
-            result = self._py_vector_call(function, arg_values, line, arg_kinds, arg_names)
-            if result is not None:
-                return result
+        result = self._py_vector_call(function, arg_values, line, arg_kinds, arg_names)
+        if result is not None:
+            return result
 
         # If all arguments are positional, we can use py_call_op.
         if arg_kinds is None or all(kind == ARG_POS for kind in arg_kinds):
@@ -916,13 +974,11 @@ def py_method_call(
         arg_names: Sequence[str | None] | None,
     ) -> Value:
         """Call a Python method (non-native and slow)."""
-        if use_method_vectorcall(self.options.capi_version):
-            # More recent Python versions support faster vectorcalls.
-            result = self._py_vector_method_call(
-                obj, method_name, arg_values, line, arg_kinds, arg_names
-            )
-            if result is not None:
-                return result
+        result = self._py_vector_method_call(
+            obj, method_name, arg_values, line, arg_kinds, arg_names
+        )
+        if result is not None:
+            return result
 
         if arg_kinds is None or all(kind == ARG_POS for kind in arg_kinds):
             # Use legacy method call API
@@ -1105,7 +1161,7 @@ def gen_method_call(
         """Generate either a native or Python method call."""
         # If we have *args, then fallback to Python method call.
         if arg_kinds is not None and any(kind.is_star() for kind in arg_kinds):
-            return self.py_method_call(base, name, arg_values, base.line, arg_kinds, arg_names)
+            return self.py_method_call(base, name, arg_values, line, arg_kinds, arg_names)
 
         # If the base type is one of ours, do a MethodCall
         if (
@@ -1280,8 +1336,6 @@ def binary_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
             return self.compare_strings(lreg, rreg, op, line)
         if is_bytes_rprimitive(ltype) and is_bytes_rprimitive(rtype) and op in ("==", "!="):
             return self.compare_bytes(lreg, rreg, op, line)
-        if is_tagged(ltype) and is_tagged(rtype) and op in int_comparison_op_mapping:
-            return self.compare_tagged(lreg, rreg, op, line)
         if is_bool_rprimitive(ltype) and is_bool_rprimitive(rtype) and op in BOOL_BINARY_OPS:
             if op in ComparisonOp.signed_ops:
                 return self.bool_comparison_op(lreg, rreg, op, line)
@@ -1291,8 +1345,7 @@ def binary_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
             return self.translate_instance_contains(rreg, lreg, op, line)
         if is_fixed_width_rtype(ltype):
             if op in FIXED_WIDTH_INT_BINARY_OPS:
-                if op.endswith("="):
-                    op = op[:-1]
+                op = op.removesuffix("=")
                 if op != "//":
                     op_id = int_op_to_id[op]
                 else:
@@ -1303,9 +1356,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):
@@ -1316,19 +1368,17 @@ 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("="):
-                    op = op[:-1]
+                op = op.removesuffix("=")
                 if op != "//":
                     op_id = int_op_to_id[op]
                 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)
@@ -1342,26 +1392,10 @@ 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)
 
-        # Mixed int comparisons
-        if op in ("==", "!="):
-            op_id = ComparisonOp.signed_ops[op]
-            if is_tagged(ltype) and is_subtype(rtype, ltype):
-                rreg = self.coerce(rreg, int_rprimitive, line)
-                return self.comparison_op(lreg, rreg, op_id, line)
-            if is_tagged(rtype) and is_subtype(ltype, rtype):
-                lreg = self.coerce(lreg, int_rprimitive, line)
-                return self.comparison_op(lreg, rreg, op_id, line)
-        elif op in op in int_comparison_op_mapping:
-            if is_tagged(ltype) and is_subtype(rtype, ltype):
-                rreg = self.coerce(rreg, short_int_rprimitive, line)
-                return self.compare_tagged(lreg, rreg, op, line)
-            if is_tagged(rtype) and is_subtype(ltype, rtype):
-                lreg = self.coerce(lreg, short_int_rprimitive, line)
-                return self.compare_tagged(lreg, rreg, op, line)
         if is_float_rprimitive(ltype) or is_float_rprimitive(rtype):
             if isinstance(lreg, Integer):
                 lreg = Float(float(lreg.numeric_value()))
@@ -1381,11 +1415,48 @@ def binary_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
                 if base_op in float_op_to_id:
                     return self.float_op(lreg, rreg, base_op, line)
 
-        call_c_ops_candidates = binary_ops.get(op, [])
-        target = self.matching_call_c(call_c_ops_candidates, [lreg, rreg], line)
+        dunder_op = self.dunder_op(lreg, rreg, op, line)
+        if dunder_op:
+            return dunder_op
+
+        primitive_ops_candidates = binary_ops.get(op, [])
+        target = self.matching_primitive_op(primitive_ops_candidates, [lreg, rreg], line)
         assert target, "Unsupported binary operation: %s" % op
         return target
 
+    def dunder_op(self, lreg: Value, rreg: Value | None, op: str, line: int) -> Value | None:
+        """
+        Dispatch a dunder method if applicable.
+        For example for `a + b` it will use `a.__add__(b)` which can lead to higher performance
+        due to the fact that the method could be already compiled and optimized instead of going
+        all the way through `PyNumber_Add(a, b)` python api (making a jump into the python DL).
+        """
+        ltype = lreg.type
+        if not isinstance(ltype, RInstance):
+            return None
+
+        method_name = op_methods.get(op) if rreg else unary_op_methods.get(op)
+        if method_name is None:
+            return None
+
+        if not ltype.class_ir.has_method(method_name):
+            return None
+
+        decl = ltype.class_ir.method_decl(method_name)
+        if not rreg and len(decl.sig.args) != 1:
+            return None
+
+        if rreg and (len(decl.sig.args) != 2 or not is_subtype(rreg.type, decl.sig.args[1].type)):
+            return None
+
+        if rreg and is_subtype(not_implemented_op.type, decl.sig.ret_type):
+            # If the method is able to return NotImplemented, we should not optimize it.
+            # We can just let go so it will be handled through the python api.
+            return None
+
+        args = [rreg] if rreg else []
+        return self.gen_method_call(lreg, method_name, args, decl.sig.ret_type, line)
+
     def check_tagged_short_int(self, val: Value, line: int, negated: bool = False) -> Value:
         """Check if a tagged integer is a short integer.
 
@@ -1398,95 +1469,6 @@ def check_tagged_short_int(self, val: Value, line: int, negated: bool = False) -
         check = self.comparison_op(bitwise_and, zero, op, line)
         return check
 
-    def compare_tagged(self, lhs: Value, rhs: Value, op: str, line: int) -> Value:
-        """Compare two tagged integers using given operator (value context)."""
-        # generate fast binary logic ops on short ints
-        if is_short_int_rprimitive(lhs.type) and is_short_int_rprimitive(rhs.type):
-            return self.comparison_op(lhs, rhs, int_comparison_op_mapping[op][0], line)
-        op_type, c_func_desc, negate_result, swap_op = int_comparison_op_mapping[op]
-        result = Register(bool_rprimitive)
-        short_int_block, int_block, out = BasicBlock(), BasicBlock(), BasicBlock()
-        check_lhs = self.check_tagged_short_int(lhs, line)
-        if op in ("==", "!="):
-            check = check_lhs
-        else:
-            # for non-equality logical ops (less/greater than, etc.), need to check both sides
-            check_rhs = self.check_tagged_short_int(rhs, line)
-            check = self.int_op(bit_rprimitive, check_lhs, check_rhs, IntOp.AND, line)
-        self.add(Branch(check, short_int_block, int_block, Branch.BOOL))
-        self.activate_block(short_int_block)
-        eq = self.comparison_op(lhs, rhs, op_type, line)
-        self.add(Assign(result, eq, line))
-        self.goto(out)
-        self.activate_block(int_block)
-        if swap_op:
-            args = [rhs, lhs]
-        else:
-            args = [lhs, rhs]
-        call = self.call_c(c_func_desc, args, line)
-        if negate_result:
-            # TODO: introduce UnaryIntOp?
-            call_result = self.unary_op(call, "not", line)
-        else:
-            call_result = call
-        self.add(Assign(result, call_result, line))
-        self.goto_and_activate(out)
-        return result
-
-    def compare_tagged_condition(
-        self, lhs: Value, rhs: Value, op: str, true: BasicBlock, false: BasicBlock, line: int
-    ) -> None:
-        """Compare two tagged integers using given operator (conditional context).
-
-        Assume lhs and rhs are tagged integers.
-
-        Args:
-            lhs: Left operand
-            rhs: Right operand
-            op: Operation, one of '==', '!=', '<', '<=', '>', '<='
-            true: Branch target if comparison is true
-            false: Branch target if comparison is false
-        """
-        is_eq = op in ("==", "!=")
-        if (is_short_int_rprimitive(lhs.type) and is_short_int_rprimitive(rhs.type)) or (
-            is_eq and (is_short_int_rprimitive(lhs.type) or is_short_int_rprimitive(rhs.type))
-        ):
-            # We can skip the tag check
-            check = self.comparison_op(lhs, rhs, int_comparison_op_mapping[op][0], line)
-            self.flush_keep_alives()
-            self.add(Branch(check, true, false, Branch.BOOL))
-            return
-        op_type, c_func_desc, negate_result, swap_op = int_comparison_op_mapping[op]
-        int_block, short_int_block = BasicBlock(), BasicBlock()
-        check_lhs = self.check_tagged_short_int(lhs, line, negated=True)
-        if is_eq or is_short_int_rprimitive(rhs.type):
-            self.flush_keep_alives()
-            self.add(Branch(check_lhs, int_block, short_int_block, Branch.BOOL))
-        else:
-            # For non-equality logical ops (less/greater than, etc.), need to check both sides
-            rhs_block = BasicBlock()
-            self.add(Branch(check_lhs, int_block, rhs_block, Branch.BOOL))
-            self.activate_block(rhs_block)
-            check_rhs = self.check_tagged_short_int(rhs, line, negated=True)
-            self.flush_keep_alives()
-            self.add(Branch(check_rhs, int_block, short_int_block, Branch.BOOL))
-        # Arbitrary integers (slow path)
-        self.activate_block(int_block)
-        if swap_op:
-            args = [rhs, lhs]
-        else:
-            args = [lhs, rhs]
-        call = self.call_c(c_func_desc, args, line)
-        if negate_result:
-            self.add(Branch(call, false, true, Branch.BOOL))
-        else:
-            self.flush_keep_alives()
-            self.add(Branch(call, true, false, Branch.BOOL))
-        # Short integers (fast path)
-        self.activate_block(short_int_block)
-        eq = self.comparison_op(lhs, rhs, op_type, line)
-        self.add(Branch(eq, true, false, Branch.BOOL))
-
     def compare_strings(self, lhs: Value, rhs: Value, op: str, line: int) -> Value:
         """Compare two strings"""
         compare_result = self.call_c(unicode_compare, [lhs, rhs], line)
@@ -1549,7 +1531,7 @@ def compare_tuples(self, lhs: Value, rhs: Value, op: str, line: int = -1) -> Val
             # Cast to bool if necessary since most types uses comparison returning a object type
             # See generic_ops.py for more information
             if not is_bool_rprimitive(compare.type):
-                compare = self.call_c(bool_op, [compare], line)
+                compare = self.primitive_op(bool_op, [compare], line)
             if i < len(lhs.type.types) - 1:
                 branch = Branch(compare, early_stop, check_blocks[i + 1], Branch.BOOL)
             else:
@@ -1568,7 +1550,7 @@ def compare_tuples(self, lhs: Value, rhs: Value, op: str, line: int = -1) -> Val
     def translate_instance_contains(self, inst: Value, item: Value, op: str, line: int) -> Value:
         res = self.gen_method_call(inst, "__contains__", [item], None, line)
         if not is_bool_rprimitive(res.type):
-            res = self.call_c(bool_op, [res], line)
+            res = self.primitive_op(bool_op, [res], line)
         if op == "not in":
             res = self.bool_bitwise_op(res, Integer(1, rtype=bool_rprimitive), "^", line)
         return res
@@ -1604,8 +1586,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):
@@ -1625,18 +1612,11 @@ def unary_op(self, value: Value, expr_op: str, line: int) -> Value:
         if isinstance(value, Float):
             return Float(-value.value, value.line)
         if isinstance(typ, RInstance):
-            if expr_op == "-":
-                method = "__neg__"
-            elif expr_op == "+":
-                method = "__pos__"
-            elif expr_op == "~":
-                method = "__invert__"
-            else:
-                method = ""
-            if method and typ.class_ir.has_method(method):
-                return self.gen_method_call(value, method, [], None, line)
-        call_c_ops_candidates = unary_ops.get(expr_op, [])
-        target = self.matching_call_c(call_c_ops_candidates, [value], line)
+            result = self.dunder_op(value, None, expr_op, line)
+            if result is not None:
+                return result
+        primitive_ops_candidates = unary_ops.get(expr_op, [])
+        target = self.matching_primitive_op(primitive_ops_candidates, [value], line)
         assert target, "Unsupported unary operation: %s" % expr_op
         return target
 
@@ -1694,22 +1674,16 @@ def new_list_op(self, values: list[Value], line: int) -> Value:
         if not values:
             return result_list
         args = [self.coerce(item, object_rprimitive, line) for item in values]
-        ob_item_ptr = self.add(GetElementPtr(result_list, PyListObject, "ob_item", line))
-        ob_item_base = self.add(LoadMem(pointer_rprimitive, ob_item_ptr, line))
+        ob_item_base = self.add(PrimitiveOp([result_list], list_items, line))
         for i in range(len(values)):
-            if i == 0:
-                item_address = ob_item_base
-            else:
-                offset = Integer(PLATFORM_SIZE * i, c_pyssize_t_rprimitive, line)
-                item_address = self.add(
-                    IntOp(pointer_rprimitive, ob_item_base, offset, IntOp.ADD, line)
-                )
-            self.add(SetMem(object_rprimitive, item_address, args[i], line))
+            self.primitive_op(
+                buf_init_item, [ob_item_base, Integer(i, c_pyssize_t_rprimitive), args[i]], line
+            )
         self.add(KeepAlive([result_list]))
         return result_list
 
     def new_set_op(self, values: list[Value], line: int) -> Value:
-        return self.call_c(new_set_op, values, line)
+        return self.primitive_op(new_set_op, values, line)
 
     def setup_rarray(
         self, item_type: RType, values: Sequence[Value], *, object_ptr: bool = False
@@ -1817,7 +1791,7 @@ def bool_value(self, value: Value) -> Value:
                     self.goto(end)
                     self.activate_block(end)
             else:
-                result = self.call_c(bool_op, [value], value.line)
+                result = self.primitive_op(bool_op, [value], value.line)
         return result
 
     def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) -> None:
@@ -1894,6 +1868,7 @@ def call_c(
                 error_kind,
                 line,
                 var_arg_idx,
+                is_pure=desc.is_pure,
             )
         )
         if desc.is_borrowed:
@@ -1950,6 +1925,103 @@ def matching_call_c(
             return target
         return None
 
+    def primitive_op(
+        self,
+        desc: PrimitiveDescription,
+        args: list[Value],
+        line: int,
+        result_type: RType | None = None,
+    ) -> Value:
+        """Add a primitive op."""
+        # Does this primitive map into calling a Python C API
+        # or an internal mypyc C API function?
+        if desc.c_function_name:
+            # TODO: Generate PrimitiveOps here and transform them into CallC
+            # ops only later in the lowering pass
+            c_desc = CFunctionDescription(
+                desc.name,
+                desc.arg_types,
+                desc.return_type,
+                desc.var_arg_type,
+                desc.truncated_type,
+                desc.c_function_name,
+                desc.error_kind,
+                desc.steals,
+                desc.is_borrowed,
+                desc.ordering,
+                desc.extra_int_constants,
+                desc.priority,
+                is_pure=desc.is_pure,
+            )
+            return self.call_c(c_desc, args, line, result_type=result_type)
+
+        # This primitive gets transformed in a lowering pass to
+        # lower-level IR ops using a custom transform function.
+
+        coerced = []
+        # Coerce fixed number arguments
+        for i in range(min(len(args), len(desc.arg_types))):
+            formal_type = desc.arg_types[i]
+            arg = args[i]
+            assert formal_type is not None  # TODO
+            arg = self.coerce(arg, formal_type, line)
+            coerced.append(arg)
+        assert desc.ordering is None
+        assert desc.var_arg_type is None
+        assert not desc.extra_int_constants
+        target = self.add(PrimitiveOp(coerced, desc, line=line))
+        if desc.is_borrowed:
+            # If the result is borrowed, force the arguments to be
+            # kept alive afterwards, as otherwise the result might be
+            # immediately freed, at the risk of a dangling pointer.
+            for arg in coerced:
+                if not isinstance(arg, (Integer, LoadLiteral)):
+                    self.keep_alives.append(arg)
+        if desc.error_kind == ERR_NEG_INT:
+            comp = ComparisonOp(target, Integer(0, desc.return_type, line), ComparisonOp.SGE, line)
+            comp.error_kind = ERR_FALSE
+            self.add(comp)
+
+        assert desc.truncated_type is None
+        result = target
+        if result_type and not is_runtime_subtype(result.type, result_type):
+            if is_none_rprimitive(result_type):
+                # Special case None return. The actual result may actually be a bool
+                # and so we can't just coerce it.
+                result = self.none()
+            else:
+                result = self.coerce(result, result_type, line, can_borrow=desc.is_borrowed)
+        return result
+
+    def matching_primitive_op(
+        self,
+        candidates: list[PrimitiveDescription],
+        args: list[Value],
+        line: int,
+        result_type: RType | None = None,
+        can_borrow: bool = False,
+    ) -> Value | None:
+        matching: PrimitiveDescription | None = None
+        for desc in candidates:
+            if len(desc.arg_types) != len(args):
+                continue
+            if all(
+                # formal is not None and # TODO
+                is_subtype(actual.type, formal)
+                for actual, formal in zip(args, desc.arg_types)
+            ) and (not desc.is_borrowed or can_borrow):
+                if matching:
+                    assert matching.priority != desc.priority, "Ambiguous:\n1) {}\n2) {}".format(
+                        matching, desc
+                    )
+                    if desc.priority > matching.priority:
+                        matching = desc
+                else:
+                    matching = desc
+        if matching:
+            return self.primitive_op(matching, args, line=line, result_type=result_type)
+        return None
+
     def int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1) -> Value:
         """Generate a native integer binary op.
 
@@ -2009,7 +2081,7 @@ def float_mod(self, lhs: Value, rhs: Value, line: int) -> Value:
         self.activate_block(copysign)
         # If the remainder is zero, CPython ensures the result has the
         # same sign as the denominator.
-        adj = self.call_c(copysign_op, [Float(0.0), rhs], line)
+        adj = self.primitive_op(copysign_op, [Float(0.0), rhs], line)
         self.add(Assign(res, adj))
         self.add(Goto(done))
         self.activate_block(done)
@@ -2018,7 +2090,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.
@@ -2030,31 +2104,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)
@@ -2114,10 +2217,8 @@ def builtin_len(self, val: Value, line: int, use_pyssize_t: bool = False) -> Val
         typ = val.type
         size_value = None
         if is_list_rprimitive(typ) or is_tuple_rprimitive(typ) or is_bytes_rprimitive(typ):
-            elem_address = self.add(GetElementPtr(val, PyVarObject, "ob_size"))
-            size_value = self.add(LoadMem(c_pyssize_t_rprimitive, elem_address))
-            self.add(KeepAlive([val]))
-        elif is_set_rprimitive(typ):
+            size_value = self.primitive_op(var_object_size, [val], line)
+        elif is_set_rprimitive(typ) or is_frozenset_rprimitive(typ):
             elem_address = self.add(GetElementPtr(val, PySetObject, "used"))
             size_value = self.add(LoadMem(c_pyssize_t_rprimitive, elem_address))
             self.add(KeepAlive([val]))
@@ -2138,7 +2239,8 @@ def builtin_len(self, val: Value, line: int, use_pyssize_t: bool = False) -> Val
             length = self.gen_method_call(val, "__len__", [], int_rprimitive, line)
             length = self.coerce(length, int_rprimitive, line)
             ok, fail = BasicBlock(), BasicBlock()
-            self.compare_tagged_condition(length, Integer(0), ">=", ok, fail, line)
+            cond = self.binary_op(length, Integer(0), ">=", line)
+            self.add_bool_branch(cond, ok, fail)
             self.activate_block(fail)
             self.add(
                 RaiseStandardError(
@@ -2174,7 +2276,7 @@ def new_tuple_with_length(self, length: Value, line: int) -> Value:
         return self.call_c(new_tuple_with_length_op, [length], line)
 
     def int_to_float(self, n: Value, line: int) -> Value:
-        return self.call_c(int_to_float_op, [n], line)
+        return self.primitive_op(int_to_float_op, [n], line)
 
     # Internal helpers
 
@@ -2258,11 +2360,11 @@ def translate_special_method_call(
 
         Return None if no translation found; otherwise return the target register.
         """
-        call_c_ops_candidates = method_call_ops.get(name, [])
-        call_c_op = self.matching_call_c(
-            call_c_ops_candidates, [base_reg] + args, line, result_type, can_borrow=can_borrow
+        primitive_ops_candidates = method_call_ops.get(name, [])
+        primitive_op = self.matching_primitive_op(
+            primitive_ops_candidates, [base_reg] + args, line, result_type, can_borrow=can_borrow
         )
-        return call_c_op
+        return primitive_op
 
     def translate_eq_cmp(self, lreg: Value, rreg: Value, expr_op: str, line: int) -> Value | None:
         """Add a equality comparison operation.
@@ -2321,6 +2423,10 @@ 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:
+        assert self.errors is not None, "cannot generate errors in this compiler phase"
+        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/main.py b/mypyc/irbuild/main.py
index 85b905393af1..7cdc6b686778 100644
--- a/mypyc/irbuild/main.py
+++ b/mypyc/irbuild/main.py
@@ -73,7 +73,7 @@ def build_ir(
 
     for module in modules:
         # First pass to determine free symbols.
-        pbv = PreBuildVisitor(errors, module, singledispatch_info.decorators_to_remove)
+        pbv = PreBuildVisitor(errors, module, singledispatch_info.decorators_to_remove, types)
         module.accept(pbv)
 
         # Construct and configure builder objects (cyclic runtime dependency).
@@ -99,6 +99,7 @@ def build_ir(
             builder.functions,
             builder.classes,
             builder.final_names,
+            builder.type_var_names,
         )
         result[module.fullname] = module_ir
         class_irs.extend(builder.classes)
diff --git a/mypyc/irbuild/mapper.py b/mypyc/irbuild/mapper.py
index dddb35230fd5..7c6e03d0037c 100644
--- a/mypyc/irbuild/mapper.py
+++ b/mypyc/irbuild/mapper.py
@@ -15,10 +15,11 @@
     Type,
     TypedDictType,
     TypeType,
-    TypeVarType,
+    TypeVarLikeType,
     UnboundType,
     UninhabitedType,
     UnionType,
+    find_unpack_in_list,
     get_proper_type,
 )
 from mypyc.ir.class_ir import ClassIR
@@ -32,6 +33,8 @@
     bytes_rprimitive,
     dict_rprimitive,
     float_rprimitive,
+    frozenset_rprimitive,
+    int16_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
     int_rprimitive,
@@ -42,6 +45,7 @@
     set_rprimitive,
     str_rprimitive,
     tuple_rprimitive,
+    uint8_rprimitive,
 )
 
 
@@ -59,6 +63,7 @@ def __init__(self, group_map: dict[str, str | None]) -> None:
         self.group_map = group_map
         self.type_to_ir: dict[TypeInfo, ClassIR] = {}
         self.func_to_decl: dict[SymbolNode, FuncDecl] = {}
+        self.symbol_fullnames: set[str] = set()
 
     def type_to_rtype(self, typ: Type | None) -> RType:
         if typ is None:
@@ -85,6 +90,8 @@ def type_to_rtype(self, typ: Type | None) -> RType:
                 return dict_rprimitive
             elif typ.type.fullname == "builtins.set":
                 return set_rprimitive
+            elif typ.type.fullname == "builtins.frozenset":
+                return frozenset_rprimitive
             elif typ.type.fullname == "builtins.tuple":
                 return tuple_rprimitive  # Varying-length tuple
             elif typ.type.fullname == "builtins.range":
@@ -102,12 +109,19 @@ 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
+            elif typ.type.fullname == "mypy_extensions.u8":
+                return uint8_rprimitive
             else:
                 return object_rprimitive
         elif isinstance(typ, TupleType):
             # Use our unboxed tuples for raw tuples but fall back to
-            # being boxed for NamedTuple.
-            if typ.partial_fallback.type.fullname == "builtins.tuple":
+            # being boxed for NamedTuple or for variadic tuples.
+            if (
+                typ.partial_fallback.type.fullname == "builtins.tuple"
+                and find_unpack_in_list(typ.items) is None
+            ):
                 return RTuple([self.type_to_rtype(t) for t in typ.items])
             else:
                 return tuple_rprimitive
@@ -121,7 +135,7 @@ def type_to_rtype(self, typ: Type | None) -> RType:
             return object_rprimitive
         elif isinstance(typ, TypeType):
             return object_rprimitive
-        elif isinstance(typ, TypeVarType):
+        elif isinstance(typ, TypeVarLikeType):
             # Erase type variable to upper bound.
             # TODO: Erase to union if object has value restriction?
             return self.type_to_rtype(typ.upper_bound)
@@ -150,7 +164,7 @@ def get_arg_rtype(self, typ: Type, kind: ArgKind) -> RType:
         else:
             return self.type_to_rtype(typ)
 
-    def fdef_to_sig(self, fdef: FuncDef) -> FuncSignature:
+    def fdef_to_sig(self, fdef: FuncDef, strict_dunders_typing: bool) -> FuncSignature:
         if isinstance(fdef.type, CallableType):
             arg_types = [
                 self.get_arg_rtype(typ, kind)
@@ -189,11 +203,14 @@ def fdef_to_sig(self, fdef: FuncDef) -> FuncSignature:
             )
         ]
 
-        # We force certain dunder methods to return objects to support letting them
-        # return NotImplemented. It also avoids some pointless boxing and unboxing,
-        # since tp_richcompare needs an object anyways.
-        if fdef.name in ("__eq__", "__ne__", "__lt__", "__gt__", "__le__", "__ge__"):
-            ret = object_rprimitive
+        if not strict_dunders_typing:
+            # We force certain dunder methods to return objects to support letting them
+            # return NotImplemented. It also avoids some pointless boxing and unboxing,
+            # since tp_richcompare needs an object anyways.
+            # However, it also prevents some optimizations.
+            if fdef.name in ("__eq__", "__ne__", "__lt__", "__gt__", "__le__", "__ge__"):
+                ret = object_rprimitive
+
         return FuncSignature(args, ret)
 
     def is_native_module(self, module: str) -> bool:
@@ -204,7 +221,8 @@ def is_native_ref_expr(self, expr: RefExpr) -> bool:
         if expr.node is None:
             return False
         if "." in expr.node.fullname:
-            return self.is_native_module(expr.node.fullname.rpartition(".")[0])
+            name = expr.node.fullname.rpartition(".")[0]
+            return self.is_native_module(name) or name in self.symbol_fullnames
         return True
 
     def is_native_module_ref_expr(self, expr: RefExpr) -> bool:
diff --git a/mypyc/irbuild/match.py b/mypyc/irbuild/match.py
index a1e671911ea5..d7bf9e0b94de 100644
--- a/mypyc/irbuild/match.py
+++ b/mypyc/irbuild/match.py
@@ -1,5 +1,7 @@
+from __future__ import annotations
+
+from collections.abc import Generator
 from contextlib import contextmanager
-from typing import Generator, List, Optional, Tuple
 
 from mypy.nodes import MatchStmt, NameExpr, TypeInfo
 from mypy.patterns import (
@@ -14,7 +16,7 @@
     ValuePattern,
 )
 from mypy.traverser import TraverserVisitor
-from mypy.types import Instance, TupleType, get_proper_type
+from mypy.types import Instance, LiteralType, TupleType, get_proper_type
 from mypyc.ir.ops import BasicBlock, Value
 from mypyc.ir.rtypes import object_rprimitive
 from mypyc.irbuild.builder import IRBuilder
@@ -56,7 +58,7 @@ class MatchVisitor(TraverserVisitor):
     subject: Value
     match: MatchStmt
 
-    as_pattern: Optional[AsPattern] = None
+    as_pattern: AsPattern | None = None
 
     def __init__(self, builder: IRBuilder, match_node: MatchStmt) -> None:
         self.builder = builder
@@ -124,14 +126,14 @@ def visit_or_pattern(self, pattern: OrPattern) -> None:
 
     def visit_class_pattern(self, pattern: ClassPattern) -> None:
         # TODO: use faster instance check for native classes (while still
-        # making sure to account for inheritence)
+        # making sure to account for inheritance)
         isinstance_op = (
             fast_isinstance_op
             if self.builder.is_builtin_ref_expr(pattern.class_ref)
             else slow_isinstance_op
         )
 
-        cond = self.builder.call_c(
+        cond = self.builder.primitive_op(
             isinstance_op, [self.subject, self.builder.accept(pattern.class_ref)], pattern.line
         )
 
@@ -150,23 +152,7 @@ def visit_class_pattern(self, pattern: ClassPattern) -> None:
 
             node = pattern.class_ref.node
             assert isinstance(node, TypeInfo)
-
-            ty = node.names.get("__match_args__")
-            assert ty
-
-            match_args_type = get_proper_type(ty.type)
-            assert isinstance(match_args_type, TupleType)
-
-            match_args: List[str] = []
-
-            for item in match_args_type.items:
-                proper_item = get_proper_type(item)
-                assert isinstance(proper_item, Instance) and proper_item.last_known_value
-
-                match_arg = proper_item.last_known_value.value
-                assert isinstance(match_arg, str)
-
-                match_args.append(match_arg)
+            match_args = extract_dunder_match_args_names(node)
 
             for i, expr in enumerate(pattern.positionals):
                 self.builder.activate_block(self.code_block)
@@ -220,7 +206,7 @@ def visit_mapping_pattern(self, pattern: MappingPattern) -> None:
 
         self.builder.add_bool_branch(is_dict, self.code_block, self.next_block)
 
-        keys: List[Value] = []
+        keys: list[Value] = []
 
         for key, value in zip(pattern.keys, pattern.values):
             self.builder.activate_block(self.code_block)
@@ -246,7 +232,7 @@ def visit_mapping_pattern(self, pattern: MappingPattern) -> None:
             self.builder.activate_block(self.code_block)
             self.code_block = BasicBlock()
 
-            rest = self.builder.call_c(dict_copy, [self.subject], pattern.rest.line)
+            rest = self.builder.primitive_op(dict_copy, [self.subject], pattern.rest.line)
 
             target = self.builder.get_assignment_target(pattern.rest)
 
@@ -330,7 +316,7 @@ def bind_as_pattern(self, value: Value, new_block: bool = False) -> None:
                 self.builder.goto(self.code_block)
 
     @contextmanager
-    def enter_subpattern(self, subject: Value) -> Generator[None, None, None]:
+    def enter_subpattern(self, subject: Value) -> Generator[None]:
         old_subject = self.subject
         self.subject = subject
         yield
@@ -339,10 +325,10 @@ def enter_subpattern(self, subject: Value) -> Generator[None, None, None]:
 
 def prep_sequence_pattern(
     seq_pattern: SequencePattern,
-) -> Tuple[Optional[int], Optional[NameExpr], List[Pattern]]:
-    star_index: Optional[int] = None
-    capture: Optional[NameExpr] = None
-    patterns: List[Pattern] = []
+) -> tuple[int | None, NameExpr | None, list[Pattern]]:
+    star_index: int | None = None
+    capture: NameExpr | None = None
+    patterns: list[Pattern] = []
 
     for i, pattern in enumerate(seq_pattern.patterns):
         if isinstance(pattern, StarredPattern):
@@ -353,3 +339,24 @@ def prep_sequence_pattern(
             patterns.append(pattern)
 
     return star_index, capture, patterns
+
+
+def extract_dunder_match_args_names(info: TypeInfo) -> list[str]:
+    ty = info.names.get("__match_args__")
+    assert ty
+    match_args_type = get_proper_type(ty.type)
+    assert isinstance(match_args_type, TupleType)
+
+    match_args: list[str] = []
+    for item in match_args_type.items:
+        proper_item = get_proper_type(item)
+
+        match_arg = None
+        if isinstance(proper_item, Instance) and proper_item.last_known_value:
+            match_arg = proper_item.last_known_value.value
+        elif isinstance(proper_item, LiteralType):
+            match_arg = proper_item.value
+        assert isinstance(match_arg, str), f"Unrecognized __match_args__ item: {item}"
+
+        match_args.append(match_arg)
+    return match_args
diff --git a/mypyc/irbuild/missingtypevisitor.py b/mypyc/irbuild/missingtypevisitor.py
new file mode 100644
index 000000000000..e655d270a4a4
--- /dev/null
+++ b/mypyc/irbuild/missingtypevisitor.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from mypy.nodes import Expression, Node
+from mypy.traverser import ExtendedTraverserVisitor
+from mypy.types import AnyType, Type, TypeOfAny
+
+
+class MissingTypesVisitor(ExtendedTraverserVisitor):
+    """AST visitor that can be used to add any missing types as a generic AnyType."""
+
+    def __init__(self, types: dict[Expression, Type]) -> None:
+        super().__init__()
+        self.types: dict[Expression, Type] = types
+
+    def visit(self, o: Node) -> bool:
+        if isinstance(o, Expression) and o not in self.types:
+            self.types[o] = AnyType(TypeOfAny.special_form)
+
+        # If returns True, will continue to nested nodes.
+        return True
diff --git a/mypyc/irbuild/nonlocalcontrol.py b/mypyc/irbuild/nonlocalcontrol.py
index 02dd51283e95..0ac9bd3cee31 100644
--- a/mypyc/irbuild/nonlocalcontrol.py
+++ b/mypyc/irbuild/nonlocalcontrol.py
@@ -120,8 +120,7 @@ def __init__(self, outer: NonlocalControl) -> None:
         self.outer = outer
 
     @abstractmethod
-    def gen_cleanup(self, builder: IRBuilder, line: int) -> None:
-        ...
+    def gen_cleanup(self, builder: IRBuilder, line: int) -> None: ...
 
     def gen_break(self, builder: IRBuilder, line: int) -> None:
         self.gen_cleanup(builder, line)
diff --git a/mypyc/irbuild/prebuildvisitor.py b/mypyc/irbuild/prebuildvisitor.py
index 519b3445e925..e630fed0d85a 100644
--- a/mypyc/irbuild/prebuildvisitor.py
+++ b/mypyc/irbuild/prebuildvisitor.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from mypy.nodes import (
+    AssignmentStmt,
     Block,
     Decorator,
     Expression,
@@ -16,7 +17,9 @@
     Var,
 )
 from mypy.traverser import ExtendedTraverserVisitor
+from mypy.types import Type
 from mypyc.errors import Errors
+from mypyc.irbuild.missingtypevisitor import MissingTypesVisitor
 
 
 class PreBuildVisitor(ExtendedTraverserVisitor):
@@ -39,6 +42,7 @@ def __init__(
         errors: Errors,
         current_file: MypyFile,
         decorators_to_remove: dict[FuncDef, list[int]],
+        types: dict[Expression, Type],
     ) -> None:
         super().__init__()
         # Dict from a function to symbols defined directly in the
@@ -73,7 +77,7 @@ def __init__(
         self.decorators_to_remove: dict[FuncDef, list[int]] = decorators_to_remove
 
         # A mapping of import groups (a series of Import nodes with
-        # nothing inbetween) where each group is keyed by its first
+        # nothing in between) where each group is keyed by its first
         # import node.
         self.module_import_groups: dict[Import, list[Import]] = {}
         self._current_import_group: Import | None = None
@@ -82,11 +86,20 @@ def __init__(
 
         self.current_file: MypyFile = current_file
 
+        self.missing_types_visitor = MissingTypesVisitor(types)
+
     def visit(self, o: Node) -> bool:
         if not isinstance(o, Import):
             self._current_import_group = None
         return True
 
+    def visit_assignment_stmt(self, stmt: AssignmentStmt) -> None:
+        # These are cases where mypy may not have types for certain expressions,
+        # but mypyc needs some form type to exist.
+        if stmt.is_alias_def:
+            stmt.rvalue.accept(self.missing_types_visitor)
+        return super().visit_assignment_stmt(stmt)
+
     def visit_block(self, block: Block) -> None:
         self._current_import_group = None
         super().visit_block(block)
@@ -119,9 +132,10 @@ def visit_decorator(self, dec: Decorator) -> None:
                 self.funcs_to_decorators[dec.func] = decorators_to_store
         super().visit_decorator(dec)
 
-    def visit_func_def(self, fdef: FuncItem) -> None:
+    def visit_func_def(self, fdef: FuncDef) -> None:
         # TODO: What about overloaded functions?
         self.visit_func(fdef)
+        self.visit_symbol_node(fdef)
 
     def visit_lambda_expr(self, expr: LambdaExpr) -> None:
         self.visit_func(expr)
diff --git a/mypyc/irbuild/prepare.py b/mypyc/irbuild/prepare.py
index 5e6520048197..98ff348d8c30 100644
--- a/mypyc/irbuild/prepare.py
+++ b/mypyc/irbuild/prepare.py
@@ -14,7 +14,8 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Iterable, NamedTuple, Tuple
+from collections.abc import Iterable
+from typing import NamedTuple
 
 from mypy.build import Graph
 from mypy.nodes import (
@@ -81,23 +82,30 @@ def build_type_map(
     # references even if there are import cycles.
     for module, cdef in classes:
         class_ir = ClassIR(
-            cdef.name, module.fullname, is_trait(cdef), is_abstract=cdef.info.is_abstract
+            cdef.name,
+            module.fullname,
+            is_trait(cdef),
+            is_abstract=cdef.info.is_abstract,
+            is_final_class=cdef.info.is_final,
         )
-        class_ir.is_ext_class = is_extension_class(cdef)
+        class_ir.is_ext_class = is_extension_class(module.path, cdef, errors)
         if class_ir.is_ext_class:
             class_ir.deletable = cdef.info.deletable_attributes.copy()
         # If global optimizations are disabled, turn of tracking of class children
         if not options.global_opts:
             class_ir.children = None
         mapper.type_to_ir[cdef.info] = class_ir
+        mapper.symbol_fullnames.add(class_ir.fullname)
 
     # Populate structural information in class IR for extension classes.
     for module, cdef in classes:
         with catch_errors(module.path, cdef.line):
             if mapper.type_to_ir[cdef.info].is_ext_class:
-                prepare_class_def(module.path, module.fullname, cdef, errors, mapper)
+                prepare_class_def(module.path, module.fullname, cdef, errors, mapper, options)
             else:
-                prepare_non_ext_class_def(module.path, module.fullname, cdef, errors, mapper)
+                prepare_non_ext_class_def(
+                    module.path, module.fullname, cdef, errors, mapper, options
+                )
 
     # Prepare implicit attribute accessors as needed if an attribute overrides a property.
     for module, cdef in classes:
@@ -110,7 +118,7 @@ def build_type_map(
     # is conditionally defined.
     for module in modules:
         for func in get_module_func_defs(module):
-            prepare_func_def(module.fullname, None, func, mapper)
+            prepare_func_def(module.fullname, None, func, mapper, options)
             # TODO: what else?
 
     # Check for incompatible attribute definitions that were not
@@ -139,10 +147,11 @@ def is_from_module(node: SymbolNode, module: MypyFile) -> bool:
 def load_type_map(mapper: Mapper, modules: list[MypyFile], deser_ctx: DeserMaps) -> None:
     """Populate a Mapper with deserialized IR from a list of modules."""
     for module in modules:
-        for name, node in module.names.items():
+        for node in module.names.values():
             if isinstance(node.node, TypeInfo) and is_from_module(node.node, module):
                 ir = deser_ctx.classes[node.node.fullname]
                 mapper.type_to_ir[node.node] = ir
+                mapper.symbol_fullnames.add(node.node.fullname)
                 mapper.func_to_decl[node.node] = ir.ctor
 
     for module in modules:
@@ -153,7 +162,7 @@ def load_type_map(mapper: Mapper, modules: list[MypyFile], deser_ctx: DeserMaps)
 
 def get_module_func_defs(module: MypyFile) -> Iterable[FuncDef]:
     """Collect all of the (non-method) functions declared in a module."""
-    for name, node in module.names.items():
+    for node in module.names.values():
         # We need to filter out functions that are imported or
         # aliases.  The best way to do this seems to be by
         # checking that the fullname matches.
@@ -164,27 +173,39 @@ def get_module_func_defs(module: MypyFile) -> Iterable[FuncDef]:
 
 
 def prepare_func_def(
-    module_name: str, class_name: str | None, fdef: FuncDef, mapper: Mapper
+    module_name: str,
+    class_name: str | None,
+    fdef: FuncDef,
+    mapper: Mapper,
+    options: CompilerOptions,
 ) -> FuncDecl:
     kind = (
         FUNC_STATICMETHOD
         if fdef.is_static
         else (FUNC_CLASSMETHOD if fdef.is_class else FUNC_NORMAL)
     )
-    decl = FuncDecl(fdef.name, class_name, module_name, mapper.fdef_to_sig(fdef), kind)
+    sig = mapper.fdef_to_sig(fdef, options.strict_dunders_typing)
+    decl = FuncDecl(fdef.name, class_name, module_name, sig, kind)
     mapper.func_to_decl[fdef] = decl
     return decl
 
 
 def prepare_method_def(
-    ir: ClassIR, module_name: str, cdef: ClassDef, mapper: Mapper, node: FuncDef | Decorator
+    ir: ClassIR,
+    module_name: str,
+    cdef: ClassDef,
+    mapper: Mapper,
+    node: FuncDef | Decorator,
+    options: CompilerOptions,
 ) -> None:
     if isinstance(node, FuncDef):
-        ir.method_decls[node.name] = prepare_func_def(module_name, cdef.name, node, mapper)
+        ir.method_decls[node.name] = prepare_func_def(
+            module_name, cdef.name, node, mapper, options
+        )
     elif isinstance(node, Decorator):
         # TODO: do something about abstract methods here. Currently, they are handled just like
         # normal methods.
-        decl = prepare_func_def(module_name, cdef.name, node.func, mapper)
+        decl = prepare_func_def(module_name, cdef.name, node.func, mapper, options)
         if not node.decorators:
             ir.method_decls[node.name] = decl
         elif isinstance(node.decorators[0], MemberExpr) and node.decorators[0].name == "setter":
@@ -237,7 +258,12 @@ def can_subclass_builtin(builtin_base: str) -> bool:
 
 
 def prepare_class_def(
-    path: str, module_name: str, cdef: ClassDef, errors: Errors, mapper: Mapper
+    path: str,
+    module_name: str,
+    cdef: ClassDef,
+    errors: Errors,
+    mapper: Mapper,
+    options: CompilerOptions,
 ) -> None:
     """Populate the interface-level information in a class IR.
 
@@ -304,7 +330,7 @@ def prepare_class_def(
     ir.mro = mro
     ir.base_mro = base_mro
 
-    prepare_methods_and_attributes(cdef, ir, path, module_name, errors, mapper)
+    prepare_methods_and_attributes(cdef, ir, path, module_name, errors, mapper, options)
     prepare_init_method(cdef, ir, module_name, mapper)
 
     for base in bases:
@@ -316,7 +342,13 @@ def prepare_class_def(
 
 
 def prepare_methods_and_attributes(
-    cdef: ClassDef, ir: ClassIR, path: str, module_name: str, errors: Errors, mapper: Mapper
+    cdef: ClassDef,
+    ir: ClassIR,
+    path: str,
+    module_name: str,
+    errors: Errors,
+    mapper: Mapper,
+    options: CompilerOptions,
 ) -> None:
     """Populate attribute and method declarations."""
     info = cdef.info
@@ -338,20 +370,24 @@ def prepare_methods_and_attributes(
                     add_setter_declaration(ir, name, attr_rtype, module_name)
                 ir.attributes[name] = attr_rtype
         elif isinstance(node.node, (FuncDef, Decorator)):
-            prepare_method_def(ir, module_name, cdef, mapper, node.node)
+            prepare_method_def(ir, module_name, cdef, mapper, node.node, options)
         elif isinstance(node.node, OverloadedFuncDef):
             # Handle case for property with both a getter and a setter
             if node.node.is_property:
                 if is_valid_multipart_property_def(node.node):
                     for item in node.node.items:
-                        prepare_method_def(ir, module_name, cdef, mapper, item)
+                        prepare_method_def(ir, module_name, cdef, mapper, item, options)
                 else:
                     errors.error("Unsupported property decorator semantics", path, cdef.line)
 
             # Handle case for regular function overload
             else:
-                assert node.node.impl
-                prepare_method_def(ir, module_name, cdef, mapper, node.node.impl)
+                if not node.node.impl:
+                    errors.error(
+                        "Overloads without implementation are not supported", path, cdef.line
+                    )
+                else:
+                    prepare_method_def(ir, module_name, cdef, mapper, node.node.impl, options)
 
     if ir.builtin_base:
         ir.attributes.clear()
@@ -436,7 +472,7 @@ def prepare_init_method(cdef: ClassDef, ir: ClassIR, module_name: str, mapper: M
     # Set up a constructor decl
     init_node = cdef.info["__init__"].node
     if not ir.is_trait and not ir.builtin_base and isinstance(init_node, FuncDef):
-        init_sig = mapper.fdef_to_sig(init_node)
+        init_sig = mapper.fdef_to_sig(init_node, True)
 
         defining_ir = mapper.type_to_ir.get(init_node.info)
         # If there is a nontrivial __init__ that wasn't defined in an
@@ -463,24 +499,29 @@ def prepare_init_method(cdef: ClassDef, ir: ClassIR, module_name: str, mapper: M
 
 
 def prepare_non_ext_class_def(
-    path: str, module_name: str, cdef: ClassDef, errors: Errors, mapper: Mapper
+    path: str,
+    module_name: str,
+    cdef: ClassDef,
+    errors: Errors,
+    mapper: Mapper,
+    options: CompilerOptions,
 ) -> None:
     ir = mapper.type_to_ir[cdef.info]
     info = cdef.info
 
-    for name, node in info.names.items():
+    for node in info.names.values():
         if isinstance(node.node, (FuncDef, Decorator)):
-            prepare_method_def(ir, module_name, cdef, mapper, node.node)
+            prepare_method_def(ir, module_name, cdef, mapper, node.node, options)
         elif isinstance(node.node, OverloadedFuncDef):
             # Handle case for property with both a getter and a setter
             if node.node.is_property:
                 if not is_valid_multipart_property_def(node.node):
                     errors.error("Unsupported property decorator semantics", path, cdef.line)
                 for item in node.node.items:
-                    prepare_method_def(ir, module_name, cdef, mapper, item)
+                    prepare_method_def(ir, module_name, cdef, mapper, item, options)
             # Handle case for regular function overload
             else:
-                prepare_method_def(ir, module_name, cdef, mapper, get_func_def(node.node))
+                prepare_method_def(ir, module_name, cdef, mapper, get_func_def(node.node), options)
 
     if any(cls in mapper.type_to_ir and mapper.type_to_ir[cls].is_ext_class for cls in info.mro):
         errors.error(
@@ -488,7 +529,7 @@ def prepare_non_ext_class_def(
         )
 
 
-RegisterImplInfo = Tuple[TypeInfo, FuncDef]
+RegisterImplInfo = tuple[TypeInfo, FuncDef]
 
 
 class SingledispatchInfo(NamedTuple):
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
index ff9df0cd597b..f652449f5289 100644
--- a/mypyc/irbuild/specialize.py
+++ b/mypyc/irbuild/specialize.py
@@ -19,6 +19,7 @@
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
+    BytesExpr,
     CallExpr,
     DictExpr,
     Expression,
@@ -44,11 +45,13 @@
 )
 from mypyc.ir.rtypes import (
     RInstance,
+    RPrimitive,
     RTuple,
     RType,
     bool_rprimitive,
     c_int_rprimitive,
     dict_rprimitive,
+    int16_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
     int_rprimitive,
@@ -56,13 +59,16 @@
     is_dict_rprimitive,
     is_fixed_width_rtype,
     is_float_rprimitive,
+    is_int16_rprimitive,
     is_int32_rprimitive,
     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 (
@@ -84,6 +90,11 @@
     dict_values_op,
 )
 from mypyc.primitives.list_ops import new_list_set_item_op
+from mypyc.primitives.str_ops import (
+    str_encode_ascii_strict,
+    str_encode_latin1_strict,
+    str_encode_utf8_strict,
+)
 from mypyc.primitives.tuple_ops import new_tuple_set_item_op
 
 # Specializers are attempted before compiling the arguments to the
@@ -163,15 +174,20 @@ 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")
+@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"):
+        if shortname in ("i64", "i32", "i16", "u8"):
             method = "__int__"
         else:
             method = f"__{shortname}__"
@@ -446,7 +462,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:
@@ -672,6 +688,58 @@ def translate_fstring(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Va
     return None
 
 
+@specialize_function("encode", str_rprimitive)
+def str_encode_fast_path(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
+    """Specialize common cases of str.encode for most used encodings and strict errors."""
+
+    if not isinstance(callee, MemberExpr):
+        return None
+
+    # We can only specialize if we have string literals as args
+    if len(expr.arg_kinds) > 0 and not isinstance(expr.args[0], StrExpr):
+        return None
+    if len(expr.arg_kinds) > 1 and not isinstance(expr.args[1], StrExpr):
+        return None
+
+    encoding = "utf8"
+    errors = "strict"
+    if len(expr.arg_kinds) > 0 and isinstance(expr.args[0], StrExpr):
+        if expr.arg_kinds[0] == ARG_NAMED:
+            if expr.arg_names[0] == "encoding":
+                encoding = expr.args[0].value
+            elif expr.arg_names[0] == "errors":
+                errors = expr.args[0].value
+        elif expr.arg_kinds[0] == ARG_POS:
+            encoding = expr.args[0].value
+        else:
+            return None
+    if len(expr.arg_kinds) > 1 and isinstance(expr.args[1], StrExpr):
+        if expr.arg_kinds[1] == ARG_NAMED:
+            if expr.arg_names[1] == "encoding":
+                encoding = expr.args[1].value
+            elif expr.arg_names[1] == "errors":
+                errors = expr.args[1].value
+        elif expr.arg_kinds[1] == ARG_POS:
+            errors = expr.args[1].value
+        else:
+            return None
+
+    if errors != "strict":
+        # We can only specialize strict errors
+        return None
+
+    encoding = encoding.lower().replace("-", "").replace("_", "")  # normalize
+    # Specialized encodings and their accepted aliases
+    if encoding in ["u8", "utf", "utf8", "cp65001"]:
+        return builder.call_c(str_encode_utf8_strict, [builder.accept(callee.expr)], expr.line)
+    elif encoding in ["646", "ascii", "usascii"]:
+        return builder.call_c(str_encode_ascii_strict, [builder.accept(callee.expr)], expr.line)
+    elif encoding in ["iso88591", "8859", "cp819", "latin", "latin1", "l1"]:
+        return builder.call_c(str_encode_latin1_strict, [builder.accept(callee.expr)], expr.line)
+
+    return None
+
+
 @specialize_function("mypy_extensions.i64")
 def translate_i64(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
@@ -680,9 +748,12 @@ 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_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)
@@ -700,12 +771,78 @@ 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_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
 
 
+@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_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:
@@ -732,7 +869,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]
@@ -741,3 +878,13 @@ def translate_float(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Opti
         # No-op float conversion.
         return builder.accept(arg)
     return None
+
+
+@specialize_function("builtins.ord")
+def translate_ord(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]
+    if isinstance(arg, (StrExpr, BytesExpr)) and len(arg.value) == 1:
+        return Integer(ord(arg.value))
+    return None
diff --git a/mypyc/irbuild/statement.py b/mypyc/irbuild/statement.py
index 63297618108c..b109d925558b 100644
--- a/mypyc/irbuild/statement.py
+++ b/mypyc/irbuild/statement.py
@@ -9,9 +9,12 @@
 from __future__ import annotations
 
 import importlib.util
-from typing import Callable, Sequence
+from collections.abc import Sequence
+from typing import Callable
 
 from mypy.nodes import (
+    ARG_NAMED,
+    ARG_POS,
     AssertStmt,
     AssignmentStmt,
     AwaitExpr,
@@ -37,6 +40,7 @@
     TempNode,
     TryStmt,
     TupleExpr,
+    TypeAliasStmt,
     WhileStmt,
     WithStmt,
     YieldExpr,
@@ -55,15 +59,18 @@
     LoadLiteral,
     LoadStatic,
     MethodCall,
+    PrimitiveDescription,
     RaiseStandardError,
     Register,
     Return,
     TupleGet,
+    Unborrow,
     Unreachable,
     Value,
 )
 from mypyc.ir.rtypes import (
     RInstance,
+    RTuple,
     c_pyssize_t_rprimitive,
     exc_rtuple,
     is_tagged,
@@ -72,7 +79,7 @@
     object_rprimitive,
 )
 from mypyc.irbuild.ast_helpers import is_borrow_friendly_expr, process_conditional
-from mypyc.irbuild.builder import IRBuilder, int_borrow_friendly_op
+from mypyc.irbuild.builder import IRBuilder, create_type_params, int_borrow_friendly_op
 from mypyc.irbuild.for_helpers import for_loop_helper
 from mypyc.irbuild.generator import add_raise_exception_blocks_to_generator_class
 from mypyc.irbuild.nonlocalcontrol import (
@@ -103,7 +110,9 @@
     coro_op,
     import_from_many_op,
     import_many_op,
+    import_op,
     send_op,
+    set_type_alias_compute_function_op,
     type_op,
     yield_from_except_op,
 )
@@ -116,8 +125,13 @@
 
 def transform_block(builder: IRBuilder, block: Block) -> None:
     if not block.is_unreachable:
+        builder.block_reachable_stack.append(True)
         for stmt in block.body:
             builder.accept(stmt)
+            if not builder.block_reachable_stack[-1]:
+                # The rest of the block is unreachable, so skip it
+                break
+        builder.block_reachable_stack.pop()
     # Raise a RuntimeError if we hit a non-empty unreachable block.
     # Don't complain about empty unreachable blocks, since mypy inserts
     # those after `if MYPY`.
@@ -183,8 +197,28 @@ def transform_assignment_stmt(builder: IRBuilder, stmt: AssignmentStmt) -> None:
 
     line = stmt.rvalue.line
     rvalue_reg = builder.accept(stmt.rvalue)
+
     if builder.non_function_scope() and stmt.is_final_def:
         builder.init_final_static(first_lvalue, rvalue_reg)
+
+    # Special-case multiple assignments like 'x, y = expr' to reduce refcount ops.
+    if (
+        isinstance(first_lvalue, (TupleExpr, ListExpr))
+        and isinstance(rvalue_reg.type, RTuple)
+        and len(rvalue_reg.type.types) == len(first_lvalue.items)
+        and len(lvalues) == 1
+        and all(is_simple_lvalue(item) for item in first_lvalue.items)
+        and any(t.is_refcounted for t in rvalue_reg.type.types)
+    ):
+        n = len(first_lvalue.items)
+        borrows = [builder.add(TupleGet(rvalue_reg, i, borrow=True)) for i in range(n)]
+        builder.builder.keep_alive([rvalue_reg], steal=True)
+        for lvalue_item, rvalue_item in zip(first_lvalue.items, borrows):
+            rvalue_item = builder.add(Unborrow(rvalue_item))
+            builder.assign(builder.get_assignment_target(lvalue_item), rvalue_item, line)
+        builder.flush_keep_alives()
+        return
+
     for lvalue in lvalues:
         target = builder.get_assignment_target(lvalue)
         builder.assign(target, rvalue_reg, line)
@@ -314,10 +348,10 @@ def transform_import_from(builder: IRBuilder, node: ImportFrom) -> None:
         return
 
     module_state = builder.graph[builder.module_name]
-    if module_state.ancestors is not None and module_state.ancestors:
-        module_package = module_state.ancestors[0]
-    elif builder.module_path.endswith("__init__.py"):
+    if builder.module_path.endswith("__init__.py"):
         module_package = builder.module_name
+    elif module_state.ancestors is not None and module_state.ancestors:
+        module_package = module_state.ancestors[0]
     else:
         module_package = ""
 
@@ -724,7 +758,7 @@ def transform_with(
         value = builder.add(MethodCall(mgr_v, f"__{al}enter__", args=[], line=line))
         exit_ = None
     else:
-        typ = builder.call_c(type_op, [mgr_v], line)
+        typ = builder.primitive_op(type_op, [mgr_v], line)
         exit_ = builder.maybe_spill(builder.py_get_attr(typ, f"__{al}exit__", line))
         value = builder.py_call(builder.py_get_attr(typ, f"__{al}enter__", line), [mgr_v], line)
 
@@ -843,7 +877,7 @@ def transform_del_item(builder: IRBuilder, target: AssignmentTarget, line: int)
                     line,
                 )
         key = builder.load_str(target.attr)
-        builder.call_c(py_delattr_op, [target.obj, key], line)
+        builder.primitive_op(py_delattr_op, [target.obj, key], line)
     elif isinstance(target, AssignmentTargetRegister):
         # Delete a local by assigning an error value to it, which will
         # prompt the insertion of uninit checks.
@@ -871,7 +905,7 @@ def emit_yield(builder: IRBuilder, val: Value, line: int) -> Value:
     next_label = len(cls.continuation_blocks)
     cls.continuation_blocks.append(next_block)
     builder.assign(cls.next_label_target, Integer(next_label), line)
-    builder.add(Return(retval))
+    builder.add(Return(retval, yield_target=next_block))
     builder.activate_block(next_block)
 
     add_raise_exception_blocks_to_generator_class(builder, line)
@@ -891,7 +925,10 @@ def emit_yield_from_or_await(
     received_reg = Register(object_rprimitive)
 
     get_op = coro_op if is_await else iter_op
-    iter_val = builder.call_c(get_op, [val], line)
+    if isinstance(get_op, PrimitiveDescription):
+        iter_val = builder.primitive_op(get_op, [val], line)
+    else:
+        iter_val = builder.call_c(get_op, [val], line)
 
     iter_reg = builder.maybe_spill_assignable(iter_val)
 
@@ -987,3 +1024,30 @@ def transform_await_expr(builder: IRBuilder, o: AwaitExpr) -> Value:
 
 def transform_match_stmt(builder: IRBuilder, m: MatchStmt) -> None:
     m.accept(MatchVisitor(builder, m))
+
+
+def transform_type_alias_stmt(builder: IRBuilder, s: TypeAliasStmt) -> None:
+    line = s.line
+    # Use "_typing" to avoid importing "typing", as the latter can be expensive.
+    # "_typing" includes everything we need here.
+    mod = builder.call_c(import_op, [builder.load_str("_typing")], line)
+    type_params = create_type_params(builder, mod, s.type_args, s.line)
+
+    type_alias_type = builder.py_get_attr(mod, "TypeAliasType", line)
+    args = [builder.load_str(s.name.name), builder.none()]
+    arg_names: list[str | None] = [None, None]
+    arg_kinds = [ARG_POS, ARG_POS]
+    if s.type_args:
+        args.append(builder.new_tuple(type_params, line))
+        arg_names.append("type_params")
+        arg_kinds.append(ARG_NAMED)
+    alias = builder.py_call(type_alias_type, args, line, arg_names=arg_names, arg_kinds=arg_kinds)
+
+    # Use primitive to set function used to lazily compute type alias type value.
+    # The value needs to be lazily computed to match Python runtime behavior, but
+    # Python public APIs don't support this, so we use a C primitive.
+    compute_fn = s.value.accept(builder.visitor)
+    builder.builder.primitive_op(set_type_alias_compute_function_op, [alias, compute_fn], line)
+
+    target = builder.get_assignment_target(s.name)
+    builder.assign(target, alias, line)
diff --git a/mypyc/irbuild/util.py b/mypyc/irbuild/util.py
index ed01a59d1214..757b49c68c83 100644
--- a/mypyc/irbuild/util.py
+++ b/mypyc/irbuild/util.py
@@ -27,10 +27,17 @@
     UnaryExpr,
     Var,
 )
+from mypy.semanal import refers_to_fullname
+from mypy.types import FINAL_DECORATOR_NAMES
+from mypyc.errors import Errors
 
 DATACLASS_DECORATORS = {"dataclasses.dataclass", "attr.s", "attr.attrs"}
 
 
+def is_final_decorator(d: Expression) -> bool:
+    return refers_to_fullname(d, FINAL_DECORATOR_NAMES)
+
+
 def is_trait_decorator(d: Expression) -> bool:
     return isinstance(d, RefExpr) and d.fullname == "mypy_extensions.trait"
 
@@ -67,6 +74,8 @@ def is_dataclass(cdef: ClassDef) -> bool:
     return any(is_dataclass_decorator(d) for d in cdef.decorators)
 
 
+# The string values returned by this function are inspected in
+# mypyc/lib-rt/misc_ops.c:CPyDataclass_SleightOfHand(...).
 def dataclass_type(cdef: ClassDef) -> str | None:
     for d in cdef.decorators:
         typ = dataclass_decorator_type(d)
@@ -117,23 +126,90 @@ def get_mypyc_attrs(stmt: ClassDef | Decorator) -> dict[str, Any]:
     return attrs
 
 
-def is_extension_class(cdef: ClassDef) -> bool:
-    if any(
-        not is_trait_decorator(d) and not is_dataclass_decorator(d) and not get_mypyc_attr_call(d)
-        for d in cdef.decorators
-    ):
+def is_extension_class(path: str, cdef: ClassDef, errors: Errors) -> bool:
+    # Check for @mypyc_attr(native_class=True/False) decorator.
+    explicit_native_class = get_explicit_native_class(path, cdef, errors)
+
+    # Classes with native_class=False are explicitly marked as non extension.
+    if explicit_native_class is False:
         return False
+
+    implicit_extension_class, reason = is_implicit_extension_class(cdef)
+
+    # Classes with native_class=True should be extension classes, but they might
+    # not be able to be due to other reasons. Print an error in that case.
+    if explicit_native_class is True and not implicit_extension_class:
+        errors.error(
+            f"Class is marked as native_class=True but it can't be a native class. {reason}",
+            path,
+            cdef.line,
+        )
+
+    return implicit_extension_class
+
+
+def get_explicit_native_class(path: str, cdef: ClassDef, errors: Errors) -> bool | None:
+    """Return value of @mypyc_attr(native_class=True/False) decorator.
+
+    Look for a @mypyc_attr decorator with native_class=True/False and return
+    the value assigned or None if it doesn't exist. Other values are an error.
+    """
+
+    for d in cdef.decorators:
+        mypyc_attr_call = get_mypyc_attr_call(d)
+        if not mypyc_attr_call:
+            continue
+
+        for i, name in enumerate(mypyc_attr_call.arg_names):
+            if name != "native_class":
+                continue
+
+            arg = mypyc_attr_call.args[i]
+            if not isinstance(arg, NameExpr):
+                errors.error("native_class must be used with True or False only", path, cdef.line)
+                return None
+
+            if arg.name == "False":
+                return False
+            elif arg.name == "True":
+                return True
+            else:
+                errors.error("native_class must be used with True or False only", path, cdef.line)
+                return None
+    return None
+
+
+def is_implicit_extension_class(cdef: ClassDef) -> tuple[bool, str]:
+    """Check if class can be extension class and return a user-friendly reason it can't be one."""
+
+    for d in cdef.decorators:
+        if (
+            not is_trait_decorator(d)
+            and not is_dataclass_decorator(d)
+            and not get_mypyc_attr_call(d)
+            and not is_final_decorator(d)
+        ):
+            return (
+                False,
+                "Classes that have decorators other than supported decorators"
+                " can't be native classes.",
+            )
+
     if cdef.info.typeddict_type:
-        return False
+        return False, "TypedDict classes can't be native classes."
     if cdef.info.is_named_tuple:
-        return False
+        return False, "NamedTuple classes can't be native classes."
     if cdef.info.metaclass_type and cdef.info.metaclass_type.type.fullname not in (
         "abc.ABCMeta",
         "typing.TypingMeta",
         "typing.GenericMeta",
     ):
-        return False
-    return True
+        return (
+            False,
+            "Classes with a metaclass other than ABCMeta, TypingMeta or"
+            " GenericMeta can't be native classes.",
+        )
+    return True, ""
 
 
 def get_func_def(op: FuncDef | Decorator | OverloadedFuncDef) -> FuncDef:
diff --git a/mypyc/irbuild/visitor.py b/mypyc/irbuild/visitor.py
index d8725ee04dc5..05a033c3e6ad 100644
--- a/mypyc/irbuild/visitor.py
+++ b/mypyc/irbuild/visitor.py
@@ -70,6 +70,7 @@
     TryStmt,
     TupleExpr,
     TypeAliasExpr,
+    TypeAliasStmt,
     TypeApplication,
     TypedDictExpr,
     TypeVarExpr,
@@ -136,6 +137,7 @@
     transform_raise_stmt,
     transform_return_stmt,
     transform_try_stmt,
+    transform_type_alias_stmt,
     transform_while_stmt,
     transform_with_stmt,
     transform_yield_expr,
@@ -194,6 +196,7 @@ def visit_expression_stmt(self, stmt: ExpressionStmt) -> None:
 
     def visit_return_stmt(self, stmt: ReturnStmt) -> None:
         transform_return_stmt(self.builder, stmt)
+        self.builder.mark_block_unreachable()
 
     def visit_assignment_stmt(self, stmt: AssignmentStmt) -> None:
         transform_assignment_stmt(self.builder, stmt)
@@ -212,12 +215,15 @@ def visit_for_stmt(self, stmt: ForStmt) -> None:
 
     def visit_break_stmt(self, stmt: BreakStmt) -> None:
         transform_break_stmt(self.builder, stmt)
+        self.builder.mark_block_unreachable()
 
     def visit_continue_stmt(self, stmt: ContinueStmt) -> None:
         transform_continue_stmt(self.builder, stmt)
+        self.builder.mark_block_unreachable()
 
     def visit_raise_stmt(self, stmt: RaiseStmt) -> None:
         transform_raise_stmt(self.builder, stmt)
+        self.builder.mark_block_unreachable()
 
     def visit_try_stmt(self, stmt: TryStmt) -> None:
         transform_try_stmt(self.builder, stmt)
@@ -245,6 +251,9 @@ def visit_nonlocal_decl(self, stmt: NonlocalDecl) -> None:
     def visit_match_stmt(self, stmt: MatchStmt) -> None:
         transform_match_stmt(self.builder, stmt)
 
+    def visit_type_alias_stmt(self, stmt: TypeAliasStmt) -> None:
+        transform_type_alias_stmt(self.builder, stmt)
+
     # Expressions
 
     def visit_name_expr(self, expr: NameExpr) -> Value:
diff --git a/mypyc/lib-rt/CPy.h b/mypyc/lib-rt/CPy.h
index 7a3e16fe9d65..1f0cf4dd63d6 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
 
 
@@ -123,41 +120,44 @@ static inline size_t CPy_FindAttrOffset(PyTypeObject *trait, CPyVTableItem *vtab
 CPyTagged CPyTagged_FromSsize_t(Py_ssize_t value);
 CPyTagged CPyTagged_FromVoidPtr(void *ptr);
 CPyTagged CPyTagged_FromInt64(int64_t value);
-CPyTagged CPyTagged_FromObject(PyObject *object);
-CPyTagged CPyTagged_StealFromObject(PyObject *object);
-CPyTagged CPyTagged_BorrowFromObject(PyObject *object);
 PyObject *CPyTagged_AsObject(CPyTagged x);
 PyObject *CPyTagged_StealAsObject(CPyTagged x);
 Py_ssize_t CPyTagged_AsSsize_t(CPyTagged x);
 void CPyTagged_IncRef(CPyTagged x);
 void CPyTagged_DecRef(CPyTagged x);
 void CPyTagged_XDecRef(CPyTagged x);
-CPyTagged CPyTagged_Negate(CPyTagged num);
-CPyTagged CPyTagged_Invert(CPyTagged num);
-CPyTagged CPyTagged_Add(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_Subtract(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_Multiply(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_FloorDivide(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_Remainder(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_And(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_Or(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_Xor(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_Rshift(CPyTagged left, CPyTagged right);
-CPyTagged CPyTagged_Lshift(CPyTagged left, CPyTagged right);
+
 bool CPyTagged_IsEq_(CPyTagged left, CPyTagged right);
 bool CPyTagged_IsLt_(CPyTagged left, CPyTagged right);
+CPyTagged CPyTagged_Negate_(CPyTagged num);
+CPyTagged CPyTagged_Invert_(CPyTagged num);
+CPyTagged CPyTagged_Add_(CPyTagged left, CPyTagged right);
+CPyTagged CPyTagged_Subtract_(CPyTagged left, CPyTagged right);
+CPyTagged CPyTagged_Multiply_(CPyTagged left, CPyTagged right);
+CPyTagged CPyTagged_FloorDivide_(CPyTagged left, CPyTagged right);
+CPyTagged CPyTagged_Remainder_(CPyTagged left, CPyTagged right);
+CPyTagged CPyTagged_BitwiseLongOp_(CPyTagged a, CPyTagged b, char op);
+CPyTagged CPyTagged_Rshift_(CPyTagged left, CPyTagged right);
+CPyTagged CPyTagged_Lshift_(CPyTagged left, CPyTagged right);
+
 PyObject *CPyTagged_Str(CPyTagged n);
 CPyTagged CPyTagged_FromFloat(double f);
 PyObject *CPyLong_FromStrWithBase(PyObject *o, CPyTagged base);
 PyObject *CPyLong_FromStr(PyObject *o);
 PyObject *CPyBool_Str(bool b);
-int64_t CPyLong_AsInt64(PyObject *o);
+int64_t CPyLong_AsInt64_(PyObject *o);
 int64_t CPyInt64_Divide(int64_t x, int64_t y);
 int64_t CPyInt64_Remainder(int64_t x, int64_t y);
-int32_t CPyLong_AsInt32(PyObject *o);
+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);
+uint8_t CPyLong_AsUInt8_(PyObject *o);
+void CPyUInt8_Overflow(void);
 double CPyTagged_TrueDivide(CPyTagged x, CPyTagged y);
 
 static inline int CPyTagged_CheckLong(CPyTagged x) {
@@ -196,6 +196,41 @@ static inline PyObject *CPyTagged_LongAsObject(CPyTagged x) {
     return (PyObject *)(x & ~CPY_INT_TAG);
 }
 
+static inline CPyTagged CPyTagged_FromObject(PyObject *object) {
+    int overflow;
+    // The overflow check knows about CPyTagged's width
+    Py_ssize_t value = CPyLong_AsSsize_tAndOverflow(object, &overflow);
+    if (unlikely(overflow != 0)) {
+        Py_INCREF(object);
+        return ((CPyTagged)object) | CPY_INT_TAG;
+    } else {
+        return value << 1;
+    }
+}
+
+static inline CPyTagged CPyTagged_StealFromObject(PyObject *object) {
+    int overflow;
+    // The overflow check knows about CPyTagged's width
+    Py_ssize_t value = CPyLong_AsSsize_tAndOverflow(object, &overflow);
+    if (unlikely(overflow != 0)) {
+        return ((CPyTagged)object) | CPY_INT_TAG;
+    } else {
+        Py_DECREF(object);
+        return value << 1;
+    }
+}
+
+static inline CPyTagged CPyTagged_BorrowFromObject(PyObject *object) {
+    int overflow;
+    // The overflow check knows about CPyTagged's width
+    Py_ssize_t value = CPyLong_AsSsize_tAndOverflow(object, &overflow);
+    if (unlikely(overflow != 0)) {
+        return ((CPyTagged)object) | CPY_INT_TAG;
+    } else {
+        return value << 1;
+    }
+}
+
 static inline bool CPyTagged_TooBig(Py_ssize_t value) {
     // Micro-optimized for the common case where it fits.
     return (size_t)value > CPY_TAGGED_MAX
@@ -283,6 +318,245 @@ static inline bool CPyTagged_IsLe(CPyTagged left, CPyTagged right) {
     }
 }
 
+static inline int64_t CPyLong_AsInt64(PyObject *o) {
+    if (likely(PyLong_Check(o))) {
+        PyLongObject *lobj = (PyLongObject *)o;
+        Py_ssize_t size = Py_SIZE(lobj);
+        if (likely(size == 1)) {
+            // Fast path
+            return CPY_LONG_DIGIT(lobj, 0);
+        } else if (likely(size == 0)) {
+            return 0;
+        }
+    }
+    // Slow path
+    return CPyLong_AsInt64_(o);
+}
+
+static inline 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 CPY_LONG_DIGIT(lobj, 0);
+        } else if (likely(size == 0)) {
+            return 0;
+        }
+    #endif
+    }
+    // Slow path
+    return CPyLong_AsInt32_(o);
+}
+
+static inline 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)) {
+            // Fast path
+            digit x = lobj->ob_digit[0];
+            if (x < 0x8000)
+                return x;
+        } else if (likely(size == 0)) {
+            return 0;
+        }
+    #endif
+    }
+    // Slow path
+    return CPyLong_AsInt16_(o);
+}
+
+static inline 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
+    return CPyLong_AsUInt8_(o);
+}
+
+static inline CPyTagged CPyTagged_Negate(CPyTagged num) {
+    if (likely(CPyTagged_CheckShort(num)
+               && num != (CPyTagged) ((Py_ssize_t)1 << (CPY_INT_BITS - 1)))) {
+        // The only possibility of an overflow error happening when negating a short is if we
+        // attempt to negate the most negative number.
+        return -num;
+    }
+    return CPyTagged_Negate_(num);
+}
+
+static inline CPyTagged CPyTagged_Add(CPyTagged left, CPyTagged right) {
+    // TODO: Use clang/gcc extension __builtin_saddll_overflow instead.
+    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
+        CPyTagged sum = left + right;
+        if (likely(!CPyTagged_IsAddOverflow(sum, left, right))) {
+            return sum;
+        }
+    }
+    return CPyTagged_Add_(left, right);
+}
+
+static inline CPyTagged CPyTagged_Subtract(CPyTagged left, CPyTagged right) {
+    // TODO: Use clang/gcc extension __builtin_saddll_overflow instead.
+    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
+        CPyTagged diff = left - right;
+        if (likely(!CPyTagged_IsSubtractOverflow(diff, left, right))) {
+            return diff;
+        }
+    }
+    return CPyTagged_Subtract_(left, right);
+}
+
+static inline CPyTagged CPyTagged_Multiply(CPyTagged left, CPyTagged right) {
+    // TODO: Consider using some clang/gcc extension to check for overflow
+    if (CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right)) {
+        if (!CPyTagged_IsMultiplyOverflow(left, right)) {
+            return left * CPyTagged_ShortAsSsize_t(right);
+        }
+    }
+    return CPyTagged_Multiply_(left, right);
+}
+
+static inline CPyTagged CPyTagged_FloorDivide(CPyTagged left, CPyTagged right) {
+    if (CPyTagged_CheckShort(left)
+        && CPyTagged_CheckShort(right)
+        && !CPyTagged_MaybeFloorDivideFault(left, right)) {
+        Py_ssize_t result = CPyTagged_ShortAsSsize_t(left) / CPyTagged_ShortAsSsize_t(right);
+        if (((Py_ssize_t)left < 0) != (((Py_ssize_t)right) < 0)) {
+            if (result * right != left) {
+                // Round down
+                result--;
+            }
+        }
+        return result << 1;
+    }
+    return CPyTagged_FloorDivide_(left, right);
+}
+
+static inline CPyTagged CPyTagged_Remainder(CPyTagged left, CPyTagged right) {
+    if (CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right)
+        && !CPyTagged_MaybeRemainderFault(left, right)) {
+        Py_ssize_t result = (Py_ssize_t)left % (Py_ssize_t)right;
+        if (((Py_ssize_t)right < 0) != ((Py_ssize_t)left < 0) && result != 0) {
+            result += right;
+        }
+        return result;
+    }
+    return CPyTagged_Remainder_(left, right);
+}
+
+// Bitwise '~'
+static inline CPyTagged CPyTagged_Invert(CPyTagged num) {
+    if (likely(CPyTagged_CheckShort(num) && num != CPY_TAGGED_ABS_MIN)) {
+        return ~num & ~CPY_INT_TAG;
+    }
+    return CPyTagged_Invert_(num);
+}
+
+// Bitwise '&'
+static inline CPyTagged CPyTagged_And(CPyTagged left, CPyTagged right) {
+    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
+        return left & right;
+    }
+    return CPyTagged_BitwiseLongOp_(left, right, '&');
+}
+
+// Bitwise '|'
+static inline CPyTagged CPyTagged_Or(CPyTagged left, CPyTagged right) {
+    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
+        return left | right;
+    }
+    return CPyTagged_BitwiseLongOp_(left, right, '|');
+}
+
+// Bitwise '^'
+static inline CPyTagged CPyTagged_Xor(CPyTagged left, CPyTagged right) {
+    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
+        return left ^ right;
+    }
+    return CPyTagged_BitwiseLongOp_(left, right, '^');
+}
+
+// Bitwise '>>'
+static inline CPyTagged CPyTagged_Rshift(CPyTagged left, CPyTagged right) {
+    if (likely(CPyTagged_CheckShort(left)
+               && CPyTagged_CheckShort(right)
+               && (Py_ssize_t)right >= 0)) {
+        CPyTagged count = CPyTagged_ShortAsSsize_t(right);
+        if (unlikely(count >= CPY_INT_BITS)) {
+            if ((Py_ssize_t)left >= 0) {
+                return 0;
+            } else {
+                return CPyTagged_ShortFromInt(-1);
+            }
+        }
+        return ((Py_ssize_t)left >> count) & ~CPY_INT_TAG;
+    }
+    return CPyTagged_Rshift_(left, right);
+}
+
+static inline bool IsShortLshiftOverflow(Py_ssize_t short_int, Py_ssize_t shift) {
+    return ((Py_ssize_t)(short_int << shift) >> shift) != short_int;
+}
+
+// Bitwise '<<'
+static inline CPyTagged CPyTagged_Lshift(CPyTagged left, CPyTagged right) {
+    if (likely(CPyTagged_CheckShort(left)
+               && CPyTagged_CheckShort(right)
+               && (Py_ssize_t)right >= 0
+               && right < CPY_INT_BITS * 2)) {
+        CPyTagged shift = CPyTagged_ShortAsSsize_t(right);
+        if (!IsShortLshiftOverflow(left, shift))
+            // Short integers, no overflow
+            return left << shift;
+    }
+    return CPyTagged_Lshift_(left, right);
+}
+
 
 // Float operations
 
@@ -388,9 +662,12 @@ int CPyList_Insert(PyObject *list, CPyTagged index, PyObject *value);
 PyObject *CPyList_Extend(PyObject *o1, PyObject *o2);
 int CPyList_Remove(PyObject *list, PyObject *obj);
 CPyTagged CPyList_Index(PyObject *list, PyObject *obj);
+PyObject *CPySequence_Sort(PyObject *seq);
 PyObject *CPySequence_Multiply(PyObject *seq, CPyTagged t_size);
 PyObject *CPySequence_RMultiply(CPyTagged t_size, PyObject *seq);
+PyObject *CPySequence_InPlaceMultiply(PyObject *seq, CPyTagged t_size);
 PyObject *CPyList_GetSlice(PyObject *obj, CPyTagged start, CPyTagged end);
+PyObject *CPyList_Copy(PyObject *list);
 int CPySequence_Check(PyObject *obj);
 
 
@@ -443,19 +720,39 @@ static inline char CPyDict_CheckSize(PyObject *dict, CPyTagged size) {
 
 // Str operations
 
+// Macros for strip type. These values are copied from CPython.
+#define LEFTSTRIP  0
+#define RIGHTSTRIP 1
+#define BOTHSTRIP  2
 
 PyObject *CPyStr_Build(Py_ssize_t len, ...);
 PyObject *CPyStr_GetItem(PyObject *str, CPyTagged index);
+CPyTagged CPyStr_Find(PyObject *str, PyObject *substr, CPyTagged start, int direction);
+CPyTagged CPyStr_FindWithEnd(PyObject *str, PyObject *substr, CPyTagged start, CPyTagged end, int direction);
 PyObject *CPyStr_Split(PyObject *str, PyObject *sep, CPyTagged max_split);
+PyObject *CPyStr_RSplit(PyObject *str, PyObject *sep, CPyTagged max_split);
+PyObject *_CPyStr_Strip(PyObject *self, int strip_type, PyObject *sep);
+static inline PyObject *CPyStr_Strip(PyObject *self, PyObject *sep) {
+    return _CPyStr_Strip(self, BOTHSTRIP, sep);
+}
+static inline PyObject *CPyStr_LStrip(PyObject *self, PyObject *sep) {
+    return _CPyStr_Strip(self, LEFTSTRIP, sep);
+}
+static inline PyObject *CPyStr_RStrip(PyObject *self, PyObject *sep) {
+    return _CPyStr_Strip(self, RIGHTSTRIP, sep);
+}
 PyObject *CPyStr_Replace(PyObject *str, PyObject *old_substr, PyObject *new_substr, CPyTagged max_replace);
 PyObject *CPyStr_Append(PyObject *o1, PyObject *o2);
 PyObject *CPyStr_GetSlice(PyObject *obj, CPyTagged start, CPyTagged end);
-bool CPyStr_Startswith(PyObject *self, PyObject *subobj);
-bool CPyStr_Endswith(PyObject *self, PyObject *subobj);
+int CPyStr_Startswith(PyObject *self, PyObject *subobj);
+int CPyStr_Endswith(PyObject *self, PyObject *subobj);
+PyObject *CPyStr_Removeprefix(PyObject *self, PyObject *prefix);
+PyObject *CPyStr_Removesuffix(PyObject *self, PyObject *suffix);
 bool CPyStr_IsTrue(PyObject *obj);
 Py_ssize_t CPyStr_Size_size_t(PyObject *str);
 PyObject *CPy_Decode(PyObject *obj, PyObject *encoding, PyObject *errors);
 PyObject *CPy_Encode(PyObject *obj, PyObject *encoding, PyObject *errors);
+CPyTagged CPyStr_Ord(PyObject *obj);
 
 
 // Bytes operations
@@ -466,6 +763,7 @@ PyObject *CPyBytes_GetSlice(PyObject *obj, CPyTagged start, CPyTagged end);
 CPyTagged CPyBytes_GetItem(PyObject *o, CPyTagged index);
 PyObject *CPyBytes_Concat(PyObject *a, PyObject *b);
 PyObject *CPyBytes_Join(PyObject *sep, PyObject *iter);
+CPyTagged CPyBytes_Ord(PyObject *obj);
 
 
 int CPyBytes_Compare(PyObject *left, PyObject *right);
@@ -509,7 +807,7 @@ static inline PyObject *_CPy_FromDummy(PyObject *p) {
     return p;
 }
 
-static int CPy_NoErrOccured(void) {
+static int CPy_NoErrOccurred(void) {
     return PyErr_Occurred() == NULL;
 }
 
@@ -541,13 +839,8 @@ void CPy_AttributeError(const char *filename, const char *funcname, const char *
 
 // Misc operations
 
-#if PY_VERSION_HEX >= 0x03080000
 #define CPy_TRASHCAN_BEGIN(op, dealloc) Py_TRASHCAN_BEGIN(op, dealloc)
 #define CPy_TRASHCAN_END(op) Py_TRASHCAN_END
-#else
-#define CPy_TRASHCAN_BEGIN(op, dealloc) Py_TRASHCAN_SAFE_BEGIN(op)
-#define CPy_TRASHCAN_END(op) Py_TRASHCAN_SAFE_END(op)
-#endif
 
 // Tweaked version of _PyArg_Parser in CPython
 typedef struct CPyArg_Parser {
@@ -577,10 +870,7 @@ static inline bool CPy_TypeCheck(PyObject *o, PyObject *type) {
     return PyObject_TypeCheck(o, (PyTypeObject *)type);
 }
 
-static inline PyObject *CPy_CalculateMetaclass(PyObject *type, PyObject *o) {
-    return (PyObject *)_PyType_CalculateMetaclass((PyTypeObject *)type, o);
-}
-
+PyObject *CPy_CalculateMetaclass(PyObject *type, PyObject *o);
 PyObject *CPy_GetCoro(PyObject *obj);
 PyObject *CPyIter_Send(PyObject *iter, PyObject *val);
 int CPy_YieldFromErrorHandle(PyObject *iter, PyObject **outp);
@@ -588,15 +878,17 @@ PyObject *CPy_FetchStopIterationValue(void);
 PyObject *CPyType_FromTemplate(PyObject *template_,
                                PyObject *orig_bases,
                                PyObject *modname);
-PyObject *CPyType_FromTemplateWarpper(PyObject *template_,
+PyObject *CPyType_FromTemplateWrapper(PyObject *template_,
                                       PyObject *orig_bases,
                                       PyObject *modname);
 int CPyDataclass_SleightOfHand(PyObject *dataclass_dec, PyObject *tp,
-                               PyObject *dict, PyObject *annotations);
+                               PyObject *dict, PyObject *annotations,
+                               PyObject *dataclass_type);
 PyObject *CPyPickle_SetState(PyObject *obj, PyObject *state);
 PyObject *CPyPickle_GetState(PyObject *obj);
 CPyTagged CPyTagged_Id(PyObject *o);
 void CPyDebug_Print(const char *msg);
+void CPyDebug_PrintObject(PyObject *obj);
 void CPy_Init(void);
 int CPyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
                                  const char *, const char *, const char * const *, ...);
@@ -632,6 +924,7 @@ PyObject *CPySingledispatch_RegisterFunction(PyObject *singledispatch_func, PyOb
 
 PyObject *CPy_GetAIter(PyObject *obj);
 PyObject *CPy_GetANext(PyObject *aiter);
+void CPy_SetTypeAliasTypeComputeFunction(PyObject *alias, PyObject *compute_value);
 
 #ifdef __cplusplus
 }
diff --git a/mypyc/lib-rt/bytes_ops.c b/mypyc/lib-rt/bytes_ops.c
index 4da62be11571..6ff34b021a9a 100644
--- a/mypyc/lib-rt/bytes_ops.c
+++ b/mypyc/lib-rt/bytes_ops.c
@@ -99,10 +99,14 @@ PyObject *CPyBytes_GetSlice(PyObject *obj, CPyTagged start, CPyTagged end) {
 // (mostly commonly, for bytearrays)
 PyObject *CPyBytes_Join(PyObject *sep, PyObject *iter) {
     if (PyBytes_CheckExact(sep)) {
-        return _PyBytes_Join(sep, iter);
+        return PyBytes_Join(sep, iter);
     } else {
         _Py_IDENTIFIER(join);
-        return _PyObject_CallMethodIdOneArg(sep, &PyId_join, iter);
+        PyObject *name = _PyUnicode_FromId(&PyId_join); /* borrowed */
+        if (name == NULL) {
+            return NULL;
+        }
+        return PyObject_CallMethodOneArg(sep, name, iter);
     }
 }
 
@@ -141,3 +145,20 @@ PyObject *CPyBytes_Build(Py_ssize_t len, ...) {
 
     return (PyObject *)ret;
 }
+
+
+CPyTagged CPyBytes_Ord(PyObject *obj) {
+    if (PyBytes_Check(obj)) {
+        Py_ssize_t s = PyBytes_GET_SIZE(obj);
+        if (s == 1) {
+            return (unsigned char)(PyBytes_AS_STRING(obj)[0]) << 1;
+        }
+    } else if (PyByteArray_Check(obj)) {
+        Py_ssize_t s = PyByteArray_GET_SIZE(obj);
+        if (s == 1) {
+            return (unsigned char)(PyByteArray_AS_STRING(obj)[0]) << 1;
+        }
+    }
+    PyErr_SetString(PyExc_TypeError, "ord() expects a character");
+    return CPY_INT_TAG;
+}
diff --git a/mypyc/lib-rt/dict_ops.c b/mypyc/lib-rt/dict_ops.c
index c0cc8d5a7f87..b102aba57307 100644
--- a/mypyc/lib-rt/dict_ops.c
+++ b/mypyc/lib-rt/dict_ops.c
@@ -78,7 +78,11 @@ PyObject *CPyDict_SetDefault(PyObject *dict, PyObject *key, PyObject *value) {
         return ret;
     }
     _Py_IDENTIFIER(setdefault);
-    return _PyObject_CallMethodIdObjArgs(dict, &PyId_setdefault, key, value, NULL);
+    PyObject *name = _PyUnicode_FromId(&PyId_setdefault); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    return PyObject_CallMethodObjArgs(dict, name, key, value, NULL);
 }
 
 PyObject *CPyDict_SetDefaultWithNone(PyObject *dict, PyObject *key) {
@@ -133,7 +137,11 @@ static inline int CPy_ObjectToStatus(PyObject *obj) {
 
 static int CPyDict_UpdateGeneral(PyObject *dict, PyObject *stuff) {
     _Py_IDENTIFIER(update);
-    PyObject *res = _PyObject_CallMethodIdOneArg(dict, &PyId_update, stuff);
+    PyObject *name = _PyUnicode_FromId(&PyId_update); /* borrowed */
+    if (name == NULL) {
+        return -1;
+    }
+    PyObject *res = PyObject_CallMethodOneArg(dict, name, stuff);
     return CPy_ObjectToStatus(res);
 }
 
@@ -200,7 +208,11 @@ PyObject *CPyDict_KeysView(PyObject *dict) {
         return _CPyDictView_New(dict, &PyDictKeys_Type);
     }
     _Py_IDENTIFIER(keys);
-    return _PyObject_CallMethodIdNoArgs(dict, &PyId_keys);
+    PyObject *name = _PyUnicode_FromId(&PyId_keys); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    return PyObject_CallMethodNoArgs(dict, name);
 }
 
 PyObject *CPyDict_ValuesView(PyObject *dict) {
@@ -208,7 +220,11 @@ PyObject *CPyDict_ValuesView(PyObject *dict) {
         return _CPyDictView_New(dict, &PyDictValues_Type);
     }
     _Py_IDENTIFIER(values);
-    return _PyObject_CallMethodIdNoArgs(dict, &PyId_values);
+    PyObject *name = _PyUnicode_FromId(&PyId_values); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    return PyObject_CallMethodNoArgs(dict, name);
 }
 
 PyObject *CPyDict_ItemsView(PyObject *dict) {
@@ -216,7 +232,11 @@ PyObject *CPyDict_ItemsView(PyObject *dict) {
         return _CPyDictView_New(dict, &PyDictItems_Type);
     }
     _Py_IDENTIFIER(items);
-    return _PyObject_CallMethodIdNoArgs(dict, &PyId_items);
+    PyObject *name = _PyUnicode_FromId(&PyId_items); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    return PyObject_CallMethodNoArgs(dict, name);
 }
 
 PyObject *CPyDict_Keys(PyObject *dict) {
@@ -226,16 +246,19 @@ PyObject *CPyDict_Keys(PyObject *dict) {
     // Inline generic fallback logic to also return a list.
     PyObject *list = PyList_New(0);
     _Py_IDENTIFIER(keys);
-    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_keys);
+    PyObject *name = _PyUnicode_FromId(&PyId_keys); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    PyObject *view = PyObject_CallMethodNoArgs(dict, name);
     if (view == NULL) {
         return NULL;
     }
-    PyObject *res = _PyList_Extend((PyListObject *)list, view);
+    int res = PyList_Extend(list, view);
     Py_DECREF(view);
-    if (res == NULL) {
+    if (res < 0) {
         return NULL;
     }
-    Py_DECREF(res);
     return list;
 }
 
@@ -246,16 +269,19 @@ PyObject *CPyDict_Values(PyObject *dict) {
     // Inline generic fallback logic to also return a list.
     PyObject *list = PyList_New(0);
     _Py_IDENTIFIER(values);
-    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_values);
+    PyObject *name = _PyUnicode_FromId(&PyId_values); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    PyObject *view = PyObject_CallMethodNoArgs(dict, name);
     if (view == NULL) {
         return NULL;
     }
-    PyObject *res = _PyList_Extend((PyListObject *)list, view);
+    int res = PyList_Extend(list, view);
     Py_DECREF(view);
-    if (res == NULL) {
+    if (res < 0) {
         return NULL;
     }
-    Py_DECREF(res);
     return list;
 }
 
@@ -266,16 +292,19 @@ PyObject *CPyDict_Items(PyObject *dict) {
     // Inline generic fallback logic to also return a list.
     PyObject *list = PyList_New(0);
     _Py_IDENTIFIER(items);
-    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_items);
+    PyObject *name = _PyUnicode_FromId(&PyId_items); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    PyObject *view = PyObject_CallMethodNoArgs(dict, name);
     if (view == NULL) {
         return NULL;
     }
-    PyObject *res = _PyList_Extend((PyListObject *)list, view);
+    int res = PyList_Extend(list, view);
     Py_DECREF(view);
-    if (res == NULL) {
+    if (res < 0) {
         return NULL;
     }
-    Py_DECREF(res);
     return list;
 }
 
@@ -284,7 +313,11 @@ char CPyDict_Clear(PyObject *dict) {
         PyDict_Clear(dict);
     } else {
         _Py_IDENTIFIER(clear);
-        PyObject *res = _PyObject_CallMethodIdNoArgs(dict, &PyId_clear);
+        PyObject *name = _PyUnicode_FromId(&PyId_clear); /* borrowed */
+        if (name == NULL) {
+            return 0;
+        }
+        PyObject *res = PyObject_CallMethodNoArgs(dict, name);
         if (res == NULL) {
             return 0;
         }
@@ -297,7 +330,11 @@ PyObject *CPyDict_Copy(PyObject *dict) {
         return PyDict_Copy(dict);
     }
     _Py_IDENTIFIER(copy);
-    return _PyObject_CallMethodIdNoArgs(dict, &PyId_copy);
+    PyObject *name = _PyUnicode_FromId(&PyId_copy); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    return PyObject_CallMethodNoArgs(dict, name);
 }
 
 PyObject *CPyDict_GetKeysIter(PyObject *dict) {
@@ -316,7 +353,11 @@ PyObject *CPyDict_GetItemsIter(PyObject *dict) {
         return dict;
     }
     _Py_IDENTIFIER(items);
-    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_items);
+    PyObject *name = _PyUnicode_FromId(&PyId_items); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    PyObject *view = PyObject_CallMethodNoArgs(dict, name);
     if (view == NULL) {
         return NULL;
     }
@@ -332,7 +373,11 @@ PyObject *CPyDict_GetValuesIter(PyObject *dict) {
         return dict;
     }
     _Py_IDENTIFIER(values);
-    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_values);
+    PyObject *name = _PyUnicode_FromId(&PyId_values); /* borrowed */
+    if (name == NULL) {
+        return NULL;
+    }
+    PyObject *view = PyObject_CallMethodNoArgs(dict, name);
     if (view == NULL) {
         return NULL;
     }
diff --git a/mypyc/lib-rt/exc_ops.c b/mypyc/lib-rt/exc_ops.c
index 219914bf3470..d8307ecf21f8 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
@@ -230,7 +236,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
diff --git a/mypyc/lib-rt/float_ops.c b/mypyc/lib-rt/float_ops.c
index d8c6f25955fa..319065742559 100644
--- a/mypyc/lib-rt/float_ops.c
+++ b/mypyc/lib-rt/float_ops.c
@@ -16,6 +16,33 @@ static double CPy_MathRangeError(void) {
     return CPY_FLOAT_ERROR;
 }
 
+static double CPy_MathExpectedNonNegativeInputError(double x) {
+    char *buf = PyOS_double_to_string(x, 'r', 0, Py_DTSF_ADD_DOT_0, NULL);
+    if (buf) {
+        PyErr_Format(PyExc_ValueError, "expected a nonnegative input, got %s", buf);
+        PyMem_Free(buf);
+    }
+    return CPY_FLOAT_ERROR;
+}
+
+static double CPy_MathExpectedPositiveInputError(double x) {
+    char *buf = PyOS_double_to_string(x, 'r', 0, Py_DTSF_ADD_DOT_0, NULL);
+    if (buf) {
+        PyErr_Format(PyExc_ValueError, "expected a positive input, got %s", buf);
+        PyMem_Free(buf);
+    }
+    return CPY_FLOAT_ERROR;
+}
+
+static double CPy_MathExpectedFiniteInput(double x) {
+    char *buf = PyOS_double_to_string(x, 'r', 0, Py_DTSF_ADD_DOT_0, NULL);
+    if (buf) {
+        PyErr_Format(PyExc_ValueError, "expected a finite input, got %s", buf);
+        PyMem_Free(buf);
+    }
+    return CPY_FLOAT_ERROR;
+}
+
 double CPyFloat_FromTagged(CPyTagged x) {
     if (CPyTagged_CheckShort(x)) {
         return CPyTagged_ShortAsSsize_t(x);
@@ -30,7 +57,11 @@ double CPyFloat_FromTagged(CPyTagged x) {
 double CPyFloat_Sin(double x) {
     double v = sin(x);
     if (unlikely(isnan(v)) && !isnan(x)) {
+#if CPY_3_14_FEATURES
+        return CPy_MathExpectedFiniteInput(x);
+#else
         return CPy_DomainError();
+#endif
     }
     return v;
 }
@@ -38,21 +69,33 @@ double CPyFloat_Sin(double x) {
 double CPyFloat_Cos(double x) {
     double v = cos(x);
     if (unlikely(isnan(v)) && !isnan(x)) {
+#if CPY_3_14_FEATURES
+        return CPy_MathExpectedFiniteInput(x);
+#else
         return CPy_DomainError();
+#endif
     }
     return v;
 }
 
 double CPyFloat_Tan(double x) {
     if (unlikely(isinf(x))) {
+#if CPY_3_14_FEATURES
+        return CPy_MathExpectedFiniteInput(x);
+#else
         return CPy_DomainError();
+#endif
     }
     return tan(x);
 }
 
 double CPyFloat_Sqrt(double x) {
     if (x < 0.0) {
+#if CPY_3_14_FEATURES
+        return CPy_MathExpectedNonNegativeInputError(x);
+#else
         return CPy_DomainError();
+#endif
     }
     return sqrt(x);
 }
@@ -67,7 +110,11 @@ double CPyFloat_Exp(double x) {
 
 double CPyFloat_Log(double x) {
     if (x <= 0.0) {
+#if CPY_3_14_FEATURES
+        return CPy_MathExpectedPositiveInputError(x);
+#else
         return CPy_DomainError();
+#endif
     }
     return log(x);
 }
diff --git a/mypyc/lib-rt/getargs.c b/mypyc/lib-rt/getargs.c
index 3c8b528f8048..163b9ac2b163 100644
--- a/mypyc/lib-rt/getargs.c
+++ b/mypyc/lib-rt/getargs.c
@@ -247,16 +247,15 @@ vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
 #endif
         if (!skip) {
             if (i < nargs && i < max) {
-                current_arg = PyTuple_GET_ITEM(args, i);
+                current_arg = Py_NewRef(PyTuple_GET_ITEM(args, i));
             }
             else if (nkwargs && i >= pos) {
-                current_arg = _PyDict_GetItemStringWithError(kwargs, kwlist[i]);
+                if (unlikely(PyDict_GetItemStringRef(kwargs, kwlist[i], &current_arg) < 0)) {
+                    return 0;
+                }
                 if (current_arg) {
                     --nkwargs;
                 }
-                else if (PyErr_Occurred()) {
-                    return 0;
-                }
             }
             else {
                 current_arg = NULL;
@@ -265,6 +264,7 @@ vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
             if (current_arg) {
                 PyObject **p = va_arg(*p_va, PyObject **);
                 *p = current_arg;
+                Py_DECREF(current_arg);
                 format++;
                 continue;
             }
@@ -370,8 +370,12 @@ vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
         Py_ssize_t j;
         /* make sure there are no arguments given by name and position */
         for (i = pos; i < bound_pos_args && i < len; i++) {
-            current_arg = _PyDict_GetItemStringWithError(kwargs, kwlist[i]);
+            PyObject *current_arg;
+            if (unlikely(PyDict_GetItemStringRef(kwargs, kwlist[i], &current_arg) < 0)) {
+                goto latefail;
+            }
             if (unlikely(current_arg != NULL)) {
+                Py_DECREF(current_arg);
                 /* arg present in tuple and in dict */
                 PyErr_Format(PyExc_TypeError,
                              "argument for %.200s%s given by name ('%s') "
@@ -381,9 +385,6 @@ vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
                              kwlist[i], i+1);
                 goto latefail;
             }
-            else if (unlikely(PyErr_Occurred() != NULL)) {
-                goto latefail;
-            }
         }
         /* make sure there are no extraneous keyword arguments */
         j = 0;
@@ -395,7 +396,7 @@ vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format,
                 goto latefail;
             }
             for (i = pos; i < len; i++) {
-                if (CPyUnicode_EqualToASCIIString(key, kwlist[i])) {
+                if (PyUnicode_EqualToUTF8(key, kwlist[i])) {
                     match = 1;
                     break;
                 }
diff --git a/mypyc/lib-rt/getargsfast.c b/mypyc/lib-rt/getargsfast.c
index 387deed4399b..e5667e22efe3 100644
--- a/mypyc/lib-rt/getargsfast.c
+++ b/mypyc/lib-rt/getargsfast.c
@@ -271,7 +271,7 @@ find_keyword(PyObject *kwnames, PyObject *const *kwstack, PyObject *key)
     for (i = 0; i < nkwargs; i++) {
         PyObject *kwname = PyTuple_GET_ITEM(kwnames, i);
         assert(PyUnicode_Check(kwname));
-        if (_PyUnicode_EQ(kwname, key)) {
+        if (PyUnicode_Equal(kwname, key)) {
             return kwstack[i];
         }
     }
diff --git a/mypyc/lib-rt/int_ops.c b/mypyc/lib-rt/int_ops.c
index 843d9b0d2230..e2c302eea576 100644
--- a/mypyc/lib-rt/int_ops.c
+++ b/mypyc/lib-rt/int_ops.c
@@ -44,41 +44,6 @@ CPyTagged CPyTagged_FromInt64(int64_t value) {
     }
 }
 
-CPyTagged CPyTagged_FromObject(PyObject *object) {
-    int overflow;
-    // The overflow check knows about CPyTagged's width
-    Py_ssize_t value = CPyLong_AsSsize_tAndOverflow(object, &overflow);
-    if (unlikely(overflow != 0)) {
-        Py_INCREF(object);
-        return ((CPyTagged)object) | CPY_INT_TAG;
-    } else {
-        return value << 1;
-    }
-}
-
-CPyTagged CPyTagged_StealFromObject(PyObject *object) {
-    int overflow;
-    // The overflow check knows about CPyTagged's width
-    Py_ssize_t value = CPyLong_AsSsize_tAndOverflow(object, &overflow);
-    if (unlikely(overflow != 0)) {
-        return ((CPyTagged)object) | CPY_INT_TAG;
-    } else {
-        Py_DECREF(object);
-        return value << 1;
-    }
-}
-
-CPyTagged CPyTagged_BorrowFromObject(PyObject *object) {
-    int overflow;
-    // The overflow check knows about CPyTagged's width
-    Py_ssize_t value = CPyLong_AsSsize_tAndOverflow(object, &overflow);
-    if (unlikely(overflow != 0)) {
-        return ((CPyTagged)object) | CPY_INT_TAG;
-    } else {
-        return value << 1;
-    }
-}
-
 PyObject *CPyTagged_AsObject(CPyTagged x) {
     PyObject *value;
     if (unlikely(CPyTagged_CheckLong(x))) {
@@ -135,13 +100,8 @@ void CPyTagged_XDecRef(CPyTagged x) {
     }
 }
 
-CPyTagged CPyTagged_Negate(CPyTagged num) {
-    if (CPyTagged_CheckShort(num)
-            && num != (CPyTagged) ((Py_ssize_t)1 << (CPY_INT_BITS - 1))) {
-        // The only possibility of an overflow error happening when negating a short is if we
-        // attempt to negate the most negative number.
-        return -num;
-    }
+// Tagged int negation slow path, where the result may be a long integer
+CPyTagged CPyTagged_Negate_(CPyTagged num) {
     PyObject *num_obj = CPyTagged_AsObject(num);
     PyObject *result = PyNumber_Negative(num_obj);
     if (result == NULL) {
@@ -151,14 +111,8 @@ CPyTagged CPyTagged_Negate(CPyTagged num) {
     return CPyTagged_StealFromObject(result);
 }
 
-CPyTagged CPyTagged_Add(CPyTagged left, CPyTagged right) {
-    // TODO: Use clang/gcc extension __builtin_saddll_overflow instead.
-    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
-        CPyTagged sum = left + right;
-        if (likely(!CPyTagged_IsAddOverflow(sum, left, right))) {
-            return sum;
-        }
-    }
+// Tagged int addition slow path, where the result may be a long integer
+CPyTagged CPyTagged_Add_(CPyTagged left, CPyTagged right) {
     PyObject *left_obj = CPyTagged_AsObject(left);
     PyObject *right_obj = CPyTagged_AsObject(right);
     PyObject *result = PyNumber_Add(left_obj, right_obj);
@@ -170,14 +124,8 @@ CPyTagged CPyTagged_Add(CPyTagged left, CPyTagged right) {
     return CPyTagged_StealFromObject(result);
 }
 
-CPyTagged CPyTagged_Subtract(CPyTagged left, CPyTagged right) {
-    // TODO: Use clang/gcc extension __builtin_saddll_overflow instead.
-    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
-        CPyTagged diff = left - right;
-        if (likely(!CPyTagged_IsSubtractOverflow(diff, left, right))) {
-            return diff;
-        }
-    }
+// Tagged int subtraction slow path, where the result may be a long integer
+CPyTagged CPyTagged_Subtract_(CPyTagged left, CPyTagged right) {
     PyObject *left_obj = CPyTagged_AsObject(left);
     PyObject *right_obj = CPyTagged_AsObject(right);
     PyObject *result = PyNumber_Subtract(left_obj, right_obj);
@@ -189,13 +137,8 @@ CPyTagged CPyTagged_Subtract(CPyTagged left, CPyTagged right) {
     return CPyTagged_StealFromObject(result);
 }
 
-CPyTagged CPyTagged_Multiply(CPyTagged left, CPyTagged right) {
-    // TODO: Consider using some clang/gcc extension
-    if (CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right)) {
-        if (!CPyTagged_IsMultiplyOverflow(left, right)) {
-            return left * CPyTagged_ShortAsSsize_t(right);
-        }
-    }
+// Tagged int multiplication slow path, where the result may be a long integer
+CPyTagged CPyTagged_Multiply_(CPyTagged left, CPyTagged right) {
     PyObject *left_obj = CPyTagged_AsObject(left);
     PyObject *right_obj = CPyTagged_AsObject(right);
     PyObject *result = PyNumber_Multiply(left_obj, right_obj);
@@ -207,19 +150,8 @@ CPyTagged CPyTagged_Multiply(CPyTagged left, CPyTagged right) {
     return CPyTagged_StealFromObject(result);
 }
 
-CPyTagged CPyTagged_FloorDivide(CPyTagged left, CPyTagged right) {
-    if (CPyTagged_CheckShort(left)
-        && CPyTagged_CheckShort(right)
-        && !CPyTagged_MaybeFloorDivideFault(left, right)) {
-        Py_ssize_t result = CPyTagged_ShortAsSsize_t(left) / CPyTagged_ShortAsSsize_t(right);
-        if (((Py_ssize_t)left < 0) != (((Py_ssize_t)right) < 0)) {
-            if (result * right != left) {
-                // Round down
-                result--;
-            }
-        }
-        return result << 1;
-    }
+// Tagged int // slow path, where the result may be a long integer (or raise)
+CPyTagged CPyTagged_FloorDivide_(CPyTagged left, CPyTagged right) {
     PyObject *left_obj = CPyTagged_AsObject(left);
     PyObject *right_obj = CPyTagged_AsObject(right);
     PyObject *result = PyNumber_FloorDivide(left_obj, right_obj);
@@ -233,15 +165,8 @@ CPyTagged CPyTagged_FloorDivide(CPyTagged left, CPyTagged right) {
     }
 }
 
-CPyTagged CPyTagged_Remainder(CPyTagged left, CPyTagged right) {
-    if (CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right)
-        && !CPyTagged_MaybeRemainderFault(left, right)) {
-        Py_ssize_t result = (Py_ssize_t)left % (Py_ssize_t)right;
-        if (((Py_ssize_t)right < 0) != ((Py_ssize_t)left < 0) && result != 0) {
-            result += right;
-        }
-        return result;
-    }
+// Tagged int % slow path, where the result may be a long integer (or raise)
+CPyTagged CPyTagged_Remainder_(CPyTagged left, CPyTagged right) {
     PyObject *left_obj = CPyTagged_AsObject(left);
     PyObject *right_obj = CPyTagged_AsObject(right);
     PyObject *result = PyNumber_Remainder(left_obj, right_obj);
@@ -307,13 +232,6 @@ PyObject *CPyBool_Str(bool b) {
     return PyObject_Str(b ? Py_True : Py_False);
 }
 
-static void CPyLong_NormalizeUnsigned(PyLongObject *v) {
-    Py_ssize_t i = v->ob_base.ob_size;
-    while (i > 0 && v->ob_digit[i - 1] == 0)
-        i--;
-    v->ob_base.ob_size = i;
-}
-
 // Bitwise op '&', '|' or '^' using the generic (slow) API
 static CPyTagged GenericBitwiseOp(CPyTagged a, CPyTagged b, char op) {
     PyObject *aobj = CPyTagged_AsObject(a);
@@ -361,14 +279,14 @@ 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);
     }
 }
 
 // Shared implementation of bitwise '&', '|' and '^' (specified by op) for at least
 // one long operand. This is somewhat optimized for performance.
-static CPyTagged BitwiseLongOp(CPyTagged a, CPyTagged b, char op) {
+CPyTagged CPyTagged_BitwiseLongOp_(CPyTagged a, CPyTagged b, char op) {
     // Directly access the digits, as there is no fast C API function for this.
     digit abuf[3];
     digit bbuf[3];
@@ -377,7 +295,6 @@ static CPyTagged BitwiseLongOp(CPyTagged a, CPyTagged b, char op) {
     digit *adigits = GetIntDigits(a, &asize, abuf);
     digit *bdigits = GetIntDigits(b, &bsize, bbuf);
 
-    PyLongObject *r;
     if (unlikely(asize < 0 || bsize < 0)) {
         // Negative operand. This is slower, but bitwise ops on them are pretty rare.
         return GenericBitwiseOp(a, b, op);
@@ -392,116 +309,61 @@ static CPyTagged BitwiseLongOp(CPyTagged a, CPyTagged b, char op) {
         asize = bsize;
         bsize = tmp_size;
     }
-    r = _PyLong_New(op == '&' ? asize : bsize);
-    if (unlikely(r == NULL)) {
+    void *digits = NULL;
+    PyLongWriter *writer = PyLongWriter_Create(0, op == '&' ? asize : bsize, &digits);
+    if (unlikely(writer == NULL)) {
         CPyError_OutOfMemory();
     }
     Py_ssize_t i;
     if (op == '&') {
         for (i = 0; i < asize; i++) {
-            r->ob_digit[i] = adigits[i] & bdigits[i];
+            ((digit *)digits)[i] = adigits[i] & bdigits[i];
         }
     } else {
         if (op == '|') {
             for (i = 0; i < asize; i++) {
-                r->ob_digit[i] = adigits[i] | bdigits[i];
+                ((digit *)digits)[i] = adigits[i] | bdigits[i];
             }
         } else {
             for (i = 0; i < asize; i++) {
-                r->ob_digit[i] = adigits[i] ^ bdigits[i];
+                ((digit *)digits)[i] = adigits[i] ^ bdigits[i];
             }
         }
         for (; i < bsize; i++) {
-            r->ob_digit[i] = bdigits[i];
+            ((digit *)digits)[i] = bdigits[i];
         }
     }
-    CPyLong_NormalizeUnsigned(r);
-    return CPyTagged_StealFromObject((PyObject *)r);
-}
-
-// Bitwise '&'
-CPyTagged CPyTagged_And(CPyTagged left, CPyTagged right) {
-    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
-        return left & right;
-    }
-    return BitwiseLongOp(left, right, '&');
-}
-
-// Bitwise '|'
-CPyTagged CPyTagged_Or(CPyTagged left, CPyTagged right) {
-    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
-        return left | right;
-    }
-    return BitwiseLongOp(left, right, '|');
+    return CPyTagged_StealFromObject(PyLongWriter_Finish(writer));
 }
 
-// Bitwise '^'
-CPyTagged CPyTagged_Xor(CPyTagged left, CPyTagged right) {
-    if (likely(CPyTagged_CheckShort(left) && CPyTagged_CheckShort(right))) {
-        return left ^ right;
-    }
-    return BitwiseLongOp(left, right, '^');
-}
-
-// Bitwise '~'
-CPyTagged CPyTagged_Invert(CPyTagged num) {
-    if (likely(CPyTagged_CheckShort(num) && num != CPY_TAGGED_ABS_MIN)) {
-        return ~num & ~CPY_INT_TAG;
-    } else {
-        PyObject *obj = CPyTagged_AsObject(num);
-        PyObject *result = PyNumber_Invert(obj);
-        if (unlikely(result == NULL)) {
-            CPyError_OutOfMemory();
-        }
-        Py_DECREF(obj);
-        return CPyTagged_StealFromObject(result);
+// Bitwise '~' slow path
+CPyTagged CPyTagged_Invert_(CPyTagged num) {
+    PyObject *obj = CPyTagged_AsObject(num);
+    PyObject *result = PyNumber_Invert(obj);
+    if (unlikely(result == NULL)) {
+        CPyError_OutOfMemory();
     }
+    Py_DECREF(obj);
+    return CPyTagged_StealFromObject(result);
 }
 
-// Bitwise '>>'
-CPyTagged CPyTagged_Rshift(CPyTagged left, CPyTagged right) {
-    if (likely(CPyTagged_CheckShort(left)
-               && CPyTagged_CheckShort(right)
-               && (Py_ssize_t)right >= 0)) {
-        CPyTagged count = CPyTagged_ShortAsSsize_t(right);
-        if (unlikely(count >= CPY_INT_BITS)) {
-            if ((Py_ssize_t)left >= 0) {
-                return 0;
-            } else {
-                return CPyTagged_ShortFromInt(-1);
-            }
-        }
-        return ((Py_ssize_t)left >> count) & ~CPY_INT_TAG;
-    } else {
-        // Long integer or negative shift -- use generic op
-        PyObject *lobj = CPyTagged_AsObject(left);
-        PyObject *robj = CPyTagged_AsObject(right);
-        PyObject *result = PyNumber_Rshift(lobj, robj);
-        Py_DECREF(lobj);
-        Py_DECREF(robj);
-        if (result == NULL) {
-            // Propagate error (could be negative shift count)
-            return CPY_INT_TAG;
-        }
-        return CPyTagged_StealFromObject(result);
+// Bitwise '>>' slow path
+CPyTagged CPyTagged_Rshift_(CPyTagged left, CPyTagged right) {
+    // Long integer or negative shift -- use generic op
+    PyObject *lobj = CPyTagged_AsObject(left);
+    PyObject *robj = CPyTagged_AsObject(right);
+    PyObject *result = PyNumber_Rshift(lobj, robj);
+    Py_DECREF(lobj);
+    Py_DECREF(robj);
+    if (result == NULL) {
+        // Propagate error (could be negative shift count)
+        return CPY_INT_TAG;
     }
+    return CPyTagged_StealFromObject(result);
 }
 
-static inline bool IsShortLshiftOverflow(Py_ssize_t short_int, Py_ssize_t shift) {
-    return ((Py_ssize_t)(short_int << shift) >> shift) != short_int;
-}
-
-// Bitwise '<<'
-CPyTagged CPyTagged_Lshift(CPyTagged left, CPyTagged right) {
-    if (likely(CPyTagged_CheckShort(left)
-               && CPyTagged_CheckShort(right)
-               && (Py_ssize_t)right >= 0
-               && right < CPY_INT_BITS * 2)) {
-        CPyTagged shift = CPyTagged_ShortAsSsize_t(right);
-        if (!IsShortLshiftOverflow(left, shift))
-            // Short integers, no overflow
-            return left << shift;
-    }
+// Bitwise '<<' slow path
+CPyTagged CPyTagged_Lshift_(CPyTagged left, CPyTagged right) {
     // Long integer or out of range shift -- use generic op
     PyObject *lobj = CPyTagged_AsObject(left);
     PyObject *robj = CPyTagged_AsObject(right);
@@ -515,18 +377,8 @@ CPyTagged CPyTagged_Lshift(CPyTagged left, CPyTagged right) {
     return CPyTagged_StealFromObject(result);
 }
 
-int64_t CPyLong_AsInt64(PyObject *o) {
-    if (likely(PyLong_Check(o))) {
-        PyLongObject *lobj = (PyLongObject *)o;
-        Py_ssize_t size = Py_SIZE(lobj);
-        if (likely(size == 1)) {
-            // Fast path
-            return lobj->ob_digit[0];
-        } else if (likely(size == 0)) {
-            return 0;
-        }
-    }
-    // Slow path
+// i64 unboxing slow path
+int64_t CPyLong_AsInt64_(PyObject *o) {
     int overflow;
     int64_t result = PyLong_AsLongLongAndOverflow(o, &overflow);
     if (result == -1) {
@@ -574,18 +426,8 @@ int64_t CPyInt64_Remainder(int64_t x, int64_t y) {
     return d;
 }
 
-int32_t CPyLong_AsInt32(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
-            return lobj->ob_digit[0];
-        } else if (likely(size == 0)) {
-            return 0;
-        }
-    }
-    // Slow path
+// i32 unboxing slow path
+int32_t CPyLong_AsInt32_(PyObject *o) {
     int overflow;
     long result = PyLong_AsLongAndOverflow(o, &overflow);
     if (result > 0x7fffffffLL || result < -0x80000000LL) {
@@ -641,6 +483,86 @@ void CPyInt32_Overflow() {
     PyErr_SetString(PyExc_OverflowError, "int too large to convert to i32");
 }
 
+// i16 unboxing slow path
+int16_t CPyLong_AsInt16_(PyObject *o) {
+    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");
+}
+
+// u8 unboxing slow path
+uint8_t CPyLong_AsUInt8_(PyObject *o) {
+    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/list_ops.c b/mypyc/lib-rt/list_ops.c
index df87228a0d10..4dddb2249f06 100644
--- a/mypyc/lib-rt/list_ops.c
+++ b/mypyc/lib-rt/list_ops.c
@@ -29,6 +29,20 @@ PyObject *CPyList_Build(Py_ssize_t len, ...) {
     return res;
 }
 
+PyObject *CPyList_Copy(PyObject *list) {
+    if(PyList_CheckExact(list)) {
+        return PyList_GetSlice(list, 0, PyList_GET_SIZE(list));
+    }
+    _Py_IDENTIFIER(copy);
+
+    PyObject *name = _PyUnicode_FromId(&PyId_copy);
+    if (name == NULL) {
+        return NULL;
+    }
+    return PyObject_CallMethodNoArgs(list, name);
+}
+
+
 PyObject *CPyList_GetItemUnsafe(PyObject *list, CPyTagged index) {
     Py_ssize_t n = CPyTagged_ShortAsSsize_t(index);
     PyObject *result = PyList_GET_ITEM(list, n);
@@ -256,7 +270,10 @@ int CPyList_Insert(PyObject *list, CPyTagged index, PyObject *value)
 }
 
 PyObject *CPyList_Extend(PyObject *o1, PyObject *o2) {
-    return _PyList_Extend((PyListObject *)o1, o2);
+    if (PyList_Extend(o1, o2) < 0) {
+        return NULL;
+    }
+    Py_RETURN_NONE;
 }
 
 // Return -2 or error, -1 if not found, or index of first match otherwise.
@@ -302,6 +319,18 @@ CPyTagged CPyList_Index(PyObject *list, PyObject *obj) {
     return index << 1;
 }
 
+PyObject *CPySequence_Sort(PyObject *seq) {
+    PyObject *newlist = PySequence_List(seq);
+    if (newlist == NULL)
+        return NULL;
+    int res = PyList_Sort(newlist);
+    if (res < 0) {
+        Py_DECREF(newlist);
+        return NULL;
+    }
+    return newlist;
+}
+
 PyObject *CPySequence_Multiply(PyObject *seq, CPyTagged t_size) {
     Py_ssize_t size = CPyTagged_AsSsize_t(t_size);
     if (size == -1 && PyErr_Occurred()) {
@@ -314,6 +343,14 @@ PyObject *CPySequence_RMultiply(CPyTagged t_size, PyObject *seq) {
     return CPySequence_Multiply(seq, t_size);
 }
 
+PyObject *CPySequence_InPlaceMultiply(PyObject *seq, CPyTagged t_size) {
+    Py_ssize_t size = CPyTagged_AsSsize_t(t_size);
+    if (size == -1 && PyErr_Occurred()) {
+        return NULL;
+    }
+    return PySequence_InPlaceRepeat(seq, size);
+}
+
 PyObject *CPyList_GetSlice(PyObject *obj, CPyTagged start, CPyTagged end) {
     if (likely(PyList_CheckExact(obj)
                && CPyTagged_CheckShort(start) && CPyTagged_CheckShort(end))) {
diff --git a/mypyc/lib-rt/misc_ops.c b/mypyc/lib-rt/misc_ops.c
index 88a76fb210d7..d234138b2ff7 100644
--- a/mypyc/lib-rt/misc_ops.c
+++ b/mypyc/lib-rt/misc_ops.c
@@ -24,11 +24,15 @@ PyObject *CPyIter_Send(PyObject *iter, PyObject *val)
 {
     // Do a send, or a next if second arg is None.
     // (This behavior is to match the PEP 380 spec for yield from.)
-    _Py_IDENTIFIER(send);
     if (Py_IsNone(val)) {
         return CPyIter_Next(iter);
     } else {
-        return _PyObject_CallMethodIdOneArg(iter, &PyId_send, val);
+        _Py_IDENTIFIER(send);
+        PyObject *name = _PyUnicode_FromId(&PyId_send); /* borrowed */
+        if (name == NULL) {
+            return NULL;
+        }
+        return PyObject_CallMethodOneArg(iter, name, val);
     }
 }
 
@@ -131,6 +135,52 @@ static bool _CPy_IsSafeMetaClass(PyTypeObject *metaclass) {
     return matches;
 }
 
+#if CPY_3_13_FEATURES
+
+// Adapted from CPython 3.13.0b3
+/* Determine the most derived metatype. */
+PyObject *CPy_CalculateMetaclass(PyObject *metatype, PyObject *bases)
+{
+    Py_ssize_t i, nbases;
+    PyTypeObject *winner;
+    PyObject *tmp;
+    PyTypeObject *tmptype;
+
+    /* Determine the proper metatype to deal with this,
+       and check for metatype conflicts while we're at it.
+       Note that if some other metatype wins to contract,
+       it's possible that its instances are not types. */
+
+    nbases = PyTuple_GET_SIZE(bases);
+    winner = (PyTypeObject *)metatype;
+    for (i = 0; i < nbases; i++) {
+        tmp = PyTuple_GET_ITEM(bases, i);
+        tmptype = Py_TYPE(tmp);
+        if (PyType_IsSubtype(winner, tmptype))
+            continue;
+        if (PyType_IsSubtype(tmptype, winner)) {
+            winner = tmptype;
+            continue;
+        }
+        /* else: */
+        PyErr_SetString(PyExc_TypeError,
+                        "metaclass conflict: "
+                        "the metaclass of a derived class "
+                        "must be a (non-strict) subclass "
+                        "of the metaclasses of all its bases");
+        return NULL;
+    }
+    return (PyObject *)winner;
+}
+
+#else
+
+PyObject *CPy_CalculateMetaclass(PyObject *metatype, PyObject *bases) {
+    return (PyObject *)_PyType_CalculateMetaclass((PyTypeObject *)metatype, bases);
+}
+
+#endif
+
 // Create a heap type based on a template non-heap type.
 // This is super hacky and maybe we should suck it up and use PyType_FromSpec instead.
 // We allow bases to be NULL to represent just inheriting from object.
@@ -163,7 +213,7 @@ PyObject *CPyType_FromTemplate(PyObject *template,
         // Find the appropriate metaclass from our base classes. We
         // care about this because Generic uses a metaclass prior to
         // Python 3.7.
-        metaclass = _PyType_CalculateMetaclass(metaclass, bases);
+        metaclass = (PyTypeObject *)CPy_CalculateMetaclass((PyObject *)metaclass, bases);
         if (!metaclass)
             goto error;
 
@@ -177,42 +227,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)
@@ -337,13 +351,15 @@ static int _CPy_UpdateObjFromDict(PyObject *obj, PyObject *dict)
  *   tp: The class we are making a dataclass
  *   dict: The dictionary containing values that dataclasses needs
  *   annotations: The type annotation dictionary
+ *   dataclass_type: A str object with the return value of util.py:dataclass_type()
  */
 int
 CPyDataclass_SleightOfHand(PyObject *dataclass_dec, PyObject *tp,
-                           PyObject *dict, PyObject *annotations) {
+                           PyObject *dict, PyObject *annotations,
+                           PyObject *dataclass_type) {
     PyTypeObject *ttp = (PyTypeObject *)tp;
     Py_ssize_t pos;
-    PyObject *res;
+    PyObject *res = NULL;
 
     /* Make a copy of the original class __dict__ */
     PyObject *orig_dict = PyDict_Copy(ttp->tp_dict);
@@ -355,7 +371,8 @@ CPyDataclass_SleightOfHand(PyObject *dataclass_dec, PyObject *tp,
     pos = 0;
     PyObject *key;
     while (PyDict_Next(annotations, &pos, &key, NULL)) {
-        if (PyObject_DelAttr(tp, key) != 0) {
+        // Check and delete key. Key may be absent from tp for InitVar variables.
+        if (PyObject_HasAttr(tp, key) == 1 && PyObject_DelAttr(tp, key) != 0) {
             goto fail;
         }
     }
@@ -370,17 +387,37 @@ CPyDataclass_SleightOfHand(PyObject *dataclass_dec, PyObject *tp,
     if (!res) {
         goto fail;
     }
-    Py_DECREF(res);
+    const char *dataclass_type_ptr = PyUnicode_AsUTF8(dataclass_type);
+    if (dataclass_type_ptr == NULL) {
+        goto fail;
+    }
+    if (strcmp(dataclass_type_ptr, "attr") == 0 ||
+        strcmp(dataclass_type_ptr, "attr-auto") == 0) {
+        // These attributes are added or modified by @attr.s(slots=True).
+        const char * const keys[] = {"__attrs_attrs__", "__attrs_own_setattr__", "__init__", ""};
+        for (const char * const *key_iter = keys; **key_iter != '\0'; key_iter++) {
+            PyObject *value = NULL;
+            int rv = PyObject_GetOptionalAttrString(res, *key_iter, &value);
+            if (rv == 1) {
+                PyObject_SetAttrString(tp, *key_iter, value);
+                Py_DECREF(value);
+            } else if (rv == -1) {
+              goto fail;
+            }
+        }
+    }
 
     /* Copy back the original contents of the dict */
     if (_CPy_UpdateObjFromDict(tp, orig_dict) != 0) {
         goto fail;
     }
 
+    Py_DECREF(res);
     Py_DECREF(orig_dict);
     return 1;
 
 fail:
+    Py_XDECREF(res);
     Py_XDECREF(orig_dict);
     return 0;
 }
@@ -502,6 +539,22 @@ void CPyDebug_Print(const char *msg) {
     fflush(stdout);
 }
 
+void CPyDebug_PrintObject(PyObject *obj) {
+    // Printing can cause errors. We don't want this to affect any existing
+    // state so we'll save any existing error and restore it at the end.
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+
+    if (PyObject_Print(obj, stderr, 0) == -1) {
+        PyErr_Print();
+    } else {
+        fprintf(stderr, "\n");
+    }
+    fflush(stderr);
+
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+}
+
 int CPySequence_CheckUnpackCount(PyObject *sequence, Py_ssize_t expected) {
     Py_ssize_t actual = Py_SIZE(sequence);
     if (unlikely(actual != expected)) {
@@ -553,7 +606,7 @@ int CPyStatics_Initialize(PyObject **statics,
             while (num-- > 0) {
                 size_t len;
                 data = parse_int(data, &len);
-                PyObject *obj = PyUnicode_FromStringAndSize(data, len);
+                PyObject *obj = PyUnicode_DecodeUTF8(data, len, "surrogatepass");
                 if (obj == NULL) {
                     return -1;
                 }
@@ -887,7 +940,7 @@ PyObject *CPySingledispatch_RegisterFunction(PyObject *singledispatch_func,
 
 }
 
-// Adapated from ceval.c GET_AITER
+// Adapted from ceval.c GET_AITER
 PyObject *CPy_GetAIter(PyObject *obj)
 {
     unaryfunc getter = NULL;
@@ -925,7 +978,7 @@ PyObject *CPy_GetAIter(PyObject *obj)
     return iter;
 }
 
-// Adapated from ceval.c GET_ANEXT
+// Adapted from ceval.c GET_ANEXT
 PyObject *CPy_GetANext(PyObject *aiter)
 {
     unaryfunc getter = NULL;
@@ -976,3 +1029,34 @@ PyObject *CPy_GetANext(PyObject *aiter)
 error:
     return NULL;
 }
+
+#ifdef CPY_3_12_FEATURES
+
+// Copied from Python 3.12.3, since this struct is internal to CPython. It defines
+// the structure of typing.TypeAliasType objects. We need it since compute_value is
+// not part of the public API, and we need to set it to match Python runtime semantics.
+//
+// IMPORTANT: This needs to be kept in sync with CPython!
+typedef struct {
+    PyObject_HEAD
+    PyObject *name;
+    PyObject *type_params;
+    PyObject *compute_value;
+    PyObject *value;
+    PyObject *module;
+} typealiasobject;
+
+void CPy_SetTypeAliasTypeComputeFunction(PyObject *alias, PyObject *compute_value) {
+    typealiasobject *obj = (typealiasobject *)alias;
+    if (obj->value != NULL) {
+        Py_DECREF(obj->value);
+    }
+    obj->value = NULL;
+    Py_INCREF(compute_value);
+    if (obj->compute_value != NULL) {
+        Py_DECREF(obj->compute_value);
+    }
+    obj->compute_value = compute_value;
+}
+
+#endif
diff --git a/mypyc/lib-rt/module_shim.tmpl b/mypyc/lib-rt/module_shim.tmpl
index 6e772efd34ec..28cce9478d25 100644
--- a/mypyc/lib-rt/module_shim.tmpl
+++ b/mypyc/lib-rt/module_shim.tmpl
@@ -5,8 +5,11 @@ PyInit_{modname}(void)
 {{
     PyObject *tmp;
     if (!(tmp = PyImport_ImportModule("{libname}"))) return NULL;
+    PyObject *capsule = PyObject_GetAttrString(tmp, "init_{full_modname}");
     Py_DECREF(tmp);
-    void *init_func = PyCapsule_Import("{libname}.init_{full_modname}", 0);
+    if (capsule == NULL) return NULL;
+    void *init_func = PyCapsule_GetPointer(capsule, "{libname}.init_{full_modname}");
+    Py_DECREF(capsule);
     if (!init_func) {{
         return NULL;
     }}
diff --git a/mypyc/lib-rt/mypyc_util.h b/mypyc/lib-rt/mypyc_util.h
index 13672087fbbc..80019d23bb06 100644
--- a/mypyc/lib-rt/mypyc_util.h
+++ b/mypyc/lib-rt/mypyc_util.h
@@ -31,6 +31,35 @@
 // Here just for consistency
 #define CPy_XDECREF(p) Py_XDECREF(p)
 
+// The *_NO_IMM operations below perform refcount manipulation for
+// non-immortal objects (Python 3.12 and later).
+//
+// Py_INCREF and other CPython operations check for immortality. This
+// can be expensive when we know that an object cannot be immortal.
+
+static inline void CPy_INCREF_NO_IMM(PyObject *op)
+{
+    op->ob_refcnt++;
+}
+
+static inline void CPy_DECREF_NO_IMM(PyObject *op)
+{
+    if (--op->ob_refcnt == 0) {
+        _Py_Dealloc(op);
+    }
+}
+
+static inline void CPy_XDECREF_NO_IMM(PyObject *op)
+{
+    if (op != NULL && --op->ob_refcnt == 0) {
+        _Py_Dealloc(op);
+    }
+}
+
+#define CPy_INCREF_NO_IMM(op) CPy_INCREF_NO_IMM((PyObject *)(op))
+#define CPy_DECREF_NO_IMM(op) CPy_DECREF_NO_IMM((PyObject *)(op))
+#define CPy_XDECREF_NO_IMM(op) CPy_XDECREF_NO_IMM((PyObject *)(op))
+
 // Tagged integer -- our representation of Python 'int' objects.
 // Small enough integers are represented as unboxed integers (shifted
 // left by 1); larger integers (larger than 63 bits on a 64-bit
@@ -53,9 +82,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
 
@@ -69,4 +101,42 @@ 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)
+
+#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)
+
+#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)
+
+#endif
+
+// Are we targeting Python 3.13 or newer?
+#define CPY_3_13_FEATURES (PY_VERSION_HEX >= 0x030d0000)
+
+// Are we targeting Python 3.14 or newer?
+#define CPY_3_14_FEATURES (PY_VERSION_HEX >= 0x030e0000)
+
 #endif
diff --git a/mypyc/lib-rt/pythoncapi_compat.h b/mypyc/lib-rt/pythoncapi_compat.h
index f22e92f7358f..f94e50a3479f 100644
--- a/mypyc/lib-rt/pythoncapi_compat.h
+++ b/mypyc/lib-rt/pythoncapi_compat.h
@@ -7,7 +7,7 @@
 // https://github.com/python/pythoncapi_compat
 //
 // Latest version:
-// https://raw.githubusercontent.com/python/pythoncapi_compat/master/pythoncapi_compat.h
+// https://raw.githubusercontent.com/python/pythoncapi-compat/main/pythoncapi_compat.h
 //
 // SPDX-License-Identifier: 0BSD
 
@@ -19,34 +19,31 @@ extern "C" {
 #endif
 
 #include <Python.h>
-#include "frameobject.h"          // PyFrameObject, PyFrame_GetBack()
+#include <stddef.h>               // offsetof()
 
-
-// Compatibility with Visual Studio 2013 and older which don't support
-// the inline keyword in C (only in C++): use __inline instead.
-#if (defined(_MSC_VER) && _MSC_VER < 1900 \
-     && !defined(__cplusplus) && !defined(inline))
-#  define PYCAPI_COMPAT_STATIC_INLINE(TYPE) static __inline TYPE
-#else
-#  define PYCAPI_COMPAT_STATIC_INLINE(TYPE) static inline TYPE
+// Python 3.11.0b4 added PyFrame_Back() to Python.h
+#if PY_VERSION_HEX < 0x030b00B4 && !defined(PYPY_VERSION)
+#  include "frameobject.h"        // PyFrameObject, PyFrame_GetBack()
+#endif
+#if PY_VERSION_HEX < 0x030C00A3
+#  include <structmember.h>       // T_SHORT, READONLY
 #endif
 
 
-// C++ compatibility: _Py_CAST() and _Py_NULL
 #ifndef _Py_CAST
-#  ifdef __cplusplus
-#    define _Py_CAST(type, expr) \
-         const_cast<type>(reinterpret_cast<const type>(expr))
-#  else
-#    define _Py_CAST(type, expr) ((type)(expr))
-#  endif
+#  define _Py_CAST(type, expr) ((type)(expr))
 #endif
+
 #ifndef _Py_NULL
-#  ifdef __cplusplus
-#    define _Py_NULL nullptr
-#  else
-#    define _Py_NULL NULL
-#  endif
+// Static inline functions should use _Py_NULL rather than using directly NULL
+// to prevent C++ compiler warnings. On C23 and newer and on C++11 and newer,
+// _Py_NULL is defined as nullptr.
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L) \
+        || (defined(__cplusplus) && __cplusplus >= 201103)
+#  define _Py_NULL nullptr
+#else
+#  define _Py_NULL NULL
+#endif
 #endif
 
 // Cast argument to PyObject* type.
@@ -54,11 +51,17 @@ extern "C" {
 #  define _PyObject_CAST(op) _Py_CAST(PyObject*, op)
 #endif
 
+#ifndef Py_BUILD_ASSERT
+#  define Py_BUILD_ASSERT(cond) \
+        do { \
+            (void)sizeof(char [1 - 2 * !(cond)]); \
+        } while(0)
+#endif
+
 
 // bpo-42262 added Py_NewRef() to Python 3.10.0a3
 #if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_NewRef)
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-_Py_NewRef(PyObject *obj)
+static inline PyObject* _Py_NewRef(PyObject *obj)
 {
     Py_INCREF(obj);
     return obj;
@@ -69,8 +72,7 @@ _Py_NewRef(PyObject *obj)
 
 // bpo-42262 added Py_XNewRef() to Python 3.10.0a3
 #if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_XNewRef)
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-_Py_XNewRef(PyObject *obj)
+static inline PyObject* _Py_XNewRef(PyObject *obj)
 {
     Py_XINCREF(obj);
     return obj;
@@ -81,8 +83,7 @@ _Py_XNewRef(PyObject *obj)
 
 // bpo-39573 added Py_SET_REFCNT() to Python 3.9.0a4
 #if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_REFCNT)
-PYCAPI_COMPAT_STATIC_INLINE(void)
-_Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)
+static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)
 {
     ob->ob_refcnt = refcnt;
 }
@@ -93,18 +94,20 @@ _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)
 // Py_SETREF() and Py_XSETREF() were added to Python 3.5.2.
 // It is excluded from the limited C API.
 #if (PY_VERSION_HEX < 0x03050200 && !defined(Py_SETREF)) && !defined(Py_LIMITED_API)
-#define Py_SETREF(op, op2)                      \
-    do {                                        \
-        PyObject *_py_tmp = _PyObject_CAST(op); \
-        (op) = (op2);                           \
-        Py_DECREF(_py_tmp);                     \
+#define Py_SETREF(dst, src)                                     \
+    do {                                                        \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
+        PyObject *_tmp_dst = (*_tmp_dst_ptr);                   \
+        *_tmp_dst_ptr = _PyObject_CAST(src);                    \
+        Py_DECREF(_tmp_dst);                                    \
     } while (0)
 
-#define Py_XSETREF(op, op2)                     \
-    do {                                        \
-        PyObject *_py_tmp = _PyObject_CAST(op); \
-        (op) = (op2);                           \
-        Py_XDECREF(_py_tmp);                    \
+#define Py_XSETREF(dst, src)                                    \
+    do {                                                        \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
+        PyObject *_tmp_dst = (*_tmp_dst_ptr);                   \
+        *_tmp_dst_ptr = _PyObject_CAST(src);                    \
+        Py_XDECREF(_tmp_dst);                                   \
     } while (0)
 #endif
 
@@ -117,18 +120,17 @@ _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)
 #if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_IsNone)
 #  define Py_IsNone(x) Py_Is(x, Py_None)
 #endif
-#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_IsTrue)
+#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsTrue)
 #  define Py_IsTrue(x) Py_Is(x, Py_True)
 #endif
-#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_IsFalse)
+#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsFalse)
 #  define Py_IsFalse(x) Py_Is(x, Py_False)
 #endif
 
 
 // bpo-39573 added Py_SET_TYPE() to Python 3.9.0a4
 #if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE)
-PYCAPI_COMPAT_STATIC_INLINE(void)
-_Py_SET_TYPE(PyObject *ob, PyTypeObject *type)
+static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type)
 {
     ob->ob_type = type;
 }
@@ -138,8 +140,7 @@ _Py_SET_TYPE(PyObject *ob, PyTypeObject *type)
 
 // bpo-39573 added Py_SET_SIZE() to Python 3.9.0a4
 #if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_SIZE)
-PYCAPI_COMPAT_STATIC_INLINE(void)
-_Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)
+static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)
 {
     ob->ob_size = size;
 }
@@ -148,9 +149,8 @@ _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)
 
 
 // bpo-40421 added PyFrame_GetCode() to Python 3.9.0b1
-#if PY_VERSION_HEX < 0x030900B1
-PYCAPI_COMPAT_STATIC_INLINE(PyCodeObject*)
-PyFrame_GetCode(PyFrameObject *frame)
+#if PY_VERSION_HEX < 0x030900B1 || defined(PYPY_VERSION)
+static inline PyCodeObject* PyFrame_GetCode(PyFrameObject *frame)
 {
     assert(frame != _Py_NULL);
     assert(frame->f_code != _Py_NULL);
@@ -158,8 +158,7 @@ PyFrame_GetCode(PyFrameObject *frame)
 }
 #endif
 
-PYCAPI_COMPAT_STATIC_INLINE(PyCodeObject*)
-_PyFrame_GetCodeBorrow(PyFrameObject *frame)
+static inline PyCodeObject* _PyFrame_GetCodeBorrow(PyFrameObject *frame)
 {
     PyCodeObject *code = PyFrame_GetCode(frame);
     Py_DECREF(code);
@@ -169,8 +168,7 @@ _PyFrame_GetCodeBorrow(PyFrameObject *frame)
 
 // bpo-40421 added PyFrame_GetBack() to Python 3.9.0b1
 #if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyFrameObject*)
-PyFrame_GetBack(PyFrameObject *frame)
+static inline PyFrameObject* PyFrame_GetBack(PyFrameObject *frame)
 {
     assert(frame != _Py_NULL);
     return _Py_CAST(PyFrameObject*, Py_XNewRef(frame->f_back));
@@ -178,8 +176,7 @@ PyFrame_GetBack(PyFrameObject *frame)
 #endif
 
 #if !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyFrameObject*)
-_PyFrame_GetBackBorrow(PyFrameObject *frame)
+static inline PyFrameObject* _PyFrame_GetBackBorrow(PyFrameObject *frame)
 {
     PyFrameObject *back = PyFrame_GetBack(frame);
     Py_XDECREF(back);
@@ -190,8 +187,7 @@ _PyFrame_GetBackBorrow(PyFrameObject *frame)
 
 // bpo-40421 added PyFrame_GetLocals() to Python 3.11.0a7
 #if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-PyFrame_GetLocals(PyFrameObject *frame)
+static inline PyObject* PyFrame_GetLocals(PyFrameObject *frame)
 {
 #if PY_VERSION_HEX >= 0x030400B1
     if (PyFrame_FastToLocalsWithError(frame) < 0) {
@@ -207,8 +203,7 @@ PyFrame_GetLocals(PyFrameObject *frame)
 
 // bpo-40421 added PyFrame_GetGlobals() to Python 3.11.0a7
 #if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-PyFrame_GetGlobals(PyFrameObject *frame)
+static inline PyObject* PyFrame_GetGlobals(PyFrameObject *frame)
 {
     return Py_NewRef(frame->f_globals);
 }
@@ -217,8 +212,7 @@ PyFrame_GetGlobals(PyFrameObject *frame)
 
 // bpo-40421 added PyFrame_GetBuiltins() to Python 3.11.0a7
 #if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-PyFrame_GetBuiltins(PyFrameObject *frame)
+static inline PyObject* PyFrame_GetBuiltins(PyFrameObject *frame)
 {
     return Py_NewRef(frame->f_builtins);
 }
@@ -227,8 +221,7 @@ PyFrame_GetBuiltins(PyFrameObject *frame)
 
 // bpo-40421 added PyFrame_GetLasti() to Python 3.11.0b1
 #if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(int)
-PyFrame_GetLasti(PyFrameObject *frame)
+static inline int PyFrame_GetLasti(PyFrameObject *frame)
 {
 #if PY_VERSION_HEX >= 0x030A00A7
     // bpo-27129: Since Python 3.10.0a7, f_lasti is an instruction offset,
@@ -245,9 +238,63 @@ PyFrame_GetLasti(PyFrameObject *frame)
 #endif
 
 
+// gh-91248 added PyFrame_GetVar() to Python 3.12.0a2
+#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetVar(PyFrameObject *frame, PyObject *name)
+{
+    PyObject *locals, *value;
+
+    locals = PyFrame_GetLocals(frame);
+    if (locals == NULL) {
+        return NULL;
+    }
+#if PY_VERSION_HEX >= 0x03000000
+    value = PyDict_GetItemWithError(locals, name);
+#else
+    value = _PyDict_GetItemWithError(locals, name);
+#endif
+    Py_DECREF(locals);
+
+    if (value == NULL) {
+        if (PyErr_Occurred()) {
+            return NULL;
+        }
+#if PY_VERSION_HEX >= 0x03000000
+        PyErr_Format(PyExc_NameError, "variable %R does not exist", name);
+#else
+        PyErr_SetString(PyExc_NameError, "variable does not exist");
+#endif
+        return NULL;
+    }
+    return Py_NewRef(value);
+}
+#endif
+
+
+// gh-91248 added PyFrame_GetVarString() to Python 3.12.0a2
+#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)
+static inline PyObject*
+PyFrame_GetVarString(PyFrameObject *frame, const char *name)
+{
+    PyObject *name_obj, *value;
+#if PY_VERSION_HEX >= 0x03000000
+    name_obj = PyUnicode_FromString(name);
+#else
+    name_obj = PyString_FromString(name);
+#endif
+    if (name_obj == NULL) {
+        return NULL;
+    }
+    value = PyFrame_GetVar(frame, name_obj);
+    Py_DECREF(name_obj);
+    return value;
+}
+#endif
+
+
 // bpo-39947 added PyThreadState_GetInterpreter() to Python 3.9.0a5
-#if PY_VERSION_HEX < 0x030900A5
-PYCAPI_COMPAT_STATIC_INLINE(PyInterpreterState *)
+#if PY_VERSION_HEX < 0x030900A5 || (defined(PYPY_VERSION) && PY_VERSION_HEX < 0x030B0000)
+static inline PyInterpreterState *
 PyThreadState_GetInterpreter(PyThreadState *tstate)
 {
     assert(tstate != _Py_NULL);
@@ -258,8 +305,7 @@ PyThreadState_GetInterpreter(PyThreadState *tstate)
 
 // bpo-40429 added PyThreadState_GetFrame() to Python 3.9.0b1
 #if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyFrameObject*)
-PyThreadState_GetFrame(PyThreadState *tstate)
+static inline PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate)
 {
     assert(tstate != _Py_NULL);
     return _Py_CAST(PyFrameObject *, Py_XNewRef(tstate->frame));
@@ -267,7 +313,7 @@ PyThreadState_GetFrame(PyThreadState *tstate)
 #endif
 
 #if !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyFrameObject*)
+static inline PyFrameObject*
 _PyThreadState_GetFrameBorrow(PyThreadState *tstate)
 {
     PyFrameObject *frame = PyThreadState_GetFrame(tstate);
@@ -278,9 +324,8 @@ _PyThreadState_GetFrameBorrow(PyThreadState *tstate)
 
 
 // bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a5
-#if PY_VERSION_HEX < 0x030900A5
-PYCAPI_COMPAT_STATIC_INLINE(PyInterpreterState*)
-PyInterpreterState_Get(void)
+#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION)
+static inline PyInterpreterState* PyInterpreterState_Get(void)
 {
     PyThreadState *tstate;
     PyInterpreterState *interp;
@@ -300,8 +345,7 @@ PyInterpreterState_Get(void)
 
 // bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a6
 #if 0x030700A1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(uint64_t)
-PyThreadState_GetID(PyThreadState *tstate)
+static inline uint64_t PyThreadState_GetID(PyThreadState *tstate)
 {
     assert(tstate != _Py_NULL);
     return tstate->id;
@@ -310,8 +354,7 @@ PyThreadState_GetID(PyThreadState *tstate)
 
 // bpo-43760 added PyThreadState_EnterTracing() to Python 3.11.0a2
 #if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(void)
-PyThreadState_EnterTracing(PyThreadState *tstate)
+static inline void PyThreadState_EnterTracing(PyThreadState *tstate)
 {
     tstate->tracing++;
 #if PY_VERSION_HEX >= 0x030A00A1
@@ -324,8 +367,7 @@ PyThreadState_EnterTracing(PyThreadState *tstate)
 
 // bpo-43760 added PyThreadState_LeaveTracing() to Python 3.11.0a2
 #if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(void)
-PyThreadState_LeaveTracing(PyThreadState *tstate)
+static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)
 {
     int use_tracing = (tstate->c_tracefunc != _Py_NULL
                        || tstate->c_profilefunc != _Py_NULL);
@@ -340,9 +382,9 @@ PyThreadState_LeaveTracing(PyThreadState *tstate)
 
 
 // bpo-37194 added PyObject_CallNoArgs() to Python 3.9.0a1
-#if PY_VERSION_HEX < 0x030900A1
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-PyObject_CallNoArgs(PyObject *func)
+// PyObject_CallNoArgs() added to PyPy 3.9.16-v7.3.11
+#if !defined(PyObject_CallNoArgs) && PY_VERSION_HEX < 0x030900A1
+static inline PyObject* PyObject_CallNoArgs(PyObject *func)
 {
     return PyObject_CallFunctionObjArgs(func, NULL);
 }
@@ -351,9 +393,9 @@ PyObject_CallNoArgs(PyObject *func)
 
 // bpo-39245 made PyObject_CallOneArg() public (previously called
 // _PyObject_CallOneArg) in Python 3.9.0a4
-#if PY_VERSION_HEX < 0x030900A4
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-PyObject_CallOneArg(PyObject *func, PyObject *arg)
+// PyObject_CallOneArg() added to PyPy 3.9.16-v7.3.11
+#if !defined(PyObject_CallOneArg) && PY_VERSION_HEX < 0x030900A4
+static inline PyObject* PyObject_CallOneArg(PyObject *func, PyObject *arg)
 {
     return PyObject_CallFunctionObjArgs(func, arg, NULL);
 }
@@ -362,10 +404,19 @@ PyObject_CallOneArg(PyObject *func, PyObject *arg)
 
 // bpo-1635741 added PyModule_AddObjectRef() to Python 3.10.0a3
 #if PY_VERSION_HEX < 0x030A00A3
-PYCAPI_COMPAT_STATIC_INLINE(int)
+static inline int
 PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value)
 {
     int res;
+
+    if (!value && !PyErr_Occurred()) {
+        // PyModule_AddObject() raises TypeError in this case
+        PyErr_SetString(PyExc_SystemError,
+                        "PyModule_AddObjectRef() must be called "
+                        "with an exception raised if value is NULL");
+        return -1;
+    }
+
     Py_XINCREF(value);
     res = PyModule_AddObject(module, name, value);
     if (res < 0) {
@@ -378,8 +429,7 @@ PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value)
 
 // bpo-40024 added PyModule_AddType() to Python 3.9.0a5
 #if PY_VERSION_HEX < 0x030900A5
-PYCAPI_COMPAT_STATIC_INLINE(int)
-PyModule_AddType(PyObject *module, PyTypeObject *type)
+static inline int PyModule_AddType(PyObject *module, PyTypeObject *type)
 {
     const char *name, *dot;
 
@@ -403,8 +453,7 @@ PyModule_AddType(PyObject *module, PyTypeObject *type)
 // bpo-40241 added PyObject_GC_IsTracked() to Python 3.9.0a6.
 // bpo-4688 added _PyObject_GC_IS_TRACKED() to Python 2.7.0a2.
 #if PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(int)
-PyObject_GC_IsTracked(PyObject* obj)
+static inline int PyObject_GC_IsTracked(PyObject* obj)
 {
     return (PyObject_IS_GC(obj) && _PyObject_GC_IS_TRACKED(obj));
 }
@@ -413,8 +462,7 @@ PyObject_GC_IsTracked(PyObject* obj)
 // bpo-40241 added PyObject_GC_IsFinalized() to Python 3.9.0a6.
 // bpo-18112 added _PyGCHead_FINALIZED() to Python 3.4.0 final.
 #if PY_VERSION_HEX < 0x030900A6 && PY_VERSION_HEX >= 0x030400F0 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(int)
-PyObject_GC_IsFinalized(PyObject *obj)
+static inline int PyObject_GC_IsFinalized(PyObject *obj)
 {
     PyGC_Head *gc = _Py_CAST(PyGC_Head*, obj) - 1;
     return (PyObject_IS_GC(obj) && _PyGCHead_FINALIZED(gc));
@@ -424,8 +472,7 @@ PyObject_GC_IsFinalized(PyObject *obj)
 
 // bpo-39573 added Py_IS_TYPE() to Python 3.9.0a4
 #if PY_VERSION_HEX < 0x030900A4 && !defined(Py_IS_TYPE)
-PYCAPI_COMPAT_STATIC_INLINE(int)
-_Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
+static inline int _Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
     return Py_TYPE(ob) == type;
 }
 #define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST(ob), type)
@@ -437,12 +484,10 @@ _Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
 // Python 3.11a2 moved _PyFloat_Pack2() and _PyFloat_Unpack2() to the internal
 // C API: Python 3.11a2-3.11a6 versions are not supported.
 #if 0x030600B1 <= PY_VERSION_HEX && PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(int)
-PyFloat_Pack2(double x, char *p, int le)
+static inline int PyFloat_Pack2(double x, char *p, int le)
 { return _PyFloat_Pack2(x, (unsigned char*)p, le); }
 
-PYCAPI_COMPAT_STATIC_INLINE(double)
-PyFloat_Unpack2(const char *p, int le)
+static inline double PyFloat_Unpack2(const char *p, int le)
 { return _PyFloat_Unpack2((const unsigned char *)p, le); }
 #endif
 
@@ -453,34 +498,54 @@ PyFloat_Unpack2(const char *p, int le)
 // and _PyFloat_Unpack8() to the internal C API: Python 3.11a2-3.11a6 versions
 // are not supported.
 #if PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(int)
-PyFloat_Pack4(double x, char *p, int le)
+static inline int PyFloat_Pack4(double x, char *p, int le)
 { return _PyFloat_Pack4(x, (unsigned char*)p, le); }
 
-PYCAPI_COMPAT_STATIC_INLINE(int)
-PyFloat_Pack8(double x, char *p, int le)
+static inline int PyFloat_Pack8(double x, char *p, int le)
 { return _PyFloat_Pack8(x, (unsigned char*)p, le); }
 
-PYCAPI_COMPAT_STATIC_INLINE(double)
-PyFloat_Unpack4(const char *p, int le)
+static inline double PyFloat_Unpack4(const char *p, int le)
 { return _PyFloat_Unpack4((const unsigned char *)p, le); }
 
-PYCAPI_COMPAT_STATIC_INLINE(double)
-PyFloat_Unpack8(const char *p, int le)
+static inline double PyFloat_Unpack8(const char *p, int le)
 { return _PyFloat_Unpack8((const unsigned char *)p, le); }
 #endif
 
 
 // gh-92154 added PyCode_GetCode() to Python 3.11.0b1
 #if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)
-PYCAPI_COMPAT_STATIC_INLINE(PyObject*)
-PyCode_GetCode(PyCodeObject *code)
+static inline PyObject* PyCode_GetCode(PyCodeObject *code)
 {
     return Py_NewRef(code->co_code);
 }
 #endif
 
 
+// gh-95008 added PyCode_GetVarnames() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetVarnames(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_varnames);
+}
+#endif
+
+// gh-95008 added PyCode_GetFreevars() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetFreevars(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_freevars);
+}
+#endif
+
+// gh-95008 added PyCode_GetCellvars() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetCellvars(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_cellvars);
+}
+#endif
+
+
 // Py_UNUSED() was added to Python 3.4.0b2.
 #if PY_VERSION_HEX < 0x030400B2 && !defined(Py_UNUSED)
 #  if defined(__GNUC__) || defined(__clang__)
@@ -491,6 +556,1649 @@ PyCode_GetCode(PyCodeObject *code)
 #endif
 
 
+// gh-105922 added PyImport_AddModuleRef() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A0
+static inline PyObject* PyImport_AddModuleRef(const char *name)
+{
+    return Py_XNewRef(PyImport_AddModule(name));
+}
+#endif
+
+
+// gh-105927 added PyWeakref_GetRef() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D0000
+static inline int PyWeakref_GetRef(PyObject *ref, PyObject **pobj)
+{
+    PyObject *obj;
+    if (ref != NULL && !PyWeakref_Check(ref)) {
+        *pobj = NULL;
+        PyErr_SetString(PyExc_TypeError, "expected a weakref");
+        return -1;
+    }
+    obj = PyWeakref_GetObject(ref);
+    if (obj == NULL) {
+        // SystemError if ref is NULL
+        *pobj = NULL;
+        return -1;
+    }
+    if (obj == Py_None) {
+        *pobj = NULL;
+        return 0;
+    }
+    *pobj = Py_NewRef(obj);
+    return 1;
+}
+#endif
+
+
+// bpo-36974 added PY_VECTORCALL_ARGUMENTS_OFFSET to Python 3.8b1
+#ifndef PY_VECTORCALL_ARGUMENTS_OFFSET
+#  define PY_VECTORCALL_ARGUMENTS_OFFSET (_Py_CAST(size_t, 1) << (8 * sizeof(size_t) - 1))
+#endif
+
+// bpo-36974 added PyVectorcall_NARGS() to Python 3.8b1
+#if PY_VERSION_HEX < 0x030800B1
+static inline Py_ssize_t PyVectorcall_NARGS(size_t n)
+{
+    return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET;
+}
+#endif
+
+
+// gh-105922 added PyObject_Vectorcall() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4
+static inline PyObject*
+PyObject_Vectorcall(PyObject *callable, PyObject *const *args,
+                     size_t nargsf, PyObject *kwnames)
+{
+#if PY_VERSION_HEX >= 0x030800B1 && !defined(PYPY_VERSION)
+    // bpo-36974 added _PyObject_Vectorcall() to Python 3.8.0b1
+    return _PyObject_Vectorcall(callable, args, nargsf, kwnames);
+#else
+    PyObject *posargs = NULL, *kwargs = NULL;
+    PyObject *res;
+    Py_ssize_t nposargs, nkwargs, i;
+
+    if (nargsf != 0 && args == NULL) {
+        PyErr_BadInternalCall();
+        goto error;
+    }
+    if (kwnames != NULL && !PyTuple_Check(kwnames)) {
+        PyErr_BadInternalCall();
+        goto error;
+    }
+
+    nposargs = (Py_ssize_t)PyVectorcall_NARGS(nargsf);
+    if (kwnames) {
+        nkwargs = PyTuple_GET_SIZE(kwnames);
+    }
+    else {
+        nkwargs = 0;
+    }
+
+    posargs = PyTuple_New(nposargs);
+    if (posargs == NULL) {
+        goto error;
+    }
+    if (nposargs) {
+        for (i=0; i < nposargs; i++) {
+            PyTuple_SET_ITEM(posargs, i, Py_NewRef(*args));
+            args++;
+        }
+    }
+
+    if (nkwargs) {
+        kwargs = PyDict_New();
+        if (kwargs == NULL) {
+            goto error;
+        }
+
+        for (i = 0; i < nkwargs; i++) {
+            PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+            PyObject *value = *args;
+            args++;
+            if (PyDict_SetItem(kwargs, key, value) < 0) {
+                goto error;
+            }
+        }
+    }
+    else {
+        kwargs = NULL;
+    }
+
+    res = PyObject_Call(callable, posargs, kwargs);
+    Py_DECREF(posargs);
+    Py_XDECREF(kwargs);
+    return res;
+
+error:
+    Py_DECREF(posargs);
+    Py_XDECREF(kwargs);
+    return NULL;
+#endif
+}
+#endif
+
+
+// gh-106521 added PyObject_GetOptionalAttr() and
+// PyObject_GetOptionalAttrString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_GetOptionalAttr(PyObject *obj, PyObject *attr_name, PyObject **result)
+{
+    // bpo-32571 added _PyObject_LookupAttr() to Python 3.7.0b1
+#if PY_VERSION_HEX >= 0x030700B1 && !defined(PYPY_VERSION)
+    return _PyObject_LookupAttr(obj, attr_name, result);
+#else
+    *result = PyObject_GetAttr(obj, attr_name);
+    if (*result != NULL) {
+        return 1;
+    }
+    if (!PyErr_Occurred()) {
+        return 0;
+    }
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        return 0;
+    }
+    return -1;
+#endif
+}
+
+static inline int
+PyObject_GetOptionalAttrString(PyObject *obj, const char *attr_name, PyObject **result)
+{
+    PyObject *name_obj;
+    int rc;
+#if PY_VERSION_HEX >= 0x03000000
+    name_obj = PyUnicode_FromString(attr_name);
+#else
+    name_obj = PyString_FromString(attr_name);
+#endif
+    if (name_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    rc = PyObject_GetOptionalAttr(obj, name_obj, result);
+    Py_DECREF(name_obj);
+    return rc;
+}
+#endif
+
+
+// gh-106307 added PyObject_GetOptionalAttr() and
+// PyMapping_GetOptionalItemString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result)
+{
+    *result = PyObject_GetItem(obj, key);
+    if (*result) {
+        return 1;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_KeyError)) {
+        return -1;
+    }
+    PyErr_Clear();
+    return 0;
+}
+
+static inline int
+PyMapping_GetOptionalItemString(PyObject *obj, const char *key, PyObject **result)
+{
+    PyObject *key_obj;
+    int rc;
+#if PY_VERSION_HEX >= 0x03000000
+    key_obj = PyUnicode_FromString(key);
+#else
+    key_obj = PyString_FromString(key);
+#endif
+    if (key_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    rc = PyMapping_GetOptionalItem(obj, key_obj, result);
+    Py_DECREF(key_obj);
+    return rc;
+}
+#endif
+
+// gh-108511 added PyMapping_HasKeyWithError() and
+// PyMapping_HasKeyStringWithError() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyMapping_HasKeyWithError(PyObject *obj, PyObject *key)
+{
+    PyObject *res;
+    int rc = PyMapping_GetOptionalItem(obj, key, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+
+static inline int
+PyMapping_HasKeyStringWithError(PyObject *obj, const char *key)
+{
+    PyObject *res;
+    int rc = PyMapping_GetOptionalItemString(obj, key, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+#endif
+
+
+// gh-108511 added PyObject_HasAttrWithError() and
+// PyObject_HasAttrStringWithError() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_HasAttrWithError(PyObject *obj, PyObject *attr)
+{
+    PyObject *res;
+    int rc = PyObject_GetOptionalAttr(obj, attr, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+
+static inline int
+PyObject_HasAttrStringWithError(PyObject *obj, const char *attr)
+{
+    PyObject *res;
+    int rc = PyObject_GetOptionalAttrString(obj, attr, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+#endif
+
+
+// gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef()
+// to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *item = PyDict_GetItemWithError(mp, key);
+#else
+    PyObject *item = _PyDict_GetItemWithError(mp, key);
+#endif
+    if (item != NULL) {
+        *result = Py_NewRef(item);
+        return 1;  // found
+    }
+    if (!PyErr_Occurred()) {
+        *result = NULL;
+        return 0;  // not found
+    }
+    *result = NULL;
+    return -1;
+}
+
+static inline int
+PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result)
+{
+    int res;
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *key_obj = PyUnicode_FromString(key);
+#else
+    PyObject *key_obj = PyString_FromString(key);
+#endif
+    if (key_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    res = PyDict_GetItemRef(mp, key_obj, result);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+// gh-106307 added PyModule_Add() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyModule_Add(PyObject *mod, const char *name, PyObject *value)
+{
+    int res = PyModule_AddObjectRef(mod, name, value);
+    Py_XDECREF(value);
+    return res;
+}
+#endif
+
+
+// gh-108014 added Py_IsFinalizing() to Python 3.13.0a1
+// bpo-1856 added _Py_Finalizing to Python 3.2.1b1.
+// _Py_IsFinalizing() was added to PyPy 7.3.0.
+#if (0x030201B1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030D00A1) \
+        && (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x7030000)
+static inline int Py_IsFinalizing(void)
+{
+#if PY_VERSION_HEX >= 0x030700A1
+    // _Py_IsFinalizing() was added to Python 3.7.0a1.
+    return _Py_IsFinalizing();
+#else
+    return (_Py_Finalizing != NULL);
+#endif
+}
+#endif
+
+
+// gh-108323 added PyDict_ContainsString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int PyDict_ContainsString(PyObject *op, const char *key)
+{
+    PyObject *key_obj = PyUnicode_FromString(key);
+    if (key_obj == NULL) {
+        return -1;
+    }
+    int res = PyDict_Contains(op, key_obj);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+// gh-108445 added PyLong_AsInt() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int PyLong_AsInt(PyObject *obj)
+{
+#ifdef PYPY_VERSION
+    long value = PyLong_AsLong(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    if (value < (long)INT_MIN || (long)INT_MAX < value) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "Python int too large to convert to C int");
+        return -1;
+    }
+    return (int)value;
+#else
+    return _PyLong_AsInt(obj);
+#endif
+}
+#endif
+
+
+// gh-107073 added PyObject_VisitManagedDict() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg)
+{
+    PyObject **dict = _PyObject_GetDictPtr(obj);
+    if (dict == NULL || *dict == NULL) {
+        return -1;
+    }
+    Py_VISIT(*dict);
+    return 0;
+}
+
+static inline void
+PyObject_ClearManagedDict(PyObject *obj)
+{
+    PyObject **dict = _PyObject_GetDictPtr(obj);
+    if (dict == NULL || *dict == NULL) {
+        return;
+    }
+    Py_CLEAR(*dict);
+}
+#endif
+
+// gh-108867 added PyThreadState_GetUnchecked() to Python 3.13.0a1
+// Python 3.5.2 added _PyThreadState_UncheckedGet().
+#if PY_VERSION_HEX >= 0x03050200 && PY_VERSION_HEX < 0x030D00A1
+static inline PyThreadState*
+PyThreadState_GetUnchecked(void)
+{
+    return _PyThreadState_UncheckedGet();
+}
+#endif
+
+// gh-110289 added PyUnicode_EqualToUTF8() and PyUnicode_EqualToUTF8AndSize()
+// to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyUnicode_EqualToUTF8AndSize(PyObject *unicode, const char *str, Py_ssize_t str_len)
+{
+    Py_ssize_t len;
+    const void *utf8;
+    PyObject *exc_type, *exc_value, *exc_tb;
+    int res;
+
+    // API cannot report errors so save/restore the exception
+    PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
+
+    // Python 3.3.0a1 added PyUnicode_AsUTF8AndSize()
+#if PY_VERSION_HEX >= 0x030300A1
+    if (PyUnicode_IS_ASCII(unicode)) {
+        utf8 = PyUnicode_DATA(unicode);
+        len = PyUnicode_GET_LENGTH(unicode);
+    }
+    else {
+        utf8 = PyUnicode_AsUTF8AndSize(unicode, &len);
+        if (utf8 == NULL) {
+            // Memory allocation failure. The API cannot report error,
+            // so ignore the exception and return 0.
+            res = 0;
+            goto done;
+        }
+    }
+
+    if (len != str_len) {
+        res = 0;
+        goto done;
+    }
+    res = (memcmp(utf8, str, (size_t)len) == 0);
+#else
+    PyObject *bytes = PyUnicode_AsUTF8String(unicode);
+    if (bytes == NULL) {
+        // Memory allocation failure. The API cannot report error,
+        // so ignore the exception and return 0.
+        res = 0;
+        goto done;
+    }
+
+#if PY_VERSION_HEX >= 0x03000000
+    len = PyBytes_GET_SIZE(bytes);
+    utf8 = PyBytes_AS_STRING(bytes);
+#else
+    len = PyString_GET_SIZE(bytes);
+    utf8 = PyString_AS_STRING(bytes);
+#endif
+    if (len != str_len) {
+        Py_DECREF(bytes);
+        res = 0;
+        goto done;
+    }
+
+    res = (memcmp(utf8, str, (size_t)len) == 0);
+    Py_DECREF(bytes);
+#endif
+
+done:
+    PyErr_Restore(exc_type, exc_value, exc_tb);
+    return res;
+}
+
+static inline int
+PyUnicode_EqualToUTF8(PyObject *unicode, const char *str)
+{
+    return PyUnicode_EqualToUTF8AndSize(unicode, str, (Py_ssize_t)strlen(str));
+}
+#endif
+
+
+// gh-111138 added PyList_Extend() and PyList_Clear() to Python 3.13.0a2
+#if PY_VERSION_HEX < 0x030D00A2
+static inline int
+PyList_Extend(PyObject *list, PyObject *iterable)
+{
+    return PyList_SetSlice(list, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, iterable);
+}
+
+static inline int
+PyList_Clear(PyObject *list)
+{
+    return PyList_SetSlice(list, 0, PY_SSIZE_T_MAX, NULL);
+}
+#endif
+
+// gh-111262 added PyDict_Pop() and PyDict_PopString() to Python 3.13.0a2
+#if PY_VERSION_HEX < 0x030D00A2
+static inline int
+PyDict_Pop(PyObject *dict, PyObject *key, PyObject **result)
+{
+    PyObject *value;
+
+    if (!PyDict_Check(dict)) {
+        PyErr_BadInternalCall();
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+
+    // bpo-16991 added _PyDict_Pop() to Python 3.5.0b2.
+    // Python 3.6.0b3 changed _PyDict_Pop() first argument type to PyObject*.
+    // Python 3.13.0a1 removed _PyDict_Pop().
+#if defined(PYPY_VERSION) || PY_VERSION_HEX < 0x030500b2 || PY_VERSION_HEX >= 0x030D0000
+    value = PyObject_CallMethod(dict, "pop", "O", key);
+#elif PY_VERSION_HEX < 0x030600b3
+    value = _PyDict_Pop(_Py_CAST(PyDictObject*, dict), key, NULL);
+#else
+    value = _PyDict_Pop(dict, key, NULL);
+#endif
+    if (value == NULL) {
+        if (result) {
+            *result = NULL;
+        }
+        if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_KeyError)) {
+            return -1;
+        }
+        PyErr_Clear();
+        return 0;
+    }
+    if (result) {
+        *result = value;
+    }
+    else {
+        Py_DECREF(value);
+    }
+    return 1;
+}
+
+static inline int
+PyDict_PopString(PyObject *dict, const char *key, PyObject **result)
+{
+    PyObject *key_obj = PyUnicode_FromString(key);
+    if (key_obj == NULL) {
+        if (result != NULL) {
+            *result = NULL;
+        }
+        return -1;
+    }
+
+    int res = PyDict_Pop(dict, key_obj, result);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030200A4
+// Python 3.2.0a4 added Py_hash_t type
+typedef Py_ssize_t Py_hash_t;
+#endif
+
+
+// gh-111545 added Py_HashPointer() to Python 3.13.0a3
+#if PY_VERSION_HEX < 0x030D00A3
+static inline Py_hash_t Py_HashPointer(const void *ptr)
+{
+#if PY_VERSION_HEX >= 0x030900A4 && !defined(PYPY_VERSION)
+    return _Py_HashPointer(ptr);
+#else
+    return _Py_HashPointer(_Py_CAST(void*, ptr));
+#endif
+}
+#endif
+
+
+// Python 3.13a4 added a PyTime API.
+// Use the private API added to Python 3.5.
+#if PY_VERSION_HEX < 0x030D00A4 && PY_VERSION_HEX  >= 0x03050000
+typedef _PyTime_t PyTime_t;
+#define PyTime_MIN _PyTime_MIN
+#define PyTime_MAX _PyTime_MAX
+
+static inline double PyTime_AsSecondsDouble(PyTime_t t)
+{ return _PyTime_AsSecondsDouble(t); }
+
+static inline int PyTime_Monotonic(PyTime_t *result)
+{ return _PyTime_GetMonotonicClockWithInfo(result, NULL); }
+
+static inline int PyTime_Time(PyTime_t *result)
+{ return _PyTime_GetSystemClockWithInfo(result, NULL); }
+
+static inline int PyTime_PerfCounter(PyTime_t *result)
+{
+#if PY_VERSION_HEX >= 0x03070000 && !defined(PYPY_VERSION)
+    return _PyTime_GetPerfCounterWithInfo(result, NULL);
+#elif PY_VERSION_HEX >= 0x03070000
+    // Call time.perf_counter_ns() and convert Python int object to PyTime_t.
+    // Cache time.perf_counter_ns() function for best performance.
+    static PyObject *func = NULL;
+    if (func == NULL) {
+        PyObject *mod = PyImport_ImportModule("time");
+        if (mod == NULL) {
+            return -1;
+        }
+
+        func = PyObject_GetAttrString(mod, "perf_counter_ns");
+        Py_DECREF(mod);
+        if (func == NULL) {
+            return -1;
+        }
+    }
+
+    PyObject *res = PyObject_CallNoArgs(func);
+    if (res == NULL) {
+        return -1;
+    }
+    long long value = PyLong_AsLongLong(res);
+    Py_DECREF(res);
+
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+
+    Py_BUILD_ASSERT(sizeof(value) >= sizeof(PyTime_t));
+    *result = (PyTime_t)value;
+    return 0;
+#else
+    // Call time.perf_counter() and convert C double to PyTime_t.
+    // Cache time.perf_counter() function for best performance.
+    static PyObject *func = NULL;
+    if (func == NULL) {
+        PyObject *mod = PyImport_ImportModule("time");
+        if (mod == NULL) {
+            return -1;
+        }
+
+        func = PyObject_GetAttrString(mod, "perf_counter");
+        Py_DECREF(mod);
+        if (func == NULL) {
+            return -1;
+        }
+    }
+
+    PyObject *res = PyObject_CallNoArgs(func);
+    if (res == NULL) {
+        return -1;
+    }
+    double d = PyFloat_AsDouble(res);
+    Py_DECREF(res);
+
+    if (d == -1.0 && PyErr_Occurred()) {
+        return -1;
+    }
+
+    // Avoid floor() to avoid having to link to libm
+    *result = (PyTime_t)(d * 1e9);
+    return 0;
+#endif
+}
+
+#endif
+
+// gh-111389 added hash constants to Python 3.13.0a5. These constants were
+// added first as private macros to Python 3.4.0b1 and PyPy 7.3.8.
+#if (!defined(PyHASH_BITS) \
+     && ((!defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x030400B1) \
+         || (defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x03070000 \
+             && PYPY_VERSION_NUM >= 0x07030800)))
+#  define PyHASH_BITS _PyHASH_BITS
+#  define PyHASH_MODULUS _PyHASH_MODULUS
+#  define PyHASH_INF _PyHASH_INF
+#  define PyHASH_IMAG _PyHASH_IMAG
+#endif
+
+
+// gh-111545 added Py_GetConstant() and Py_GetConstantBorrowed()
+// to Python 3.13.0a6
+#if PY_VERSION_HEX < 0x030D00A6 && !defined(Py_CONSTANT_NONE)
+
+#define Py_CONSTANT_NONE 0
+#define Py_CONSTANT_FALSE 1
+#define Py_CONSTANT_TRUE 2
+#define Py_CONSTANT_ELLIPSIS 3
+#define Py_CONSTANT_NOT_IMPLEMENTED 4
+#define Py_CONSTANT_ZERO 5
+#define Py_CONSTANT_ONE 6
+#define Py_CONSTANT_EMPTY_STR 7
+#define Py_CONSTANT_EMPTY_BYTES 8
+#define Py_CONSTANT_EMPTY_TUPLE 9
+
+static inline PyObject* Py_GetConstant(unsigned int constant_id)
+{
+    static PyObject* constants[Py_CONSTANT_EMPTY_TUPLE + 1] = {NULL};
+
+    if (constants[Py_CONSTANT_NONE] == NULL) {
+        constants[Py_CONSTANT_NONE] = Py_None;
+        constants[Py_CONSTANT_FALSE] = Py_False;
+        constants[Py_CONSTANT_TRUE] = Py_True;
+        constants[Py_CONSTANT_ELLIPSIS] = Py_Ellipsis;
+        constants[Py_CONSTANT_NOT_IMPLEMENTED] = Py_NotImplemented;
+
+        constants[Py_CONSTANT_ZERO] = PyLong_FromLong(0);
+        if (constants[Py_CONSTANT_ZERO] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_ONE] = PyLong_FromLong(1);
+        if (constants[Py_CONSTANT_ONE] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_STR] = PyUnicode_FromStringAndSize("", 0);
+        if (constants[Py_CONSTANT_EMPTY_STR] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_BYTES] = PyBytes_FromStringAndSize("", 0);
+        if (constants[Py_CONSTANT_EMPTY_BYTES] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_TUPLE] = PyTuple_New(0);
+        if (constants[Py_CONSTANT_EMPTY_TUPLE] == NULL) {
+            goto fatal_error;
+        }
+        // goto dance to avoid compiler warnings about Py_FatalError()
+        goto init_done;
+
+fatal_error:
+        // This case should never happen
+        Py_FatalError("Py_GetConstant() failed to get constants");
+    }
+
+init_done:
+    if (constant_id <= Py_CONSTANT_EMPTY_TUPLE) {
+        return Py_NewRef(constants[constant_id]);
+    }
+    else {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+}
+
+static inline PyObject* Py_GetConstantBorrowed(unsigned int constant_id)
+{
+    PyObject *obj = Py_GetConstant(constant_id);
+    Py_XDECREF(obj);
+    return obj;
+}
+#endif
+
+
+// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4
+#if PY_VERSION_HEX < 0x030D00A4
+static inline PyObject *
+PyList_GetItemRef(PyObject *op, Py_ssize_t index)
+{
+    PyObject *item = PyList_GetItem(op, index);
+    Py_XINCREF(item);
+    return item;
+}
+#endif
+
+
+// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4
+#if PY_VERSION_HEX < 0x030D00A4
+static inline int
+PyDict_SetDefaultRef(PyObject *d, PyObject *key, PyObject *default_value,
+                     PyObject **result)
+{
+    PyObject *value;
+    if (PyDict_GetItemRef(d, key, &value) < 0) {
+        // get error
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+    if (value != NULL) {
+        // present
+        if (result) {
+            *result = value;
+        }
+        else {
+            Py_DECREF(value);
+        }
+        return 1;
+    }
+
+    // missing: set the item
+    if (PyDict_SetItem(d, key, default_value) < 0) {
+        // set error
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+    if (result) {
+        *result = Py_NewRef(default_value);
+    }
+    return 0;
+}
+#endif
+
+#if PY_VERSION_HEX < 0x030D00B3
+#  define Py_BEGIN_CRITICAL_SECTION(op) {
+#  define Py_END_CRITICAL_SECTION() }
+#  define Py_BEGIN_CRITICAL_SECTION2(a, b) {
+#  define Py_END_CRITICAL_SECTION2() }
+#endif
+
+#if PY_VERSION_HEX < 0x030E0000 && PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION)
+typedef struct PyUnicodeWriter PyUnicodeWriter;
+
+static inline void PyUnicodeWriter_Discard(PyUnicodeWriter *writer)
+{
+    _PyUnicodeWriter_Dealloc((_PyUnicodeWriter*)writer);
+    PyMem_Free(writer);
+}
+
+static inline PyUnicodeWriter* PyUnicodeWriter_Create(Py_ssize_t length)
+{
+    if (length < 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "length must be positive");
+        return NULL;
+    }
+
+    const size_t size = sizeof(_PyUnicodeWriter);
+    PyUnicodeWriter *pub_writer = (PyUnicodeWriter *)PyMem_Malloc(size);
+    if (pub_writer == _Py_NULL) {
+        PyErr_NoMemory();
+        return _Py_NULL;
+    }
+    _PyUnicodeWriter *writer = (_PyUnicodeWriter *)pub_writer;
+
+    _PyUnicodeWriter_Init(writer);
+    if (_PyUnicodeWriter_Prepare(writer, length, 127) < 0) {
+        PyUnicodeWriter_Discard(pub_writer);
+        return NULL;
+    }
+    writer->overallocate = 1;
+    return pub_writer;
+}
+
+static inline PyObject* PyUnicodeWriter_Finish(PyUnicodeWriter *writer)
+{
+    PyObject *str = _PyUnicodeWriter_Finish((_PyUnicodeWriter*)writer);
+    assert(((_PyUnicodeWriter*)writer)->buffer == NULL);
+    PyMem_Free(writer);
+    return str;
+}
+
+static inline int
+PyUnicodeWriter_WriteChar(PyUnicodeWriter *writer, Py_UCS4 ch)
+{
+    if (ch > 0x10ffff) {
+        PyErr_SetString(PyExc_ValueError,
+                        "character must be in range(0x110000)");
+        return -1;
+    }
+
+    return _PyUnicodeWriter_WriteChar((_PyUnicodeWriter*)writer, ch);
+}
+
+static inline int
+PyUnicodeWriter_WriteStr(PyUnicodeWriter *writer, PyObject *obj)
+{
+    PyObject *str = PyObject_Str(obj);
+    if (str == NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteRepr(PyUnicodeWriter *writer, PyObject *obj)
+{
+    PyObject *str = PyObject_Repr(obj);
+    if (str == NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteUTF8(PyUnicodeWriter *writer,
+                          const char *str, Py_ssize_t size)
+{
+    if (size < 0) {
+        size = (Py_ssize_t)strlen(str);
+    }
+
+    PyObject *str_obj = PyUnicode_FromStringAndSize(str, size);
+    if (str_obj == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj);
+    Py_DECREF(str_obj);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteWideChar(PyUnicodeWriter *writer,
+                              const wchar_t *str, Py_ssize_t size)
+{
+    if (size < 0) {
+        size = (Py_ssize_t)wcslen(str);
+    }
+
+    PyObject *str_obj = PyUnicode_FromWideChar(str, size);
+    if (str_obj == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj);
+    Py_DECREF(str_obj);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteSubstring(PyUnicodeWriter *writer, PyObject *str,
+                               Py_ssize_t start, Py_ssize_t end)
+{
+    if (!PyUnicode_Check(str)) {
+        PyErr_Format(PyExc_TypeError, "expect str, not %T", str);
+        return -1;
+    }
+    if (start < 0 || start > end) {
+        PyErr_Format(PyExc_ValueError, "invalid start argument");
+        return -1;
+    }
+    if (end > PyUnicode_GET_LENGTH(str)) {
+        PyErr_Format(PyExc_ValueError, "invalid end argument");
+        return -1;
+    }
+
+    return _PyUnicodeWriter_WriteSubstring((_PyUnicodeWriter*)writer, str,
+                                           start, end);
+}
+
+static inline int
+PyUnicodeWriter_Format(PyUnicodeWriter *writer, const char *format, ...)
+{
+    va_list vargs;
+    va_start(vargs, format);
+    PyObject *str = PyUnicode_FromFormatV(format, vargs);
+    va_end(vargs);
+    if (str == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+#endif  // PY_VERSION_HEX < 0x030E0000
+
+// gh-116560 added PyLong_GetSign() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyLong_GetSign(PyObject *obj, int *sign)
+{
+    if (!PyLong_Check(obj)) {
+        PyErr_Format(PyExc_TypeError, "expect int, got %s", Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+
+    *sign = _PyLong_Sign(obj);
+    return 0;
+}
+#endif
+
+// gh-126061 added PyLong_IsPositive/Negative/Zero() to Python in 3.14.0a2
+#if PY_VERSION_HEX < 0x030E00A2
+static inline int PyLong_IsPositive(PyObject *obj)
+{
+    if (!PyLong_Check(obj)) {
+        PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+    return _PyLong_Sign(obj) == 1;
+}
+
+static inline int PyLong_IsNegative(PyObject *obj)
+{
+    if (!PyLong_Check(obj)) {
+        PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+    return _PyLong_Sign(obj) == -1;
+}
+
+static inline int PyLong_IsZero(PyObject *obj)
+{
+    if (!PyLong_Check(obj)) {
+        PyErr_Format(PyExc_TypeError, "expected int, got %s", Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+    return _PyLong_Sign(obj) == 0;
+}
+#endif
+
+
+// gh-124502 added PyUnicode_Equal() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyUnicode_Equal(PyObject *str1, PyObject *str2)
+{
+    if (!PyUnicode_Check(str1)) {
+        PyErr_Format(PyExc_TypeError, "first argument must be str, not %s",
+                     Py_TYPE(str1)->tp_name);
+        return -1;
+    }
+    if (!PyUnicode_Check(str2)) {
+        PyErr_Format(PyExc_TypeError, "second argument must be str, not %s",
+                     Py_TYPE(str2)->tp_name);
+        return -1;
+    }
+
+#if PY_VERSION_HEX >= 0x030d0000 && !defined(PYPY_VERSION)
+    PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *str1, PyObject *str2);
+
+    return _PyUnicode_Equal(str1, str2);
+#elif PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION)
+    return _PyUnicode_EQ(str1, str2);
+#elif PY_VERSION_HEX >= 0x03090000 && defined(PYPY_VERSION)
+    return _PyUnicode_EQ(str1, str2);
+#else
+    return (PyUnicode_Compare(str1, str2) == 0);
+#endif
+}
+#endif
+
+
+// gh-121645 added PyBytes_Join() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline PyObject* PyBytes_Join(PyObject *sep, PyObject *iterable)
+{
+    return _PyBytes_Join(sep, iterable);
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline Py_hash_t Py_HashBuffer(const void *ptr, Py_ssize_t len)
+{
+#if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
+    PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void *src, Py_ssize_t len);
+
+    return _Py_HashBytes(ptr, len);
+#else
+    Py_hash_t hash;
+    PyObject *bytes = PyBytes_FromStringAndSize((const char*)ptr, len);
+    if (bytes == NULL) {
+        return -1;
+    }
+    hash = PyObject_Hash(bytes);
+    Py_DECREF(bytes);
+    return hash;
+#endif
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyIter_NextItem(PyObject *iter, PyObject **item)
+{
+    iternextfunc tp_iternext;
+
+    assert(iter != NULL);
+    assert(item != NULL);
+
+    tp_iternext = Py_TYPE(iter)->tp_iternext;
+    if (tp_iternext == NULL) {
+        *item = NULL;
+        PyErr_Format(PyExc_TypeError, "expected an iterator, got '%s'",
+                     Py_TYPE(iter)->tp_name);
+        return -1;
+    }
+
+    if ((*item = tp_iternext(iter))) {
+        return 1;
+    }
+    if (!PyErr_Occurred()) {
+        return 0;
+    }
+    if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+        PyErr_Clear();
+        return 0;
+    }
+    return -1;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline PyObject* PyLong_FromInt32(int32_t value)
+{
+    Py_BUILD_ASSERT(sizeof(long) >= 4);
+    return PyLong_FromLong(value);
+}
+
+static inline PyObject* PyLong_FromInt64(int64_t value)
+{
+    Py_BUILD_ASSERT(sizeof(long long) >= 8);
+    return PyLong_FromLongLong(value);
+}
+
+static inline PyObject* PyLong_FromUInt32(uint32_t value)
+{
+    Py_BUILD_ASSERT(sizeof(unsigned long) >= 4);
+    return PyLong_FromUnsignedLong(value);
+}
+
+static inline PyObject* PyLong_FromUInt64(uint64_t value)
+{
+    Py_BUILD_ASSERT(sizeof(unsigned long long) >= 8);
+    return PyLong_FromUnsignedLongLong(value);
+}
+
+static inline int PyLong_AsInt32(PyObject *obj, int32_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(int) == 4);
+    int value = PyLong_AsInt(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (int32_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsInt64(PyObject *obj, int64_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long long) == 8);
+    long long value = PyLong_AsLongLong(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (int64_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsUInt32(PyObject *obj, uint32_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long) >= 4);
+    unsigned long value = PyLong_AsUnsignedLong(obj);
+    if (value == (unsigned long)-1 && PyErr_Occurred()) {
+        return -1;
+    }
+#if SIZEOF_LONG > 4
+    if ((unsigned long)UINT32_MAX < value) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "Python int too large to convert to C uint32_t");
+        return -1;
+    }
+#endif
+    *pvalue = (uint32_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsUInt64(PyObject *obj, uint64_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long long) == 8);
+    unsigned long long value = PyLong_AsUnsignedLongLong(obj);
+    if (value == (unsigned long long)-1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (uint64_t)value;
+    return 0;
+}
+#endif
+
+
+// gh-102471 added import and export API for integers to 3.14.0a2.
+#if PY_VERSION_HEX < 0x030E00A2 && PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
+// Helpers to access PyLongObject internals.
+static inline void
+_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size)
+{
+#if PY_VERSION_HEX >= 0x030C0000
+    op->long_value.lv_tag = (uintptr_t)(1 - sign) | ((uintptr_t)(size) << 3);
+#elif PY_VERSION_HEX >= 0x030900A4
+    Py_SET_SIZE(op, sign * size);
+#else
+    Py_SIZE(op) = sign * size;
+#endif
+}
+
+static inline Py_ssize_t
+_PyLong_DigitCount(const PyLongObject *op)
+{
+#if PY_VERSION_HEX >= 0x030C0000
+    return (Py_ssize_t)(op->long_value.lv_tag >> 3);
+#else
+    return _PyLong_Sign((PyObject*)op) < 0 ? -Py_SIZE(op) : Py_SIZE(op);
+#endif
+}
+
+static inline digit*
+_PyLong_GetDigits(const PyLongObject *op)
+{
+#if PY_VERSION_HEX >= 0x030C0000
+    return (digit*)(op->long_value.ob_digit);
+#else
+    return (digit*)(op->ob_digit);
+#endif
+}
+
+typedef struct PyLongLayout {
+    uint8_t bits_per_digit;
+    uint8_t digit_size;
+    int8_t digits_order;
+    int8_t digit_endianness;
+} PyLongLayout;
+
+typedef struct PyLongExport {
+    int64_t value;
+    uint8_t negative;
+    Py_ssize_t ndigits;
+    const void *digits;
+    Py_uintptr_t _reserved;
+} PyLongExport;
+
+typedef struct PyLongWriter PyLongWriter;
+
+static inline const PyLongLayout*
+PyLong_GetNativeLayout(void)
+{
+    static const PyLongLayout PyLong_LAYOUT = {
+        PyLong_SHIFT,
+        sizeof(digit),
+        -1,  // least significant first
+        PY_LITTLE_ENDIAN ? -1 : 1,
+    };
+
+    return &PyLong_LAYOUT;
+}
+
+static inline int
+PyLong_Export(PyObject *obj, PyLongExport *export_long)
+{
+    if (!PyLong_Check(obj)) {
+        memset(export_long, 0, sizeof(*export_long));
+        PyErr_Format(PyExc_TypeError, "expected int, got %s",
+                     Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+
+    // Fast-path: try to convert to a int64_t
+    PyLongObject *self = (PyLongObject*)obj;
+    int overflow;
+#if SIZEOF_LONG == 8
+    long value = PyLong_AsLongAndOverflow(obj, &overflow);
+#else
+    // Windows has 32-bit long, so use 64-bit long long instead
+    long long value = PyLong_AsLongLongAndOverflow(obj, &overflow);
+#endif
+    Py_BUILD_ASSERT(sizeof(value) == sizeof(int64_t));
+    // the function cannot fail since obj is a PyLongObject
+    assert(!(value == -1 && PyErr_Occurred()));
+
+    if (!overflow) {
+        export_long->value = value;
+        export_long->negative = 0;
+        export_long->ndigits = 0;
+        export_long->digits = 0;
+        export_long->_reserved = 0;
+    }
+    else {
+        export_long->value = 0;
+        export_long->negative = _PyLong_Sign(obj) < 0;
+        export_long->ndigits = _PyLong_DigitCount(self);
+        if (export_long->ndigits == 0) {
+            export_long->ndigits = 1;
+        }
+        export_long->digits = _PyLong_GetDigits(self);
+        export_long->_reserved = (Py_uintptr_t)Py_NewRef(obj);
+    }
+    return 0;
+}
+
+static inline void
+PyLong_FreeExport(PyLongExport *export_long)
+{
+    PyObject *obj = (PyObject*)export_long->_reserved;
+
+    if (obj) {
+        export_long->_reserved = 0;
+        Py_DECREF(obj);
+    }
+}
+
+static inline PyLongWriter*
+PyLongWriter_Create(int negative, Py_ssize_t ndigits, void **digits)
+{
+    if (ndigits <= 0) {
+        PyErr_SetString(PyExc_ValueError, "ndigits must be positive");
+        return NULL;
+    }
+    assert(digits != NULL);
+
+    PyLongObject *obj = _PyLong_New(ndigits);
+    if (obj == NULL) {
+        return NULL;
+    }
+    _PyLong_SetSignAndDigitCount(obj, negative?-1:1, ndigits);
+
+    *digits = _PyLong_GetDigits(obj);
+    return (PyLongWriter*)obj;
+}
+
+static inline void
+PyLongWriter_Discard(PyLongWriter *writer)
+{
+    PyLongObject *obj = (PyLongObject *)writer;
+
+    assert(Py_REFCNT(obj) == 1);
+    Py_DECREF(obj);
+}
+
+static inline PyObject*
+PyLongWriter_Finish(PyLongWriter *writer)
+{
+    PyObject *obj = (PyObject *)writer;
+    PyLongObject *self = (PyLongObject*)obj;
+    Py_ssize_t j = _PyLong_DigitCount(self);
+    Py_ssize_t i = j;
+    int sign = _PyLong_Sign(obj);
+
+    assert(Py_REFCNT(obj) == 1);
+
+    // Normalize and get singleton if possible
+    while (i > 0 && _PyLong_GetDigits(self)[i-1] == 0) {
+        --i;
+    }
+    if (i != j) {
+        if (i == 0) {
+            sign = 0;
+        }
+        _PyLong_SetSignAndDigitCount(self, sign, i);
+    }
+    if (i <= 1) {
+        long val = sign * (long)(_PyLong_GetDigits(self)[0]);
+        Py_DECREF(obj);
+        return PyLong_FromLong(val);
+    }
+
+    return obj;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030C00A3
+#  define Py_T_SHORT      T_SHORT
+#  define Py_T_INT        T_INT
+#  define Py_T_LONG       T_LONG
+#  define Py_T_FLOAT      T_FLOAT
+#  define Py_T_DOUBLE     T_DOUBLE
+#  define Py_T_STRING     T_STRING
+#  define _Py_T_OBJECT    T_OBJECT
+#  define Py_T_CHAR       T_CHAR
+#  define Py_T_BYTE       T_BYTE
+#  define Py_T_UBYTE      T_UBYTE
+#  define Py_T_USHORT     T_USHORT
+#  define Py_T_UINT       T_UINT
+#  define Py_T_ULONG      T_ULONG
+#  define Py_T_STRING_INPLACE  T_STRING_INPLACE
+#  define Py_T_BOOL       T_BOOL
+#  define Py_T_OBJECT_EX  T_OBJECT_EX
+#  define Py_T_LONGLONG   T_LONGLONG
+#  define Py_T_ULONGLONG  T_ULONGLONG
+#  define Py_T_PYSSIZET   T_PYSSIZET
+
+#  if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
+#    define _Py_T_NONE      T_NONE
+#  endif
+
+#  define Py_READONLY            READONLY
+#  define Py_AUDIT_READ          READ_RESTRICTED
+#  define _Py_WRITE_RESTRICTED   PY_WRITE_RESTRICTED
+#endif
+
+
+// gh-127350 added Py_fopen() and Py_fclose() to Python 3.14a4
+#if PY_VERSION_HEX < 0x030E00A4
+static inline FILE* Py_fopen(PyObject *path, const char *mode)
+{
+#if 0x030400A2 <= PY_VERSION_HEX && !defined(PYPY_VERSION)
+    PyAPI_FUNC(FILE*) _Py_fopen_obj(PyObject *path, const char *mode);
+
+    return _Py_fopen_obj(path, mode);
+#else
+    FILE *f;
+    PyObject *bytes;
+#if PY_VERSION_HEX >= 0x03000000
+    if (!PyUnicode_FSConverter(path, &bytes)) {
+        return NULL;
+    }
+#else
+    if (!PyString_Check(path)) {
+        PyErr_SetString(PyExc_TypeError, "except str");
+        return NULL;
+    }
+    bytes = Py_NewRef(path);
+#endif
+    const char *path_bytes = PyBytes_AS_STRING(bytes);
+
+    f = fopen(path_bytes, mode);
+    Py_DECREF(bytes);
+
+    if (f == NULL) {
+        PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, path);
+        return NULL;
+    }
+    return f;
+#endif
+}
+
+static inline int Py_fclose(FILE *file)
+{
+    return fclose(file);
+}
+#endif
+
+
+#if 0x03090000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030E0000 && !defined(PYPY_VERSION)
+static inline PyObject*
+PyConfig_Get(const char *name)
+{
+    typedef enum {
+        _PyConfig_MEMBER_INT,
+        _PyConfig_MEMBER_UINT,
+        _PyConfig_MEMBER_ULONG,
+        _PyConfig_MEMBER_BOOL,
+        _PyConfig_MEMBER_WSTR,
+        _PyConfig_MEMBER_WSTR_OPT,
+        _PyConfig_MEMBER_WSTR_LIST,
+    } PyConfigMemberType;
+
+    typedef struct {
+        const char *name;
+        size_t offset;
+        PyConfigMemberType type;
+        const char *sys_attr;
+    } PyConfigSpec;
+
+#define PYTHONCAPI_COMPAT_SPEC(MEMBER, TYPE, sys_attr) \
+    {#MEMBER, offsetof(PyConfig, MEMBER), \
+     _PyConfig_MEMBER_##TYPE, sys_attr}
+
+    static const PyConfigSpec config_spec[] = {
+        PYTHONCAPI_COMPAT_SPEC(argv, WSTR_LIST, "argv"),
+        PYTHONCAPI_COMPAT_SPEC(base_exec_prefix, WSTR_OPT, "base_exec_prefix"),
+        PYTHONCAPI_COMPAT_SPEC(base_executable, WSTR_OPT, "_base_executable"),
+        PYTHONCAPI_COMPAT_SPEC(base_prefix, WSTR_OPT, "base_prefix"),
+        PYTHONCAPI_COMPAT_SPEC(bytes_warning, UINT, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(exec_prefix, WSTR_OPT, "exec_prefix"),
+        PYTHONCAPI_COMPAT_SPEC(executable, WSTR_OPT, "executable"),
+        PYTHONCAPI_COMPAT_SPEC(inspect, BOOL, _Py_NULL),
+#if 0x030C0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(int_max_str_digits, UINT, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(interactive, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(module_search_paths, WSTR_LIST, "path"),
+        PYTHONCAPI_COMPAT_SPEC(optimization_level, UINT, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(parser_debug, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(platlibdir, WSTR, "platlibdir"),
+        PYTHONCAPI_COMPAT_SPEC(prefix, WSTR_OPT, "prefix"),
+        PYTHONCAPI_COMPAT_SPEC(pycache_prefix, WSTR_OPT, "pycache_prefix"),
+        PYTHONCAPI_COMPAT_SPEC(quiet, BOOL, _Py_NULL),
+#if 0x030B0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(stdlib_dir, WSTR_OPT, "_stdlib_dir"),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(use_environment, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(verbose, UINT, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(warnoptions, WSTR_LIST, "warnoptions"),
+        PYTHONCAPI_COMPAT_SPEC(write_bytecode, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(xoptions, WSTR_LIST, "_xoptions"),
+        PYTHONCAPI_COMPAT_SPEC(buffered_stdio, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(check_hash_pycs_mode, WSTR, _Py_NULL),
+#if 0x030B0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(code_debug_ranges, BOOL, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(configure_c_stdio, BOOL, _Py_NULL),
+#if 0x030D0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(cpu_count, INT, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(dev_mode, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(dump_refs, BOOL, _Py_NULL),
+#if 0x030B0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(dump_refs_file, WSTR_OPT, _Py_NULL),
+#endif
+#ifdef Py_GIL_DISABLED
+        PYTHONCAPI_COMPAT_SPEC(enable_gil, INT, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(faulthandler, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(filesystem_encoding, WSTR, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(filesystem_errors, WSTR, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(hash_seed, ULONG, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(home, WSTR_OPT, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(import_time, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(install_signal_handlers, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(isolated, BOOL, _Py_NULL),
+#ifdef MS_WINDOWS
+        PYTHONCAPI_COMPAT_SPEC(legacy_windows_stdio, BOOL, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(malloc_stats, BOOL, _Py_NULL),
+#if 0x030A0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(orig_argv, WSTR_LIST, "orig_argv"),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(parse_argv, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(pathconfig_warnings, BOOL, _Py_NULL),
+#if 0x030C0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(perf_profiling, UINT, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(program_name, WSTR, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(run_command, WSTR_OPT, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(run_filename, WSTR_OPT, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(run_module, WSTR_OPT, _Py_NULL),
+#if 0x030B0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(safe_path, BOOL, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(show_ref_count, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(site_import, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(skip_source_first_line, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(stdio_encoding, WSTR, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(stdio_errors, WSTR, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(tracemalloc, UINT, _Py_NULL),
+#if 0x030B0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(use_frozen_modules, BOOL, _Py_NULL),
+#endif
+        PYTHONCAPI_COMPAT_SPEC(use_hash_seed, BOOL, _Py_NULL),
+        PYTHONCAPI_COMPAT_SPEC(user_site_directory, BOOL, _Py_NULL),
+#if 0x030A0000 <= PY_VERSION_HEX
+        PYTHONCAPI_COMPAT_SPEC(warn_default_encoding, BOOL, _Py_NULL),
+#endif
+    };
+
+#undef PYTHONCAPI_COMPAT_SPEC
+
+    const PyConfigSpec *spec;
+    int found = 0;
+    for (size_t i=0; i < sizeof(config_spec) / sizeof(config_spec[0]); i++) {
+        spec = &config_spec[i];
+        if (strcmp(spec->name, name) == 0) {
+            found = 1;
+            break;
+        }
+    }
+    if (found) {
+        if (spec->sys_attr != NULL) {
+            PyObject *value = PySys_GetObject(spec->sys_attr);
+            if (value == NULL) {
+                PyErr_Format(PyExc_RuntimeError, "lost sys.%s", spec->sys_attr);
+                return NULL;
+            }
+            return Py_NewRef(value);
+        }
+
+        PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
+
+        const PyConfig *config = _Py_GetConfig();
+        void *member = (char *)config + spec->offset;
+        switch (spec->type) {
+        case _PyConfig_MEMBER_INT:
+        case _PyConfig_MEMBER_UINT:
+        {
+            int value = *(int *)member;
+            return PyLong_FromLong(value);
+        }
+        case _PyConfig_MEMBER_BOOL:
+        {
+            int value = *(int *)member;
+            return PyBool_FromLong(value != 0);
+        }
+        case _PyConfig_MEMBER_ULONG:
+        {
+            unsigned long value = *(unsigned long *)member;
+            return PyLong_FromUnsignedLong(value);
+        }
+        case _PyConfig_MEMBER_WSTR:
+        case _PyConfig_MEMBER_WSTR_OPT:
+        {
+            wchar_t *wstr = *(wchar_t **)member;
+            if (wstr != NULL) {
+                return PyUnicode_FromWideChar(wstr, -1);
+            }
+            else {
+                return Py_NewRef(Py_None);
+            }
+        }
+        case _PyConfig_MEMBER_WSTR_LIST:
+        {
+            const PyWideStringList *list = (const PyWideStringList *)member;
+            PyObject *tuple = PyTuple_New(list->length);
+            if (tuple == NULL) {
+                return NULL;
+            }
+
+            for (Py_ssize_t i = 0; i < list->length; i++) {
+                PyObject *item = PyUnicode_FromWideChar(list->items[i], -1);
+                if (item == NULL) {
+                    Py_DECREF(tuple);
+                    return NULL;
+                }
+                PyTuple_SET_ITEM(tuple, i, item);
+            }
+            return tuple;
+        }
+        default:
+            Py_UNREACHABLE();
+        }
+    }
+
+    PyErr_Format(PyExc_ValueError, "unknown config option name: %s", name);
+    return NULL;
+}
+
+static inline int
+PyConfig_GetInt(const char *name, int *value)
+{
+    PyObject *obj = PyConfig_Get(name);
+    if (obj == NULL) {
+        return -1;
+    }
+
+    if (!PyLong_Check(obj)) {
+        Py_DECREF(obj);
+        PyErr_Format(PyExc_TypeError, "config option %s is not an int", name);
+        return -1;
+    }
+
+    int as_int = PyLong_AsInt(obj);
+    Py_DECREF(obj);
+    if (as_int == -1 && PyErr_Occurred()) {
+        PyErr_Format(PyExc_OverflowError,
+                     "config option %s value does not fit into a C int", name);
+        return -1;
+    }
+
+    *value = as_int;
+    return 0;
+}
+#endif  // PY_VERSION_HEX > 0x03090000 && !defined(PYPY_VERSION)
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/mypyc/lib-rt/pythonsupport.c b/mypyc/lib-rt/pythonsupport.c
new file mode 100644
index 000000000000..90fb69705a00
--- /dev/null
+++ b/mypyc/lib-rt/pythonsupport.c
@@ -0,0 +1,106 @@
+// Collects code that was copied in from cpython, for a couple of different reasons:
+//  * We wanted to modify it to produce a more efficient version for our uses
+//  * We needed to call it and it was static :(
+//  * We wanted to call it and needed to backport it
+
+#include "pythonsupport.h"
+
+#if CPY_3_12_FEATURES
+
+// Slow path of CPyLong_AsSsize_tAndOverflow (non-inlined)
+Py_ssize_t
+CPyLong_AsSsize_tAndOverflow_(PyObject *vv, int *overflow)
+{
+    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);
+
+    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.
+     */
+    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
+
+// Slow path of CPyLong_AsSsize_tAndOverflow (non-inlined, Python 3.11 and earlier)
+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 = Py_SIZE(v);
+
+    sign = 1;
+    x = 0;
+    if (i < 0) {
+        sign = -1;
+        i = -(i);
+    }
+    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.
+     */
+    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;
+}
+
+
+#endif
diff --git a/mypyc/lib-rt/pythonsupport.h b/mypyc/lib-rt/pythonsupport.h
index 8a1159a98853..7019c12cf59a 100644
--- a/mypyc/lib-rt/pythonsupport.h
+++ b/mypyc/lib-rt/pythonsupport.h
@@ -13,6 +13,19 @@
 #include <assert.h>
 #include "mypyc_util.h"
 
+#if CPY_3_13_FEATURES
+#ifndef Py_BUILD_CORE
+#define Py_BUILD_CORE
+#endif
+#include "internal/pycore_genobject.h"  // _PyGen_FetchStopIterationValue
+#include "internal/pycore_pyerrors.h"  // _PyErr_FormatFromCause, _PyErr_SetKeyError
+#include "internal/pycore_setobject.h"  // _PySet_Update
+#endif
+
+#if CPY_3_12_FEATURES
+#include "internal/pycore_frame.h"
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -44,7 +57,7 @@ update_bases(PyObject *bases)
             }
             continue;
         }
-        if (_PyObject_LookupAttrId(base, &PyId___mro_entries__, &meth) < 0) {
+        if (PyObject_GetOptionalAttrString(base, PyId___mro_entries__.string, &meth) < 0) {
             goto error;
         }
         if (!meth) {
@@ -55,7 +68,7 @@ update_bases(PyObject *bases)
             }
             continue;
         }
-        new_base = _PyObject_FastCall(meth, stack, 1);
+        new_base = PyObject_Vectorcall(meth, stack, 1, NULL);
         Py_DECREF(meth);
         if (!new_base) {
             goto error;
@@ -104,7 +117,7 @@ init_subclass(PyTypeObject *type, PyObject *kwds)
     PyObject *super, *func, *result;
     PyObject *args[2] = {(PyObject *)type, (PyObject *)type};
 
-    super = _PyObject_FastCall((PyObject *)&PySuper_Type, args, 2);
+    super = PyObject_Vectorcall((PyObject *)&PySuper_Type, args, 2, NULL);
     if (super == NULL) {
         return -1;
     }
@@ -125,6 +138,43 @@ init_subclass(PyTypeObject *type, PyObject *kwds)
     return 0;
 }
 
+Py_ssize_t
+CPyLong_AsSsize_tAndOverflow_(PyObject *vv, int *overflow);
+
+#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;
+    Py_ssize_t res;
+    Py_ssize_t i;
+
+    *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 {
+        // Slow path is moved to a non-inline helper function to
+        // limit size of generated code
+        int overflow_local;
+        res = CPyLong_AsSsize_tAndOverflow_(vv, &overflow_local);
+        *overflow = overflow_local;
+    }
+    return res;
+}
+
+#else
+
 // Adapted from longobject.c in Python 3.7.0
 
 /* This function adapted from PyLong_AsLongLongAndOverflow, but with
@@ -141,10 +191,8 @@ 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;
 
@@ -152,44 +200,23 @@ 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;
-        if (i < 0) {
-            sign = -1;
-            i = -(i);
-        }
-        while (--i >= 0) {
-            prev = x;
-            x = (x << PyLong_SHIFT) + v->ob_digit[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 */
-        }
+        // Slow path is moved to a non-inline helper function to
+        // limit size of generated code
+        int overflow_local;
+        res = CPyLong_AsSsize_tAndOverflow_(vv, &overflow_local);
+        *overflow = overflow_local;
     }
-  exit:
     return res;
 }
 
+#endif
+
 // Adapted from listobject.c in Python 3.7.0
 static int
 list_resize(PyListObject *self, Py_ssize_t newsize)
@@ -289,23 +316,6 @@ list_count(PyListObject *self, PyObject *value)
     return CPyTagged_ShortFromSsize_t(count);
 }
 
-#if PY_VERSION_HEX < 0x03080000
-static PyObject *
-_PyDict_GetItemStringWithError(PyObject *v, const char *key)
-{
-    PyObject *kv, *rv;
-    kv = PyUnicode_FromString(key);
-    if (kv == NULL) {
-        return NULL;
-    }
-    rv = PyDict_GetItemWithError(v, kv);
-    Py_DECREF(kv);
-    return rv;
-}
-#endif
-
-#define CPyUnicode_EqualToASCIIString(x, y) _PyUnicode_EqualToASCIIString(x, y)
-
 // Adapted from genobject.c in Python 3.7.2
 // Copied because it wasn't in 3.5.2 and it is undocumented anyways.
 /*
@@ -371,7 +381,7 @@ _CPyDictView_New(PyObject *dict, PyTypeObject *type)
 static int
 _CPyObject_HasAttrId(PyObject *v, _Py_Identifier *name) {
     PyObject *tmp = NULL;
-    int result = _PyObject_LookupAttrId(v, name, &tmp);
+    int result = PyObject_GetOptionalAttrString(v, name->string, &tmp);
     if (tmp) {
         Py_DECREF(tmp);
     }
@@ -381,13 +391,23 @@ _CPyObject_HasAttrId(PyObject *v, _Py_Identifier *name) {
 #define _CPyObject_HasAttrId _PyObject_HasAttrId
 #endif
 
-#if PY_VERSION_HEX < 0x03090000
-// OneArgs and NoArgs functions got added in 3.9
-#define _PyObject_CallMethodIdNoArgs(self, name) \
-    _PyObject_CallMethodIdObjArgs((self), (name), NULL)
-#define _PyObject_CallMethodIdOneArg(self, name, arg) \
-    _PyObject_CallMethodIdObjArgs((self), (name), (arg), NULL)
-#endif
+#if CPY_3_12_FEATURES
+
+// These are copied from genobject.c in Python 3.12
+
+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
@@ -402,6 +422,8 @@ gen_is_coroutine(PyObject *o)
     return 0;
 }
 
+#endif
+
 /*
  *   This helper function returns an awaitable for `o`:
  *     - `o` if `o` is a coroutine-object;
diff --git a/mypyc/lib-rt/setup.py b/mypyc/lib-rt/setup.py
index a31b705cd723..1faacc8fc136 100644
--- a/mypyc/lib-rt/setup.py
+++ b/mypyc/lib-rt/setup.py
@@ -5,7 +5,10 @@
 
 from __future__ import annotations
 
+import os
+import subprocess
 import sys
+from distutils.command.build_ext import build_ext
 from distutils.core import Extension, setup
 from typing import Any
 
@@ -17,6 +20,30 @@
     kwargs = {}
     compile_args = ["--std=c++11"]
 
+
+class build_ext_custom(build_ext):  # noqa: N801
+    def get_library_names(self):
+        return ["gtest"]
+
+    def run(self):
+        gtest_dir = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "..", "external", "googletest")
+        )
+
+        os.makedirs(self.build_temp, exist_ok=True)
+
+        # Build Google Test, the C++ framework we use for testing C code.
+        # The source code for Google Test is copied to this repository.
+        subprocess.check_call(
+            ["make", "-f", os.path.join(gtest_dir, "make", "Makefile"), f"GTEST_DIR={gtest_dir}"],
+            cwd=self.build_temp,
+        )
+
+        self.library_dirs = [self.build_temp]
+
+        return build_ext.run(self)
+
+
 setup(
     name="test_capi",
     version="0.1",
@@ -31,13 +58,14 @@
                 "list_ops.c",
                 "exc_ops.c",
                 "generic_ops.c",
+                "pythonsupport.c",
             ],
             depends=["CPy.h", "mypyc_util.h", "pythonsupport.h"],
             extra_compile_args=["-Wno-unused-function", "-Wno-sign-compare"] + compile_args,
-            library_dirs=["../external/googletest/make"],
             libraries=["gtest"],
             include_dirs=["../external/googletest", "../external/googletest/include"],
             **kwargs,
         )
     ],
+    cmdclass={"build_ext": build_ext_custom},
 )
diff --git a/mypyc/lib-rt/str_ops.c b/mypyc/lib-rt/str_ops.c
index 90b19001f8f0..49fcbb8c6876 100644
--- a/mypyc/lib-rt/str_ops.c
+++ b/mypyc/lib-rt/str_ops.c
@@ -5,6 +5,65 @@
 #include <Python.h>
 #include "CPy.h"
 
+// The _PyUnicode_CheckConsistency definition has been moved to the internal API
+// https://github.com/python/cpython/pull/106398
+#if defined(Py_DEBUG) && defined(CPY_3_13_FEATURES)
+#include "internal/pycore_unicodeobject.h"
+#endif
+
+// Copied from cpython.git:Objects/unicodeobject.c@0ef4ffeefd1737c18dc9326133c7894d58108c2e.
+#define BLOOM_MASK unsigned long
+#define BLOOM(mask, ch)     ((mask &  (1UL << ((ch) & (BLOOM_WIDTH - 1)))))
+#if LONG_BIT >= 128
+#define BLOOM_WIDTH 128
+#elif LONG_BIT >= 64
+#define BLOOM_WIDTH 64
+#elif LONG_BIT >= 32
+#define BLOOM_WIDTH 32
+#else
+#error "LONG_BIT is smaller than 32"
+#endif
+
+// Copied from cpython.git:Objects/unicodeobject.c@0ef4ffeefd1737c18dc9326133c7894d58108c2e.
+// This is needed for str.strip("...").
+static inline BLOOM_MASK
+make_bloom_mask(int kind, const void* ptr, Py_ssize_t len)
+{
+#define BLOOM_UPDATE(TYPE, MASK, PTR, LEN)             \
+    do {                                               \
+        TYPE *data = (TYPE *)PTR;                      \
+        TYPE *end = data + LEN;                        \
+        Py_UCS4 ch;                                    \
+        for (; data != end; data++) {                  \
+            ch = *data;                                \
+            MASK |= (1UL << (ch & (BLOOM_WIDTH - 1))); \
+        }                                              \
+        break;                                         \
+    } while (0)
+
+    /* calculate simple bloom-style bitmask for a given unicode string */
+
+    BLOOM_MASK mask;
+
+    mask = 0;
+    switch (kind) {
+    case PyUnicode_1BYTE_KIND:
+        BLOOM_UPDATE(Py_UCS1, mask, ptr, len);
+        break;
+    case PyUnicode_2BYTE_KIND:
+        BLOOM_UPDATE(Py_UCS2, mask, ptr, len);
+        break;
+    case PyUnicode_4BYTE_KIND:
+        BLOOM_UPDATE(Py_UCS4, mask, ptr, len);
+        break;
+    default:
+        Py_UNREACHABLE();
+    }
+    return mask;
+
+#undef BLOOM_UPDATE
+}
+
 PyObject *CPyStr_GetItem(PyObject *str, CPyTagged index) {
     if (PyUnicode_READY(str) != -1) {
         if (CPyTagged_CheckShort(index)) {
@@ -117,7 +176,11 @@ PyObject *CPyStr_Build(Py_ssize_t len, ...) {
             PyObject *item = va_arg(args, PyObject *);
             Py_ssize_t itemlen = PyUnicode_GET_LENGTH(item);
             if (itemlen != 0) {
+#if CPY_3_13_FEATURES
+                PyUnicode_CopyCharacters(res, res_offset, item, 0, itemlen);
+#else
                 _PyUnicode_FastCopyCharacters(res, res_offset, item, 0, itemlen);
+#endif
                 res_offset += itemlen;
             }
         }
@@ -125,10 +188,35 @@ PyObject *CPyStr_Build(Py_ssize_t len, ...) {
         assert(res_offset == PyUnicode_GET_LENGTH(res));
     }
 
+#ifdef Py_DEBUG
     assert(_PyUnicode_CheckConsistency(res, 1));
+#endif
     return res;
 }
 
+CPyTagged CPyStr_Find(PyObject *str, PyObject *substr, CPyTagged start, int direction) {
+    CPyTagged end = PyUnicode_GET_LENGTH(str) << 1;
+    return CPyStr_FindWithEnd(str, substr, start, end, direction);
+}
+
+CPyTagged CPyStr_FindWithEnd(PyObject *str, PyObject *substr, CPyTagged start, CPyTagged end, int direction) {
+    Py_ssize_t temp_start = CPyTagged_AsSsize_t(start);
+    if (temp_start == -1 && PyErr_Occurred()) {
+        PyErr_SetString(PyExc_OverflowError, CPYTHON_LARGE_INT_ERRMSG);
+        return CPY_INT_TAG;
+    }
+    Py_ssize_t temp_end = CPyTagged_AsSsize_t(end);
+    if (temp_end == -1 && PyErr_Occurred()) {
+        PyErr_SetString(PyExc_OverflowError, CPYTHON_LARGE_INT_ERRMSG);
+        return CPY_INT_TAG;
+    }
+    Py_ssize_t index = PyUnicode_Find(str, substr, temp_start, temp_end, direction);
+    if (unlikely(index == -2)) {
+        return CPY_INT_TAG;
+    }
+    return index << 1;
+}
+
 PyObject *CPyStr_Split(PyObject *str, PyObject *sep, CPyTagged max_split) {
     Py_ssize_t temp_max_split = CPyTagged_AsSsize_t(max_split);
     if (temp_max_split == -1 && PyErr_Occurred()) {
@@ -138,6 +226,133 @@ PyObject *CPyStr_Split(PyObject *str, PyObject *sep, CPyTagged max_split) {
     return PyUnicode_Split(str, sep, temp_max_split);
 }
 
+PyObject *CPyStr_RSplit(PyObject *str, PyObject *sep, CPyTagged max_split) {
+    Py_ssize_t temp_max_split = CPyTagged_AsSsize_t(max_split);
+    if (temp_max_split == -1 && PyErr_Occurred()) {
+        PyErr_SetString(PyExc_OverflowError, CPYTHON_LARGE_INT_ERRMSG);
+        return NULL;
+    }
+    return PyUnicode_RSplit(str, sep, temp_max_split);
+}
+
+// This function has been copied from _PyUnicode_XStrip in cpython.git:Objects/unicodeobject.c@0ef4ffeefd1737c18dc9326133c7894d58108c2e.
+static PyObject *_PyStr_XStrip(PyObject *self, int striptype, PyObject *sepobj) {
+    const void *data;
+    int kind;
+    Py_ssize_t i, j, len;
+    BLOOM_MASK sepmask;
+    Py_ssize_t seplen;
+
+    // This check is needed from Python 3.9 and earlier.
+    if (PyUnicode_READY(self) == -1 || PyUnicode_READY(sepobj) == -1)
+        return NULL;
+
+    kind = PyUnicode_KIND(self);
+    data = PyUnicode_DATA(self);
+    len = PyUnicode_GET_LENGTH(self);
+    seplen = PyUnicode_GET_LENGTH(sepobj);
+    sepmask = make_bloom_mask(PyUnicode_KIND(sepobj),
+                              PyUnicode_DATA(sepobj),
+                              seplen);
+
+    i = 0;
+    if (striptype != RIGHTSTRIP) {
+        while (i < len) {
+            Py_UCS4 ch = PyUnicode_READ(kind, data, i);
+            if (!BLOOM(sepmask, ch))
+                break;
+            if (PyUnicode_FindChar(sepobj, ch, 0, seplen, 1) < 0)
+                break;
+            i++;
+        }
+    }
+
+    j = len;
+    if (striptype != LEFTSTRIP) {
+        j--;
+        while (j >= i) {
+            Py_UCS4 ch = PyUnicode_READ(kind, data, j);
+            if (!BLOOM(sepmask, ch))
+                break;
+            if (PyUnicode_FindChar(sepobj, ch, 0, seplen, 1) < 0)
+                break;
+            j--;
+        }
+
+        j++;
+    }
+
+    return PyUnicode_Substring(self, i, j);
+}
+
+// Copied from do_strip function in cpython.git/Objects/unicodeobject.c@0ef4ffeefd1737c18dc9326133c7894d58108c2e.
+PyObject *_CPyStr_Strip(PyObject *self, int strip_type, PyObject *sep) {
+    if (sep == NULL || sep == Py_None) {
+        Py_ssize_t len, i, j;
+
+        // This check is needed from Python 3.9 and earlier.
+        if (PyUnicode_READY(self) == -1)
+            return NULL;
+
+        len = PyUnicode_GET_LENGTH(self);
+
+        if (PyUnicode_IS_ASCII(self)) {
+            const Py_UCS1 *data = PyUnicode_1BYTE_DATA(self);
+
+            i = 0;
+            if (strip_type != RIGHTSTRIP) {
+                while (i < len) {
+                    Py_UCS1 ch = data[i];
+                    if (!_Py_ascii_whitespace[ch])
+                        break;
+                    i++;
+                }
+            }
+
+            j = len;
+            if (strip_type != LEFTSTRIP) {
+                j--;
+                while (j >= i) {
+                    Py_UCS1 ch = data[j];
+                    if (!_Py_ascii_whitespace[ch])
+                        break;
+                    j--;
+                }
+                j++;
+            }
+        }
+        else {
+            int kind = PyUnicode_KIND(self);
+            const void *data = PyUnicode_DATA(self);
+
+            i = 0;
+            if (strip_type != RIGHTSTRIP) {
+                while (i < len) {
+                    Py_UCS4 ch = PyUnicode_READ(kind, data, i);
+                    if (!Py_UNICODE_ISSPACE(ch))
+                        break;
+                    i++;
+                }
+            }
+
+            j = len;
+            if (strip_type != LEFTSTRIP) {
+                j--;
+                while (j >= i) {
+                    Py_UCS4 ch = PyUnicode_READ(kind, data, j);
+                    if (!Py_UNICODE_ISSPACE(ch))
+                        break;
+                    j--;
+                }
+                j++;
+            }
+        }
+
+        return PyUnicode_Substring(self, i, j);
+    }
+    return _PyStr_XStrip(self, strip_type, sep);
+}
+
 PyObject *CPyStr_Replace(PyObject *str, PyObject *old_substr,
                          PyObject *new_substr, CPyTagged max_replace) {
     Py_ssize_t temp_max_replace = CPyTagged_AsSsize_t(max_replace);
@@ -148,18 +363,74 @@ PyObject *CPyStr_Replace(PyObject *str, PyObject *old_substr,
     return PyUnicode_Replace(str, old_substr, new_substr, temp_max_replace);
 }
 
-bool CPyStr_Startswith(PyObject *self, PyObject *subobj) {
+int CPyStr_Startswith(PyObject *self, PyObject *subobj) {
     Py_ssize_t start = 0;
     Py_ssize_t end = PyUnicode_GET_LENGTH(self);
+    if (PyTuple_Check(subobj)) {
+        Py_ssize_t i;
+        for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
+            PyObject *substring = PyTuple_GET_ITEM(subobj, i);
+            if (!PyUnicode_Check(substring)) {
+                PyErr_Format(PyExc_TypeError,
+                             "tuple for startswith must only contain str, "
+                             "not %.100s",
+                             Py_TYPE(substring)->tp_name);
+                return 2;
+            }
+            int result = PyUnicode_Tailmatch(self, substring, start, end, -1);
+            if (result) {
+                return 1;
+            }
+        }
+        return 0;
+    }
     return PyUnicode_Tailmatch(self, subobj, start, end, -1);
 }
 
-bool CPyStr_Endswith(PyObject *self, PyObject *subobj) {
+int CPyStr_Endswith(PyObject *self, PyObject *subobj) {
     Py_ssize_t start = 0;
     Py_ssize_t end = PyUnicode_GET_LENGTH(self);
+    if (PyTuple_Check(subobj)) {
+        Py_ssize_t i;
+        for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
+            PyObject *substring = PyTuple_GET_ITEM(subobj, i);
+            if (!PyUnicode_Check(substring)) {
+                PyErr_Format(PyExc_TypeError,
+                             "tuple for endswith must only contain str, "
+                             "not %.100s",
+                             Py_TYPE(substring)->tp_name);
+                return 2;
+            }
+            int result = PyUnicode_Tailmatch(self, substring, start, end, 1);
+            if (result) {
+                return 1;
+            }
+        }
+        return 0;
+    }
     return PyUnicode_Tailmatch(self, subobj, start, end, 1);
 }
 
+PyObject *CPyStr_Removeprefix(PyObject *self, PyObject *prefix) {
+    Py_ssize_t end = PyUnicode_GET_LENGTH(self);
+    int match = PyUnicode_Tailmatch(self, prefix, 0, end, -1);
+    if (match) {
+        Py_ssize_t prefix_end = PyUnicode_GET_LENGTH(prefix);
+        return PyUnicode_Substring(self, prefix_end, end);
+    }
+    return Py_NewRef(self);
+}
+
+PyObject *CPyStr_Removesuffix(PyObject *self, PyObject *suffix) {
+    Py_ssize_t end = PyUnicode_GET_LENGTH(self);
+    int match = PyUnicode_Tailmatch(self, suffix, 0, end, 1);
+    if (match) {
+        Py_ssize_t suffix_end = PyUnicode_GET_LENGTH(suffix);
+        return PyUnicode_Substring(self, 0, end - suffix_end);
+    }
+    return Py_NewRef(self);
+}
+
 /* This does a dodgy attempt to append in place  */
 PyObject *CPyStr_Append(PyObject *o1, PyObject *o2) {
     PyUnicode_Append(&o1, o2);
@@ -239,3 +510,15 @@ PyObject *CPy_Encode(PyObject *obj, PyObject *encoding, PyObject *errors) {
         return NULL;
     }
 }
+
+
+CPyTagged CPyStr_Ord(PyObject *obj) {
+    Py_ssize_t s = PyUnicode_GET_LENGTH(obj);
+    if (s == 1) {
+        int kind = PyUnicode_KIND(obj);
+        return PyUnicode_READ(kind, PyUnicode_DATA(obj), 0) << 1;
+    }
+    PyErr_Format(
+        PyExc_TypeError, "ord() expected a character, but a string of length %zd found", s);
+    return CPY_INT_TAG;
+}
diff --git a/mypyc/lower/__init__.py b/mypyc/lower/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/mypyc/lower/int_ops.py b/mypyc/lower/int_ops.py
new file mode 100644
index 000000000000..adfb4c21e2de
--- /dev/null
+++ b/mypyc/lower/int_ops.py
@@ -0,0 +1,113 @@
+"""Convert tagged int primitive ops to lower-level ops."""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+from mypyc.ir.ops import Assign, BasicBlock, Branch, ComparisonOp, Register, Value
+from mypyc.ir.rtypes import bool_rprimitive, is_short_int_rprimitive
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+from mypyc.lower.registry import lower_primitive_op
+from mypyc.primitives.int_ops import int_equal_, int_less_than_
+from mypyc.primitives.registry import CFunctionDescription
+
+
+# Description for building int comparison ops
+#
+# Fields:
+#   binary_op_variant: identify which IntOp to use when operands are short integers
+#   c_func_description: the C function to call when operands are tagged integers
+#   c_func_negated: whether to negate the C function call's result
+#   c_func_swap_operands: whether to swap lhs and rhs when call the function
+class IntComparisonOpDescription(NamedTuple):
+    binary_op_variant: int
+    c_func_description: CFunctionDescription
+    c_func_negated: bool
+    c_func_swap_operands: bool
+
+
+# Provide mapping from textual op to short int's op variant and boxed int's description.
+# Note that these are not complete implementations and require extra IR.
+int_comparison_op_mapping: dict[str, IntComparisonOpDescription] = {
+    "==": IntComparisonOpDescription(ComparisonOp.EQ, int_equal_, False, False),
+    "!=": IntComparisonOpDescription(ComparisonOp.NEQ, int_equal_, True, False),
+    "<": IntComparisonOpDescription(ComparisonOp.SLT, int_less_than_, False, False),
+    "<=": IntComparisonOpDescription(ComparisonOp.SLE, int_less_than_, True, True),
+    ">": IntComparisonOpDescription(ComparisonOp.SGT, int_less_than_, False, True),
+    ">=": IntComparisonOpDescription(ComparisonOp.SGE, int_less_than_, True, False),
+}
+
+
+def compare_tagged(self: LowLevelIRBuilder, lhs: Value, rhs: Value, op: str, line: int) -> Value:
+    """Compare two tagged integers using given operator (value context)."""
+    # generate fast binary logic ops on short ints
+    if (is_short_int_rprimitive(lhs.type) or is_short_int_rprimitive(rhs.type)) and op in (
+        "==",
+        "!=",
+    ):
+        quick = True
+    else:
+        quick = is_short_int_rprimitive(lhs.type) and is_short_int_rprimitive(rhs.type)
+    if quick:
+        return self.comparison_op(lhs, rhs, int_comparison_op_mapping[op][0], line)
+    op_type, c_func_desc, negate_result, swap_op = int_comparison_op_mapping[op]
+    result = Register(bool_rprimitive)
+    short_int_block, int_block, out = BasicBlock(), BasicBlock(), BasicBlock()
+    check_lhs = self.check_tagged_short_int(lhs, line, negated=True)
+    if op in ("==", "!="):
+        self.add(Branch(check_lhs, int_block, short_int_block, Branch.BOOL))
+    else:
+        # for non-equality logical ops (less/greater than, etc.), need to check both sides
+        short_lhs = BasicBlock()
+        self.add(Branch(check_lhs, int_block, short_lhs, Branch.BOOL))
+        self.activate_block(short_lhs)
+        check_rhs = self.check_tagged_short_int(rhs, line, negated=True)
+        self.add(Branch(check_rhs, int_block, short_int_block, Branch.BOOL))
+    self.activate_block(int_block)
+    if swap_op:
+        args = [rhs, lhs]
+    else:
+        args = [lhs, rhs]
+    call = self.call_c(c_func_desc, args, line)
+    if negate_result:
+        # TODO: introduce UnaryIntOp?
+        call_result = self.unary_op(call, "not", line)
+    else:
+        call_result = call
+    self.add(Assign(result, call_result, line))
+    self.goto(out)
+    self.activate_block(short_int_block)
+    eq = self.comparison_op(lhs, rhs, op_type, line)
+    self.add(Assign(result, eq, line))
+    self.goto_and_activate(out)
+    return result
+
+
+@lower_primitive_op("int_eq")
+def lower_int_eq(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    return compare_tagged(builder, args[0], args[1], "==", line)
+
+
+@lower_primitive_op("int_ne")
+def lower_int_ne(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    return compare_tagged(builder, args[0], args[1], "!=", line)
+
+
+@lower_primitive_op("int_lt")
+def lower_int_lt(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    return compare_tagged(builder, args[0], args[1], "<", line)
+
+
+@lower_primitive_op("int_le")
+def lower_int_le(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    return compare_tagged(builder, args[0], args[1], "<=", line)
+
+
+@lower_primitive_op("int_gt")
+def lower_int_gt(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    return compare_tagged(builder, args[0], args[1], ">", line)
+
+
+@lower_primitive_op("int_ge")
+def lower_int_ge(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    return compare_tagged(builder, args[0], args[1], ">=", line)
diff --git a/mypyc/lower/list_ops.py b/mypyc/lower/list_ops.py
new file mode 100644
index 000000000000..f719a9fcd23d
--- /dev/null
+++ b/mypyc/lower/list_ops.py
@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from mypyc.common import PLATFORM_SIZE
+from mypyc.ir.ops import GetElementPtr, IncRef, Integer, IntOp, LoadMem, SetMem, Value
+from mypyc.ir.rtypes import (
+    PyListObject,
+    c_pyssize_t_rprimitive,
+    object_rprimitive,
+    pointer_rprimitive,
+)
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+from mypyc.lower.registry import lower_primitive_op
+
+
+@lower_primitive_op("buf_init_item")
+def buf_init_item(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    """Initialize an item in a buffer of "PyObject *" values at given index.
+
+    This can be used to initialize the data buffer of a freshly allocated list
+    object.
+    """
+    base = args[0]
+    index_value = args[1]
+    value = args[2]
+    assert isinstance(index_value, Integer)
+    index = index_value.numeric_value()
+    if index == 0:
+        ptr = base
+    else:
+        ptr = builder.add(
+            IntOp(
+                pointer_rprimitive,
+                base,
+                Integer(index * PLATFORM_SIZE, c_pyssize_t_rprimitive),
+                IntOp.ADD,
+                line,
+            )
+        )
+    return builder.add(SetMem(object_rprimitive, ptr, value, line))
+
+
+@lower_primitive_op("list_items")
+def list_items(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    ob_item_ptr = builder.add(GetElementPtr(args[0], PyListObject, "ob_item", line))
+    return builder.add(LoadMem(pointer_rprimitive, ob_item_ptr, line))
+
+
+def list_item_ptr(builder: LowLevelIRBuilder, obj: Value, index: Value, line: int) -> Value:
+    """Get a pointer to a list item (index must be valid and non-negative).
+
+    Type of index must be c_pyssize_t_rprimitive, and obj must refer to a list object.
+    """
+    # List items are represented as an array of pointers. Pointer to the item obj[index] is
+    # <pointer to first item> + index * <pointer size>.
+    items = list_items(builder, [obj], line)
+    delta = builder.add(
+        IntOp(
+            c_pyssize_t_rprimitive,
+            index,
+            Integer(PLATFORM_SIZE, c_pyssize_t_rprimitive),
+            IntOp.MUL,
+        )
+    )
+    return builder.add(IntOp(pointer_rprimitive, items, delta, IntOp.ADD))
+
+
+@lower_primitive_op("list_get_item_unsafe")
+def list_get_item_unsafe(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    index = builder.coerce(args[1], c_pyssize_t_rprimitive, line)
+    item_ptr = list_item_ptr(builder, args[0], index, line)
+    value = builder.add(LoadMem(object_rprimitive, item_ptr, line))
+    builder.add(IncRef(value))
+    return value
diff --git a/mypyc/lower/misc_ops.py b/mypyc/lower/misc_ops.py
new file mode 100644
index 000000000000..1effcd4f42ac
--- /dev/null
+++ b/mypyc/lower/misc_ops.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from mypyc.ir.ops import GetElementPtr, LoadMem, Value
+from mypyc.ir.rtypes import PyVarObject, c_pyssize_t_rprimitive
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+from mypyc.lower.registry import lower_primitive_op
+
+
+@lower_primitive_op("var_object_size")
+def var_object_size(builder: LowLevelIRBuilder, args: list[Value], line: int) -> Value:
+    elem_address = builder.add(GetElementPtr(args[0], PyVarObject, "ob_size"))
+    return builder.add(LoadMem(c_pyssize_t_rprimitive, elem_address))
diff --git a/mypyc/lower/registry.py b/mypyc/lower/registry.py
new file mode 100644
index 000000000000..a20990fe39ae
--- /dev/null
+++ b/mypyc/lower/registry.py
@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Callable, Final, Optional, TypeVar
+
+from mypyc.ir.ops import Value
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+
+LowerFunc = Callable[[LowLevelIRBuilder, list[Value], int], Value]
+LowerFuncOpt = Callable[[LowLevelIRBuilder, list[Value], int], Optional[Value]]
+
+lowering_registry: Final[dict[str, LowerFuncOpt]] = {}
+
+LF = TypeVar("LF", LowerFunc, LowerFuncOpt)
+
+
+def lower_primitive_op(name: str) -> Callable[[LF], LF]:
+    """Register a handler that generates low-level IR for a primitive op."""
+
+    def wrapper(f: LF) -> LF:
+        assert name not in lowering_registry
+        lowering_registry[name] = f
+        return f
+
+    return wrapper
+
+
+# Import various modules that set up global state.
+from mypyc.lower import int_ops, list_ops, misc_ops  # noqa: F401
diff --git a/mypyc/namegen.py b/mypyc/namegen.py
index 675dae9001c7..5f57fa9a70ed 100644
--- a/mypyc/namegen.py
+++ b/mypyc/namegen.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable
+from collections.abc import Iterable
 
 
 class NameGenerator:
@@ -100,10 +100,9 @@ def make_module_translation_map(names: list[str]) -> dict[str, str]:
     for name in names:
         for suffix in candidate_suffixes(name):
             if num_instances[suffix] == 1:
-                result[name] = suffix
                 break
-        else:
-            assert False, names
+        # Takes the last suffix if none are unique
+        result[name] = suffix
     return result
 
 
diff --git a/mypyc/options.py b/mypyc/options.py
index 5f0cf12aeefe..24e68163bb11 100644
--- a/mypyc/options.py
+++ b/mypyc/options.py
@@ -14,6 +14,7 @@ def __init__(
         include_runtime_files: bool | None = None,
         capi_version: tuple[int, int] | None = None,
         python_version: tuple[int, int] | None = None,
+        strict_dunder_typing: bool = False,
     ) -> None:
         self.strip_asserts = strip_asserts
         self.multi_file = multi_file
@@ -30,3 +31,10 @@ def __init__(
         # features are used.
         self.capi_version = capi_version or sys.version_info[:2]
         self.python_version = python_version
+        # Make possible to inline dunder methods in the generated code.
+        # Typically, the convention is the dunder methods can return `NotImplemented`
+        # even when its return type is just `bool`.
+        # By enabling this option, this convention is no longer valid and the dunder
+        # will assume the return type of the method strictly, which can lead to
+        # more optimization opportunities.
+        self.strict_dunders_typing = strict_dunder_typing
diff --git a/mypyc/primitives/bytes_ops.py b/mypyc/primitives/bytes_ops.py
index d7a7f3e2f59b..1afd196cff84 100644
--- a/mypyc/primitives/bytes_ops.py
+++ b/mypyc/primitives/bytes_ops.py
@@ -99,3 +99,11 @@
     error_kind=ERR_MAGIC,
     var_arg_type=bytes_rprimitive,
 )
+
+function_op(
+    name="builtins.ord",
+    arg_types=[bytes_rprimitive],
+    return_type=int_rprimitive,
+    c_function_name="CPyBytes_Ord",
+    error_kind=ERR_MAGIC,
+)
diff --git a/mypyc/primitives/exc_ops.py b/mypyc/primitives/exc_ops.py
index ad105056158a..9a5f6392a917 100644
--- a/mypyc/primitives/exc_ops.py
+++ b/mypyc/primitives/exc_ops.py
@@ -41,7 +41,7 @@
 no_err_occurred_op = custom_op(
     arg_types=[],
     return_type=bit_rprimitive,
-    c_function_name="CPy_NoErrOccured",
+    c_function_name="CPy_NoErrOccurred",
     error_kind=ERR_FALSE,
 )
 
diff --git a/mypyc/primitives/generic_ops.py b/mypyc/primitives/generic_ops.py
index 3caec0a9875e..54510d99cf87 100644
--- a/mypyc/primitives/generic_ops.py
+++ b/mypyc/primitives/generic_ops.py
@@ -178,7 +178,7 @@
 )
 
 # obj1[obj2]
-method_op(
+py_get_item_op = method_op(
     name="__getitem__",
     arg_types=[object_rprimitive, object_rprimitive],
     return_type=object_rprimitive,
@@ -281,7 +281,7 @@
         object_rprimitive,
     ],  # Keyword arg names tuple (or NULL)
     return_type=object_rprimitive,
-    c_function_name="_PyObject_Vectorcall",
+    c_function_name="PyObject_Vectorcall",
     error_kind=ERR_MAGIC,
 )
 
diff --git a/mypyc/primitives/int_ops.py b/mypyc/primitives/int_ops.py
index eff4b4ffd8ab..9b8b48da602d 100644
--- a/mypyc/primitives/int_ops.py
+++ b/mypyc/primitives/int_ops.py
@@ -10,15 +10,20 @@
 
 from __future__ import annotations
 
-from typing import NamedTuple
-
-from mypyc.ir.ops import ERR_ALWAYS, ERR_MAGIC, ERR_MAGIC_OVERLAPPING, ERR_NEVER, ComparisonOp
+from mypyc.ir.ops import (
+    ERR_ALWAYS,
+    ERR_MAGIC,
+    ERR_MAGIC_OVERLAPPING,
+    ERR_NEVER,
+    PrimitiveDescription,
+)
 from mypyc.ir.rtypes import (
     RType,
     bit_rprimitive,
     bool_rprimitive,
     c_pyssize_t_rprimitive,
     float_rprimitive,
+    int16_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
     int_rprimitive,
@@ -26,18 +31,17 @@
     str_rprimitive,
     void_rtype,
 )
-from mypyc.primitives.registry import (
-    CFunctionDescription,
-    binary_op,
-    custom_op,
-    function_op,
-    load_address_op,
-    unary_op,
-)
+from mypyc.primitives.registry import binary_op, custom_op, function_op, load_address_op, unary_op
 
 # 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",
+    "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?
 
@@ -73,25 +77,45 @@
         error_kind=ERR_MAGIC,
     )
 
-# str(int)
-int_to_str_op = function_op(
-    name="builtins.str",
-    arg_types=[int_rprimitive],
-    return_type=str_rprimitive,
-    c_function_name="CPyTagged_Str",
-    error_kind=ERR_MAGIC,
-    priority=2,
-)
+for name in ("builtins.str", "builtins.repr"):
+    # str(int) and repr(int)
+    int_to_str_op = function_op(
+        name=name,
+        arg_types=[int_rprimitive],
+        return_type=str_rprimitive,
+        c_function_name="CPyTagged_Str",
+        error_kind=ERR_MAGIC,
+        priority=2,
+    )
+    # We need a specialization for str on bools also since the int one is wrong...
+    function_op(
+        name=name,
+        arg_types=[bool_rprimitive],
+        return_type=str_rprimitive,
+        c_function_name="CPyBool_Str",
+        error_kind=ERR_MAGIC,
+        priority=3,
+    )
+
+
+def int_binary_primitive(
+    op: str, primitive_name: str, return_type: RType = int_rprimitive, error_kind: int = ERR_NEVER
+) -> PrimitiveDescription:
+    return binary_op(
+        name=op,
+        arg_types=[int_rprimitive, int_rprimitive],
+        return_type=return_type,
+        primitive_name=primitive_name,
+        error_kind=error_kind,
+    )
 
-# We need a specialization for str on bools also since the int one is wrong...
-function_op(
-    name="builtins.str",
-    arg_types=[bool_rprimitive],
-    return_type=str_rprimitive,
-    c_function_name="CPyBool_Str",
-    error_kind=ERR_MAGIC,
-    priority=3,
-)
+
+int_eq = int_binary_primitive(op="==", primitive_name="int_eq", return_type=bit_rprimitive)
+int_ne = int_binary_primitive(op="!=", primitive_name="int_ne", return_type=bit_rprimitive)
+int_lt = int_binary_primitive(op="<", primitive_name="int_lt", return_type=bit_rprimitive)
+int_le = int_binary_primitive(op="<=", primitive_name="int_le", return_type=bit_rprimitive)
+int_gt = int_binary_primitive(op=">", primitive_name="int_gt", return_type=bit_rprimitive)
+int_ge = int_binary_primitive(op=">=", primitive_name="int_ge", return_type=bit_rprimitive)
 
 
 def int_binary_op(
@@ -145,7 +169,7 @@ def int_binary_op(
 int_binary_op("<<=", "CPyTagged_Lshift", error_kind=ERR_MAGIC)
 
 
-def int_unary_op(name: str, c_function_name: str) -> CFunctionDescription:
+def int_unary_op(name: str, c_function_name: str) -> PrimitiveDescription:
     return unary_op(
         name=name,
         arg_type=int_rprimitive,
@@ -162,26 +186,13 @@ def int_unary_op(name: str, c_function_name: str) -> CFunctionDescription:
 # Primitives related to integer comparison operations:
 
 
-# Description for building int comparison ops
-#
-# Fields:
-#   binary_op_variant: identify which IntOp to use when operands are short integers
-#   c_func_description: the C function to call when operands are tagged integers
-#   c_func_negated: whether to negate the C function call's result
-#   c_func_swap_operands: whether to swap lhs and rhs when call the function
-class IntComparisonOpDescription(NamedTuple):
-    binary_op_variant: int
-    c_func_description: CFunctionDescription
-    c_func_negated: bool
-    c_func_swap_operands: bool
-
-
 # Equals operation on two boxed tagged integers
 int_equal_ = custom_op(
     arg_types=[int_rprimitive, int_rprimitive],
     return_type=bit_rprimitive,
     c_function_name="CPyTagged_IsEq_",
     error_kind=ERR_NEVER,
+    is_pure=True,
 )
 
 # Less than operation on two boxed tagged integers
@@ -190,19 +201,9 @@ class IntComparisonOpDescription(NamedTuple):
     return_type=bit_rprimitive,
     c_function_name="CPyTagged_IsLt_",
     error_kind=ERR_NEVER,
+    is_pure=True,
 )
 
-# Provide mapping from textual op to short int's op variant and boxed int's description.
-# Note that these are not complete implementations and require extra IR.
-int_comparison_op_mapping: dict[str, IntComparisonOpDescription] = {
-    "==": IntComparisonOpDescription(ComparisonOp.EQ, int_equal_, False, False),
-    "!=": IntComparisonOpDescription(ComparisonOp.NEQ, int_equal_, True, False),
-    "<": IntComparisonOpDescription(ComparisonOp.SLT, int_less_than_, False, False),
-    "<=": IntComparisonOpDescription(ComparisonOp.SLE, int_less_than_, True, True),
-    ">": IntComparisonOpDescription(ComparisonOp.SGT, int_less_than_, False, True),
-    ">=": IntComparisonOpDescription(ComparisonOp.SGE, int_less_than_, True, False),
-}
-
 int64_divide_op = custom_op(
     arg_types=[int64_rprimitive, int64_rprimitive],
     return_type=int64_rprimitive,
@@ -231,6 +232,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 +282,17 @@ 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,
+)
+
+uint8_overflow = custom_op(
+    arg_types=[],
+    return_type=void_rtype,
+    c_function_name="CPyUInt8_Overflow",
+    error_kind=ERR_ALWAYS,
+)
diff --git a/mypyc/primitives/list_ops.py b/mypyc/primitives/list_ops.py
index 7fe3157f3a38..99df6fe0dc9c 100644
--- a/mypyc/primitives/list_ops.py
+++ b/mypyc/primitives/list_ops.py
@@ -11,12 +11,14 @@
     int_rprimitive,
     list_rprimitive,
     object_rprimitive,
+    pointer_rprimitive,
     short_int_rprimitive,
 )
 from mypyc.primitives.registry import (
     ERR_NEG_INT,
     binary_op,
     custom_op,
+    custom_primitive_op,
     function_op,
     load_address_op,
     method_op,
@@ -25,6 +27,15 @@
 # Get the 'builtins.list' type object.
 load_address_op(name="builtins.list", type=object_rprimitive, src="PyList_Type")
 
+# sorted(obj)
+function_op(
+    name="builtins.sorted",
+    arg_types=[object_rprimitive],
+    return_type=list_rprimitive,
+    c_function_name="CPySequence_Sort",
+    error_kind=ERR_MAGIC,
+)
+
 # list(obj)
 to_list = function_op(
     name="builtins.list",
@@ -60,6 +71,14 @@
     steals=True,
 )
 
+# Get pointer to list items (ob_item PyListObject field)
+list_items = custom_primitive_op(
+    name="list_items",
+    arg_types=[list_rprimitive],
+    return_type=pointer_rprimitive,
+    error_kind=ERR_NEVER,
+)
+
 # list[index] (for an integer index)
 list_get_item_op = method_op(
     name="__getitem__",
@@ -124,10 +143,10 @@
 
 # This is unsafe because it assumes that the index is a non-negative short integer
 # that is in-bounds for the list.
-list_get_item_unsafe_op = custom_op(
+list_get_item_unsafe_op = custom_primitive_op(
+    name="list_get_item_unsafe",
     arg_types=[list_rprimitive, short_int_rprimitive],
     return_type=object_rprimitive,
-    c_function_name="CPyList_GetItemUnsafe",
     error_kind=ERR_NEVER,
 )
 
@@ -252,6 +271,33 @@
     error_kind=ERR_MAGIC,
 )
 
+# list.copy()
+method_op(
+    name="copy",
+    arg_types=[list_rprimitive],
+    return_type=list_rprimitive,
+    c_function_name="CPyList_Copy",
+    error_kind=ERR_MAGIC,
+)
+
+# list + list
+binary_op(
+    name="+",
+    arg_types=[list_rprimitive, list_rprimitive],
+    return_type=list_rprimitive,
+    c_function_name="PySequence_Concat",
+    error_kind=ERR_MAGIC,
+)
+
+# list += list
+binary_op(
+    name="+=",
+    arg_types=[list_rprimitive, object_rprimitive],
+    return_type=list_rprimitive,
+    c_function_name="PySequence_InPlaceConcat",
+    error_kind=ERR_MAGIC,
+)
+
 # list * int
 binary_op(
     name="*",
@@ -270,6 +316,15 @@
     error_kind=ERR_MAGIC,
 )
 
+# list *= int
+binary_op(
+    name="*=",
+    arg_types=[list_rprimitive, int_rprimitive],
+    return_type=list_rprimitive,
+    c_function_name="CPySequence_InPlaceMultiply",
+    error_kind=ERR_MAGIC,
+)
+
 # list[begin:end]
 list_slice_op = custom_op(
     arg_types=[list_rprimitive, int_rprimitive, int_rprimitive],
diff --git a/mypyc/primitives/misc_ops.py b/mypyc/primitives/misc_ops.py
index 5a8cc111ebc2..7494b46790ce 100644
--- a/mypyc/primitives/misc_ops.py
+++ b/mypyc/primitives/misc_ops.py
@@ -13,9 +13,17 @@
     int_rprimitive,
     object_pointer_rprimitive,
     object_rprimitive,
+    pointer_rprimitive,
     str_rprimitive,
+    void_rtype,
+)
+from mypyc.primitives.registry import (
+    ERR_NEG_INT,
+    custom_op,
+    custom_primitive_op,
+    function_op,
+    load_address_op,
 )
-from mypyc.primitives.registry import ERR_NEG_INT, custom_op, function_op, load_address_op
 
 # Get the 'bool' type object.
 load_address_op(name="builtins.bool", type=object_rprimitive, src="PyBool_Type")
@@ -216,7 +224,13 @@
 # Create a dataclass from an extension class. See
 # CPyDataclass_SleightOfHand for more docs.
 dataclass_sleight_of_hand = custom_op(
-    arg_types=[object_rprimitive, object_rprimitive, dict_rprimitive, dict_rprimitive],
+    arg_types=[
+        object_rprimitive,
+        object_rprimitive,
+        dict_rprimitive,
+        dict_rprimitive,
+        str_rprimitive,
+    ],
     return_type=bit_rprimitive,
     c_function_name="CPyDataclass_SleightOfHand",
     error_kind=ERR_FALSE,
@@ -232,10 +246,48 @@
 )
 
 
-# register an implementation for a singledispatch function
+# Register an implementation for a singledispatch function
 register_function = custom_op(
     arg_types=[object_rprimitive, object_rprimitive, object_rprimitive],
     return_type=object_rprimitive,
     c_function_name="CPySingledispatch_RegisterFunction",
     error_kind=ERR_MAGIC,
 )
+
+
+# Initialize a PyObject * item in a memory buffer (steal the value)
+buf_init_item = custom_primitive_op(
+    name="buf_init_item",
+    arg_types=[pointer_rprimitive, c_pyssize_t_rprimitive, object_rprimitive],
+    return_type=void_rtype,
+    error_kind=ERR_NEVER,
+    steals=[False, False, True],
+)
+
+# Get length of PyVarObject instance (e.g. list or tuple)
+var_object_size = custom_primitive_op(
+    name="var_object_size",
+    arg_types=[object_rprimitive],
+    return_type=c_pyssize_t_rprimitive,
+    error_kind=ERR_NEVER,
+)
+
+# Set the lazy value compute function of an TypeAliasType instance (Python 3.12+).
+# This must only be used as part of initializing the object. Any existing value
+# will be cleared.
+set_type_alias_compute_function_op = custom_primitive_op(
+    name="set_type_alias_compute_function",
+    c_function_name="CPy_SetTypeAliasTypeComputeFunction",
+    # (alias object, value compute function)
+    arg_types=[object_rprimitive, object_rprimitive],
+    return_type=void_rtype,
+    error_kind=ERR_NEVER,
+)
+
+debug_print_op = custom_primitive_op(
+    name="debug_print",
+    c_function_name="CPyDebug_PrintObject",
+    arg_types=[object_rprimitive],
+    return_type=void_rtype,
+    error_kind=ERR_NEVER,
+)
diff --git a/mypyc/primitives/registry.py b/mypyc/primitives/registry.py
index 1e2cf2695ee7..5e7ecb70f55d 100644
--- a/mypyc/primitives/registry.py
+++ b/mypyc/primitives/registry.py
@@ -37,10 +37,9 @@
 
 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.ops import PrimitiveDescription, StealsDescription
 from mypyc.ir.rtypes import RType
 
 # Error kind for functions that return negative integer on exception. This
@@ -50,17 +49,18 @@
 
 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
+    is_pure: bool
 
 
 # A description for C load operations including LoadGlobal and LoadAddress
@@ -70,17 +70,17 @@ class LoadAddressDescription(NamedTuple):
     src: str  # name of the target to load
 
 
-# CallC op for method call(such as 'str.join')
-method_call_ops: dict[str, list[CFunctionDescription]] = {}
+# Primitive ops for method call (such as 'str.join')
+method_call_ops: dict[str, list[PrimitiveDescription]] = {}
 
-# CallC op for top level function call(such as 'builtins.list')
-function_ops: dict[str, list[CFunctionDescription]] = {}
+# Primitive ops for top level function call (such as 'builtins.list')
+function_ops: dict[str, list[PrimitiveDescription]] = {}
 
-# CallC op for binary ops
-binary_ops: dict[str, list[CFunctionDescription]] = {}
+# Primitive ops for binary operations
+binary_ops: dict[str, list[PrimitiveDescription]] = {}
 
-# CallC op for unary ops
-unary_ops: dict[str, list[CFunctionDescription]] = {}
+# Primitive ops for unary ops
+unary_ops: dict[str, list[PrimitiveDescription]] = {}
 
 builtin_names: dict[str, tuple[RType, str]] = {}
 
@@ -94,11 +94,12 @@ def method_op(
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
-) -> CFunctionDescription:
+    is_pure: bool = False,
+) -> PrimitiveDescription:
     """Define a c function call op that replaces a method call.
 
     This will be automatically generated by matching against the AST.
@@ -122,9 +123,13 @@ def method_op(
         steals: description of arguments that this steals (ref count wise)
         is_borrowed: if True, returned value is borrowed (no need to decrease refcount)
         priority: if multiple ops match, the one with the highest priority is picked
+        is_pure: if True, declare that the C function has no side effects, takes immutable
+                 arguments, and never raises an exception
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = method_call_ops.setdefault(name, [])
-    desc = CFunctionDescription(
+    desc = PrimitiveDescription(
         name,
         arg_types,
         return_type,
@@ -137,6 +142,7 @@ def method_op(
         ordering,
         extra_int_constants,
         priority,
+        is_pure=is_pure,
     )
     ops.append(desc)
     return desc
@@ -151,12 +157,12 @@ def function_op(
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
-) -> CFunctionDescription:
-    """Define a c function call op that replaces a function call.
+) -> PrimitiveDescription:
+    """Define a C function call op that replaces a function call.
 
     This will be automatically generated by matching against the AST.
 
@@ -166,20 +172,23 @@ def function_op(
         name: full name of the function
         arg_types: positional argument types for which this applies
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = function_ops.setdefault(name, [])
-    desc = CFunctionDescription(
+    desc = PrimitiveDescription(
         name,
         arg_types,
         return_type,
-        var_arg_type,
-        truncated_type,
-        c_function_name,
-        error_kind,
-        steals,
-        is_borrowed,
-        ordering,
-        extra_int_constants,
-        priority,
+        var_arg_type=var_arg_type,
+        truncated_type=truncated_type,
+        c_function_name=c_function_name,
+        error_kind=error_kind,
+        steals=steals,
+        is_borrowed=is_borrowed,
+        ordering=ordering,
+        extra_int_constants=extra_int_constants,
+        priority=priority,
+        is_pure=False,
     )
     ops.append(desc)
     return desc
@@ -189,16 +198,17 @@ def binary_op(
     name: str,
     arg_types: list[RType],
     return_type: RType,
-    c_function_name: str,
     error_kind: int,
+    c_function_name: str | None = None,
+    primitive_name: str | None = None,
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
-) -> CFunctionDescription:
+) -> PrimitiveDescription:
     """Define a c function call op for a binary operation.
 
     This will be automatically generated by matching against the AST.
@@ -206,20 +216,25 @@ def binary_op(
     Most arguments are similar to method_op(), but exactly two argument types
     are expected.
     """
+    assert c_function_name is not None or primitive_name is not None
+    assert not (c_function_name is not None and primitive_name is not None)
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = binary_ops.setdefault(name, [])
-    desc = CFunctionDescription(
-        name,
-        arg_types,
-        return_type,
-        var_arg_type,
-        truncated_type,
-        c_function_name,
-        error_kind,
-        steals,
-        is_borrowed,
-        ordering,
-        extra_int_constants,
-        priority,
+    desc = PrimitiveDescription(
+        name=primitive_name or name,
+        arg_types=arg_types,
+        return_type=return_type,
+        var_arg_type=var_arg_type,
+        truncated_type=truncated_type,
+        c_function_name=c_function_name,
+        error_kind=error_kind,
+        steals=steals,
+        is_borrowed=is_borrowed,
+        ordering=ordering,
+        extra_int_constants=extra_int_constants,
+        priority=priority,
+        is_pure=False,
     )
     ops.append(desc)
     return desc
@@ -233,14 +248,18 @@ def custom_op(
     var_arg_type: RType | None = None,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
+    *,
+    is_pure: bool = False,
 ) -> CFunctionDescription:
     """Create a one-off CallC op that can't be automatically generated from the AST.
 
     Most arguments are similar to method_op().
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     return CFunctionDescription(
         "<custom>",
         arg_types,
@@ -254,6 +273,44 @@ def custom_op(
         ordering,
         extra_int_constants,
         0,
+        is_pure=is_pure,
+    )
+
+
+def custom_primitive_op(
+    name: str,
+    arg_types: list[RType],
+    return_type: RType,
+    error_kind: int,
+    c_function_name: str | None = None,
+    var_arg_type: RType | None = None,
+    truncated_type: RType | None = None,
+    ordering: list[int] | None = None,
+    extra_int_constants: list[tuple[int, RType]] | None = None,
+    steals: StealsDescription = False,
+    is_borrowed: bool = False,
+    is_pure: bool = False,
+) -> PrimitiveDescription:
+    """Define a primitive op that can't be automatically generated based on the AST.
+
+    Most arguments are similar to method_op().
+    """
+    if extra_int_constants is None:
+        extra_int_constants = []
+    return PrimitiveDescription(
+        name=name,
+        arg_types=arg_types,
+        return_type=return_type,
+        var_arg_type=var_arg_type,
+        truncated_type=truncated_type,
+        c_function_name=c_function_name,
+        error_kind=error_kind,
+        steals=steals,
+        is_borrowed=is_borrowed,
+        ordering=ordering,
+        extra_int_constants=extra_int_constants,
+        priority=0,
+        is_pure=is_pure,
     )
 
 
@@ -265,32 +322,36 @@ def unary_op(
     error_kind: int,
     truncated_type: RType | None = None,
     ordering: list[int] | None = None,
-    extra_int_constants: list[tuple[int, RType]] = [],
+    extra_int_constants: list[tuple[int, RType]] | None = None,
     steals: StealsDescription = False,
     is_borrowed: bool = False,
     priority: int = 1,
-) -> CFunctionDescription:
-    """Define a c function call op for an unary operation.
+    is_pure: bool = False,
+) -> PrimitiveDescription:
+    """Define a primitive op for an unary operation.
 
     This will be automatically generated by matching against the AST.
 
     Most arguments are similar to method_op(), but exactly one argument type
     is expected.
     """
+    if extra_int_constants is None:
+        extra_int_constants = []
     ops = unary_ops.setdefault(name, [])
-    desc = CFunctionDescription(
+    desc = PrimitiveDescription(
         name,
         [arg_type],
         return_type,
-        None,
-        truncated_type,
-        c_function_name,
-        error_kind,
-        steals,
-        is_borrowed,
-        ordering,
-        extra_int_constants,
-        priority,
+        var_arg_type=None,
+        truncated_type=truncated_type,
+        c_function_name=c_function_name,
+        error_kind=error_kind,
+        steals=steals,
+        is_borrowed=is_borrowed,
+        ordering=ordering,
+        extra_int_constants=extra_int_constants,
+        priority=priority,
+        is_pure=is_pure,
     )
     ops.append(desc)
     return desc
@@ -302,11 +363,10 @@ def load_address_op(name: str, type: RType, src: str) -> LoadAddressDescription:
     return LoadAddressDescription(name, type, src)
 
 
+# Import various modules that set up global state.
 import mypyc.primitives.bytes_ops
 import mypyc.primitives.dict_ops
 import mypyc.primitives.float_ops
-
-# Import various modules that set up global state.
 import mypyc.primitives.int_ops
 import mypyc.primitives.list_ops
 import mypyc.primitives.misc_ops
diff --git a/mypyc/primitives/set_ops.py b/mypyc/primitives/set_ops.py
index fcfb7847dc7d..eb7c9b46609d 100644
--- a/mypyc/primitives/set_ops.py
+++ b/mypyc/primitives/set_ops.py
@@ -1,4 +1,4 @@
-"""Primitive set (and frozenset) ops."""
+"""Primitive set and frozenset ops."""
 
 from __future__ import annotations
 
@@ -7,6 +7,7 @@
     bit_rprimitive,
     bool_rprimitive,
     c_int_rprimitive,
+    frozenset_rprimitive,
     object_rprimitive,
     pointer_rprimitive,
     set_rprimitive,
@@ -22,7 +23,7 @@
 # Get the 'builtins.set' type object.
 load_address_op(name="builtins.set", type=object_rprimitive, src="PySet_Type")
 
-# Get the 'builtins.frozenset' tyoe object.
+# Get the 'builtins.frozenset' type object.
 load_address_op(name="builtins.frozenset", type=object_rprimitive, src="PyFrozenSet_Type")
 
 # Construct an empty set.
@@ -44,11 +45,21 @@
     error_kind=ERR_MAGIC,
 )
 
+# Construct an empty frozenset
+function_op(
+    name="builtins.frozenset",
+    arg_types=[],
+    return_type=frozenset_rprimitive,
+    c_function_name="PyFrozenSet_New",
+    error_kind=ERR_MAGIC,
+    extra_int_constants=[(0, pointer_rprimitive)],
+)
+
 # frozenset(obj)
 function_op(
     name="builtins.frozenset",
     arg_types=[object_rprimitive],
-    return_type=object_rprimitive,
+    return_type=frozenset_rprimitive,
     c_function_name="PyFrozenSet_New",
     error_kind=ERR_MAGIC,
 )
@@ -64,6 +75,17 @@
     ordering=[1, 0],
 )
 
+# item in frozenset
+binary_op(
+    name="in",
+    arg_types=[object_rprimitive, frozenset_rprimitive],
+    return_type=c_int_rprimitive,
+    c_function_name="PySet_Contains",
+    error_kind=ERR_NEG_INT,
+    truncated_type=bool_rprimitive,
+    ordering=[1, 0],
+)
+
 # set.remove(obj)
 method_op(
     name="remove",
diff --git a/mypyc/primitives/str_ops.py b/mypyc/primitives/str_ops.py
index 2ff1fbdb4b3e..ded339b9672c 100644
--- a/mypyc/primitives/str_ops.py
+++ b/mypyc/primitives/str_ops.py
@@ -15,6 +15,7 @@
     object_rprimitive,
     pointer_rprimitive,
     str_rprimitive,
+    tuple_rprimitive,
 )
 from mypyc.primitives.registry import (
     ERR_NEG_INT,
@@ -37,6 +38,15 @@
     error_kind=ERR_MAGIC,
 )
 
+# repr(obj)
+function_op(
+    name="builtins.repr",
+    arg_types=[object_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="PyObject_Repr",
+    error_kind=ERR_MAGIC,
+)
+
 # str1 + str2
 binary_op(
     name="+",
@@ -83,6 +93,40 @@
     error_kind=ERR_MAGIC,
 )
 
+# item in str
+binary_op(
+    name="in",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=c_int_rprimitive,
+    c_function_name="PyUnicode_Contains",
+    error_kind=ERR_NEG_INT,
+    truncated_type=bool_rprimitive,
+    ordering=[1, 0],
+)
+
+# str.find(...) and str.rfind(...)
+str_find_types: list[RType] = [str_rprimitive, str_rprimitive, int_rprimitive, int_rprimitive]
+str_find_functions = ["CPyStr_Find", "CPyStr_Find", "CPyStr_FindWithEnd"]
+str_find_constants: list[list[tuple[int, RType]]] = [[(0, c_int_rprimitive)], [], []]
+str_rfind_constants: list[list[tuple[int, RType]]] = [[(0, c_int_rprimitive)], [], []]
+for i in range(len(str_find_types) - 1):
+    method_op(
+        name="find",
+        arg_types=str_find_types[0 : i + 2],
+        return_type=int_rprimitive,
+        c_function_name=str_find_functions[i],
+        extra_int_constants=str_find_constants[i] + [(1, c_int_rprimitive)],
+        error_kind=ERR_MAGIC,
+    )
+    method_op(
+        name="rfind",
+        arg_types=str_find_types[0 : i + 2],
+        return_type=int_rprimitive,
+        c_function_name=str_find_functions[i],
+        extra_int_constants=str_rfind_constants[i] + [(-1, c_int_rprimitive)],
+        error_kind=ERR_MAGIC,
+    )
+
 # str.join(obj)
 method_op(
     name="join",
@@ -100,27 +144,85 @@
     var_arg_type=str_rprimitive,
 )
 
+# str.strip, str.lstrip, str.rstrip
+for strip_prefix in ["l", "r", ""]:
+    method_op(
+        name=f"{strip_prefix}strip",
+        arg_types=[str_rprimitive, str_rprimitive],
+        return_type=str_rprimitive,
+        c_function_name=f"CPyStr_{strip_prefix.upper()}Strip",
+        error_kind=ERR_NEVER,
+    )
+    method_op(
+        name=f"{strip_prefix}strip",
+        arg_types=[str_rprimitive],
+        return_type=str_rprimitive,
+        c_function_name=f"CPyStr_{strip_prefix.upper()}Strip",
+        # This 0 below is implicitly treated as NULL in C.
+        extra_int_constants=[(0, c_int_rprimitive)],
+        error_kind=ERR_NEVER,
+    )
+
 # str.startswith(str)
 method_op(
     name="startswith",
     arg_types=[str_rprimitive, str_rprimitive],
-    return_type=bool_rprimitive,
+    return_type=c_int_rprimitive,
     c_function_name="CPyStr_Startswith",
+    truncated_type=bool_rprimitive,
     error_kind=ERR_NEVER,
 )
 
+# str.startswith(tuple)
+method_op(
+    name="startswith",
+    arg_types=[str_rprimitive, tuple_rprimitive],
+    return_type=bool_rprimitive,
+    c_function_name="CPyStr_Startswith",
+    error_kind=ERR_MAGIC,
+)
+
 # str.endswith(str)
 method_op(
     name="endswith",
     arg_types=[str_rprimitive, str_rprimitive],
+    return_type=c_int_rprimitive,
+    c_function_name="CPyStr_Endswith",
+    truncated_type=bool_rprimitive,
+    error_kind=ERR_NEVER,
+)
+
+# str.endswith(tuple)
+method_op(
+    name="endswith",
+    arg_types=[str_rprimitive, tuple_rprimitive],
     return_type=bool_rprimitive,
     c_function_name="CPyStr_Endswith",
+    error_kind=ERR_MAGIC,
+)
+
+# str.removeprefix(str)
+method_op(
+    name="removeprefix",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPyStr_Removeprefix",
     error_kind=ERR_NEVER,
 )
 
-# str.split(...)
+# str.removesuffix(str)
+method_op(
+    name="removesuffix",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=str_rprimitive,
+    c_function_name="CPyStr_Removesuffix",
+    error_kind=ERR_NEVER,
+)
+
+# str.split(...) and str.rsplit(...)
 str_split_types: list[RType] = [str_rprimitive, str_rprimitive, int_rprimitive]
 str_split_functions = ["PyUnicode_Split", "PyUnicode_Split", "CPyStr_Split"]
+str_rsplit_functions = ["PyUnicode_RSplit", "PyUnicode_RSplit", "CPyStr_RSplit"]
 str_split_constants: list[list[tuple[int, RType]]] = [
     [(0, pointer_rprimitive), (-1, c_int_rprimitive)],
     [(-1, c_int_rprimitive)],
@@ -135,6 +237,45 @@
         extra_int_constants=str_split_constants[i],
         error_kind=ERR_MAGIC,
     )
+    method_op(
+        name="rsplit",
+        arg_types=str_split_types[0 : i + 1],
+        return_type=list_rprimitive,
+        c_function_name=str_rsplit_functions[i],
+        extra_int_constants=str_split_constants[i],
+        error_kind=ERR_MAGIC,
+    )
+
+# str.splitlines(...)
+str_splitlines_types: list[RType] = [str_rprimitive, bool_rprimitive]
+str_splitlines_constants: list[list[tuple[int, RType]]] = [[(0, c_int_rprimitive)], []]
+for i in range(2):
+    method_op(
+        name="splitlines",
+        arg_types=str_splitlines_types[0 : i + 1],
+        return_type=list_rprimitive,
+        c_function_name="PyUnicode_Splitlines",
+        extra_int_constants=str_splitlines_constants[i],
+        error_kind=ERR_NEVER,
+    )
+
+# str.partition(str)
+method_op(
+    name="partition",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="PyUnicode_Partition",
+    error_kind=ERR_MAGIC,
+)
+
+# str.rpartition(str)
+method_op(
+    name="rpartition",
+    arg_types=[str_rprimitive, str_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="PyUnicode_RPartition",
+    error_kind=ERR_MAGIC,
+)
 
 # str.replace(old, new)
 method_op(
@@ -219,6 +360,30 @@
     extra_int_constants=[(0, pointer_rprimitive)],
 )
 
+# str.encode(encoding) - utf8 strict specialization
+str_encode_utf8_strict = custom_op(
+    arg_types=[str_rprimitive],
+    return_type=bytes_rprimitive,
+    c_function_name="PyUnicode_AsUTF8String",
+    error_kind=ERR_MAGIC,
+)
+
+# str.encode(encoding) - ascii strict specialization
+str_encode_ascii_strict = custom_op(
+    arg_types=[str_rprimitive],
+    return_type=bytes_rprimitive,
+    c_function_name="PyUnicode_AsASCIIString",
+    error_kind=ERR_MAGIC,
+)
+
+# str.encode(encoding) - latin1 strict specialization
+str_encode_latin1_strict = custom_op(
+    arg_types=[str_rprimitive],
+    return_type=bytes_rprimitive,
+    c_function_name="PyUnicode_AsLatin1String",
+    error_kind=ERR_MAGIC,
+)
+
 # str.encode(encoding, errors)
 method_op(
     name="encode",
@@ -227,3 +392,11 @@
     c_function_name="CPy_Encode",
     error_kind=ERR_MAGIC,
 )
+
+function_op(
+    name="builtins.ord",
+    arg_types=[str_rprimitive],
+    return_type=int_rprimitive,
+    c_function_name="CPyStr_Ord",
+    error_kind=ERR_MAGIC,
+)
diff --git a/mypyc/primitives/tuple_ops.py b/mypyc/primitives/tuple_ops.py
index 0ea0243dc18b..a9bbaa80fb5c 100644
--- a/mypyc/primitives/tuple_ops.py
+++ b/mypyc/primitives/tuple_ops.py
@@ -15,7 +15,7 @@
     object_rprimitive,
     tuple_rprimitive,
 )
-from mypyc.primitives.registry import custom_op, function_op, load_address_op, method_op
+from mypyc.primitives.registry import binary_op, custom_op, function_op, load_address_op, method_op
 
 # Get the 'builtins.tuple' type object.
 load_address_op(name="builtins.tuple", type=object_rprimitive, src="PyTuple_Type")
@@ -74,6 +74,33 @@
     error_kind=ERR_MAGIC,
 )
 
+# tuple + tuple
+binary_op(
+    name="+",
+    arg_types=[tuple_rprimitive, tuple_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="PySequence_Concat",
+    error_kind=ERR_MAGIC,
+)
+
+# tuple * int
+binary_op(
+    name="*",
+    arg_types=[tuple_rprimitive, int_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="CPySequence_Multiply",
+    error_kind=ERR_MAGIC,
+)
+
+# int * tuple
+binary_op(
+    name="*",
+    arg_types=[int_rprimitive, tuple_rprimitive],
+    return_type=tuple_rprimitive,
+    c_function_name="CPySequence_RMultiply",
+    error_kind=ERR_MAGIC,
+)
+
 # tuple[begin:end]
 tuple_slice_op = custom_op(
     arg_types=[tuple_rprimitive, int_rprimitive, int_rprimitive],
diff --git a/mypyc/py.typed b/mypyc/py.typed
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/mypyc/test-data/alwaysdefined.test b/mypyc/test-data/alwaysdefined.test
index e8c44d8fc548..ecbc8c410d6d 100644
--- a/mypyc/test-data/alwaysdefined.test
+++ b/mypyc/test-data/alwaysdefined.test
@@ -166,8 +166,7 @@ IfConditionalAndNonConditional1: [x]
 IfConditionalAndNonConditional2: []
 
 [case testAlwaysDefinedExpressions]
-from typing import Dict, List, Set, Optional, cast
-from typing_extensions import Final
+from typing import Dict, Final, List, Set, Optional, cast
 
 import other
 
@@ -307,7 +306,7 @@ def f() -> int:
 
 [file other.py]
 # Not compiled
-from typing_extensions import Final
+from typing import Final
 
 Y: Final = 3
 
diff --git a/mypyc/test-data/analysis.test b/mypyc/test-data/analysis.test
index efd219cc222a..35677b8ea56d 100644
--- a/mypyc/test-data/analysis.test
+++ b/mypyc/test-data/analysis.test
@@ -10,40 +10,27 @@ def f(a: int) -> None:
 [out]
 def f(a):
     a, x :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
+    r0 :: bit
     y, z :: int
 L0:
     x = 2
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_eq x, a
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = CPyTagged_IsEq_(x, a)
-    if r2 goto L3 else goto L4 :: bool
-L2:
-    r3 = x == a
-    if r3 goto L3 else goto L4 :: bool
-L3:
     y = 2
-    goto L5
-L4:
+    goto L3
+L2:
     z = 2
-L5:
+L3:
     return 1
 (0, 0)   {a}                     {a, x}
 (0, 1)   {a, x}                  {a, x}
 (0, 2)   {a, x}                  {a, x}
-(0, 3)   {a, x}                  {a, x}
-(1, 0)   {a, x}                  {a, x}
-(1, 1)   {a, x}                  {a, x}
-(2, 0)   {a, x}                  {a, x}
-(2, 1)   {a, x}                  {a, x}
-(3, 0)   {a, x}                  {a, x, y}
-(3, 1)   {a, x, y}               {a, x, y}
-(4, 0)   {a, x}                  {a, x, z}
-(4, 1)   {a, x, z}               {a, x, z}
-(5, 0)   {a, x, y, z}            {a, x, y, z}
+(1, 0)   {a, x}                  {a, x, y}
+(1, 1)   {a, x, y}               {a, x, y}
+(2, 0)   {a, x}                  {a, x, z}
+(2, 1)   {a, x, z}               {a, x, z}
+(3, 0)   {a, x, y, z}            {a, x, y, z}
 
 [case testSimple_Liveness]
 def f(a: int) -> int:
@@ -58,7 +45,7 @@ def f(a):
     r0 :: bit
 L0:
     x = 2
-    r0 = x == 2
+    r0 = int_eq x, 2
     if r0 goto L1 else goto L2 :: bool
 L1:
     return a
@@ -124,7 +111,7 @@ def f(a):
     r0 :: bit
     y, x :: int
 L0:
-    r0 = a == 2
+    r0 = int_eq a, 2
     if r0 goto L1 else goto L2 :: bool
 L1:
     y = 2
@@ -161,40 +148,27 @@ def f(n: int) -> None:
 [out]
 def f(n):
     n :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    r4, m :: int
+    r0 :: bit
+    r1, m :: int
 L0:
 L1:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L3 :: bool
+    r0 = int_lt n, 10
+    if r0 goto L2 else goto L3 :: bool
 L2:
-    r2 = CPyTagged_IsLt_(n, 10)
-    if r2 goto L4 else goto L5 :: bool
-L3:
-    r3 = n < 10 :: signed
-    if r3 goto L4 else goto L5 :: bool
-L4:
-    r4 = CPyTagged_Add(n, 2)
-    n = r4
+    r1 = CPyTagged_Add(n, 2)
+    n = r1
     m = n
     goto L1
-L5:
+L3:
     return 1
 (0, 0)   {n}                     {n}
 (1, 0)   {n}                     {n}
 (1, 1)   {n}                     {n}
-(1, 2)   {n}                     {n}
 (2, 0)   {n}                     {n}
 (2, 1)   {n}                     {n}
+(2, 2)   {n}                     {m, n}
+(2, 3)   {m, n}                  {m, n}
 (3, 0)   {n}                     {n}
-(3, 1)   {n}                     {n}
-(4, 0)   {n}                     {n}
-(4, 1)   {n}                     {n}
-(4, 2)   {n}                     {m, n}
-(4, 3)   {m, n}                  {m, n}
-(5, 0)   {n}                     {n}
 
 [case testMultiPass_Liveness]
 def f(n: int) -> None:
@@ -208,67 +182,40 @@ def f(n: int) -> None:
 [out]
 def f(n):
     n, x, y :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
+    r0, r1 :: bit
 L0:
     x = 2
     y = 2
 L1:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L3 :: bool
+    r0 = int_lt n, 2
+    if r0 goto L2 else goto L6 :: bool
 L2:
-    r2 = CPyTagged_IsLt_(n, 2)
-    if r2 goto L4 else goto L10 :: bool
+    n = y
 L3:
-    r3 = n < 2 :: signed
-    if r3 goto L4 else goto L10 :: bool
+    r1 = int_lt n, 4
+    if r1 goto L4 else goto L5 :: bool
 L4:
-    n = y
-L5:
-    r4 = n & 1
-    r5 = r4 != 0
-    if r5 goto L6 else goto L7 :: bool
-L6:
-    r6 = CPyTagged_IsLt_(n, 4)
-    if r6 goto L8 else goto L9 :: bool
-L7:
-    r7 = n < 4 :: signed
-    if r7 goto L8 else goto L9 :: bool
-L8:
     n = 2
     n = x
-    goto L5
-L9:
+    goto L3
+L5:
     goto L1
-L10:
+L6:
     return 1
 (0, 0)   {n}                     {n, x}
 (0, 1)   {n, x}                  {n, x, y}
 (0, 2)   {n, x, y}               {n, x, y}
-(1, 0)   {n, x, y}               {n, r0, x, y}
-(1, 1)   {n, r0, x, y}           {n, r1, x, y}
-(1, 2)   {n, r1, x, y}           {n, x, y}
-(2, 0)   {n, x, y}               {r2, x, y}
-(2, 1)   {r2, x, y}              {x, y}
-(3, 0)   {n, x, y}               {r3, x, y}
-(3, 1)   {r3, x, y}              {x, y}
-(4, 0)   {x, y}                  {n, x, y}
-(4, 1)   {n, x, y}               {n, x, y}
-(5, 0)   {n, x, y}               {n, r4, x, y}
-(5, 1)   {n, r4, x, y}           {n, r5, x, y}
-(5, 2)   {n, r5, x, y}           {n, x, y}
-(6, 0)   {n, x, y}               {n, r6, x, y}
-(6, 1)   {n, r6, x, y}           {n, x, y}
-(7, 0)   {n, x, y}               {n, r7, x, y}
-(7, 1)   {n, r7, x, y}           {n, x, y}
-(8, 0)   {x, y}                  {x, y}
-(8, 1)   {x, y}                  {n, x, y}
-(8, 2)   {n, x, y}               {n, x, y}
-(9, 0)   {n, x, y}               {n, x, y}
-(10, 0)  {}                      {}
+(1, 0)   {n, x, y}               {r0, x, y}
+(1, 1)   {r0, x, y}              {x, y}
+(2, 0)   {x, y}                  {n, x, y}
+(2, 1)   {n, x, y}               {n, x, y}
+(3, 0)   {n, x, y}               {n, r1, x, y}
+(3, 1)   {n, r1, x, y}           {n, x, y}
+(4, 0)   {x, y}                  {x, y}
+(4, 1)   {x, y}                  {n, x, y}
+(4, 2)   {n, x, y}               {n, x, y}
+(5, 0)   {n, x, y}               {n, x, y}
+(6, 0)   {}                      {}
 
 [case testCall_Liveness]
 def f(x: int) -> int:
@@ -309,80 +256,35 @@ def f(a: int) -> None:
 [out]
 def f(a):
     a :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: native_int
-    r7 :: bit
-    r8 :: native_int
-    r9, r10, r11 :: bit
+    r0, r1 :: bit
     y, x :: int
 L0:
 L1:
-    r0 = a & 1
-    r1 = r0 != 0
-    if r1 goto L3 else goto L2 :: bool
+    r0 = int_lt a, a
+    if r0 goto L2 else goto L6 :: bool
 L2:
-    r2 = a & 1
-    r3 = r2 != 0
-    if r3 goto L3 else goto L4 :: bool
 L3:
-    r4 = CPyTagged_IsLt_(a, a)
-    if r4 goto L5 else goto L12 :: bool
+    r1 = int_lt a, a
+    if r1 goto L4 else goto L5 :: bool
 L4:
-    r5 = a < a :: signed
-    if r5 goto L5 else goto L12 :: bool
-L5:
-L6:
-    r6 = a & 1
-    r7 = r6 != 0
-    if r7 goto L8 else goto L7 :: bool
-L7:
-    r8 = a & 1
-    r9 = r8 != 0
-    if r9 goto L8 else goto L9 :: bool
-L8:
-    r10 = CPyTagged_IsLt_(a, a)
-    if r10 goto L10 else goto L11 :: bool
-L9:
-    r11 = a < a :: signed
-    if r11 goto L10 else goto L11 :: bool
-L10:
     y = a
-    goto L6
-L11:
+    goto L3
+L5:
     x = a
     goto L1
-L12:
+L6:
     return 1
 (0, 0)   {a}                     {a}
 (1, 0)   {a, x, y}               {a, x, y}
 (1, 1)   {a, x, y}               {a, x, y}
-(1, 2)   {a, x, y}               {a, x, y}
 (2, 0)   {a, x, y}               {a, x, y}
-(2, 1)   {a, x, y}               {a, x, y}
-(2, 2)   {a, x, y}               {a, x, y}
 (3, 0)   {a, x, y}               {a, x, y}
 (3, 1)   {a, x, y}               {a, x, y}
 (4, 0)   {a, x, y}               {a, x, y}
 (4, 1)   {a, x, y}               {a, x, y}
 (5, 0)   {a, x, y}               {a, x, y}
+(5, 1)   {a, x, y}               {a, x, y}
 (6, 0)   {a, x, y}               {a, x, y}
-(6, 1)   {a, x, y}               {a, x, y}
-(6, 2)   {a, x, y}               {a, x, y}
-(7, 0)   {a, x, y}               {a, x, y}
-(7, 1)   {a, x, y}               {a, x, y}
-(7, 2)   {a, x, y}               {a, x, y}
-(8, 0)   {a, x, y}               {a, x, y}
-(8, 1)   {a, x, y}               {a, x, y}
-(9, 0)   {a, x, y}               {a, x, y}
-(9, 1)   {a, x, y}               {a, x, y}
-(10, 0)  {a, x, y}               {a, x, y}
-(10, 1)  {a, x, y}               {a, x, y}
-(11, 0)  {a, x, y}               {a, x, y}
-(11, 1)  {a, x, y}               {a, x, y}
-(12, 0)  {a, x, y}               {a, x, y}
 
 [case testTrivial_BorrowedArgument]
 def f(a: int, b: int) -> int:
@@ -421,40 +323,27 @@ def f(a: int) -> int:
 [out]
 def f(a):
     a :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
+    r0 :: bit
     x :: int
 L0:
-    r0 = a & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_eq a, a
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = CPyTagged_IsEq_(a, a)
-    if r2 goto L3 else goto L4 :: bool
-L2:
-    r3 = a == a
-    if r3 goto L3 else goto L4 :: bool
-L3:
     x = 4
     a = 2
-    goto L5
-L4:
+    goto L3
+L2:
     x = 2
-L5:
+L3:
     return x
 (0, 0)   {a}                     {a}
 (0, 1)   {a}                     {a}
-(0, 2)   {a}                     {a}
 (1, 0)   {a}                     {a}
-(1, 1)   {a}                     {a}
+(1, 1)   {a}                     {}
+(1, 2)   {}                      {}
 (2, 0)   {a}                     {a}
 (2, 1)   {a}                     {a}
-(3, 0)   {a}                     {a}
-(3, 1)   {a}                     {}
-(3, 2)   {}                      {}
-(4, 0)   {a}                     {a}
-(4, 1)   {a}                     {a}
-(5, 0)   {}                      {}
+(3, 0)   {}                      {}
 
 [case testLoop_BorrowedArgument]
 def f(a: int) -> int:
@@ -467,55 +356,33 @@ def f(a: int) -> int:
 [out]
 def f(a):
     a, sum, i :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6, r7 :: int
+    r0 :: bit
+    r1, r2 :: int
 L0:
     sum = 0
     i = 0
 L1:
-    r0 = i & 1
-    r1 = r0 != 0
-    if r1 goto L3 else goto L2 :: bool
+    r0 = int_le i, a
+    if r0 goto L2 else goto L3 :: bool
 L2:
-    r2 = a & 1
-    r3 = r2 != 0
-    if r3 goto L3 else goto L4 :: bool
-L3:
-    r4 = CPyTagged_IsLt_(a, i)
-    if r4 goto L6 else goto L5 :: bool
-L4:
-    r5 = i <= a :: signed
-    if r5 goto L5 else goto L6 :: bool
-L5:
-    r6 = CPyTagged_Add(sum, i)
-    sum = r6
-    r7 = CPyTagged_Add(i, 2)
-    i = r7
+    r1 = CPyTagged_Add(sum, i)
+    sum = r1
+    r2 = CPyTagged_Add(i, 2)
+    i = r2
     goto L1
-L6:
+L3:
     return sum
 (0, 0)   {a}                     {a}
 (0, 1)   {a}                     {a}
 (0, 2)   {a}                     {a}
 (1, 0)   {a}                     {a}
 (1, 1)   {a}                     {a}
-(1, 2)   {a}                     {a}
 (2, 0)   {a}                     {a}
 (2, 1)   {a}                     {a}
 (2, 2)   {a}                     {a}
+(2, 3)   {a}                     {a}
+(2, 4)   {a}                     {a}
 (3, 0)   {a}                     {a}
-(3, 1)   {a}                     {a}
-(4, 0)   {a}                     {a}
-(4, 1)   {a}                     {a}
-(5, 0)   {a}                     {a}
-(5, 1)   {a}                     {a}
-(5, 2)   {a}                     {a}
-(5, 3)   {a}                     {a}
-(5, 4)   {a}                     {a}
-(6, 0)   {a}                     {a}
 
 [case testError]
 def f(x: List[int]) -> None: pass # E: Name "List" is not defined \
diff --git a/mypyc/test-data/annotate-basic.test b/mypyc/test-data/annotate-basic.test
new file mode 100644
index 000000000000..c9e1c4b64a32
--- /dev/null
+++ b/mypyc/test-data/annotate-basic.test
@@ -0,0 +1,477 @@
+[case testAnnotateNonNativeAttribute]
+from typing import Any
+
+def f1(x):
+    return x.foo  # A: Get non-native attribute "foo".
+
+def f2(x: Any) -> object:
+    return x.foo  # A: Get non-native attribute "foo".
+
+def f3(x):
+    x.bar = 1  # A: Set non-native attribute "bar".
+
+class C:
+    foo: int
+
+    def method(self) -> int:
+        return self.foo
+
+def good1(x: C) -> int:
+    return x.foo
+
+[case testAnnotateMethod]
+class C:
+    def method(self, x):
+        return x + "y"  # A: Generic "+" operation.
+
+[case testAnnotateGenericBinaryOperations]
+def generic_add(x):
+    return x + 1  # A: Generic "+" operation.
+
+def generic_sub(x):
+    return x - 1  # A: Generic "-" operation.
+
+def generic_mul(x):
+    return x * 1  # A: Generic "*" operation.
+
+def generic_div(x):
+    return x / 1  # A: Generic "/" operation.
+
+def generic_floor_div(x):
+    return x // 1  # A: Generic "//" operation.
+
+def generic_unary_plus(x):
+    return +x  # A: Generic unary "+" operation.
+
+def generic_unary_minus(x):
+    return -x  # A: Generic unary "-" operation.
+
+def native_int_ops(x: int, y: int) -> int:
+    a = x + 1 - y
+    return x * a // y
+
+[case testAnnotateGenericBitwiseOperations]
+def generic_and(x):
+    return x & 1  # A: Generic "&" operation.
+
+def generic_or(x):
+    return x | 1  # A: Generic "|" operation.
+
+def generic_xor(x):
+    return x ^ 1  # A: Generic "^" operation.
+
+def generic_left_shift(x):
+    return x << 1  # A: Generic "<<" operation.
+
+def generic_right_shift(x):
+    return x >> 1  # A: Generic ">>" operation.
+
+def generic_invert(x):
+    return ~x  # A: Generic "~" operation.
+
+def native_int_ops(x: int, y: int) -> int:
+    a = (x & 1) << y
+    return (x | a) >> (y ^ 1)
+
+[case testAnnotateGenericComparisonOperations]
+def generic_eq(x, y):
+    return x == y  # A: Generic comparison operation.
+
+def generic_ne(x, y):
+    return x != y  # A: Generic comparison operation.
+
+def generic_lt(x, y):
+    return x < y  # A: Generic comparison operation.
+
+def generic_le(x, y):
+    return x <= y  # A: Generic comparison operation.
+
+def generic_gt(x, y):
+    return x > y  # A: Generic comparison operation.
+
+def generic_ge(x, y):
+    return x >= y  # A: Generic comparison operation.
+
+def int_comparisons(x: int, y: int) -> int:
+    if x == y:
+        return 0
+    if x < y:
+        return 1
+    if x > y:
+        return 2
+    return 3
+
+[case testAnnotateTwoOperationsOnLine]
+def f(x):
+    return x.foo + 1  # A: Get non-native attribute "foo". Generic "+" operation.
+
+[case testAnnotateNonNativeMethod]
+from typing import Any
+
+def f1(x):
+    return x.foo()  # A: Call non-native method "foo" (it may be defined in a non-native class, or decorated).
+
+def f2(x: Any) -> None:
+    x.foo(1)  # A: Call non-native method "foo" (it may be defined in a non-native class, or decorated).
+    x.foo(a=1)  # A: Call non-native method "foo" (it may be defined in a non-native class, or decorated).
+    t = (1, 'x')
+    x.foo(*t)  # A: Get non-native attribute "foo". Generic call operation.
+    d = {"a": 1}
+    x.foo(*d)  # A: Get non-native attribute "foo". Generic call operation.
+
+class C:
+    def foo(self) -> int:
+        return 0
+
+def g(c: C) -> int:
+    return c.foo()
+
+[case testAnnotateGlobalVariableAccess]
+from typing import Final
+import nonnative
+
+x = 0
+y: Final = 0
+
+def read() -> int:
+    return x  # A: Access global "x" through namespace dictionary (hint: access is faster if you can make it Final).
+
+def assign(a: int) -> None:
+    global x
+    x = a  # A: Access global "x" through namespace dictionary (hint: access is faster if you can make it Final).
+
+def read_final() -> int:
+    return y
+
+def read_nonnative() -> int:
+    return nonnative.z  # A: Get non-native attribute "z".
+
+[file nonnative.py]
+z = 2
+
+[case testAnnotateNestedFunction]
+def f1() -> None:
+    def g() -> None:  # A: A nested function object is allocated each time statement is executed. A module-level function would be faster.
+        pass
+
+    g()
+
+def f2() -> int:
+    l = lambda: 1  # A: A new object is allocated for lambda each time it is evaluated. A module-level function would be faster.
+    return l()
+
+[case testAnnotateGetSetItem]
+from typing import List, Dict
+
+def f1(x, y):
+    return x[y]  # A: Generic indexing operation.
+
+def f2(x, y, z):
+    x[y] = z  # A: Generic indexed assignment.
+
+def list_get_item(x: List[int], y: int) -> int:
+    return x[y]
+
+def list_set_item(x: List[int], y: int) -> None:
+    x[y] = 5
+
+def dict_get_item(d: Dict[str, str]) -> str:
+    return d['x']
+
+def dict_set_item(d: Dict[str, str]) -> None:
+    d['x'] = 'y'
+
+[case testAnnotateStrMethods]
+def startswith(x: str) -> bool:
+    return x.startswith('foo')
+
+def islower(x: str) -> bool:
+    return x.islower()  # A: Call non-native method "islower" (it may be defined in a non-native class, or decorated).
+
+[case testAnnotateSpecificStdlibFeatures]
+import functools
+import itertools
+from functools import partial
+from itertools import chain, groupby, islice
+
+def f(x: int, y: int) -> None: pass
+
+def use_partial1() -> None:
+    p = partial(f, 1)  # A: "functools.partial" is inefficient in compiled code.
+    p(2)
+
+def use_partial2() -> None:
+    p = functools.partial(f, 1)  # A: "functools.partial" is inefficient in compiled code.
+    p(2)
+
+def use_chain1() -> None:
+    for x in chain([1, 3], [4, 5]):  # A: "itertools.chain" is inefficient in compiled code (hint: replace with for loops).
+        pass
+
+def use_chain2() -> None:
+    for x in itertools.chain([1, 3], [4, 5]):  # A: "itertools.chain" is inefficient in compiled code (hint: replace with for loops).
+        pass
+
+def use_groupby1() -> None:
+    for a, b in groupby([('A', 'B')]):  # A: "itertools.groupby" is inefficient in compiled code.
+        pass
+
+def use_groupby2() -> None:
+    for a, b in itertools.groupby([('A', 'B')]):  # A: "itertools.groupby" is inefficient in compiled code.
+        pass
+
+def use_islice() -> None:
+    for x in islice([1, 2, 3], 1, 2):  # A: "itertools.islice" is inefficient in compiled code (hint: replace with for loop over index range).
+        pass
+
+[case testAnnotateGenericForLoop]
+from typing import Iterable, Sequence, Iterator, List
+
+def f1(a):
+    for x in a:  # A: For loop uses generic operations (iterable has type "Any").
+        pass
+
+def f2(a: Iterable[str]) -> None:
+    for x in a:  # A: For loop uses generic operations (iterable has the abstract type "typing.Iterable").
+        pass
+
+def f3(a: Sequence[str]) -> None:
+    for x in a:  # A: For loop uses generic operations (iterable has the abstract type "typing.Sequence").
+        pass
+
+def f4(a: Iterator[str]) -> None:
+    for x in a:  # A: For loop uses generic operations (iterable has the abstract type "typing.Iterator").
+        pass
+
+def good1(a: List[str]) -> None:
+    for x in a:
+        pass
+
+class C:
+    def __iter__(self) -> Iterator[str]:
+        assert False
+
+def good2(a: List[str]) -> None:
+    for x in a:
+        pass
+
+[case testAnnotateGenericComprehensionOrGenerator]
+from typing import List, Iterable
+
+def f1(a):
+    return [x for x in a]  # A: Comprehension or generator uses generic operations (iterable has type "Any").
+
+def f2(a: Iterable[int]):
+    return {x for x in a}  # A: Comprehension or generator uses generic operations (iterable has the abstract type "typing.Iterable").
+
+def f3(a):
+    return {x: 1 for x in a}  # A: Comprehension uses generic operations (iterable has type "Any").
+
+def f4(a):
+    return (x for x in a)  # A: Comprehension or generator uses generic operations (iterable has type "Any").
+
+def good1(a: List[int]) -> List[int]:
+    return [x + 1 for x in a]
+
+[case testAnnotateIsinstance]
+from typing import Protocol, runtime_checkable, Union
+
+@runtime_checkable
+class P(Protocol):
+    def foo(self) -> None: ...
+
+class C: pass
+
+class D(C):
+    def bar(self) -> None: pass
+
+def bad1(x: object) -> bool:
+    return isinstance(x, P)  # A: Expensive isinstance() check against protocol "P".
+
+def bad2(x: object) -> bool:
+    return isinstance(x, (str, P))  # A: Expensive isinstance() check against protocol "P".
+
+def good1(x: C) -> bool:
+    if isinstance(x, D):
+        x.bar()
+    return isinstance(x, D)
+
+def good2(x: Union[int, str]) -> int:
+    if isinstance(x, int):
+        return x + 1
+    else:
+        return int(x + "1")
+[typing fixtures/typing-full.pyi]
+
+[case testAnnotateDeepcopy]
+from typing import Any
+import copy
+
+def f(x: Any) -> Any:
+    return copy.deepcopy(x)  # A: "copy.deepcopy" tends to be slow. Make a shallow copy if possible.
+
+[case testAnnotateContextManager]
+from typing import Iterator
+from contextlib import contextmanager
+
+@contextmanager
+def slow_ctx_manager() -> Iterator[None]:
+    yield
+
+class FastCtxManager:
+    def __enter__(self) -> None: pass
+    def __exit__(self, a, b, c) -> None: pass
+
+def f1(x) -> None:
+    with slow_ctx_manager():  # A: "slow_ctx_manager" uses @contextmanager, which is slow in compiled code. Use a native class with "__enter__" and "__exit__" methods instead.
+        x.foo  # A: Get non-native attribute "foo".
+
+def f2(x) -> None:
+    with FastCtxManager():
+        x.foo  # A: Get non-native attribute "foo".
+
+[case testAnnotateAvoidNoiseAtTopLevel]
+from typing import Final
+
+class C(object):
+    x = "s"
+    y: Final = 1
+
+x = "s"
+y: Final = 1
+
+def f1() -> None:
+    x = object  # A: Get non-native attribute "object".
+
+[case testAnnotateCreateNonNativeInstance]
+from typing import NamedTuple
+from dataclasses import dataclass
+
+from nonnative import C
+
+def f1() -> None:
+    c = C()  # A: Creating an instance of non-native class "C" is slow.
+    c.foo()  # A: Call non-native method "foo" (it may be defined in a non-native class, or decorated).
+
+class NT(NamedTuple):
+    x: int
+    y: str
+
+def f2() -> int:
+    o = NT(1, "x")  # A: Creating an instance of non-native class "NT" is slow.
+    return o.x
+
+def f3() -> int:
+    o = NT(x=1, y="x")  # A: Creating an instance of non-native class "NT" is slow.
+    a, b = o
+    return a
+
+@dataclass
+class D:
+    x: int
+
+def f4() -> int:
+    o = D(1)  # A: Class "D" is only partially native, and constructing an instance is slow.
+    return o.x
+
+class Nat:
+    x: int
+
+class Deriv(Nat):
+    def __init__(self, y: int) -> None:
+        self.y = y
+
+def good1() -> int:
+    n = Nat()
+    d = Deriv(y=1)
+    return n.x + d.x + d.y
+
+[file nonnative.py]
+class C:
+    def foo(self) -> None: pass
+
+[case testAnnotateGetAttrAndSetAttrBuiltins]
+def f1(x, s: str):
+    return getattr("x", s)  # A: Dynamic attribute lookup.
+
+def f2(x, s: str):
+    setattr(x, s, None)  # A: Dynamic attribute set.
+
+[case testAnnotateSpecialAssignments]
+from typing import TypeVar, NamedTuple, List, TypedDict, NewType
+
+# Even though these are slow, we don't complain about them since there is generally
+# no better way (and at module top level these are very unlikely to be bottlenecks)
+A = List[int]
+T = TypeVar("T", bound=List[int])
+NT = NamedTuple("NT", [("x", List[int])])
+TD = TypedDict("TD", {"x": List[int]})
+New = NewType("New", List[int])
+[typing fixtures/typing-full.pyi]
+
+[case testAnnotateCallDecoratedNativeFunctionOrMethod]
+from typing import TypeVar, Callable, Any
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+def mydeco(f: F) -> F:
+    return f
+
+@mydeco
+def d(x: int) -> int:
+    return x
+
+def f1() -> int:
+    return d(1)  # A: Calling a decorated function ("d") is inefficient, even if it's native.
+
+class C:
+    @mydeco
+    def d(self) -> None:
+        pass
+
+
+def f2() -> None:
+    c = C()
+    c.d()  # A: Call non-native method "d" (it may be defined in a non-native class, or decorated).
+
+[case testAnnotateCallDifferentKindsOfMethods]
+from abc import ABC, abstractmethod
+
+class C:
+    @staticmethod
+    def s() -> None: ...
+
+    @classmethod
+    def c(cls) -> None: ...
+
+    @property
+    def p(self) -> int:
+        return 0
+
+    @property
+    def p2(self) -> int:
+        return 0
+
+    @p2.setter
+    def p2(self, x: int) -> None:
+        pass
+
+def f1() -> int:
+    c = C()
+    c.s()
+    c.c()
+    c.p2 = 1
+    return c.p + c.p2
+
+class A(ABC):
+    @abstractmethod
+    def m(self) -> int:
+        raise NotImplementedError  # A: Get non-native attribute "NotImplementedError".
+
+class D(A):
+    def m(self) -> int:
+        return 1
+
+def f2() -> int:
+    d = D()
+    return d.m()
diff --git a/mypyc/test-data/commandline.test b/mypyc/test-data/commandline.test
index 672e879fbe1e..ae0be03eb66b 100644
--- a/mypyc/test-data/commandline.test
+++ b/mypyc/test-data/commandline.test
@@ -105,8 +105,7 @@ def f(x: int) -> int:
 # cmd: test.py
 
 [file test.py]
-from typing import List, Any, AsyncIterable
-from typing_extensions import Final
+from typing import Final, List, Any, AsyncIterable
 from mypy_extensions import trait, mypyc_attr
 from functools import singledispatch
 
@@ -200,9 +199,9 @@ wtvr = next(i for i in range(10) if i == 5)
 
 d1 = {1: 2}
 
-# Make sure we can produce an error when we hit the awful None case
+# Since PR 18180, the following pattern should pose no problems anymore:
 def f(l: List[object]) -> None:
-    x = None  # E: Local variable "x" has inferred type None; add an annotation
+    x = None
     for i in l:
         if x is None:
             x = i
@@ -243,3 +242,50 @@ def i(arg: Foo) -> None:
 
 [file test.py]
 names = (str(v) for v in [1, 2, 3])  # W: Treating generator comprehension as list
+
+[case testSubPackage]
+# cmd: pkg/sub/foo.py
+from pkg.sub import foo
+
+[file pkg/__init__.py]
+
+[file pkg/sub/__init__.py]
+print("importing...")
+from . import foo
+print("done")
+
+[file pkg/sub/foo.py]
+print("imported foo")
+
+[out]
+importing...
+imported foo
+done
+
+[case testImportFromInitPy]
+# cmd: foo.py
+import foo
+
+[file pkg2/__init__.py]
+
+[file pkg2/mod2.py]
+class A:
+    class B:
+        pass
+
+[file pkg1/__init__.py]
+from pkg2.mod2 import A
+
+[file foo.py]
+import pkg1
+from typing import TypedDict
+
+class Eggs(TypedDict):
+    obj1: pkg1.A.B
+
+print(type(Eggs(obj1=pkg1.A.B())["obj1"]).__name__)
+print(type(Eggs(obj1=pkg1.A.B())["obj1"]).__module__)
+
+[out]
+B
+pkg2.mod2
diff --git a/mypyc/test-data/driver/driver.py b/mypyc/test-data/driver/driver.py
index 6717f402f72d..c9d179224a30 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]
diff --git a/mypyc/test-data/exceptions-freq.test b/mypyc/test-data/exceptions-freq.test
index a655eed44d90..b0e4cd6d35f7 100644
--- a/mypyc/test-data/exceptions-freq.test
+++ b/mypyc/test-data/exceptions-freq.test
@@ -97,7 +97,7 @@ L2:
 hot blocks: [0, 1]
 
 [case testRareBranch_freq]
-from typing_extensions import Final
+from typing import Final
 
 x: Final = str()
 
diff --git a/mypyc/test-data/exceptions.test b/mypyc/test-data/exceptions.test
index 16bf8ba1eb89..18983b2c92e9 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
@@ -111,56 +111,42 @@ def sum(a: List[int], l: int) -> int:
 def sum(a, l):
     a :: list
     l, sum, i :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: object
-    r7, r8, r9, r10 :: int
+    r0 :: bit
+    r1 :: object
+    r2, r3, r4, r5 :: int
 L0:
     sum = 0
     i = 0
 L1:
-    r0 = i & 1
-    r1 = r0 != 0
-    if r1 goto L3 else goto L2 :: bool
+    r0 = int_lt i, l
+    if r0 goto L2 else goto L7 :: bool
 L2:
-    r2 = l & 1
-    r3 = r2 != 0
-    if r3 goto L3 else goto L4 :: bool
+    r1 = CPyList_GetItemBorrow(a, i)
+    if is_error(r1) goto L8 (error at sum:6) else goto L3
 L3:
-    r4 = CPyTagged_IsLt_(i, l)
-    if r4 goto L5 else goto L10 :: bool
+    r2 = unbox(int, r1)
+    if is_error(r2) goto L8 (error at sum:6) else goto L4
 L4:
-    r5 = i < l :: signed
-    if r5 goto L5 else goto L10 :: bool
-L5:
-    r6 = CPyList_GetItemBorrow(a, i)
-    if is_error(r6) goto L11 (error at sum:6) else goto L6
-L6:
-    r7 = unbox(int, r6)
-    if is_error(r7) goto L11 (error at sum:6) else goto L7
-L7:
-    r8 = CPyTagged_Add(sum, r7)
+    r3 = CPyTagged_Add(sum, r2)
     dec_ref sum :: int
-    dec_ref r7 :: int
-    sum = r8
-    r9 = CPyTagged_Add(i, 2)
+    dec_ref r2 :: int
+    sum = r3
+    r4 = CPyTagged_Add(i, 2)
     dec_ref i :: int
-    i = r9
+    i = r4
     goto L1
-L8:
+L5:
     return sum
-L9:
-    r10 = <error> :: int
-    return r10
-L10:
+L6:
+    r5 = <error> :: int
+    return r5
+L7:
     dec_ref i :: int
-    goto L8
-L11:
+    goto L5
+L8:
     dec_ref sum :: int
     dec_ref i :: int
-    goto L9
+    goto L6
 
 [case testTryExcept]
 def g() -> None:
@@ -177,9 +163,12 @@ def g():
     r5 :: str
     r6 :: object
     r7 :: str
-    r8, r9 :: object
-    r10 :: bit
-    r11 :: None
+    r8 :: object
+    r9 :: object[1]
+    r10 :: object_ptr
+    r11 :: object
+    r12 :: bit
+    r13 :: None
 L0:
 L1:
     r0 = builtins :: module
@@ -187,7 +176,7 @@ L1:
     r2 = CPyObject_GetAttr(r0, r1)
     if is_error(r2) goto L3 (error at g:3) else goto L2
 L2:
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
     dec_ref r2
     if is_error(r3) goto L3 (error at g:3) else goto L10
 L3:
@@ -198,9 +187,11 @@ L3:
     r8 = CPyObject_GetAttr(r6, r7)
     if is_error(r8) goto L6 (error at g:5) else goto L4
 L4:
-    r9 = PyObject_CallFunctionObjArgs(r8, r5, 0)
+    r9 = [r5]
+    r10 = load_address r9
+    r11 = PyObject_Vectorcall(r8, r10, 1, 0)
     dec_ref r8
-    if is_error(r9) goto L6 (error at g:5) else goto L11
+    if is_error(r11) goto L6 (error at g:5) else goto L11
 L5:
     CPy_RestoreExcInfo(r4)
     dec_ref r4
@@ -208,20 +199,20 @@ L5:
 L6:
     CPy_RestoreExcInfo(r4)
     dec_ref r4
-    r10 = CPy_KeepPropagating()
-    if not r10 goto L9 else goto L7 :: bool
+    r12 = CPy_KeepPropagating()
+    if not r12 goto L9 else goto L7 :: bool
 L7:
     unreachable
 L8:
     return 1
 L9:
-    r11 = <error> :: None
-    return r11
+    r13 = <error> :: None
+    return r13
 L10:
     dec_ref r3
     goto L8
 L11:
-    dec_ref r9
+    dec_ref r11
     goto L5
 
 [case testGenopsTryFinally]
@@ -243,9 +234,12 @@ def a():
     r10 :: str
     r11 :: object
     r12 :: str
-    r13, r14 :: object
-    r15 :: bit
-    r16 :: str
+    r13 :: object
+    r14 :: object[1]
+    r15 :: object_ptr
+    r16 :: object
+    r17 :: bit
+    r18 :: str
 L0:
 L1:
     r0 = builtins :: module
@@ -253,7 +247,7 @@ L1:
     r2 = CPyObject_GetAttr(r0, r1)
     if is_error(r2) goto L5 (error at a:3) else goto L2
 L2:
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
     dec_ref r2
     if is_error(r3) goto L5 (error at a:3) else goto L19
 L3:
@@ -276,9 +270,11 @@ L6:
     r13 = CPyObject_GetAttr(r11, r12)
     if is_error(r13) goto L20 (error at a:6) else goto L7
 L7:
-    r14 = PyObject_CallFunctionObjArgs(r13, r10, 0)
+    r14 = [r10]
+    r15 = load_address r14
+    r16 = PyObject_Vectorcall(r13, r15, 1, 0)
     dec_ref r13
-    if is_error(r14) goto L20 (error at a:6) else goto L21
+    if is_error(r16) goto L20 (error at a:6) else goto L21
 L8:
     if is_error(r7) goto L11 else goto L22
 L9:
@@ -296,15 +292,15 @@ L14:
     CPy_RestoreExcInfo(r7)
     xdec_ref r7
 L15:
-    r15 = CPy_KeepPropagating()
-    if not r15 goto L18 else goto L16 :: bool
+    r17 = CPy_KeepPropagating()
+    if not r17 goto L18 else goto L16 :: bool
 L16:
     unreachable
 L17:
     unreachable
 L18:
-    r16 = <error> :: str
-    return r16
+    r18 = <error> :: str
+    return r18
 L19:
     dec_ref r3
     goto L3
@@ -312,7 +308,7 @@ L20:
     xdec_ref r5
     goto L13
 L21:
-    dec_ref r14
+    dec_ref r16
     goto L8
 L22:
     xdec_ref r5
@@ -460,8 +456,11 @@ def f(b):
     r6 :: str
     r7 :: object
     r8 :: bool
-    r9 :: object
-    r10 :: None
+    r9 :: object[1]
+    r10 :: object_ptr
+    r11 :: object
+    r12 :: bool
+    r13 :: None
 L0:
     r0 = <error> :: str
     v = r0
@@ -469,50 +468,59 @@ L0:
     inc_ref r1
     u = r1
 L1:
-    if b goto L10 else goto L11 :: bool
+    if b goto L13 else goto L14 :: bool
 L2:
     r2 = 'b'
     inc_ref r2
     v = r2
     r3 = v == u
     r4 = r3 ^ 1
-    if r4 goto L11 else goto L1 :: bool
+    if r4 goto L14 else goto L1 :: bool
 L3:
     r5 = builtins :: module
     r6 = 'print'
     r7 = CPyObject_GetAttr(r5, r6)
-    if is_error(r7) goto L12 (error at f:7) else goto L4
+    if is_error(r7) goto L15 (error at f:7) else goto L4
 L4:
-    if is_error(v) goto L13 else goto L7
+    if is_error(v) goto L16 else goto L7
 L5:
     r8 = raise UnboundLocalError('local variable "v" referenced before assignment')
-    if not r8 goto L9 (error at f:7) else goto L6 :: bool
+    if not r8 goto L12 (error at f:-1) else goto L6 :: bool
 L6:
     unreachable
 L7:
-    r9 = PyObject_CallFunctionObjArgs(r7, v, 0)
+    r9 = [v]
+    r10 = load_address r9
+    r11 = PyObject_Vectorcall(r7, r10, 1, 0)
     dec_ref r7
-    xdec_ref v
-    if is_error(r9) goto L9 (error at f:7) else goto L14
+    if is_error(r11) goto L15 (error at f:7) else goto L17
 L8:
-    return 1
+    if is_error(v) goto L9 else goto L11
 L9:
-    r10 = <error> :: None
-    return r10
+    r12 = raise UnboundLocalError('local variable "v" referenced before assignment')
+    if not r12 goto L12 (error at f:-1) else goto L10 :: bool
 L10:
+    unreachable
+L11:
+    xdec_ref v
+    return 1
+L12:
+    r13 = <error> :: None
+    return r13
+L13:
     xdec_ref v
     goto L2
-L11:
+L14:
     dec_ref u
     goto L3
-L12:
+L15:
     xdec_ref v
-    goto L9
-L13:
+    goto L12
+L16:
     dec_ref r7
     goto L5
-L14:
-    dec_ref r9
+L17:
+    dec_ref r11
     goto L8
 
 [case testExceptionWithOverlappingErrorValue]
@@ -528,10 +536,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 +550,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 +620,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 +644,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 +673,7 @@ L4:
 L5:
     return y
 L6:
-    r6 = <error> :: int64
+    r6 = <error> :: i64
     return r6
 
 [case testExceptionWithFloatAttribute]
diff --git a/mypyc/test-data/fixtures/ir.py b/mypyc/test-data/fixtures/ir.py
index 0b081b079bda..1b92590a5fd4 100644
--- a/mypyc/test-data/fixtures/ir.py
+++ b/mypyc/test-data/fixtures/ir.py
@@ -7,12 +7,12 @@
     overload, Mapping, Union, Callable, Sequence, FrozenSet, Protocol
 )
 
-T = TypeVar('T')
+_T = TypeVar('_T')
 T_co = TypeVar('T_co', covariant=True)
 T_contra = TypeVar('T_contra', contravariant=True)
-S = TypeVar('S')
-K = TypeVar('K') # for keys in mapping
-V = TypeVar('V') # for values in mapping
+_S = TypeVar('_S')
+_K = TypeVar('_K') # for keys in mapping
+_V = TypeVar('_V') # for values in mapping
 
 class __SupportsAbs(Protocol[T_co]):
     def __abs__(self) -> T_co: pass
@@ -45,6 +45,7 @@ def __ne__(self, x: object) -> bool: pass
 
 class type:
     def __init__(self, o: object) -> None: ...
+    def __or__(self, o: object) -> Any: ...
     __name__ : str
     __annotations__: Dict[str, Any]
 
@@ -87,6 +88,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: ...
@@ -99,15 +102,26 @@ def __getitem__(self, i: int) -> str: pass
     def __getitem__(self, i: slice) -> str: pass
     def __contains__(self, item: str) -> bool: pass
     def __iter__(self) -> Iterator[str]: ...
-    def split(self, sep: Optional[str] = None, max: Optional[int] = None) -> List[str]: pass
-    def strip (self, item: str) -> str: pass
+    def find(self, sub: str, start: Optional[int] = None, end: Optional[int] = None, /) -> int: ...
+    def rfind(self, sub: str, start: Optional[int] = None, end: Optional[int] = None, /) -> int: ...
+    def split(self, sep: Optional[str] = None, maxsplit: int = -1) -> List[str]: pass
+    def rsplit(self, sep: Optional[str] = None, maxsplit: int = -1) -> List[str]: pass
+    def splitlines(self, keepends: bool = False) -> List[str]: ...
+    def strip (self, item: Optional[str] = None) -> str: pass
+    def lstrip(self, item: Optional[str] = None) -> str: pass
+    def rstrip(self, item: Optional[str] = None) -> str: pass
     def join(self, x: Iterable[str]) -> str: pass
     def format(self, *args: Any, **kwargs: Any) -> str: ...
     def upper(self) -> str: ...
-    def startswith(self, x: str, start: int=..., end: int=...) -> bool: ...
-    def endswith(self, x: str, start: int=..., end: int=...) -> bool: ...
+    def startswith(self, x: Union[str, Tuple[str, ...]], start: int=..., end: int=...) -> bool: ...
+    def endswith(self, x: Union[str, Tuple[str, ...]], start: int=..., end: int=...) -> bool: ...
     def replace(self, old: str, new: str, maxcount: int=...) -> str: ...
-    def encode(self, x: str=..., y: str=...) -> bytes: ...
+    def encode(self, encoding: str=..., errors: str=...) -> bytes: ...
+    def partition(self, sep: str, /) -> Tuple[str, str, str]: ...
+    def rpartition(self, sep: str, /) -> Tuple[str, str, str]: ...
+    def removeprefix(self, prefix: str, /) -> str: ...
+    def removesuffix(self, suffix: str, /) -> str: ...
+    def islower(self) -> bool: ...
 
 class float:
     def __init__(self, x: object) -> None: pass
@@ -134,7 +148,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 +161,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
@@ -190,79 +208,91 @@ def __getitem__(self, i: slice) -> Tuple[T_co, ...]: pass
     def __len__(self) -> int: pass
     def __iter__(self) -> Iterator[T_co]: ...
     def __contains__(self, item: object) -> int: ...
+    @overload
+    def __add__(self, value: Tuple[T_co, ...], /) -> Tuple[T_co, ...]: ...
+    @overload
+    def __add__(self, value: Tuple[_T, ...], /) -> Tuple[T_co | _T, ...]: ...
+    def __mul__(self, value: int, /) -> Tuple[T_co, ...]: ...
+    def __rmul__(self, value: int, /) -> Tuple[T_co, ...]: ...
 
 class function: pass
 
-class list(Generic[T], Sequence[T], Iterable[T]):
-    def __init__(self, i: Optional[Iterable[T]] = None) -> None: pass
+class list(Generic[_T], Sequence[_T], Iterable[_T]):
+    def __init__(self, i: Optional[Iterable[_T]] = None) -> None: pass
     @overload
-    def __getitem__(self, i: int) -> T: ...
+    def __getitem__(self, i: int) -> _T: ...
     @overload
-    def __getitem__(self, s: slice) -> List[T]: ...
-    def __setitem__(self, i: int, o: T) -> None: pass
+    def __getitem__(self, s: slice) -> List[_T]: ...
+    def __setitem__(self, i: int, o: _T) -> None: pass
     def __delitem__(self, i: int) -> None: pass
-    def __mul__(self, i: int) -> List[T]: pass
-    def __rmul__(self, i: int) -> List[T]: pass
-    def __iter__(self) -> Iterator[T]: pass
+    def __mul__(self, i: int) -> List[_T]: pass
+    def __rmul__(self, i: int) -> List[_T]: pass
+    def __imul__(self, i: int) -> List[_T]: ...
+    def __iter__(self) -> Iterator[_T]: pass
     def __len__(self) -> int: pass
     def __contains__(self, item: object) -> int: ...
-    def __add__(self, x: List[T]) -> List[T]: ...
-    def append(self, x: T) -> None: pass
-    def pop(self, i: int = -1) -> T: pass
-    def count(self, T) -> int: pass
-    def extend(self, l: Iterable[T]) -> None: pass
-    def insert(self, i: int, x: T) -> None: pass
+    @overload
+    def __add__(self, value: List[_T], /) -> List[_T]: ...
+    @overload
+    def __add__(self, value: List[_S], /) -> List[_S | _T]: ...
+    def __iadd__(self, value: Iterable[_T], /) -> List[_T]: ...  # type: ignore[misc]
+    def append(self, x: _T) -> None: pass
+    def pop(self, i: int = -1) -> _T: pass
+    def count(self, _T) -> int: pass
+    def extend(self, l: Iterable[_T]) -> None: pass
+    def insert(self, i: int, x: _T) -> None: pass
     def sort(self) -> None: pass
     def reverse(self) -> None: pass
-    def remove(self, o: T) -> None: pass
-    def index(self, o: T) -> int: pass
+    def remove(self, o: _T) -> None: pass
+    def index(self, o: _T) -> int: pass
+    def copy(self) -> List[_T]: pass
 
-class dict(Mapping[K, V]):
+class dict(Mapping[_K, _V]):
     @overload
-    def __init__(self, **kwargs: K) -> None: ...
+    def __init__(self, **kwargs: _K) -> None: ...
     @overload
-    def __init__(self, map: Mapping[K, V], **kwargs: V) -> None: ...
+    def __init__(self, map: Mapping[_K, _V], **kwargs: _V) -> None: ...
     @overload
-    def __init__(self, iterable: Iterable[Tuple[K, V]], **kwargs: V) -> None: ...
-    def __getitem__(self, key: K) -> V: pass
-    def __setitem__(self, k: K, v: V) -> None: pass
-    def __delitem__(self, k: K) -> None: pass
+    def __init__(self, iterable: Iterable[Tuple[_K, _V]], **kwargs: _V) -> None: ...
+    def __getitem__(self, key: _K) -> _V: pass
+    def __setitem__(self, k: _K, v: _V) -> None: pass
+    def __delitem__(self, k: _K) -> None: pass
     def __contains__(self, item: object) -> int: pass
-    def __iter__(self) -> Iterator[K]: pass
+    def __iter__(self) -> Iterator[_K]: pass
     def __len__(self) -> int: pass
     @overload
-    def update(self, __m: Mapping[K, V], **kwargs: V) -> None: pass
+    def update(self, __m: Mapping[_K, _V], **kwargs: _V) -> None: pass
     @overload
-    def update(self, __m: Iterable[Tuple[K, V]], **kwargs: V) -> None: ...
+    def update(self, __m: Iterable[Tuple[_K, _V]], **kwargs: _V) -> None: ...
     @overload
-    def update(self, **kwargs: V) -> None: ...
-    def pop(self, x: int) -> K: pass
-    def keys(self) -> Iterable[K]: pass
-    def values(self) -> Iterable[V]: pass
-    def items(self) -> Iterable[Tuple[K, V]]: pass
+    def update(self, **kwargs: _V) -> None: ...
+    def pop(self, x: int) -> _K: pass
+    def keys(self) -> Iterable[_K]: pass
+    def values(self) -> Iterable[_V]: pass
+    def items(self) -> Iterable[Tuple[_K, _V]]: pass
     def clear(self) -> None: pass
-    def copy(self) -> Dict[K, V]: pass
-    def setdefault(self, key: K, val: V = ...) -> V: pass
+    def copy(self) -> Dict[_K, _V]: pass
+    def setdefault(self, key: _K, val: _V = ...) -> _V: pass
 
-class set(Generic[T]):
-    def __init__(self, i: Optional[Iterable[T]] = None) -> None: pass
-    def __iter__(self) -> Iterator[T]: pass
+class set(Generic[_T]):
+    def __init__(self, i: Optional[Iterable[_T]] = None) -> None: pass
+    def __iter__(self) -> Iterator[_T]: pass
     def __len__(self) -> int: pass
-    def add(self, x: T) -> None: pass
-    def remove(self, x: T) -> None: pass
-    def discard(self, x: T) -> None: pass
+    def add(self, x: _T) -> None: pass
+    def remove(self, x: _T) -> None: pass
+    def discard(self, x: _T) -> None: pass
     def clear(self) -> None: pass
-    def pop(self) -> T: pass
-    def update(self, x: Iterable[S]) -> None: pass
-    def __or__(self, s: Union[Set[S], FrozenSet[S]]) -> Set[Union[T, S]]: ...
-    def __xor__(self, s: Union[Set[S], FrozenSet[S]]) -> Set[Union[T, S]]: ...
-
-class frozenset(Generic[T]):
-    def __init__(self, i: Optional[Iterable[T]] = None) -> None: pass
-    def __iter__(self) -> Iterator[T]: pass
+    def pop(self) -> _T: pass
+    def update(self, x: Iterable[_S]) -> None: pass
+    def __or__(self, s: Union[Set[_S], FrozenSet[_S]]) -> Set[Union[_T, _S]]: ...
+    def __xor__(self, s: Union[Set[_S], FrozenSet[_S]]) -> Set[Union[_T, _S]]: ...
+
+class frozenset(Generic[_T]):
+    def __init__(self, i: Optional[Iterable[_T]] = None) -> None: pass
+    def __iter__(self) -> Iterator[_T]: pass
     def __len__(self) -> int: pass
-    def __or__(self, s: Union[Set[S], FrozenSet[S]]) -> FrozenSet[Union[T, S]]: ...
-    def __xor__(self, s: Union[Set[S], FrozenSet[S]]) -> FrozenSet[Union[T, S]]: ...
+    def __or__(self, s: Union[Set[_S], FrozenSet[_S]]) -> FrozenSet[Union[_T, _S]]: ...
+    def __xor__(self, s: Union[Set[_S], FrozenSet[_S]]) -> FrozenSet[Union[_T, _S]]: ...
 
 class slice: pass
 
@@ -317,31 +347,33 @@ class OverflowError(ArithmeticError): pass
 
 class GeneratorExit(BaseException): pass
 
-def any(i: Iterable[T]) -> bool: pass
-def all(i: Iterable[T]) -> bool: pass
-def sum(i: Iterable[T]) -> int: pass
-def reversed(object: Sequence[T]) -> Iterator[T]: ...
+def any(i: Iterable[_T]) -> bool: pass
+def all(i: Iterable[_T]) -> bool: pass
+def sum(i: Iterable[_T]) -> int: pass
+def reversed(object: Sequence[_T]) -> Iterator[_T]: ...
 def id(o: object) -> int: pass
 # This type is obviously wrong but the test stubs don't have Sized anymore
 def len(o: object) -> int: pass
 def print(*object) -> None: pass
 def isinstance(x: object, t: object) -> bool: pass
-def iter(i: Iterable[T]) -> Iterator[T]: pass
+def iter(i: Iterable[_T]) -> Iterator[_T]: pass
 @overload
-def next(i: Iterator[T]) -> T: pass
+def next(i: Iterator[_T]) -> _T: pass
 @overload
-def next(i: Iterator[T], default: T) -> T: pass
+def next(i: Iterator[_T], default: _T) -> _T: pass
 def hash(o: object) -> int: ...
 def globals() -> Dict[str, Any]: ...
+def hasattr(obj: object, name: str) -> bool: ...
 def getattr(obj: object, name: str, default: Any = None) -> Any: ...
 def setattr(obj: object, name: str, value: Any) -> None: ...
-def enumerate(x: Iterable[T]) -> Iterator[Tuple[int, T]]: ...
+def delattr(obj: object, name: str) -> None: ...
+def enumerate(x: Iterable[_T]) -> Iterator[Tuple[int, _T]]: ...
 @overload
-def zip(x: Iterable[T], y: Iterable[S]) -> Iterator[Tuple[T, S]]: ...
+def zip(x: Iterable[_T], y: Iterable[_S]) -> Iterator[Tuple[_T, _S]]: ...
 @overload
-def zip(x: Iterable[T], y: Iterable[S], z: Iterable[V]) -> Iterator[Tuple[T, S, V]]: ...
+def zip(x: Iterable[_T], y: Iterable[_S], z: Iterable[_V]) -> Iterator[Tuple[_T, _S, _V]]: ...
 def eval(e: str) -> Any: ...
-def abs(x: __SupportsAbs[T]) -> T: ...
+def abs(x: __SupportsAbs[_T]) -> _T: ...
 @overload
 def divmod(x: __SupportsDivMod[T_contra, T_co], y: T_contra) -> T_co: ...
 @overload
@@ -352,9 +384,10 @@ def pow(base: __SupportsPow2[T_contra, T_co], exp: T_contra, mod: None = None) -
 def pow(base: __SupportsPow3NoneOnly[T_contra, T_co], exp: T_contra, mod: None = None) -> T_co: ...
 @overload
 def pow(base: __SupportsPow3[T_contra, _M, T_co], exp: T_contra, mod: _M) -> T_co: ...
+def sorted(iterable: Iterable[_T]) -> list[_T]: ...
 def exit() -> None: ...
-def min(x: T, y: T) -> T: ...
-def max(x: T, y: T) -> T: ...
+def min(x: _T, y: _T) -> _T: ...
+def max(x: _T, y: _T) -> _T: ...
 def repr(o: object) -> str: ...
 def ascii(o: object) -> str: ...
 def ord(o: object) -> int: ...
diff --git a/mypyc/test-data/fixtures/testutil.py b/mypyc/test-data/fixtures/testutil.py
index 5a4b1d0f549e..36ec41c8f38b 100644
--- a/mypyc/test-data/fixtures/testutil.py
+++ b/mypyc/test-data/fixtures/testutil.py
@@ -5,9 +5,9 @@
 import math
 from typing import (
     Any, Iterator, TypeVar, Generator, Optional, List, Tuple, Sequence,
-    Union, Callable, Awaitable,
+    Union, Callable, Awaitable, Generic
 )
-from typing_extensions import Final
+from typing import Final
 
 FLOAT_MAGIC: Final = -113.0
 
@@ -45,7 +45,7 @@ def assertRaises(typ: type, msg: str = '') -> Iterator[None]:
     try:
         yield
     except Exception as e:
-        assert isinstance(e, typ), f"{e!r} is not a {typ.__name__}"
+        assert type(e) is typ, f"{e!r} is not a {typ.__name__}"
         assert msg in str(e), f'Message "{e}" does not match "{msg}"'
     else:
         assert False, f"Expected {typ.__name__} but got no exception"
@@ -86,7 +86,7 @@ def run_generator(gen: Generator[T, V, U],
 F = TypeVar('F', bound=Callable)
 
 
-class async_val(Awaitable[V]):
+class async_val(Awaitable[V], Generic[T, V]):
     def __init__(self, val: T) -> None:
         self.val = val
 
diff --git a/mypyc/test-data/fixtures/typing-full.pyi b/mypyc/test-data/fixtures/typing-full.pyi
index 52bca09a1dec..6b6aba6802b1 100644
--- a/mypyc/test-data/fixtures/typing-full.pyi
+++ b/mypyc/test-data/fixtures/typing-full.pyi
@@ -10,26 +10,29 @@ from abc import abstractmethod, ABCMeta
 
 class GenericMeta(type): pass
 
+class _SpecialForm:
+    def __getitem__(self, index): ...
+
 cast = 0
 overload = 0
-Any = 0
-Union = 0
+Any = object()
 Optional = 0
 TypeVar = 0
 Generic = 0
 Protocol = 0
 Tuple = 0
-Callable = 0
 _promote = 0
 NamedTuple = 0
 Type = 0
 no_type_check = 0
 ClassVar = 0
 Final = 0
-Literal = 0
 TypedDict = 0
 NoReturn = 0
 NewType = 0
+Callable: _SpecialForm
+Union: _SpecialForm
+Literal: _SpecialForm
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
@@ -167,3 +170,6 @@ class _TypedDict(Mapping[str, object]):
     def pop(self, k: NoReturn, default: T = ...) -> object: ...
     def update(self: T, __m: T) -> None: ...
     def __delitem__(self, k: NoReturn) -> None: ...
+
+class TypeAliasType:
+    pass
diff --git a/mypyc/test-data/irbuild-any.test b/mypyc/test-data/irbuild-any.test
index 8274e3d5c619..55783a9a9498 100644
--- a/mypyc/test-data/irbuild-any.test
+++ b/mypyc/test-data/irbuild-any.test
@@ -37,7 +37,6 @@ def f(a: Any, n: int, c: C) -> None:
     c.n = a
     a = n
     n = a
-    a.a = n
 [out]
 def f(a, n, c):
     a :: object
@@ -49,10 +48,6 @@ def f(a, n, c):
     r3 :: bool
     r4 :: object
     r5 :: int
-    r6 :: str
-    r7 :: object
-    r8 :: int32
-    r9 :: bit
 L0:
     r0 = box(int, n)
     c.a = r0; r1 = is_error
@@ -62,10 +57,6 @@ L0:
     a = r4
     r5 = unbox(int, a)
     n = r5
-    r6 = 'a'
-    r7 = box(int, n)
-    r8 = PyObject_SetAttr(a, r6, r7)
-    r9 = r8 >= 0 :: signed
     return 1
 
 [case testCoerceAnyInOps]
@@ -99,14 +90,14 @@ 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
-    r13, r14, r15 :: ptr
+    r13 :: ptr
 L0:
     r0 = box(int, n)
     r1 = PyObject_GetItem(a, r0)
@@ -121,11 +112,9 @@ L0:
     r10 = CPyList_SetItem(l, n, a)
     r11 = PyList_New(2)
     r12 = box(int, n)
-    r13 = get_element_ptr r11 ob_item :: PyListObject
-    r14 = load_mem r13 :: ptr*
-    set_mem r14, a :: builtins.object*
-    r15 = r14 + WORD_SIZE*1
-    set_mem r15, r12 :: builtins.object*
+    r13 = list_items r11
+    buf_init_item r13, 0, a
+    buf_init_item r13, 1, r12
     keep_alive r11
     return 1
 def f3(a, n):
@@ -153,7 +142,9 @@ def f4(a, n, b):
     a :: object
     n :: int
     b :: bool
-    r0, r1, r2, r3 :: object
+    r0 :: union[object, int]
+    r1, r2 :: object
+    r3 :: union[int, object]
     r4 :: int
 L0:
     if b goto L1 else goto L2 :: bool
diff --git a/mypyc/test-data/irbuild-basic.test b/mypyc/test-data/irbuild-basic.test
index 496eca77e090..6e5267fc34dd 100644
--- a/mypyc/test-data/irbuild-basic.test
+++ b/mypyc/test-data/irbuild-basic.test
@@ -76,27 +76,13 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
+    r0 :: bit
 L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L1 :: bool
+    r0 = int_lt x, y
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
-L2:
-    r4 = CPyTagged_IsLt_(x, y)
-    if r4 goto L4 else goto L5 :: bool
-L3:
-    r5 = x < y :: signed
-    if r5 goto L4 else goto L5 :: bool
-L4:
     x = 2
-L5:
+L2:
     return x
 
 [case testIfElse]
@@ -109,30 +95,16 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
+    r0 :: bit
 L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L1 :: bool
+    r0 = int_lt x, y
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
-L2:
-    r4 = CPyTagged_IsLt_(x, y)
-    if r4 goto L4 else goto L5 :: bool
-L3:
-    r5 = x < y :: signed
-    if r5 goto L4 else goto L5 :: bool
-L4:
     x = 2
-    goto L6
-L5:
+    goto L3
+L2:
     x = 4
-L6:
+L3:
     return x
 
 [case testAnd1]
@@ -145,48 +117,19 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: native_int
-    r7 :: bit
-    r8 :: native_int
-    r9, r10, r11 :: bit
-L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L1 :: bool
+    r0, r1 :: bit
+L0:
+    r0 = int_lt x, y
+    if r0 goto L1 else goto L3 :: bool
 L1:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
+    r1 = int_gt x, y
+    if r1 goto L2 else goto L3 :: bool
 L2:
-    r4 = CPyTagged_IsLt_(x, y)
-    if r4 goto L4 else goto L9 :: bool
-L3:
-    r5 = x < y :: signed
-    if r5 goto L4 else goto L9 :: bool
-L4:
-    r6 = x & 1
-    r7 = r6 != 0
-    if r7 goto L6 else goto L5 :: bool
-L5:
-    r8 = y & 1
-    r9 = r8 != 0
-    if r9 goto L6 else goto L7 :: bool
-L6:
-    r10 = CPyTagged_IsLt_(y, x)
-    if r10 goto L8 else goto L9 :: bool
-L7:
-    r11 = x > y :: signed
-    if r11 goto L8 else goto L9 :: bool
-L8:
     x = 2
-    goto L10
-L9:
+    goto L4
+L3:
     x = 4
-L10:
+L4:
     return x
 
 [case testAnd2]
@@ -221,48 +164,19 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: native_int
-    r7 :: bit
-    r8 :: native_int
-    r9, r10, r11 :: bit
-L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L1 :: bool
+    r0, r1 :: bit
+L0:
+    r0 = int_lt x, y
+    if r0 goto L2 else goto L1 :: bool
 L1:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
+    r1 = int_gt x, y
+    if r1 goto L2 else goto L3 :: bool
 L2:
-    r4 = CPyTagged_IsLt_(x, y)
-    if r4 goto L8 else goto L4 :: bool
-L3:
-    r5 = x < y :: signed
-    if r5 goto L8 else goto L4 :: bool
-L4:
-    r6 = x & 1
-    r7 = r6 != 0
-    if r7 goto L6 else goto L5 :: bool
-L5:
-    r8 = y & 1
-    r9 = r8 != 0
-    if r9 goto L6 else goto L7 :: bool
-L6:
-    r10 = CPyTagged_IsLt_(y, x)
-    if r10 goto L8 else goto L9 :: bool
-L7:
-    r11 = x > y :: signed
-    if r11 goto L8 else goto L9 :: bool
-L8:
     x = 2
-    goto L10
-L9:
+    goto L4
+L3:
     x = 4
-L10:
+L4:
     return x
 
 [case testOr2]
@@ -295,27 +209,13 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
+    r0 :: bit
 L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L1 :: bool
+    r0 = int_lt x, y
+    if r0 goto L2 else goto L1 :: bool
 L1:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
-L2:
-    r4 = CPyTagged_IsLt_(x, y)
-    if r4 goto L5 else goto L4 :: bool
-L3:
-    r5 = x < y :: signed
-    if r5 goto L5 else goto L4 :: bool
-L4:
     x = 2
-L5:
+L2:
     return x
 
 [case testNotAnd]
@@ -326,45 +226,16 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: native_int
-    r7 :: bit
-    r8 :: native_int
-    r9, r10, r11 :: bit
-L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L1 :: bool
+    r0, r1 :: bit
+L0:
+    r0 = int_lt x, y
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
+    r1 = int_gt x, y
+    if r1 goto L3 else goto L2 :: bool
 L2:
-    r4 = CPyTagged_IsLt_(x, y)
-    if r4 goto L4 else goto L8 :: bool
-L3:
-    r5 = x < y :: signed
-    if r5 goto L4 else goto L8 :: bool
-L4:
-    r6 = x & 1
-    r7 = r6 != 0
-    if r7 goto L6 else goto L5 :: bool
-L5:
-    r8 = y & 1
-    r9 = r8 != 0
-    if r9 goto L6 else goto L7 :: bool
-L6:
-    r10 = CPyTagged_IsLt_(y, x)
-    if r10 goto L9 else goto L8 :: bool
-L7:
-    r11 = x > y :: signed
-    if r11 goto L9 else goto L8 :: bool
-L8:
     x = 2
-L9:
+L3:
     return x
 
 [case testWhile]
@@ -375,31 +246,17 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: int
+    r0 :: bit
+    r1 :: int
 L0:
 L1:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L3 else goto L2 :: bool
+    r0 = int_gt x, y
+    if r0 goto L2 else goto L3 :: bool
 L2:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L3 else goto L4 :: bool
-L3:
-    r4 = CPyTagged_IsLt_(y, x)
-    if r4 goto L5 else goto L6 :: bool
-L4:
-    r5 = x > y :: signed
-    if r5 goto L5 else goto L6 :: bool
-L5:
-    r6 = CPyTagged_Subtract(x, y)
-    x = r6
+    r1 = CPyTagged_Subtract(x, y)
+    x = r1
     goto L1
-L6:
+L3:
     return x
 
 [case testWhile2]
@@ -411,32 +268,18 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: int
+    r0 :: bit
+    r1 :: int
 L0:
     x = 2
 L1:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L3 else goto L2 :: bool
+    r0 = int_gt x, y
+    if r0 goto L2 else goto L3 :: bool
 L2:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L3 else goto L4 :: bool
-L3:
-    r4 = CPyTagged_IsLt_(y, x)
-    if r4 goto L5 else goto L6 :: bool
-L4:
-    r5 = x > y :: signed
-    if r5 goto L5 else goto L6 :: bool
-L5:
-    r6 = CPyTagged_Subtract(x, y)
-    x = r6
+    r1 = CPyTagged_Subtract(x, y)
+    x = r1
     goto L1
-L6:
+L3:
     return x
 
 [case testImplicitNoneReturn]
@@ -466,30 +309,16 @@ def f(x: int, y: int) -> None:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
+    r0 :: bit
 L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L1 :: bool
+    r0 = int_lt x, y
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = y & 1
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
-L2:
-    r4 = CPyTagged_IsLt_(x, y)
-    if r4 goto L4 else goto L5 :: bool
-L3:
-    r5 = x < y :: signed
-    if r5 goto L4 else goto L5 :: bool
-L4:
     x = 2
-    goto L6
-L5:
+    goto L3
+L2:
     y = 4
-L6:
+L3:
     return 1
 
 [case testRecursion]
@@ -501,29 +330,21 @@ def f(n: int) -> int:
 [out]
 def f(n):
     n :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    r4, r5, r6, r7, r8 :: int
+    r0 :: bit
+    r1, r2, r3, r4, r5 :: int
 L0:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_le n, 2
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = CPyTagged_IsLt_(2, n)
-    if r2 goto L4 else goto L3 :: bool
+    return 2
 L2:
-    r3 = n <= 2 :: signed
-    if r3 goto L3 else goto L4 :: bool
+    r1 = CPyTagged_Subtract(n, 2)
+    r2 = f(r1)
+    r3 = CPyTagged_Subtract(n, 4)
+    r4 = f(r3)
+    r5 = CPyTagged_Add(r2, r4)
+    return r5
 L3:
-    return 2
-L4:
-    r4 = CPyTagged_Subtract(n, 2)
-    r5 = f(r4)
-    r6 = CPyTagged_Subtract(n, 4)
-    r7 = f(r6)
-    r8 = CPyTagged_Add(r5, r7)
-    return r8
-L5:
     unreachable
 
 [case testReportTypeCheckError]
@@ -550,33 +371,25 @@ def f(n: int) -> int:
 [out]
 def f(n):
     n :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
+    r0 :: bit
     x :: int
-    r4 :: bit
+    r1 :: bit
 L0:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_lt n, 0
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = CPyTagged_IsLt_(n, 0)
-    if r2 goto L3 else goto L4 :: bool
+    x = 2
+    goto L6
 L2:
-    r3 = n < 0 :: signed
-    if r3 goto L3 else goto L4 :: bool
+    r1 = int_eq n, 0
+    if r1 goto L3 else goto L4 :: bool
 L3:
     x = 2
-    goto L8
+    goto L5
 L4:
-    r4 = n == 0
-    if r4 goto L5 else goto L6 :: bool
+    x = 4
 L5:
-    x = 2
-    goto L7
 L6:
-    x = 4
-L7:
-L8:
     return x
 
 [case testUnaryMinus]
@@ -598,7 +411,7 @@ def f(n):
     r0 :: bit
     r1 :: int
 L0:
-    r0 = n == 0
+    r0 = int_eq n, 0
     if r0 goto L1 else goto L2 :: bool
 L1:
     r1 = 0
@@ -671,16 +484,22 @@ def f(x):
     x :: int
     r0 :: object
     r1 :: str
-    r2, r3, r4 :: object
-    r5 :: int
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
+    r7 :: int
 L0:
     r0 = testmodule :: module
     r1 = 'factorial'
     r2 = CPyObject_GetAttr(r0, r1)
     r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    return r5
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
+    r7 = unbox(int, r6)
+    return r7
 
 [case testImport_toplevel]
 import sys
@@ -713,7 +532,7 @@ def __top_level__():
     r18 :: str
     r19 :: dict
     r20 :: str
-    r21 :: int32
+    r21 :: i32
     r22 :: bit
     r23 :: object_ptr
     r24 :: object_ptr[1]
@@ -768,7 +587,7 @@ L2:
     r33 = single :: module
     r34 = 'hello'
     r35 = CPyObject_GetAttr(r33, r34)
-    r36 = PyObject_CallFunctionObjArgs(r35, 0)
+    r36 = PyObject_Vectorcall(r35, 0, 0, 0)
     return 1
 
 [case testFromImport_toplevel]
@@ -787,36 +606,42 @@ def f(x):
     x :: int
     r0 :: dict
     r1 :: str
-    r2, r3, r4 :: object
-    r5 :: int
-    r6 :: dict
-    r7 :: str
-    r8, r9 :: object
-    r10, r11 :: int
-    r12 :: dict
-    r13 :: str
-    r14, r15 :: object
-    r16, r17 :: int
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
+    r7 :: int
+    r8 :: dict
+    r9 :: str
+    r10, r11 :: object
+    r12, r13 :: int
+    r14 :: dict
+    r15 :: str
+    r16, r17 :: object
+    r18, r19 :: int
 L0:
     r0 = __main__.globals :: static
     r1 = 'g'
     r2 = CPyDict_GetItem(r0, r1)
     r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    r6 = __main__.globals :: static
-    r7 = 'h'
-    r8 = CPyDict_GetItem(r6, r7)
-    r9 = PyObject_CallFunctionObjArgs(r8, 0)
-    r10 = unbox(int, r9)
-    r11 = CPyTagged_Add(r5, r10)
-    r12 = __main__.globals :: static
-    r13 = 'two'
-    r14 = CPyDict_GetItem(r12, r13)
-    r15 = PyObject_CallFunctionObjArgs(r14, 0)
-    r16 = unbox(int, r15)
-    r17 = CPyTagged_Add(r11, r16)
-    return r17
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
+    r7 = unbox(int, r6)
+    r8 = __main__.globals :: static
+    r9 = 'h'
+    r10 = CPyDict_GetItem(r8, r9)
+    r11 = PyObject_Vectorcall(r10, 0, 0, 0)
+    r12 = unbox(int, r11)
+    r13 = CPyTagged_Add(r7, r12)
+    r14 = __main__.globals :: static
+    r15 = 'two'
+    r16 = CPyDict_GetItem(r14, r15)
+    r17 = PyObject_Vectorcall(r16, 0, 0, 0)
+    r18 = unbox(int, r17)
+    r19 = CPyTagged_Add(r13, r18)
+    return r19
 def __top_level__():
     r0, r1 :: object
     r2 :: bit
@@ -860,13 +685,19 @@ def f(x):
     x :: int
     r0 :: object
     r1 :: str
-    r2, r3, r4 :: object
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
 L0:
     r0 = builtins :: module
     r1 = 'print'
     r2 = CPyObject_GetAttr(r0, r1)
     r3 = object 5
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
     return 1
 
 [case testPrint]
@@ -878,13 +709,19 @@ def f(x):
     x :: int
     r0 :: object
     r1 :: str
-    r2, r3, r4 :: object
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
 L0:
     r0 = builtins :: module
     r1 = 'print'
     r2 = CPyObject_GetAttr(r0, r1)
     r3 = object 5
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
     return 1
 
 [case testUnicodeLiteral]
@@ -913,7 +750,7 @@ L0:
     r1 = b'1234'
     return r1
 
-[case testPyMethodCall1]
+[case testPyMethodCall1_64bit]
 from typing import Any
 def f(x: Any) -> int:
     y: int = x.pop()
@@ -922,20 +759,30 @@ def f(x: Any) -> int:
 def f(x):
     x :: object
     r0 :: str
-    r1 :: object
-    r2, y :: int
-    r3 :: str
-    r4 :: object
-    r5 :: int
+    r1 :: object[1]
+    r2 :: object_ptr
+    r3 :: object
+    r4, y :: int
+    r5 :: str
+    r6 :: object[1]
+    r7 :: object_ptr
+    r8 :: object
+    r9 :: int
 L0:
     r0 = 'pop'
-    r1 = CPyObject_CallMethodObjArgs(x, r0, 0)
-    r2 = unbox(int, r1)
-    y = r2
-    r3 = 'pop'
-    r4 = CPyObject_CallMethodObjArgs(x, r3, 0)
-    r5 = unbox(int, r4)
-    return r5
+    r1 = [x]
+    r2 = load_address r1
+    r3 = PyObject_VectorcallMethod(r0, r2, 9223372036854775809, 0)
+    keep_alive x
+    r4 = unbox(int, r3)
+    y = r4
+    r5 = 'pop'
+    r6 = [x]
+    r7 = load_address r6
+    r8 = PyObject_VectorcallMethod(r5, r7, 9223372036854775809, 0)
+    keep_alive x
+    r9 = unbox(int, r8)
+    return r9
 
 [case testObjectType]
 def g(y: object) -> None:
@@ -948,21 +795,20 @@ def g(y):
     r0 :: None
     r1 :: list
     r2 :: object
-    r3, r4 :: ptr
-    r5 :: None
-    r6 :: object
-    r7 :: None
+    r3 :: ptr
+    r4 :: None
+    r5 :: object
+    r6 :: None
 L0:
     r0 = g(y)
     r1 = PyList_New(1)
     r2 = object 1
-    r3 = get_element_ptr r1 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, r2 :: builtins.object*
+    r3 = list_items r1
+    buf_init_item r3, 0, r2
     keep_alive r1
-    r5 = g(r1)
-    r6 = box(None, 1)
-    r7 = g(r6)
+    r4 = g(r1)
+    r5 = box(None, 1)
+    r6 = g(r5)
     return 1
 
 [case testCoerceToObject1]
@@ -976,28 +822,27 @@ def g(y: object) -> object:
 def g(y):
     y, r0, r1 :: object
     r2 :: list
-    r3, r4 :: ptr
+    r3 :: ptr
     a :: list
-    r5 :: tuple[int, int]
-    r6 :: object
-    r7 :: bit
-    r8, r9 :: object
+    r4 :: tuple[int, int]
+    r5 :: object
+    r6 :: bit
+    r7, r8 :: object
 L0:
     r0 = object 1
     r1 = g(r0)
     r2 = PyList_New(1)
-    r3 = get_element_ptr r2 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, y :: builtins.object*
+    r3 = list_items r2
+    buf_init_item r3, 0, y
     keep_alive r2
     a = r2
-    r5 = (2, 4)
-    r6 = box(tuple[int, int], r5)
-    r7 = CPyList_SetItem(a, 0, r6)
-    r8 = box(bool, 1)
-    y = r8
-    r9 = object 3
-    return r9
+    r4 = (2, 4)
+    r5 = box(tuple[int, int], r4)
+    r6 = CPyList_SetItem(a, 0, r5)
+    r7 = box(bool, 1)
+    y = r7
+    r8 = object 3
+    return r8
 
 [case testCoerceToObject2]
 class A:
@@ -1146,7 +991,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)
@@ -1172,13 +1017,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
 
@@ -1269,27 +1117,19 @@ def f(x: int) -> int:
 [out]
 def absolute_value(x):
     x :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    r4, r5 :: int
+    r0 :: bit
+    r1, r2 :: int
 L0:
-    r0 = x & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_gt x, 0
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = CPyTagged_IsLt_(0, x)
-    if r2 goto L3 else goto L4 :: bool
+    r1 = x
+    goto L3
 L2:
-    r3 = x > 0 :: signed
-    if r3 goto L3 else goto L4 :: bool
+    r2 = CPyTagged_Negate(x)
+    r1 = r2
 L3:
-    r4 = x
-    goto L5
-L4:
-    r5 = CPyTagged_Negate(x)
-    r4 = r5
-L5:
-    return r4
+    return r1
 def call_native_function(x):
     x, r0 :: int
 L0:
@@ -1299,16 +1139,22 @@ def call_python_function(x):
     x :: int
     r0 :: dict
     r1 :: str
-    r2, r3, r4 :: object
-    r5 :: int
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
+    r7 :: int
 L0:
     r0 = __main__.globals :: static
     r1 = 'f'
     r2 = CPyDict_GetItem(r0, r1)
     r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    return r5
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
+    r7 = unbox(int, r6)
+    return r7
 def return_float():
 L0:
     return 5.0
@@ -1327,11 +1173,11 @@ def call_callable_type():
 L0:
     r0 = return_callable_type()
     f = r0
-    r1 = PyObject_CallFunctionObjArgs(f, 0)
+    r1 = PyObject_Vectorcall(f, 0, 0, 0)
     r2 = unbox(float, r1)
     return r2
 
-[case testCallableTypesWithKeywordArgs]
+[case testCallableTypesWithKeywordArgs_64bit]
 from typing import List
 
 def call_python_function_with_keyword_arg(x: str) -> int:
@@ -1345,58 +1191,51 @@ def call_python_method_with_keyword_args(xs: List[int], first: int, second: int)
 [out]
 def call_python_function_with_keyword_arg(x):
     x :: str
-    r0 :: object
-    r1 :: str
-    r2 :: tuple
-    r3 :: object
-    r4 :: dict
-    r5 :: object
+    r0, r1 :: object
+    r2 :: object[2]
+    r3 :: object_ptr
+    r4, r5 :: object
     r6 :: int
 L0:
     r0 = load_address PyLong_Type
-    r1 = 'base'
-    r2 = PyTuple_Pack(1, x)
-    r3 = object 2
-    r4 = CPyDict_Build(1, r1, r3)
-    r5 = PyObject_Call(r0, r2, r4)
+    r1 = object 2
+    r2 = [x, r1]
+    r3 = load_address r2
+    r4 = ('base',)
+    r5 = PyObject_Vectorcall(r0, r3, 1, r4)
+    keep_alive x, r1
     r6 = unbox(int, r5)
     return r6
 def call_python_method_with_keyword_args(xs, first, second):
     xs :: list
     first, second :: int
     r0 :: str
-    r1 :: object
-    r2 :: str
-    r3 :: object
-    r4 :: tuple
-    r5 :: object
-    r6 :: dict
-    r7 :: object
-    r8 :: str
-    r9 :: object
-    r10, r11 :: str
-    r12 :: tuple
-    r13, r14 :: object
-    r15 :: dict
-    r16 :: object
+    r1, r2 :: object
+    r3 :: object[3]
+    r4 :: object_ptr
+    r5, r6 :: object
+    r7 :: str
+    r8, r9 :: object
+    r10 :: object[3]
+    r11 :: object_ptr
+    r12, r13 :: object
 L0:
     r0 = 'insert'
-    r1 = CPyObject_GetAttr(xs, r0)
-    r2 = 'x'
-    r3 = object 0
-    r4 = PyTuple_Pack(1, r3)
-    r5 = box(int, first)
-    r6 = CPyDict_Build(1, r2, r5)
-    r7 = PyObject_Call(r1, r4, r6)
-    r8 = 'insert'
-    r9 = CPyObject_GetAttr(xs, r8)
-    r10 = 'x'
-    r11 = 'i'
-    r12 = PyTuple_Pack(0)
-    r13 = box(int, second)
-    r14 = object 1
-    r15 = CPyDict_Build(2, r10, r13, r11, r14)
-    r16 = PyObject_Call(r9, r12, r15)
+    r1 = object 0
+    r2 = box(int, first)
+    r3 = [xs, r1, r2]
+    r4 = load_address r3
+    r5 = ('x',)
+    r6 = PyObject_VectorcallMethod(r0, r4, 9223372036854775810, r5)
+    keep_alive xs, r1, r2
+    r7 = 'insert'
+    r8 = box(int, second)
+    r9 = object 1
+    r10 = [xs, r8, r9]
+    r11 = load_address r10
+    r12 = ('x', 'i')
+    r13 = PyObject_VectorcallMethod(r7, r11, 9223372036854775809, r12)
+    keep_alive xs, r8, r9
     return xs
 
 [case testObjectAsBoolean]
@@ -1422,13 +1261,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
@@ -1450,17 +1289,14 @@ L3:
     unreachable
 def lst(x):
     x :: list
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3 :: bit
+    r0 :: native_int
+    r1 :: short_int
+    r2 :: bit
 L0:
-    r0 = get_element_ptr x ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive x
-    r2 = r1 << 1
-    r3 = r2 != 0
-    if r3 goto L1 else goto L2 :: bool
+    r0 = var_object_size x
+    r1 = r0 << 1
+    r2 = int_ne r1, 0
+    if r2 goto L1 else goto L2 :: bool
 L1:
     return 2
 L2:
@@ -1530,7 +1366,7 @@ def opt_o(x):
     r0 :: object
     r1 :: bit
     r2 :: object
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: bool
 L0:
@@ -1541,7 +1377,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
@@ -1565,7 +1401,7 @@ L0:
     r0 = builtins :: module
     r1 = 'Exception'
     r2 = CPyObject_GetAttr(r0, r1)
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
     CPy_Raise(r3)
     unreachable
 def bar():
@@ -1593,7 +1429,10 @@ def f():
     r3 :: int
     r4 :: object
     r5 :: str
-    r6, r7, r8 :: object
+    r6, r7 :: object
+    r8 :: object[1]
+    r9 :: object_ptr
+    r10 :: object
 L0:
     r0 = __main__.globals :: static
     r1 = 'x'
@@ -1603,7 +1442,10 @@ L0:
     r5 = 'print'
     r6 = CPyObject_GetAttr(r4, r5)
     r7 = box(int, r3)
-    r8 = PyObject_CallFunctionObjArgs(r6, r7, 0)
+    r8 = [r7]
+    r9 = load_address r8
+    r10 = PyObject_Vectorcall(r6, r9, 1, 0)
+    keep_alive r7
     return 1
 def __top_level__():
     r0, r1 :: object
@@ -1613,7 +1455,7 @@ def __top_level__():
     r5 :: dict
     r6 :: str
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: dict
     r11 :: str
@@ -1621,7 +1463,10 @@ def __top_level__():
     r13 :: int
     r14 :: object
     r15 :: str
-    r16, r17, r18 :: object
+    r16, r17 :: object
+    r18 :: object[1]
+    r19 :: object_ptr
+    r20 :: object
 L0:
     r0 = builtins :: module
     r1 = load_address _Py_NoneStruct
@@ -1645,7 +1490,10 @@ L2:
     r15 = 'print'
     r16 = CPyObject_GetAttr(r14, r15)
     r17 = box(int, r13)
-    r18 = PyObject_CallFunctionObjArgs(r16, r17, 0)
+    r18 = [r17]
+    r19 = load_address r18
+    r20 = PyObject_Vectorcall(r16, r19, 1, 0)
+    keep_alive r17
     return 1
 
 [case testCallOverloaded]
@@ -1662,16 +1510,22 @@ def f(x: str) -> int: ...
 def f():
     r0 :: object
     r1 :: str
-    r2, r3, r4 :: object
-    r5 :: str
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
+    r7 :: str
 L0:
     r0 = m :: module
     r1 = 'f'
     r2 = CPyObject_GetAttr(r0, r1)
     r3 = object 1
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = cast(str, r4)
-    return r5
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
+    r7 = cast(str, r6)
+    return r7
 
 [case testCallOverloadedNative]
 from typing import overload, Union
@@ -1728,7 +1582,7 @@ def main() -> None:
 def foo(x):
     x :: union[int, str]
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: __main__.B
@@ -1737,7 +1591,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()
@@ -1853,12 +1707,12 @@ def h():
     r3 :: object
     r4 :: list
     r5 :: object
-    r6, r7 :: ptr
-    r8, r9 :: object
-    r10 :: tuple
-    r11 :: dict
-    r12 :: object
-    r13 :: tuple[int, int, int]
+    r6 :: ptr
+    r7, r8 :: object
+    r9 :: tuple
+    r10 :: dict
+    r11 :: object
+    r12 :: tuple[int, int, int]
 L0:
     r0 = (4, 6)
     r1 = __main__.globals :: static
@@ -1866,17 +1720,16 @@ L0:
     r3 = CPyDict_GetItem(r1, r2)
     r4 = PyList_New(1)
     r5 = object 1
-    r6 = get_element_ptr r4 ob_item :: PyListObject
-    r7 = load_mem r6 :: ptr*
-    set_mem r7, r5 :: builtins.object*
+    r6 = list_items r4
+    buf_init_item r6, 0, r5
     keep_alive r4
-    r8 = box(tuple[int, int], r0)
-    r9 = CPyList_Extend(r4, r8)
-    r10 = PyList_AsTuple(r4)
-    r11 = PyDict_New()
-    r12 = PyObject_Call(r3, r10, r11)
-    r13 = unbox(tuple[int, int, int], r12)
-    return r13
+    r7 = box(tuple[int, int], r0)
+    r8 = CPyList_Extend(r4, r7)
+    r9 = PyList_AsTuple(r4)
+    r10 = PyDict_New()
+    r11 = PyObject_Call(r3, r9, r10)
+    r12 = unbox(tuple[int, int, int], r11)
+    return r12
 
 [case testStar2Args]
 from typing import Tuple
@@ -1900,7 +1753,7 @@ def g():
     r8 :: str
     r9 :: object
     r10 :: dict
-    r11 :: int32
+    r11 :: i32
     r12 :: bit
     r13 :: tuple
     r14 :: object
@@ -1930,7 +1783,7 @@ def h():
     r6 :: str
     r7 :: object
     r8 :: dict
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: object
     r12 :: tuple
@@ -2041,94 +1894,59 @@ def f() -> List[int]:
 def f():
     r0, r1 :: list
     r2, r3, r4 :: object
-    r5, r6, r7, r8 :: ptr
-    r9 :: short_int
-    r10 :: ptr
-    r11 :: native_int
-    r12 :: short_int
-    r13 :: bit
-    r14 :: object
-    r15, x :: int
-    r16 :: native_int
-    r17, r18 :: bit
-    r19 :: bool
-    r20, r21 :: bit
-    r22 :: native_int
-    r23, r24 :: bit
-    r25 :: bool
-    r26, r27 :: bit
-    r28 :: int
-    r29 :: object
-    r30 :: int32
-    r31 :: bit
-    r32 :: short_int
+    r5 :: ptr
+    r6 :: short_int
+    r7 :: native_int
+    r8 :: short_int
+    r9 :: bit
+    r10 :: object
+    r11, x :: int
+    r12, r13 :: bit
+    r14 :: int
+    r15 :: object
+    r16 :: i32
+    r17 :: bit
+    r18 :: short_int
 L0:
     r0 = PyList_New(0)
     r1 = PyList_New(3)
     r2 = object 1
     r3 = object 2
     r4 = object 3
-    r5 = get_element_ptr r1 ob_item :: PyListObject
-    r6 = load_mem r5 :: ptr*
-    set_mem r6, r2 :: builtins.object*
-    r7 = r6 + WORD_SIZE*1
-    set_mem r7, r3 :: builtins.object*
-    r8 = r6 + WORD_SIZE*2
-    set_mem r8, r4 :: builtins.object*
+    r5 = list_items r1
+    buf_init_item r5, 0, r2
+    buf_init_item r5, 1, r3
+    buf_init_item r5, 2, r4
     keep_alive r1
-    r9 = 0
+    r6 = 0
 L1:
-    r10 = get_element_ptr r1 ob_size :: PyVarObject
-    r11 = load_mem r10 :: native_int*
-    keep_alive r1
-    r12 = r11 << 1
-    r13 = r9 < r12 :: signed
-    if r13 goto L2 else goto L14 :: bool
+    r7 = var_object_size r1
+    r8 = r7 << 1
+    r9 = int_lt r6, r8
+    if r9 goto L2 else goto L8 :: bool
 L2:
-    r14 = CPyList_GetItemUnsafe(r1, r9)
-    r15 = unbox(int, r14)
-    x = r15
-    r16 = x & 1
-    r17 = r16 == 0
-    if r17 goto L3 else goto L4 :: bool
+    r10 = list_get_item_unsafe r1, r6
+    r11 = unbox(int, r10)
+    x = r11
+    r12 = int_ne x, 4
+    if r12 goto L4 else goto L3 :: bool
 L3:
-    r18 = x != 4
-    r19 = r18
-    goto L5
+    goto L7
 L4:
-    r20 = CPyTagged_IsEq_(x, 4)
-    r21 = r20 ^ 1
-    r19 = r21
+    r13 = int_ne x, 6
+    if r13 goto L6 else goto L5 :: bool
 L5:
-    if r19 goto L7 else goto L6 :: bool
+    goto L7
 L6:
-    goto L13
+    r14 = CPyTagged_Multiply(x, x)
+    r15 = box(int, r14)
+    r16 = PyList_Append(r0, r15)
+    r17 = r16 >= 0 :: signed
 L7:
-    r22 = x & 1
-    r23 = r22 == 0
-    if r23 goto L8 else goto L9 :: bool
-L8:
-    r24 = x != 6
-    r25 = r24
-    goto L10
-L9:
-    r26 = CPyTagged_IsEq_(x, 6)
-    r27 = r26 ^ 1
-    r25 = r27
-L10:
-    if r25 goto L12 else goto L11 :: bool
-L11:
-    goto L13
-L12:
-    r28 = CPyTagged_Multiply(x, x)
-    r29 = box(int, r28)
-    r30 = PyList_Append(r0, r29)
-    r31 = r30 >= 0 :: signed
-L13:
-    r32 = r9 + 2
-    r9 = r32
+    r18 = r6 + 2
+    r6 = r18
     goto L1
-L14:
+L8:
     return r0
 
 [case testDictComprehension]
@@ -2140,95 +1958,60 @@ def f():
     r0 :: dict
     r1 :: list
     r2, r3, r4 :: object
-    r5, r6, r7, r8 :: ptr
-    r9 :: short_int
-    r10 :: ptr
-    r11 :: native_int
-    r12 :: short_int
-    r13 :: bit
-    r14 :: object
-    r15, x :: int
-    r16 :: native_int
-    r17, r18 :: bit
-    r19 :: bool
-    r20, r21 :: bit
-    r22 :: native_int
-    r23, r24 :: bit
-    r25 :: bool
-    r26, r27 :: bit
-    r28 :: int
-    r29, r30 :: object
-    r31 :: int32
-    r32 :: bit
-    r33 :: short_int
+    r5 :: ptr
+    r6 :: short_int
+    r7 :: native_int
+    r8 :: short_int
+    r9 :: bit
+    r10 :: object
+    r11, x :: int
+    r12, r13 :: bit
+    r14 :: int
+    r15, r16 :: object
+    r17 :: i32
+    r18 :: bit
+    r19 :: short_int
 L0:
     r0 = PyDict_New()
     r1 = PyList_New(3)
     r2 = object 1
     r3 = object 2
     r4 = object 3
-    r5 = get_element_ptr r1 ob_item :: PyListObject
-    r6 = load_mem r5 :: ptr*
-    set_mem r6, r2 :: builtins.object*
-    r7 = r6 + WORD_SIZE*1
-    set_mem r7, r3 :: builtins.object*
-    r8 = r6 + WORD_SIZE*2
-    set_mem r8, r4 :: builtins.object*
+    r5 = list_items r1
+    buf_init_item r5, 0, r2
+    buf_init_item r5, 1, r3
+    buf_init_item r5, 2, r4
     keep_alive r1
-    r9 = 0
+    r6 = 0
 L1:
-    r10 = get_element_ptr r1 ob_size :: PyVarObject
-    r11 = load_mem r10 :: native_int*
-    keep_alive r1
-    r12 = r11 << 1
-    r13 = r9 < r12 :: signed
-    if r13 goto L2 else goto L14 :: bool
+    r7 = var_object_size r1
+    r8 = r7 << 1
+    r9 = int_lt r6, r8
+    if r9 goto L2 else goto L8 :: bool
 L2:
-    r14 = CPyList_GetItemUnsafe(r1, r9)
-    r15 = unbox(int, r14)
-    x = r15
-    r16 = x & 1
-    r17 = r16 == 0
-    if r17 goto L3 else goto L4 :: bool
+    r10 = list_get_item_unsafe r1, r6
+    r11 = unbox(int, r10)
+    x = r11
+    r12 = int_ne x, 4
+    if r12 goto L4 else goto L3 :: bool
 L3:
-    r18 = x != 4
-    r19 = r18
-    goto L5
+    goto L7
 L4:
-    r20 = CPyTagged_IsEq_(x, 4)
-    r21 = r20 ^ 1
-    r19 = r21
+    r13 = int_ne x, 6
+    if r13 goto L6 else goto L5 :: bool
 L5:
-    if r19 goto L7 else goto L6 :: bool
+    goto L7
 L6:
-    goto L13
+    r14 = CPyTagged_Multiply(x, x)
+    r15 = box(int, x)
+    r16 = box(int, r14)
+    r17 = CPyDict_SetItem(r0, r15, r16)
+    r18 = r17 >= 0 :: signed
 L7:
-    r22 = x & 1
-    r23 = r22 == 0
-    if r23 goto L8 else goto L9 :: bool
-L8:
-    r24 = x != 6
-    r25 = r24
-    goto L10
-L9:
-    r26 = CPyTagged_IsEq_(x, 6)
-    r27 = r26 ^ 1
-    r25 = r27
-L10:
-    if r25 goto L12 else goto L11 :: bool
-L11:
-    goto L13
-L12:
-    r28 = CPyTagged_Multiply(x, x)
-    r29 = box(int, x)
-    r30 = box(int, r28)
-    r31 = CPyDict_SetItem(r0, r29, r30)
-    r32 = r31 >= 0 :: signed
-L13:
-    r33 = r9 + 2
-    r9 = r33
+    r19 = r6 + 2
+    r6 = r19
     goto L1
-L14:
+L8:
     return r0
 
 [case testLoopsMultipleAssign]
@@ -2241,82 +2024,73 @@ def f(l: List[Tuple[int, int, int]]) -> List[int]:
 def f(l):
     l :: list
     r0 :: short_int
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
-    r4 :: bit
-    r5 :: object
-    r6 :: tuple[int, int, int]
-    r7, x, r8, y, r9, z :: int
-    r10 :: short_int
-    r11 :: ptr
-    r12 :: native_int
-    r13 :: list
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: bit
+    r4 :: object
+    r5 :: tuple[int, int, int]
+    r6, x, r7, y, r8, z :: int
+    r9 :: short_int
+    r10 :: native_int
+    r11 :: list
+    r12 :: short_int
+    r13 :: native_int
     r14 :: short_int
-    r15 :: ptr
-    r16 :: native_int
-    r17 :: short_int
-    r18 :: bit
-    r19 :: object
-    r20 :: tuple[int, int, int]
-    r21, x_2, r22, y_2, r23, z_2, r24, r25 :: int
-    r26 :: object
-    r27 :: bit
-    r28 :: short_int
+    r15 :: bit
+    r16 :: object
+    r17 :: tuple[int, int, int]
+    r18, x_2, r19, y_2, r20, z_2, r21, r22 :: int
+    r23 :: object
+    r24 :: bit
+    r25 :: short_int
 L0:
     r0 = 0
 L1:
-    r1 = get_element_ptr l ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
-    keep_alive l
-    r3 = r2 << 1
-    r4 = r0 < r3 :: signed
-    if r4 goto L2 else goto L4 :: bool
+    r1 = var_object_size l
+    r2 = r1 << 1
+    r3 = int_lt r0, r2
+    if r3 goto L2 else goto L4 :: bool
 L2:
-    r5 = CPyList_GetItemUnsafe(l, r0)
-    r6 = unbox(tuple[int, int, int], r5)
-    r7 = r6[0]
-    x = r7
-    r8 = r6[1]
-    y = r8
-    r9 = r6[2]
-    z = r9
+    r4 = list_get_item_unsafe l, r0
+    r5 = unbox(tuple[int, int, int], r4)
+    r6 = r5[0]
+    x = r6
+    r7 = r5[1]
+    y = r7
+    r8 = r5[2]
+    z = r8
 L3:
-    r10 = r0 + 2
-    r0 = r10
+    r9 = r0 + 2
+    r0 = r9
     goto L1
 L4:
-    r11 = get_element_ptr l ob_size :: PyVarObject
-    r12 = load_mem r11 :: native_int*
-    keep_alive l
-    r13 = PyList_New(r12)
-    r14 = 0
+    r10 = var_object_size l
+    r11 = PyList_New(r10)
+    r12 = 0
 L5:
-    r15 = get_element_ptr l ob_size :: PyVarObject
-    r16 = load_mem r15 :: native_int*
-    keep_alive l
-    r17 = r16 << 1
-    r18 = r14 < r17 :: signed
-    if r18 goto L6 else goto L8 :: bool
+    r13 = var_object_size l
+    r14 = r13 << 1
+    r15 = int_lt r12, r14
+    if r15 goto L6 else goto L8 :: bool
 L6:
-    r19 = CPyList_GetItemUnsafe(l, r14)
-    r20 = unbox(tuple[int, int, int], r19)
-    r21 = r20[0]
-    x_2 = r21
-    r22 = r20[1]
-    y_2 = r22
-    r23 = r20[2]
-    z_2 = r23
-    r24 = CPyTagged_Add(x_2, y_2)
-    r25 = CPyTagged_Add(r24, z_2)
-    r26 = box(int, r25)
-    r27 = CPyList_SetItemUnsafe(r13, r14, r26)
+    r16 = list_get_item_unsafe l, r12
+    r17 = unbox(tuple[int, int, int], r16)
+    r18 = r17[0]
+    x_2 = r18
+    r19 = r17[1]
+    y_2 = r19
+    r20 = r17[2]
+    z_2 = r20
+    r21 = CPyTagged_Add(x_2, y_2)
+    r22 = CPyTagged_Add(r21, z_2)
+    r23 = box(int, r22)
+    r24 = CPyList_SetItemUnsafe(r11, r12, r23)
 L7:
-    r28 = r14 + 2
-    r14 = r28
+    r25 = r12 + 2
+    r12 = r25
     goto L5
 L8:
-    return r13
+    return r11
 
 [case testProperty]
 class PropertyHolder:
@@ -2424,45 +2198,54 @@ def __top_level__():
     r19 :: object
     r20 :: dict
     r21 :: str
-    r22, r23 :: object
-    r24 :: dict
-    r25 :: str
-    r26 :: int32
-    r27 :: bit
-    r28 :: str
-    r29 :: dict
+    r22 :: object
+    r23 :: object[2]
+    r24 :: object_ptr
+    r25 :: object
+    r26 :: dict
+    r27 :: str
+    r28 :: i32
+    r29 :: bit
     r30 :: str
-    r31, r32, r33 :: object
-    r34 :: tuple
-    r35 :: dict
-    r36 :: str
-    r37 :: int32
-    r38 :: bit
+    r31 :: dict
+    r32 :: str
+    r33, r34 :: object
+    r35 :: object[2]
+    r36 :: object_ptr
+    r37 :: object
+    r38 :: tuple
     r39 :: dict
     r40 :: str
-    r41, r42, r43 :: object
-    r44 :: dict
-    r45 :: str
-    r46 :: int32
-    r47 :: bit
-    r48 :: str
-    r49 :: dict
-    r50 :: str
-    r51 :: object
-    r52 :: dict
-    r53 :: str
-    r54, r55 :: object
+    r41 :: i32
+    r42 :: bit
+    r43 :: dict
+    r44 :: str
+    r45, r46, r47 :: object
+    r48 :: dict
+    r49 :: str
+    r50 :: i32
+    r51 :: bit
+    r52 :: str
+    r53 :: dict
+    r54 :: str
+    r55 :: object
     r56 :: dict
     r57 :: str
-    r58 :: int32
-    r59 :: bit
-    r60 :: list
-    r61, r62, r63 :: object
-    r64, r65, r66, r67 :: ptr
-    r68 :: dict
-    r69 :: str
-    r70 :: int32
-    r71 :: bit
+    r58 :: object
+    r59 :: object[2]
+    r60 :: object_ptr
+    r61 :: object
+    r62 :: dict
+    r63 :: str
+    r64 :: i32
+    r65 :: bit
+    r66 :: list
+    r67, r68, r69 :: object
+    r70 :: ptr
+    r71 :: dict
+    r72 :: str
+    r73 :: i32
+    r74 :: bit
 L0:
     r0 = builtins :: module
     r1 = load_address _Py_NoneStruct
@@ -2492,59 +2275,65 @@ L2:
     r20 = __main__.globals :: static
     r21 = 'NamedTuple'
     r22 = CPyDict_GetItem(r20, r21)
-    r23 = PyObject_CallFunctionObjArgs(r22, r9, r19, 0)
-    r24 = __main__.globals :: static
-    r25 = 'Lol'
-    r26 = CPyDict_SetItem(r24, r25, r23)
-    r27 = r26 >= 0 :: signed
-    r28 = ''
-    r29 = __main__.globals :: static
-    r30 = 'Lol'
-    r31 = CPyDict_GetItem(r29, r30)
-    r32 = object 1
-    r33 = PyObject_CallFunctionObjArgs(r31, r32, r28, 0)
-    r34 = cast(tuple, r33)
-    r35 = __main__.globals :: static
-    r36 = 'x'
-    r37 = CPyDict_SetItem(r35, r36, r34)
-    r38 = r37 >= 0 :: signed
+    r23 = [r9, r19]
+    r24 = load_address r23
+    r25 = PyObject_Vectorcall(r22, r24, 2, 0)
+    keep_alive r9, r19
+    r26 = __main__.globals :: static
+    r27 = 'Lol'
+    r28 = CPyDict_SetItem(r26, r27, r25)
+    r29 = r28 >= 0 :: signed
+    r30 = ''
+    r31 = __main__.globals :: static
+    r32 = 'Lol'
+    r33 = CPyDict_GetItem(r31, r32)
+    r34 = object 1
+    r35 = [r34, r30]
+    r36 = load_address r35
+    r37 = PyObject_Vectorcall(r33, r36, 2, 0)
+    keep_alive r34, r30
+    r38 = cast(tuple, r37)
     r39 = __main__.globals :: static
-    r40 = 'List'
-    r41 = CPyDict_GetItem(r39, r40)
-    r42 = load_address PyLong_Type
-    r43 = PyObject_GetItem(r41, r42)
-    r44 = __main__.globals :: static
-    r45 = 'Foo'
-    r46 = CPyDict_SetItem(r44, r45, r43)
-    r47 = r46 >= 0 :: signed
-    r48 = 'Bar'
-    r49 = __main__.globals :: static
-    r50 = 'Foo'
-    r51 = CPyDict_GetItem(r49, r50)
-    r52 = __main__.globals :: static
-    r53 = 'NewType'
-    r54 = CPyDict_GetItem(r52, r53)
-    r55 = PyObject_CallFunctionObjArgs(r54, r48, r51, 0)
+    r40 = 'x'
+    r41 = CPyDict_SetItem(r39, r40, r38)
+    r42 = r41 >= 0 :: signed
+    r43 = __main__.globals :: static
+    r44 = 'List'
+    r45 = CPyDict_GetItem(r43, r44)
+    r46 = load_address PyLong_Type
+    r47 = PyObject_GetItem(r45, r46)
+    r48 = __main__.globals :: static
+    r49 = 'Foo'
+    r50 = CPyDict_SetItem(r48, r49, r47)
+    r51 = r50 >= 0 :: signed
+    r52 = 'Bar'
+    r53 = __main__.globals :: static
+    r54 = 'Foo'
+    r55 = CPyDict_GetItem(r53, r54)
     r56 = __main__.globals :: static
-    r57 = 'Bar'
-    r58 = CPyDict_SetItem(r56, r57, r55)
-    r59 = r58 >= 0 :: signed
-    r60 = PyList_New(3)
-    r61 = object 1
-    r62 = object 2
-    r63 = object 3
-    r64 = get_element_ptr r60 ob_item :: PyListObject
-    r65 = load_mem r64 :: ptr*
-    set_mem r65, r61 :: builtins.object*
-    r66 = r65 + WORD_SIZE*1
-    set_mem r66, r62 :: builtins.object*
-    r67 = r65 + WORD_SIZE*2
-    set_mem r67, r63 :: builtins.object*
-    keep_alive r60
-    r68 = __main__.globals :: static
-    r69 = 'y'
-    r70 = CPyDict_SetItem(r68, r69, r60)
-    r71 = r70 >= 0 :: signed
+    r57 = 'NewType'
+    r58 = CPyDict_GetItem(r56, r57)
+    r59 = [r52, r55]
+    r60 = load_address r59
+    r61 = PyObject_Vectorcall(r58, r60, 2, 0)
+    keep_alive r52, r55
+    r62 = __main__.globals :: static
+    r63 = 'Bar'
+    r64 = CPyDict_SetItem(r62, r63, r61)
+    r65 = r64 >= 0 :: signed
+    r66 = PyList_New(3)
+    r67 = object 1
+    r68 = object 2
+    r69 = object 3
+    r70 = list_items r66
+    buf_init_item r70, 0, r67
+    buf_init_item r70, 1, r68
+    buf_init_item r70, 2, r69
+    keep_alive r66
+    r71 = __main__.globals :: static
+    r72 = 'y'
+    r73 = CPyDict_SetItem(r71, r72, r66)
+    r74 = r73 >= 0 :: signed
     return 1
 
 [case testChainedConditional]
@@ -2559,60 +2348,24 @@ L0:
     return x
 def f(x, y, z):
     x, y, z, r0, r1 :: int
-    r2 :: native_int
-    r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
-    r8 :: bool
-    r9 :: bit
-    r10 :: bool
-    r11 :: int
-    r12 :: native_int
-    r13 :: bit
-    r14 :: native_int
-    r15, r16, r17 :: bit
-    r18 :: bool
-    r19 :: bit
+    r2 :: bit
+    r3 :: bool
+    r4 :: int
+    r5 :: bit
 L0:
     r0 = g(x)
     r1 = g(y)
-    r2 = r0 & 1
-    r3 = r2 == 0
-    r4 = r1 & 1
-    r5 = r4 == 0
-    r6 = r3 & r5
-    if r6 goto L1 else goto L2 :: bool
+    r2 = int_lt r0, r1
+    if r2 goto L2 else goto L1 :: bool
 L1:
-    r7 = r0 < r1 :: signed
-    r8 = r7
+    r3 = r2
     goto L3
 L2:
-    r9 = CPyTagged_IsLt_(r0, r1)
-    r8 = r9
+    r4 = g(z)
+    r5 = int_gt r1, r4
+    r3 = r5
 L3:
-    if r8 goto L5 else goto L4 :: bool
-L4:
-    r10 = r8
-    goto L9
-L5:
-    r11 = g(z)
-    r12 = r1 & 1
-    r13 = r12 == 0
-    r14 = r11 & 1
-    r15 = r14 == 0
-    r16 = r13 & r15
-    if r16 goto L6 else goto L7 :: bool
-L6:
-    r17 = r1 > r11 :: signed
-    r18 = r17
-    goto L8
-L7:
-    r19 = CPyTagged_IsLt_(r11, r1)
-    r18 = r19
-L8:
-    r10 = r18
-L9:
-    return r10
+    return r3
 
 [case testEq]
 class A:
@@ -2629,7 +2382,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
@@ -2641,7 +2394,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:
@@ -2691,47 +2444,55 @@ L2:
 def g_a_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.g_a_obj
     r0 :: __main__.a_env
-    r1, g :: object
-    r2 :: str
-    r3 :: object
-    r4 :: str
-    r5, r6, r7, r8 :: object
-    r9 :: str
-    r10 :: object
-    r11 :: str
-    r12, r13 :: object
+    r1 :: str
+    r2 :: object
+    r3 :: str
+    r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7, r8, r9 :: object
+    r10 :: str
+    r11 :: object
+    r12 :: str
+    r13 :: object
+    r14 :: object[1]
+    r15 :: object_ptr
+    r16 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.g
-    g = r1
-    r2 = 'Entering'
-    r3 = builtins :: module
-    r4 = 'print'
-    r5 = CPyObject_GetAttr(r3, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r2, 0)
-    r7 = r0.f
-    r8 = PyObject_CallFunctionObjArgs(r7, 0)
-    r9 = 'Exited'
-    r10 = builtins :: module
-    r11 = 'print'
-    r12 = CPyObject_GetAttr(r10, r11)
-    r13 = PyObject_CallFunctionObjArgs(r12, r9, 0)
+    r1 = 'Entering'
+    r2 = builtins :: module
+    r3 = 'print'
+    r4 = CPyObject_GetAttr(r2, r3)
+    r5 = [r1]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
+    keep_alive r1
+    r8 = r0.f
+    r9 = PyObject_Vectorcall(r8, 0, 0, 0)
+    r10 = 'Exited'
+    r11 = builtins :: module
+    r12 = 'print'
+    r13 = CPyObject_GetAttr(r11, r12)
+    r14 = [r10]
+    r15 = load_address r14
+    r16 = PyObject_Vectorcall(r13, r15, 1, 0)
+    keep_alive r10
     return 1
 def a(f):
     f :: object
     r0 :: __main__.a_env
     r1 :: bool
     r2 :: __main__.g_a_obj
-    r3, r4 :: bool
-    r5 :: object
+    r3 :: bool
+    g :: object
 L0:
     r0 = a_env()
     r0.f = f; r1 = is_error
     r2 = g_a_obj()
     r2.__mypyc_env__ = r0; r3 = is_error
-    r0.g = r2; r4 = is_error
-    r5 = r0.g
-    return r5
+    g = r2
+    return g
 def g_b_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -2748,47 +2509,55 @@ L2:
 def g_b_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.g_b_obj
     r0 :: __main__.b_env
-    r1, g :: object
-    r2 :: str
-    r3 :: object
-    r4 :: str
-    r5, r6, r7, r8 :: object
-    r9 :: str
-    r10 :: object
-    r11 :: str
-    r12, r13 :: object
+    r1 :: str
+    r2 :: object
+    r3 :: str
+    r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7, r8, r9 :: object
+    r10 :: str
+    r11 :: object
+    r12 :: str
+    r13 :: object
+    r14 :: object[1]
+    r15 :: object_ptr
+    r16 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.g
-    g = r1
-    r2 = '---'
-    r3 = builtins :: module
-    r4 = 'print'
-    r5 = CPyObject_GetAttr(r3, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r2, 0)
-    r7 = r0.f
-    r8 = PyObject_CallFunctionObjArgs(r7, 0)
-    r9 = '---'
-    r10 = builtins :: module
-    r11 = 'print'
-    r12 = CPyObject_GetAttr(r10, r11)
-    r13 = PyObject_CallFunctionObjArgs(r12, r9, 0)
+    r1 = '---'
+    r2 = builtins :: module
+    r3 = 'print'
+    r4 = CPyObject_GetAttr(r2, r3)
+    r5 = [r1]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
+    keep_alive r1
+    r8 = r0.f
+    r9 = PyObject_Vectorcall(r8, 0, 0, 0)
+    r10 = '---'
+    r11 = builtins :: module
+    r12 = 'print'
+    r13 = CPyObject_GetAttr(r11, r12)
+    r14 = [r10]
+    r15 = load_address r14
+    r16 = PyObject_Vectorcall(r13, r15, 1, 0)
+    keep_alive r10
     return 1
 def b(f):
     f :: object
     r0 :: __main__.b_env
     r1 :: bool
     r2 :: __main__.g_b_obj
-    r3, r4 :: bool
-    r5 :: object
+    r3 :: bool
+    g :: object
 L0:
     r0 = b_env()
     r0.f = f; r1 = is_error
     r2 = g_b_obj()
     r2.__mypyc_env__ = r0; r3 = is_error
-    r0.g = r2; r4 = is_error
-    r5 = r0.g
-    return r5
+    g = r2
+    return g
 def d_c_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -2805,20 +2574,23 @@ L2:
 def d_c_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.d_c_obj
     r0 :: __main__.c_env
-    r1, d :: object
-    r2 :: str
-    r3 :: object
-    r4 :: str
-    r5, r6 :: object
+    r1 :: str
+    r2 :: object
+    r3 :: str
+    r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.d
-    d = r1
-    r2 = 'd'
-    r3 = builtins :: module
-    r4 = 'print'
-    r5 = CPyObject_GetAttr(r3, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r2, 0)
+    r1 = 'd'
+    r2 = builtins :: module
+    r3 = 'print'
+    r4 = CPyObject_GetAttr(r2, r3)
+    r5 = [r1]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
+    keep_alive r1
     return 1
 def c():
     r0 :: __main__.c_env
@@ -2826,19 +2598,27 @@ def c():
     r2 :: bool
     r3 :: dict
     r4 :: str
-    r5, r6 :: object
-    r7 :: dict
-    r8 :: str
-    r9, r10 :: object
-    r11 :: bool
-    r12 :: dict
-    r13 :: str
-    r14 :: int32
-    r15 :: bit
+    r5 :: object
+    r6 :: object[1]
+    r7 :: object_ptr
+    r8 :: object
+    r9 :: dict
+    r10 :: str
+    r11 :: object
+    r12 :: object[1]
+    r13 :: object_ptr
+    r14, d :: object
+    r15 :: dict
     r16 :: str
-    r17 :: object
-    r18 :: str
-    r19, r20, r21, r22 :: object
+    r17 :: i32
+    r18 :: bit
+    r19 :: str
+    r20 :: object
+    r21 :: str
+    r22 :: object
+    r23 :: object[1]
+    r24 :: object_ptr
+    r25, r26 :: object
 L0:
     r0 = c_env()
     r1 = d_c_obj()
@@ -2846,23 +2626,31 @@ L0:
     r3 = __main__.globals :: static
     r4 = 'b'
     r5 = CPyDict_GetItem(r3, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r1, 0)
-    r7 = __main__.globals :: static
-    r8 = 'a'
-    r9 = CPyDict_GetItem(r7, r8)
-    r10 = PyObject_CallFunctionObjArgs(r9, r6, 0)
-    r0.d = r10; r11 = is_error
-    r12 = __main__.globals :: static
-    r13 = 'd'
-    r14 = CPyDict_SetItem(r12, r13, r10)
-    r15 = r14 >= 0 :: signed
-    r16 = 'c'
-    r17 = builtins :: module
-    r18 = 'print'
-    r19 = CPyObject_GetAttr(r17, r18)
-    r20 = PyObject_CallFunctionObjArgs(r19, r16, 0)
-    r21 = r0.d
-    r22 = PyObject_CallFunctionObjArgs(r21, 0)
+    r6 = [r1]
+    r7 = load_address r6
+    r8 = PyObject_Vectorcall(r5, r7, 1, 0)
+    keep_alive r1
+    r9 = __main__.globals :: static
+    r10 = 'a'
+    r11 = CPyDict_GetItem(r9, r10)
+    r12 = [r8]
+    r13 = load_address r12
+    r14 = PyObject_Vectorcall(r11, r13, 1, 0)
+    keep_alive r8
+    d = r14
+    r15 = __main__.globals :: static
+    r16 = 'd'
+    r17 = CPyDict_SetItem(r15, r16, r14)
+    r18 = r17 >= 0 :: signed
+    r19 = 'c'
+    r20 = builtins :: module
+    r21 = 'print'
+    r22 = CPyObject_GetAttr(r20, r21)
+    r23 = [r19]
+    r24 = load_address r23
+    r25 = PyObject_Vectorcall(r22, r24, 1, 0)
+    keep_alive r19
+    r26 = PyObject_Vectorcall(d, 0, 0, 0)
     return 1
 def __top_level__():
     r0, r1 :: object
@@ -2877,14 +2665,20 @@ def __top_level__():
     r11 :: object
     r12 :: dict
     r13 :: str
-    r14, r15 :: object
-    r16 :: dict
-    r17 :: str
-    r18, r19 :: object
-    r20 :: dict
-    r21 :: str
-    r22 :: int32
-    r23 :: bit
+    r14 :: object
+    r15 :: object[1]
+    r16 :: object_ptr
+    r17 :: object
+    r18 :: dict
+    r19 :: str
+    r20 :: object
+    r21 :: object[1]
+    r22 :: object_ptr
+    r23 :: object
+    r24 :: dict
+    r25 :: str
+    r26 :: i32
+    r27 :: bit
 L0:
     r0 = builtins :: module
     r1 = load_address _Py_NoneStruct
@@ -2906,15 +2700,21 @@ L2:
     r12 = __main__.globals :: static
     r13 = 'b'
     r14 = CPyDict_GetItem(r12, r13)
-    r15 = PyObject_CallFunctionObjArgs(r14, r11, 0)
-    r16 = __main__.globals :: static
-    r17 = 'a'
-    r18 = CPyDict_GetItem(r16, r17)
-    r19 = PyObject_CallFunctionObjArgs(r18, r15, 0)
-    r20 = __main__.globals :: static
-    r21 = 'c'
-    r22 = CPyDict_SetItem(r20, r21, r19)
-    r23 = r22 >= 0 :: signed
+    r15 = [r11]
+    r16 = load_address r15
+    r17 = PyObject_Vectorcall(r14, r16, 1, 0)
+    keep_alive r11
+    r18 = __main__.globals :: static
+    r19 = 'a'
+    r20 = CPyDict_GetItem(r18, r19)
+    r21 = [r17]
+    r22 = load_address r21
+    r23 = PyObject_Vectorcall(r20, r22, 1, 0)
+    keep_alive r17
+    r24 = __main__.globals :: static
+    r25 = 'c'
+    r26 = CPyDict_SetItem(r24, r25, r23)
+    r27 = r26 >= 0 :: signed
     return 1
 
 [case testDecoratorsSimple_toplevel]
@@ -2944,47 +2744,55 @@ L2:
 def g_a_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.g_a_obj
     r0 :: __main__.a_env
-    r1, g :: object
-    r2 :: str
-    r3 :: object
-    r4 :: str
-    r5, r6, r7, r8 :: object
-    r9 :: str
-    r10 :: object
-    r11 :: str
-    r12, r13 :: object
+    r1 :: str
+    r2 :: object
+    r3 :: str
+    r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7, r8, r9 :: object
+    r10 :: str
+    r11 :: object
+    r12 :: str
+    r13 :: object
+    r14 :: object[1]
+    r15 :: object_ptr
+    r16 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.g
-    g = r1
-    r2 = 'Entering'
-    r3 = builtins :: module
-    r4 = 'print'
-    r5 = CPyObject_GetAttr(r3, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r2, 0)
-    r7 = r0.f
-    r8 = PyObject_CallFunctionObjArgs(r7, 0)
-    r9 = 'Exited'
-    r10 = builtins :: module
-    r11 = 'print'
-    r12 = CPyObject_GetAttr(r10, r11)
-    r13 = PyObject_CallFunctionObjArgs(r12, r9, 0)
+    r1 = 'Entering'
+    r2 = builtins :: module
+    r3 = 'print'
+    r4 = CPyObject_GetAttr(r2, r3)
+    r5 = [r1]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
+    keep_alive r1
+    r8 = r0.f
+    r9 = PyObject_Vectorcall(r8, 0, 0, 0)
+    r10 = 'Exited'
+    r11 = builtins :: module
+    r12 = 'print'
+    r13 = CPyObject_GetAttr(r11, r12)
+    r14 = [r10]
+    r15 = load_address r14
+    r16 = PyObject_Vectorcall(r13, r15, 1, 0)
+    keep_alive r10
     return 1
 def a(f):
     f :: object
     r0 :: __main__.a_env
     r1 :: bool
     r2 :: __main__.g_a_obj
-    r3, r4 :: bool
-    r5 :: object
+    r3 :: bool
+    g :: object
 L0:
     r0 = a_env()
     r0.f = f; r1 = is_error
     r2 = g_a_obj()
     r2.__mypyc_env__ = r0; r3 = is_error
-    r0.g = r2; r4 = is_error
-    r5 = r0.g
-    return r5
+    g = r2
+    return g
 def __top_level__():
     r0, r1 :: object
     r2 :: bit
@@ -3025,85 +2833,57 @@ def call_any(l):
     r0 :: bool
     r1, r2 :: object
     r3, i :: int
-    r4 :: native_int
-    r5, r6 :: bit
-    r7 :: bool
-    r8, r9 :: bit
+    r4, r5 :: bit
 L0:
     r0 = 0
     r1 = PyObject_GetIter(l)
 L1:
     r2 = PyIter_Next(r1)
-    if is_error(r2) goto L9 else goto L2
+    if is_error(r2) goto L6 else goto L2
 L2:
     r3 = unbox(int, r2)
     i = r3
-    r4 = i & 1
-    r5 = r4 == 0
-    if r5 goto L3 else goto L4 :: bool
+    r4 = int_eq i, 0
+    if r4 goto L3 else goto L4 :: bool
 L3:
-    r6 = i == 0
-    r7 = r6
-    goto L5
+    r0 = 1
+    goto L8
 L4:
-    r8 = CPyTagged_IsEq_(i, 0)
-    r7 = r8
 L5:
-    if r7 goto L6 else goto L7 :: bool
+    goto L1
 L6:
-    r0 = 1
-    goto L11
+    r5 = CPy_NoErrOccurred()
 L7:
 L8:
-    goto L1
-L9:
-    r9 = CPy_NoErrOccured()
-L10:
-L11:
     return r0
 def call_all(l):
     l :: object
     r0 :: bool
     r1, r2 :: object
     r3, i :: int
-    r4 :: native_int
-    r5, r6 :: bit
-    r7 :: bool
-    r8 :: bit
-    r9 :: bool
-    r10 :: bit
+    r4, r5, r6 :: bit
 L0:
     r0 = 1
     r1 = PyObject_GetIter(l)
 L1:
     r2 = PyIter_Next(r1)
-    if is_error(r2) goto L9 else goto L2
+    if is_error(r2) goto L6 else goto L2
 L2:
     r3 = unbox(int, r2)
     i = r3
-    r4 = i & 1
-    r5 = r4 == 0
+    r4 = int_eq i, 0
+    r5 = r4 ^ 1
     if r5 goto L3 else goto L4 :: bool
 L3:
-    r6 = i == 0
-    r7 = r6
-    goto L5
+    r0 = 0
+    goto L8
 L4:
-    r8 = CPyTagged_IsEq_(i, 0)
-    r7 = r8
 L5:
-    r9 = r7 ^ 1
-    if r9 goto L6 else goto L7 :: bool
+    goto L1
 L6:
-    r0 = 0
-    goto L11
+    r6 = CPy_NoErrOccurred()
 L7:
 L8:
-    goto L1
-L9:
-    r10 = CPy_NoErrOccured()
-L10:
-L11:
     return r0
 
 [case testSum]
@@ -3118,10 +2898,13 @@ def call_sum(l, comparison):
     r0 :: int
     r1, r2 :: object
     r3, x :: int
-    r4, r5 :: object
-    r6, r7 :: bool
-    r8, r9 :: int
-    r10 :: bit
+    r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7 :: object
+    r8, r9 :: bool
+    r10, r11 :: int
+    r12 :: bit
 L0:
     r0 = 0
     r1 = PyObject_GetIter(l)
@@ -3132,16 +2915,19 @@ L2:
     r3 = unbox(int, r2)
     x = r3
     r4 = box(int, x)
-    r5 = PyObject_CallFunctionObjArgs(comparison, r4, 0)
-    r6 = unbox(bool, r5)
-    r7 = r6 << 1
-    r8 = extend r7: builtins.bool to builtins.int
-    r9 = CPyTagged_Add(r0, r8)
-    r0 = r9
+    r5 = [r4]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(comparison, r6, 1, 0)
+    keep_alive r4
+    r8 = unbox(bool, r7)
+    r9 = r8 << 1
+    r10 = extend r9: builtins.bool to builtins.int
+    r11 = CPyTagged_Add(r0, r10)
+    r0 = r11
 L3:
     goto L1
 L4:
-    r10 = CPy_NoErrOccured()
+    r12 = CPy_NoErrOccurred()
 L5:
     return r0
 
@@ -3154,7 +2940,7 @@ def lol(x: Any):
 def lol(x):
     x :: object
     r0, r1 :: str
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: object
 L0:
@@ -3351,6 +3137,32 @@ def foo(z):
 L0:
     return 1
 
+[case testFinalLocals]
+from typing import Final
+
+def inlined() -> str:
+    # XXX: the final type must be declared explicitly for Var.final_value to be set.
+    const: Final[str] = "Oppenheimer"
+    return const
+
+def local() -> str:
+    const: Final[str] = inlined()
+    return const
+[out]
+def inlined():
+    r0, const, r1 :: str
+L0:
+    r0 = 'Oppenheimer'
+    const = r0
+    r1 = 'Oppenheimer'
+    return r1
+def local():
+    r0, const :: str
+L0:
+    r0 = inlined()
+    const = r0
+    return const
+
 [case testDirectlyCall__bool__]
 class A:
     def __bool__(self) -> bool:
@@ -3395,13 +3207,19 @@ def f(x):
     x :: int
     r0 :: object
     r1 :: str
-    r2, r3, r4 :: object
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
 L0:
     r0 = builtins :: module
     r1 = 'reveal_type'
     r2 = CPyObject_GetAttr(r0, r1)
     r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
     return 1
 
 [case testCallCWithStrJoinMethod]
@@ -3459,13 +3277,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]
@@ -3490,7 +3308,7 @@ def root():
     r7 :: dict
     r8 :: str
     r9 :: object
-    r10 :: int32
+    r10 :: i32
     r11 :: bit
     r12 :: dict
     r13, r14 :: object
@@ -3501,7 +3319,7 @@ def root():
     r19 :: dict
     r20 :: str
     r21 :: object
-    r22 :: int32
+    r22 :: i32
     r23 :: bit
 L0:
     r0 = __main__.globals :: static
@@ -3547,7 +3365,7 @@ def submodule():
     r7 :: dict
     r8 :: str
     r9 :: object
-    r10 :: int32
+    r10 :: i32
     r11 :: bit
     r12 :: dict
     r13 :: str
@@ -3586,14 +3404,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]
@@ -3609,34 +3427,40 @@ def range_in_loop() -> None:
         sum += i
 [out]
 def range_object():
-    r0, r1, r2, r3, r4 :: object
-    r5, r :: range
+    r0, r1, r2, r3 :: object
+    r4 :: object[3]
+    r5 :: object_ptr
+    r6 :: object
+    r7, r :: range
     sum :: int
-    r6, r7 :: object
-    r8, i, r9 :: int
-    r10 :: bit
+    r8, r9 :: object
+    r10, i, r11 :: int
+    r12 :: bit
 L0:
     r0 = load_address PyRange_Type
     r1 = object 4
     r2 = object 12
     r3 = object 2
-    r4 = PyObject_CallFunctionObjArgs(r0, r1, r2, r3, 0)
-    r5 = cast(range, r4)
-    r = r5
+    r4 = [r1, r2, r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r0, r5, 3, 0)
+    keep_alive r1, r2, r3
+    r7 = cast(range, r6)
+    r = r7
     sum = 0
-    r6 = PyObject_GetIter(r)
+    r8 = PyObject_GetIter(r)
 L1:
-    r7 = PyIter_Next(r6)
-    if is_error(r7) goto L4 else goto L2
+    r9 = PyIter_Next(r8)
+    if is_error(r9) goto L4 else goto L2
 L2:
-    r8 = unbox(int, r7)
-    i = r8
-    r9 = CPyTagged_Add(sum, i)
-    sum = r9
+    r10 = unbox(int, r9)
+    i = r10
+    r11 = CPyTagged_Add(sum, i)
+    sum = r11
 L3:
     goto L1
 L4:
-    r10 = CPy_NoErrOccured()
+    r12 = CPy_NoErrOccurred()
 L5:
     return 1
 def range_in_loop():
@@ -3651,7 +3475,7 @@ L0:
     r0 = 8
     i = r0
 L1:
-    r1 = r0 < 24 :: signed
+    r1 = int_lt r0, 24
     if r1 goto L2 else goto L4 :: bool
 L2:
     r2 = CPyTagged_Add(sum, i)
@@ -3702,3 +3526,33 @@ def f(arg):
     arg :: __main__.A
 L0:
     return arg
+
+[case testTypeCheckingFlag]
+from typing import TYPE_CHECKING, List
+
+def f(arg: List[int]) -> int:
+    if TYPE_CHECKING:
+        from collections.abc import Sized
+    s: Sized = arg
+    return len(s)
+
+[out]
+def f(arg):
+    arg :: list
+    r0 :: bool
+    r1 :: int
+    r2 :: bit
+    s :: object
+    r3 :: int
+L0:
+    r0 = 0 << 1
+    r1 = extend r0: builtins.bool to builtins.int
+    r2 = r1 != 0
+    if r2 goto L1 else goto L2 :: bool
+L1:
+    goto L3
+L2:
+L3:
+    s = arg
+    r3 = CPyObject_Size(s)
+    return r3
diff --git a/mypyc/test-data/irbuild-bool.test b/mypyc/test-data/irbuild-bool.test
index 9257d8d63f7e..128266e6b1d7 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]
@@ -87,26 +87,23 @@ L0:
     return 1
 def list_to_bool(l):
     l :: list
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3 :: bit
-L0:
-    r0 = get_element_ptr l ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive l
-    r2 = r1 << 1
-    r3 = r2 != 0
-    return r3
+    r0 :: native_int
+    r1 :: short_int
+    r2 :: bit
+L0:
+    r0 = var_object_size l
+    r1 = r0 << 1
+    r2 = int_ne r1, 0
+    return r2
 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
@@ -222,7 +219,7 @@ def eq1(x, y):
 L0:
     r0 = y << 1
     r1 = extend r0: builtins.bool to builtins.int
-    r2 = x == r1
+    r2 = int_eq x, r1
     return r2
 def eq2(x, y):
     x :: bool
@@ -233,23 +230,23 @@ def eq2(x, y):
 L0:
     r0 = x << 1
     r1 = extend r0: builtins.bool to builtins.int
-    r2 = r1 == y
+    r2 = int_eq 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
 
@@ -272,74 +269,38 @@ def lt1(x, y):
     x :: bool
     y :: int
     r0 :: bool
-    r1 :: short_int
-    r2 :: native_int
-    r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
-    r8 :: bool
-    r9 :: bit
+    r1 :: int
+    r2 :: bit
 L0:
     r0 = x << 1
-    r1 = extend r0: builtins.bool to short_int
-    r2 = r1 & 1
-    r3 = r2 == 0
-    r4 = y & 1
-    r5 = r4 == 0
-    r6 = r3 & r5
-    if r6 goto L1 else goto L2 :: bool
-L1:
-    r7 = r1 < y :: signed
-    r8 = r7
-    goto L3
-L2:
-    r9 = CPyTagged_IsLt_(r1, y)
-    r8 = r9
-L3:
-    return r8
+    r1 = extend r0: builtins.bool to builtins.int
+    r2 = int_lt r1, y
+    return r2
 def lt2(x, y):
     x :: int
     y, r0 :: bool
-    r1 :: short_int
-    r2 :: native_int
-    r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
-    r8 :: bool
-    r9 :: bit
+    r1 :: int
+    r2 :: bit
 L0:
     r0 = y << 1
-    r1 = extend r0: builtins.bool to short_int
-    r2 = x & 1
-    r3 = r2 == 0
-    r4 = r1 & 1
-    r5 = r4 == 0
-    r6 = r3 & r5
-    if r6 goto L1 else goto L2 :: bool
-L1:
-    r7 = x < r1 :: signed
-    r8 = r7
-    goto L3
-L2:
-    r9 = CPyTagged_IsLt_(x, r1)
-    r8 = r9
-L3:
-    return r8
+    r1 = extend r0: builtins.bool to builtins.int
+    r2 = int_lt x, r1
+    return r2
 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 +347,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 f13a1a956580..476c5ac59f48 100644
--- a/mypyc/test-data/irbuild-bytes.test
+++ b/mypyc/test-data/irbuild-bytes.test
@@ -13,24 +13,30 @@ def f(num, l, d, s):
     s :: str
     r0, r1 :: object
     r2, b1 :: bytes
-    r3, r4, r5 :: object
-    r6, b2, r7, b3, r8, b4, r9, b5 :: bytes
+    r3, r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7 :: object
+    r8, b2, r9, b3, r10, b4, r11, b5 :: bytes
 L0:
     r0 = load_address PyBytes_Type
-    r1 = PyObject_CallFunctionObjArgs(r0, 0)
+    r1 = PyObject_Vectorcall(r0, 0, 0, 0)
     r2 = cast(bytes, r1)
     b1 = r2
     r3 = load_address PyBytes_Type
     r4 = box(int, num)
-    r5 = PyObject_CallFunctionObjArgs(r3, r4, 0)
-    r6 = cast(bytes, r5)
-    b2 = r6
-    r7 = PyBytes_FromObject(l)
-    b3 = r7
-    r8 = PyBytes_FromObject(d)
-    b4 = r8
-    r9 = PyBytes_FromObject(s)
-    b5 = r9
+    r5 = [r4]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(r3, r6, 1, 0)
+    keep_alive r4
+    r8 = cast(bytes, r7)
+    b2 = r8
+    r9 = PyBytes_FromObject(l)
+    b3 = r9
+    r10 = PyBytes_FromObject(d)
+    b4 = r10
+    r11 = PyBytes_FromObject(s)
+    b5 = r11
     return 1
 
 [case testBytearrayBasics]
@@ -53,7 +59,7 @@ L0:
     r0 = builtins :: module
     r1 = 'bytearray'
     r2 = CPyObject_GetAttr(r0, r1)
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
     a = r3
     r4 = PyByteArray_FromObject(s)
     b = r4
@@ -71,7 +77,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 +86,7 @@ L0:
     return r2
 def neq(x, y):
     x, y :: bytes
-    r0 :: int32
+    r0 :: i32
     r1, r2 :: bit
 L0:
     r0 = CPyBytes_Compare(x, y)
@@ -140,15 +146,12 @@ def f(b: bytes) -> int:
 [out]
 def f(b):
     b :: bytes
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
+    r0 :: native_int
+    r1 :: short_int
 L0:
-    r0 = get_element_ptr b ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive b
-    r2 = r1 << 1
-    return r2
+    r0 = var_object_size b
+    r1 = r0 << 1
+    return r1
 
 [case testBytesFormatting]
 def f(var: bytes, num: int) -> None:
diff --git a/mypyc/test-data/irbuild-classes.test b/mypyc/test-data/irbuild-classes.test
index 0a7076e5f0ad..9d564a552a05 100644
--- a/mypyc/test-data/irbuild-classes.test
+++ b/mypyc/test-data/irbuild-classes.test
@@ -41,28 +41,27 @@ def f():
     r0, c :: __main__.C
     r1 :: bool
     r2 :: list
-    r3, r4 :: ptr
+    r3 :: ptr
     a :: list
-    r5 :: object
-    r6, d :: __main__.C
-    r7, r8 :: int
+    r4 :: object
+    r5, d :: __main__.C
+    r6, r7 :: int
 L0:
     r0 = C()
     c = r0
     c.x = 10; r1 = is_error
     r2 = PyList_New(1)
-    r3 = get_element_ptr r2 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, c :: builtins.object*
+    r3 = list_items r2
+    buf_init_item r3, 0, c
     keep_alive r2
     a = r2
-    r5 = CPyList_GetItemShort(a, 0)
-    r6 = cast(__main__.C, r5)
-    d = r6
-    r7 = borrow d.x
-    r8 = CPyTagged_Add(r7, 2)
+    r4 = CPyList_GetItemShort(a, 0)
+    r5 = cast(__main__.C, r4)
+    d = r5
+    r6 = borrow d.x
+    r7 = CPyTagged_Add(r6, 2)
     keep_alive d
-    return r8
+    return r7
 
 [case testMethodCall]
 class A:
@@ -210,53 +209,56 @@ def __top_level__():
     r13 :: str
     r14 :: dict
     r15 :: str
-    r16, r17 :: object
-    r18 :: dict
-    r19 :: str
-    r20 :: int32
-    r21 :: bit
-    r22 :: object
-    r23 :: str
-    r24, r25 :: object
-    r26 :: bool
-    r27 :: str
-    r28 :: tuple
-    r29 :: int32
-    r30 :: bit
-    r31 :: dict
-    r32 :: str
-    r33 :: int32
-    r34 :: bit
-    r35 :: object
-    r36 :: str
-    r37, r38 :: object
-    r39 :: str
-    r40 :: tuple
-    r41 :: int32
-    r42 :: bit
-    r43 :: dict
-    r44 :: str
-    r45 :: int32
-    r46 :: bit
-    r47, r48 :: object
-    r49 :: dict
-    r50 :: str
-    r51 :: object
-    r52 :: dict
-    r53 :: str
-    r54, r55 :: object
-    r56 :: tuple
-    r57 :: str
-    r58, r59 :: object
-    r60 :: bool
-    r61, r62 :: str
-    r63 :: tuple
-    r64 :: int32
-    r65 :: bit
-    r66 :: dict
-    r67 :: str
-    r68 :: int32
-    r69 :: bit
+    r16 :: object
+    r17 :: object[1]
+    r18 :: object_ptr
+    r19 :: object
+    r20 :: dict
+    r21 :: str
+    r22 :: i32
+    r23 :: bit
+    r24 :: object
+    r25 :: str
+    r26, r27 :: object
+    r28 :: bool
+    r29 :: str
+    r30 :: tuple
+    r31 :: i32
+    r32 :: bit
+    r33 :: dict
+    r34 :: str
+    r35 :: i32
+    r36 :: bit
+    r37 :: object
+    r38 :: str
+    r39, r40 :: object
+    r41 :: str
+    r42 :: tuple
+    r43 :: i32
+    r44 :: bit
+    r45 :: dict
+    r46 :: str
+    r47 :: i32
+    r48 :: bit
+    r49, r50 :: object
+    r51 :: dict
+    r52 :: str
+    r53 :: object
+    r54 :: dict
+    r55 :: str
+    r56, r57 :: object
+    r58 :: tuple
+    r59 :: str
+    r60, r61 :: object
+    r62 :: bool
+    r63, r64 :: str
+    r65 :: tuple
+    r66 :: i32
+    r67 :: bit
+    r68 :: dict
+    r69 :: str
+    r70 :: i32
+    r71 :: bit
 L0:
     r0 = builtins :: module
     r1 = load_address _Py_NoneStruct
@@ -281,62 +283,65 @@ L2:
     r14 = __main__.globals :: static
     r15 = 'TypeVar'
     r16 = CPyDict_GetItem(r14, r15)
-    r17 = PyObject_CallFunctionObjArgs(r16, r13, 0)
-    r18 = __main__.globals :: static
-    r19 = 'T'
-    r20 = CPyDict_SetItem(r18, r19, r17)
-    r21 = r20 >= 0 :: signed
-    r22 = <error> :: object
-    r23 = '__main__'
-    r24 = __main__.C_template :: type
-    r25 = CPyType_FromTemplate(r24, r22, r23)
-    r26 = C_trait_vtable_setup()
-    r27 = '__mypyc_attrs__'
-    r28 = PyTuple_Pack(0)
-    r29 = PyObject_SetAttr(r25, r27, r28)
-    r30 = r29 >= 0 :: signed
-    __main__.C = r25 :: type
-    r31 = __main__.globals :: static
-    r32 = 'C'
-    r33 = CPyDict_SetItem(r31, r32, r25)
-    r34 = r33 >= 0 :: signed
-    r35 = <error> :: object
-    r36 = '__main__'
-    r37 = __main__.S_template :: type
-    r38 = CPyType_FromTemplate(r37, r35, r36)
-    r39 = '__mypyc_attrs__'
-    r40 = PyTuple_Pack(0)
-    r41 = PyObject_SetAttr(r38, r39, r40)
-    r42 = r41 >= 0 :: signed
-    __main__.S = r38 :: type
-    r43 = __main__.globals :: static
-    r44 = 'S'
-    r45 = CPyDict_SetItem(r43, r44, r38)
-    r46 = r45 >= 0 :: signed
-    r47 = __main__.C :: type
-    r48 = __main__.S :: type
-    r49 = __main__.globals :: static
-    r50 = 'Generic'
-    r51 = CPyDict_GetItem(r49, r50)
-    r52 = __main__.globals :: static
-    r53 = 'T'
-    r54 = CPyDict_GetItem(r52, r53)
-    r55 = PyObject_GetItem(r51, r54)
-    r56 = PyTuple_Pack(3, r47, r48, r55)
-    r57 = '__main__'
-    r58 = __main__.D_template :: type
-    r59 = CPyType_FromTemplate(r58, r56, r57)
-    r60 = D_trait_vtable_setup()
-    r61 = '__mypyc_attrs__'
-    r62 = '__dict__'
-    r63 = PyTuple_Pack(1, r62)
-    r64 = PyObject_SetAttr(r59, r61, r63)
-    r65 = r64 >= 0 :: signed
-    __main__.D = r59 :: type
-    r66 = __main__.globals :: static
-    r67 = 'D'
-    r68 = CPyDict_SetItem(r66, r67, r59)
-    r69 = r68 >= 0 :: signed
+    r17 = [r13]
+    r18 = load_address r17
+    r19 = PyObject_Vectorcall(r16, r18, 1, 0)
+    keep_alive r13
+    r20 = __main__.globals :: static
+    r21 = 'T'
+    r22 = CPyDict_SetItem(r20, r21, r19)
+    r23 = r22 >= 0 :: signed
+    r24 = <error> :: object
+    r25 = '__main__'
+    r26 = __main__.C_template :: type
+    r27 = CPyType_FromTemplate(r26, r24, r25)
+    r28 = C_trait_vtable_setup()
+    r29 = '__mypyc_attrs__'
+    r30 = PyTuple_Pack(0)
+    r31 = PyObject_SetAttr(r27, r29, r30)
+    r32 = r31 >= 0 :: signed
+    __main__.C = r27 :: type
+    r33 = __main__.globals :: static
+    r34 = 'C'
+    r35 = CPyDict_SetItem(r33, r34, r27)
+    r36 = r35 >= 0 :: signed
+    r37 = <error> :: object
+    r38 = '__main__'
+    r39 = __main__.S_template :: type
+    r40 = CPyType_FromTemplate(r39, r37, r38)
+    r41 = '__mypyc_attrs__'
+    r42 = PyTuple_Pack(0)
+    r43 = PyObject_SetAttr(r40, r41, r42)
+    r44 = r43 >= 0 :: signed
+    __main__.S = r40 :: type
+    r45 = __main__.globals :: static
+    r46 = 'S'
+    r47 = CPyDict_SetItem(r45, r46, r40)
+    r48 = r47 >= 0 :: signed
+    r49 = __main__.C :: type
+    r50 = __main__.S :: type
+    r51 = __main__.globals :: static
+    r52 = 'Generic'
+    r53 = CPyDict_GetItem(r51, r52)
+    r54 = __main__.globals :: static
+    r55 = 'T'
+    r56 = CPyDict_GetItem(r54, r55)
+    r57 = PyObject_GetItem(r53, r56)
+    r58 = PyTuple_Pack(3, r49, r50, r57)
+    r59 = '__main__'
+    r60 = __main__.D_template :: type
+    r61 = CPyType_FromTemplate(r60, r58, r59)
+    r62 = D_trait_vtable_setup()
+    r63 = '__mypyc_attrs__'
+    r64 = '__dict__'
+    r65 = PyTuple_Pack(1, r64)
+    r66 = PyObject_SetAttr(r61, r63, r65)
+    r67 = r66 >= 0 :: signed
+    __main__.D = r61 :: type
+    r68 = __main__.globals :: static
+    r69 = 'D'
+    r70 = CPyDict_SetItem(r68, r69, r61)
+    r71 = r70 >= 0 :: signed
     return 1
 
 [case testIsInstance]
@@ -601,7 +606,7 @@ L0:
     r3 = CPyTagged_Add(r0, r2)
     return r3
 
-[case testCallClassMethodViaCls]
+[case testCallClassMethodViaCls_64bit]
 class C:
     @classmethod
     def f(cls, x: int) -> int:
@@ -614,7 +619,7 @@ class C:
 class D:
     @classmethod
     def f(cls, x: int) -> int:
-        # TODO: This could aso be optimized, since g is not ever overridden
+        # TODO: This could also be optimized, since g is not ever overridden
         return cls.g(x)
 
     @classmethod
@@ -642,14 +647,20 @@ def D.f(cls, x):
     cls :: object
     x :: int
     r0 :: str
-    r1, r2 :: object
-    r3 :: int
+    r1 :: object
+    r2 :: object[2]
+    r3 :: object_ptr
+    r4 :: object
+    r5 :: int
 L0:
     r0 = 'g'
     r1 = box(int, x)
-    r2 = CPyObject_CallMethodObjArgs(cls, r0, r1, 0)
-    r3 = unbox(int, r2)
-    return r3
+    r2 = [cls, r1]
+    r3 = load_address r2
+    r4 = PyObject_VectorcallMethod(r0, r3, 9223372036854775810, 0)
+    keep_alive cls, r1
+    r5 = unbox(int, r4)
+    return r5
 def D.g(cls, x):
     cls :: object
     x :: int
@@ -748,18 +759,24 @@ def DictSubclass.__init__(self):
     self :: dict
     r0 :: object
     r1 :: str
-    r2, r3, r4 :: object
-    r5 :: str
-    r6, r7 :: object
+    r2, r3 :: object
+    r4 :: object[2]
+    r5 :: object_ptr
+    r6 :: object
+    r7 :: str
+    r8, r9 :: object
 L0:
     r0 = builtins :: module
     r1 = 'super'
     r2 = CPyObject_GetAttr(r0, r1)
     r3 = __main__.DictSubclass :: type
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, self, 0)
-    r5 = '__init__'
-    r6 = CPyObject_GetAttr(r4, r5)
-    r7 = PyObject_CallFunctionObjArgs(r6, 0)
+    r4 = [r3, self]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 2, 0)
+    keep_alive r3, self
+    r7 = '__init__'
+    r8 = CPyObject_GetAttr(r6, r7)
+    r9 = PyObject_Vectorcall(r8, 0, 0, 0)
     return 1
 
 [case testClassVariable]
@@ -837,7 +854,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 +866,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:
@@ -893,7 +910,7 @@ L0:
     r1 = unbox(bool, r0)
     return r1
 
-[case testEqDefinedLater]
+[case testEqDefinedLater_64bit]
 def f(a: 'Base', b: 'Base') -> bool:
     return a == b
 
@@ -940,13 +957,18 @@ L0:
 def fOpt2(a, b):
     a, b :: __main__.Derived
     r0 :: str
-    r1 :: object
-    r2 :: bool
+    r1 :: object[2]
+    r2 :: object_ptr
+    r3 :: object
+    r4 :: bool
 L0:
     r0 = '__ne__'
-    r1 = CPyObject_CallMethodObjArgs(a, r0, b, 0)
-    r2 = unbox(bool, r1)
-    return r2
+    r1 = [a, b]
+    r2 = load_address r1
+    r3 = PyObject_VectorcallMethod(r0, r2, 9223372036854775810, 0)
+    keep_alive a, b
+    r4 = unbox(bool, r3)
+    return r4
 def Derived.__eq__(self, other):
     self :: __main__.Derived
     other, r0 :: object
@@ -957,7 +979,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 +991,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 +1051,7 @@ def foo(x: WelpDict) -> None:
 [out]
 def foo(x):
     x :: dict
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
 L0:
     r0 = CPyDict_Update(x, x)
@@ -1249,7 +1271,7 @@ L0:
     r0 = x.__getitem__(2)
     r1 = CPyList_GetItemShortBorrow(r0, 0)
     r2 = unbox(int, r1)
-    r3 = r2 == 4
+    r3 = int_eq r2, 4
     keep_alive r0
     if r3 goto L1 else goto L2 :: bool
 L1:
@@ -1301,3 +1323,61 @@ class T:
 
 class E(T):
     y: str  # E: Type of "y" is incompatible with definition in trait "T"
+
+
+[case testNestedClasses]
+def outer():
+    class Inner:  # E: Nested class definitions not supported
+        pass
+
+    return Inner
+
+if True:
+    class OtherInner:  # E: Nested class definitions not supported
+        pass
+
+[case testEnumClassAlias]
+from enum import Enum
+from typing import Literal, Union
+
+class SomeEnum(Enum):
+    AVALUE = "a"
+
+ALIAS = Literal[SomeEnum.AVALUE]
+ALIAS2 = Union[Literal[SomeEnum.AVALUE], None]
+
+[case testMypycAttrNativeClassErrors]
+from mypy_extensions import mypyc_attr
+
+@mypyc_attr(native_class=False)
+class AnnontatedNonExtensionClass:
+    pass
+
+@mypyc_attr(native_class=False)
+class DerivedExplicitNonNativeClass(AnnontatedNonExtensionClass):
+    pass
+
+
+def decorator(cls):
+    return cls
+
+@mypyc_attr(native_class=True)
+@decorator
+class NonNativeClassContradiction():  # E: Class is marked as native_class=True but it can't be a native class. Classes that have decorators other than supported decorators can't be native classes.
+    pass
+
+
+@mypyc_attr(native_class="yes")
+class BadUse():  # E: native_class must be used with True or False only
+    pass
+
+[case testMypycAttrNativeClassMetaError]
+from mypy_extensions import mypyc_attr
+
+@mypyc_attr(native_class=True)
+class M(type):  # E: Inheriting from most builtin types is unimplemented
+    pass
+
+@mypyc_attr(native_class=True)
+class A(metaclass=M):  # E: Class is marked as native_class=True but it can't be a native class. Classes with a metaclass other than ABCMeta, TypingMeta or GenericMeta can't be native classes.
+    pass
diff --git a/mypyc/test-data/irbuild-constant-fold.test b/mypyc/test-data/irbuild-constant-fold.test
index 866953f0c09a..cd953c84c541 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
@@ -190,7 +187,7 @@ L0:
     return 1
 
 [case testIntConstantFoldingFinal]
-from typing_extensions import Final
+from typing import Final
 X: Final = 5
 Y: Final = 2 + 4
 
@@ -206,7 +203,7 @@ L0:
     return 1
 
 [case testIntConstantFoldingClassFinal]
-from typing_extensions import Final
+from typing import Final
 class C:
     X: Final = 5
 
@@ -224,20 +221,260 @@ L0:
     a = 12
     return 1
 
+[case testFloatConstantFolding]
+from typing 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
+from typing 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 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 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
diff --git a/mypyc/test-data/irbuild-dict.test b/mypyc/test-data/irbuild-dict.test
index 362031b84e76..a71f5aa2d8a2 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
@@ -186,7 +186,7 @@ L3:
     r14 = CPyDict_CheckSize(d, r2)
     goto L1
 L4:
-    r15 = CPy_NoErrOccured()
+    r15 = CPy_NoErrOccurred()
 L5:
     return d
 
@@ -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'
@@ -218,8 +218,7 @@ L0:
     return r2
 
 [case testDictIterationMethods]
-from typing import Dict, Union
-from typing_extensions import TypedDict
+from typing import Dict, TypedDict, Union
 
 class Person(TypedDict):
     name: str
@@ -239,6 +238,7 @@ def typeddict(d: Person) -> None:
     for k, v in d.items():
         if k == "name":
             name = v
+[typing fixtures/typing-full.pyi]
 [out]
 def print_dict_methods(d1, d2):
     d1, d2 :: dict
@@ -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
@@ -295,7 +295,7 @@ L5:
     r13 = CPyDict_CheckSize(d1, r2)
     goto L1
 L6:
-    r14 = CPy_NoErrOccured()
+    r14 = CPy_NoErrOccurred()
 L7:
     r15 = 0
     r16 = PyDict_Size(d2)
@@ -325,7 +325,7 @@ L10:
     r33 = CPyDict_CheckSize(d2, r17)
     goto L8
 L11:
-    r34 = CPy_NoErrOccured()
+    r34 = CPy_NoErrOccurred()
 L12:
     return 1
 def union_of_dicts(d):
@@ -342,11 +342,14 @@ def union_of_dicts(d):
     r11 :: union[int, str]
     k :: str
     v :: union[int, str]
-    r12, r13 :: object
-    r14 :: int
+    r12 :: object
+    r13 :: object[1]
+    r14 :: object_ptr
     r15 :: object
-    r16 :: int32
-    r17, r18, r19 :: bit
+    r16 :: int
+    r17 :: object
+    r18 :: i32
+    r19, r20, r21 :: bit
 L0:
     r0 = PyDict_New()
     new = r0
@@ -368,16 +371,19 @@ L2:
     k = r10
     v = r11
     r12 = load_address PyLong_Type
-    r13 = PyObject_CallFunctionObjArgs(r12, v, 0)
-    r14 = unbox(int, r13)
-    r15 = box(int, r14)
-    r16 = CPyDict_SetItem(new, k, r15)
-    r17 = r16 >= 0 :: signed
+    r13 = [v]
+    r14 = load_address r13
+    r15 = PyObject_Vectorcall(r12, r14, 1, 0)
+    keep_alive v
+    r16 = unbox(int, r15)
+    r17 = box(int, r16)
+    r18 = CPyDict_SetItem(new, k, r17)
+    r19 = r18 >= 0 :: signed
 L3:
-    r18 = CPyDict_CheckSize(d, r3)
+    r20 = CPyDict_CheckSize(d, r3)
     goto L1
 L4:
-    r19 = CPy_NoErrOccured()
+    r21 = CPy_NoErrOccurred()
 L5:
     return 1
 def typeddict(d):
@@ -393,7 +399,7 @@ def typeddict(d):
     r9, k :: str
     v :: object
     r10 :: str
-    r11 :: int32
+    r11 :: i32
     r12 :: bit
     r13 :: object
     r14, r15, r16 :: bit
@@ -436,7 +442,7 @@ L8:
     r17 = CPyDict_CheckSize(d, r2)
     goto L1
 L9:
-    r18 = CPy_NoErrOccured()
+    r18 = CPy_NoErrOccurred()
 L10:
     return 1
 
@@ -537,8 +543,8 @@ def f3(d, flag):
     r2 :: str
     r3 :: list
     r4 :: object
-    r5, r6 :: ptr
-    r7, r8 :: object
+    r5 :: ptr
+    r6, r7 :: object
 L0:
     if flag goto L1 else goto L2 :: bool
 L1:
@@ -549,15 +555,14 @@ L2:
     r2 = 'a'
     r3 = PyList_New(1)
     r4 = object 1
-    r5 = get_element_ptr r3 ob_item :: PyListObject
-    r6 = load_mem r5 :: ptr*
-    set_mem r6, r4 :: builtins.object*
+    r5 = list_items r3
+    buf_init_item r5, 0, r4
     keep_alive r3
-    r7 = CPyDict_SetDefault(d, r2, r3)
-    return r7
+    r6 = CPyDict_SetDefault(d, r2, r3)
+    return r6
 L3:
-    r8 = box(None, 1)
-    return r8
+    r7 = box(None, 1)
+    return r7
 def f4(d, flag):
     d :: dict
     flag :: bool
diff --git a/mypyc/test-data/irbuild-dunders.test b/mypyc/test-data/irbuild-dunders.test
index 3c140d927c0f..1796a7e2160e 100644
--- a/mypyc/test-data/irbuild-dunders.test
+++ b/mypyc/test-data/irbuild-dunders.test
@@ -15,24 +15,16 @@ L0:
 def f(c):
     c :: __main__.C
     r0 :: int
-    r1 :: native_int
-    r2, r3, r4 :: bit
-    r5 :: bool
+    r1 :: bit
+    r2 :: bool
 L0:
     r0 = c.__len__()
-    r1 = r0 & 1
-    r2 = r1 != 0
-    if r2 goto L1 else goto L2 :: bool
+    r1 = int_ge r0, 0
+    if r1 goto L2 else goto L1 :: bool
 L1:
-    r3 = CPyTagged_IsLt_(r0, 0)
-    if r3 goto L3 else goto L4 :: bool
-L2:
-    r4 = r0 >= 0 :: signed
-    if r4 goto L4 else goto L3 :: bool
-L3:
-    r5 = raise ValueError('__len__() should return >= 0')
+    r2 = raise ValueError('__len__() should return >= 0')
     unreachable
-L4:
+L2:
     return r0
 
 [case testDundersSetItem]
@@ -103,14 +95,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 e3a60852574b..d0fd32ffbdd7 100644
--- a/mypyc/test-data/irbuild-float.test
+++ b/mypyc/test-data/irbuild-float.test
@@ -219,7 +219,7 @@ L0:
     return r0
 
 [case testFloatFinalConstant]
-from typing_extensions import Final
+from typing import Final
 
 X: Final = 123.0
 Y: Final = -1.0
@@ -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-frozenset.test b/mypyc/test-data/irbuild-frozenset.test
new file mode 100644
index 000000000000..2fa84a2ed055
--- /dev/null
+++ b/mypyc/test-data/irbuild-frozenset.test
@@ -0,0 +1,115 @@
+[case testNewFrozenSet]
+from typing import FrozenSet
+def f() -> FrozenSet[int]:
+    return frozenset({1, 2, 3})
+[out]
+def f():
+    r0 :: set
+    r1 :: object
+    r2 :: i32
+    r3 :: bit
+    r4 :: object
+    r5 :: i32
+    r6 :: bit
+    r7 :: object
+    r8 :: i32
+    r9 :: bit
+    r10 :: frozenset
+L0:
+    r0 = PySet_New(0)
+    r1 = object 1
+    r2 = PySet_Add(r0, r1)
+    r3 = r2 >= 0 :: signed
+    r4 = object 2
+    r5 = PySet_Add(r0, r4)
+    r6 = r5 >= 0 :: signed
+    r7 = object 3
+    r8 = PySet_Add(r0, r7)
+    r9 = r8 >= 0 :: signed
+    r10 = PyFrozenSet_New(r0)
+    return r10
+
+[case testNewEmptyFrozenSet]
+from typing import FrozenSet
+def f1() -> FrozenSet[int]:
+    return frozenset()
+
+def f2() -> FrozenSet[int]:
+    return frozenset(())
+[out]
+def f1():
+    r0 :: frozenset
+L0:
+    r0 = PyFrozenSet_New(0)
+    return r0
+def f2():
+    r0 :: tuple[]
+    r1 :: object
+    r2 :: frozenset
+L0:
+    r0 = ()
+    r1 = box(tuple[], r0)
+    r2 = PyFrozenSet_New(r1)
+    return r2
+
+[case testNewFrozenSetFromIterable]
+from typing import FrozenSet, List, TypeVar
+
+T = TypeVar("T")
+
+def f(l: List[T]) -> FrozenSet[T]:
+    return frozenset(l)
+[out]
+def f(l):
+    l :: list
+    r0 :: frozenset
+L0:
+    r0 = PyFrozenSet_New(l)
+    return r0
+
+[case testFrozenSetSize]
+from typing import FrozenSet
+def f() -> int:
+    return len(frozenset((1, 2, 3)))
+[out]
+def f():
+    r0 :: tuple[int, int, int]
+    r1 :: object
+    r2 :: frozenset
+    r3 :: ptr
+    r4 :: native_int
+    r5 :: short_int
+L0:
+    r0 = (2, 4, 6)
+    r1 = box(tuple[int, int, int], r0)
+    r2 = PyFrozenSet_New(r1)
+    r3 = get_element_ptr r2 used :: PySetObject
+    r4 = load_mem r3 :: native_int*
+    keep_alive r2
+    r5 = r4 << 1
+    return r5
+
+[case testFrozenSetContains]
+from typing import FrozenSet
+def f() -> bool:
+    x = frozenset((3, 4))
+    return (5 in x)
+[out]
+def f():
+    r0 :: tuple[int, int]
+    r1 :: object
+    r2, x :: frozenset
+    r3 :: object
+    r4 :: i32
+    r5 :: bit
+    r6 :: bool
+L0:
+    r0 = (6, 8)
+    r1 = box(tuple[int, int], r0)
+    r2 = PyFrozenSet_New(r1)
+    x = r2
+    r3 = object 5
+    r4 = PySet_Contains(x, r3)
+    r5 = r4 >= 0 :: signed
+    r6 = truncate r4: i32 to builtins.bool
+    return r6
diff --git a/mypyc/test-data/irbuild-generics.test b/mypyc/test-data/irbuild-generics.test
index fe4a94992717..feb7b9db20fb 100644
--- a/mypyc/test-data/irbuild-generics.test
+++ b/mypyc/test-data/irbuild-generics.test
@@ -17,13 +17,12 @@ def g(x):
     x :: list
     r0 :: object
     r1 :: list
-    r2, r3 :: ptr
+    r2 :: ptr
 L0:
     r0 = CPyList_GetItemShort(x, 0)
     r1 = PyList_New(1)
-    r2 = get_element_ptr r1 ob_item :: PyListObject
-    r3 = load_mem r2 :: ptr*
-    set_mem r3, r0 :: builtins.object*
+    r2 = list_items r1
+    buf_init_item r2, 0, r0
     keep_alive r1
     return r1
 def h(x, y):
@@ -132,7 +131,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 +139,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
@@ -149,3 +148,680 @@ L2:
     r4 = x
 L3:
     return r4
+
+
+[case testParamSpec]
+from typing import Callable, ParamSpec
+
+P = ParamSpec("P")
+
+def execute(func: Callable[P, int], *args: P.args, **kwargs: P.kwargs) -> int:
+    return func(*args, **kwargs)
+
+def f(x: int) -> int:
+    return x
+
+execute(f, 1)
+[out]
+def execute(func, args, kwargs):
+    func :: object
+    args :: tuple
+    kwargs :: dict
+    r0 :: list
+    r1 :: object
+    r2 :: dict
+    r3 :: i32
+    r4 :: bit
+    r5 :: tuple
+    r6 :: object
+    r7 :: int
+L0:
+    r0 = PyList_New(0)
+    r1 = CPyList_Extend(r0, args)
+    r2 = PyDict_New()
+    r3 = CPyDict_UpdateInDisplay(r2, kwargs)
+    r4 = r3 >= 0 :: signed
+    r5 = PyList_AsTuple(r0)
+    r6 = PyObject_Call(func, r5, r2)
+    r7 = unbox(int, r6)
+    return r7
+def f(x):
+    x :: int
+L0:
+    return x
+
+[case testTypeVarMappingBound]
+# Dicts are special-cased for efficient iteration.
+from typing import Dict, TypedDict, TypeVar, Union
+
+class TD(TypedDict):
+    foo: int
+
+M = TypeVar("M", bound=Dict[str, int])
+U = TypeVar("U", bound=Union[Dict[str, int], Dict[str, str]])
+T = TypeVar("T", bound=TD)
+
+def fn_mapping(m: M) -> None:
+    [x for x in m]
+    [x for x in m.values()]
+    {x for x in m.keys()}
+    {k: v for k, v in m.items()}
+
+def fn_union(m: U) -> None:
+    [x for x in m]
+    [x for x in m.values()]
+    {x for x in m.keys()}
+    {k: v for k, v in m.items()}
+
+def fn_typeddict(t: T) -> None:
+    [x for x in t]
+    [x for x in t.values()]
+    {x for x in t.keys()}
+    {k: v for k, v in t.items()}
+
+[typing fixtures/typing-full.pyi]
+[out]
+def fn_mapping(m):
+    m :: dict
+    r0 :: list
+    r1 :: short_int
+    r2 :: native_int
+    r3 :: short_int
+    r4 :: object
+    r5 :: tuple[bool, short_int, object]
+    r6 :: short_int
+    r7 :: bool
+    r8 :: object
+    r9, x :: str
+    r10 :: i32
+    r11, r12, r13 :: bit
+    r14 :: list
+    r15 :: short_int
+    r16 :: native_int
+    r17 :: short_int
+    r18 :: object
+    r19 :: tuple[bool, short_int, object]
+    r20 :: short_int
+    r21 :: bool
+    r22 :: object
+    r23, x_2 :: int
+    r24 :: object
+    r25 :: i32
+    r26, r27, r28 :: bit
+    r29 :: set
+    r30 :: short_int
+    r31 :: native_int
+    r32 :: short_int
+    r33 :: object
+    r34 :: tuple[bool, short_int, object]
+    r35 :: short_int
+    r36 :: bool
+    r37 :: object
+    r38, x_3 :: str
+    r39 :: i32
+    r40, r41, r42 :: bit
+    r43 :: dict
+    r44 :: short_int
+    r45 :: native_int
+    r46 :: short_int
+    r47 :: object
+    r48 :: tuple[bool, short_int, object, object]
+    r49 :: short_int
+    r50 :: bool
+    r51, r52 :: object
+    r53 :: str
+    r54 :: int
+    k :: str
+    v :: int
+    r55 :: object
+    r56 :: i32
+    r57, r58, r59 :: bit
+L0:
+    r0 = PyList_New(0)
+    r1 = 0
+    r2 = PyDict_Size(m)
+    r3 = r2 << 1
+    r4 = CPyDict_GetKeysIter(m)
+L1:
+    r5 = CPyDict_NextKey(r4, r1)
+    r6 = r5[1]
+    r1 = r6
+    r7 = r5[0]
+    if r7 goto L2 else goto L4 :: bool
+L2:
+    r8 = r5[2]
+    r9 = cast(str, r8)
+    x = r9
+    r10 = PyList_Append(r0, x)
+    r11 = r10 >= 0 :: signed
+L3:
+    r12 = CPyDict_CheckSize(m, r3)
+    goto L1
+L4:
+    r13 = CPy_NoErrOccurred()
+L5:
+    r14 = PyList_New(0)
+    r15 = 0
+    r16 = PyDict_Size(m)
+    r17 = r16 << 1
+    r18 = CPyDict_GetValuesIter(m)
+L6:
+    r19 = CPyDict_NextValue(r18, r15)
+    r20 = r19[1]
+    r15 = r20
+    r21 = r19[0]
+    if r21 goto L7 else goto L9 :: bool
+L7:
+    r22 = r19[2]
+    r23 = unbox(int, r22)
+    x_2 = r23
+    r24 = box(int, x_2)
+    r25 = PyList_Append(r14, r24)
+    r26 = r25 >= 0 :: signed
+L8:
+    r27 = CPyDict_CheckSize(m, r17)
+    goto L6
+L9:
+    r28 = CPy_NoErrOccurred()
+L10:
+    r29 = PySet_New(0)
+    r30 = 0
+    r31 = PyDict_Size(m)
+    r32 = r31 << 1
+    r33 = CPyDict_GetKeysIter(m)
+L11:
+    r34 = CPyDict_NextKey(r33, r30)
+    r35 = r34[1]
+    r30 = r35
+    r36 = r34[0]
+    if r36 goto L12 else goto L14 :: bool
+L12:
+    r37 = r34[2]
+    r38 = cast(str, r37)
+    x_3 = r38
+    r39 = PySet_Add(r29, x_3)
+    r40 = r39 >= 0 :: signed
+L13:
+    r41 = CPyDict_CheckSize(m, r32)
+    goto L11
+L14:
+    r42 = CPy_NoErrOccurred()
+L15:
+    r43 = PyDict_New()
+    r44 = 0
+    r45 = PyDict_Size(m)
+    r46 = r45 << 1
+    r47 = CPyDict_GetItemsIter(m)
+L16:
+    r48 = CPyDict_NextItem(r47, r44)
+    r49 = r48[1]
+    r44 = r49
+    r50 = r48[0]
+    if r50 goto L17 else goto L19 :: bool
+L17:
+    r51 = r48[2]
+    r52 = r48[3]
+    r53 = cast(str, r51)
+    r54 = unbox(int, r52)
+    k = r53
+    v = r54
+    r55 = box(int, v)
+    r56 = CPyDict_SetItem(r43, k, r55)
+    r57 = r56 >= 0 :: signed
+L18:
+    r58 = CPyDict_CheckSize(m, r46)
+    goto L16
+L19:
+    r59 = CPy_NoErrOccurred()
+L20:
+    return 1
+def fn_union(m):
+    m :: dict
+    r0 :: list
+    r1 :: short_int
+    r2 :: native_int
+    r3 :: short_int
+    r4 :: object
+    r5 :: tuple[bool, short_int, object]
+    r6 :: short_int
+    r7 :: bool
+    r8 :: object
+    r9, x :: str
+    r10 :: i32
+    r11, r12, r13 :: bit
+    r14 :: list
+    r15 :: short_int
+    r16 :: native_int
+    r17 :: short_int
+    r18 :: object
+    r19 :: tuple[bool, short_int, object]
+    r20 :: short_int
+    r21 :: bool
+    r22 :: object
+    r23, x_2 :: union[int, str]
+    r24 :: i32
+    r25, r26, r27 :: bit
+    r28 :: set
+    r29 :: short_int
+    r30 :: native_int
+    r31 :: short_int
+    r32 :: object
+    r33 :: tuple[bool, short_int, object]
+    r34 :: short_int
+    r35 :: bool
+    r36 :: object
+    r37, x_3 :: str
+    r38 :: i32
+    r39, r40, r41 :: bit
+    r42 :: dict
+    r43 :: short_int
+    r44 :: native_int
+    r45 :: short_int
+    r46 :: object
+    r47 :: tuple[bool, short_int, object, object]
+    r48 :: short_int
+    r49 :: bool
+    r50, r51 :: object
+    r52 :: str
+    r53 :: union[int, str]
+    k :: str
+    v :: union[int, str]
+    r54 :: i32
+    r55, r56, r57 :: bit
+L0:
+    r0 = PyList_New(0)
+    r1 = 0
+    r2 = PyDict_Size(m)
+    r3 = r2 << 1
+    r4 = CPyDict_GetKeysIter(m)
+L1:
+    r5 = CPyDict_NextKey(r4, r1)
+    r6 = r5[1]
+    r1 = r6
+    r7 = r5[0]
+    if r7 goto L2 else goto L4 :: bool
+L2:
+    r8 = r5[2]
+    r9 = cast(str, r8)
+    x = r9
+    r10 = PyList_Append(r0, x)
+    r11 = r10 >= 0 :: signed
+L3:
+    r12 = CPyDict_CheckSize(m, r3)
+    goto L1
+L4:
+    r13 = CPy_NoErrOccurred()
+L5:
+    r14 = PyList_New(0)
+    r15 = 0
+    r16 = PyDict_Size(m)
+    r17 = r16 << 1
+    r18 = CPyDict_GetValuesIter(m)
+L6:
+    r19 = CPyDict_NextValue(r18, r15)
+    r20 = r19[1]
+    r15 = r20
+    r21 = r19[0]
+    if r21 goto L7 else goto L9 :: bool
+L7:
+    r22 = r19[2]
+    r23 = cast(union[int, str], r22)
+    x_2 = r23
+    r24 = PyList_Append(r14, x_2)
+    r25 = r24 >= 0 :: signed
+L8:
+    r26 = CPyDict_CheckSize(m, r17)
+    goto L6
+L9:
+    r27 = CPy_NoErrOccurred()
+L10:
+    r28 = PySet_New(0)
+    r29 = 0
+    r30 = PyDict_Size(m)
+    r31 = r30 << 1
+    r32 = CPyDict_GetKeysIter(m)
+L11:
+    r33 = CPyDict_NextKey(r32, r29)
+    r34 = r33[1]
+    r29 = r34
+    r35 = r33[0]
+    if r35 goto L12 else goto L14 :: bool
+L12:
+    r36 = r33[2]
+    r37 = cast(str, r36)
+    x_3 = r37
+    r38 = PySet_Add(r28, x_3)
+    r39 = r38 >= 0 :: signed
+L13:
+    r40 = CPyDict_CheckSize(m, r31)
+    goto L11
+L14:
+    r41 = CPy_NoErrOccurred()
+L15:
+    r42 = PyDict_New()
+    r43 = 0
+    r44 = PyDict_Size(m)
+    r45 = r44 << 1
+    r46 = CPyDict_GetItemsIter(m)
+L16:
+    r47 = CPyDict_NextItem(r46, r43)
+    r48 = r47[1]
+    r43 = r48
+    r49 = r47[0]
+    if r49 goto L17 else goto L19 :: bool
+L17:
+    r50 = r47[2]
+    r51 = r47[3]
+    r52 = cast(str, r50)
+    r53 = cast(union[int, str], r51)
+    k = r52
+    v = r53
+    r54 = CPyDict_SetItem(r42, k, v)
+    r55 = r54 >= 0 :: signed
+L18:
+    r56 = CPyDict_CheckSize(m, r45)
+    goto L16
+L19:
+    r57 = CPy_NoErrOccurred()
+L20:
+    return 1
+def fn_typeddict(t):
+    t :: dict
+    r0 :: list
+    r1 :: short_int
+    r2 :: native_int
+    r3 :: short_int
+    r4 :: object
+    r5 :: tuple[bool, short_int, object]
+    r6 :: short_int
+    r7 :: bool
+    r8 :: object
+    r9, x :: str
+    r10 :: i32
+    r11, r12, r13 :: bit
+    r14 :: list
+    r15 :: short_int
+    r16 :: native_int
+    r17 :: short_int
+    r18 :: object
+    r19 :: tuple[bool, short_int, object]
+    r20 :: short_int
+    r21 :: bool
+    r22, x_2 :: object
+    r23 :: i32
+    r24, r25, r26 :: bit
+    r27 :: set
+    r28 :: short_int
+    r29 :: native_int
+    r30 :: short_int
+    r31 :: object
+    r32 :: tuple[bool, short_int, object]
+    r33 :: short_int
+    r34 :: bool
+    r35 :: object
+    r36, x_3 :: str
+    r37 :: i32
+    r38, r39, r40 :: bit
+    r41 :: dict
+    r42 :: short_int
+    r43 :: native_int
+    r44 :: short_int
+    r45 :: object
+    r46 :: tuple[bool, short_int, object, object]
+    r47 :: short_int
+    r48 :: bool
+    r49, r50 :: object
+    r51, k :: str
+    v :: object
+    r52 :: i32
+    r53, r54, r55 :: bit
+L0:
+    r0 = PyList_New(0)
+    r1 = 0
+    r2 = PyDict_Size(t)
+    r3 = r2 << 1
+    r4 = CPyDict_GetKeysIter(t)
+L1:
+    r5 = CPyDict_NextKey(r4, r1)
+    r6 = r5[1]
+    r1 = r6
+    r7 = r5[0]
+    if r7 goto L2 else goto L4 :: bool
+L2:
+    r8 = r5[2]
+    r9 = cast(str, r8)
+    x = r9
+    r10 = PyList_Append(r0, x)
+    r11 = r10 >= 0 :: signed
+L3:
+    r12 = CPyDict_CheckSize(t, r3)
+    goto L1
+L4:
+    r13 = CPy_NoErrOccurred()
+L5:
+    r14 = PyList_New(0)
+    r15 = 0
+    r16 = PyDict_Size(t)
+    r17 = r16 << 1
+    r18 = CPyDict_GetValuesIter(t)
+L6:
+    r19 = CPyDict_NextValue(r18, r15)
+    r20 = r19[1]
+    r15 = r20
+    r21 = r19[0]
+    if r21 goto L7 else goto L9 :: bool
+L7:
+    r22 = r19[2]
+    x_2 = r22
+    r23 = PyList_Append(r14, x_2)
+    r24 = r23 >= 0 :: signed
+L8:
+    r25 = CPyDict_CheckSize(t, r17)
+    goto L6
+L9:
+    r26 = CPy_NoErrOccurred()
+L10:
+    r27 = PySet_New(0)
+    r28 = 0
+    r29 = PyDict_Size(t)
+    r30 = r29 << 1
+    r31 = CPyDict_GetKeysIter(t)
+L11:
+    r32 = CPyDict_NextKey(r31, r28)
+    r33 = r32[1]
+    r28 = r33
+    r34 = r32[0]
+    if r34 goto L12 else goto L14 :: bool
+L12:
+    r35 = r32[2]
+    r36 = cast(str, r35)
+    x_3 = r36
+    r37 = PySet_Add(r27, x_3)
+    r38 = r37 >= 0 :: signed
+L13:
+    r39 = CPyDict_CheckSize(t, r30)
+    goto L11
+L14:
+    r40 = CPy_NoErrOccurred()
+L15:
+    r41 = PyDict_New()
+    r42 = 0
+    r43 = PyDict_Size(t)
+    r44 = r43 << 1
+    r45 = CPyDict_GetItemsIter(t)
+L16:
+    r46 = CPyDict_NextItem(r45, r42)
+    r47 = r46[1]
+    r42 = r47
+    r48 = r46[0]
+    if r48 goto L17 else goto L19 :: bool
+L17:
+    r49 = r46[2]
+    r50 = r46[3]
+    r51 = cast(str, r49)
+    k = r51
+    v = r50
+    r52 = CPyDict_SetItem(r41, k, v)
+    r53 = r52 >= 0 :: signed
+L18:
+    r54 = CPyDict_CheckSize(t, r44)
+    goto L16
+L19:
+    r55 = CPy_NoErrOccurred()
+L20:
+    return 1
+
+[case testParamSpecComponentsAreUsable]
+from typing import Callable, ParamSpec
+
+P = ParamSpec("P")
+
+def deco(func: Callable[P, int]) -> Callable[P, int]:
+    def inner(*args: P.args, **kwargs: P.kwargs) -> int:
+        can_listcomp = [x for x in args]
+        can_dictcomp = {k: v for k, v in kwargs.items()}
+        can_iter = list(kwargs)
+        can_use_keys = list(kwargs.keys())
+        can_use_values = list(kwargs.values())
+        return func(*args, **kwargs)
+
+    return inner
+
+@deco
+def f(x: int) -> int:
+    return x
+
+f(1)
+[out]
+def inner_deco_obj.__get__(__mypyc_self__, instance, owner):
+    __mypyc_self__, instance, owner, r0 :: object
+    r1 :: bit
+    r2 :: object
+L0:
+    r0 = load_address _Py_NoneStruct
+    r1 = instance == r0
+    if r1 goto L1 else goto L2 :: bool
+L1:
+    return __mypyc_self__
+L2:
+    r2 = PyMethod_New(__mypyc_self__, instance)
+    return r2
+def inner_deco_obj.__call__(__mypyc_self__, args, kwargs):
+    __mypyc_self__ :: __main__.inner_deco_obj
+    args :: tuple
+    kwargs :: dict
+    r0 :: __main__.deco_env
+    r1 :: native_int
+    r2 :: list
+    r3 :: short_int
+    r4 :: native_int
+    r5 :: short_int
+    r6 :: bit
+    r7, x :: object
+    r8 :: bit
+    r9 :: short_int
+    can_listcomp :: list
+    r10 :: dict
+    r11 :: short_int
+    r12 :: native_int
+    r13 :: short_int
+    r14 :: object
+    r15 :: tuple[bool, short_int, object, object]
+    r16 :: short_int
+    r17 :: bool
+    r18, r19 :: object
+    r20, k :: str
+    v :: object
+    r21 :: i32
+    r22, r23, r24 :: bit
+    can_dictcomp :: dict
+    r25, can_iter, r26, can_use_keys, r27, can_use_values :: list
+    r28 :: object
+    r29 :: list
+    r30 :: object
+    r31 :: dict
+    r32 :: i32
+    r33 :: bit
+    r34 :: tuple
+    r35 :: object
+    r36 :: int
+L0:
+    r0 = __mypyc_self__.__mypyc_env__
+    r1 = var_object_size args
+    r2 = PyList_New(r1)
+    r3 = 0
+L1:
+    r4 = var_object_size args
+    r5 = r4 << 1
+    r6 = int_lt r3, r5
+    if r6 goto L2 else goto L4 :: bool
+L2:
+    r7 = CPySequenceTuple_GetItem(args, r3)
+    x = r7
+    r8 = CPyList_SetItemUnsafe(r2, r3, x)
+L3:
+    r9 = r3 + 2
+    r3 = r9
+    goto L1
+L4:
+    can_listcomp = r2
+    r10 = PyDict_New()
+    r11 = 0
+    r12 = PyDict_Size(kwargs)
+    r13 = r12 << 1
+    r14 = CPyDict_GetItemsIter(kwargs)
+L5:
+    r15 = CPyDict_NextItem(r14, r11)
+    r16 = r15[1]
+    r11 = r16
+    r17 = r15[0]
+    if r17 goto L6 else goto L8 :: bool
+L6:
+    r18 = r15[2]
+    r19 = r15[3]
+    r20 = cast(str, r18)
+    k = r20
+    v = r19
+    r21 = CPyDict_SetItem(r10, k, v)
+    r22 = r21 >= 0 :: signed
+L7:
+    r23 = CPyDict_CheckSize(kwargs, r13)
+    goto L5
+L8:
+    r24 = CPy_NoErrOccurred()
+L9:
+    can_dictcomp = r10
+    r25 = PySequence_List(kwargs)
+    can_iter = r25
+    r26 = CPyDict_Keys(kwargs)
+    can_use_keys = r26
+    r27 = CPyDict_Values(kwargs)
+    can_use_values = r27
+    r28 = r0.func
+    r29 = PyList_New(0)
+    r30 = CPyList_Extend(r29, args)
+    r31 = PyDict_New()
+    r32 = CPyDict_UpdateInDisplay(r31, kwargs)
+    r33 = r32 >= 0 :: signed
+    r34 = PyList_AsTuple(r29)
+    r35 = PyObject_Call(r28, r34, r31)
+    r36 = unbox(int, r35)
+    return r36
+def deco(func):
+    func :: object
+    r0 :: __main__.deco_env
+    r1 :: bool
+    r2 :: __main__.inner_deco_obj
+    r3 :: bool
+    inner :: object
+L0:
+    r0 = deco_env()
+    r0.func = func; r1 = is_error
+    r2 = inner_deco_obj()
+    r2.__mypyc_env__ = r0; r3 = is_error
+    inner = r2
+    return inner
+def f(x):
+    x :: int
+L0:
+    return x
diff --git a/mypyc/test-data/irbuild-glue-methods.test b/mypyc/test-data/irbuild-glue-methods.test
index 6d749bf5dd84..35e6be1283eb 100644
--- a/mypyc/test-data/irbuild-glue-methods.test
+++ b/mypyc/test-data/irbuild-glue-methods.test
@@ -194,18 +194,24 @@ def DerivedProperty.next(self):
     self :: __main__.DerivedProperty
     r0 :: object
     r1 :: int
-    r2, r3, r4 :: object
-    r5 :: int
-    r6 :: __main__.DerivedProperty
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
+    r7 :: int
+    r8 :: __main__.DerivedProperty
 L0:
     r0 = self._incr_func
     r1 = self.value
     r2 = self._incr_func
     r3 = box(int, r1)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    r6 = DerivedProperty(r0, r5)
-    return r6
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
+    r7 = unbox(int, r6)
+    r8 = DerivedProperty(r0, r7)
+    return r8
 def DerivedProperty.next__BaseProperty_glue(__mypyc_self__):
     __mypyc_self__, r0 :: __main__.DerivedProperty
 L0:
@@ -224,24 +230,36 @@ def AgainProperty.next(self):
     self :: __main__.AgainProperty
     r0 :: object
     r1 :: int
-    r2, r3, r4 :: object
-    r5 :: int
-    r6, r7, r8 :: object
-    r9 :: int
-    r10 :: __main__.AgainProperty
+    r2, r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
+    r7 :: int
+    r8, r9 :: object
+    r10 :: object[1]
+    r11 :: object_ptr
+    r12 :: object
+    r13 :: int
+    r14 :: __main__.AgainProperty
 L0:
     r0 = self._incr_func
     r1 = self.value
     r2 = self._incr_func
     r3 = box(int, r1)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    r6 = self._incr_func
-    r7 = box(int, r5)
-    r8 = PyObject_CallFunctionObjArgs(r6, r7, 0)
-    r9 = unbox(int, r8)
-    r10 = AgainProperty(r0, r9)
-    return r10
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r2, r5, 1, 0)
+    keep_alive r3
+    r7 = unbox(int, r6)
+    r8 = self._incr_func
+    r9 = box(int, r7)
+    r10 = [r9]
+    r11 = load_address r10
+    r12 = PyObject_Vectorcall(r8, r11, 1, 0)
+    keep_alive r9
+    r13 = unbox(int, r12)
+    r14 = AgainProperty(r0, r13)
+    return r14
 def AgainProperty.next__DerivedProperty_glue(__mypyc_self__):
     __mypyc_self__, r0 :: __main__.AgainProperty
 L0:
@@ -343,8 +361,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 +389,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 +402,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 +423,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 +450,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
new file mode 100644
index 000000000000..a03c9df2c6ac
--- /dev/null
+++ b/mypyc/test-data/irbuild-i16.test
@@ -0,0 +1,526 @@
+# 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 :: i16
+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 :: i16
+    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 :: i16
+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 :: i16
+    r2, r3, r4 :: bit
+    r5 :: i16
+    r6 :: bit
+    r7, r8, r9 :: i16
+    r10, r11, r12 :: bit
+    r13 :: i16
+    r14 :: bit
+    r15 :: i16
+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 :: i16
+    r2, r3, r4, r5 :: bit
+    r6, r7, r8 :: i16
+    r9, r10, r11, r12 :: bit
+    r13 :: i16
+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 :: 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
+
+def f(x: Any) -> Any:
+    y: i16 = x
+    return y
+[out]
+def f(x):
+    x :: object
+    r0, y :: i16
+    r1 :: object
+L0:
+    r0 = unbox(i16, x)
+    y = r0
+    r1 = box(i16, 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 :: i16
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: i16
+    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 i16
+    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 :: i16
+    y :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: i16
+    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 i16
+    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 :: i16
+    r0 :: native_int
+    r1 :: int
+L0:
+    r0 = extend signed a: i16 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 :: i16
+    x :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6, r7 :: i16
+    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 i16
+    r6 = r5
+    goto L5
+L4:
+    CPyInt16_Overflow()
+    unreachable
+L5:
+    r7 = r6 + a
+    r8 = extend signed r7: i16 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 :: i16
+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 :: i16
+L0:
+    return x
+def from_i32(x):
+    x :: i32
+    r0 :: i16
+L0:
+    r0 = truncate x: i32 to i16
+    return r0
+def from_i64(x):
+    x :: i64
+    r0 :: i16
+L0:
+    r0 = truncate x: i64 to i16
+    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 :: i16
+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 i16
+    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)
+    a = i16(32767)
+    b = i16(32768)  # Truncate
+    c = i16(-32768)
+    d = i16(-32769)  # Truncate
+[out]
+def f():
+    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]
+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 :: i16
+L0:
+    r0 = extend b: builtins.bool to i16
+    return r0
+def str_to_i16(s):
+    s :: str
+    r0 :: object
+    r1 :: i16
+L0:
+    r0 = CPyLong_FromStr(s)
+    r1 = unbox(i16, r0)
+    return r1
+def C.__int__(self):
+    self :: __main__.C
+L0:
+    return 5
+def instance_to_i16(c):
+    c :: __main__.C
+    r0 :: i16
+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 :: i16
+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 i16
+    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 725e183657b1..7dcb722ec906 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
@@ -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,15 +424,21 @@ def from_i32(x: i32) -> i32:
 def from_i64(x: i64) -> i32:
     return i32(x)
 [out]
+def from_i16(x):
+    x :: i16
+    r0 :: i32
+L0:
+    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]
@@ -443,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
@@ -456,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:
@@ -465,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]
@@ -502,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
@@ -520,7 +531,7 @@ L0:
     return 5
 def instance_to_i32(c):
     c :: __main__.C
-    r0 :: int32
+    r0 :: i32
 L0:
     r0 = c.__int__()
     return r0
@@ -530,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
@@ -544,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:
@@ -564,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 a18171c41d57..c59e306b09df 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,27 +1137,26 @@ class C:
     s: str
 [out]
 def f(n):
-    n :: int64
+    n :: i64
     r0 :: __main__.C
     r1 :: list
-    r2, r3 :: ptr
+    r2 :: ptr
     a :: list
-    r4 :: object
-    r5 :: __main__.C
-    r6 :: str
+    r3 :: object
+    r4 :: __main__.C
+    r5 :: str
 L0:
     r0 = C()
     r1 = PyList_New(1)
-    r2 = get_element_ptr r1 ob_item :: PyListObject
-    r3 = load_mem r2 :: ptr*
-    set_mem r3, r0 :: builtins.object*
+    r2 = list_items r1
+    buf_init_item r2, 0, r0
     keep_alive r1
     a = r1
-    r4 = CPyList_GetItemInt64Borrow(a, n)
-    r5 = borrow cast(__main__.C, r4)
-    r6 = r5.s
-    keep_alive a, n, r4
-    return r6
+    r3 = CPyList_GetItemInt64Borrow(a, n)
+    r4 = borrow cast(__main__.C, r3)
+    r5 = r4.s
+    keep_alive a, n, r3
+    return r5
 
 [case testBorrowOverI64ListGetItem2]
 from typing import List
@@ -1170,13 +1169,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,40 +1200,34 @@ def g(a: List[i64], y: i64) -> bool:
 [out]
 def f(a, y):
     a :: list
-    y :: int64
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3 :: int64
-    r4 :: bit
+    y :: i64
+    r0 :: native_int
+    r1 :: short_int
+    r2 :: i64
+    r3 :: bit
 L0:
-    r0 = get_element_ptr a ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive a
-    r2 = r1 << 1
-    r3 = r2 >> 1
-    r4 = r3 < y :: signed
-    if r4 goto L1 else goto L2 :: bool
+    r0 = var_object_size a
+    r1 = r0 << 1
+    r2 = r1 >> 1
+    r3 = r2 < y :: signed
+    if r3 goto L1 else goto L2 :: bool
 L1:
     return 1
 L2:
     return 0
 def g(a, y):
     a :: list
-    y :: int64
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3 :: int64
-    r4 :: bit
+    y :: i64
+    r0 :: native_int
+    r1 :: short_int
+    r2 :: i64
+    r3 :: bit
 L0:
-    r0 = get_element_ptr a ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive a
-    r2 = r1 << 1
-    r3 = r2 >> 1
-    r4 = y < r3 :: signed
-    if r4 goto L1 else goto L2 :: bool
+    r0 = var_object_size a
+    r1 = r0 << 1
+    r2 = r1 >> 1
+    r3 = y < r2 :: signed
+    if r3 goto L1 else goto L2 :: bool
 L1:
     return 1
 L2:
@@ -1248,35 +1241,34 @@ def f(n: i64) -> List[i64]:
     return [n] * n
 [out]
 def f(n):
-    n :: int64
+    n :: i64
     r0 :: list
     r1 :: object
-    r2, r3 :: ptr
-    r4, r5 :: bit
-    r6, r7, r8 :: int
-    r9 :: list
+    r2 :: ptr
+    r3, r4 :: bit
+    r5, r6, r7 :: int
+    r8 :: list
 L0:
     r0 = PyList_New(1)
-    r1 = box(int64, n)
-    r2 = get_element_ptr r0 ob_item :: PyListObject
-    r3 = load_mem r2 :: ptr*
-    set_mem r3, r1 :: builtins.object*
+    r1 = box(i64, n)
+    r2 = list_items r0
+    buf_init_item r2, 0, r1
     keep_alive r0
-    r4 = n <= 4611686018427387903 :: signed
-    if r4 goto L1 else goto L2 :: bool
+    r3 = n <= 4611686018427387903 :: signed
+    if r3 goto L1 else goto L2 :: bool
 L1:
-    r5 = n >= -4611686018427387904 :: signed
-    if r5 goto L3 else goto L2 :: bool
+    r4 = n >= -4611686018427387904 :: signed
+    if r4 goto L3 else goto L2 :: bool
 L2:
-    r6 = CPyTagged_FromInt64(n)
-    r7 = r6
+    r5 = CPyTagged_FromInt64(n)
+    r6 = r5
     goto L4
 L3:
-    r8 = n << 1
-    r7 = r8
+    r7 = n << 1
+    r6 = r7
 L4:
-    r9 = CPySequence_Multiply(r0, r7)
-    return r9
+    r8 = CPySequence_Multiply(r0, r6)
+    return r8
 
 [case testShortIntAndI64Op]
 from mypy_extensions import i64
@@ -1297,70 +1289,58 @@ def lt_i64(a: List[i64], n: i64) -> bool:
 [out]
 def add_i64(a, n):
     a :: list
-    n :: int64
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3, r4 :: int64
+    n :: i64
+    r0 :: native_int
+    r1 :: short_int
+    r2, r3 :: i64
 L0:
-    r0 = get_element_ptr a ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive a
-    r2 = r1 << 1
-    r3 = r2 >> 1
-    r4 = r3 + n
-    return r4
+    r0 = var_object_size a
+    r1 = r0 << 1
+    r2 = r1 >> 1
+    r3 = r2 + n
+    return r3
 def add_i64_2(a, n):
     a :: list
-    n :: int64
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3, r4 :: int64
+    n :: i64
+    r0 :: native_int
+    r1 :: short_int
+    r2, r3 :: i64
 L0:
-    r0 = get_element_ptr a ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive a
-    r2 = r1 << 1
-    r3 = r2 >> 1
-    r4 = n + r3
-    return r4
+    r0 = var_object_size a
+    r1 = r0 << 1
+    r2 = r1 >> 1
+    r3 = n + r2
+    return r3
 def eq_i64(a, n):
     a :: list
-    n :: int64
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3 :: int64
-    r4 :: bit
+    n :: i64
+    r0 :: native_int
+    r1 :: short_int
+    r2 :: i64
+    r3 :: bit
 L0:
-    r0 = get_element_ptr a ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive a
-    r2 = r1 << 1
-    r3 = r2 >> 1
-    r4 = r3 == n
-    if r4 goto L1 else goto L2 :: bool
+    r0 = var_object_size a
+    r1 = r0 << 1
+    r2 = r1 >> 1
+    r3 = r2 == n
+    if r3 goto L1 else goto L2 :: bool
 L1:
     return 1
 L2:
     return 0
 def lt_i64(a, n):
     a :: list
-    n :: int64
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
-    r3 :: int64
-    r4 :: bit
+    n :: i64
+    r0 :: native_int
+    r1 :: short_int
+    r2 :: i64
+    r3 :: bit
 L0:
-    r0 = get_element_ptr a ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive a
-    r2 = r1 << 1
-    r3 = r2 >> 1
-    r4 = n < r3 :: signed
-    if r4 goto L1 else goto L2 :: bool
+    r0 = var_object_size a
+    r1 = r0 << 1
+    r2 = r1 >> 1
+    r3 = n < r2 :: signed
+    if r3 goto L1 else goto L2 :: bool
 L1:
     return 1
 L2:
@@ -1376,10 +1356,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 +1367,7 @@ L0:
 L1:
     return 1
 L2:
-    r2 = unbox(int64, x)
+    r2 = unbox(i64, x)
     return r2
 
 [case testI64DefaultValueSingle]
@@ -1400,10 +1380,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 +1394,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 +1411,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 +1438,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 +1466,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
@@ -1506,7 +1486,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,14 +1497,20 @@ def from_i32(x: i32) -> i64:
 def from_i64(x: i64) -> i64:
     return i64(x)
 [out]
+def from_i16(x):
+    x :: i16
+    r0 :: i64
+L0:
+    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
 
@@ -1535,10 +1524,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
@@ -1563,7 +1552,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:
@@ -1591,7 +1580,7 @@ def f() -> None:
     z = i64(-3)
 [out]
 def f():
-    x, y, z :: int64
+    x, y, z :: i64
 L0:
     x = 0
     y = 11
@@ -1606,9 +1595,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
@@ -1633,9 +1622,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
@@ -1662,8 +1651,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
@@ -1675,8 +1664,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
@@ -1688,7 +1677,7 @@ L2:
     return 1
 
 [case testI64FinalConstants]
-from typing_extensions import Final
+from typing import Final
 from mypy_extensions import i64
 
 A: Final = -1
@@ -1742,26 +1731,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:
@@ -1779,18 +1768,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
@@ -1819,16 +1808,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
@@ -1865,25 +1854,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
@@ -1891,7 +1880,7 @@ L0:
     return 5
 def instance_to_i64(c):
     c :: __main__.C
-    r0 :: int64
+    r0 :: i64
 L0:
     r0 = c.__int__()
     return r0
@@ -1900,10 +1889,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
@@ -1933,17 +1922,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
@@ -1963,7 +1952,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
@@ -1991,7 +1980,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
@@ -2008,7 +1997,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:
@@ -2033,22 +2022,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)
@@ -2056,22 +2045,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)
@@ -2090,17 +2079,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]
@@ -2128,11 +2117,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-int.test b/mypyc/test-data/irbuild-int.test
index fbe00aff4040..bdf9127b722a 100644
--- a/mypyc/test-data/irbuild-int.test
+++ b/mypyc/test-data/irbuild-int.test
@@ -4,24 +4,10 @@ def f(x: int, y: int) -> bool:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1, r2 :: bit
-    r3 :: bool
-    r4, r5 :: bit
-L0:
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = x != y
-    r3 = r2
-    goto L3
-L2:
-    r4 = CPyTagged_IsEq_(x, y)
-    r5 = r4 ^ 1
-    r3 = r5
-L3:
-    return r3
+    r0 :: bit
+L0:
+    r0 = int_ne x, y
+    return r0
 
 [case testShortIntComparisons]
 def f(x: int) -> int:
@@ -39,46 +25,37 @@ def f(x: int) -> int:
 [out]
 def f(x):
     x :: int
-    r0, r1, r2, r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
+    r0, r1, r2, r3, r4 :: bit
 L0:
-    r0 = x == 6
+    r0 = int_eq x, 6
     if r0 goto L1 else goto L2 :: bool
 L1:
     return 2
 L2:
-    r1 = x != 8
+    r1 = int_ne x, 8
     if r1 goto L3 else goto L4 :: bool
 L3:
     return 4
 L4:
-    r2 = 10 == x
+    r2 = int_eq 10, x
     if r2 goto L5 else goto L6 :: bool
 L5:
     return 6
 L6:
-    r3 = 12 != x
+    r3 = int_ne 12, x
     if r3 goto L7 else goto L8 :: bool
 L7:
     return 8
 L8:
-    r4 = x & 1
-    r5 = r4 != 0
-    if r5 goto L9 else goto L10 :: bool
+    r4 = int_lt x, 8
+    if r4 goto L9 else goto L10 :: bool
 L9:
-    r6 = CPyTagged_IsLt_(x, 8)
-    if r6 goto L11 else goto L12 :: bool
+    return 10
 L10:
-    r7 = x < 8 :: signed
-    if r7 goto L11 else goto L12 :: bool
 L11:
-    return 10
 L12:
 L13:
 L14:
-L15:
-L16:
     return 12
 
 [case testIntMin]
@@ -87,36 +64,18 @@ def f(x: int, y: int) -> int:
 [out]
 def f(x, y):
     x, y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6 :: bool
-    r7 :: bit
-    r8 :: int
-L0:
-    r0 = y & 1
-    r1 = r0 == 0
-    r2 = x & 1
-    r3 = r2 == 0
-    r4 = r1 & r3
-    if r4 goto L1 else goto L2 :: bool
+    r0 :: bit
+    r1 :: int
+L0:
+    r0 = int_lt y, x
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r5 = y < x :: signed
-    r6 = r5
+    r1 = y
     goto L3
 L2:
-    r7 = CPyTagged_IsLt_(y, x)
-    r6 = r7
+    r1 = x
 L3:
-    if r6 goto L4 else goto L5 :: bool
-L4:
-    r8 = y
-    goto L6
-L5:
-    r8 = x
-L6:
-    return r8
+    return r1
 
 [case testIntFloorDivideByPowerOfTwo]
 def divby1(x: int) -> int:
@@ -157,7 +116,7 @@ L0:
     return r0
 
 [case testFinalConstantFolding]
-from typing_extensions import Final
+from typing import Final
 
 X: Final = -1
 Y: Final = -(1 + 3*2)
@@ -223,13 +182,31 @@ def int_to_int(n):
 L0:
     return n
 
-[case testIntUnaryPlus]
+[case testIntUnaryOps]
+def unary_minus(n: int) -> int:
+    x = -n
+    return x
 def unary_plus(n: int) -> int:
     x = +n
     return x
+def unary_invert(n: int) -> int:
+    x = ~n
+    return x
 [out]
+def unary_minus(n):
+    n, r0, x :: int
+L0:
+    r0 = CPyTagged_Negate(n)
+    x = r0
+    return x
 def unary_plus(n):
     n, x :: int
 L0:
     x = n
     return x
+def unary_invert(n):
+    n, r0, x :: int
+L0:
+    r0 = CPyTagged_Invert(n)
+    x = r0
+    return x
diff --git a/mypyc/test-data/irbuild-isinstance.test b/mypyc/test-data/irbuild-isinstance.test
index 6bb92d0a947e..78da2e9c1e19 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 eaeff9432446..2435b5aee350 100644
--- a/mypyc/test-data/irbuild-lists.test
+++ b/mypyc/test-data/irbuild-lists.test
@@ -108,17 +108,15 @@ def f() -> None:
 def f():
     r0 :: list
     r1, r2 :: object
-    r3, r4, r5 :: ptr
+    r3 :: ptr
     x :: list
 L0:
     r0 = PyList_New(2)
     r1 = object 1
     r2 = object 2
-    r3 = get_element_ptr r0 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, r1 :: builtins.object*
-    r5 = r4 + WORD_SIZE*1
-    set_mem r5, r2 :: builtins.object*
+    r3 = list_items r0
+    buf_init_item r3, 0, r1
+    buf_init_item r3, 1, r2
     keep_alive r0
     x = r0
     return 1
@@ -147,6 +145,32 @@ L0:
     x = r10
     return 1
 
+[case testListAdd]
+from typing import List
+def f(a: List[int], b: List[int]) -> None:
+    c = a + b
+[out]
+def f(a, b):
+    a, b, r0, c :: list
+L0:
+    r0 = PySequence_Concat(a, b)
+    c = r0
+    return 1
+
+[case testListIAdd]
+from typing import List, Any
+def f(a: List[int], b: Any) -> None:
+    a += b
+[out]
+def f(a, b):
+    a :: list
+    b :: object
+    r0 :: list
+L0:
+    r0 = PySequence_InPlaceConcat(a, b)
+    a = r0
+    return 1
+
 [case testListMultiply]
 from typing import List
 def f(a: List[int]) -> None:
@@ -156,19 +180,30 @@ def f(a: List[int]) -> None:
 def f(a):
     a, r0, b, r1 :: list
     r2 :: object
-    r3, r4 :: ptr
-    r5 :: list
+    r3 :: ptr
+    r4 :: list
 L0:
     r0 = CPySequence_Multiply(a, 4)
     b = r0
     r1 = PyList_New(1)
     r2 = object 4
-    r3 = get_element_ptr r1 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, r2 :: builtins.object*
+    r3 = list_items r1
+    buf_init_item r3, 0, r2
     keep_alive r1
-    r5 = CPySequence_RMultiply(6, r1)
-    b = r5
+    r4 = CPySequence_RMultiply(6, r1)
+    b = r4
+    return 1
+
+[case testListIMultiply]
+from typing import List
+def f(a: List[int]) -> None:
+    a *= 2
+[out]
+def f(a):
+    a, r0 :: list
+L0:
+    r0 = CPySequence_InPlaceMultiply(a, 4)
+    a = r0
     return 1
 
 [case testListLen]
@@ -178,15 +213,24 @@ def f(a: List[int]) -> int:
 [out]
 def f(a):
     a :: list
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
+    r0 :: native_int
+    r1 :: short_int
 L0:
-    r0 = get_element_ptr a ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive a
-    r2 = r1 << 1
-    return r2
+    r0 = var_object_size a
+    r1 = r0 << 1
+    return r1
+
+[case testListCopy]
+from typing import List
+from typing import Any
+def f(a: List[Any]) -> List[Any]:
+    return a.copy()
+[out]
+def f(a):
+    a, r0 :: list
+L0:
+    r0 = CPyList_Copy(a)
+    return r0
 
 [case testListAppend]
 from typing import List
@@ -197,7 +241,7 @@ def f(a, x):
     a :: list
     x :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     r0 = box(int, x)
@@ -214,33 +258,30 @@ def increment(l: List[int]) -> List[int]:
 [out]
 def increment(l):
     l :: list
-    r0 :: ptr
-    r1 :: native_int
-    r2, r3 :: short_int
+    r0 :: native_int
+    r1, r2 :: short_int
     i :: int
-    r4 :: bit
-    r5, r6, r7 :: object
-    r8 :: bit
-    r9 :: short_int
+    r3 :: bit
+    r4, r5, r6 :: object
+    r7 :: bit
+    r8 :: short_int
 L0:
-    r0 = get_element_ptr l ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive l
-    r2 = r1 << 1
-    r3 = 0
-    i = r3
+    r0 = var_object_size l
+    r1 = r0 << 1
+    r2 = 0
+    i = r2
 L1:
-    r4 = r3 < r2 :: signed
-    if r4 goto L2 else goto L4 :: bool
+    r3 = int_lt r2, r1
+    if r3 goto L2 else goto L4 :: bool
 L2:
-    r5 = CPyList_GetItem(l, i)
-    r6 = object 1
-    r7 = PyNumber_InPlaceAdd(r5, r6)
-    r8 = CPyList_SetItem(l, i, r7)
+    r4 = CPyList_GetItem(l, i)
+    r5 = object 1
+    r6 = PyNumber_InPlaceAdd(r4, r5)
+    r7 = CPyList_SetItem(l, i, r6)
 L3:
-    r9 = r3 + 2
-    r3 = r9
-    i = r9
+    r8 = r2 + 2
+    r2 = r8
+    i = r8
     goto L1
 L4:
     return l
@@ -253,25 +294,23 @@ def f(x: List[int], y: List[int]) -> List[int]:
 def f(x, y):
     x, y, r0 :: list
     r1, r2 :: object
-    r3, r4, r5 :: ptr
-    r6, r7, r8 :: object
-    r9 :: int32
-    r10 :: bit
+    r3 :: ptr
+    r4, r5, r6 :: object
+    r7 :: i32
+    r8 :: bit
 L0:
     r0 = PyList_New(2)
     r1 = object 1
     r2 = object 2
-    r3 = get_element_ptr r0 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, r1 :: builtins.object*
-    r5 = r4 + WORD_SIZE*1
-    set_mem r5, r2 :: builtins.object*
+    r3 = list_items r0
+    buf_init_item r3, 0, r1
+    buf_init_item r3, 1, r2
     keep_alive r0
-    r6 = CPyList_Extend(r0, x)
-    r7 = CPyList_Extend(r0, y)
-    r8 = object 3
-    r9 = PyList_Append(r0, r8)
-    r10 = r9 >= 0 :: signed
+    r4 = CPyList_Extend(r0, x)
+    r5 = CPyList_Extend(r0, y)
+    r6 = object 3
+    r7 = PyList_Append(r0, r6)
+    r8 = r7 >= 0 :: signed
     return r0
 
 [case testListIn]
@@ -283,14 +322,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 +341,7 @@ def f(x, y):
     x :: list
     y :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     r0 = box(int, y)
@@ -318,86 +357,75 @@ def f(source: List[int]) -> None:
 [out]
 def f(source):
     source :: list
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: list
-    r3 :: short_int
-    r4 :: ptr
-    r5 :: native_int
-    r6 :: short_int
-    r7 :: bit
-    r8 :: object
-    r9, x, r10 :: int
-    r11 :: object
-    r12 :: bit
-    r13 :: short_int
+    r0 :: native_int
+    r1 :: list
+    r2 :: short_int
+    r3 :: native_int
+    r4 :: short_int
+    r5 :: bit
+    r6 :: object
+    r7, x, r8 :: int
+    r9 :: object
+    r10 :: bit
+    r11 :: short_int
     a :: list
-    r14 :: ptr
+    r12 :: native_int
+    r13 :: list
+    r14 :: short_int
     r15 :: native_int
-    r16 :: list
-    r17 :: short_int
-    r18 :: ptr
-    r19 :: native_int
-    r20 :: short_int
-    r21 :: bit
-    r22 :: object
-    r23, x_2, r24 :: int
-    r25 :: object
-    r26 :: bit
-    r27 :: short_int
+    r16 :: short_int
+    r17 :: bit
+    r18 :: object
+    r19, x_2, r20 :: int
+    r21 :: object
+    r22 :: bit
+    r23 :: short_int
     b :: list
 L0:
-    r0 = get_element_ptr source ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive source
-    r2 = PyList_New(r1)
-    r3 = 0
+    r0 = var_object_size source
+    r1 = PyList_New(r0)
+    r2 = 0
 L1:
-    r4 = get_element_ptr source ob_size :: PyVarObject
-    r5 = load_mem r4 :: native_int*
-    keep_alive source
-    r6 = r5 << 1
-    r7 = r3 < r6 :: signed
-    if r7 goto L2 else goto L4 :: bool
+    r3 = var_object_size source
+    r4 = r3 << 1
+    r5 = int_lt r2, r4
+    if r5 goto L2 else goto L4 :: bool
 L2:
-    r8 = CPyList_GetItemUnsafe(source, r3)
-    r9 = unbox(int, r8)
-    x = r9
-    r10 = CPyTagged_Add(x, 2)
-    r11 = box(int, r10)
-    r12 = CPyList_SetItemUnsafe(r2, r3, r11)
+    r6 = list_get_item_unsafe source, r2
+    r7 = unbox(int, r6)
+    x = r7
+    r8 = CPyTagged_Add(x, 2)
+    r9 = box(int, r8)
+    r10 = CPyList_SetItemUnsafe(r1, r2, r9)
 L3:
-    r13 = r3 + 2
-    r3 = r13
+    r11 = r2 + 2
+    r2 = r11
     goto L1
 L4:
-    a = r2
-    r14 = get_element_ptr source ob_size :: PyVarObject
-    r15 = load_mem r14 :: native_int*
-    keep_alive source
-    r16 = PyList_New(r15)
-    r17 = 0
+    a = r1
+    r12 = var_object_size source
+    r13 = PyList_New(r12)
+    r14 = 0
 L5:
-    r18 = get_element_ptr source ob_size :: PyVarObject
-    r19 = load_mem r18 :: native_int*
-    keep_alive source
-    r20 = r19 << 1
-    r21 = r17 < r20 :: signed
-    if r21 goto L6 else goto L8 :: bool
+    r15 = var_object_size source
+    r16 = r15 << 1
+    r17 = int_lt r14, r16
+    if r17 goto L6 else goto L8 :: bool
 L6:
-    r22 = CPyList_GetItemUnsafe(source, r17)
-    r23 = unbox(int, r22)
-    x_2 = r23
-    r24 = CPyTagged_Add(x_2, 2)
-    r25 = box(int, r24)
-    r26 = CPyList_SetItemUnsafe(r16, r17, r25)
+    r18 = list_get_item_unsafe source, r14
+    r19 = unbox(int, r18)
+    x_2 = r19
+    r20 = CPyTagged_Add(x_2, 2)
+    r21 = box(int, r20)
+    r22 = CPyList_SetItemUnsafe(r13, r14, r21)
 L7:
-    r27 = r17 + 2
-    r17 = r27
+    r23 = r14 + 2
+    r14 = r23
     goto L5
 L8:
-    b = r16
+    b = r13
     return 1
+
 [case testGeneratorNext]
 from typing import List, Optional
 
@@ -407,42 +435,39 @@ def test(x: List[int]) -> None:
 def test(x):
     x :: list
     r0 :: short_int
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
-    r4 :: bit
-    r5 :: object
-    r6, i :: int
-    r7 :: object
-    r8 :: union[int, None]
-    r9 :: short_int
-    r10 :: object
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: bit
+    r4 :: object
+    r5, i :: int
+    r6 :: object
+    r7 :: union[int, None]
+    r8 :: short_int
+    r9 :: object
     res :: union[int, None]
 L0:
     r0 = 0
 L1:
-    r1 = get_element_ptr x ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
-    keep_alive x
-    r3 = r2 << 1
-    r4 = r0 < r3 :: signed
-    if r4 goto L2 else goto L4 :: bool
+    r1 = var_object_size x
+    r2 = r1 << 1
+    r3 = int_lt r0, r2
+    if r3 goto L2 else goto L4 :: bool
 L2:
-    r5 = CPyList_GetItemUnsafe(x, r0)
-    r6 = unbox(int, r5)
-    i = r6
-    r7 = box(int, i)
-    r8 = r7
+    r4 = list_get_item_unsafe x, r0
+    r5 = unbox(int, r4)
+    i = r5
+    r6 = box(int, i)
+    r7 = r6
     goto L5
 L3:
-    r9 = r0 + 2
-    r0 = r9
+    r8 = r0 + 2
+    r0 = r8
     goto L1
 L4:
-    r10 = box(None, 1)
-    r8 = r10
+    r9 = box(None, 1)
+    r7 = r9
 L5:
-    res = r8
+    res = r7
     return 1
 
 [case testSimplifyListUnion]
@@ -462,86 +487,99 @@ 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
-    r5 :: ptr
-    r6 :: native_int
-    r7 :: short_int
-    r8 :: int
+    r5 :: native_int
+    r6 :: short_int
+    r7 :: int
 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)
-    r5 = get_element_ptr r4 ob_size :: PyVarObject
-    r6 = load_mem r5 :: native_int*
-    keep_alive r4
-    r7 = r6 << 1
+    r5 = var_object_size r4
+    r6 = r5 << 1
     keep_alive a
-    return r7
+    return r6
 L2:
-    r8 = unbox(int, a)
-    return r8
+    r7 = unbox(int, a)
+    return r7
 def loop(a):
     a :: list
     r0 :: short_int
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
-    r4 :: bit
-    r5 :: object
-    r6, x :: union[str, bytes]
-    r7 :: short_int
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: bit
+    r4 :: object
+    r5, x :: union[str, bytes]
+    r6 :: short_int
 L0:
     r0 = 0
 L1:
-    r1 = get_element_ptr a ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
-    keep_alive a
-    r3 = r2 << 1
-    r4 = r0 < r3 :: signed
-    if r4 goto L2 else goto L4 :: bool
+    r1 = var_object_size a
+    r2 = r1 << 1
+    r3 = int_lt r0, r2
+    if r3 goto L2 else goto L4 :: bool
 L2:
-    r5 = CPyList_GetItemUnsafe(a, r0)
-    r6 = cast(union[str, bytes], r5)
-    x = r6
+    r4 = list_get_item_unsafe a, r0
+    r5 = cast(union[str, bytes], r4)
+    x = r5
 L3:
-    r7 = r0 + 2
-    r0 = r7
+    r6 = r0 + 2
+    r0 = r6
     goto L1
 L4:
     return 1
 def nested_union(a):
     a :: list
     r0 :: short_int
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
-    r4 :: bit
-    r5 :: object
-    r6, x :: union[str, None]
-    r7 :: short_int
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: bit
+    r4 :: object
+    r5, x :: union[str, None]
+    r6 :: short_int
 L0:
     r0 = 0
 L1:
-    r1 = get_element_ptr a ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
-    keep_alive a
-    r3 = r2 << 1
-    r4 = r0 < r3 :: signed
-    if r4 goto L2 else goto L4 :: bool
+    r1 = var_object_size a
+    r2 = r1 << 1
+    r3 = int_lt r0, r2
+    if r3 goto L2 else goto L4 :: bool
 L2:
-    r5 = CPyList_GetItemUnsafe(a, r0)
-    r6 = cast(union[str, None], r5)
-    x = r6
+    r4 = list_get_item_unsafe a, r0
+    r5 = cast(union[str, None], r4)
+    x = r5
 L3:
-    r7 = r0 + 2
-    r0 = r7
+    r6 = r0 + 2
+    r0 = r6
     goto L1
 L4:
     return 1
+
+[case testSorted]
+from typing import List, Any
+def list_sort(a: List[int]) -> None:
+    a.sort()
+def sort_iterable(a: Any) -> None:
+    sorted(a)
+[out]
+def list_sort(a):
+    a :: list
+    r0 :: i32
+    r1 :: bit
+L0:
+    r0 = PyList_Sort(a)
+    r1 = r0 >= 0 :: signed
+    return 1
+def sort_iterable(a):
+    a :: object
+    r0 :: list
+L0:
+    r0 = CPySequence_Sort(a)
+    return 1
diff --git a/mypyc/test-data/irbuild-match.test b/mypyc/test-data/irbuild-match.test
index 2afe3d862f51..28aff3dcfc45 100644
--- a/mypyc/test-data/irbuild-match.test
+++ b/mypyc/test-data/irbuild-match.test
@@ -14,7 +14,7 @@ def f():
     r6 :: object_ptr
     r7, r8 :: object
 L0:
-    r0 = 246 == 246
+    r0 = int_eq 246, 246
     if r0 goto L1 else goto L2 :: bool
 L1:
     r1 = 'matched'
@@ -23,13 +23,14 @@ L1:
     r4 = CPyObject_GetAttr(r2, r3)
     r5 = [r1]
     r6 = load_address r5
-    r7 = _PyObject_Vectorcall(r4, r6, 1, 0)
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
     keep_alive r1
     goto L3
 L2:
 L3:
     r8 = box(None, 1)
     return r8
+
 [case testMatchOrPattern_python3_10]
 def f():
     match 123:
@@ -46,10 +47,10 @@ def f():
     r7 :: object_ptr
     r8, r9 :: object
 L0:
-    r0 = 246 == 246
+    r0 = int_eq 246, 246
     if r0 goto L3 else goto L1 :: bool
 L1:
-    r1 = 246 == 912
+    r1 = int_eq 246, 912
     if r1 goto L3 else goto L2 :: bool
 L2:
     goto L4
@@ -60,13 +61,14 @@ L3:
     r5 = CPyObject_GetAttr(r3, r4)
     r6 = [r2]
     r7 = load_address r6
-    r8 = _PyObject_Vectorcall(r5, r7, 1, 0)
+    r8 = PyObject_Vectorcall(r5, r7, 1, 0)
     keep_alive r2
     goto L5
 L4:
 L5:
     r9 = box(None, 1)
     return r9
+
 [case testMatchOrPatternManyPatterns_python3_10]
 def f():
     match 1:
@@ -83,16 +85,16 @@ def f():
     r9 :: object_ptr
     r10, r11 :: object
 L0:
-    r0 = 2 == 2
+    r0 = int_eq 2, 2
     if r0 goto L5 else goto L1 :: bool
 L1:
-    r1 = 2 == 4
+    r1 = int_eq 2, 4
     if r1 goto L5 else goto L2 :: bool
 L2:
-    r2 = 2 == 6
+    r2 = int_eq 2, 6
     if r2 goto L5 else goto L3 :: bool
 L3:
-    r3 = 2 == 8
+    r3 = int_eq 2, 8
     if r3 goto L5 else goto L4 :: bool
 L4:
     goto L6
@@ -103,13 +105,14 @@ L5:
     r7 = CPyObject_GetAttr(r5, r6)
     r8 = [r4]
     r9 = load_address r8
-    r10 = _PyObject_Vectorcall(r7, r9, 1, 0)
+    r10 = PyObject_Vectorcall(r7, r9, 1, 0)
     keep_alive r4
     goto L7
 L6:
 L7:
     r11 = box(None, 1)
     return r11
+
 [case testMatchClassPattern_python3_10]
 def f():
     match 123:
@@ -138,14 +141,14 @@ L1:
     r6 = CPyObject_GetAttr(r4, r5)
     r7 = [r3]
     r8 = load_address r7
-    r9 = _PyObject_Vectorcall(r6, r8, 1, 0)
+    r9 = PyObject_Vectorcall(r6, r8, 1, 0)
     keep_alive r3
     goto L3
 L2:
 L3:
     r10 = box(None, 1)
     return r10
-[case testMatchExaustivePattern_python3_10]
+[case testMatchExhaustivePattern_python3_10]
 def f():
     match 123:
         case _:
@@ -167,7 +170,7 @@ L1:
     r3 = CPyObject_GetAttr(r1, r2)
     r4 = [r0]
     r5 = load_address r4
-    r6 = _PyObject_Vectorcall(r3, r5, 1, 0)
+    r6 = PyObject_Vectorcall(r3, r5, 1, 0)
     keep_alive r0
     goto L3
 L2:
@@ -200,7 +203,7 @@ def f():
     r14 :: object_ptr
     r15, r16 :: object
 L0:
-    r0 = 246 == 246
+    r0 = int_eq 246, 246
     if r0 goto L1 else goto L2 :: bool
 L1:
     r1 = 'matched'
@@ -209,11 +212,11 @@ L1:
     r4 = CPyObject_GetAttr(r2, r3)
     r5 = [r1]
     r6 = load_address r5
-    r7 = _PyObject_Vectorcall(r4, r6, 1, 0)
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
     keep_alive r1
     goto L5
 L2:
-    r8 = 246 == 912
+    r8 = int_eq 246, 912
     if r8 goto L3 else goto L4 :: bool
 L3:
     r9 = 'no match'
@@ -222,13 +225,14 @@ L3:
     r12 = CPyObject_GetAttr(r10, r11)
     r13 = [r9]
     r14 = load_address r13
-    r15 = _PyObject_Vectorcall(r12, r14, 1, 0)
+    r15 = PyObject_Vectorcall(r12, r14, 1, 0)
     keep_alive r9
     goto L5
 L4:
 L5:
     r16 = box(None, 1)
     return r16
+
 [case testMatchMultiBodyAndComplexOr_python3_10]
 def f():
     match 123:
@@ -265,7 +269,7 @@ def f():
     r23 :: object_ptr
     r24, r25 :: object
 L0:
-    r0 = 246 == 2
+    r0 = int_eq 246, 2
     if r0 goto L1 else goto L2 :: bool
 L1:
     r1 = 'here 1'
@@ -274,14 +278,14 @@ L1:
     r4 = CPyObject_GetAttr(r2, r3)
     r5 = [r1]
     r6 = load_address r5
-    r7 = _PyObject_Vectorcall(r4, r6, 1, 0)
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
     keep_alive r1
     goto L9
 L2:
-    r8 = 246 == 4
+    r8 = int_eq 246, 4
     if r8 goto L5 else goto L3 :: bool
 L3:
-    r9 = 246 == 6
+    r9 = int_eq 246, 6
     if r9 goto L5 else goto L4 :: bool
 L4:
     goto L6
@@ -292,11 +296,11 @@ L5:
     r13 = CPyObject_GetAttr(r11, r12)
     r14 = [r10]
     r15 = load_address r14
-    r16 = _PyObject_Vectorcall(r13, r15, 1, 0)
+    r16 = PyObject_Vectorcall(r13, r15, 1, 0)
     keep_alive r10
     goto L9
 L6:
-    r17 = 246 == 246
+    r17 = int_eq 246, 246
     if r17 goto L7 else goto L8 :: bool
 L7:
     r18 = 'here 123'
@@ -305,13 +309,14 @@ L7:
     r21 = CPyObject_GetAttr(r19, r20)
     r22 = [r18]
     r23 = load_address r22
-    r24 = _PyObject_Vectorcall(r21, r23, 1, 0)
+    r24 = PyObject_Vectorcall(r21, r23, 1, 0)
     keep_alive r18
     goto L9
 L8:
 L9:
     r25 = box(None, 1)
     return r25
+
 [case testMatchWithGuard_python3_10]
 def f():
     match 123:
@@ -328,7 +333,7 @@ def f():
     r6 :: object_ptr
     r7, r8 :: object
 L0:
-    r0 = 246 == 246
+    r0 = int_eq 246, 246
     if r0 goto L1 else goto L3 :: bool
 L1:
     if 1 goto L2 else goto L3 :: bool
@@ -339,13 +344,14 @@ L2:
     r4 = CPyObject_GetAttr(r2, r3)
     r5 = [r1]
     r6 = load_address r5
-    r7 = _PyObject_Vectorcall(r4, r6, 1, 0)
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
     keep_alive r1
     goto L4
 L3:
 L4:
     r8 = box(None, 1)
     return r8
+
 [case testMatchSingleton_python3_10]
 def f():
     match 123:
@@ -394,7 +400,7 @@ L1:
     r6 = CPyObject_GetAttr(r4, r5)
     r7 = [r3]
     r8 = load_address r7
-    r9 = _PyObject_Vectorcall(r6, r8, 1, 0)
+    r9 = PyObject_Vectorcall(r6, r8, 1, 0)
     keep_alive r3
     goto L7
 L2:
@@ -409,7 +415,7 @@ L3:
     r16 = CPyObject_GetAttr(r14, r15)
     r17 = [r13]
     r18 = load_address r17
-    r19 = _PyObject_Vectorcall(r16, r18, 1, 0)
+    r19 = PyObject_Vectorcall(r16, r18, 1, 0)
     keep_alive r13
     goto L7
 L4:
@@ -424,7 +430,7 @@ L5:
     r26 = CPyObject_GetAttr(r24, r25)
     r27 = [r23]
     r28 = load_address r27
-    r29 = _PyObject_Vectorcall(r26, r28, 1, 0)
+    r29 = PyObject_Vectorcall(r26, r28, 1, 0)
     keep_alive r23
     goto L7
 L6:
@@ -449,7 +455,7 @@ def f():
     r9 :: object_ptr
     r10, r11 :: object
 L0:
-    r0 = 2 == 2
+    r0 = int_eq 2, 2
     if r0 goto L3 else goto L1 :: bool
 L1:
     r1 = load_address PyLong_Type
@@ -465,13 +471,14 @@ L3:
     r7 = CPyObject_GetAttr(r5, r6)
     r8 = [r4]
     r9 = load_address r8
-    r10 = _PyObject_Vectorcall(r7, r9, 1, 0)
+    r10 = PyObject_Vectorcall(r7, r9, 1, 0)
     keep_alive r4
     goto L5
 L4:
 L5:
     r11 = box(None, 1)
     return r11
+
 [case testMatchAsPattern_python3_10]
 def f():
     match 123:
@@ -487,7 +494,7 @@ def f():
     r6 :: object_ptr
     r7, r8 :: object
 L0:
-    r0 = 246 == 246
+    r0 = int_eq 246, 246
     r1 = object 123
     x = r1
     if r0 goto L1 else goto L2 :: bool
@@ -497,13 +504,14 @@ L1:
     r4 = CPyObject_GetAttr(r2, r3)
     r5 = [x]
     r6 = load_address r5
-    r7 = _PyObject_Vectorcall(r4, r6, 1, 0)
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
     keep_alive x
     goto L3
 L2:
 L3:
     r8 = box(None, 1)
     return r8
+
 [case testMatchAsPatternOnOrPattern_python3_10]
 def f():
     match 1:
@@ -521,12 +529,12 @@ def f():
     r8 :: object_ptr
     r9, r10 :: object
 L0:
-    r0 = 2 == 2
+    r0 = int_eq 2, 2
     r1 = object 1
     x = r1
     if r0 goto L3 else goto L1 :: bool
 L1:
-    r2 = 2 == 4
+    r2 = int_eq 2, 4
     r3 = object 2
     x = r3
     if r2 goto L3 else goto L2 :: bool
@@ -538,13 +546,14 @@ L3:
     r6 = CPyObject_GetAttr(r4, r5)
     r7 = [x]
     r8 = load_address r7
-    r9 = _PyObject_Vectorcall(r6, r8, 1, 0)
+    r9 = PyObject_Vectorcall(r6, r8, 1, 0)
     keep_alive x
     goto L5
 L4:
 L5:
     r10 = box(None, 1)
     return r10
+
 [case testMatchAsPatternOnClassPattern_python3_10]
 def f():
     match 123:
@@ -575,7 +584,7 @@ L2:
     r6 = box(int, i)
     r7 = [r6]
     r8 = load_address r7
-    r9 = _PyObject_Vectorcall(r5, r8, 1, 0)
+    r9 = PyObject_Vectorcall(r5, r8, 1, 0)
     keep_alive r6
     goto L4
 L3:
@@ -608,22 +617,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 +646,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 +655,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 +664,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 +673,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'
@@ -673,7 +682,7 @@ L4:
     r28 = CPyObject_GetAttr(r26, r27)
     r29 = [r25]
     r30 = load_address r29
-    r31 = _PyObject_Vectorcall(r28, r30, 1, 0)
+    r31 = PyObject_Vectorcall(r28, r30, 1, 0)
     keep_alive r25
     goto L6
 L5:
@@ -693,22 +702,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 +731,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 +740,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 +749,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 +758,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'
@@ -758,7 +767,7 @@ L4:
     r28 = CPyObject_GetAttr(r26, r27)
     r29 = [r25]
     r30 = load_address r29
-    r31 = _PyObject_Vectorcall(r28, r30, 1, 0)
+    r31 = PyObject_Vectorcall(r28, r30, 1, 0)
     keep_alive r25
     goto L6
 L5:
@@ -776,16 +785,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 +808,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 +817,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
@@ -826,7 +835,7 @@ L4:
     r19 = CPyObject_GetAttr(r17, r18)
     r20 = [r16]
     r21 = load_address r20
-    r22 = _PyObject_Vectorcall(r19, r21, 1, 0)
+    r22 = PyObject_Vectorcall(r19, r21, 1, 0)
     keep_alive r16
     goto L6
 L5:
@@ -856,18 +865,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 +890,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 +902,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 +911,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'
@@ -911,7 +920,7 @@ L4:
     r22 = CPyObject_GetAttr(r20, r21)
     r23 = [r19]
     r24 = load_address r23
-    r25 = _PyObject_Vectorcall(r22, r24, 1, 0)
+    r25 = PyObject_Vectorcall(r22, r24, 1, 0)
     keep_alive r19
     goto L6
 L5:
@@ -940,7 +949,7 @@ L0:
     return 1
 def f(x):
     x, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: str
@@ -957,7 +966,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'
@@ -971,7 +980,7 @@ L2:
     r10 = CPyObject_GetAttr(r8, r9)
     r11 = [r7]
     r12 = load_address r11
-    r13 = _PyObject_Vectorcall(r10, r12, 1, 0)
+    r13 = PyObject_Vectorcall(r10, r12, 1, 0)
     keep_alive r7
     goto L4
 L3:
@@ -986,7 +995,7 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: str
     r3 :: object
@@ -1006,7 +1015,7 @@ L1:
     r5 = CPyObject_GetAttr(r3, r4)
     r6 = [r2]
     r7 = load_address r6
-    r8 = _PyObject_Vectorcall(r5, r7, 1, 0)
+    r8 = PyObject_Vectorcall(r5, r7, 1, 0)
     keep_alive r2
     goto L3
 L2:
@@ -1021,15 +1030,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 +1063,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'
@@ -1063,7 +1072,7 @@ L3:
     r14 = CPyObject_GetAttr(r12, r13)
     r15 = [r11]
     r16 = load_address r15
-    r17 = _PyObject_Vectorcall(r14, r16, 1, 0)
+    r17 = PyObject_Vectorcall(r14, r16, 1, 0)
     keep_alive r11
     goto L5
 L4:
@@ -1078,7 +1087,7 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2, rest :: dict
     r3 :: str
@@ -1102,7 +1111,7 @@ L2:
     r6 = CPyObject_GetAttr(r4, r5)
     r7 = [r3]
     r8 = load_address r7
-    r9 = _PyObject_Vectorcall(r6, r8, 1, 0)
+    r9 = PyObject_Vectorcall(r6, r8, 1, 0)
     keep_alive r3
     goto L4
 L3:
@@ -1117,19 +1126,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 +1162,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)
@@ -1167,7 +1176,7 @@ L4:
     r17 = CPyObject_GetAttr(r15, r16)
     r18 = [r14]
     r19 = load_address r18
-    r20 = _PyObject_Vectorcall(r17, r19, 1, 0)
+    r20 = PyObject_Vectorcall(r17, r19, 1, 0)
     keep_alive r14
     goto L6
 L5:
@@ -1182,7 +1191,7 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
@@ -1209,7 +1218,7 @@ L2:
     r8 = CPyObject_GetAttr(r6, r7)
     r9 = [r5]
     r10 = load_address r9
-    r11 = _PyObject_Vectorcall(r8, r10, 1, 0)
+    r11 = PyObject_Vectorcall(r8, r10, 1, 0)
     keep_alive r5
     goto L4
 L3:
@@ -1224,16 +1233,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 +1267,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 +1275,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'
@@ -1275,7 +1284,7 @@ L4:
     r20 = CPyObject_GetAttr(r18, r19)
     r21 = [r17]
     r22 = load_address r21
-    r23 = _PyObject_Vectorcall(r20, r22, 1, 0)
+    r23 = PyObject_Vectorcall(r20, r22, 1, 0)
     keep_alive r17
     goto L6
 L5:
@@ -1290,16 +1299,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 +1333,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 +1341,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'
@@ -1341,7 +1350,7 @@ L4:
     r20 = CPyObject_GetAttr(r18, r19)
     r21 = [r17]
     r22 = load_address r21
-    r23 = _PyObject_Vectorcall(r20, r22, 1, 0)
+    r23 = PyObject_Vectorcall(r20, r22, 1, 0)
     keep_alive r17
     goto L6
 L5:
@@ -1356,27 +1365,28 @@ 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
-    r18, rest :: object
-    r19 :: str
-    r20 :: object
-    r21 :: str
-    r22 :: object
-    r23 :: object[1]
-    r24 :: object_ptr
-    r25, r26 :: object
+    r18 :: object
+    r19, rest :: list
+    r20 :: str
+    r21 :: object
+    r22 :: str
+    r23 :: object
+    r24 :: object[1]
+    r25 :: object_ptr
+    r26, r27 :: object
 L0:
     r0 = CPySequence_Check(x)
     r1 = r0 != 0
@@ -1392,7 +1402,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,26 +1410,28 @@ 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
     r18 = PySequence_GetSlice(x, 2, r17)
-    rest = r18
+    r19 = cast(list, r18)
+    rest = r19
 L5:
-    r19 = 'matched'
-    r20 = builtins :: module
-    r21 = 'print'
-    r22 = CPyObject_GetAttr(r20, r21)
-    r23 = [r19]
-    r24 = load_address r23
-    r25 = _PyObject_Vectorcall(r22, r24, 1, 0)
-    keep_alive r19
+    r20 = 'matched'
+    r21 = builtins :: module
+    r22 = 'print'
+    r23 = CPyObject_GetAttr(r21, r22)
+    r24 = [r20]
+    r25 = load_address r24
+    r26 = PyObject_Vectorcall(r23, r25, 1, 0)
+    keep_alive r20
     goto L7
 L6:
 L7:
-    r26 = box(None, 1)
-    return r26
+    r27 = box(None, 1)
+    return r27
+
 [case testMatchSequenceWithStarPatternInTheMiddle_python3_10]
 def f(x):
     match x:
@@ -1428,32 +1440,33 @@ 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
-    r19, rest :: object
-    r20 :: str
-    r21 :: object
-    r22 :: str
-    r23 :: object
-    r24 :: object[1]
-    r25 :: object_ptr
-    r26, r27 :: object
+    r19 :: object
+    r20, rest :: list
+    r21 :: str
+    r22 :: object
+    r23 :: str
+    r24 :: object
+    r25 :: object[1]
+    r26 :: object_ptr
+    r27, r28 :: object
 L0:
     r0 = CPySequence_Check(x)
     r1 = r0 != 0
@@ -1469,7 +1482,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,26 +1491,28 @@ 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
     r19 = PySequence_GetSlice(x, 1, r18)
-    rest = r19
+    r20 = cast(list, r19)
+    rest = r20
 L5:
-    r20 = 'matched'
-    r21 = builtins :: module
-    r22 = 'print'
-    r23 = CPyObject_GetAttr(r21, r22)
-    r24 = [r20]
-    r25 = load_address r24
-    r26 = _PyObject_Vectorcall(r23, r25, 1, 0)
-    keep_alive r20
+    r21 = 'matched'
+    r22 = builtins :: module
+    r23 = 'print'
+    r24 = CPyObject_GetAttr(r22, r23)
+    r25 = [r21]
+    r26 = load_address r25
+    r27 = PyObject_Vectorcall(r24, r26, 1, 0)
+    keep_alive r21
     goto L7
 L6:
 L7:
-    r27 = box(None, 1)
-    return r27
+    r28 = box(None, 1)
+    return r28
+
 [case testMatchSequenceWithStarPatternAtTheStart_python3_10]
 def f(x):
     match x:
@@ -1506,29 +1521,30 @@ 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
-    r20, rest :: object
-    r21 :: str
-    r22 :: object
-    r23 :: str
-    r24 :: object
-    r25 :: object[1]
-    r26 :: object_ptr
-    r27, r28 :: object
+    r20 :: object
+    r21, rest :: list
+    r22 :: str
+    r23 :: object
+    r24 :: str
+    r25 :: object
+    r26 :: object[1]
+    r27 :: object_ptr
+    r28, r29 :: object
 L0:
     r0 = CPySequence_Check(x)
     r1 = r0 != 0
@@ -1545,7 +1561,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,26 +1570,28 @@ 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
     r20 = PySequence_GetSlice(x, 0, r19)
-    rest = r20
+    r21 = cast(list, r20)
+    rest = r21
 L5:
-    r21 = 'matched'
-    r22 = builtins :: module
-    r23 = 'print'
-    r24 = CPyObject_GetAttr(r22, r23)
-    r25 = [r21]
-    r26 = load_address r25
-    r27 = _PyObject_Vectorcall(r24, r26, 1, 0)
-    keep_alive r21
+    r22 = 'matched'
+    r23 = builtins :: module
+    r24 = 'print'
+    r25 = CPyObject_GetAttr(r23, r24)
+    r26 = [r22]
+    r27 = load_address r26
+    r28 = PyObject_Vectorcall(r25, r27, 1, 0)
+    keep_alive r22
     goto L7
 L6:
 L7:
-    r28 = box(None, 1)
-    return r28
+    r29 = box(None, 1)
+    return r29
+
 [case testMatchBuiltinClassPattern_python3_10]
 def f(x):
     match x:
@@ -1605,7 +1623,7 @@ L2:
     r6 = CPyObject_GetAttr(r4, r5)
     r7 = [r3]
     r8 = load_address r7
-    r9 = _PyObject_Vectorcall(r6, r8, 1, 0)
+    r9 = PyObject_Vectorcall(r6, r8, 1, 0)
     keep_alive r3
     goto L4
 L3:
@@ -1620,19 +1638,20 @@ 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, rest :: object
-    r7 :: str
-    r8 :: object
-    r9 :: str
-    r10 :: object
-    r11 :: object[1]
-    r12 :: object_ptr
-    r13, r14 :: object
+    r6 :: object
+    r7, rest :: list
+    r8 :: str
+    r9 :: object
+    r10 :: str
+    r11 :: object
+    r12 :: object[1]
+    r13 :: object_ptr
+    r14, r15 :: object
 L0:
     r0 = CPySequence_Check(x)
     r1 = r0 != 0
@@ -1645,21 +1664,23 @@ L1:
 L2:
     r5 = r2 - 0
     r6 = PySequence_GetSlice(x, 0, r5)
-    rest = r6
+    r7 = cast(list, r6)
+    rest = r7
 L3:
-    r7 = 'matched'
-    r8 = builtins :: module
-    r9 = 'print'
-    r10 = CPyObject_GetAttr(r8, r9)
-    r11 = [r7]
-    r12 = load_address r11
-    r13 = _PyObject_Vectorcall(r10, r12, 1, 0)
-    keep_alive r7
+    r8 = 'matched'
+    r9 = builtins :: module
+    r10 = 'print'
+    r11 = CPyObject_GetAttr(r9, r10)
+    r12 = [r8]
+    r13 = load_address r12
+    r14 = PyObject_Vectorcall(r11, r13, 1, 0)
+    keep_alive r8
     goto L5
 L4:
 L5:
-    r14 = box(None, 1)
-    return r14
+    r15 = box(None, 1)
+    return r15
+
 [case testMatchTypeAnnotatedNativeClass_python3_10]
 class A:
     a: int
@@ -1674,7 +1695,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 +1708,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'
@@ -1706,3 +1727,81 @@ L4:
 L5:
 L6:
     unreachable
+
+[case testMatchLiteralMatchArgs_python3_10]
+from typing import Literal
+
+class Foo:
+    __match_args__: tuple[Literal["foo"]] = ("foo",)
+    foo: str
+
+def f(x: Foo) -> None:
+    match x:
+        case Foo(foo):
+            print("foo")
+        case _:
+            assert False, "Unreachable"
+[out]
+def Foo.__mypyc_defaults_setup(__mypyc_self__):
+    __mypyc_self__ :: __main__.Foo
+    r0 :: str
+    r1 :: tuple[str]
+L0:
+    r0 = 'foo'
+    r1 = (r0)
+    __mypyc_self__.__match_args__ = r1
+    return 1
+def f(x):
+    x :: __main__.Foo
+    r0 :: object
+    r1 :: i32
+    r2 :: bit
+    r3 :: bool
+    r4 :: str
+    r5 :: object
+    r6, foo, r7 :: str
+    r8 :: object
+    r9 :: str
+    r10 :: object
+    r11 :: object[1]
+    r12 :: object_ptr
+    r13, r14 :: object
+    r15 :: i32
+    r16 :: bit
+    r17, r18 :: bool
+L0:
+    r0 = __main__.Foo :: type
+    r1 = PyObject_IsInstance(x, r0)
+    r2 = r1 >= 0 :: signed
+    r3 = truncate r1: i32 to builtins.bool
+    if r3 goto L1 else goto L3 :: bool
+L1:
+    r4 = 'foo'
+    r5 = CPyObject_GetAttr(x, r4)
+    r6 = cast(str, r5)
+    foo = r6
+L2:
+    r7 = 'foo'
+    r8 = builtins :: module
+    r9 = 'print'
+    r10 = CPyObject_GetAttr(r8, r9)
+    r11 = [r7]
+    r12 = load_address r11
+    r13 = PyObject_Vectorcall(r10, r12, 1, 0)
+    keep_alive r7
+    goto L8
+L3:
+L4:
+    r14 = box(bool, 0)
+    r15 = PyObject_IsTrue(r14)
+    r16 = r15 >= 0 :: signed
+    r17 = truncate r15: i32 to builtins.bool
+    if r17 goto L6 else goto L5 :: bool
+L5:
+    r18 = raise AssertionError('Unreachable')
+    unreachable
+L6:
+    goto L8
+L7:
+L8:
+    return 1
diff --git a/mypyc/test-data/irbuild-nested.test b/mypyc/test-data/irbuild-nested.test
index adef80263533..1b390e9c3504 100644
--- a/mypyc/test-data/irbuild-nested.test
+++ b/mypyc/test-data/irbuild-nested.test
@@ -50,25 +50,22 @@ L2:
 def inner_a_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.inner_a_obj
     r0 :: __main__.a_env
-    r1, inner, r2 :: object
+    r1 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = box(None, 1)
-    return r2
+    r1 = box(None, 1)
+    return r1
 def a():
     r0 :: __main__.a_env
     r1 :: __main__.inner_a_obj
-    r2, r3 :: bool
-    r4 :: object
+    r2 :: bool
+    inner :: object
 L0:
     r0 = a_env()
     r1 = inner_a_obj()
     r1.__mypyc_env__ = r0; r2 = is_error
-    r0.inner = r1; r3 = is_error
-    r4 = r0.inner
-    return r4
+    inner = r1
+    return inner
 def second_b_first_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -86,15 +83,12 @@ def second_b_first_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.second_b_first_obj
     r0 :: __main__.first_b_env
     r1 :: __main__.b_env
-    r2, second :: object
-    r3 :: str
+    r2 :: str
 L0:
     r0 = __mypyc_self__.__mypyc_env__
     r1 = r0.__mypyc_env__
-    r2 = r0.second
-    second = r2
-    r3 = 'b.first.second: nested function'
-    return r3
+    r2 = 'b.first.second: nested function'
+    return r2
 def first_b_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -111,35 +105,30 @@ L2:
 def first_b_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.first_b_obj
     r0 :: __main__.b_env
-    r1, first :: object
-    r2 :: __main__.first_b_env
-    r3 :: bool
-    r4 :: __main__.second_b_first_obj
-    r5, r6 :: bool
-    r7 :: object
+    r1 :: __main__.first_b_env
+    r2 :: bool
+    r3 :: __main__.second_b_first_obj
+    r4 :: bool
+    second :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.first
-    first = r1
-    r2 = first_b_env()
-    r2.__mypyc_env__ = r0; r3 = is_error
-    r4 = second_b_first_obj()
-    r4.__mypyc_env__ = r2; r5 = is_error
-    r2.second = r4; r6 = is_error
-    r7 = r2.second
-    return r7
+    r1 = first_b_env()
+    r1.__mypyc_env__ = r0; r2 = is_error
+    r3 = second_b_first_obj()
+    r3.__mypyc_env__ = r1; r4 = is_error
+    second = r3
+    return second
 def b():
     r0 :: __main__.b_env
     r1 :: __main__.first_b_obj
-    r2, r3 :: bool
-    r4 :: object
+    r2 :: bool
+    first :: object
 L0:
     r0 = b_env()
     r1 = first_b_obj()
     r1.__mypyc_env__ = r0; r2 = is_error
-    r0.first = r1; r3 = is_error
-    r4 = r0.first
-    return r4
+    first = r1
+    return first
 def inner_c_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -157,28 +146,24 @@ def inner_c_obj.__call__(__mypyc_self__, s):
     __mypyc_self__ :: __main__.inner_c_obj
     s :: str
     r0 :: __main__.c_env
-    r1, inner :: object
-    r2, r3 :: str
+    r1, r2 :: str
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = '!'
-    r3 = PyUnicode_Concat(s, r2)
-    return r3
+    r1 = '!'
+    r2 = PyUnicode_Concat(s, r1)
+    return r2
 def c(num):
     num :: float
     r0 :: __main__.c_env
     r1 :: __main__.inner_c_obj
-    r2, r3 :: bool
-    r4 :: object
+    r2 :: bool
+    inner :: object
 L0:
     r0 = c_env()
     r1 = inner_c_obj()
     r1.__mypyc_env__ = r0; r2 = is_error
-    r0.inner = r1; r3 = is_error
-    r4 = r0.inner
-    return r4
+    inner = r1
+    return inner
 def inner_d_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -196,40 +181,46 @@ def inner_d_obj.__call__(__mypyc_self__, s):
     __mypyc_self__ :: __main__.inner_d_obj
     s :: str
     r0 :: __main__.d_env
-    r1, inner :: object
-    r2, r3 :: str
+    r1, r2 :: str
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = '?'
-    r3 = PyUnicode_Concat(s, r2)
-    return r3
+    r1 = '?'
+    r2 = PyUnicode_Concat(s, r1)
+    return r2
 def d(num):
     num :: float
     r0 :: __main__.d_env
     r1 :: __main__.inner_d_obj
-    r2, r3 :: bool
-    r4 :: str
-    r5, r6 :: object
+    r2 :: bool
+    inner :: object
+    r3 :: str
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
     r7, a, r8 :: str
-    r9, r10 :: object
-    r11, b :: str
+    r9 :: object[1]
+    r10 :: object_ptr
+    r11 :: object
+    r12, b :: str
 L0:
     r0 = d_env()
     r1 = inner_d_obj()
     r1.__mypyc_env__ = r0; r2 = is_error
-    r0.inner = r1; r3 = is_error
-    r4 = 'one'
-    r5 = r0.inner
-    r6 = PyObject_CallFunctionObjArgs(r5, r4, 0)
+    inner = r1
+    r3 = 'one'
+    r4 = [r3]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(inner, r5, 1, 0)
+    keep_alive r3
     r7 = cast(str, r6)
     a = r7
     r8 = 'two'
-    r9 = r0.inner
-    r10 = PyObject_CallFunctionObjArgs(r9, r8, 0)
-    r11 = cast(str, r10)
-    b = r11
+    r9 = [r8]
+    r10 = load_address r9
+    r11 = PyObject_Vectorcall(inner, r10, 1, 0)
+    keep_alive r8
+    r12 = cast(str, r11)
+    b = r12
     return a
 def inner():
     r0 :: str
@@ -290,32 +281,28 @@ L2:
 def inner_a_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.inner_a_obj
     r0 :: __main__.a_env
-    r1, inner :: object
-    r2 :: int
+    r1 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = r0.num
-    return r2
+    r1 = r0.num
+    return r1
 def a(num):
     num :: int
     r0 :: __main__.a_env
     r1 :: bool
     r2 :: __main__.inner_a_obj
-    r3, r4 :: bool
-    r5, r6 :: object
-    r7 :: int
+    r3 :: bool
+    inner, r4 :: object
+    r5 :: int
 L0:
     r0 = a_env()
     r0.num = num; r1 = is_error
     r2 = inner_a_obj()
     r2.__mypyc_env__ = r0; r3 = is_error
-    r0.inner = r2; r4 = is_error
-    r5 = r0.inner
-    r6 = PyObject_CallFunctionObjArgs(r5, 0)
-    r7 = unbox(int, r6)
-    return r7
+    inner = r2
+    r4 = PyObject_Vectorcall(inner, 0, 0, 0)
+    r5 = unbox(int, r4)
+    return r5
 def inner_b_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -332,36 +319,32 @@ L2:
 def inner_b_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.inner_b_obj
     r0 :: __main__.b_env
-    r1, inner :: object
-    r2 :: bool
-    foo, r3 :: int
+    r1 :: bool
+    foo, r2 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r0.num = 8; r2 = is_error
+    r0.num = 8; r1 = is_error
     foo = 12
-    r3 = r0.num
-    return r3
+    r2 = r0.num
+    return r2
 def b():
     r0 :: __main__.b_env
     r1 :: bool
     r2 :: __main__.inner_b_obj
-    r3, r4 :: bool
-    r5, r6 :: object
-    r7, r8, r9 :: int
+    r3 :: bool
+    inner, r4 :: object
+    r5, r6, r7 :: int
 L0:
     r0 = b_env()
     r0.num = 6; r1 = is_error
     r2 = inner_b_obj()
     r2.__mypyc_env__ = r0; r3 = is_error
-    r0.inner = r2; r4 = is_error
-    r5 = r0.inner
-    r6 = PyObject_CallFunctionObjArgs(r5, 0)
-    r7 = unbox(int, r6)
-    r8 = r0.num
-    r9 = CPyTagged_Add(r7, r8)
-    return r9
+    inner = r2
+    r4 = PyObject_Vectorcall(inner, 0, 0, 0)
+    r5 = unbox(int, r4)
+    r6 = r0.num
+    r7 = CPyTagged_Add(r5, r6)
+    return r7
 def inner_c_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -378,14 +361,11 @@ L2:
 def inner_c_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.inner_c_obj
     r0 :: __main__.c_env
-    r1, inner :: object
-    r2 :: str
+    r1 :: str
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = 'f.inner: first definition'
-    return r2
+    r1 = 'f.inner: first definition'
+    return r1
 def inner_c_obj_0.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -402,40 +382,37 @@ L2:
 def inner_c_obj_0.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.inner_c_obj_0
     r0 :: __main__.c_env
-    r1, inner :: object
-    r2 :: str
+    r1 :: str
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = 'f.inner: second definition'
-    return r2
+    r1 = 'f.inner: second definition'
+    return r1
 def c(flag):
     flag :: bool
     r0 :: __main__.c_env
     r1 :: __main__.inner_c_obj
-    r2, r3 :: bool
-    r4 :: __main__.inner_c_obj_0
-    r5, r6 :: bool
-    r7, r8 :: object
-    r9 :: str
+    r2 :: bool
+    inner :: object
+    r3 :: __main__.inner_c_obj_0
+    r4 :: bool
+    r5 :: object
+    r6 :: str
 L0:
     r0 = c_env()
     if flag goto L1 else goto L2 :: bool
 L1:
     r1 = inner_c_obj()
     r1.__mypyc_env__ = r0; r2 = is_error
-    r0.inner = r1; r3 = is_error
+    inner = r1
     goto L3
 L2:
-    r4 = inner_c_obj_0()
-    r4.__mypyc_env__ = r0; r5 = is_error
-    r0.inner = r4; r6 = is_error
+    r3 = inner_c_obj_0()
+    r3.__mypyc_env__ = r0; r4 = is_error
+    inner = r3
 L3:
-    r7 = r0.inner
-    r8 = PyObject_CallFunctionObjArgs(r7, 0)
-    r9 = cast(str, r8)
-    return r9
+    r5 = PyObject_Vectorcall(inner, 0, 0, 0)
+    r6 = cast(str, r5)
+    return r6
 
 [case testSpecialNested]
 def a() -> int:
@@ -465,15 +442,12 @@ def c_a_b_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.c_a_b_obj
     r0 :: __main__.b_a_env
     r1 :: __main__.a_env
-    r2, c :: object
-    r3 :: int
+    r2 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
     r1 = r0.__mypyc_env__
-    r2 = r0.c
-    c = r2
-    r3 = r1.x
-    return r3
+    r2 = r1.x
+    return r2
 def b_a_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -490,48 +464,43 @@ L2:
 def b_a_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.b_a_obj
     r0 :: __main__.a_env
-    r1, b :: object
-    r2 :: __main__.b_a_env
-    r3 :: bool
-    r4, r5 :: int
-    r6 :: bool
-    r7 :: __main__.c_a_b_obj
-    r8, r9 :: bool
-    r10, r11 :: object
-    r12 :: int
+    r1 :: __main__.b_a_env
+    r2 :: bool
+    r3, r4 :: int
+    r5 :: bool
+    r6 :: __main__.c_a_b_obj
+    r7 :: bool
+    c, r8 :: object
+    r9 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.b
-    b = r1
-    r2 = b_a_env()
-    r2.__mypyc_env__ = r0; r3 = is_error
-    r4 = r0.x
-    r5 = CPyTagged_Add(r4, 2)
-    r0.x = r5; r6 = is_error
-    r7 = c_a_b_obj()
-    r7.__mypyc_env__ = r2; r8 = is_error
-    r2.c = r7; r9 = is_error
-    r10 = r2.c
-    r11 = PyObject_CallFunctionObjArgs(r10, 0)
-    r12 = unbox(int, r11)
-    return r12
+    r1 = b_a_env()
+    r1.__mypyc_env__ = r0; r2 = is_error
+    r3 = r0.x
+    r4 = CPyTagged_Add(r3, 2)
+    r0.x = r4; r5 = is_error
+    r6 = c_a_b_obj()
+    r6.__mypyc_env__ = r1; r7 = is_error
+    c = r6
+    r8 = PyObject_Vectorcall(c, 0, 0, 0)
+    r9 = unbox(int, r8)
+    return r9
 def a():
     r0 :: __main__.a_env
     r1 :: bool
     r2 :: __main__.b_a_obj
-    r3, r4 :: bool
-    r5, r6 :: object
-    r7 :: int
+    r3 :: bool
+    b, r4 :: object
+    r5 :: int
 L0:
     r0 = a_env()
     r0.x = 2; r1 = is_error
     r2 = b_a_obj()
     r2.__mypyc_env__ = r0; r3 = is_error
-    r0.b = r2; r4 = is_error
-    r5 = r0.b
-    r6 = PyObject_CallFunctionObjArgs(r5, 0)
-    r7 = unbox(int, r6)
-    return r7
+    b = r2
+    r4 = PyObject_Vectorcall(b, 0, 0, 0)
+    r5 = unbox(int, r4)
+    return r5
 
 [case testNestedFunctionInsideStatements]
 def f(flag: bool) -> str:
@@ -559,14 +528,11 @@ L2:
 def inner_f_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.inner_f_obj
     r0 :: __main__.f_env
-    r1, inner :: object
-    r2 :: str
+    r1 :: str
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = 'f.inner: first definition'
-    return r2
+    r1 = 'f.inner: first definition'
+    return r1
 def inner_f_obj_0.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -583,40 +549,37 @@ L2:
 def inner_f_obj_0.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.inner_f_obj_0
     r0 :: __main__.f_env
-    r1, inner :: object
-    r2 :: str
+    r1 :: str
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.inner
-    inner = r1
-    r2 = 'f.inner: second definition'
-    return r2
+    r1 = 'f.inner: second definition'
+    return r1
 def f(flag):
     flag :: bool
     r0 :: __main__.f_env
     r1 :: __main__.inner_f_obj
-    r2, r3 :: bool
-    r4 :: __main__.inner_f_obj_0
-    r5, r6 :: bool
-    r7, r8 :: object
-    r9 :: str
+    r2 :: bool
+    inner :: object
+    r3 :: __main__.inner_f_obj_0
+    r4 :: bool
+    r5 :: object
+    r6 :: str
 L0:
     r0 = f_env()
     if flag goto L1 else goto L2 :: bool
 L1:
     r1 = inner_f_obj()
     r1.__mypyc_env__ = r0; r2 = is_error
-    r0.inner = r1; r3 = is_error
+    inner = r1
     goto L3
 L2:
-    r4 = inner_f_obj_0()
-    r4.__mypyc_env__ = r0; r5 = is_error
-    r0.inner = r4; r6 = is_error
+    r3 = inner_f_obj_0()
+    r3.__mypyc_env__ = r0; r4 = is_error
+    inner = r3
 L3:
-    r7 = r0.inner
-    r8 = PyObject_CallFunctionObjArgs(r7, 0)
-    r9 = cast(str, r8)
-    return r9
+    r5 = PyObject_Vectorcall(inner, 0, 0, 0)
+    r6 = cast(str, r5)
+    return r6
 
 [case testNestedFunctionsCallEachOther]
 from typing import Callable, List
@@ -652,15 +615,12 @@ L2:
 def foo_f_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.foo_f_obj
     r0 :: __main__.f_env
-    r1, foo :: object
-    r2, r3 :: int
+    r1, r2 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.foo
-    foo = r1
-    r2 = r0.a
-    r3 = CPyTagged_Add(r2, 2)
-    return r3
+    r1 = r0.a
+    r2 = CPyTagged_Add(r1, 2)
+    return r2
 def bar_f_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -677,16 +637,14 @@ L2:
 def bar_f_obj.__call__(__mypyc_self__):
     __mypyc_self__ :: __main__.bar_f_obj
     r0 :: __main__.f_env
-    r1, bar, r2, r3 :: object
-    r4 :: int
+    r1, r2 :: object
+    r3 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.bar
-    bar = r1
-    r2 = r0.foo
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
-    r4 = unbox(int, r3)
-    return r4
+    r1 = r0.foo
+    r2 = PyObject_Vectorcall(r1, 0, 0, 0)
+    r3 = unbox(int, r2)
+    return r3
 def baz_f_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -704,26 +662,30 @@ def baz_f_obj.__call__(__mypyc_self__, n):
     __mypyc_self__ :: __main__.baz_f_obj
     n :: int
     r0 :: __main__.f_env
-    r1, baz :: object
-    r2 :: bit
-    r3 :: int
-    r4, r5 :: object
-    r6, r7 :: int
+    r1 :: bit
+    r2 :: int
+    r3, r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7 :: object
+    r8, r9 :: int
 L0:
     r0 = __mypyc_self__.__mypyc_env__
-    r1 = r0.baz
-    baz = r1
-    r2 = n == 0
-    if r2 goto L1 else goto L2 :: bool
+    r1 = int_eq n, 0
+    if r1 goto L1 else goto L2 :: bool
 L1:
     return 0
 L2:
-    r3 = CPyTagged_Subtract(n, 2)
-    r4 = box(int, r3)
-    r5 = PyObject_CallFunctionObjArgs(baz, r4, 0)
-    r6 = unbox(int, r5)
-    r7 = CPyTagged_Add(n, r6)
-    return r7
+    r2 = CPyTagged_Subtract(n, 2)
+    r3 = r0.baz
+    r4 = box(int, r2)
+    r5 = [r4]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(r3, r6, 1, 0)
+    keep_alive r4
+    r8 = unbox(int, r7)
+    r9 = CPyTagged_Add(n, r8)
+    return r9
 def f(a):
     a :: int
     r0 :: __main__.f_env
@@ -736,8 +698,11 @@ def f(a):
     r9, r10 :: bool
     r11, r12 :: object
     r13, r14 :: int
-    r15, r16, r17 :: object
-    r18, r19 :: int
+    r15, r16 :: object
+    r17 :: object[1]
+    r18 :: object_ptr
+    r19 :: object
+    r20, r21 :: int
 L0:
     r0 = f_env()
     r0.a = a; r1 = is_error
@@ -751,15 +716,18 @@ L0:
     r8.__mypyc_env__ = r0; r9 = is_error
     r0.baz = r8; r10 = is_error
     r11 = r0.bar
-    r12 = PyObject_CallFunctionObjArgs(r11, 0)
+    r12 = PyObject_Vectorcall(r11, 0, 0, 0)
     r13 = unbox(int, r12)
     r14 = r0.a
     r15 = r0.baz
     r16 = box(int, r14)
-    r17 = PyObject_CallFunctionObjArgs(r15, r16, 0)
-    r18 = unbox(int, r17)
-    r19 = CPyTagged_Add(r13, r18)
-    return r19
+    r17 = [r16]
+    r18 = load_address r17
+    r19 = PyObject_Vectorcall(r15, r18, 1, 0)
+    keep_alive r16
+    r20 = unbox(int, r19)
+    r21 = CPyTagged_Add(r13, r20)
+    return r21
 
 [case testLambdas]
 def f(x: int, y: int) -> None:
@@ -807,12 +775,18 @@ def __mypyc_lambda__1_f_obj.__call__(__mypyc_self__, a, b):
     __mypyc_self__ :: __main__.__mypyc_lambda__1_f_obj
     a, b :: object
     r0 :: __main__.f_env
-    r1, r2 :: object
+    r1 :: object
+    r2 :: object[2]
+    r3 :: object_ptr
+    r4 :: object
 L0:
     r0 = __mypyc_self__.__mypyc_env__
     r1 = r0.s
-    r2 = PyObject_CallFunctionObjArgs(r1, a, b, 0)
-    return r2
+    r2 = [a, b]
+    r3 = load_address r2
+    r4 = PyObject_Vectorcall(r1, r3, 2, 0)
+    keep_alive a, b
+    return r4
 def f(x, y):
     x, y :: int
     r0 :: __main__.f_env
@@ -820,8 +794,11 @@ def f(x, y):
     r2, r3 :: bool
     r4 :: __main__.__mypyc_lambda__1_f_obj
     r5 :: bool
-    t, r6, r7, r8 :: object
-    r9 :: None
+    t, r6, r7 :: object
+    r8 :: object[2]
+    r9 :: object_ptr
+    r10 :: object
+    r11 :: None
 L0:
     r0 = f_env()
     r1 = __mypyc_lambda__0_f_obj()
@@ -832,9 +809,12 @@ L0:
     t = r4
     r6 = box(int, x)
     r7 = box(int, y)
-    r8 = PyObject_CallFunctionObjArgs(t, r6, r7, 0)
-    r9 = unbox(None, r8)
-    return r9
+    r8 = [r6, r7]
+    r9 = load_address r8
+    r10 = PyObject_Vectorcall(t, r9, 2, 0)
+    keep_alive r6, r7
+    r11 = unbox(None, r10)
+    return r11
 
 [case testRecursiveFunction]
 from typing import Callable
@@ -850,7 +830,7 @@ def baz(n):
     r0 :: bit
     r1, r2, r3 :: int
 L0:
-    r0 = n == 0
+    r0 = int_eq n, 0
     if r0 goto L1 else goto L2 :: bool
 L1:
     return 0
diff --git a/mypyc/test-data/irbuild-optional.test b/mypyc/test-data/irbuild-optional.test
index e98cf1b19e2e..75c008586999 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
@@ -222,7 +222,7 @@ def f(y):
 L0:
     r0 = box(None, 1)
     x = r0
-    r1 = y == 2
+    r1 = int_eq y, 2
     if r1 goto L1 else goto L2 :: bool
 L1:
     r2 = box(int, y)
@@ -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 b6c551124769..c42a1fa74a75 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)
@@ -39,7 +39,10 @@ L0:
     return r0
 
 [case testNewSetFromIterable]
-from typing import Set, List
+from typing import Set, List, TypeVar
+
+T = TypeVar("T")
+
 def f(l: List[T]) -> Set[T]:
     return set(l)
 [out]
@@ -79,58 +82,52 @@ L0:
 def test1():
     r0 :: list
     r1, r2, r3 :: object
-    r4, r5, r6, r7 :: ptr
+    r4 :: ptr
     tmp_list :: list
-    r8 :: set
-    r9 :: short_int
-    r10 :: ptr
-    r11 :: native_int
-    r12 :: short_int
-    r13 :: bit
-    r14 :: object
-    r15, x, r16 :: int
-    r17 :: object
-    r18 :: int32
-    r19 :: bit
-    r20 :: short_int
+    r5 :: set
+    r6 :: short_int
+    r7 :: native_int
+    r8 :: short_int
+    r9 :: bit
+    r10 :: object
+    r11, x, r12 :: int
+    r13 :: object
+    r14 :: i32
+    r15 :: bit
+    r16 :: short_int
     a :: set
 L0:
     r0 = PyList_New(3)
     r1 = object 1
     r2 = object 3
     r3 = object 5
-    r4 = get_element_ptr r0 ob_item :: PyListObject
-    r5 = load_mem r4 :: ptr*
-    set_mem r5, r1 :: builtins.object*
-    r6 = r5 + WORD_SIZE*1
-    set_mem r6, r2 :: builtins.object*
-    r7 = r5 + WORD_SIZE*2
-    set_mem r7, r3 :: builtins.object*
+    r4 = list_items r0
+    buf_init_item r4, 0, r1
+    buf_init_item r4, 1, r2
+    buf_init_item r4, 2, r3
     keep_alive r0
     tmp_list = r0
-    r8 = PySet_New(0)
-    r9 = 0
+    r5 = PySet_New(0)
+    r6 = 0
 L1:
-    r10 = get_element_ptr tmp_list ob_size :: PyVarObject
-    r11 = load_mem r10 :: native_int*
-    keep_alive tmp_list
-    r12 = r11 << 1
-    r13 = r9 < r12 :: signed
-    if r13 goto L2 else goto L4 :: bool
+    r7 = var_object_size tmp_list
+    r8 = r7 << 1
+    r9 = int_lt r6, r8
+    if r9 goto L2 else goto L4 :: bool
 L2:
-    r14 = CPyList_GetItemUnsafe(tmp_list, r9)
-    r15 = unbox(int, r14)
-    x = r15
-    r16 = f(x)
-    r17 = box(int, r16)
-    r18 = PySet_Add(r8, r17)
-    r19 = r18 >= 0 :: signed
+    r10 = list_get_item_unsafe tmp_list, r6
+    r11 = unbox(int, r10)
+    x = r11
+    r12 = f(x)
+    r13 = box(int, r12)
+    r14 = PySet_Add(r5, r13)
+    r15 = r14 >= 0 :: signed
 L3:
-    r20 = r9 + 2
-    r9 = r20
+    r16 = r6 + 2
+    r6 = r16
     goto L1
 L4:
-    a = r8
+    a = r5
     return 1
 def test2():
     r0, tmp_tuple :: tuple[int, int, int]
@@ -138,7 +135,7 @@ def test2():
     r2, r3, r4 :: object
     r5, x, r6 :: int
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9, r10 :: bit
     b :: set
 L0:
@@ -160,7 +157,7 @@ L2:
 L3:
     goto L1
 L4:
-    r10 = CPy_NoErrOccured()
+    r10 = CPy_NoErrOccurred()
 L5:
     b = r1
     return 1
@@ -179,7 +176,7 @@ def test3():
     r15 :: object
     r16, x, r17 :: int
     r18 :: object
-    r19 :: int32
+    r19 :: i32
     r20, r21, r22 :: bit
     c :: set
 L0:
@@ -214,7 +211,7 @@ L3:
     r21 = CPyDict_CheckSize(tmp_dict, r10)
     goto L1
 L4:
-    r22 = CPy_NoErrOccured()
+    r22 = CPy_NoErrOccurred()
 L5:
     c = r7
     return 1
@@ -225,7 +222,7 @@ def test4():
     r2 :: bit
     r3 :: int
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: short_int
     d :: set
@@ -234,7 +231,7 @@ L0:
     r1 = 2
     x = r1
 L1:
-    r2 = r1 < 12 :: signed
+    r2 = int_lt r1, 12
     if r2 goto L2 else goto L4 :: bool
 L2:
     r3 = f(x)
@@ -256,7 +253,7 @@ def test5():
     r2 :: bit
     r3 :: int
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: short_int
     e :: set
@@ -265,7 +262,7 @@ L0:
     r1 = 2
     x = r1
 L1:
-    r2 = r1 < 12 :: signed
+    r2 = int_lt r1, 12
     if r2 goto L2 else goto L4 :: bool
 L2:
     r3 = f(x)
@@ -312,38 +309,32 @@ L0:
 def test():
     r0 :: list
     r1, r2, r3, r4, r5 :: object
-    r6, r7, r8, r9, r10, r11 :: ptr
+    r6 :: ptr
     tmp_list :: list
-    r12 :: set
-    r13, r14 :: list
-    r15 :: short_int
-    r16 :: ptr
-    r17 :: native_int
-    r18 :: short_int
-    r19 :: bit
-    r20 :: object
-    r21, z :: int
-    r22 :: native_int
-    r23 :: bit
-    r24 :: native_int
-    r25, r26, r27 :: bit
-    r28 :: bool
-    r29 :: bit
-    r30 :: int
-    r31 :: object
-    r32 :: int32
-    r33 :: bit
-    r34 :: short_int
-    r35, r36, r37 :: object
-    r38, y, r39 :: int
-    r40 :: object
-    r41 :: int32
-    r42, r43 :: bit
-    r44, r45, r46 :: object
-    r47, x, r48 :: int
-    r49 :: object
-    r50 :: int32
-    r51, r52 :: bit
+    r7 :: set
+    r8, r9 :: list
+    r10 :: short_int
+    r11 :: native_int
+    r12 :: short_int
+    r13 :: bit
+    r14 :: object
+    r15, z :: int
+    r16 :: bit
+    r17 :: int
+    r18 :: object
+    r19 :: i32
+    r20 :: bit
+    r21 :: short_int
+    r22, r23, r24 :: object
+    r25, y, r26 :: int
+    r27 :: object
+    r28 :: i32
+    r29, r30 :: bit
+    r31, r32, r33 :: object
+    r34, x, r35 :: int
+    r36 :: object
+    r37 :: i32
+    r38, r39 :: bit
     a :: set
 L0:
     r0 = PyList_New(5)
@@ -352,96 +343,76 @@ L0:
     r3 = object 3
     r4 = object 4
     r5 = object 5
-    r6 = get_element_ptr r0 ob_item :: PyListObject
-    r7 = load_mem r6 :: ptr*
-    set_mem r7, r1 :: builtins.object*
-    r8 = r7 + WORD_SIZE*1
-    set_mem r8, r2 :: builtins.object*
-    r9 = r7 + WORD_SIZE*2
-    set_mem r9, r3 :: builtins.object*
-    r10 = r7 + WORD_SIZE*3
-    set_mem r10, r4 :: builtins.object*
-    r11 = r7 + WORD_SIZE*4
-    set_mem r11, r5 :: builtins.object*
+    r6 = list_items r0
+    buf_init_item r6, 0, r1
+    buf_init_item r6, 1, r2
+    buf_init_item r6, 2, r3
+    buf_init_item r6, 3, r4
+    buf_init_item r6, 4, r5
     keep_alive r0
     tmp_list = r0
-    r12 = PySet_New(0)
-    r13 = PyList_New(0)
-    r14 = PyList_New(0)
-    r15 = 0
+    r7 = PySet_New(0)
+    r8 = PyList_New(0)
+    r9 = PyList_New(0)
+    r10 = 0
 L1:
-    r16 = get_element_ptr tmp_list ob_size :: PyVarObject
-    r17 = load_mem r16 :: native_int*
-    keep_alive tmp_list
-    r18 = r17 << 1
-    r19 = r15 < r18 :: signed
-    if r19 goto L2 else goto L9 :: bool
+    r11 = var_object_size tmp_list
+    r12 = r11 << 1
+    r13 = int_lt r10, r12
+    if r13 goto L2 else goto L6 :: bool
 L2:
-    r20 = CPyList_GetItemUnsafe(tmp_list, r15)
-    r21 = unbox(int, r20)
-    z = r21
-    r22 = z & 1
-    r23 = r22 == 0
-    r24 = 8 & 1
-    r25 = r24 == 0
-    r26 = r23 & r25
-    if r26 goto L3 else goto L4 :: bool
+    r14 = list_get_item_unsafe tmp_list, r10
+    r15 = unbox(int, r14)
+    z = r15
+    r16 = int_lt z, 8
+    if r16 goto L4 else goto L3 :: bool
 L3:
-    r27 = z < 8 :: signed
-    r28 = r27
     goto L5
 L4:
-    r29 = CPyTagged_IsLt_(z, 8)
-    r28 = r29
+    r17 = f1(z)
+    r18 = box(int, r17)
+    r19 = PyList_Append(r9, r18)
+    r20 = r19 >= 0 :: signed
 L5:
-    if r28 goto L7 else goto L6 :: bool
+    r21 = r10 + 2
+    r10 = r21
+    goto L1
 L6:
-    goto L8
+    r22 = PyObject_GetIter(r9)
+    r23 = PyObject_GetIter(r22)
 L7:
-    r30 = f1(z)
-    r31 = box(int, r30)
-    r32 = PyList_Append(r14, r31)
-    r33 = r32 >= 0 :: signed
+    r24 = PyIter_Next(r23)
+    if is_error(r24) goto L10 else goto L8
 L8:
-    r34 = r15 + 2
-    r15 = r34
-    goto L1
+    r25 = unbox(int, r24)
+    y = r25
+    r26 = f2(y)
+    r27 = box(int, r26)
+    r28 = PyList_Append(r8, r27)
+    r29 = r28 >= 0 :: signed
 L9:
-    r35 = PyObject_GetIter(r14)
-    r36 = PyObject_GetIter(r35)
+    goto L7
 L10:
-    r37 = PyIter_Next(r36)
-    if is_error(r37) goto L13 else goto L11
+    r30 = CPy_NoErrOccurred()
 L11:
-    r38 = unbox(int, r37)
-    y = r38
-    r39 = f2(y)
-    r40 = box(int, r39)
-    r41 = PyList_Append(r13, r40)
-    r42 = r41 >= 0 :: signed
+    r31 = PyObject_GetIter(r8)
+    r32 = PyObject_GetIter(r31)
 L12:
-    goto L10
+    r33 = PyIter_Next(r32)
+    if is_error(r33) goto L15 else goto L13
 L13:
-    r43 = CPy_NoErrOccured()
+    r34 = unbox(int, r33)
+    x = r34
+    r35 = f3(x)
+    r36 = box(int, r35)
+    r37 = PySet_Add(r7, r36)
+    r38 = r37 >= 0 :: signed
 L14:
-    r44 = PyObject_GetIter(r13)
-    r45 = PyObject_GetIter(r44)
+    goto L12
 L15:
-    r46 = PyIter_Next(r45)
-    if is_error(r46) goto L18 else goto L16
+    r39 = CPy_NoErrOccurred()
 L16:
-    r47 = unbox(int, r46)
-    x = r47
-    r48 = f3(x)
-    r49 = box(int, r48)
-    r50 = PySet_Add(r12, r49)
-    r51 = r50 >= 0 :: signed
-L17:
-    goto L15
-L18:
-    r52 = CPy_NoErrOccured()
-L19:
-    a = r12
+    a = r7
     return 1
 
 [case testSetSize]
@@ -452,13 +423,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 +460,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 +482,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 +513,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 +533,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 +552,7 @@ def f() -> Set[int]:
 [out]
 def f():
     r0, x :: set
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     r0 = PySet_New(0)
@@ -612,7 +583,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 +598,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)
@@ -657,7 +628,7 @@ L0:
     return r0
 
 [case testOperatorInSetLiteral]
-from typing_extensions import Final
+from typing import Final
 
 CONST: Final = "daylily"
 non_const = 10
@@ -672,14 +643,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 +660,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 +678,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
+    r4 :: frozenset
     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,11 +712,11 @@ 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]
-from typing_extensions import Final
+from typing import Final
 
 CONST: Final = 10
 non_const = 20
@@ -781,7 +752,7 @@ L2:
 L3:
     goto L1
 L4:
-    r4 = CPy_NoErrOccured()
+    r4 = CPy_NoErrOccurred()
 L5:
     return 1
 def precomputed2():
@@ -799,7 +770,7 @@ L2:
 L3:
     goto L1
 L4:
-    r3 = CPy_NoErrOccured()
+    r3 = CPy_NoErrOccurred()
 L5:
     return 1
 def not_precomputed():
@@ -809,7 +780,7 @@ def not_precomputed():
     r3 :: int
     r4 :: set
     r5 :: object
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
     r8, r9 :: object
     r10, not_optimized :: int
@@ -833,6 +804,6 @@ L2:
 L3:
     goto L1
 L4:
-    r11 = CPy_NoErrOccured()
+    r11 = CPy_NoErrOccurred()
 L5:
     return 1
diff --git a/mypyc/test-data/irbuild-singledispatch.test b/mypyc/test-data/irbuild-singledispatch.test
index 4e18bbf50d4e..c95e832cc5df 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()
@@ -38,19 +38,23 @@ def f_obj.__call__(__mypyc_self__, arg):
     r8 :: str
     r9 :: object
     r10 :: dict
-    r11 :: object
-    r12 :: int32
-    r13 :: bit
-    r14 :: object
-    r15 :: ptr
+    r11 :: object[2]
+    r12 :: object_ptr
+    r13 :: object
+    r14 :: i32
+    r15 :: bit
     r16 :: object
-    r17 :: bit
-    r18 :: int
+    r17 :: ptr
+    r18 :: object
     r19 :: bit
     r20 :: int
-    r21 :: bool
-    r22 :: object
+    r21 :: bit
+    r22 :: int
     r23 :: bool
+    r24 :: object[1]
+    r25 :: object_ptr
+    r26 :: object
+    r27 :: bool
 L0:
     r0 = get_element_ptr arg ob_type :: PyObject
     r1 = load_mem r0 :: builtins.object*
@@ -68,31 +72,37 @@ L2:
     r8 = '_find_impl'
     r9 = CPyObject_GetAttr(r7, r8)
     r10 = __mypyc_self__.registry
-    r11 = PyObject_CallFunctionObjArgs(r9, r1, r10, 0)
-    r12 = CPyDict_SetItem(r2, r1, r11)
-    r13 = r12 >= 0 :: signed
-    r6 = r11
+    r11 = [r1, r10]
+    r12 = load_address r11
+    r13 = PyObject_Vectorcall(r9, r12, 2, 0)
+    keep_alive r1, r10
+    r14 = CPyDict_SetItem(r2, r1, r13)
+    r15 = r14 >= 0 :: signed
+    r6 = r13
 L3:
-    r14 = load_address PyLong_Type
-    r15 = get_element_ptr r6 ob_type :: PyObject
-    r16 = load_mem r15 :: builtins.object*
+    r16 = load_address PyLong_Type
+    r17 = get_element_ptr r6 ob_type :: PyObject
+    r18 = load_mem r17 :: builtins.object*
     keep_alive r6
-    r17 = r16 == r14
-    if r17 goto L4 else goto L7 :: bool
+    r19 = r18 == r16
+    if r19 goto L4 else goto L7 :: bool
 L4:
-    r18 = unbox(int, r6)
-    r19 = r18 == 0
-    if r19 goto L5 else goto L6 :: bool
+    r20 = unbox(int, r6)
+    r21 = int_eq r20, 0
+    if r21 goto L5 else goto L6 :: bool
 L5:
-    r20 = unbox(int, arg)
-    r21 = g(r20)
-    return r21
+    r22 = unbox(int, arg)
+    r23 = g(r22)
+    return r23
 L6:
     unreachable
 L7:
-    r22 = PyObject_CallFunctionObjArgs(r6, arg, 0)
-    r23 = unbox(bool, r22)
-    return r23
+    r24 = [arg]
+    r25 = load_address r24
+    r26 = PyObject_Vectorcall(r6, r25, 1, 0)
+    keep_alive arg
+    r27 = unbox(bool, r26)
+    return r27
 def f_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
@@ -129,7 +139,6 @@ def g(arg):
 L0:
     return 1
 
-
 [case testCallsToSingledispatchFunctionsAreNative]
 from functools import singledispatch
 
@@ -148,7 +157,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()
@@ -170,16 +179,20 @@ def f_obj.__call__(__mypyc_self__, x):
     r8 :: str
     r9 :: object
     r10 :: dict
-    r11 :: object
-    r12 :: int32
-    r13 :: bit
-    r14 :: object
-    r15 :: ptr
+    r11 :: object[2]
+    r12 :: object_ptr
+    r13 :: object
+    r14 :: i32
+    r15 :: bit
     r16 :: object
-    r17 :: bit
-    r18 :: int
-    r19 :: object
-    r20 :: None
+    r17 :: ptr
+    r18 :: object
+    r19 :: bit
+    r20 :: int
+    r21 :: object[1]
+    r22 :: object_ptr
+    r23 :: object
+    r24 :: None
 L0:
     r0 = get_element_ptr x ob_type :: PyObject
     r1 = load_mem r0 :: builtins.object*
@@ -197,24 +210,30 @@ L2:
     r8 = '_find_impl'
     r9 = CPyObject_GetAttr(r7, r8)
     r10 = __mypyc_self__.registry
-    r11 = PyObject_CallFunctionObjArgs(r9, r1, r10, 0)
-    r12 = CPyDict_SetItem(r2, r1, r11)
-    r13 = r12 >= 0 :: signed
-    r6 = r11
+    r11 = [r1, r10]
+    r12 = load_address r11
+    r13 = PyObject_Vectorcall(r9, r12, 2, 0)
+    keep_alive r1, r10
+    r14 = CPyDict_SetItem(r2, r1, r13)
+    r15 = r14 >= 0 :: signed
+    r6 = r13
 L3:
-    r14 = load_address PyLong_Type
-    r15 = get_element_ptr r6 ob_type :: PyObject
-    r16 = load_mem r15 :: builtins.object*
+    r16 = load_address PyLong_Type
+    r17 = get_element_ptr r6 ob_type :: PyObject
+    r18 = load_mem r17 :: builtins.object*
     keep_alive r6
-    r17 = r16 == r14
-    if r17 goto L4 else goto L5 :: bool
+    r19 = r18 == r16
+    if r19 goto L4 else goto L5 :: bool
 L4:
-    r18 = unbox(int, r6)
+    r20 = unbox(int, r6)
     unreachable
 L5:
-    r19 = PyObject_CallFunctionObjArgs(r6, x, 0)
-    r20 = unbox(None, r19)
-    return r20
+    r21 = [x]
+    r22 = load_address r21
+    r23 = PyObject_Vectorcall(r6, r22, 1, 0)
+    keep_alive x
+    r24 = unbox(None, r23)
+    return r24
 def f_obj.__get__(__mypyc_self__, instance, owner):
     __mypyc_self__, instance, owner, r0 :: object
     r1 :: bit
diff --git a/mypyc/test-data/irbuild-statements.test b/mypyc/test-data/irbuild-statements.test
index 090c7ed9f3df..1f9336d32140 100644
--- a/mypyc/test-data/irbuild-statements.test
+++ b/mypyc/test-data/irbuild-statements.test
@@ -16,7 +16,7 @@ L0:
     r0 = 0
     i = r0
 L1:
-    r1 = r0 < 10 :: signed
+    r1 = int_lt r0, 10
     if r1 goto L2 else goto L4 :: bool
 L2:
     r2 = CPyTagged_Add(x, i)
@@ -36,39 +36,21 @@ def f(a: int) -> None:
 [out]
 def f(a):
     a, r0, i :: int
-    r1 :: native_int
-    r2 :: bit
-    r3 :: native_int
-    r4, r5, r6 :: bit
-    r7 :: bool
-    r8 :: bit
-    r9 :: int
+    r1 :: bit
+    r2 :: int
 L0:
     r0 = 0
     i = r0
 L1:
-    r1 = r0 & 1
-    r2 = r1 == 0
-    r3 = a & 1
-    r4 = r3 == 0
-    r5 = r2 & r4
-    if r5 goto L2 else goto L3 :: bool
+    r1 = int_lt r0, a
+    if r1 goto L2 else goto L4 :: bool
 L2:
-    r6 = r0 < a :: signed
-    r7 = r6
-    goto L4
 L3:
-    r8 = CPyTagged_IsLt_(r0, a)
-    r7 = r8
-L4:
-    if r7 goto L5 else goto L7 :: bool
-L5:
-L6:
-    r9 = CPyTagged_Add(r0, 2)
-    r0 = r9
-    i = r9
+    r2 = CPyTagged_Add(r0, 2)
+    r0 = r2
+    i = r2
     goto L1
-L7:
+L4:
     return 1
 
 [case testForInNegativeRange]
@@ -85,7 +67,7 @@ L0:
     r0 = 20
     i = r0
 L1:
-    r1 = r0 > 0 :: signed
+    r1 = int_gt r0, 0
     if r1 goto L2 else goto L4 :: bool
 L2:
 L3:
@@ -104,22 +86,14 @@ def f() -> None:
 [out]
 def f():
     n :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
+    r0 :: bit
 L0:
     n = 0
 L1:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L3 :: bool
+    r0 = int_lt n, 10
+    if r0 goto L2 else goto L3 :: bool
 L2:
-    r2 = CPyTagged_IsLt_(n, 10)
-    if r2 goto L4 else goto L5 :: bool
 L3:
-    r3 = n < 10 :: signed
-    if r3 goto L4 else goto L5 :: bool
-L4:
-L5:
     return 1
 
 [case testBreakFor]
@@ -136,7 +110,7 @@ L0:
     r0 = 0
     n = r0
 L1:
-    r1 = r0 < 10 :: signed
+    r1 = int_lt r0, 10
     if r1 goto L2 else goto L4 :: bool
 L2:
     goto L4
@@ -158,36 +132,19 @@ def f() -> None:
 [out]
 def f():
     n :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
+    r0, r1 :: bit
 L0:
     n = 0
 L1:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L3 :: bool
+    r0 = int_lt n, 10
+    if r0 goto L2 else goto L6 :: bool
 L2:
-    r2 = CPyTagged_IsLt_(n, 10)
-    if r2 goto L4 else goto L10 :: bool
 L3:
-    r3 = n < 10 :: signed
-    if r3 goto L4 else goto L10 :: bool
+    r1 = int_lt n, 8
+    if r1 goto L4 else goto L5 :: bool
 L4:
 L5:
-    r4 = n & 1
-    r5 = r4 != 0
-    if r5 goto L6 else goto L7 :: bool
 L6:
-    r6 = CPyTagged_IsLt_(n, 8)
-    if r6 goto L8 else goto L9 :: bool
-L7:
-    r7 = n < 8 :: signed
-    if r7 goto L8 else goto L9 :: bool
-L8:
-L9:
-L10:
     return 1
 
 [case testContinue]
@@ -198,23 +155,15 @@ def f() -> None:
 [out]
 def f():
     n :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
+    r0 :: bit
 L0:
     n = 0
 L1:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L3 :: bool
+    r0 = int_lt n, 10
+    if r0 goto L2 else goto L3 :: bool
 L2:
-    r2 = CPyTagged_IsLt_(n, 10)
-    if r2 goto L4 else goto L5 :: bool
-L3:
-    r3 = n < 10 :: signed
-    if r3 goto L4 else goto L5 :: bool
-L4:
     goto L1
-L5:
+L3:
     return 1
 
 [case testContinueFor]
@@ -231,7 +180,7 @@ L0:
     r0 = 0
     n = r0
 L1:
-    r1 = r0 < 10 :: signed
+    r1 = int_lt r0, 10
     if r1 goto L2 else goto L4 :: bool
 L2:
 L3:
@@ -252,38 +201,21 @@ def f() -> None:
 [out]
 def f():
     n :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
+    r0, r1 :: bit
 L0:
     n = 0
 L1:
-    r0 = n & 1
-    r1 = r0 != 0
-    if r1 goto L2 else goto L3 :: bool
+    r0 = int_lt n, 10
+    if r0 goto L2 else goto L6 :: bool
 L2:
-    r2 = CPyTagged_IsLt_(n, 10)
-    if r2 goto L4 else goto L10 :: bool
 L3:
-    r3 = n < 10 :: signed
-    if r3 goto L4 else goto L10 :: bool
+    r1 = int_lt n, 8
+    if r1 goto L4 else goto L5 :: bool
 L4:
+    goto L3
 L5:
-    r4 = n & 1
-    r5 = r4 != 0
-    if r5 goto L6 else goto L7 :: bool
-L6:
-    r6 = CPyTagged_IsLt_(n, 8)
-    if r6 goto L8 else goto L9 :: bool
-L7:
-    r7 = n < 8 :: signed
-    if r7 goto L8 else goto L9 :: bool
-L8:
-    goto L5
-L9:
     goto L1
-L10:
+L6:
     return 1
 
 [case testForList]
@@ -299,32 +231,29 @@ def f(ls):
     ls :: list
     y :: int
     r0 :: short_int
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
-    r4 :: bit
-    r5 :: object
-    r6, x, r7 :: int
-    r8 :: short_int
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: bit
+    r4 :: object
+    r5, x, r6 :: int
+    r7 :: short_int
 L0:
     y = 0
     r0 = 0
 L1:
-    r1 = get_element_ptr ls ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
-    keep_alive ls
-    r3 = r2 << 1
-    r4 = r0 < r3 :: signed
-    if r4 goto L2 else goto L4 :: bool
+    r1 = var_object_size ls
+    r2 = r1 << 1
+    r3 = int_lt r0, r2
+    if r3 goto L2 else goto L4 :: bool
 L2:
-    r5 = CPyList_GetItemUnsafe(ls, r0)
-    r6 = unbox(int, r5)
-    x = r6
-    r7 = CPyTagged_Add(y, x)
-    y = r7
+    r4 = list_get_item_unsafe ls, r0
+    r5 = unbox(int, r4)
+    x = r5
+    r6 = CPyTagged_Add(y, x)
+    y = r6
 L3:
-    r8 = r0 + 2
-    r0 = r8
+    r7 = r0 + 2
+    r0 = r7
     goto L1
 L4:
     return y
@@ -372,7 +301,7 @@ L3:
     r12 = CPyDict_CheckSize(d, r2)
     goto L1
 L4:
-    r13 = CPy_NoErrOccured()
+    r13 = CPy_NoErrOccurred()
 L5:
     return 1
 
@@ -439,7 +368,7 @@ L5:
     r18 = CPyDict_CheckSize(d, r2)
     goto L1
 L6:
-    r19 = CPy_NoErrOccured()
+    r19 = CPy_NoErrOccurred()
 L7:
     return s
 
@@ -502,16 +431,16 @@ L0:
 [case testMultipleAssignmentBasicUnpacking]
 from typing import Tuple, Any
 
-def from_tuple(t: Tuple[int, str]) -> None:
+def from_tuple(t: Tuple[bool, None]) -> None:
     x, y = t
 
 def from_any(a: Any) -> None:
     x, y = a
 [out]
 def from_tuple(t):
-    t :: tuple[int, str]
-    r0, x :: int
-    r1, y :: str
+    t :: tuple[bool, None]
+    r0, x :: bool
+    r1, y :: None
 L0:
     r0 = t[0]
     x = r0
@@ -564,15 +493,20 @@ def from_any(a: Any) -> None:
 def from_tuple(t):
     t :: tuple[int, object]
     r0 :: int
-    r1, x, r2 :: object
-    r3, y :: int
+    r1 :: object
+    r2 :: int
+    r3, x, r4 :: object
+    r5, y :: int
 L0:
-    r0 = t[0]
-    r1 = box(int, r0)
-    x = r1
-    r2 = t[1]
-    r3 = unbox(int, r2)
-    y = r3
+    r0 = borrow t[0]
+    r1 = borrow t[1]
+    keep_alive steal t
+    r2 = unborrow r0
+    r3 = box(int, r2)
+    x = r3
+    r4 = unborrow r1
+    r5 = unbox(int, r4)
+    y = r5
     return 1
 def from_any(a):
     a, r0, r1 :: object
@@ -651,19 +585,19 @@ 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
 L0:
     r0 = CPySequence_CheckUnpackCount(l, 2)
     r1 = r0 >= 0 :: signed
-    r2 = CPyList_GetItemUnsafe(l, 0)
-    r3 = CPyList_GetItemUnsafe(l, 2)
+    r2 = list_get_item_unsafe l, 0
+    r3 = list_get_item_unsafe l, 2
     x = r2
     r4 = unbox(int, r3)
     y = r4
@@ -701,13 +635,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')
@@ -723,7 +657,10 @@ def complex_msg(x, s):
     r3 :: bit
     r4 :: object
     r5 :: str
-    r6, r7 :: object
+    r6 :: object
+    r7 :: object[1]
+    r8 :: object_ptr
+    r9 :: object
 L0:
     r0 = load_address _Py_NoneStruct
     r1 = x != r0
@@ -736,8 +673,11 @@ L2:
     r4 = builtins :: module
     r5 = 'AssertionError'
     r6 = CPyObject_GetAttr(r4, r5)
-    r7 = PyObject_CallFunctionObjArgs(r6, s, 0)
-    CPy_Raise(r7)
+    r7 = [s]
+    r8 = load_address r7
+    r9 = PyObject_Vectorcall(r6, r8, 1, 0)
+    keep_alive s
+    CPy_Raise(r9)
     unreachable
 L3:
     return 1
@@ -753,40 +693,38 @@ def delListMultiple() -> None:
 def delList():
     r0 :: list
     r1, r2 :: object
-    r3, r4, r5 :: ptr
+    r3 :: ptr
     l :: list
-    r6 :: object
-    r7 :: int32
-    r8 :: bit
+    r4 :: object
+    r5 :: i32
+    r6 :: bit
 L0:
     r0 = PyList_New(2)
     r1 = object 1
     r2 = object 2
-    r3 = get_element_ptr r0 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, r1 :: builtins.object*
-    r5 = r4 + WORD_SIZE*1
-    set_mem r5, r2 :: builtins.object*
+    r3 = list_items r0
+    buf_init_item r3, 0, r1
+    buf_init_item r3, 1, r2
     keep_alive r0
     l = r0
-    r6 = object 1
-    r7 = PyObject_DelItem(l, r6)
-    r8 = r7 >= 0 :: signed
+    r4 = object 1
+    r5 = PyObject_DelItem(l, r4)
+    r6 = r5 >= 0 :: signed
     return 1
 def delListMultiple():
     r0 :: list
     r1, r2, r3, r4, r5, r6, r7 :: object
-    r8, r9, r10, r11, r12, r13, r14, r15 :: ptr
+    r8 :: ptr
     l :: list
-    r16 :: object
-    r17 :: int32
-    r18 :: bit
-    r19 :: object
-    r20 :: int32
-    r21 :: bit
-    r22 :: object
-    r23 :: int32
-    r24 :: bit
+    r9 :: object
+    r10 :: i32
+    r11 :: bit
+    r12 :: object
+    r13 :: i32
+    r14 :: bit
+    r15 :: object
+    r16 :: i32
+    r17 :: bit
 L0:
     r0 = PyList_New(7)
     r1 = object 1
@@ -796,32 +734,25 @@ L0:
     r5 = object 5
     r6 = object 6
     r7 = object 7
-    r8 = get_element_ptr r0 ob_item :: PyListObject
-    r9 = load_mem r8 :: ptr*
-    set_mem r9, r1 :: builtins.object*
-    r10 = r9 + WORD_SIZE*1
-    set_mem r10, r2 :: builtins.object*
-    r11 = r9 + WORD_SIZE*2
-    set_mem r11, r3 :: builtins.object*
-    r12 = r9 + WORD_SIZE*3
-    set_mem r12, r4 :: builtins.object*
-    r13 = r9 + WORD_SIZE*4
-    set_mem r13, r5 :: builtins.object*
-    r14 = r9 + WORD_SIZE*5
-    set_mem r14, r6 :: builtins.object*
-    r15 = r9 + WORD_SIZE*6
-    set_mem r15, r7 :: builtins.object*
+    r8 = list_items r0
+    buf_init_item r8, 0, r1
+    buf_init_item r8, 1, r2
+    buf_init_item r8, 2, r3
+    buf_init_item r8, 3, r4
+    buf_init_item r8, 4, r5
+    buf_init_item r8, 5, r6
+    buf_init_item r8, 6, r7
     keep_alive r0
     l = r0
-    r16 = object 1
-    r17 = PyObject_DelItem(l, r16)
-    r18 = r17 >= 0 :: signed
-    r19 = object 2
-    r20 = PyObject_DelItem(l, r19)
-    r21 = r20 >= 0 :: signed
-    r22 = object 3
-    r23 = PyObject_DelItem(l, r22)
-    r24 = r23 >= 0 :: signed
+    r9 = object 1
+    r10 = PyObject_DelItem(l, r9)
+    r11 = r10 >= 0 :: signed
+    r12 = object 2
+    r13 = PyObject_DelItem(l, r12)
+    r14 = r13 >= 0 :: signed
+    r15 = object 3
+    r16 = PyObject_DelItem(l, r15)
+    r17 = r16 >= 0 :: signed
     return 1
 
 [case testDelDict]
@@ -837,7 +768,7 @@ def delDict():
     r2, r3 :: object
     r4, d :: dict
     r5 :: str
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
 L0:
     r0 = 'one'
@@ -855,9 +786,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 +832,7 @@ L0:
 def delAttribute():
     r0, dummy :: __main__.Dummy
     r1 :: str
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
 L0:
     r0 = Dummy(2, 4)
@@ -913,10 +844,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)
@@ -941,38 +872,33 @@ def g(x: Iterable[int]) -> None:
 [out]
 def f(a):
     a :: list
-    r0 :: short_int
+    r0, r1 :: short_int
+    r2 :: native_int
+    r3 :: short_int
+    r4 :: bit
     i :: int
-    r1 :: short_int
-    r2 :: ptr
-    r3 :: native_int
-    r4 :: short_int
-    r5 :: bit
-    r6 :: object
-    r7, x, r8 :: int
-    r9, r10 :: short_int
+    r5 :: object
+    r6, x, r7 :: int
+    r8, r9 :: short_int
 L0:
     r0 = 0
-    i = 0
     r1 = 0
 L1:
-    r2 = get_element_ptr a ob_size :: PyVarObject
-    r3 = load_mem r2 :: native_int*
-    keep_alive a
-    r4 = r3 << 1
-    r5 = r1 < r4 :: signed
-    if r5 goto L2 else goto L4 :: bool
+    r2 = var_object_size a
+    r3 = r2 << 1
+    r4 = int_lt r1, r3
+    if r4 goto L2 else goto L4 :: bool
 L2:
-    r6 = CPyList_GetItemUnsafe(a, r1)
-    r7 = unbox(int, r6)
-    x = r7
-    r8 = CPyTagged_Add(i, x)
+    i = r0
+    r5 = list_get_item_unsafe a, r1
+    r6 = unbox(int, r5)
+    x = r6
+    r7 = CPyTagged_Add(i, x)
 L3:
-    r9 = r0 + 2
-    r0 = r9
-    i = r9
-    r10 = r1 + 2
-    r1 = r10
+    r8 = r0 + 2
+    r0 = r8
+    r9 = r1 + 2
+    r1 = r9
     goto L1
 L4:
 L5:
@@ -980,28 +906,26 @@ L5:
 def g(x):
     x :: object
     r0 :: short_int
-    i :: int
     r1, r2 :: object
-    r3, n :: int
+    i, r3, n :: int
     r4 :: short_int
     r5 :: bit
 L0:
     r0 = 0
-    i = 0
     r1 = PyObject_GetIter(x)
 L1:
     r2 = PyIter_Next(r1)
     if is_error(r2) goto L4 else goto L2
 L2:
+    i = r0
     r3 = unbox(int, r2)
     n = r3
 L3:
     r4 = r0 + 2
     r0 = r4
-    i = r4
     goto L1
 L4:
-    r5 = CPy_NoErrOccured()
+    r5 = CPy_NoErrOccurred()
 L5:
     return 1
 
@@ -1022,50 +946,47 @@ def f(a, b):
     b :: object
     r0 :: short_int
     r1 :: object
-    r2 :: ptr
-    r3 :: native_int
-    r4 :: short_int
-    r5 :: bit
-    r6, r7 :: object
-    r8, x :: int
-    r9, y :: bool
-    r10 :: int32
-    r11 :: bit
-    r12 :: bool
-    r13 :: short_int
-    r14 :: bit
+    r2 :: native_int
+    r3 :: short_int
+    r4 :: bit
+    r5, r6 :: object
+    r7, x :: int
+    r8, y :: bool
+    r9 :: i32
+    r10 :: bit
+    r11 :: bool
+    r12 :: short_int
+    r13 :: bit
 L0:
     r0 = 0
     r1 = PyObject_GetIter(b)
 L1:
-    r2 = get_element_ptr a ob_size :: PyVarObject
-    r3 = load_mem r2 :: native_int*
-    keep_alive a
-    r4 = r3 << 1
-    r5 = r0 < r4 :: signed
-    if r5 goto L2 else goto L7 :: bool
+    r2 = var_object_size a
+    r3 = r2 << 1
+    r4 = int_lt r0, r3
+    if r4 goto L2 else goto L7 :: bool
 L2:
-    r6 = PyIter_Next(r1)
-    if is_error(r6) goto L7 else goto L3
+    r5 = PyIter_Next(r1)
+    if is_error(r5) goto L7 else goto L3
 L3:
-    r7 = CPyList_GetItemUnsafe(a, r0)
-    r8 = unbox(int, r7)
-    x = r8
-    r9 = unbox(bool, r6)
-    y = r9
-    r10 = PyObject_IsTrue(b)
-    r11 = r10 >= 0 :: signed
-    r12 = truncate r10: int32 to builtins.bool
-    if r12 goto L4 else goto L5 :: bool
+    r6 = list_get_item_unsafe a, r0
+    r7 = unbox(int, r6)
+    x = r7
+    r8 = unbox(bool, r5)
+    y = r8
+    r9 = PyObject_IsTrue(b)
+    r10 = r9 >= 0 :: signed
+    r11 = truncate r9: i32 to builtins.bool
+    if r11 goto L4 else goto L5 :: bool
 L4:
     x = 2
 L5:
 L6:
-    r13 = r0 + 2
-    r0 = r13
+    r12 = r0 + 2
+    r0 = r12
     goto L1
 L7:
-    r14 = CPy_NoErrOccured()
+    r13 = CPy_NoErrOccurred()
 L8:
     return 1
 def g(a, b):
@@ -1075,15 +996,14 @@ def g(a, b):
     r1, r2 :: short_int
     z :: int
     r3 :: object
-    r4 :: ptr
-    r5 :: native_int
-    r6 :: short_int
-    r7, r8 :: bit
-    r9, x :: bool
-    r10 :: object
-    r11, y :: int
-    r12, r13 :: short_int
-    r14 :: bit
+    r4 :: native_int
+    r5 :: short_int
+    r6, r7 :: bit
+    r8, x :: bool
+    r9 :: object
+    r10, y :: int
+    r11, r12 :: short_int
+    r13 :: bit
 L0:
     r0 = PyObject_GetIter(a)
     r1 = 0
@@ -1093,30 +1013,52 @@ L1:
     r3 = PyIter_Next(r0)
     if is_error(r3) goto L6 else goto L2
 L2:
-    r4 = get_element_ptr b ob_size :: PyVarObject
-    r5 = load_mem r4 :: native_int*
-    keep_alive b
-    r6 = r5 << 1
-    r7 = r1 < r6 :: signed
-    if r7 goto L3 else goto L6 :: bool
+    r4 = var_object_size b
+    r5 = r4 << 1
+    r6 = int_lt r1, r5
+    if r6 goto L3 else goto L6 :: bool
 L3:
-    r8 = r2 < 10 :: signed
-    if r8 goto L4 else goto L6 :: bool
+    r7 = int_lt r2, 10
+    if r7 goto L4 else goto L6 :: bool
 L4:
-    r9 = unbox(bool, r3)
-    x = r9
-    r10 = CPyList_GetItemUnsafe(b, r1)
-    r11 = unbox(int, r10)
-    y = r11
+    r8 = unbox(bool, r3)
+    x = r8
+    r9 = list_get_item_unsafe b, r1
+    r10 = unbox(int, r9)
+    y = r10
     x = 0
 L5:
-    r12 = r1 + 2
-    r1 = r12
-    r13 = r2 + 2
-    r2 = r13
-    z = r13
+    r11 = r1 + 2
+    r1 = r11
+    r12 = r2 + 2
+    r2 = r12
+    z = r12
     goto L1
 L6:
-    r14 = CPy_NoErrOccured()
+    r13 = CPy_NoErrOccurred()
 L7:
     return 1
+
+[case testConditionalFunctionDefinition]
+if int():
+    def foo() -> int:
+        return 0
+else:
+    def foo() -> int:  # E
+        return 1
+
+def bar() -> int:
+    return 0
+
+if int():
+    def bar() -> int:  # E
+        return 1
+[out]
+main:5: error: Duplicate definition of "foo" not supported by mypyc
+main:12: error: Duplicate definition of "bar" not supported by mypyc
+
+[case testRepeatedUnderscoreFunctions]
+def _(arg): pass
+def _(arg): pass
+[out]
+main:2: error: Duplicate definition of "_" not supported by mypyc
diff --git a/mypyc/test-data/irbuild-str.test b/mypyc/test-data/irbuild-str.test
index 63be7250ebd1..ad495dddcb15 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
@@ -137,6 +137,57 @@ L4:
 L5:
     unreachable
 
+[case testStrStartswithEndswithTuple]
+from typing import Tuple
+
+def do_startswith(s1: str, s2: Tuple[str, ...]) -> bool:
+    return s1.startswith(s2)
+
+def do_endswith(s1: str, s2: Tuple[str, ...]) -> bool:
+    return s1.endswith(s2)
+
+def do_tuple_literal_args(s1: str) -> None:
+    x = s1.startswith(("a", "b"))
+    y = s1.endswith(("a", "b"))
+[out]
+def do_startswith(s1, s2):
+    s1 :: str
+    s2 :: tuple
+    r0 :: bool
+L0:
+    r0 = CPyStr_Startswith(s1, s2)
+    return r0
+def do_endswith(s1, s2):
+    s1 :: str
+    s2 :: tuple
+    r0 :: bool
+L0:
+    r0 = CPyStr_Endswith(s1, s2)
+    return r0
+def do_tuple_literal_args(s1):
+    s1, r0, r1 :: str
+    r2 :: tuple[str, str]
+    r3 :: object
+    r4, x :: bool
+    r5, r6 :: str
+    r7 :: tuple[str, str]
+    r8 :: object
+    r9, y :: bool
+L0:
+    r0 = 'a'
+    r1 = 'b'
+    r2 = (r0, r1)
+    r3 = box(tuple[str, str], r2)
+    r4 = CPyStr_Startswith(s1, r3)
+    x = r4
+    r5 = 'a'
+    r6 = 'b'
+    r7 = (r5, r6)
+    r8 = box(tuple[str, str], r7)
+    r9 = CPyStr_Endswith(s1, r8)
+    y = r9
+    return 1
+
 [case testStrToBool]
 def is_true(x: str) -> bool:
     if x:
@@ -189,7 +240,7 @@ L0:
     s4 = r13
     return 1
 
-[case testFStrings]
+[case testFStrings_64bit]
 def f(var: str, num: int) -> None:
     s1 = f"Hi! I'm {var}. I am {num} years old."
     s2 = f'Hello {var:>{num}}'
@@ -200,10 +251,12 @@ def f(var, num):
     var :: str
     num :: int
     r0, r1, r2, r3, r4, s1, r5, r6, r7, r8, r9, r10, r11 :: str
-    r12 :: object
-    r13 :: str
-    r14 :: list
-    r15, r16, r17 :: ptr
+    r12 :: object[3]
+    r13 :: object_ptr
+    r14 :: object
+    r15 :: str
+    r16 :: list
+    r17 :: ptr
     r18, s2, r19, s3, r20, s4 :: str
 L0:
     r0 = "Hi! I'm "
@@ -219,16 +272,17 @@ L0:
     r9 = CPyTagged_Str(num)
     r10 = CPyStr_Build(2, r8, r9)
     r11 = 'format'
-    r12 = CPyObject_CallMethodObjArgs(r7, r11, var, r10, 0)
-    r13 = cast(str, r12)
-    r14 = PyList_New(2)
-    r15 = get_element_ptr r14 ob_item :: PyListObject
-    r16 = load_mem r15 :: ptr*
-    set_mem r16, r6 :: builtins.object*
-    r17 = r16 + WORD_SIZE*1
-    set_mem r17, r13 :: builtins.object*
-    keep_alive r14
-    r18 = PyUnicode_Join(r5, r14)
+    r12 = [r7, var, r10]
+    r13 = load_address r12
+    r14 = PyObject_VectorcallMethod(r11, r13, 9223372036854775811, 0)
+    keep_alive r7, var, r10
+    r15 = cast(str, r14)
+    r16 = PyList_New(2)
+    r17 = list_items r16
+    buf_init_item r17, 0, r6
+    buf_init_item r17, 1, r15
+    keep_alive r16
+    r18 = PyUnicode_Join(r5, r16)
     s2 = r18
     r19 = ''
     s3 = r19
@@ -291,24 +345,162 @@ L0:
     r5 = CPy_Decode(b, r3, r4)
     return 1
 
-[case testEncode]
+[case testEncode_64bit]
 def f(s: str) -> None:
     s.encode()
     s.encode('utf-8')
+    s.encode('utf8', 'strict')
+    s.encode('latin1', errors='strict')
+    s.encode(encoding='ascii')
+    s.encode(errors='strict', encoding='latin-1')
+    s.encode('utf-8', 'backslashreplace')
     s.encode('ascii', 'backslashreplace')
+    encoding = 'utf8'
+    s.encode(encoding)
+    errors = 'strict'
+    s.encode('utf8', errors)
+    s.encode('utf8', errors=errors)
+    s.encode(errors=errors)
+    s.encode(encoding=encoding, errors=errors)
+    s.encode('latin2')
+
 [out]
 def f(s):
     s :: str
-    r0 :: bytes
+    r0, r1, r2, r3, r4, r5 :: bytes
+    r6, r7 :: str
+    r8 :: bytes
+    r9, r10 :: str
+    r11 :: bytes
+    r12, encoding :: str
+    r13 :: bytes
+    r14, errors, r15 :: str
+    r16 :: bytes
+    r17, r18 :: str
+    r19 :: object[3]
+    r20 :: object_ptr
+    r21, r22 :: object
+    r23 :: str
+    r24 :: object[2]
+    r25 :: object_ptr
+    r26, r27 :: object
+    r28 :: str
+    r29 :: object[3]
+    r30 :: object_ptr
+    r31, r32 :: object
+    r33 :: str
+    r34 :: bytes
+L0:
+    r0 = PyUnicode_AsUTF8String(s)
+    r1 = PyUnicode_AsUTF8String(s)
+    r2 = PyUnicode_AsUTF8String(s)
+    r3 = PyUnicode_AsLatin1String(s)
+    r4 = PyUnicode_AsASCIIString(s)
+    r5 = PyUnicode_AsLatin1String(s)
+    r6 = 'utf-8'
+    r7 = 'backslashreplace'
+    r8 = CPy_Encode(s, r6, r7)
+    r9 = 'ascii'
+    r10 = 'backslashreplace'
+    r11 = CPy_Encode(s, r9, r10)
+    r12 = 'utf8'
+    encoding = r12
+    r13 = CPy_Encode(s, encoding, 0)
+    r14 = 'strict'
+    errors = r14
+    r15 = 'utf8'
+    r16 = CPy_Encode(s, r15, errors)
+    r17 = 'utf8'
+    r18 = 'encode'
+    r19 = [s, r17, errors]
+    r20 = load_address r19
+    r21 = ('errors',)
+    r22 = PyObject_VectorcallMethod(r18, r20, 9223372036854775810, r21)
+    keep_alive s, r17, errors
+    r23 = 'encode'
+    r24 = [s, errors]
+    r25 = load_address r24
+    r26 = ('errors',)
+    r27 = PyObject_VectorcallMethod(r23, r25, 9223372036854775809, r26)
+    keep_alive s, errors
+    r28 = 'encode'
+    r29 = [s, encoding, errors]
+    r30 = load_address r29
+    r31 = ('encoding', 'errors')
+    r32 = PyObject_VectorcallMethod(r28, r30, 9223372036854775809, r31)
+    keep_alive s, encoding, errors
+    r33 = 'latin2'
+    r34 = CPy_Encode(s, r33, 0)
+    return 1
+
+[case testOrd]
+def str_ord(x: str) -> int:
+    return ord(x)
+def str_ord_literal() -> int:
+    return ord("a")
+def bytes_ord(x: bytes) -> int:
+    return ord(x)
+def bytes_ord_literal() -> int:
+    return ord(b"a")
+def any_ord(x) -> int:
+    return ord(x)
+[out]
+def str_ord(x):
+    x :: str
+    r0 :: int
+L0:
+    r0 = CPyStr_Ord(x)
+    return r0
+def str_ord_literal():
+L0:
+    return 194
+def bytes_ord(x):
+    x :: bytes
+    r0 :: int
+L0:
+    r0 = CPyBytes_Ord(x)
+    return r0
+def bytes_ord_literal():
+L0:
+    return 194
+def any_ord(x):
+    x, r0 :: object
     r1 :: str
-    r2 :: bytes
-    r3, r4 :: str
-    r5 :: bytes
+    r2 :: object
+    r3 :: object[1]
+    r4 :: object_ptr
+    r5 :: object
+    r6 :: int
 L0:
-    r0 = CPy_Encode(s, 0, 0)
-    r1 = 'utf-8'
-    r2 = CPy_Encode(s, r1, 0)
-    r3 = 'ascii'
-    r4 = 'backslashreplace'
-    r5 = CPy_Encode(s, r3, r4)
+    r0 = builtins :: module
+    r1 = 'ord'
+    r2 = CPyObject_GetAttr(r0, r1)
+    r3 = [x]
+    r4 = load_address r3
+    r5 = PyObject_Vectorcall(r2, r4, 1, 0)
+    keep_alive x
+    r6 = unbox(int, r5)
+    return r6
+
+[case testStrip]
+def do_strip(s: str) -> None:
+    s.lstrip("x")
+    s.strip("y")
+    s.rstrip("z")
+    s.lstrip()
+    s.strip()
+    s.rstrip()
+[out]
+def do_strip(s):
+    s, r0, r1, r2, r3, r4, r5, r6, r7, r8 :: str
+L0:
+    r0 = 'x'
+    r1 = CPyStr_LStrip(s, r0)
+    r2 = 'y'
+    r3 = CPyStr_Strip(s, r2)
+    r4 = 'z'
+    r5 = CPyStr_RStrip(s, r4)
+    r6 = CPyStr_LStrip(s, 0)
+    r7 = CPyStr_Strip(s, 0)
+    r8 = CPyStr_RStrip(s, 0)
     return 1
diff --git a/mypyc/test-data/irbuild-try.test b/mypyc/test-data/irbuild-try.test
index faf3fa1dbd2f..ad1aa78c0554 100644
--- a/mypyc/test-data/irbuild-try.test
+++ b/mypyc/test-data/irbuild-try.test
@@ -13,14 +13,17 @@ def g():
     r5 :: str
     r6 :: object
     r7 :: str
-    r8, r9 :: object
-    r10 :: bit
+    r8 :: object
+    r9 :: object[1]
+    r10 :: object_ptr
+    r11 :: object
+    r12 :: bit
 L0:
 L1:
     r0 = builtins :: module
     r1 = 'object'
     r2 = CPyObject_GetAttr(r0, r1)
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
     goto L5
 L2: (handler for L1)
     r4 = CPy_CatchError()
@@ -28,13 +31,16 @@ L2: (handler for L1)
     r6 = builtins :: module
     r7 = 'print'
     r8 = CPyObject_GetAttr(r6, r7)
-    r9 = PyObject_CallFunctionObjArgs(r8, r5, 0)
+    r9 = [r5]
+    r10 = load_address r9
+    r11 = PyObject_Vectorcall(r8, r10, 1, 0)
+    keep_alive r5
 L3:
     CPy_RestoreExcInfo(r4)
     goto L5
 L4: (handler for L2)
     CPy_RestoreExcInfo(r4)
-    r10 = CPy_KeepPropagating()
+    r12 = CPy_KeepPropagating()
     unreachable
 L5:
     return 1
@@ -59,8 +65,11 @@ def g(b):
     r7 :: str
     r8 :: object
     r9 :: str
-    r10, r11 :: object
-    r12 :: bit
+    r10 :: object
+    r11 :: object[1]
+    r12 :: object_ptr
+    r13 :: object
+    r14 :: bit
 L0:
 L1:
     if b goto L2 else goto L3 :: bool
@@ -68,7 +77,7 @@ L2:
     r0 = builtins :: module
     r1 = 'object'
     r2 = CPyObject_GetAttr(r0, r1)
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
     goto L4
 L3:
     r4 = 'hi'
@@ -81,13 +90,16 @@ L5: (handler for L1, L2, L3, L4)
     r8 = builtins :: module
     r9 = 'print'
     r10 = CPyObject_GetAttr(r8, r9)
-    r11 = PyObject_CallFunctionObjArgs(r10, r7, 0)
+    r11 = [r7]
+    r12 = load_address r11
+    r13 = PyObject_Vectorcall(r10, r12, 1, 0)
+    keep_alive r7
 L6:
     CPy_RestoreExcInfo(r6)
     goto L8
 L7: (handler for L5)
     CPy_RestoreExcInfo(r6)
-    r12 = CPy_KeepPropagating()
+    r14 = CPy_KeepPropagating()
     unreachable
 L8:
     return 1
@@ -107,80 +119,98 @@ def g():
     r0 :: str
     r1 :: object
     r2 :: str
-    r3, r4, r5 :: object
-    r6 :: str
-    r7, r8 :: object
-    r9 :: tuple[object, object, object]
-    r10 :: object
-    r11 :: str
+    r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6, r7 :: object
+    r8 :: str
+    r9, r10 :: object
+    r11 :: tuple[object, object, object]
     r12 :: object
-    r13 :: bit
-    r14, e :: object
-    r15 :: str
-    r16 :: object
+    r13 :: str
+    r14 :: object
+    r15 :: bit
+    r16, e :: object
     r17 :: str
-    r18, r19 :: object
-    r20 :: bit
-    r21 :: tuple[object, object, object]
-    r22 :: str
+    r18 :: object
+    r19 :: str
+    r20 :: object
+    r21 :: object[2]
+    r22 :: object_ptr
     r23 :: object
-    r24 :: str
-    r25, r26 :: object
-    r27 :: bit
+    r24 :: bit
+    r25 :: tuple[object, object, object]
+    r26 :: str
+    r27 :: object
+    r28 :: str
+    r29 :: object
+    r30 :: object[1]
+    r31 :: object_ptr
+    r32 :: object
+    r33 :: bit
 L0:
 L1:
     r0 = 'a'
     r1 = builtins :: module
     r2 = 'print'
     r3 = CPyObject_GetAttr(r1, r2)
-    r4 = PyObject_CallFunctionObjArgs(r3, r0, 0)
+    r4 = [r0]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r3, r5, 1, 0)
+    keep_alive r0
 L2:
-    r5 = builtins :: module
-    r6 = 'object'
-    r7 = CPyObject_GetAttr(r5, r6)
-    r8 = PyObject_CallFunctionObjArgs(r7, 0)
+    r7 = builtins :: module
+    r8 = 'object'
+    r9 = CPyObject_GetAttr(r7, r8)
+    r10 = PyObject_Vectorcall(r9, 0, 0, 0)
     goto L8
 L3: (handler for L2)
-    r9 = CPy_CatchError()
-    r10 = builtins :: module
-    r11 = 'AttributeError'
-    r12 = CPyObject_GetAttr(r10, r11)
-    r13 = CPy_ExceptionMatches(r12)
-    if r13 goto L4 else goto L5 :: bool
+    r11 = CPy_CatchError()
+    r12 = builtins :: module
+    r13 = 'AttributeError'
+    r14 = CPyObject_GetAttr(r12, r13)
+    r15 = CPy_ExceptionMatches(r14)
+    if r15 goto L4 else goto L5 :: bool
 L4:
-    r14 = CPy_GetExcValue()
-    e = r14
-    r15 = 'b'
-    r16 = builtins :: module
-    r17 = 'print'
-    r18 = CPyObject_GetAttr(r16, r17)
-    r19 = PyObject_CallFunctionObjArgs(r18, r15, e, 0)
+    r16 = CPy_GetExcValue()
+    e = r16
+    r17 = 'b'
+    r18 = builtins :: module
+    r19 = 'print'
+    r20 = CPyObject_GetAttr(r18, r19)
+    r21 = [r17, e]
+    r22 = load_address r21
+    r23 = PyObject_Vectorcall(r20, r22, 2, 0)
+    keep_alive r17, e
     goto L6
 L5:
     CPy_Reraise()
     unreachable
 L6:
-    CPy_RestoreExcInfo(r9)
+    CPy_RestoreExcInfo(r11)
     goto L8
 L7: (handler for L3, L4, L5)
-    CPy_RestoreExcInfo(r9)
-    r20 = CPy_KeepPropagating()
+    CPy_RestoreExcInfo(r11)
+    r24 = CPy_KeepPropagating()
     unreachable
 L8:
     goto L12
 L9: (handler for L1, L6, L7, L8)
-    r21 = CPy_CatchError()
-    r22 = 'weeee'
-    r23 = builtins :: module
-    r24 = 'print'
-    r25 = CPyObject_GetAttr(r23, r24)
-    r26 = PyObject_CallFunctionObjArgs(r25, r22, 0)
+    r25 = CPy_CatchError()
+    r26 = 'weeee'
+    r27 = builtins :: module
+    r28 = 'print'
+    r29 = CPyObject_GetAttr(r27, r28)
+    r30 = [r26]
+    r31 = load_address r30
+    r32 = PyObject_Vectorcall(r29, r31, 1, 0)
+    keep_alive r26
 L10:
-    CPy_RestoreExcInfo(r21)
+    CPy_RestoreExcInfo(r25)
     goto L12
 L11: (handler for L9)
-    CPy_RestoreExcInfo(r21)
-    r27 = CPy_KeepPropagating()
+    CPy_RestoreExcInfo(r25)
+    r33 = CPy_KeepPropagating()
     unreachable
 L12:
     return 1
@@ -203,15 +233,21 @@ def g():
     r5 :: str
     r6 :: object
     r7 :: str
-    r8, r9, r10 :: object
-    r11 :: str
-    r12 :: object
-    r13 :: bit
-    r14 :: str
-    r15 :: object
+    r8 :: object
+    r9 :: object[1]
+    r10 :: object_ptr
+    r11, r12 :: object
+    r13 :: str
+    r14 :: object
+    r15 :: bit
     r16 :: str
-    r17, r18 :: object
-    r19 :: bit
+    r17 :: object
+    r18 :: str
+    r19 :: object
+    r20 :: object[1]
+    r21 :: object_ptr
+    r22 :: object
+    r23 :: bit
 L0:
 L1:
     goto L9
@@ -227,20 +263,26 @@ L3:
     r6 = builtins :: module
     r7 = 'print'
     r8 = CPyObject_GetAttr(r6, r7)
-    r9 = PyObject_CallFunctionObjArgs(r8, r5, 0)
+    r9 = [r5]
+    r10 = load_address r9
+    r11 = PyObject_Vectorcall(r8, r10, 1, 0)
+    keep_alive r5
     goto L7
 L4:
-    r10 = builtins :: module
-    r11 = 'IndexError'
-    r12 = CPyObject_GetAttr(r10, r11)
-    r13 = CPy_ExceptionMatches(r12)
-    if r13 goto L5 else goto L6 :: bool
+    r12 = builtins :: module
+    r13 = 'IndexError'
+    r14 = CPyObject_GetAttr(r12, r13)
+    r15 = CPy_ExceptionMatches(r14)
+    if r15 goto L5 else goto L6 :: bool
 L5:
-    r14 = 'yo'
-    r15 = builtins :: module
-    r16 = 'print'
-    r17 = CPyObject_GetAttr(r15, r16)
-    r18 = PyObject_CallFunctionObjArgs(r17, r14, 0)
+    r16 = 'yo'
+    r17 = builtins :: module
+    r18 = 'print'
+    r19 = CPyObject_GetAttr(r17, r18)
+    r20 = [r16]
+    r21 = load_address r20
+    r22 = PyObject_Vectorcall(r19, r21, 1, 0)
+    keep_alive r16
     goto L7
 L6:
     CPy_Reraise()
@@ -250,7 +292,7 @@ L7:
     goto L9
 L8: (handler for L2, L3, L4, L5, L6)
     CPy_RestoreExcInfo(r0)
-    r19 = CPy_KeepPropagating()
+    r23 = CPy_KeepPropagating()
     unreachable
 L9:
     return 1
@@ -268,13 +310,19 @@ def a(b):
     r0 :: str
     r1 :: object
     r2 :: str
-    r3, r4 :: object
-    r5, r6, r7 :: tuple[object, object, object]
-    r8 :: str
-    r9 :: object
+    r3 :: object
+    r4 :: object[1]
+    r5 :: object_ptr
+    r6 :: object
+    r7, r8, r9 :: tuple[object, object, object]
     r10 :: str
-    r11, r12 :: object
-    r13 :: bit
+    r11 :: object
+    r12 :: str
+    r13 :: object
+    r14 :: object[1]
+    r15 :: object_ptr
+    r16 :: object
+    r17 :: bit
 L0:
 L1:
     if b goto L2 else goto L3 :: bool
@@ -283,36 +331,42 @@ L2:
     r1 = builtins :: module
     r2 = 'Exception'
     r3 = CPyObject_GetAttr(r1, r2)
-    r4 = PyObject_CallFunctionObjArgs(r3, r0, 0)
-    CPy_Raise(r4)
+    r4 = [r0]
+    r5 = load_address r4
+    r6 = PyObject_Vectorcall(r3, r5, 1, 0)
+    keep_alive r0
+    CPy_Raise(r6)
     unreachable
 L3:
 L4:
 L5:
-    r5 = <error> :: tuple[object, object, object]
-    r6 = r5
+    r7 = <error> :: tuple[object, object, object]
+    r8 = r7
     goto L7
 L6: (handler for L1, L2, L3)
-    r7 = CPy_CatchError()
-    r6 = r7
+    r9 = CPy_CatchError()
+    r8 = r9
 L7:
-    r8 = 'finally'
-    r9 = builtins :: module
-    r10 = 'print'
-    r11 = CPyObject_GetAttr(r9, r10)
-    r12 = PyObject_CallFunctionObjArgs(r11, r8, 0)
-    if is_error(r6) goto L9 else goto L8
+    r10 = 'finally'
+    r11 = builtins :: module
+    r12 = 'print'
+    r13 = CPyObject_GetAttr(r11, r12)
+    r14 = [r10]
+    r15 = load_address r14
+    r16 = PyObject_Vectorcall(r13, r15, 1, 0)
+    keep_alive r10
+    if is_error(r8) goto L9 else goto L8
 L8:
     CPy_Reraise()
     unreachable
 L9:
     goto L13
 L10: (handler for L7, L8)
-    if is_error(r6) goto L12 else goto L11
+    if is_error(r8) goto L12 else goto L11
 L11:
-    CPy_RestoreExcInfo(r6)
+    CPy_RestoreExcInfo(r8)
 L12:
-    r13 = CPy_KeepPropagating()
+    r17 = CPy_KeepPropagating()
     unreachable
 L13:
     return 1
@@ -328,90 +382,114 @@ def foo(x):
     r2 :: str
     r3 :: object
     r4 :: str
-    r5, r6 :: object
-    r7 :: bool
+    r5 :: object
+    r6 :: object[1]
+    r7 :: object_ptr
+    r8 :: object
+    r9 :: bool
     y :: object
-    r8 :: str
-    r9 :: object
     r10 :: str
-    r11, r12 :: object
-    r13, r14 :: tuple[object, object, object]
-    r15, r16, r17, r18 :: object
-    r19 :: int32
-    r20 :: bit
-    r21 :: bool
-    r22 :: bit
-    r23, r24, r25 :: tuple[object, object, object]
-    r26, r27 :: object
+    r11 :: object
+    r12 :: str
+    r13 :: object
+    r14 :: object[1]
+    r15 :: object_ptr
+    r16 :: object
+    r17, r18 :: tuple[object, object, object]
+    r19, r20, r21 :: object
+    r22 :: object[4]
+    r23 :: object_ptr
+    r24 :: object
+    r25 :: i32
+    r26 :: bit
+    r27 :: bool
     r28 :: bit
+    r29, r30, r31 :: tuple[object, object, object]
+    r32 :: object
+    r33 :: object[4]
+    r34 :: object_ptr
+    r35 :: object
+    r36 :: bit
 L0:
-    r0 = PyObject_CallFunctionObjArgs(x, 0)
+    r0 = PyObject_Vectorcall(x, 0, 0, 0)
     r1 = PyObject_Type(r0)
     r2 = '__exit__'
     r3 = CPyObject_GetAttr(r1, r2)
     r4 = '__enter__'
     r5 = CPyObject_GetAttr(r1, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r0, 0)
-    r7 = 1
+    r6 = [r0]
+    r7 = load_address r6
+    r8 = PyObject_Vectorcall(r5, r7, 1, 0)
+    keep_alive r0
+    r9 = 1
 L1:
 L2:
-    y = r6
-    r8 = 'hello'
-    r9 = builtins :: module
-    r10 = 'print'
-    r11 = CPyObject_GetAttr(r9, r10)
-    r12 = PyObject_CallFunctionObjArgs(r11, r8, 0)
+    y = r8
+    r10 = 'hello'
+    r11 = builtins :: module
+    r12 = 'print'
+    r13 = CPyObject_GetAttr(r11, r12)
+    r14 = [r10]
+    r15 = load_address r14
+    r16 = PyObject_Vectorcall(r13, r15, 1, 0)
+    keep_alive r10
     goto L8
 L3: (handler for L2)
-    r13 = CPy_CatchError()
-    r7 = 0
-    r14 = CPy_GetExcInfo()
-    r15 = r14[0]
-    r16 = r14[1]
-    r17 = r14[2]
-    r18 = PyObject_CallFunctionObjArgs(r3, r0, r15, r16, r17, 0)
-    r19 = PyObject_IsTrue(r18)
-    r20 = r19 >= 0 :: signed
-    r21 = truncate r19: int32 to builtins.bool
-    if r21 goto L5 else goto L4 :: bool
+    r17 = CPy_CatchError()
+    r9 = 0
+    r18 = CPy_GetExcInfo()
+    r19 = r18[0]
+    r20 = r18[1]
+    r21 = r18[2]
+    r22 = [r0, r19, r20, r21]
+    r23 = load_address r22
+    r24 = PyObject_Vectorcall(r3, r23, 4, 0)
+    keep_alive r0, r19, r20, r21
+    r25 = PyObject_IsTrue(r24)
+    r26 = r25 >= 0 :: signed
+    r27 = truncate r25: i32 to builtins.bool
+    if r27 goto L5 else goto L4 :: bool
 L4:
     CPy_Reraise()
     unreachable
 L5:
 L6:
-    CPy_RestoreExcInfo(r13)
+    CPy_RestoreExcInfo(r17)
     goto L8
 L7: (handler for L3, L4, L5)
-    CPy_RestoreExcInfo(r13)
-    r22 = CPy_KeepPropagating()
+    CPy_RestoreExcInfo(r17)
+    r28 = CPy_KeepPropagating()
     unreachable
 L8:
 L9:
 L10:
-    r23 = <error> :: tuple[object, object, object]
-    r24 = r23
+    r29 = <error> :: tuple[object, object, object]
+    r30 = r29
     goto L12
 L11: (handler for L1, L6, L7, L8)
-    r25 = CPy_CatchError()
-    r24 = r25
+    r31 = CPy_CatchError()
+    r30 = r31
 L12:
-    if r7 goto L13 else goto L14 :: bool
+    if r9 goto L13 else goto L14 :: bool
 L13:
-    r26 = load_address _Py_NoneStruct
-    r27 = PyObject_CallFunctionObjArgs(r3, r0, r26, r26, r26, 0)
+    r32 = load_address _Py_NoneStruct
+    r33 = [r0, r32, r32, r32]
+    r34 = load_address r33
+    r35 = PyObject_Vectorcall(r3, r34, 4, 0)
+    keep_alive r0, r32, r32, r32
 L14:
-    if is_error(r24) goto L16 else goto L15
+    if is_error(r30) goto L16 else goto L15
 L15:
     CPy_Reraise()
     unreachable
 L16:
     goto L20
 L17: (handler for L12, L13, L14, L15)
-    if is_error(r24) goto L19 else goto L18
+    if is_error(r30) goto L19 else goto L18
 L18:
-    CPy_RestoreExcInfo(r24)
+    CPy_RestoreExcInfo(r30)
 L19:
-    r28 = CPy_KeepPropagating()
+    r36 = CPy_KeepPropagating()
     unreachable
 L20:
     return 1
@@ -443,19 +521,22 @@ def foo(x):
     r2 :: str
     r3 :: object
     r4 :: str
-    r5, r6 :: object
-    r7, r8 :: tuple[object, object, object]
-    r9, r10, r11 :: object
-    r12 :: None
-    r13 :: object
-    r14 :: int32
-    r15 :: bit
-    r16 :: bool
+    r5 :: object
+    r6 :: object[1]
+    r7 :: object_ptr
+    r8 :: object
+    r9, r10 :: tuple[object, object, object]
+    r11, r12, r13 :: object
+    r14 :: None
+    r15 :: object
+    r16 :: i32
     r17 :: bit
-    r18, r19, r20 :: tuple[object, object, object]
-    r21 :: object
-    r22 :: None
-    r23 :: bit
+    r18 :: bool
+    r19 :: bit
+    r20, r21, r22 :: tuple[object, object, object]
+    r23 :: object
+    r24 :: None
+    r25 :: bit
 L0:
     r0 = x.__enter__()
     r1 = 1
@@ -465,59 +546,62 @@ L2:
     r3 = builtins :: module
     r4 = 'print'
     r5 = CPyObject_GetAttr(r3, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r2, 0)
+    r6 = [r2]
+    r7 = load_address r6
+    r8 = PyObject_Vectorcall(r5, r7, 1, 0)
+    keep_alive r2
     goto L8
 L3: (handler for L2)
-    r7 = CPy_CatchError()
+    r9 = CPy_CatchError()
     r1 = 0
-    r8 = CPy_GetExcInfo()
-    r9 = r8[0]
-    r10 = r8[1]
-    r11 = r8[2]
-    r12 = x.__exit__(r9, r10, r11)
-    r13 = box(None, r12)
-    r14 = PyObject_IsTrue(r13)
-    r15 = r14 >= 0 :: signed
-    r16 = truncate r14: int32 to builtins.bool
-    if r16 goto L5 else goto L4 :: bool
+    r10 = CPy_GetExcInfo()
+    r11 = r10[0]
+    r12 = r10[1]
+    r13 = r10[2]
+    r14 = x.__exit__(r11, r12, r13)
+    r15 = box(None, r14)
+    r16 = PyObject_IsTrue(r15)
+    r17 = r16 >= 0 :: signed
+    r18 = truncate r16: i32 to builtins.bool
+    if r18 goto L5 else goto L4 :: bool
 L4:
     CPy_Reraise()
     unreachable
 L5:
 L6:
-    CPy_RestoreExcInfo(r7)
+    CPy_RestoreExcInfo(r9)
     goto L8
 L7: (handler for L3, L4, L5)
-    CPy_RestoreExcInfo(r7)
-    r17 = CPy_KeepPropagating()
+    CPy_RestoreExcInfo(r9)
+    r19 = CPy_KeepPropagating()
     unreachable
 L8:
 L9:
 L10:
-    r18 = <error> :: tuple[object, object, object]
-    r19 = r18
+    r20 = <error> :: tuple[object, object, object]
+    r21 = r20
     goto L12
 L11: (handler for L1, L6, L7, L8)
-    r20 = CPy_CatchError()
-    r19 = r20
+    r22 = CPy_CatchError()
+    r21 = r22
 L12:
     if r1 goto L13 else goto L14 :: bool
 L13:
-    r21 = load_address _Py_NoneStruct
-    r22 = x.__exit__(r21, r21, r21)
+    r23 = load_address _Py_NoneStruct
+    r24 = x.__exit__(r23, r23, r23)
 L14:
-    if is_error(r19) goto L16 else goto L15
+    if is_error(r21) goto L16 else goto L15
 L15:
     CPy_Reraise()
     unreachable
 L16:
     goto L20
 L17: (handler for L12, L13, L14, L15)
-    if is_error(r19) goto L19 else goto L18
+    if is_error(r21) goto L19 else goto L18
 L18:
-    CPy_RestoreExcInfo(r19)
+    CPy_RestoreExcInfo(r21)
 L19:
-    r23 = CPy_KeepPropagating()
+    r25 = CPy_KeepPropagating()
     unreachable
 L20:
     return 1
diff --git a/mypyc/test-data/irbuild-tuple.test b/mypyc/test-data/irbuild-tuple.test
index 6a86a6c6781b..582391ff6f98 100644
--- a/mypyc/test-data/irbuild-tuple.test
+++ b/mypyc/test-data/irbuild-tuple.test
@@ -62,15 +62,12 @@ def f(x: Tuple[int, ...]) -> int:
 [out]
 def f(x):
     x :: tuple
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: short_int
+    r0 :: native_int
+    r1 :: short_int
 L0:
-    r0 = get_element_ptr x ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive x
-    r2 = r1 << 1
-    return r2
+    r0 = var_object_size x
+    r1 = r0 << 1
+    return r1
 
 [case testSequenceTupleForced]
 from typing import Tuple
@@ -101,28 +98,26 @@ def f(x, y):
     x, y :: object
     r0 :: list
     r1, r2 :: object
-    r3, r4, r5 :: ptr
-    r6, r7, r8 :: object
-    r9 :: int32
-    r10 :: bit
-    r11 :: tuple
+    r3 :: ptr
+    r4, r5, r6 :: object
+    r7 :: i32
+    r8 :: bit
+    r9 :: tuple
 L0:
     r0 = PyList_New(2)
     r1 = object 1
     r2 = object 2
-    r3 = get_element_ptr r0 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
-    set_mem r4, r1 :: builtins.object*
-    r5 = r4 + WORD_SIZE*1
-    set_mem r5, r2 :: builtins.object*
+    r3 = list_items r0
+    buf_init_item r3, 0, r1
+    buf_init_item r3, 1, r2
     keep_alive r0
-    r6 = CPyList_Extend(r0, x)
-    r7 = CPyList_Extend(r0, y)
-    r8 = object 3
-    r9 = PyList_Append(r0, r8)
-    r10 = r9 >= 0 :: signed
-    r11 = PyList_AsTuple(r0)
-    return r11
+    r4 = CPyList_Extend(r0, x)
+    r5 = CPyList_Extend(r0, y)
+    r6 = object 3
+    r7 = PyList_Append(r0, r6)
+    r8 = r7 >= 0 :: signed
+    r9 = PyList_AsTuple(r0)
+    return r9
 
 [case testTupleFor]
 from typing import Tuple, List
@@ -133,29 +128,26 @@ def f(xs: Tuple[str, ...]) -> None:
 def f(xs):
     xs :: tuple
     r0 :: short_int
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
-    r4 :: bit
-    r5 :: object
-    r6, x :: str
-    r7 :: short_int
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: bit
+    r4 :: object
+    r5, x :: str
+    r6 :: short_int
 L0:
     r0 = 0
 L1:
-    r1 = get_element_ptr xs ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
-    keep_alive xs
-    r3 = r2 << 1
-    r4 = r0 < r3 :: signed
-    if r4 goto L2 else goto L4 :: bool
+    r1 = var_object_size xs
+    r2 = r1 << 1
+    r3 = int_lt r0, r2
+    if r3 goto L2 else goto L4 :: bool
 L2:
-    r5 = CPySequenceTuple_GetItem(xs, r0)
-    r6 = cast(str, r5)
-    x = r6
+    r4 = CPySequenceTuple_GetItem(xs, r0)
+    r5 = cast(str, r4)
+    x = r5
 L3:
-    r7 = r0 + 2
-    r0 = r7
+    r6 = r0 + 2
+    r0 = r6
     goto L1
 L4:
     return 1
@@ -195,70 +187,30 @@ def f(i: int) -> bool:
 [out]
 def f(i):
     i :: int
-    r0 :: native_int
-    r1, r2 :: bit
+    r0 :: bit
+    r1 :: bool
+    r2 :: bit
     r3 :: bool
     r4 :: bit
-    r5 :: bool
-    r6 :: native_int
-    r7, r8 :: bit
-    r9 :: bool
-    r10 :: bit
-    r11 :: bool
-    r12 :: native_int
-    r13, r14 :: bit
-    r15 :: bool
-    r16 :: bit
 L0:
-    r0 = i & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_eq i, 2
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = i == 2
-    r3 = r2
+    r1 = r0
     goto L3
 L2:
-    r4 = CPyTagged_IsEq_(i, 2)
-    r3 = r4
+    r2 = int_eq i, 4
+    r1 = r2
 L3:
-    if r3 goto L4 else goto L5 :: bool
+    if r1 goto L4 else goto L5 :: bool
 L4:
-    r5 = r3
-    goto L9
+    r3 = r1
+    goto L6
 L5:
-    r6 = i & 1
-    r7 = r6 == 0
-    if r7 goto L6 else goto L7 :: bool
+    r4 = int_eq i, 6
+    r3 = r4
 L6:
-    r8 = i == 4
-    r9 = r8
-    goto L8
-L7:
-    r10 = CPyTagged_IsEq_(i, 4)
-    r9 = r10
-L8:
-    r5 = r9
-L9:
-    if r5 goto L10 else goto L11 :: bool
-L10:
-    r11 = r5
-    goto L15
-L11:
-    r12 = i & 1
-    r13 = r12 == 0
-    if r13 goto L12 else goto L13 :: bool
-L12:
-    r14 = i == 6
-    r15 = r14
-    goto L14
-L13:
-    r16 = CPyTagged_IsEq_(i, 6)
-    r15 = r16
-L14:
-    r11 = r15
-L15:
-    return r11
-
+    return r3
 
 [case testTupleBuiltFromList]
 def f(val: int) -> bool:
@@ -270,83 +222,61 @@ def test() -> None:
 [out]
 def f(val):
     val, r0 :: int
-    r1 :: native_int
-    r2, r3 :: bit
-    r4 :: bool
-    r5 :: bit
+    r1 :: bit
 L0:
     r0 = CPyTagged_Remainder(val, 4)
-    r1 = r0 & 1
-    r2 = r1 == 0
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    r3 = r0 == 0
-    r4 = r3
-    goto L3
-L2:
-    r5 = CPyTagged_IsEq_(r0, 0)
-    r4 = r5
-L3:
-    return r4
+    r1 = int_eq r0, 0
+    return r1
 def test():
     r0 :: list
     r1, r2, r3 :: object
-    r4, r5, r6, r7 :: ptr
+    r4 :: ptr
     source :: list
-    r8 :: ptr
-    r9 :: native_int
-    r10 :: tuple
-    r11 :: short_int
-    r12 :: ptr
-    r13 :: native_int
-    r14 :: short_int
+    r5 :: native_int
+    r6 :: tuple
+    r7 :: short_int
+    r8 :: native_int
+    r9 :: short_int
+    r10 :: bit
+    r11 :: object
+    r12, x :: int
+    r13 :: bool
+    r14 :: object
     r15 :: bit
-    r16 :: object
-    r17, x :: int
-    r18 :: bool
-    r19 :: object
-    r20 :: bit
-    r21 :: short_int
+    r16 :: short_int
     a :: tuple
 L0:
     r0 = PyList_New(3)
     r1 = object 1
     r2 = object 2
     r3 = object 3
-    r4 = get_element_ptr r0 ob_item :: PyListObject
-    r5 = load_mem r4 :: ptr*
-    set_mem r5, r1 :: builtins.object*
-    r6 = r5 + WORD_SIZE*1
-    set_mem r6, r2 :: builtins.object*
-    r7 = r5 + WORD_SIZE*2
-    set_mem r7, r3 :: builtins.object*
+    r4 = list_items r0
+    buf_init_item r4, 0, r1
+    buf_init_item r4, 1, r2
+    buf_init_item r4, 2, r3
     keep_alive r0
     source = r0
-    r8 = get_element_ptr source ob_size :: PyVarObject
-    r9 = load_mem r8 :: native_int*
-    keep_alive source
-    r10 = PyTuple_New(r9)
-    r11 = 0
+    r5 = var_object_size source
+    r6 = PyTuple_New(r5)
+    r7 = 0
 L1:
-    r12 = get_element_ptr source ob_size :: PyVarObject
-    r13 = load_mem r12 :: native_int*
-    keep_alive source
-    r14 = r13 << 1
-    r15 = r11 < r14 :: signed
-    if r15 goto L2 else goto L4 :: bool
+    r8 = var_object_size source
+    r9 = r8 << 1
+    r10 = int_lt r7, r9
+    if r10 goto L2 else goto L4 :: bool
 L2:
-    r16 = CPyList_GetItemUnsafe(source, r11)
-    r17 = unbox(int, r16)
-    x = r17
-    r18 = f(x)
-    r19 = box(bool, r18)
-    r20 = CPySequenceTuple_SetItemUnsafe(r10, r11, r19)
+    r11 = list_get_item_unsafe source, r7
+    r12 = unbox(int, r11)
+    x = r12
+    r13 = f(x)
+    r14 = box(bool, r13)
+    r15 = CPySequenceTuple_SetItemUnsafe(r6, r7, r14)
 L3:
-    r21 = r11 + 2
-    r11 = r21
+    r16 = r7 + 2
+    r7 = r16
     goto L1
 L4:
-    a = r10
+    a = r6
     return 1
 
 [case testTupleBuiltFromStr]
@@ -388,7 +318,7 @@ L1:
     r5 = CPyStr_Size_size_t(source)
     r6 = r5 >= 0 :: signed
     r7 = r5 << 1
-    r8 = r4 < r7 :: signed
+    r8 = int_lt r4, r7
     if r8 goto L2 else goto L4 :: bool
 L2:
     r9 = CPyStr_GetItem(source, r4)
@@ -419,44 +349,107 @@ L0:
     return r0
 def test(source):
     source :: tuple
-    r0 :: ptr
-    r1 :: native_int
-    r2 :: tuple
-    r3 :: short_int
-    r4 :: ptr
-    r5 :: native_int
-    r6 :: short_int
-    r7 :: bit
-    r8 :: object
-    r9, x, r10 :: bool
-    r11 :: object
-    r12 :: bit
-    r13 :: short_int
+    r0 :: native_int
+    r1 :: tuple
+    r2 :: short_int
+    r3 :: native_int
+    r4 :: short_int
+    r5 :: bit
+    r6 :: object
+    r7, x, r8 :: bool
+    r9 :: object
+    r10 :: bit
+    r11 :: short_int
     a :: tuple
 L0:
-    r0 = get_element_ptr source ob_size :: PyVarObject
-    r1 = load_mem r0 :: native_int*
-    keep_alive source
-    r2 = PyTuple_New(r1)
-    r3 = 0
+    r0 = var_object_size source
+    r1 = PyTuple_New(r0)
+    r2 = 0
 L1:
-    r4 = get_element_ptr source ob_size :: PyVarObject
-    r5 = load_mem r4 :: native_int*
-    keep_alive source
-    r6 = r5 << 1
-    r7 = r3 < r6 :: signed
-    if r7 goto L2 else goto L4 :: bool
+    r3 = var_object_size source
+    r4 = r3 << 1
+    r5 = int_lt r2, r4
+    if r5 goto L2 else goto L4 :: bool
 L2:
-    r8 = CPySequenceTuple_GetItem(source, r3)
-    r9 = unbox(bool, r8)
-    x = r9
-    r10 = f(x)
-    r11 = box(bool, r10)
-    r12 = CPySequenceTuple_SetItemUnsafe(r2, r3, r11)
+    r6 = CPySequenceTuple_GetItem(source, r2)
+    r7 = unbox(bool, r6)
+    x = r7
+    r8 = f(x)
+    r9 = box(bool, r8)
+    r10 = CPySequenceTuple_SetItemUnsafe(r1, r2, r9)
 L3:
-    r13 = r3 + 2
-    r3 = r13
+    r11 = r2 + 2
+    r2 = r11
     goto L1
 L4:
-    a = r2
+    a = r1
+    return 1
+
+[case testTupleAdd]
+from typing import Tuple
+def f(a: Tuple[int, ...], b: Tuple[int, ...]) -> None:
+    c = a + b
+    d = a + (1, 2)
+def g(a: Tuple[int, int], b: Tuple[int, int]) -> None:
+    c = a + b
+[out]
+def f(a, b):
+    a, b, r0, c :: tuple
+    r1 :: tuple[int, int]
+    r2 :: object
+    r3, d :: tuple
+L0:
+    r0 = PySequence_Concat(a, b)
+    c = r0
+    r1 = (2, 4)
+    r2 = box(tuple[int, int], r1)
+    r3 = PySequence_Concat(a, r2)
+    d = r3
+    return 1
+def g(a, b):
+    a, b :: tuple[int, int]
+    r0, r1 :: object
+    r2 :: tuple
+    r3, c :: tuple[int, int, int, int]
+L0:
+    r0 = box(tuple[int, int], a)
+    r1 = box(tuple[int, int], b)
+    r2 = PySequence_Concat(r0, r1)
+    r3 = unbox(tuple[int, int, int, int], r2)
+    c = r3
+    return 1
+
+[case testTupleMultiply]
+from typing import Tuple
+def f(a: Tuple[int]) -> None:
+    b = a * 2
+    c = 3 * (2,)
+def g(a: Tuple[int, ...]) -> None:
+    b = a * 2
+[out]
+def f(a):
+    a :: tuple[int]
+    r0 :: object
+    r1 :: tuple
+    r2, b :: tuple[int, int]
+    r3 :: tuple[int]
+    r4 :: object
+    r5 :: tuple
+    r6, c :: tuple[int, int, int]
+L0:
+    r0 = box(tuple[int], a)
+    r1 = CPySequence_Multiply(r0, 4)
+    r2 = unbox(tuple[int, int], r1)
+    b = r2
+    r3 = (4)
+    r4 = box(tuple[int], r3)
+    r5 = CPySequence_RMultiply(6, r4)
+    r6 = unbox(tuple[int, int, int], r5)
+    c = r6
+    return 1
+def g(a):
+    a, r0, b :: tuple
+L0:
+    r0 = CPySequence_Multiply(a, 4)
+    b = r0
     return 1
diff --git a/mypyc/test-data/irbuild-u8.test b/mypyc/test-data/irbuild-u8.test
new file mode 100644
index 000000000000..14f691c9451f
--- /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 2c164491a5a1..7209c00ce75d 100644
--- a/mypyc/test-data/irbuild-unreachable.test
+++ b/mypyc/test-data/irbuild-unreachable.test
@@ -1,4 +1,4 @@
-# Test cases for unreachable expressions
+# Test cases for unreachable expressions and statements
 
 [case testUnreachableMemberExpr]
 import sys
@@ -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
@@ -104,3 +104,144 @@ L5:
 L6:
     y = r11
     return 1
+
+[case testUnreachableStatementAfterReturn]
+def f(x: bool) -> int:
+    if x:
+        return 1
+        f(False)
+    return 2
+[out]
+def f(x):
+    x :: bool
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    return 2
+L2:
+    return 4
+
+[case testUnreachableStatementAfterContinue]
+def c() -> bool:
+    return False
+
+def f() -> None:
+    n = True
+    while n:
+        if c():
+            continue
+            if int():
+                f()
+        n = False
+[out]
+def c():
+L0:
+    return 0
+def f():
+    n, r0 :: bool
+L0:
+    n = 1
+L1:
+    if n goto L2 else goto L5 :: bool
+L2:
+    r0 = c()
+    if r0 goto L3 else goto L4 :: bool
+L3:
+    goto L1
+L4:
+    n = 0
+    goto L1
+L5:
+    return 1
+
+[case testUnreachableStatementAfterBreak]
+def c() -> bool:
+    return False
+
+def f() -> None:
+    n = True
+    while n:
+        if c():
+            break
+            if int():
+                f()
+        n = False
+[out]
+def c():
+L0:
+    return 0
+def f():
+    n, r0 :: bool
+L0:
+    n = 1
+L1:
+    if n goto L2 else goto L5 :: bool
+L2:
+    r0 = c()
+    if r0 goto L3 else goto L4 :: bool
+L3:
+    goto L5
+L4:
+    n = 0
+    goto L1
+L5:
+    return 1
+
+[case testUnreachableStatementAfterRaise]
+def f(x: bool) -> int:
+    if x:
+        raise ValueError()
+        print('hello')
+    return 2
+[out]
+def f(x):
+    x :: bool
+    r0 :: object
+    r1 :: str
+    r2, r3 :: object
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    r0 = builtins :: module
+    r1 = 'ValueError'
+    r2 = CPyObject_GetAttr(r0, r1)
+    r3 = PyObject_Vectorcall(r2, 0, 0, 0)
+    CPy_Raise(r3)
+    unreachable
+L2:
+    return 4
+
+[case testUnreachableStatementAfterAssertFalse]
+def f(x: bool) -> int:
+    if x:
+        assert False
+        print('hello')
+    return 2
+[out]
+def f(x):
+    x, r0 :: bool
+    r1 :: str
+    r2 :: object
+    r3 :: str
+    r4 :: object
+    r5 :: object[1]
+    r6 :: object_ptr
+    r7 :: object
+L0:
+    if x goto L1 else goto L4 :: bool
+L1:
+    if 0 goto L3 else goto L2 :: bool
+L2:
+    r0 = raise AssertionError
+    unreachable
+L3:
+    r1 = 'hello'
+    r2 = builtins :: module
+    r3 = 'print'
+    r4 = CPyObject_GetAttr(r2, r3)
+    r5 = [r1]
+    r6 = load_address r5
+    r7 = PyObject_Vectorcall(r4, r6, 1, 0)
+    keep_alive r1
+L4:
+    return 4
diff --git a/mypyc/test-data/irbuild-vectorcall.test b/mypyc/test-data/irbuild-vectorcall.test
index 1ba08efc2501..15e717191ff0 100644
--- a/mypyc/test-data/irbuild-vectorcall.test
+++ b/mypyc/test-data/irbuild-vectorcall.test
@@ -3,7 +3,7 @@
 -- Vectorcalls are faster than the legacy API, especially with keyword arguments,
 -- since there is no need to allocate a temporary dictionary for keyword args.
 
-[case testeVectorcallBasic_python3_8]
+[case testeVectorcallBasic]
 from typing import Any
 
 def f(c: Any) -> None:
@@ -17,16 +17,16 @@ def f(c):
     r4 :: object_ptr
     r5 :: object
 L0:
-    r0 = _PyObject_Vectorcall(c, 0, 0, 0)
+    r0 = PyObject_Vectorcall(c, 0, 0, 0)
     r1 = 'x'
     r2 = 'y'
     r3 = [r1, r2]
     r4 = load_address r3
-    r5 = _PyObject_Vectorcall(c, r4, 2, 0)
+    r5 = PyObject_Vectorcall(c, r4, 2, 0)
     keep_alive r1, r2
     return 1
 
-[case testVectorcallKeywords_python3_8]
+[case testVectorcallKeywords]
 from typing import Any
 
 def f(c: Any) -> None:
@@ -48,7 +48,7 @@ L0:
     r1 = [r0]
     r2 = load_address r1
     r3 = ('x',)
-    r4 = _PyObject_Vectorcall(c, r2, 0, r3)
+    r4 = PyObject_Vectorcall(c, r2, 0, r3)
     keep_alive r0
     r5 = 'x'
     r6 = 'y'
@@ -56,43 +56,11 @@ L0:
     r8 = [r5, r6, r7]
     r9 = load_address r8
     r10 = ('a', 'b')
-    r11 = _PyObject_Vectorcall(c, r9, 1, r10)
+    r11 = PyObject_Vectorcall(c, r9, 1, r10)
     keep_alive r5, r6, r7
     return 1
 
-[case testVectorcallMethod_python3_8]
-from typing import Any
-
-def f(o: Any) -> None:
-    # On Python 3.8 vectorcalls are only faster with keyword args
-    o.m('x')
-    o.m('x', a='y')
-[out]
-def f(o):
-    o :: object
-    r0, r1 :: str
-    r2 :: object
-    r3, r4, r5 :: str
-    r6 :: object
-    r7 :: object[2]
-    r8 :: object_ptr
-    r9, r10 :: object
-L0:
-    r0 = 'x'
-    r1 = 'm'
-    r2 = CPyObject_CallMethodObjArgs(o, r1, r0, 0)
-    r3 = 'x'
-    r4 = 'y'
-    r5 = 'm'
-    r6 = CPyObject_GetAttr(o, r5)
-    r7 = [r3, r4]
-    r8 = load_address r7
-    r9 = ('a',)
-    r10 = _PyObject_Vectorcall(r6, r8, 1, r9)
-    keep_alive r3, r4
-    return 1
-
-[case testVectorcallMethod_python3_9_64bit]
+[case testVectorcallMethod_64bit]
 from typing import Any
 
 def f(o: Any) -> None:
@@ -128,7 +96,7 @@ L0:
     keep_alive o, r5, r6, r7
     return 1
 
-[case testVectorcallMethod_python3_9_32bit]
+[case testVectorcallMethod_32bit]
 from typing import Any
 
 def f(o: Any) -> None:
diff --git a/mypyc/test-data/lowering-int.test b/mypyc/test-data/lowering-int.test
new file mode 100644
index 000000000000..ad561c561872
--- /dev/null
+++ b/mypyc/test-data/lowering-int.test
@@ -0,0 +1,387 @@
+-- Test cases for converting high-level IR to lower-level IR (lowering).
+
+[case testLowerIntEq]
+def f(x: int, y: int) -> int:
+    if x == y:
+        return 1
+    else:
+        return 2
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L1 else goto L2 :: bool
+L1:
+    r2 = CPyTagged_IsEq_(x, y)
+    if r2 goto L3 else goto L4 :: bool
+L2:
+    r3 = x == y
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    return 2
+L4:
+    return 4
+
+[case testLowerIntNe]
+def f(x: int, y: int) -> int:
+    if x != y:
+        return 1
+    else:
+        return 2
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1, r2, r3, r4 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L1 else goto L2 :: bool
+L1:
+    r2 = CPyTagged_IsEq_(x, y)
+    r3 = r2 ^ 1
+    if r3 goto L3 else goto L4 :: bool
+L2:
+    r4 = x != y
+    if r4 goto L3 else goto L4 :: bool
+L3:
+    return 2
+L4:
+    return 4
+
+[case testLowerIntEqWithConstant]
+def f(x: int, y: int) -> int:
+    if x == 2:
+        return 1
+    elif -1 == x:
+        return 2
+    return 3
+[out]
+def f(x, y):
+    x, y :: int
+    r0, r1 :: bit
+L0:
+    r0 = x == 4
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    return 2
+L2:
+    r1 = -2 == x
+    if r1 goto L3 else goto L4 :: bool
+L3:
+    return 4
+L4:
+    return 6
+
+[case testLowerIntNeWithConstant]
+def f(x: int, y: int) -> int:
+    if x != 2:
+        return 1
+    elif -1 != x:
+        return 2
+    return 3
+[out]
+def f(x, y):
+    x, y :: int
+    r0, r1 :: bit
+L0:
+    r0 = x != 4
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    return 2
+L2:
+    r1 = -2 != x
+    if r1 goto L3 else goto L4 :: bool
+L3:
+    return 4
+L4:
+    return 6
+
+[case testLowerIntEqValueContext]
+def f(x: int, y: int) -> bool:
+    return x == y
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1, r2 :: bit
+    r3 :: bool
+    r4 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L1 else goto L2 :: bool
+L1:
+    r2 = CPyTagged_IsEq_(x, y)
+    r3 = r2
+    goto L3
+L2:
+    r4 = x == y
+    r3 = r4
+L3:
+    return r3
+
+[case testLowerIntLt]
+def f(x: int, y: int) -> int:
+    if x < y:
+        return 1
+    else:
+        return 2
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1 :: bit
+    r2 :: native_int
+    r3, r4, r5 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L1 :: bool
+L1:
+    r2 = y & 1
+    r3 = r2 != 0
+    if r3 goto L2 else goto L3 :: bool
+L2:
+    r4 = CPyTagged_IsLt_(x, y)
+    if r4 goto L4 else goto L5 :: bool
+L3:
+    r5 = x < y :: signed
+    if r5 goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+
+[case testLowerIntLe]
+def f(x: int, y: int) -> int:
+    if x <= y:
+        return 1
+    else:
+        return 2
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1 :: bit
+    r2 :: native_int
+    r3, r4, r5, r6 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L1 :: bool
+L1:
+    r2 = y & 1
+    r3 = r2 != 0
+    if r3 goto L2 else goto L3 :: bool
+L2:
+    r4 = CPyTagged_IsLt_(y, x)
+    r5 = r4 ^ 1
+    if r5 goto L4 else goto L5 :: bool
+L3:
+    r6 = x <= y :: signed
+    if r6 goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+
+[case testLowerIntGt]
+def f(x: int, y: int) -> int:
+    if x > y:
+        return 1
+    else:
+        return 2
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1 :: bit
+    r2 :: native_int
+    r3, r4, r5 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L1 :: bool
+L1:
+    r2 = y & 1
+    r3 = r2 != 0
+    if r3 goto L2 else goto L3 :: bool
+L2:
+    r4 = CPyTagged_IsLt_(y, x)
+    if r4 goto L4 else goto L5 :: bool
+L3:
+    r5 = x > y :: signed
+    if r5 goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+
+[case testLowerIntGe]
+def f(x: int, y: int) -> int:
+    if x >= y:
+        return 1
+    else:
+        return 2
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1 :: bit
+    r2 :: native_int
+    r3, r4, r5, r6 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L1 :: bool
+L1:
+    r2 = y & 1
+    r3 = r2 != 0
+    if r3 goto L2 else goto L3 :: bool
+L2:
+    r4 = CPyTagged_IsLt_(x, y)
+    r5 = r4 ^ 1
+    if r5 goto L4 else goto L5 :: bool
+L3:
+    r6 = x >= y :: signed
+    if r6 goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+
+[case testLowerIntLtShort]
+def both() -> int:
+    if 3 < 5:
+        return 1
+    else:
+        return 2
+
+def rhs_only(x: int) -> int:
+    if x < 5:
+        return 1
+    else:
+        return 2
+
+def lhs_only(x: int) -> int:
+    if 5 < x:
+        return 1
+    else:
+        return 2
+[out]
+def both():
+    r0 :: bit
+L0:
+    r0 = 6 < 10 :: signed
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    return 2
+L2:
+    return 4
+def rhs_only(x):
+    x :: int
+    r0 :: native_int
+    r1 :: bit
+    r2 :: native_int
+    r3, r4, r5 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L1 :: bool
+L1:
+    r2 = 10 & 1
+    r3 = r2 != 0
+    if r3 goto L2 else goto L3 :: bool
+L2:
+    r4 = CPyTagged_IsLt_(x, 10)
+    if r4 goto L4 else goto L5 :: bool
+L3:
+    r5 = x < 10 :: signed
+    if r5 goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+def lhs_only(x):
+    x :: int
+    r0 :: native_int
+    r1 :: bit
+    r2 :: native_int
+    r3, r4, r5 :: bit
+L0:
+    r0 = 10 & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L1 :: bool
+L1:
+    r2 = x & 1
+    r3 = r2 != 0
+    if r3 goto L2 else goto L3 :: bool
+L2:
+    r4 = CPyTagged_IsLt_(10, x)
+    if r4 goto L4 else goto L5 :: bool
+L3:
+    r5 = 10 < x :: signed
+    if r5 goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+
+[case testLowerIntForLoop_64bit]
+from __future__ import annotations
+
+def f(l: list[int]) -> None:
+    for x in l:
+        pass
+[out]
+def f(l):
+    l :: list
+    r0 :: short_int
+    r1 :: ptr
+    r2 :: native_int
+    r3 :: short_int
+    r4 :: bit
+    r5 :: native_int
+    r6, r7 :: ptr
+    r8 :: native_int
+    r9 :: ptr
+    r10 :: object
+    r11, x :: int
+    r12 :: short_int
+    r13 :: None
+L0:
+    r0 = 0
+L1:
+    r1 = get_element_ptr l ob_size :: PyVarObject
+    r2 = load_mem r1 :: native_int*
+    r3 = r2 << 1
+    r4 = r0 < r3 :: signed
+    if r4 goto L2 else goto L5 :: bool
+L2:
+    r5 = r0 >> 1
+    r6 = get_element_ptr l ob_item :: PyListObject
+    r7 = load_mem r6 :: ptr*
+    r8 = r5 * 8
+    r9 = r7 + r8
+    r10 = load_mem r9 :: builtins.object*
+    inc_ref r10
+    r11 = unbox(int, r10)
+    dec_ref r10
+    if is_error(r11) goto L6 (error at f:4) else goto L3
+L3:
+    x = r11
+    dec_ref x :: int
+L4:
+    r12 = r0 + 2
+    r0 = r12
+    goto L1
+L5:
+    return 1
+L6:
+    r13 = <error> :: None
+    return r13
diff --git a/mypyc/test-data/lowering-list.test b/mypyc/test-data/lowering-list.test
new file mode 100644
index 000000000000..c8438d869970
--- /dev/null
+++ b/mypyc/test-data/lowering-list.test
@@ -0,0 +1,33 @@
+[case testLowerListDisplay]
+def f() -> None:
+    a = [4, 6, 7]
+[out]
+def f():
+    r0 :: list
+    r1, r2, r3 :: object
+    r4, r5, r6, r7 :: ptr
+    a :: list
+    r8 :: None
+L0:
+    r0 = PyList_New(3)
+    if is_error(r0) goto L2 (error at f:2) else goto L1
+L1:
+    r1 = object 4
+    r2 = object 6
+    r3 = object 7
+    r4 = get_element_ptr r0 ob_item :: PyListObject
+    r5 = load_mem r4 :: ptr*
+    inc_ref r1
+    set_mem r5, r1 :: builtins.object*
+    inc_ref r2
+    r6 = r5 + WORD_SIZE*1
+    set_mem r6, r2 :: builtins.object*
+    inc_ref r3
+    r7 = r5 + WORD_SIZE*2
+    set_mem r7, r3 :: builtins.object*
+    a = r0
+    dec_ref a
+    return 1
+L2:
+    r8 = <error> :: None
+    return r8
diff --git a/mypyc/test-data/opt-copy-propagation.test b/mypyc/test-data/opt-copy-propagation.test
new file mode 100644
index 000000000000..49b80f4385fc
--- /dev/null
+++ b/mypyc/test-data/opt-copy-propagation.test
@@ -0,0 +1,400 @@
+-- Test cases for copy propagation optimization.  This also tests IR transforms in general,
+-- as copy propagation was the first IR transform that was implemented.
+
+[case testCopyPropagationSimple]
+def g() -> int:
+    return 1
+
+def f() -> int:
+    y = g()
+    return y
+[out]
+def g():
+L0:
+    return 2
+def f():
+    r0 :: int
+L0:
+    r0 = g()
+    return r0
+
+[case testCopyPropagationChain]
+def f(x: int) -> int:
+    y = x
+    z = y
+    return z
+[out]
+def f(x):
+    x :: int
+L0:
+    return x
+
+[case testCopyPropagationChainPartial]
+def f(x: int) -> int:
+    y = x
+    z = y
+    x = 2
+    return z
+[out]
+def f(x):
+    x, y :: int
+L0:
+    y = x
+    x = 4
+    return y
+
+[case testCopyPropagationChainBad]
+def f(x: int) -> int:
+    y = x
+    z = y
+    y = 2
+    return z
+[out]
+def f(x):
+    x, y, z :: int
+L0:
+    y = x
+    z = y
+    y = 4
+    return z
+
+[case testCopyPropagationMutatedSource1]
+def f(x: int) -> int:
+    y = x
+    x = 1
+    return y
+[out]
+def f(x):
+    x, y :: int
+L0:
+    y = x
+    x = 2
+    return y
+
+[case testCopyPropagationMutatedSource2]
+def f() -> int:
+    z = 1
+    y = z
+    z = 2
+    return y
+[out]
+def f():
+    z, y :: int
+L0:
+    z = 2
+    y = z
+    z = 4
+    return y
+
+[case testCopyPropagationTooComplex]
+def f(b: bool, x: int) -> int:
+    if b:
+        y = x
+        return y
+    else:
+        y = 1
+        return y
+[out]
+def f(b, x):
+    b :: bool
+    x, y :: int
+L0:
+    if b goto L1 else goto L2 :: bool
+L1:
+    y = x
+    return y
+L2:
+    y = 2
+    return y
+
+[case testCopyPropagationArg]
+def f(x: int) -> int:
+    x = 2
+    return x
+[out]
+def f(x):
+    x :: int
+L0:
+    x = 4
+    return x
+
+[case testCopyPropagationPartiallyDefined1]
+def f(b: bool) -> int:
+    if b:
+        x = 1
+    y = x
+    return y
+[out]
+def f(b):
+    b :: bool
+    r0, x :: int
+    r1 :: bool
+    y :: int
+L0:
+    r0 = <error> :: int
+    x = r0
+    if b goto L1 else goto L2 :: bool
+L1:
+    x = 2
+L2:
+    if is_error(x) goto L3 else goto L4
+L3:
+    r1 = raise UnboundLocalError('local variable "x" referenced before assignment')
+    unreachable
+L4:
+    y = x
+    return y
+
+-- The remaining test cases test basic IRTransform functionality and are not
+-- all needed for testing copy propagation as such.
+
+[case testIRTransformBranch]
+from mypy_extensions import i64
+
+def f(x: bool) -> int:
+    y = x
+    if y:
+        return 1
+    else:
+        return 2
+[out]
+def f(x):
+    x :: bool
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    return 2
+L2:
+    return 4
+
+[case testIRTransformAssignment]
+def f(b: bool, x: int) -> int:
+    y = x
+    if b:
+        return y
+    else:
+        return 1
+[out]
+def f(b, x):
+    b :: bool
+    x :: int
+L0:
+    if b goto L1 else goto L2 :: bool
+L1:
+    return x
+L2:
+    return 2
+
+[case testIRTransformRegisterOps1]
+from __future__ import annotations
+from typing import cast
+
+class C:
+    a: int
+
+    def m(self, x: int) -> None: pass
+
+def get_attr(x: C) -> int:
+    y = x
+    return y.a
+
+def set_attr(x: C) -> None:
+    y = x
+    y.a = 1
+
+def tuple_get(x: tuple[int, int]) -> int:
+    y = x
+    return y[0]
+
+def tuple_set(x: int, xx: int) -> tuple[int, int]:
+    y = x
+    z = xx
+    return y, z
+
+def call(x: int) -> int:
+    y = x
+    return call(y)
+
+def method_call(c: C, x: int) -> None:
+    y = x
+    c.m(y)
+
+def cast_op(x: object) -> str:
+    y = x
+    return cast(str, y)
+
+def box(x: int) -> object:
+    y = x
+    return y
+
+def unbox(x: object) -> int:
+    y = x
+    return cast(int, y)
+
+def call_c(x: list[str]) -> None:
+    y = x
+    y.append("x")
+
+def keep_alive(x: C) -> int:
+    y = x
+    return y.a + 1
+[out]
+def C.m(self, x):
+    self :: __main__.C
+    x :: int
+L0:
+    return 1
+def get_attr(x):
+    x :: __main__.C
+    r0 :: int
+L0:
+    r0 = x.a
+    return r0
+def set_attr(x):
+    x :: __main__.C
+    r0 :: bool
+L0:
+    x.a = 2; r0 = is_error
+    return 1
+def tuple_get(x):
+    x :: tuple[int, int]
+    r0 :: int
+L0:
+    r0 = x[0]
+    return r0
+def tuple_set(x, xx):
+    x, xx :: int
+    r0 :: tuple[int, int]
+L0:
+    r0 = (x, xx)
+    return r0
+def call(x):
+    x, r0 :: int
+L0:
+    r0 = call(x)
+    return r0
+def method_call(c, x):
+    c :: __main__.C
+    x :: int
+    r0 :: None
+L0:
+    r0 = c.m(x)
+    return 1
+def cast_op(x):
+    x :: object
+    r0 :: str
+L0:
+    r0 = cast(str, x)
+    return r0
+def box(x):
+    x :: int
+    r0 :: object
+L0:
+    r0 = box(int, x)
+    return r0
+def unbox(x):
+    x :: object
+    r0 :: int
+L0:
+    r0 = unbox(int, x)
+    return r0
+def call_c(x):
+    x :: list
+    r0 :: str
+    r1 :: i32
+    r2 :: bit
+L0:
+    r0 = 'x'
+    r1 = PyList_Append(x, r0)
+    r2 = r1 >= 0 :: signed
+    return 1
+def keep_alive(x):
+    x :: __main__.C
+    r0, r1 :: int
+L0:
+    r0 = borrow x.a
+    r1 = CPyTagged_Add(r0, 2)
+    keep_alive x
+    return r1
+
+[case testIRTransformRegisterOps2]
+from mypy_extensions import i32, i64
+
+def truncate(x: i64) -> i32:
+    y = x
+    return i32(y)
+
+def extend(x: i32) -> i64:
+    y = x
+    return i64(y)
+
+def int_op(x: i64, xx: i64) -> i64:
+    y = x
+    z = xx
+    return y + z
+
+def comparison_op(x: i64, xx: i64) -> bool:
+    y = x
+    z = xx
+    return y == z
+
+def float_op(x: float, xx: float) -> float:
+    y = x
+    z = xx
+    return y + z
+
+def float_neg(x: float) -> float:
+    y = x
+    return -y
+
+def float_comparison_op(x: float, xx: float) -> bool:
+    y = x
+    z = xx
+    return y == z
+[out]
+def truncate(x):
+    x :: i64
+    r0 :: i32
+L0:
+    r0 = truncate x: i64 to i32
+    return r0
+def extend(x):
+    x :: i32
+    r0 :: i64
+L0:
+    r0 = extend signed x: i32 to i64
+    return r0
+def int_op(x, xx):
+    x, xx, r0 :: i64
+L0:
+    r0 = x + xx
+    return r0
+def comparison_op(x, xx):
+    x, xx :: i64
+    r0 :: bit
+L0:
+    r0 = x == xx
+    return r0
+def float_op(x, xx):
+    x, xx, r0 :: float
+L0:
+    r0 = x + xx
+    return r0
+def float_neg(x):
+    x, r0 :: float
+L0:
+    r0 = -x
+    return r0
+def float_comparison_op(x, xx):
+    x, xx :: float
+    r0 :: bit
+L0:
+    r0 = x == xx
+    return r0
+
+-- Note that transforms of these ops aren't tested here:
+-- * LoadMem
+-- * SetMem
+-- * GetElementPtr
+-- * LoadAddress
+-- * Unborrow
diff --git a/mypyc/test-data/opt-flag-elimination.test b/mypyc/test-data/opt-flag-elimination.test
new file mode 100644
index 000000000000..337ced70a355
--- /dev/null
+++ b/mypyc/test-data/opt-flag-elimination.test
@@ -0,0 +1,296 @@
+-- Test cases for "flag elimination" optimization.  Used to optimize away
+-- registers that are always used immediately after assignment as branch conditions.
+
+[case testFlagEliminationSimple]
+def c() -> bool:
+    return True
+def d() -> bool:
+    return True
+
+def f(x: bool) -> int:
+    if x:
+        b = c()
+    else:
+        b = d()
+    if b:
+        return 1
+    else:
+        return 2
+[out]
+def c():
+L0:
+    return 1
+def d():
+L0:
+    return 1
+def f(x):
+    x, r0, r1 :: bool
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    r0 = c()
+    if r0 goto L3 else goto L4 :: bool
+L2:
+    r1 = d()
+    if r1 goto L3 else goto L4 :: bool
+L3:
+    return 2
+L4:
+    return 4
+
+[case testFlagEliminationOneAssignment]
+def c() -> bool:
+    return True
+
+def f(x: bool) -> int:
+    # Not applied here
+    b = c()
+    if b:
+        return 1
+    else:
+        return 2
+[out]
+def c():
+L0:
+    return 1
+def f(x):
+    x, r0, b :: bool
+L0:
+    r0 = c()
+    b = r0
+    if b goto L1 else goto L2 :: bool
+L1:
+    return 2
+L2:
+    return 4
+
+[case testFlagEliminationThreeCases]
+def c(x: int) -> bool:
+    return True
+
+def f(x: bool, y: bool) -> int:
+    if x:
+        b = c(1)
+    elif y:
+        b = c(2)
+    else:
+        b = c(3)
+    if b:
+        return 1
+    else:
+        return 2
+[out]
+def c(x):
+    x :: int
+L0:
+    return 1
+def f(x, y):
+    x, y, r0, r1, r2 :: bool
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    r0 = c(2)
+    if r0 goto L5 else goto L6 :: bool
+L2:
+    if y goto L3 else goto L4 :: bool
+L3:
+    r1 = c(4)
+    if r1 goto L5 else goto L6 :: bool
+L4:
+    r2 = c(6)
+    if r2 goto L5 else goto L6 :: bool
+L5:
+    return 2
+L6:
+    return 4
+
+[case testFlagEliminationAssignmentNotLastOp]
+def f(x: bool) -> int:
+    y = 0
+    if x:
+        b = True
+        y = 1
+    else:
+        b = False
+    if b:
+        return 1
+    else:
+        return 2
+[out]
+def f(x):
+    x :: bool
+    y :: int
+    b :: bool
+L0:
+    y = 0
+    if x goto L1 else goto L2 :: bool
+L1:
+    b = 1
+    y = 2
+    goto L3
+L2:
+    b = 0
+L3:
+    if b goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+
+[case testFlagEliminationAssignmentNoDirectGoto]
+def f(x: bool) -> int:
+    if x:
+        b = True
+    else:
+        b = False
+    if x:
+        if b:
+            return 1
+        else:
+            return 2
+    return 4
+[out]
+def f(x):
+    x, b :: bool
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    b = 1
+    goto L3
+L2:
+    b = 0
+L3:
+    if x goto L4 else goto L7 :: bool
+L4:
+    if b goto L5 else goto L6 :: bool
+L5:
+    return 2
+L6:
+    return 4
+L7:
+    return 8
+
+[case testFlagEliminationBranchNotNextOpAfterGoto]
+def f(x: bool) -> int:
+    if x:
+        b = True
+    else:
+        b = False
+    y = 1  # Prevents the optimization
+    if b:
+        return 1
+    else:
+        return 2
+[out]
+def f(x):
+    x, b :: bool
+    y :: int
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    b = 1
+    goto L3
+L2:
+    b = 0
+L3:
+    y = 2
+    if b goto L4 else goto L5 :: bool
+L4:
+    return 2
+L5:
+    return 4
+
+[case testFlagEliminationFlagReadTwice]
+def f(x: bool) -> bool:
+    if x:
+        b = True
+    else:
+        b = False
+    if b:
+        return b  # Prevents the optimization
+    else:
+        return False
+[out]
+def f(x):
+    x, b :: bool
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    b = 1
+    goto L3
+L2:
+    b = 0
+L3:
+    if b goto L4 else goto L5 :: bool
+L4:
+    return b
+L5:
+    return 0
+
+[case testFlagEliminationArgumentNotEligible]
+def f(x: bool, b: bool) -> bool:
+    if x:
+        b = True
+    else:
+        b = False
+    if b:
+        return True
+    else:
+        return False
+[out]
+def f(x, b):
+    x, b :: bool
+L0:
+    if x goto L1 else goto L2 :: bool
+L1:
+    b = 1
+    goto L3
+L2:
+    b = 0
+L3:
+    if b goto L4 else goto L5 :: bool
+L4:
+    return 1
+L5:
+    return 0
+
+[case testFlagEliminationFlagNotAlwaysDefined]
+def f(x: bool, y: bool) -> bool:
+    if x:
+        b = True
+    elif y:
+        b = False
+    else:
+        bb = False  # b not assigned here -> can't optimize
+    if b:
+        return True
+    else:
+        return False
+[out]
+def f(x, y):
+    x, y, r0, b, bb, r1 :: bool
+L0:
+    r0 = <error> :: bool
+    b = r0
+    if x goto L1 else goto L2 :: bool
+L1:
+    b = 1
+    goto L5
+L2:
+    if y goto L3 else goto L4 :: bool
+L3:
+    b = 0
+    goto L5
+L4:
+    bb = 0
+L5:
+    if is_error(b) goto L6 else goto L7
+L6:
+    r1 = raise UnboundLocalError('local variable "b" referenced before assignment')
+    unreachable
+L7:
+    if b goto L8 else goto L9 :: bool
+L8:
+    return 1
+L9:
+    return 0
diff --git a/mypyc/test-data/refcount.test b/mypyc/test-data/refcount.test
index 372956a00cab..22153cff5a91 100644
--- a/mypyc/test-data/refcount.test
+++ b/mypyc/test-data/refcount.test
@@ -67,7 +67,7 @@ def f():
 L0:
     x = 2
     y = 4
-    r0 = x == 2
+    r0 = int_eq x, 2
     if r0 goto L3 else goto L4 :: bool
 L1:
     return x
@@ -185,34 +185,26 @@ def f(a: int) -> int:
 [out]
 def f(a):
     a :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    x, r4, y :: int
+    r0 :: bit
+    x, r1, y :: int
 L0:
-    r0 = a & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_eq a, a
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = CPyTagged_IsEq_(a, a)
-    if r2 goto L3 else goto L4 :: bool
-L2:
-    r3 = a == a
-    if r3 goto L3 else goto L4 :: bool
-L3:
     a = 2
-    goto L5
-L4:
+    goto L3
+L2:
     x = 4
     dec_ref x :: int
-    goto L6
-L5:
-    r4 = CPyTagged_Add(a, 2)
+    goto L4
+L3:
+    r1 = CPyTagged_Add(a, 2)
     dec_ref a :: int
-    y = r4
+    y = r1
     return y
-L6:
+L4:
     inc_ref a :: int
-    goto L5
+    goto L3
 
 [case testConditionalAssignToArgument2]
 def f(a: int) -> int:
@@ -225,33 +217,25 @@ def f(a: int) -> int:
 [out]
 def f(a):
     a :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    x, r4, y :: int
+    r0 :: bit
+    x, r1, y :: int
 L0:
-    r0 = a & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_eq a, a
+    if r0 goto L1 else goto L2 :: bool
 L1:
-    r2 = CPyTagged_IsEq_(a, a)
-    if r2 goto L3 else goto L4 :: bool
-L2:
-    r3 = a == a
-    if r3 goto L3 else goto L4 :: bool
-L3:
     x = 4
     dec_ref x :: int
-    goto L6
-L4:
+    goto L4
+L2:
     a = 2
-L5:
-    r4 = CPyTagged_Add(a, 2)
+L3:
+    r1 = CPyTagged_Add(a, 2)
     dec_ref a :: int
-    y = r4
+    y = r1
     return y
-L6:
+L4:
     inc_ref a :: int
-    goto L5
+    goto L3
 
 [case testConditionalAssignToArgument3]
 def f(a: int) -> int:
@@ -261,25 +245,17 @@ def f(a: int) -> int:
 [out]
 def f(a):
     a :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
+    r0 :: bit
 L0:
-    r0 = a & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_eq a, a
+    if r0 goto L1 else goto L3 :: bool
 L1:
-    r2 = CPyTagged_IsEq_(a, a)
-    if r2 goto L3 else goto L5 :: bool
-L2:
-    r3 = a == a
-    if r3 goto L3 else goto L5 :: bool
-L3:
     a = 2
-L4:
+L2:
     return a
-L5:
+L3:
     inc_ref a :: int
-    goto L4
+    goto L2
 
 [case testAssignRegisterToItself]
 def f(a: int) -> int:
@@ -438,40 +414,32 @@ def f() -> int:
 [out]
 def f():
     x, y, z :: int
-    r0 :: native_int
-    r1, r2, r3 :: bit
-    a, r4, r5 :: int
+    r0 :: bit
+    a, r1, r2 :: int
 L0:
     x = 2
     y = 4
     z = 6
-    r0 = z & 1
-    r1 = r0 != 0
-    if r1 goto L1 else goto L2 :: bool
+    r0 = int_eq z, z
+    if r0 goto L3 else goto L4 :: bool
 L1:
-    r2 = CPyTagged_IsEq_(z, z)
-    if r2 goto L5 else goto L6 :: bool
-L2:
-    r3 = z == z
-    if r3 goto L5 else goto L6 :: bool
-L3:
     return z
-L4:
+L2:
     a = 2
-    r4 = CPyTagged_Add(x, y)
+    r1 = CPyTagged_Add(x, y)
     dec_ref x :: int
     dec_ref y :: int
-    r5 = CPyTagged_Subtract(r4, a)
-    dec_ref r4 :: int
+    r2 = CPyTagged_Subtract(r1, a)
+    dec_ref r1 :: int
     dec_ref a :: int
-    return r5
-L5:
+    return r2
+L3:
     dec_ref x :: int
     dec_ref y :: int
-    goto L3
-L6:
+    goto L1
+L4:
     dec_ref z :: int
-    goto L4
+    goto L2
 
 [case testLoop]
 def f(a: int) -> int:
@@ -484,41 +452,27 @@ def f(a: int) -> int:
 [out]
 def f(a):
     a, sum, i :: int
-    r0 :: native_int
-    r1 :: bit
-    r2 :: native_int
-    r3, r4, r5 :: bit
-    r6, r7 :: int
+    r0 :: bit
+    r1, r2 :: int
 L0:
     sum = 0
     i = 0
 L1:
-    r0 = i & 1
-    r1 = r0 != 0
-    if r1 goto L3 else goto L2 :: bool
+    r0 = int_le i, a
+    if r0 goto L2 else goto L4 :: bool
 L2:
-    r2 = a & 1
-    r3 = r2 != 0
-    if r3 goto L3 else goto L4 :: bool
-L3:
-    r4 = CPyTagged_IsLt_(a, i)
-    if r4 goto L7 else goto L5 :: bool
-L4:
-    r5 = i <= a :: signed
-    if r5 goto L5 else goto L7 :: bool
-L5:
-    r6 = CPyTagged_Add(sum, i)
+    r1 = CPyTagged_Add(sum, i)
     dec_ref sum :: int
-    sum = r6
-    r7 = CPyTagged_Add(i, 2)
+    sum = r1
+    r2 = CPyTagged_Add(i, 2)
     dec_ref i :: int
-    i = r7
+    i = r2
     goto L1
-L6:
+L3:
     return sum
-L7:
+L4:
     dec_ref i :: int
-    goto L6
+    goto L3
 
 [case testCall]
 def f(a: int) -> int:
@@ -544,19 +498,17 @@ def f() -> int:
 def f():
     r0 :: list
     r1, r2 :: object
-    r3, r4, r5 :: ptr
+    r3 :: ptr
     a :: list
 L0:
     r0 = PyList_New(2)
     r1 = object 0
     r2 = object 1
-    r3 = get_element_ptr r0 ob_item :: PyListObject
-    r4 = load_mem r3 :: ptr*
+    r3 = list_items r0
     inc_ref r1
-    set_mem r4, r1 :: builtins.object*
-    r5 = r4 + WORD_SIZE*1
+    buf_init_item r3, 0, r1
     inc_ref r2
-    set_mem r5, r2 :: builtins.object*
+    buf_init_item r3, 1, r2
     a = r0
     dec_ref a
     return 0
@@ -623,21 +575,20 @@ def f() -> None:
 def f():
     r0 :: __main__.C
     r1 :: list
-    r2, r3 :: ptr
+    r2 :: ptr
     a :: list
-    r4 :: object
-    r5, d :: __main__.C
+    r3 :: object
+    r4, d :: __main__.C
 L0:
     r0 = C()
     r1 = PyList_New(1)
-    r2 = get_element_ptr r1 ob_item :: PyListObject
-    r3 = load_mem r2 :: ptr*
-    set_mem r3, r0 :: builtins.object*
+    r2 = list_items r1
+    buf_init_item r2, 0, r0
     a = r1
-    r4 = CPyList_GetItemShort(a, 0)
+    r3 = CPyList_GetItemShort(a, 0)
     dec_ref a
-    r5 = cast(__main__.C, r4)
-    d = r5
+    r4 = cast(__main__.C, r3)
+    d = r4
     dec_ref d
     return 1
 
@@ -656,6 +607,66 @@ L1:
 L2:
     return 4
 
+[case testReturnTuple]
+from typing import Tuple
+
+class C: pass
+def f() -> Tuple[C, C]:
+    a = C()
+    b = C()
+    return a, b
+[out]
+def f():
+    r0, a, r1, b :: __main__.C
+    r2 :: tuple[__main__.C, __main__.C]
+L0:
+    r0 = C()
+    a = r0
+    r1 = C()
+    b = r1
+    r2 = (a, b)
+    return r2
+
+[case testDecomposeTuple]
+from typing import Tuple
+
+class C:
+    a: int
+
+def f() -> int:
+    x, y = g()
+    return x.a + y.a
+
+def g() -> Tuple[C, C]:
+    return C(), C()
+[out]
+def f():
+    r0 :: tuple[__main__.C, __main__.C]
+    r1, r2, r3, x, r4, y :: __main__.C
+    r5, r6, r7 :: int
+L0:
+    r0 = g()
+    r1 = borrow r0[0]
+    r2 = borrow r0[1]
+    r3 = unborrow r1
+    x = r3
+    r4 = unborrow r2
+    y = r4
+    r5 = borrow x.a
+    r6 = borrow y.a
+    r7 = CPyTagged_Add(r5, r6)
+    dec_ref x
+    dec_ref y
+    return r7
+def g():
+    r0, r1 :: __main__.C
+    r2 :: tuple[__main__.C, __main__.C]
+L0:
+    r0 = C()
+    r1 = C()
+    r2 = (r0, r1)
+    return r2
+
 [case testUnicodeLiteral]
 def f() -> str:
     return "some string"
@@ -673,22 +684,18 @@ def g(x: str) -> int:
 [out]
 def g(x):
     x :: str
-    r0 :: object
-    r1 :: str
-    r2 :: tuple
-    r3 :: object
-    r4 :: dict
-    r5 :: object
+    r0, r1 :: object
+    r2 :: object[2]
+    r3 :: object_ptr
+    r4, r5 :: object
     r6 :: int
 L0:
     r0 = load_address PyLong_Type
-    r1 = 'base'
-    r2 = PyTuple_Pack(1, x)
-    r3 = object 2
-    r4 = CPyDict_Build(1, r1, r3)
-    r5 = PyObject_Call(r0, r2, r4)
-    dec_ref r2
-    dec_ref r4
+    r1 = object 2
+    r2 = [x, r1]
+    r3 = load_address r2
+    r4 = ('base',)
+    r5 = PyObject_Vectorcall(r0, r3, 1, r4)
     r6 = unbox(int, r5)
     dec_ref r5
     return r6
@@ -702,7 +709,7 @@ def f(a, x):
     a :: list
     x :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     inc_ref x :: int
@@ -760,7 +767,7 @@ L3:
     r12 = CPyDict_CheckSize(d, r2)
     goto L1
 L4:
-    r13 = CPy_NoErrOccured()
+    r13 = CPy_NoErrOccurred()
 L5:
     return 1
 L6:
@@ -793,6 +800,31 @@ L2:
 L3:
     return 1
 
+[case testTupleUnpackUnused]
+from typing import Tuple
+
+def f(x: Tuple[str, int]) -> int:
+    a, xi = x
+    return 0
+[out]
+def f(x):
+    x :: tuple[str, int]
+    r0 :: str
+    r1 :: int
+    r2, a :: str
+    r3, xi :: int
+L0:
+    r0 = borrow x[0]
+    r1 = borrow x[1]
+    inc_ref x
+    r2 = unborrow r0
+    a = r2
+    dec_ref a
+    r3 = unborrow r1
+    xi = r3
+    dec_ref xi :: int
+    return 0
+
 [case testGetElementPtrLifeTime]
 from typing import List
 
@@ -802,17 +834,15 @@ def f() -> int:
 [out]
 def f():
     r0, x :: list
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
+    r1 :: native_int
+    r2 :: short_int
 L0:
     r0 = PyList_New(0)
     x = r0
-    r1 = get_element_ptr x ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
+    r1 = var_object_size x
     dec_ref x
-    r3 = r2 << 1
-    return r3
+    r2 = r1 << 1
+    return r2
 
 [case testSometimesUninitializedVariable]
 def f(x: bool) -> int:
@@ -866,7 +896,7 @@ L11:
     xdec_ref y :: int
     goto L6
 
-[case testVectorcall_python3_8]
+[case testVectorcall]
 from typing import Any
 
 def call(f: Any, x: int) -> int:
@@ -885,13 +915,13 @@ L0:
     r0 = box(int, x)
     r1 = [r0]
     r2 = load_address r1
-    r3 = _PyObject_Vectorcall(f, r2, 1, 0)
+    r3 = PyObject_Vectorcall(f, r2, 1, 0)
     dec_ref r0
     r4 = unbox(int, r3)
     dec_ref r3
     return r4
 
-[case testVectorcallMethod_python3_9_64bit]
+[case testVectorcallMethod_64bit]
 from typing import Any
 
 def call(o: Any, x: int) -> int:
@@ -1053,15 +1083,13 @@ class C:
 def f(x):
     x :: __main__.C
     r0 :: list
-    r1 :: ptr
-    r2 :: native_int
-    r3 :: short_int
+    r1 :: native_int
+    r2 :: short_int
 L0:
     r0 = borrow x.a
-    r1 = get_element_ptr r0 ob_size :: PyVarObject
-    r2 = load_mem r1 :: native_int*
-    r3 = r2 << 1
-    return r3
+    r1 = var_object_size r0
+    r2 = r1 << 1
+    return r2
 
 [case testBorrowIsinstanceArgument]
 from typing import List
@@ -1242,23 +1270,22 @@ class C:
 def f():
     r0 :: __main__.C
     r1 :: list
-    r2, r3 :: ptr
+    r2 :: ptr
     a :: list
-    r4 :: object
-    r5 :: __main__.C
-    r6 :: str
+    r3 :: object
+    r4 :: __main__.C
+    r5 :: str
 L0:
     r0 = C()
     r1 = PyList_New(1)
-    r2 = get_element_ptr r1 ob_item :: PyListObject
-    r3 = load_mem r2 :: ptr*
-    set_mem r3, r0 :: builtins.object*
+    r2 = list_items r1
+    buf_init_item r2, 0, r0
     a = r1
-    r4 = CPyList_GetItemShortBorrow(a, 0)
-    r5 = borrow cast(__main__.C, r4)
-    r6 = r5.s
+    r3 = CPyList_GetItemShortBorrow(a, 0)
+    r4 = borrow cast(__main__.C, r3)
+    r5 = r4.s
     dec_ref a
-    return r6
+    return r5
 
 [case testBorrowSetAttrObject]
 from typing import Optional
@@ -1311,25 +1338,12 @@ class C:
 def add(c):
     c :: __main__.C
     r0, r1 :: int
-    r2 :: native_int
-    r3, r4 :: bit
-    r5 :: bool
-    r6 :: bit
+    r2 :: bit
 L0:
     r0 = borrow c.x
     r1 = borrow c.y
-    r2 = r0 & 1
-    r3 = r2 == 0
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = r0 == r1
-    r5 = r4
-    goto L3
-L2:
-    r6 = CPyTagged_IsEq_(r0, r1)
-    r5 = r6
-L3:
-    return r5
+    r2 = int_eq r0, r1
+    return r2
 
 [case testBorrowIntLessThan]
 def add(c: C) -> bool:
@@ -1342,33 +1356,15 @@ class C:
 def add(c):
     c :: __main__.C
     r0, r1 :: int
-    r2 :: native_int
-    r3 :: bit
-    r4 :: native_int
-    r5, r6, r7 :: bit
-    r8 :: bool
-    r9 :: bit
+    r2 :: bit
 L0:
     r0 = borrow c.x
     r1 = borrow c.y
-    r2 = r0 & 1
-    r3 = r2 == 0
-    r4 = r1 & 1
-    r5 = r4 == 0
-    r6 = r3 & r5
-    if r6 goto L1 else goto L2 :: bool
-L1:
-    r7 = r0 < r1 :: signed
-    r8 = r7
-    goto L3
-L2:
-    r9 = CPyTagged_IsLt_(r0, r1)
-    r8 = r9
-L3:
-    return r8
+    r2 = int_lt r0, r1
+    return r2
 
 [case testBorrowIntCompareFinal]
-from typing_extensions import Final
+from typing import Final
 
 X: Final = 10
 
@@ -1381,24 +1377,11 @@ class C:
 def add(c):
     c :: __main__.C
     r0 :: int
-    r1 :: native_int
-    r2, r3 :: bit
-    r4 :: bool
-    r5 :: bit
+    r1 :: bit
 L0:
     r0 = borrow c.x
-    r1 = r0 & 1
-    r2 = r1 == 0
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    r3 = r0 == 20
-    r4 = r3
-    goto L3
-L2:
-    r5 = CPyTagged_IsEq_(r0, 20)
-    r4 = r5
-L3:
-    return r4
+    r1 = int_eq r0, 20
+    return r1
 
 [case testBorrowIntArithmetic]
 def add(c: C) -> int:
@@ -1441,23 +1424,15 @@ class C:
 def add(c, n):
     c :: __main__.C
     n, r0, r1 :: int
-    r2 :: native_int
-    r3, r4, r5 :: bit
+    r2 :: bit
 L0:
     r0 = borrow c.x
     r1 = borrow c.y
-    r2 = r0 & 1
-    r3 = r2 != 0
-    if r3 goto L1 else goto L2 :: bool
+    r2 = int_eq r0, r1
+    if r2 goto L1 else goto L2 :: bool
 L1:
-    r4 = CPyTagged_IsEq_(r0, r1)
-    if r4 goto L3 else goto L4 :: bool
-L2:
-    r5 = r0 == r1
-    if r5 goto L3 else goto L4 :: bool
-L3:
     return 1
-L4:
+L2:
     return 0
 
 [case testBorrowIntInPlaceOp]
@@ -1504,10 +1479,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-async.test b/mypyc/test-data/run-async.test
index 85ad172d61df..58b690a944af 100644
--- a/mypyc/test-data/run-async.test
+++ b/mypyc/test-data/run-async.test
@@ -1,8 +1,10 @@
 # async test cases (compile and run)
 
-[case testAsync]
+[case testRunAsyncBasics]
 import asyncio
 
+from testutil import assertRaises
+
 async def h() -> int:
     return 1
 
@@ -11,19 +13,164 @@ async def g() -> int:
     return await h()
 
 async def f() -> int:
-    return await g()
+    return await g() + 2
+
+async def f2() -> int:
+    x = 0
+    for i in range(2):
+        x += i + await f() + await g()
+    return x
+
+def test_simple_call() -> None:
+    result = asyncio.run(f())
+    assert result == 3
+
+def test_multiple_awaits_in_expression() -> None:
+    result = asyncio.run(f2())
+    assert result == 9
+
+class MyError(Exception):
+    pass
+
+async def exc1() -> None:
+    await asyncio.sleep(0)
+    raise MyError()
+
+async def exc2() -> None:
+    await asyncio.sleep(0)
+    raise MyError()
+
+async def exc3() -> None:
+    await exc1()
+
+async def exc4() -> None:
+    await exc2()
+
+async def exc5() -> int:
+    try:
+        await exc1()
+    except MyError:
+        return 3
+    return 4
+
+async def exc6() -> int:
+    try:
+        await exc4()
+    except MyError:
+        return 3
+    return 4
+
+def test_exception() -> None:
+    with assertRaises(MyError):
+        asyncio.run(exc1())
+    with assertRaises(MyError):
+        asyncio.run(exc2())
+    with assertRaises(MyError):
+        asyncio.run(exc3())
+    with assertRaises(MyError):
+        asyncio.run(exc4())
+    assert asyncio.run(exc5()) == 3
+    assert asyncio.run(exc6()) == 3
 
 [file asyncio/__init__.pyi]
 async def sleep(t: float) -> None: ...
+# eh, we could use the real type but it doesn't seem important
+def run(x: object) -> object: ...
 
 [typing fixtures/typing-full.pyi]
 
-[file driver.py]
-from native import f
+[case testRunAsyncAwaitInVariousPositions]
+from typing import cast, Any
+
 import asyncio
 
-result = asyncio.run(f())
-assert result == 1
+async def one() -> int:
+    await asyncio.sleep(0.0)
+    return int() + 1
+
+async def true() -> bool:
+    return bool(int() + await one())
+
+async def branch_await() -> int:
+    if bool(int() + 1) == await true():
+        return 3
+    return 2
+
+async def branch_await_not() -> int:
+    if bool(int() + 1) == (not await true()):
+        return 3
+    return 2
+
+def test_branch() -> None:
+    assert asyncio.run(branch_await()) == 3
+    assert asyncio.run(branch_await_not()) == 2
+
+async def assign_multi() -> int:
+    _, x = int(), await one()
+    return x + 1
+
+def test_assign_multi() -> None:
+    assert asyncio.run(assign_multi()) == 2
+
+class C:
+    def __init__(self, s: str) -> None:
+        self.s = s
+
+    def concat(self, s: str) -> str:
+        return self.s + s
+
+async def make_c(s: str) -> C:
+    await one()
+    return C(s)
+
+async def concat(s: str, t: str) -> str:
+    await one()
+    return s + t
+
+async def set_attr(s: str) -> None:
+    (await make_c("xyz")).s = await concat(s, "!")
+
+def test_set_attr() -> None:
+    asyncio.run(set_attr("foo"))  # Just check that it compiles and runs
+
+def concat2(x: str, y: str) -> str:
+    return x + y
+
+async def call1(s: str) -> str:
+    return concat2(str(int()), await concat(s, "a"))
+
+async def call2(s: str) -> str:
+    return await concat(str(int()), await concat(s, "b"))
+
+def test_call() -> None:
+    assert asyncio.run(call1("foo")) == "0fooa"
+    assert asyncio.run(call2("foo")) == "0foob"
+
+async def method_call(s: str) -> str:
+    return C("<").concat(await concat(s, ">"))
+
+def test_method_call() -> None:
+    assert asyncio.run(method_call("foo")) == "<foo>"
+
+class D:
+    def __init__(self, a: str, b: str) -> None:
+        self.a = a
+        self.b = b
+
+async def construct(s: str) -> str:
+    c = D(await concat(s, "!"), await concat(s, "?"))
+    return c.a + c.b
+
+def test_construct() -> None:
+    assert asyncio.run(construct("foo")) == "foo!foo?"
+
+[file asyncio/__init__.pyi]
+async def sleep(t: float) -> None: ...
+# eh, we could use the real type but it doesn't seem important
+def run(x: object) -> object: ...
+
+[typing fixtures/typing-full.pyi]
+
 
 [case testAsyncWith]
 from testutil import async_val
@@ -68,7 +215,6 @@ yields, val = run_generator(async_return())
 assert yields == ('foo',)
 assert val == 'test', val
 
-
 [case testAsyncFor]
 from typing import AsyncIterable, List, Set, Dict
 
@@ -143,3 +289,275 @@ async def foo() -> AsyncIterable[int]:
 yields, val = run_generator(async_iter(foo()))
 assert yields == (0,1,2), yields
 assert val == 'lol no', val
+
+[case testAsyncWithVarReuse]
+class ConMan:
+    async def __aenter__(self) -> int:
+        return 1
+    async def __aexit__(self, *exc: object):
+        pass
+
+class ConManB:
+    async def __aenter__(self) -> int:
+        return 2
+    async def __aexit__(self, *exc: object):
+        pass
+
+async def x() -> None:
+    value = 2
+    async with ConMan() as f:
+        value += f
+    assert value == 3, value
+    async with ConManB() as f:
+        value += f
+    assert value == 5, value
+
+[typing fixtures/typing-full.pyi]
+[file driver.py]
+import asyncio
+import native
+asyncio.run(native.x())
+
+[case testRunAsyncSpecialCases]
+import asyncio
+
+async def t() -> tuple[int, str, str]:
+    return (1, "x", "y")
+
+async def f() -> tuple[int, str, str]:
+    return await t()
+
+def test_tuple_return() -> None:
+    result = asyncio.run(f())
+    assert result == (1, "x", "y")
+
+async def e() -> ValueError:
+    return ValueError("foo")
+
+async def g() -> ValueError:
+    return await e()
+
+def test_exception_return() -> None:
+    result = asyncio.run(g())
+    assert isinstance(result, ValueError)
+
+[file asyncio/__init__.pyi]
+async def sleep(t: float) -> None: ...
+# eh, we could use the real type but it doesn't seem important
+def run(x: object) -> object: ...
+
+[typing fixtures/typing-full.pyi]
+
+[case testRunAsyncRefCounting]
+import asyncio
+import gc
+
+def assert_no_leaks(fn, max_new):
+    # Warm-up, in case asyncio allocates something on first use
+    asyncio.run(fn())
+
+    gc.collect()
+    old_objs = gc.get_objects()
+
+    for i in range(10):
+        asyncio.run(fn())
+
+    gc.collect()
+    new_objs = gc.get_objects()
+
+    delta = len(new_objs) - len(old_objs)
+    # Often a few persistent objects get allocated, which may be unavoidable.
+    # The main thing we care about is that each iteration does not leak an
+    # additional object.
+    assert delta <= max_new, delta
+
+async def concat_one(x: str) -> str:
+    return x + "1"
+
+async def foo(n: int) -> str:
+    s = ""
+    while len(s) < n:
+        s = await concat_one(s)
+    return s
+
+def test_trivial() -> None:
+    assert_no_leaks(lambda: foo(1000), 5)
+
+async def make_list(a: list[int]) -> list[int]:
+    await concat_one("foobar")
+    return [a[0]]
+
+async def spill() -> list[int]:
+    a: list[int] = []
+    for i in range(5):
+        await asyncio.sleep(0.0001)
+        a = (await make_list(a + [1])) + a + (await make_list(a + [2]))
+    return a
+
+async def bar(n: int) -> None:
+    for i in range(n):
+        await spill()
+
+def test_spilled() -> None:
+    assert_no_leaks(lambda: bar(40), 2)
+
+async def raise_deep(n: int) -> str:
+    if n == 0:
+        await asyncio.sleep(0.0001)
+        raise TypeError(str(n))
+    else:
+        if n == 2:
+            await asyncio.sleep(0.0001)
+        return await raise_deep(n - 1)
+
+async def maybe_raise(n: int) -> str:
+    if n % 3 == 0:
+        await raise_deep(5)
+    elif n % 29 == 0:
+        await asyncio.sleep(0.0001)
+    return str(n)
+
+async def exc(n: int) -> list[str]:
+    a = []
+    for i in range(n):
+        try:
+            a.append(str(int()) + await maybe_raise(n))
+        except TypeError:
+            a.append(str(int() + 5))
+    return a
+
+def test_exception() -> None:
+    assert_no_leaks(lambda: exc(50), 2)
+
+class C:
+    def __init__(self, s: str) -> None:
+        self.s = s
+
+async def id(c: C) -> C:
+    return c
+
+async def stolen_helper(c: C, s: str) -> str:
+    await asyncio.sleep(0.0001)
+    (await id(c)).s = await concat_one(s)
+    await asyncio.sleep(0.0001)
+    return c.s
+
+async def stolen(n: int) -> int:
+    for i in range(n):
+        c = C(str(i))
+        s = await stolen_helper(c, str(i + 2))
+        assert s == str(i + 2) + "1"
+    return n
+
+def test_stolen() -> None:
+    assert_no_leaks(lambda: stolen(100), 2)
+
+[file asyncio/__init__.pyi]
+def run(x: object) -> object: ...
+async def sleep(t: float) -> None: ...
+
+[case testRunAsyncMiscTypesInEnvironment]
+# Here we test that values of various kinds of types can be spilled to the
+# environment. In particular, types with "overlapping error values" such as
+# i64 can be tricky, since they require extra work to support undefined
+# attribute values (which raise AttributeError when accessed). For these,
+# the object struct has a bitfield which keeps track of whether certain
+# attributes have an assigned value.
+#
+# In practice we mark these attributes as "always defined", which causes these
+# checks to be skipped on attribute access, and thus we don't require the
+# bitfield to exist.
+#
+# See the comment of RType.error_overlap for more information.
+
+import asyncio
+
+from mypy_extensions import i64, i32, i16, u8
+
+async def inc_float(x: float) -> float:
+    return x + 1.0
+
+async def inc_i64(x: i64) -> i64:
+    return x + 1
+
+async def inc_i32(x: i32) -> i32:
+    return x + 1
+
+async def inc_i16(x: i16) -> i16:
+    return x + 1
+
+async def inc_u8(x: u8) -> u8:
+    return x + 1
+
+async def inc_tuple(x: tuple[i64, float]) -> tuple[i64, float]:
+    return x[0] + 1, x[1] + 1.5
+
+async def neg_bool(b: bool) -> bool:
+    return not b
+
+async def float_ops(x: float) -> float:
+    n = x
+    n = await inc_float(n)
+    n = float("0.5") + await inc_float(n)
+    return n
+
+def test_float() -> None:
+    assert asyncio.run(float_ops(2.5)) == 5.0
+
+async def i64_ops(x: i64) -> i64:
+    n = x
+    n = await inc_i64(n)
+    n = i64("1") + await inc_i64(n)
+    return n
+
+def test_i64() -> None:
+    assert asyncio.run(i64_ops(2)) == 5
+
+async def i32_ops(x: i32) -> i32:
+    n = x
+    n = await inc_i32(n)
+    n = i32("1") + await inc_i32(n)
+    return n
+
+def test_i32() -> None:
+    assert asyncio.run(i32_ops(3)) == 6
+
+async def i16_ops(x: i16) -> i16:
+    n = x
+    n = await inc_i16(n)
+    n = i16("1") + await inc_i16(n)
+    return n
+
+def test_i16() -> None:
+    assert asyncio.run(i16_ops(4)) == 7
+
+async def u8_ops(x: u8) -> u8:
+    n = x
+    n = await inc_u8(n)
+    n = u8("1") + await inc_u8(n)
+    return n
+
+def test_u8() -> None:
+    assert asyncio.run(u8_ops(5)) == 8
+
+async def tuple_ops(x: tuple[i64, float]) -> tuple[i64, float]:
+    n = x
+    n = await inc_tuple(n)
+    m = ((i64("1"), float("0.5")), await inc_tuple(n))
+    return m[1]
+
+def test_tuple() -> None:
+    assert asyncio.run(tuple_ops((1, 2.5))) == (3, 5.5)
+
+async def bool_ops(x: bool) -> bool:
+    n = x
+    n = await neg_bool(n)
+    m = (bool("1"), await neg_bool(n))
+    return m[0] and m[1]
+
+def test_bool() -> None:
+    assert asyncio.run(bool_ops(True)) is True
+    assert asyncio.run(bool_ops(False)) is False
+
+[file asyncio/__init__.pyi]
+def run(x: object) -> object: ...
diff --git a/mypyc/test-data/run-bools.test b/mypyc/test-data/run-bools.test
index d7a2aa37ade7..a0b8ea31ebc0 100644
--- a/mypyc/test-data/run-bools.test
+++ b/mypyc/test-data/run-bools.test
@@ -31,7 +31,7 @@ def test_if() -> None:
     assert f(False) is True
 
 def test_bitwise_and() -> None:
-    # Use eval() to avoid constand folding
+    # Use eval() to avoid constant folding
     t: bool = eval('True')
     f: bool = eval('False')
     assert t & t == True
@@ -44,7 +44,7 @@ def test_bitwise_and() -> None:
     assert t == False
 
 def test_bitwise_or() -> None:
-    # Use eval() to avoid constand folding
+    # Use eval() to avoid constant folding
     t: bool = eval('True')
     f: bool = eval('False')
     assert t | t == True
@@ -57,7 +57,7 @@ def test_bitwise_or() -> None:
     assert f == True
 
 def test_bitwise_xor() -> None:
-    # Use eval() to avoid constand folding
+    # Use eval() to avoid constant folding
     t: bool = eval('True')
     f: bool = eval('False')
     assert t ^ t == False
diff --git a/mypyc/test-data/run-bytes.test b/mypyc/test-data/run-bytes.test
index aaf541194ac6..fa63c46a6798 100644
--- a/mypyc/test-data/run-bytes.test
+++ b/mypyc/test-data/run-bytes.test
@@ -111,6 +111,29 @@ def test_len() -> None:
     assert len(b) == 3
     assert len(bytes()) == 0
 
+def test_ord() -> None:
+    assert ord(b'a') == ord('a')
+    assert ord(b'a' + bytes()) == ord('a')
+    assert ord(b'\x00') == 0
+    assert ord(b'\x00' + bytes()) == 0
+    assert ord(b'\xfe') == 254
+    assert ord(b'\xfe' + bytes()) == 254
+
+    with assertRaises(TypeError):
+        ord(b'aa')
+    with assertRaises(TypeError):
+        ord(b'')
+
+def test_ord_bytesarray() -> None:
+    assert ord(bytearray(b'a')) == ord('a')
+    assert ord(bytearray(b'\x00')) == 0
+    assert ord(bytearray(b'\xfe')) == 254
+
+    with assertRaises(TypeError):
+        ord(bytearray(b'aa'))
+    with assertRaises(TypeError):
+        ord(bytearray(b''))
+
 [case testBytesSlicing]
 def test_bytes_slicing() -> None:
     b = b'abcdefg'
diff --git a/mypyc/test-data/run-classes.test b/mypyc/test-data/run-classes.test
index 268e07f6bde4..97bc063dd8ea 100644
--- a/mypyc/test-data/run-classes.test
+++ b/mypyc/test-data/run-classes.test
@@ -3,8 +3,13 @@ class Empty: pass
 
 def f(e: Empty) -> Empty:
     return e
+
+class EmptyEllipsis: ...
+
+def g(e: EmptyEllipsis) -> EmptyEllipsis:
+    return e
 [file driver.py]
-from native import Empty, f
+from native import Empty, EmptyEllipsis, f, g
 
 print(isinstance(Empty, type))
 print(Empty)
@@ -12,11 +17,22 @@ print(str(Empty())[:20])
 
 e = Empty()
 print(f(e) is e)
+
+print(isinstance(EmptyEllipsis, type))
+print(EmptyEllipsis)
+print(str(EmptyEllipsis())[:28])
+
+e2 = EmptyEllipsis()
+print(g(e2) is e2)
 [out]
 True
 <class 'native.Empty'>
 <native.Empty object
 True
+True
+<class 'native.EmptyEllipsis'>
+<native.EmptyEllipsis object
+True
 
 [case testClassWithFields]
 class C:
@@ -60,6 +76,25 @@ assert hasattr(c, 'x')
 1000000000000000000000000000001
 1000000000000000000000000000002
 
+[case testTypedDictWithFields]
+import collections
+import json
+from typing import TypedDict
+class C(TypedDict):
+    x: collections.deque
+    spam: json.JSONDecoder
+[file driver.py]
+from native import C
+from collections import deque
+from json import JSONDecoder
+
+print(C.__annotations__["x"] is deque)
+print(C.__annotations__["spam"] is JSONDecoder)
+[typing fixtures/typing-full.pyi]
+[out]
+True
+True
+
 [case testClassWithDeletableAttributes]
 from typing import Any, cast
 from testutil import assertRaises
@@ -254,8 +289,8 @@ from enum import Enum
 
 class TestEnum(Enum):
     _order_ = "a b"
-    a : int = 1
-    b : int = 2
+    a = 1
+    b = 2
 
     @classmethod
     def test(cls) -> int:
@@ -438,6 +473,25 @@ a = A(10)
 assert a.foo() == 11
 assert foo() == 21
 
+[case testClassKwargs]
+class X:
+    def __init__(self, msg: str, **variables: int) -> None:
+         self.msg = msg
+         self.variables = variables
+
+[file driver.py]
+import traceback
+from native import X
+x = X('hello', a=0, b=1)
+assert x.msg == 'hello'
+assert x.variables == {'a': 0, 'b': 1}
+try:
+    X('hello', msg='hello')
+except TypeError as e:
+    print(f"{type(e).__name__}: {e}")
+[out]
+TypeError: argument for __init__() given by name ('msg') and position (1)
+
 [case testGenericClass]
 from typing import TypeVar, Generic, Sequence
 T = TypeVar('T')
@@ -662,8 +716,7 @@ Traceback (most recent call last):
 AttributeError: attribute 'x' of 'X' undefined
 
 [case testClassMethods]
-from typing import ClassVar, Any
-from typing_extensions import final
+from typing import ClassVar, Any, final
 from mypy_extensions import mypyc_attr
 
 from interp import make_interpreted_subclass
@@ -1020,7 +1073,7 @@ assert b.z is None
 assert not hasattr(b, 'bogus')
 
 [case testProtocol]
-from typing_extensions import Protocol
+from typing import Protocol
 
 class Proto(Protocol):
     def foo(self, x: int) -> None:
@@ -1370,9 +1423,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 +1433,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 +1441,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
@@ -2505,7 +2547,7 @@ class Derived(Base):
 assert Derived()() == 1
 
 [case testClassWithFinalAttribute]
-from typing_extensions import Final
+from typing import Final
 
 class C:
     A: Final = -1
@@ -2514,3 +2556,409 @@ class C:
 def test_final_attribute() -> None:
     assert C.A == -1
     assert C.a == [-1]
+
+[case testClassWithFinalDecorator]
+from typing import final
+
+@final
+class C:
+    def a(self) -> int:
+        return 1
+
+def test_class_final_attribute() -> None:
+    assert C().a() == 1
+
+
+[case testClassWithFinalDecoratorCtor]
+from typing import final
+
+@final
+class C:
+    def __init__(self) -> None:
+        self.a = 1
+
+    def b(self) -> int:
+        return 2
+
+    @property
+    def c(self) -> int:
+        return 3
+
+def test_class_final_attribute() -> None:
+    assert C().a == 1
+    assert C().b() == 2
+    assert C().c == 3
+
+[case testClassWithFinalDecoratorInheritedWithProperties]
+from typing import final
+
+class B:
+    def a(self) -> int:
+        return 2
+
+    @property
+    def b(self) -> int:
+        return self.a() + 2
+
+    @property
+    def c(self) -> int:
+        return 3
+
+def test_class_final_attribute_basic() -> None:
+    assert B().a() == 2
+    assert B().b == 4
+    assert B().c == 3
+
+@final
+class C(B):
+    def a(self) -> int:
+        return 1
+
+    @property
+    def b(self) -> int:
+        return self.a() + 1
+
+def fn(cl: B) -> int:
+    return cl.a()
+
+def test_class_final_attribute_inherited() -> None:
+    assert C().a() == 1
+    assert fn(C()) == 1
+    assert B().a() == 2
+    assert fn(B()) == 2
+
+    assert B().b == 4
+    assert C().b == 2
+    assert B().c == 3
+    assert C().c == 3
+
+[case testClassWithFinalAttributeAccess]
+from typing import Final
+
+class C:
+    a: Final = {'x': 'y'}
+    b: Final = C.a
+
+def test_final_attribute() -> None:
+    assert C.a['x'] == 'y'
+    assert C.b['x'] == 'y'
+    assert C.a is C.b
+
+[case testClassDerivedFromIntEnum]
+from enum import IntEnum, auto
+
+class Player(IntEnum):
+    MIN = auto()
+
+print(f'{Player.MIN = }')
+[file driver.py]
+from native import Player
+[out]
+Player.MIN = <Player.MIN: 1>
+
+[case testStaticCallsWithUnpackingArgs]
+from typing import Tuple
+
+class Foo:
+  @staticmethod
+  def static(a: int, b: int, c: int) -> Tuple[int, int, int]:
+    return (c+1, a+2, b+3)
+
+  @classmethod
+  def clsmethod(cls, a: int, b: int, c: int) -> Tuple[int, int, int]:
+    return (c+1, a+2, b+3)
+
+
+print(Foo.static(*[10, 20, 30]))
+print(Foo.static(*(40, 50), *[60]))
+assert Foo.static(70, 80, *[90]) == Foo.clsmethod(70, *(80, 90))
+
+[file driver.py]
+import native
+
+[out]
+(31, 12, 23)
+(61, 42, 53)
+
+[case testDataclassInitVar]
+import dataclasses
+
+@dataclasses.dataclass
+class C:
+    init_v: dataclasses.InitVar[int]
+    v: float = dataclasses.field(init=False)
+
+    def __post_init__(self, init_v):
+        self.v = init_v + 0.1
+
+[file driver.py]
+import native
+print(native.C(22).v)
+
+[out]
+22.1
+
+[case testLastParentEnum]
+from enum import Enum
+
+class ColorCode(str, Enum):
+    OKGREEN = "okgreen"
+
+[file driver.py]
+import native
+print(native.ColorCode.OKGREEN.value)
+
+[out]
+okgreen
+
+[case testAttrWithSlots]
+import attr
+
+@attr.s(slots=True)
+class A:
+    ints: list[int] = attr.ib()
+
+[file driver.py]
+import native
+print(native.A(ints=[1, -17]).ints)
+
+[out]
+\[1, -17]
+
+[case testDataclassClassReference]
+from __future__ import annotations
+from dataclasses import dataclass
+
+class BackwardDefinedClass:
+    pass
+
+@dataclass
+class Data:
+    bitem: BackwardDefinedClass
+    bitems: 'BackwardDefinedClass'
+    fitem: ForwardDefinedClass
+    fitems: 'ForwardDefinedClass'
+
+class ForwardDefinedClass:
+    pass
+
+def test_function():
+    d = Data(
+        bitem=BackwardDefinedClass(),
+        bitems=BackwardDefinedClass(),
+        fitem=ForwardDefinedClass(),
+        fitems=ForwardDefinedClass(),
+    )
+    assert(isinstance(d.bitem, BackwardDefinedClass))
+    assert(isinstance(d.bitems, BackwardDefinedClass))
+    assert(isinstance(d.fitem, ForwardDefinedClass))
+    assert(isinstance(d.fitems, ForwardDefinedClass))
+
+[case testDel]
+class A:
+    def __del__(self):
+        print("deleting A...")
+
+class B:
+    def __del__(self):
+        print("deleting B...")
+
+class C(B):
+    def __init__(self):
+        self.a = A()
+
+    def __del__(self):
+        print("deleting C...")
+        super().__del__()
+
+class D(A):
+    pass
+
+[file driver.py]
+import native
+native.C()
+native.D()
+
+[out]
+deleting C...
+deleting B...
+deleting A...
+deleting A...
+
+[case testDelCircular]
+import dataclasses
+import typing
+
+i: int = 1
+
+@dataclasses.dataclass
+class C:
+    var: typing.Optional["C"] = dataclasses.field(default=None)
+
+    def __del__(self):
+        global i
+        print(f"deleting C{i}...")
+        i = i + 1
+
+[file driver.py]
+import native
+import gc
+
+c1 = native.C()
+c2 = native.C()
+c1.var = c2
+c2.var = c1
+del c1
+del c2
+gc.collect()
+
+[out]
+deleting C1...
+deleting C2...
+
+[case testDelException]
+# The error message in the expected output of this test does not match CPython's error message due to the way mypyc compiles Python classes. If the error message is fixed, the expected output of this test will also change.
+class F:
+    def __del__(self):
+        if True:
+            raise Exception("e2")
+
+[file driver.py]
+import native
+f = native.F()
+del f
+
+[out]
+Exception ignored in: <slot wrapper '__del__' of 'F' objects>
+Traceback (most recent call last):
+  File "native.py", line 5, in __del__
+    raise Exception("e2")
+Exception: e2
+
+[case testMypycAttrNativeClass]
+from mypy_extensions import mypyc_attr
+from testutil import assertRaises
+
+@mypyc_attr(native_class=False)
+class AnnontatedNonExtensionClass:
+    pass
+
+class DerivedClass(AnnontatedNonExtensionClass):
+    pass
+
+class ImplicitExtensionClass():
+    pass
+
+@mypyc_attr(native_class=True)
+class AnnotatedExtensionClass():
+    pass
+
+def test_function():
+    setattr(AnnontatedNonExtensionClass, 'attr_class', 5)
+    assert(hasattr(AnnontatedNonExtensionClass, 'attr_class') == True)
+    assert(getattr(AnnontatedNonExtensionClass, 'attr_class') == 5)
+    delattr(AnnontatedNonExtensionClass, 'attr_class')
+    assert(hasattr(AnnontatedNonExtensionClass, 'attr_class') == False)
+
+    inst = AnnontatedNonExtensionClass()
+    setattr(inst, 'attr_instance', 6)
+    assert(hasattr(inst, 'attr_instance') == True)
+    assert(getattr(inst, 'attr_instance') == 6)
+    delattr(inst, 'attr_instance')
+    assert(hasattr(inst, 'attr_instance') == False)
+
+    setattr(DerivedClass, 'attr_class', 5)
+    assert(hasattr(DerivedClass, 'attr_class') == True)
+    assert(getattr(DerivedClass, 'attr_class') == 5)
+    delattr(DerivedClass, 'attr_class')
+    assert(hasattr(DerivedClass, 'attr_class') == False)
+
+    derived_inst = DerivedClass()
+    setattr(derived_inst, 'attr_instance', 6)
+    assert(hasattr(derived_inst, 'attr_instance') == True)
+    assert(getattr(derived_inst, 'attr_instance') == 6)
+    delattr(derived_inst, 'attr_instance')
+    assert(hasattr(derived_inst, 'attr_instance') == False)
+
+    ext_inst = ImplicitExtensionClass()
+    with assertRaises(AttributeError):
+        setattr(ext_inst, 'attr_instance', 6)
+
+    explicit_ext_inst = AnnotatedExtensionClass()
+    with assertRaises(AttributeError):
+        setattr(explicit_ext_inst, 'attr_instance', 6)
+
+[case testMypycAttrNativeClassDunder]
+from mypy_extensions import mypyc_attr
+from typing import Generic, Optional, TypeVar
+
+_T = TypeVar("_T")
+
+get_count = set_count = del_count = 0
+
+@mypyc_attr(native_class=False)
+class Bar(Generic[_T]):
+    # Note the lack of __deletable__
+    def __init__(self) -> None:
+        self.value: str = 'start'
+    def __get__(self, instance: _T, owner: Optional[type[_T]] = None) -> str:
+        global get_count
+        get_count += 1
+        return self.value
+    def __set__(self, instance: _T, value: str) -> None:
+        global set_count
+        set_count += 1
+        self.value = value
+    def __delete__(self, instance: _T) -> None:
+        global del_count
+        del_count += 1
+        del self.value
+
+@mypyc_attr(native_class=False)
+class Foo(object):
+    bar: Bar = Bar()
+
+[file driver.py]
+import native
+
+f = native.Foo()
+assert(hasattr(f, 'bar'))
+assert(native.get_count == 1)
+assert(f.bar == 'start')
+assert(native.get_count == 2)
+f.bar = 'test'
+assert(f.bar == 'test')
+assert(native.set_count == 1)
+del f.bar
+assert(not hasattr(f, 'bar'))
+assert(native.del_count == 1)
+
+[case testMypycAttrNativeClassMeta]
+from mypy_extensions import mypyc_attr
+from typing import ClassVar, TypeVar
+
+_T = TypeVar("_T")
+
+@mypyc_attr(native_class=False)
+class M(type):
+    count: ClassVar[int] = 0
+    def make(cls: type[_T]) -> _T:
+        M.count += 1
+        return cls()
+
+# implicit native_class=False
+# see testMypycAttrNativeClassMetaError for when trying to set it True
+class A(metaclass=M):
+    pass
+
+[file driver.py]
+import native
+
+a: native.A = native.A.make()
+assert(native.A.count == 1)
+
+class B(native.A):
+    pass
+
+b: B = B.make()
+assert(B.count == 2)
diff --git a/mypyc/test-data/run-dicts.test b/mypyc/test-data/run-dicts.test
index 58b862e3f303..2a3be188ad00 100644
--- a/mypyc/test-data/run-dicts.test
+++ b/mypyc/test-data/run-dicts.test
@@ -95,8 +95,7 @@ assert get_content_set(od) == ({1, 3}, {2, 4}, {(1, 2), (3, 4)})
 [typing fixtures/typing-full.pyi]
 
 [case testDictIterationMethodsRun]
-from typing import Dict, Union
-from typing_extensions import TypedDict
+from typing import Dict, TypedDict, Union
 
 class ExtensionDict(TypedDict):
     python: str
@@ -157,7 +156,11 @@ else:
 try:
     clear_during_iter(d)
 except RuntimeError as e:
-    assert str(e) == "OrderedDict changed size during iteration"
+    assert str(e) in (
+        "OrderedDict changed size during iteration",
+        # Error message changed in Python 3.13 and some 3.12 patch version
+        "OrderedDict mutated during iteration",
+    )
 else:
     assert False
 
@@ -184,6 +187,7 @@ except TypeError as e:
     assert str(e) == "a tuple of length 2 expected"
 else:
     assert False
+[typing fixtures/typing-full.pyi]
 [out]
 1
 3
diff --git a/mypyc/test-data/run-dunders-special.test b/mypyc/test-data/run-dunders-special.test
new file mode 100644
index 000000000000..30c618374f88
--- /dev/null
+++ b/mypyc/test-data/run-dunders-special.test
@@ -0,0 +1,9 @@
+[case testDundersNotImplemented]
+# This case is special because it tests the behavior of NotImplemented
+# used in a typed function which return type is bool.
+# This is a convention that can be overridden by the user.
+class UsesNotImplemented:
+    def __eq__(self, b: object) -> bool:
+        return NotImplemented
+
+assert UsesNotImplemented() != object()
diff --git a/mypyc/test-data/run-dunders.test b/mypyc/test-data/run-dunders.test
index 2845187de2c3..b8fb13c9dcec 100644
--- a/mypyc/test-data/run-dunders.test
+++ b/mypyc/test-data/run-dunders.test
@@ -32,10 +32,6 @@ class BoxedThing:
 class Subclass2(BoxedThing):
     pass
 
-class UsesNotImplemented:
-    def __eq__(self, b: object) -> bool:
-        return NotImplemented
-
 def index_into(x : Any, y : Any) -> Any:
     return x[y]
 
@@ -81,8 +77,6 @@ assert is_truthy(Item('a'))
 assert not is_truthy(Subclass1(''))
 assert is_truthy(Subclass1('a'))
 
-assert UsesNotImplemented() != object()
-
 internal_index_into()
 [out]
 7 7
@@ -943,3 +937,31 @@ def test_errors() -> None:
         pow(ForwardNotImplemented(), Child(), 3)  # type: ignore
     with assertRaises(TypeError, "unsupported operand type(s) for ** or pow(): 'ForwardModRequired' and 'int'"):
         ForwardModRequired()**3  # type: ignore
+
+[case testDundersWithFinal]
+from typing import final
+class A:
+    def __init__(self, x: int) -> None:
+        self.x = x
+
+    def __add__(self, y: int) -> int:
+        return self.x + y
+
+    def __lt__(self, x: 'A') -> bool:
+        return self.x < x.x
+
+@final
+class B(A):
+    def __add__(self, y: int) -> int:
+        return self.x + y + 1
+
+    def __lt__(self, x: 'A') -> bool:
+        return self.x < x.x + 1
+
+def test_final() -> None:
+    a = A(5)
+    b = B(5)
+    assert a + 3 == 8
+    assert b + 3 == 9
+    assert (a < A(5)) is False
+    assert (b < A(5)) is True
diff --git a/mypyc/test-data/run-exceptions.test b/mypyc/test-data/run-exceptions.test
index c591fc1d8c15..1b180b933197 100644
--- a/mypyc/test-data/run-exceptions.test
+++ b/mypyc/test-data/run-exceptions.test
@@ -80,6 +80,43 @@ Traceback (most recent call last):
   File "native.py", line 23, in __init__
     raise Exception
 Exception
+[out version>=3.13]
+Traceback (most recent call last):
+  File "driver.py", line 4, in <module>
+    f([])
+    ~^^^^
+  File "native.py", line 3, in f
+    g(x)
+  File "native.py", line 6, in g
+    x[5] = 2
+IndexError: list assignment index out of range
+Traceback (most recent call last):
+  File "driver.py", line 8, in <module>
+    r1()
+    ~~^^
+  File "native.py", line 10, in r1
+    q1()
+  File "native.py", line 13, in q1
+    raise Exception("test")
+Exception: test
+Traceback (most recent call last):
+  File "driver.py", line 12, in <module>
+    r2()
+    ~~^^
+  File "native.py", line 16, in r2
+    q2()
+  File "native.py", line 19, in q2
+    raise Exception
+Exception
+Traceback (most recent call last):
+  File "driver.py", line 16, in <module>
+    hey()
+    ~~~^^
+  File "native.py", line 26, in hey
+    A()
+  File "native.py", line 23, in __init__
+    raise Exception
+Exception
 
 [case testTryExcept]
 from typing import Any, Iterator
@@ -264,6 +301,55 @@ attr! -- 'object' object has no attribute 'lol'
 out!
 == l ==
 key! -- 0
+[out version>=3.13]
+== i ==
+<class 'IndexError'>
+Traceback (most recent call last):
+  File "driver.py", line 6, in <module>
+    i()
+    ~^^
+  File "native.py", line 44, in i
+    r(0)
+  File "native.py", line 15, in r
+    [0][1]
+IndexError: list index out of range
+== k ==
+Traceback (most recent call last):
+  File "native.py", line 59, in k
+    r(1)
+  File "native.py", line 17, in r
+    raise Exception('hi')
+Exception: hi
+
+During handling of the above exception, another exception occurred:
+
+Traceback (most recent call last):
+  File "driver.py", line 12, in <module>
+    k()
+    ~^^
+  File "native.py", line 61, in k
+    r(0)
+  File "native.py", line 15, in r
+    [0][1]
+IndexError: list index out of range
+== g ==
+caught!
+caught!
+== f ==
+hi
+None
+list index out of range
+None
+== h ==
+gonna break
+None
+== j ==
+lookup!
+lookup!
+attr! -- 'object' object has no attribute 'lol'
+out!
+== l ==
+key! -- 0
 
 [case testTryFinally]
 from typing import Any
diff --git a/mypyc/test-data/run-floats.test b/mypyc/test-data/run-floats.test
index 2c101100549d..49620f6448c7 100644
--- a/mypyc/test-data/run-floats.test
+++ b/mypyc/test-data/run-floats.test
@@ -2,8 +2,7 @@
 
 [case testFloatOps]
 from __future__ import annotations
-from typing import Any, cast
-from typing_extensions import Final
+from typing import Final, Any, cast
 from testutil import assertRaises, float_vals, FLOAT_MAGIC
 import math
 
@@ -348,8 +347,7 @@ def test_tuples() -> None:
     assert t2 == tuple([5.0, 1.5, -7.0, -113.0])
 
 [case testFloatGlueMethodsAndInheritance]
-from typing import Any
-from typing_extensions import Final
+from typing import Final, Any
 
 from mypy_extensions import trait
 
diff --git a/mypyc/test-data/run-functions.test b/mypyc/test-data/run-functions.test
index 21993891c4e3..91a6103e31ae 100644
--- a/mypyc/test-data/run-functions.test
+++ b/mypyc/test-data/run-functions.test
@@ -140,7 +140,7 @@ def triple(a: int) -> Callable[[], Callable[[int], int]]:
     return outer
 
 def if_else(flag: int) -> str:
-    def dummy_funtion() -> str:
+    def dummy_function() -> str:
         return 'if_else.dummy_function'
 
     if flag < 0:
@@ -155,7 +155,7 @@ def if_else(flag: int) -> str:
     return inner()
 
 def for_loop() -> int:
-    def dummy_funtion() -> str:
+    def dummy_function() -> str:
         return 'for_loop.dummy_function'
 
     for i in range(5):
@@ -166,7 +166,7 @@ def for_loop() -> int:
     return 0
 
 def while_loop() -> int:
-    def dummy_funtion() -> str:
+    def dummy_function() -> str:
         return 'while_loop.dummy_function'
 
     i = 0
@@ -1243,7 +1243,8 @@ def g() -> None:
 g()
 
 [case testUnpackKwargsCompiled]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -1254,5 +1255,58 @@ def foo(**kwargs: Unpack[Person]) -> None:
 
 # This is not really supported yet, just test that we behave reasonably.
 foo(name='Jennifer', age=38)
+[typing fixtures/typing-full.pyi]
 [out]
 Jennifer
+
+[case testNestedFunctionDunderDict312]
+import sys
+
+def foo() -> None:
+    def inner() -> str: return "bar"
+    print(inner.__dict__)  # type: ignore[attr-defined]
+    inner.__dict__.update({"x": 1})  # type: ignore[attr-defined]
+    print(inner.__dict__)  # type: ignore[attr-defined]
+    print(inner.x)  # type: ignore[attr-defined]
+
+if sys.version_info >= (3, 12):  # type: ignore
+    foo()
+[out]
+[out version>=3.12]
+{}
+{'x': 1}
+1
+
+[case testFunctoolsUpdateWrapper]
+import functools
+
+def bar() -> None:
+    def inner() -> str: return "bar"
+    functools.update_wrapper(inner, bar)  # type: ignore
+    print(inner.__dict__)  # type: ignore
+
+bar()
+[out]
+{'__module__': 'native', '__name__': 'bar', '__qualname__': 'bar', '__doc__': None, '__wrapped__': <built-in function bar>}
+
+[case testCallNestedFunctionWithNamed]
+def f() -> None:
+    def a() -> None:
+        pass
+    def b() -> None:
+        a()
+    b()
+[file driver.py]
+from native import f
+f()
+
+[case testCallNestedFunctionWithLambda]
+def f(x: int) -> int:
+    def inc(x: int) -> int:
+        return x + 1
+    return (lambda x: inc(x))(1)
+[file driver.py]
+from native import f
+print(f(1))
+[out]
+2
diff --git a/mypyc/test-data/run-generators.test b/mypyc/test-data/run-generators.test
index bcf9da1846ae..2e55ded76f74 100644
--- a/mypyc/test-data/run-generators.test
+++ b/mypyc/test-data/run-generators.test
@@ -246,12 +246,12 @@ assert run_generator(another_triple()()) == ((1,), None)
 assert run_generator(outer()) == ((0, 1, 2, 3, 4), None)
 
 [case testYieldThrow]
-from typing import Generator, Iterable, Any
+from typing import Generator, Iterable, Any, Union
 from traceback import print_tb
 from contextlib import contextmanager
 import wrapsys
 
-def generator() -> Iterable[int]:
+def generator() -> Generator[int, None, Union[int, None]]:
     try:
         yield 1
         yield 2
@@ -264,6 +264,7 @@ def generator() -> Iterable[int]:
         else:
             print('caught exception without value')
         return 0
+    return None
 
 def no_except() -> Iterable[int]:
     yield 1
@@ -355,11 +356,11 @@ with ctx_manager() as c:
     raise Exception
   File "native.py", line 10, in generator
     yield 3
-  File "native.py", line 30, in wrapper
+  File "native.py", line 31, in wrapper
     return (yield from x)
   File "native.py", line 9, in generator
     yield 2
-  File "native.py", line 30, in wrapper
+  File "native.py", line 31, in wrapper
     return (yield from x)
 caught exception without value
 caught exception with value some string
@@ -679,3 +680,20 @@ def test_basic() -> None:
     with context:
         assert context.x == 1
     assert context.x == 0
+
+
+[case testYieldSpill]
+from typing import Generator
+from testutil import run_generator
+
+def f() -> int:
+    return 1
+
+def yield_spill() -> Generator[str, int, int]:
+    return f() + (yield "foo")
+
+def test_basic() -> None:
+    x = run_generator(yield_spill(), [2])
+    yields, val = x
+    assert yields == ('foo',)
+    assert val == 3, val
diff --git a/mypyc/test-data/run-generics.test b/mypyc/test-data/run-generics.test
new file mode 100644
index 000000000000..bc78a3b8ab86
--- /dev/null
+++ b/mypyc/test-data/run-generics.test
@@ -0,0 +1,111 @@
+[case testTypeVarMappingBound]
+# Dicts are special-cased for efficient iteration.
+from typing import Dict, TypedDict, TypeVar, Union
+
+class TD(TypedDict):
+    foo: int
+
+M = TypeVar("M", bound=Dict[str, int])
+U = TypeVar("U", bound=Union[Dict[str, int], Dict[str, str]])
+T = TypeVar("T", bound=TD)
+
+def fn_mapping(m: M) -> None:
+    print([x for x in m])
+    print([x for x in m.values()])
+    print([x for x in m.keys()])
+    print({k: v for k, v in m.items()})
+
+def fn_union(m: U) -> None:
+    print([x for x in m])
+    print([x for x in m.values()])
+    print([x for x in m.keys()])
+    print({k: v for k, v in m.items()})
+
+def fn_typeddict(t: T) -> None:
+    print([x for x in t])
+    print([x for x in t.values()])
+    print([x for x in t.keys()])
+    print({k: v for k, v in t.items()})
+
+fn_mapping({})
+print("=====")
+fn_mapping({"a": 1, "b": 2})
+print("=====")
+
+fn_union({"a": 1, "b": 2})
+print("=====")
+fn_union({"a": "1", "b": "2"})
+print("=====")
+
+orig: Union[Dict[str, int], Dict[str, str]] = {"a": 1, "b": 2}
+fn_union(orig)
+print("=====")
+
+td: TD = {"foo": 1}
+fn_typeddict(td)
+[typing fixtures/typing-full.pyi]
+[out]
+\[]
+\[]
+\[]
+{}
+=====
+\['a', 'b']
+\[1, 2]
+\['a', 'b']
+{'a': 1, 'b': 2}
+=====
+\['a', 'b']
+\[1, 2]
+\['a', 'b']
+{'a': 1, 'b': 2}
+=====
+\['a', 'b']
+\['1', '2']
+\['a', 'b']
+{'a': '1', 'b': '2'}
+=====
+\['a', 'b']
+\[1, 2]
+\['a', 'b']
+{'a': 1, 'b': 2}
+=====
+\['foo']
+\[1]
+\['foo']
+{'foo': 1}
+
+[case testParamSpecComponentsAreUsable]
+from typing import Callable
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+
+def deco(func: Callable[P, int]) -> Callable[P, int]:
+    def inner(*args: P.args, **kwargs: P.kwargs) -> int:
+        print([x for x in args])
+        print({k: v for k, v in kwargs.items()})
+        print(list(kwargs))
+        print(list(kwargs.keys()))
+        print(list(kwargs.values()))
+        return func(*args, **kwargs)
+
+    return inner
+
+@deco
+def f(x: int, y: str) -> int:
+    return x
+
+assert f(1, 'a') == 1
+assert f(2, y='b') == 2
+[out]
+\[1, 'a']
+{}
+\[]
+\[]
+\[]
+\[2]
+{'y': 'b'}
+\['y']
+\['y']
+\['b']
diff --git a/mypyc/test-data/run-i16.test b/mypyc/test-data/run-i16.test
new file mode 100644
index 000000000000..fbb0c15220bc
--- /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 af99fb79d35e..bb1fa43bb9fd 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 bcde39fed5ff..0dcad465cc9a 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
@@ -513,11 +517,10 @@ def test_isinstance() -> None:
     assert narrow2("foobar") == 6
 
 [case testI64ErrorValuesAndUndefined]
-from typing import Any, Tuple
+from typing import Any, Final, Tuple
 import sys
 
 from mypy_extensions import mypyc_attr, i64
-from typing_extensions import Final
 
 from testutil import assertRaises
 
@@ -901,8 +904,7 @@ def test_undefined_native_int_tuple_via_any() -> None:
     assert o.t == (-13, 45)
 
 [case testI64DefaultArgValues]
-from typing import Any, Iterator, Tuple
-from typing_extensions import Final
+from typing import Any, Final, Iterator, Tuple
 
 MAGIC: Final = -113
 
@@ -1202,7 +1204,7 @@ def test_magic_default() -> None:
     assert a(MAGIC) == MAGIC
 
 [case testI64UndefinedLocal]
-from typing_extensions import Final
+from typing import Final
 
 from mypy_extensions import i64, i32
 
@@ -1303,28 +1305,28 @@ def test_many_locals() -> None:
         a31: i64 = 31
         a32: i64 = 32
         a33: i64 = 33
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a0)
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a31)
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a32)
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a33)
     a0 = 5
     assert a0 == 5
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a31)
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a32)
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a33)
     a32 = 55
     assert a0 == 5
     assert a32 == 55
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a31)
-    with assertRaises(NameError):
+    with assertRaises(UnboundLocalError):
         print(a33)
     a31 = 10
     a33 = 20
@@ -1334,8 +1336,7 @@ def test_many_locals() -> None:
     assert a33 == 20
 
 [case testI64GlueMethodsAndInheritance]
-from typing import Any
-from typing_extensions import Final
+from typing import Final, Any
 
 from mypy_extensions import i64, trait
 
@@ -1500,3 +1501,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-data/run-lists.test b/mypyc/test-data/run-lists.test
index 84d5ee121a20..07c6d7735f10 100644
--- a/mypyc/test-data/run-lists.test
+++ b/mypyc/test-data/run-lists.test
@@ -51,6 +51,55 @@ print(2, a)
 1 [-1, 5]
 2 [340282366920938463463374607431768211461, -170141183460469231731687303715884105736]
 
+[case testListCopy]
+from typing import List
+from copysubclass import subc
+
+def test_list_copy() -> None:
+    l1 = [1, 2, 3, -4, 5]
+    l2 = l1.copy()
+    assert l1.copy() == l1
+    assert l1.copy() == l2
+    assert l1 == l2
+    assert l1.copy() == l2.copy()
+    l1 = l2.copy()
+    assert l1 == l2
+    assert l1.copy() == l2
+    assert l1 == [1, 2, 3, -4, 5]
+    l2 = [1, 2, -3]
+    l1 = []
+    assert l1.copy() == []
+    assert l2.copy() != l1
+    assert l2 == l2.copy()
+    l1 = l2
+    assert l1.copy().copy() == l2.copy().copy().copy()
+    assert l1.copy() == l2.copy()
+    l1 == [1, 2, -3].copy()
+    assert l1 == l2
+    l2 = [1, 2, 3].copy()
+    assert l2 != l1
+    l1 = [1, 2, 3]
+    assert l1.copy() == l2.copy()
+    l3 = [1, 2 , 3, "abcdef"]
+    assert l3 == l3.copy()
+    l4 = ["abc", 5, 10]
+    l4 = l3.copy()
+    assert l4 == l3
+    #subclass testing
+    l5: subc = subc([1, 2, 3])
+    l6 = l5.copy()
+    assert l6 == l5
+    l6 = [1, 2, "3", 4, 5]
+    l5 = subc([1,2,"3",4,5])
+    assert l5.copy() == l6.copy()
+    l6 = l5.copy()
+    assert l5 == l6
+
+[file copysubclass.py]
+from typing import Any
+class subc(list[Any]):
+    pass
+
 [case testSieve]
 from typing import List
 
@@ -218,6 +267,9 @@ print(g())
 7
 
 [case testListOps]
+from typing import Any, cast
+from testutil import assertRaises
+
 def test_slicing() -> None:
     # Use dummy adds to avoid constant folding
     zero = int()
@@ -240,6 +292,34 @@ def test_slicing() -> None:
     assert s[long_int:] == []
     assert s[-long_int:-1] == ["f", "o", "o", "b", "a"]
 
+def in_place_add(l2: Any) -> list[Any]:
+    l1 = [1, 2]
+    l1 += l2
+    return l1
+
+def test_add() -> None:
+    res = [1, 2, 3, 4]
+    assert [1, 2] + [3, 4] == res
+    with assertRaises(TypeError, 'can only concatenate list (not "tuple") to list'):
+        assert [1, 2] + cast(Any, (3, 4)) == res
+    l1 = [1, 2]
+    id_l1 = id(l1)
+    l1 += [3, 4]
+    assert l1 == res
+    assert id_l1 == id(l1)
+    assert in_place_add([3, 4]) == res
+    assert in_place_add((3, 4)) == res
+    assert in_place_add({3, 4}) == res
+    assert in_place_add({3: "", 4: ""}) == res
+    assert in_place_add(range(3, 5)) == res
+
+def test_multiply() -> None:
+    l1 = [1]
+    assert l1 * 3 == [1, 1, 1]
+    assert 3 * l1 == [1, 1, 1]
+    l1 *= 3
+    assert l1 == [1, 1, 1]
+
 [case testOperatorInExpression]
 
 def tuple_in_int0(i: int) -> bool:
@@ -409,3 +489,25 @@ def test_index_with_literal() -> None:
     assert d is d2
     d = a[-2].d
     assert d is d1
+
+[case testSorted]
+from typing import List
+
+def test_list_sort() -> None:
+    l1 = [2, 1, 3]
+    id_l1 = id(l1)
+    l1.sort()
+    assert l1 == [1, 2, 3]
+    assert id_l1 == id(l1)
+
+def test_sorted() -> None:
+    res = [1, 2, 3]
+    l1 = [2, 1, 3]
+    id_l1 = id(l1)
+    s_l1 = sorted(l1)
+    assert s_l1 == res
+    assert id_l1 != id(s_l1)
+    assert l1 == [2, 1, 3]
+    assert sorted((2, 1, 3)) == res
+    assert sorted({2, 1, 3}) == res
+    assert sorted({2: "", 1: "", 3: ""}) == res
diff --git a/mypyc/test-data/run-loops.test b/mypyc/test-data/run-loops.test
index 994b30b42347..3cbb07297e6e 100644
--- a/mypyc/test-data/run-loops.test
+++ b/mypyc/test-data/run-loops.test
@@ -228,6 +228,7 @@ def nested_enumerate() -> None:
             assert i == inner
             inner += 1
         outer += 1
+    assert i == 2
     assert outer_seen == l1
 
 def nested_range() -> None:
@@ -276,7 +277,10 @@ for k in range(12):
 [out]
 
 [case testForIterable]
-from typing import Iterable, Dict, Any, Tuple
+from typing import Iterable, Dict, Any, Tuple, TypeVar
+
+T = TypeVar("T")
+
 def iterate_over_any(a: Any) -> None:
     for element in a:
         print(element)
@@ -350,13 +354,47 @@ iterate_over_tuple((1, 2, 3))
 Traceback (most recent call last):
   File "driver.py", line 16, in <module>
     iterate_over_any(5)
-  File "native.py", line 3, in iterate_over_any
+  File "native.py", line 6, in iterate_over_any
+    for element in a:
+TypeError: 'int' object is not iterable
+Traceback (most recent call last):
+  File "driver.py", line 20, in <module>
+    iterate_over_iterable(broken_generator(5))
+  File "native.py", line 10, in iterate_over_iterable
+    for element in iterable:
+  File "driver.py", line 8, in broken_generator
+    raise Exception('Exception Manually Raised')
+Exception: Exception Manually Raised
+Traceback (most recent call last):
+  File "driver.py", line 24, in <module>
+    iterate_and_delete(d)
+  File "native.py", line 14, in iterate_and_delete
+    for key in d:
+RuntimeError: dictionary changed size during iteration
+15
+6
+3
+0
+1
+2
+3
+4
+1
+2
+3
+[out version>=3.13]
+Traceback (most recent call last):
+  File "driver.py", line 16, in <module>
+    iterate_over_any(5)
+    ~~~~~~~~~~~~~~~~^^^
+  File "native.py", line 6, in iterate_over_any
     for element in a:
 TypeError: 'int' object is not iterable
 Traceback (most recent call last):
   File "driver.py", line 20, in <module>
     iterate_over_iterable(broken_generator(5))
-  File "native.py", line 7, in iterate_over_iterable
+    ~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^
+  File "native.py", line 10, in iterate_over_iterable
     for element in iterable:
   File "driver.py", line 8, in broken_generator
     raise Exception('Exception Manually Raised')
@@ -364,7 +402,8 @@ Exception: Exception Manually Raised
 Traceback (most recent call last):
   File "driver.py", line 24, in <module>
     iterate_and_delete(d)
-  File "native.py", line 11, in iterate_and_delete
+    ~~~~~~~~~~~~~~~~~~^^^
+  File "native.py", line 14, in iterate_and_delete
     for key in d:
 RuntimeError: dictionary changed size during iteration
 15
@@ -427,6 +466,29 @@ assert g([6, 7], ['a', 'b']) == [(0, 6, 'a'), (1, 7, 'b')]
 assert f([6, 7], [8]) == [(0, 6, 8)]
 assert f([6], [8, 9]) == [(0, 6, 8)]
 
+[case testEnumerateEmptyList]
+from typing import List
+
+def get_enumerate_locals(iterable: List[int]) -> int:
+    for i, j in enumerate(iterable):
+        pass
+    try:
+        return i
+    except NameError:
+        return -100
+
+[file driver.py]
+from native import get_enumerate_locals
+
+print(get_enumerate_locals([]))
+print(get_enumerate_locals([55]))
+print(get_enumerate_locals([551, 552]))
+
+[out]
+-100
+0
+1
+
 [case testIterTypeTrickiness]
 # Test inferring the type of a for loop body doesn't cause us grief
 # Extracted from somethings that broke in mypy
@@ -483,3 +545,29 @@ def test_range_object() -> None:
         r4 = range(4, 12, 0)
     except ValueError as e:
         assert "range() arg 3 must not be zero" in str(e)
+
+[case testNamedTupleLoop]
+from collections.abc import Iterable
+from typing import NamedTuple, Any
+from typing_extensions import Self
+
+
+class Vector2(NamedTuple):
+    x: int
+    y: float
+
+    @classmethod
+    def from_iter(cls, iterable: Iterable[Any]) -> Self:
+        return cls(*iter(iterable))
+
+    def __neg__(self) -> Self:
+        return self.from_iter(-c for c in self)
+
+[file driver.py]
+import native
+print(-native.Vector2(2, -3.1))
+print([x for x in native.Vector2(4, -5.2)])
+
+[out]
+Vector2(x=-2, y=3.1)
+\[4, -5.2]
diff --git a/mypyc/test-data/run-math.test b/mypyc/test-data/run-math.test
index 266b4851575f..d3102290d2af 100644
--- a/mypyc/test-data/run-math.test
+++ b/mypyc/test-data/run-math.test
@@ -1,8 +1,7 @@
 # Test cases for the math module (compile and run)
 
 [case testMathOps]
-from typing import Any, Callable
-from typing_extensions import Final
+from typing import Any, Callable, Final
 import math
 from math import pi, e, tau, inf, nan
 from testutil import assertRaises, float_vals, assertDomainError, assertMathRangeError
diff --git a/mypyc/test-data/run-misc.test b/mypyc/test-data/run-misc.test
index fd0eb5022236..a08be091bcc3 100644
--- a/mypyc/test-data/run-misc.test
+++ b/mypyc/test-data/run-misc.test
@@ -37,9 +37,9 @@ from testutil import assertRaises
 
 f(True, True)
 f(False, False)
-with assertRaises(NameError):
+with assertRaises(UnboundLocalError):
     f(False, True)
-with assertRaises(NameError):
+with assertRaises(UnboundLocalError):
     g()
 [out]
 lol
@@ -612,8 +612,7 @@ for a in sorted(s):
 9     8   72
 
 [case testDummyTypes]
-from typing import Tuple, List, Dict, NamedTuple
-from typing_extensions import Literal, TypedDict, NewType
+from typing import Tuple, List, Dict, Literal, NamedTuple, NewType, TypedDict
 
 class A:
     pass
@@ -664,6 +663,7 @@ except Exception as e:
     print(type(e).__name__)
 # ... but not that it is a valid literal value
 take_literal(10)
+[typing fixtures/typing-full.pyi]
 [out]
 Lol(a=1, b=[])
 10
@@ -675,7 +675,7 @@ TypeError
 10
 
 [case testClassBasedTypedDict]
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 class TD(TypedDict):
     a: int
@@ -707,6 +707,7 @@ def test_non_total_typed_dict() -> None:
     d4 = TD4(a=1, b=2, c=3, d=4)
     assert d3['c'] == 3
     assert d4['d'] == 4
+[typing fixtures/typing-full.pyi]
 
 [case testClassBasedNamedTuple]
 from typing import NamedTuple
@@ -968,7 +969,10 @@ print(z)
 [case testCheckVersion]
 import sys
 
-if sys.version_info[:2] == (3, 12):
+if sys.version_info[:2] == (3, 13):
+    def version() -> int:
+        return 13
+elif sys.version_info[:2] == (3, 12):
     def version() -> int:
         return 12
 elif sys.version_info[:2] == (3, 11):
@@ -1097,8 +1101,10 @@ B = sys.platform == 'x' and sys.foobar
 C = sys.platform == 'x' and f(a, -b, 'y') > [c + e, g(y=2)]
 C = sys.platform == 'x' and cast(a, b[c])
 C = sys.platform == 'x' and (lambda x: y + x)
-# TODO: This still doesn't work
-# C = sys.platform == 'x' and (x for y in z)
+C = sys.platform == 'x' and (x for y in z)
+C = sys.platform == 'x' and [x for y in z]
+C = sys.platform == 'x' and {x: x for y in z}
+C = sys.platform == 'x' and {x for y in z}
 
 assert not A
 assert not B
@@ -1108,29 +1114,14 @@ assert not C
 # make the initial import fail
 assert False
 
-class C:
-    def __init__(self):
-        self.x = 1
-        self.y = 2
-def test() -> None:
-    a = C()
 [file driver.py]
 # load native, cause PyInit to be run, create the module but don't finish initializing the globals
-try:
-    import native
-except:
-    pass
-try:
-    # try accessing those globals that were never properly initialized
-    import native
-    native.test()
-# should fail with AssertionError due to `assert False` in other function
-except AssertionError:
-    pass
-
-[case testRepeatedUnderscoreFunctions]
-def _(arg): pass
-def _(arg): pass
+for _ in range(2):
+    try:
+        import native
+        raise RuntimeError('exception expected')
+    except AssertionError:
+        pass
 
 [case testUnderscoreFunctionsInMethods]
 
diff --git a/mypyc/test-data/run-multimodule.test b/mypyc/test-data/run-multimodule.test
index 70c73dc2088b..5112e126169f 100644
--- a/mypyc/test-data/run-multimodule.test
+++ b/mypyc/test-data/run-multimodule.test
@@ -155,7 +155,7 @@ def f(c: C) -> int:
     c = cast(C, o)
     return a_global + c.x + c.f() + d.x + d.f() + 1
 [file other.py]
-from typing_extensions import Final
+from typing import Final
 a_global: Final = int('5')
 
 class C:
@@ -291,6 +291,23 @@ Traceback (most recent call last):
   File "other.py", line 3, in fail2
     x[2] = 2
 IndexError: list assignment index out of range
+[out version>=3.13]
+Traceback (most recent call last):
+  File "driver.py", line 6, in <module>
+    other.fail2()
+    ~~~~~~~~~~~^^
+  File "other.py", line 3, in fail2
+    x[2] = 2
+IndexError: list assignment index out of range
+Traceback (most recent call last):
+  File "driver.py", line 12, in <module>
+    native.fail()
+    ~~~~~~~~~~~^^
+  File "native.py", line 4, in fail
+    fail2()
+  File "other.py", line 3, in fail2
+    x[2] = 2
+IndexError: list assignment index out of range
 
 [case testMultiModuleCycle]
 if False:
@@ -478,7 +495,7 @@ class Bar:
         bar(self)
 
 [file other.py]
-from typing_extensions import TYPE_CHECKING
+from typing import TYPE_CHECKING
 MYPY = False
 if MYPY:
     from native import Foo
@@ -508,7 +525,7 @@ def f(c: 'C') -> int:
     return c.x
 
 [file other.py]
-from typing_extensions import TYPE_CHECKING
+from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from native import D
 
@@ -718,11 +735,11 @@ def foo() -> int:
     return X
 
 [file other.py]
-from typing_extensions import Final
+from typing import Final
 X: Final = 10
 
 [file other.py.2]
-from typing_extensions import Final
+from typing import Final
 X: Final = 20
 
 [file driver.py]
diff --git a/mypyc/test-data/run-primitives.test b/mypyc/test-data/run-primitives.test
index b95f742977be..694700d4738c 100644
--- a/mypyc/test-data/run-primitives.test
+++ b/mypyc/test-data/run-primitives.test
@@ -345,10 +345,10 @@ delAttribute()
 delAttributeMultiple()
 with assertRaises(AttributeError):
     native.global_var
-with assertRaises(NameError, 'local variable "dummy" referenced before assignment'):
+with assertRaises(UnboundLocalError, 'local variable "dummy" referenced before assignment'):
     delLocal(True)
 assert delLocal(False) == 10
-with assertRaises(NameError, 'local variable "dummy" referenced before assignment'):
+with assertRaises(UnboundLocalError, 'local variable "dummy" referenced before assignment'):
     delLocalLoop()
 [out]
 (1, 2, 3)
diff --git a/mypyc/test-data/run-python312.test b/mypyc/test-data/run-python312.test
new file mode 100644
index 000000000000..5c0a807c375a
--- /dev/null
+++ b/mypyc/test-data/run-python312.test
@@ -0,0 +1,231 @@
+[case testPEP695Basics]
+from enum import Enum
+from typing import Any, Literal, TypeAliasType, cast
+
+from testutil import assertRaises
+
+def id[T](x: T) -> T:
+    return x
+
+def test_call_generic_function() -> None:
+    assert id(2) == 2
+    assert id('x') == 'x'
+
+class C[T]:
+    x: T
+
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+class D[T, S]:
+    x: T
+    y: S
+
+    def __init__(self, x: T, y: S) -> None:
+        self.x = x
+        self.y = y
+
+    def set(self, x: object, y: object) -> None:
+        self.x = cast(T, x)
+        self.y = cast(S, y)
+
+def test_generic_class() -> None:
+    c = C(5)
+    assert c.x == 5
+    c2 = C[str]('x')
+    assert c2.x == 'x'
+    d = D[str, int]('a', 5)
+    assert d.x == 'a'
+    assert d.y == 5
+    d.set('b', 6)
+    assert d.x == 'b'
+    assert d.y == 6
+
+def test_generic_class_via_any() -> None:
+    c_any: Any = C
+    c = c_any(2)
+    assert c.x == 2
+    c2 = c_any[str]('y')
+    assert c2.x == 'y'
+    assert str(c_any[str]) == 'native.C[str]'
+
+    d_any: Any = D
+    d = d_any(1, 'x')
+    assert d.x == 1
+    assert d.y == 'x'
+    d2 = d_any[int, str](2, 'y')
+    assert d2.x == 2
+    assert d2.y == 'y'
+
+    with assertRaises(TypeError):
+        c_any[int, str]
+    with assertRaises(TypeError):
+        d_any[int]
+
+class E[*Ts]: pass
+
+def test_type_var_tuple() -> None:
+    e: E[int, str] = E()
+    e_any: Any = E
+    assert isinstance(e_any(), E)
+    assert isinstance(e_any[int](), E)
+    assert isinstance(e_any[int, str](), E)
+
+class F[**P]: pass
+
+def test_param_spec() -> None:
+    f: F[[int, str]] = F()
+    f_any: Any = F
+    assert isinstance(f_any(), F)
+    assert isinstance(f_any[[int, str]](), F)
+
+class SubC[S](C[S]):
+    def __init__(self, x: S) -> None:
+       super().__init__(x)
+
+def test_generic_subclass() -> None:
+    s = SubC(1)
+    assert s.x == 1
+    s2 = SubC[str]('y')
+    assert s2.x == 'y'
+    sub_any: Any = SubC
+    assert sub_any(1).x == 1
+    assert sub_any[str]('x').x == 'x'
+    assert isinstance(s, SubC)
+    assert isinstance(s, C)
+
+class SubD[
+           T,  # Put everything on separate lines
+           S](
+              D[T,
+                S]): pass
+
+def test_generic_subclass_two_params() -> None:
+    s = SubD(3, 'y')
+    assert s.x == 3
+    assert s.y == 'y'
+    s2 = SubD[str, int]('z', 4)
+    assert s2.x == 'z'
+    assert s2.y == 4
+    sub_any: Any = SubD
+    assert sub_any(3, 'y').y == 'y'
+    assert sub_any[int, str](3, 'y').y == 'y'
+    assert isinstance(s, SubD)
+    assert isinstance(s, D)
+
+class SubE[*Ts](E[*Ts]): pass
+
+def test_type_var_tuple_subclass() -> None:
+    sub_any: Any = SubE
+    assert isinstance(sub_any(), SubE)
+    assert isinstance(sub_any(), E)
+    assert isinstance(sub_any[int](), SubE)
+    assert isinstance(sub_any[int, str](), SubE)
+
+
+class SubF[**P](F[P]): pass
+
+def test_param_spec_subclass() -> None:
+    sub_any: Any = SubF
+    assert isinstance(sub_any(), SubF)
+    assert isinstance(sub_any(), F)
+    assert isinstance(sub_any[[int]](), SubF)
+    assert isinstance(sub_any[[int, str]](), SubF)
+
+# We test that upper bounds and restricted values can be used, but not that
+# they are introspectable
+
+def bound[T: C](x: T) -> T:
+    return x
+
+def test_function_with_upper_bound() -> None:
+    c = C(1)
+    assert bound(c) is c
+
+def restriction[T: (int, str)](x: T) -> T:
+    return x
+
+def test_function_with_value_restriction() -> None:
+    assert restriction(1) == 1
+    assert restriction('x') == 'x'
+
+class Bound[T: C]:
+     def __init__(self, x: T) -> None:
+         self.x = x
+
+def test_class_with_upper_bound() -> None:
+    c = C(1)
+    b = Bound(c)
+    assert b.x is c
+    b2 = Bound[C](c)
+    assert b2.x is c
+
+class Restriction[T: (int, str)]:
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+def test_class_with_value_restriction() -> None:
+    r = Restriction(1)
+    assert r.x == 1
+    r2 = Restriction[str]('a')
+    assert r2.x == 'a'
+
+type A = int
+
+def test_simple_type_alias() -> None:
+    assert isinstance(A, TypeAliasType)
+    assert getattr(A, "__value__") is int
+    assert str(A) == "A"
+
+type B = Fwd[int]
+Fwd = list
+
+def test_forward_reference_in_alias() -> None:
+    assert isinstance(B, TypeAliasType)
+    assert getattr(B, "__value__") == list[int]
+
+type R = int | list[R]
+
+def test_recursive_type_alias() -> None:
+    assert isinstance(R, TypeAliasType)
+    assert getattr(R, "__value__") == (int | list[R])
+
+class SomeEnum(Enum):
+    AVALUE = "a"
+
+type EnumLiteralAlias1 = Literal[SomeEnum.AVALUE]
+type EnumLiteralAlias2 = Literal[SomeEnum.AVALUE] | None
+EnumLiteralAlias3 = Literal[SomeEnum.AVALUE] | None
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695GenericTypeAlias]
+from typing import Callable
+from types import GenericAlias
+
+from testutil import assertRaises
+
+type A[T] = list[T]
+
+def test_generic_alias() -> None:
+    assert type(A[str]) is GenericAlias
+    assert str(A[str]) == "A[str]"
+    assert str(getattr(A, "__value__")) == "list[T]"
+
+type B[T, S] = dict[S, T]
+
+def test_generic_alias_with_two_args() -> None:
+    assert str(B[str, int]) == "B[str, int]"
+    assert str(getattr(B, "__value__")) == "dict[S, T]"
+
+type C[*Ts] = tuple[*Ts]
+
+def test_type_var_tuple_type_alias() -> None:
+    assert str(C[int, str]) == "C[int, str]"
+    assert str(getattr(C, "__value__")) == "tuple[typing.Unpack[Ts]]"
+
+type D[**P] = Callable[P, int]
+
+def test_param_spec_type_alias() -> None:
+    assert str(D[[int, str]]) == "D[[int, str]]"
+    assert str(getattr(D, "__value__")) == "typing.Callable[P, int]"
+[typing fixtures/typing-full.pyi]
diff --git a/mypyc/test-data/run-sets.test b/mypyc/test-data/run-sets.test
index 8d178d03a75b..68edd1e6b77d 100644
--- a/mypyc/test-data/run-sets.test
+++ b/mypyc/test-data/run-sets.test
@@ -116,9 +116,126 @@ s = {1, 2, 3}
 update(s, [5, 4, 3])
 assert s == {1, 2, 3, 4, 5}
 
+[case testFrozenSets]
+from typing import FrozenSet, List, Any, cast
+from testutil import assertRaises
+
+def instantiateLiteral() -> FrozenSet[int]:
+    return frozenset((1, 2, 3, 5, 8))
+
+def emptyFrozenSet1() -> FrozenSet[int]:
+    return frozenset()
+
+def emptyFrozenSet2() -> FrozenSet[int]:
+    return frozenset(())
+
+def fromIterator() -> List[FrozenSet[int]]:
+    a = frozenset([1, 3, 5])
+    b = frozenset((1, 3, 5))
+    c = frozenset({1, 3, 5})
+    d = frozenset({1: '1', 3: '3', 5: '5'})
+    e = frozenset(x for x in range(1, 6, 2))
+    f = frozenset((x for x in range(1, 6, 2)))
+    return [a, b, c, d, e, f]
+
+def fromIterator2() -> FrozenSet[int]:
+    tmp_list = [1, 2, 3, 4, 5]
+    return frozenset((x + 1) for x in ((y * 10) for y in (z for z in tmp_list if z < 4)))
+
+def castFrozenSet() -> FrozenSet[int]:
+    x: Any = frozenset((1, 2, 3, 5, 8))
+    return cast(FrozenSet, x)
+
+def castFrozenSetError() -> FrozenSet[int]:
+    x: Any = {1, 2, 3, 5, 8}
+    return cast(FrozenSet, x)
+
+def test_frozen_sets() -> None:
+    val = instantiateLiteral()
+    assert 1 in val
+    assert 2 in val
+    assert 3 in val
+    assert 5 in val
+    assert 8 in val
+    assert len(val) == 5
+    assert val == {1, 2, 3, 5, 8}
+    s = 0
+    for i in val:
+        s += i
+    assert s == 19
+
+    empty_set1 = emptyFrozenSet1()
+    assert empty_set1 == frozenset()
+
+    empty_set2 = emptyFrozenSet2()
+    assert empty_set2 == frozenset()
+
+    sets = fromIterator()
+    for s2 in sets:
+        assert s2 == {1, 3, 5}
+
+    s3 = fromIterator2()
+    assert s3 == {11, 21, 31}
+
+    val2 = castFrozenSet()
+    assert val2 == {1, 2, 3, 5, 8}
+
+    with assertRaises(TypeError, "frozenset object expected; got set"):
+        castFrozenSetError()
+
+[case testFrozenSetsFromIterables]
+from typing import FrozenSet
+
+def f(x: int) -> int:
+    return x
+
+def f1() -> FrozenSet[int]:
+    tmp_list = [1, 3, 5]
+    return frozenset(f(x) for x in tmp_list)
+
+def f2() -> FrozenSet[int]:
+    tmp_tuple = (1, 3, 5)
+    return frozenset(f(x) for x in tmp_tuple)
+
+def f3() -> FrozenSet[int]:
+    tmp_set = {1, 3, 5}
+    return frozenset(f(x) for x in tmp_set)
+
+def f4() -> FrozenSet[int]:
+    tmp_dict = {1: '1', 3: '3', 5: '5'}
+    return frozenset(f(x) for x in tmp_dict)
+
+def f5() -> FrozenSet[int]:
+    return frozenset(f(x) for x in range(1, 6, 2))
+
+def f6() -> FrozenSet[int]:
+    return frozenset((f(x) for x in range(1, 6, 2)))
+
+def g1(x: int) -> int:
+    return x
+
+def g2(x: int) -> int:
+    return x * 10
+
+def g3(x: int) -> int:
+    return x + 1
+
+def g4() -> FrozenSet[int]:
+    tmp_list = [1, 2, 3, 4, 5]
+    return frozenset(g3(x) for x in (g2(y) for y in (g1(z) for z in tmp_list if z < 4)))
+
+def test_frozen_sets_from_iterables() -> None:
+    val = frozenset({1, 3, 5})
+    assert f1() == val
+    assert f2() == val
+    assert f3() == val
+    assert f4() == val
+    assert f5() == val
+    assert f6() == val
+    assert g4() == frozenset({11, 21, 31})
+
 [case testPrecomputedFrozenSets]
-from typing import Any
-from typing_extensions import Final
+from typing import Final, Any
 
 CONST: Final = "CONST"
 non_const = "non_const"
diff --git a/mypyc/test-data/run-strings.test b/mypyc/test-data/run-strings.test
index be668435d073..9183b45b036a 100644
--- a/mypyc/test-data/run-strings.test
+++ b/mypyc/test-data/run-strings.test
@@ -2,6 +2,11 @@
 
 [case testStrBasics]
 from typing import Tuple
+class A:
+    def __str__(self) -> str:
+        return "A-str"
+    def __repr__(self) -> str:
+        return "A-repr"
 def f() -> str:
     return 'some string'
 def g() -> str:
@@ -10,6 +15,14 @@ def tostr(x: int) -> str:
     return str(x)
 def booltostr(x: bool) -> str:
     return str(x)
+def clstostr(x: A) -> str:
+    return str(x)
+def torepr(x: int) -> str:
+    return repr(x)
+def booltorepr(x: bool) -> str:
+    return repr(x)
+def clstorepr(x: A) -> str:
+    return repr(x)
 def concat(x: str, y: str) -> str:
     return x + y
 def eq(x: str) -> int:
@@ -20,10 +33,21 @@ def eq(x: str) -> int:
     return 2
 def match(x: str, y: str) -> Tuple[bool, bool]:
     return (x.startswith(y), x.endswith(y))
+def match_tuple(x: str, y: Tuple[str, ...]) -> Tuple[bool, bool]:
+    return (x.startswith(y), x.endswith(y))
+def match_tuple_literal_args(x: str, y: str, z: str) -> Tuple[bool, bool]:
+    return (x.startswith((y, z)), x.endswith((y, z)))
+def remove_prefix_suffix(x: str, y: str) -> Tuple[str, str]:
+    return (x.removeprefix(y), x.removesuffix(y))
 
 [file driver.py]
-from native import f, g, tostr, booltostr, concat, eq, match
+from native import (
+    f, g, A, tostr, booltostr, clstostr, concat, eq, match, match_tuple,
+    match_tuple_literal_args, remove_prefix_suffix,
+    torepr, booltorepr, clstorepr
+)
 import sys
+from testutil import assertRaises
 
 assert f() == 'some string'
 assert f() is sys.intern('some string')
@@ -32,20 +56,45 @@ assert tostr(57) == '57'
 assert concat('foo', 'bar') == 'foobar'
 assert booltostr(True) == 'True'
 assert booltostr(False) == 'False'
+assert clstostr(A()) == "A-str"
 assert eq('foo') == 0
 assert eq('zar') == 1
 assert eq('bar') == 2
 
+assert torepr(57) == '57'
+assert booltorepr(True) == 'True'
+assert booltorepr(False) == 'False'
+assert clstorepr(A()) == "A-repr"
+
 assert int(tostr(0)) == 0
 assert int(tostr(20)) == 20
+assert int(torepr(0)) == 0
+assert int(torepr(20)) == 20
 assert match('', '') == (True, True)
 assert match('abc', '') == (True, True)
 assert match('abc', 'a') == (True, False)
 assert match('abc', 'c') == (False, True)
 assert match('', 'abc') == (False, False)
+assert match_tuple('abc', ('d', 'e')) == (False, False)
+assert match_tuple('abc', ('a', 'c')) == (True, True)
+assert match_tuple('abc', ('a',)) == (True, False)
+assert match_tuple('abc', ('c',)) == (False, True)
+assert match_tuple('abc', ('x', 'y', 'z')) == (False, False)
+assert match_tuple('abc', ('x', 'y', 'z', 'a', 'c')) == (True, True)
+with assertRaises(TypeError, "tuple for startswith must only contain str"):
+    assert match_tuple('abc', (None,))
+with assertRaises(TypeError, "tuple for endswith must only contain str"):
+    assert match_tuple('abc', ('a', None))
+assert match_tuple_literal_args('abc', 'z', 'a') == (True, False)
+assert match_tuple_literal_args('abc', 'z', 'c') == (False, True)
+
+assert remove_prefix_suffix('', '') == ('', '')
+assert remove_prefix_suffix('abc', 'a') == ('bc', 'abc')
+assert remove_prefix_suffix('abc', 'c') == ('abc', 'ab')
 
 [case testStringOps]
-from typing import List, Optional
+from typing import List, Optional, Tuple
+from testutil import assertRaises
 
 def do_split(s: str, sep: Optional[str] = None, max_split: Optional[int] = None) -> List[str]:
     if sep is not None:
@@ -55,6 +104,14 @@ def do_split(s: str, sep: Optional[str] = None, max_split: Optional[int] = None)
             return s.split(sep)
     return s.split()
 
+def do_rsplit(s: str, sep: Optional[str] = None, max_split: Optional[int] = None) -> List[str]:
+    if sep is not None:
+        if max_split is not None:
+            return s.rsplit(sep, max_split)
+        else:
+            return s.rsplit(sep)
+    return s.rsplit()
+
 ss = "abc abcd abcde abcdef"
 
 def test_split() -> None:
@@ -66,13 +123,77 @@ def test_split() -> None:
     assert do_split(ss, " ", 1) == ["abc", "abcd abcde abcdef"]
     assert do_split(ss, " ", 2) == ["abc", "abcd", "abcde abcdef"]
 
+def test_rsplit() -> None:
+    assert do_rsplit(ss) == ["abc", "abcd", "abcde", "abcdef"]
+    assert do_rsplit(ss, " ") == ["abc", "abcd", "abcde", "abcdef"]
+    assert do_rsplit(ss, "-") == ["abc abcd abcde abcdef"]
+    assert do_rsplit(ss, " ", -1) == ["abc", "abcd", "abcde", "abcdef"]
+    assert do_rsplit(ss, " ", 0) == ["abc abcd abcde abcdef"]
+    assert do_rsplit(ss, " ", 1) == ["abc abcd abcde", "abcdef"]  # different to do_split
+    assert do_rsplit(ss, " ", 2) == ["abc abcd", "abcde", "abcdef"]  # different to do_split
+
+def splitlines(s: str, keepends: Optional[bool] = None) -> List[str]:
+    if keepends is not None:
+        return s.splitlines(keepends)
+    return s.splitlines()
+
+s_text = "This\nis\n\nsome\nlong\ntext.\n"
+
+def test_splitlines() -> None:
+    assert splitlines(s_text) == ["This", "is", "", "some", "long", "text."]
+    assert splitlines(s_text, False) == ["This", "is", "", "some", "long", "text."]
+    assert splitlines(s_text, True) == ["This\n", "is\n", "\n", "some\n", "long\n", "text.\n"]
+
+s_partition = "Some long text"
+
+def partition(s: str, sep: str) -> Tuple[str, str, str]:
+    return s.partition(sep)
+
+def rpartition(s: str, sep: str) -> Tuple[str, str, str]:
+    return s.rpartition(sep)
+
+def test_partition() -> None:
+    assert partition(s_partition, " ") == ("Some", " ", "long text")
+    assert partition(s_partition, "Hello") == ("Some long text", "", "")
+    assert rpartition(s_partition, " ") == ("Some long", " ", "text")
+    assert rpartition(s_partition, "Hello") == ("", "", "Some long text")
+    with assertRaises(ValueError, "empty separator"):
+        partition(s_partition, "")
+    with assertRaises(ValueError, "empty separator"):
+        rpartition(s_partition, "")
+
+def contains(s: str, o: str) -> bool:
+    return o in s
+
 def getitem(s: str, index: int) -> str:
     return s[index]
 
-from testutil import assertRaises
+def find(s: str, substr: str, start: Optional[int] = None, end: Optional[int] = None) -> int:
+    if start is not None:
+        if end is not None:
+            return s.find(substr, start, end)
+        return s.find(substr, start)
+    return s.find(substr)
+
+def rfind(s: str, substr: str, start: Optional[int] = None, end: Optional[int] = None) -> int:
+    if start is not None:
+        if end is not None:
+            return s.rfind(substr, start, end)
+        return s.rfind(substr, start)
+    return s.rfind(substr)
 
 s = "abc"
 
+def test_contains() -> None:
+    assert contains(s, "a") is True
+    assert contains(s, "abc") is True
+    assert contains(s, "Hello") is False
+    assert contains(s, "bc") is True
+    assert contains(s, "abcd") is False
+    assert contains(s, "bb") is False
+    assert contains(s, "") is True
+    assert contains(s, " ") is False
+
 def test_getitem() -> None:
     assert getitem(s, 0) == "a"
     assert getitem(s, 1) == "b"
@@ -85,6 +206,26 @@ def test_getitem() -> None:
     with assertRaises(IndexError, "string index out of range"):
         getitem(s, -4)
 
+def test_find() -> None:
+    s = "abcab"
+    assert find(s, "Hello") == -1
+    assert find(s, "abc") == 0
+    assert find(s, "b") == 1
+    assert find(s, "b", 1) == 1
+    assert find(s, "b", 1, 2) == 1
+    assert find(s, "b", 3) == 4
+    assert find(s, "b", 3, 5) == 4
+    assert find(s, "b", 3, 4) == -1
+
+    assert rfind(s, "Hello") == -1
+    assert rfind(s, "abc") == 0
+    assert rfind(s, "b") == 4
+    assert rfind(s, "b", 1) == 4
+    assert rfind(s, "b", 1, 2) == 1
+    assert rfind(s, "b", 3) == 4
+    assert rfind(s, "b", 3, 5) == 4
+    assert rfind(s, "b", 3, 4) == -1
+
 def str_to_int(s: str, base: Optional[int] = None) -> int:
     if base:
         return int(s, base)
@@ -565,25 +706,32 @@ def test_chr() -> None:
     assert try_invalid(1114112)
 
 [case testOrd]
+from testutil import assertRaises
+
 def test_ord() -> None:
+    assert ord(' ') == 32
+    assert ord(' ' + str()) == 32
+    assert ord('\x00') == 0
+    assert ord('\x00' + str()) == 0
     assert ord('\ue000') == 57344
-    s = "a\xac\u1234\u20ac\U00008000"
-    # ^^^^ two-digit hex escape
-    #   ^^^^^^ four-digit Unicode escape
-    #           ^^^^^^^^^^ eight-digit Unicode escape
+    assert ord('\ue000' + str()) == 57344
+    s = "a\xac\u1234\u20ac\U00010000"
+    #     ^^^^ two-digit hex escape
+    #         ^^^^^^ four-digit Unicode escape
+    #                     ^^^^^^^^^^ eight-digit Unicode escape
     l1 = [ord(c) for c in s]
-    assert l1 == [97, 172, 4660, 8364, 32768]
+    assert l1 == [97, 172, 4660, 8364, 65536]
     u = 'abcdé'
     assert ord(u[-1]) == 233
     assert ord(b'a') == 97
     assert ord(b'a' + bytes()) == 97
-    u2 = '\U0010ffff'
+    u2 = '\U0010ffff' + str()
     assert ord(u2) == 1114111
-    try:
+    assert ord('\U0010ffff') == 1114111
+    with assertRaises(TypeError, "ord() expected a character, but a string of length 2 found"):
         ord('aa')
-        assert False
-    except TypeError:
-        pass
+    with assertRaises(TypeError):
+        ord('')
 
 [case testDecode]
 def test_decode() -> None:
@@ -639,3 +787,31 @@ def test_encode() -> None:
     assert u'\u00E1'.encode('latin1') == b'\xe1'
     with assertRaises(UnicodeEncodeError):
         u.encode('latin1')
+
+[case testUnicodeSurrogate]
+def f() -> str:
+    return "\ud800"
+
+def test_surrogate() -> None:
+    assert ord(f()) == 0xd800
+    assert ord("\udfff") == 0xdfff
+    assert repr("foobar\x00\xab\ud912\U00012345") == r"'foobar\x00«\ud912𒍅'"
+
+[case testStrip]
+def test_all_strips_default() -> None:
+    s = " a1\t"
+    assert s.lstrip() == "a1\t"
+    assert s.strip() == "a1"
+    assert s.rstrip() == " a1"
+def test_all_strips() -> None:
+    s = "xxb2yy"
+    assert s.lstrip("xy") == "b2yy"
+    assert s.strip("xy") == "b2"
+    assert s.rstrip("xy") == "xxb2"
+def test_unicode_whitespace() -> None:
+    assert "\u200A\u000D\u2009\u2020\u000Dtt\u0085\u000A".strip() == "\u2020\u000Dtt"
+def test_unicode_range() -> None:
+    assert "\u2029 \U00107581 ".lstrip() == "\U00107581 "
+    assert "\u2029 \U0010AAAA\U00104444B\u205F ".strip() == "\U0010AAAA\U00104444B"
+    assert " \u3000\u205F ".strip() == ""
+    assert "\u2029 \U00102865\u205F ".rstrip() == "\u2029 \U00102865"
diff --git a/mypyc/test-data/run-tuples.test b/mypyc/test-data/run-tuples.test
index f6c92b9c720f..1437eaef2aa5 100644
--- a/mypyc/test-data/run-tuples.test
+++ b/mypyc/test-data/run-tuples.test
@@ -97,7 +97,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 import Dict, List, NamedTuple, Optional, Tuple, Union, final
 
 class FuncIR: pass
 
@@ -121,17 +121,30 @@ 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
+import sys
+from typing import Optional
 from native import ClassIR, FuncIR, Record
 
+if sys.version_info >= (3, 14):
+    from test.support import EqualToForwardRef
+    type_forward_ref = EqualToForwardRef
+else:
+    from typing import ForwardRef
+    type_forward_ref = ForwardRef
+
 assert Record.__annotations__ == {
     'st_mtime': float,
     'st_size': int,
     'is_borrowed': bool,
     'hash': str,
     'python_path': tuple,
-    'type': ForwardRef('ClassIR'),
+    'type': type_forward_ref('ClassIR'),
     'method': FuncIR,
     'shadow_method': type,
     'classes': dict,
@@ -141,8 +154,8 @@ assert Record.__annotations__ == {
 }, Record.__annotations__
 
 [case testTupleOps]
-from typing import Tuple, List, Any, Optional
-from typing_extensions import Final
+from typing import Tuple, Final, List, Any, Optional, cast
+from testutil import assertRaises
 
 def f() -> Tuple[()]:
     return ()
@@ -250,3 +263,18 @@ TUPLE: Final[Tuple[str, ...]] = ('x', 'y')
 def test_final_boxed_tuple() -> None:
     t = TUPLE
     assert t == ('x', 'y')
+
+def test_add() -> None:
+    res = (1, 2, 3, 4)
+    assert (1, 2) + (3, 4) == res
+    with assertRaises(TypeError, 'can only concatenate tuple (not "list") to tuple'):
+        assert (1, 2) + cast(Any, [3, 4]) == res
+
+def multiply(a: Tuple[Any, ...], b: int) -> Tuple[Any, ...]:
+    return a * b
+
+def test_multiply() -> None:
+    res = (1, 1, 1)
+    assert (1,) * 3 == res
+    assert 3 * (1,) == res
+    assert multiply((1,), 3) == res
diff --git a/mypyc/test-data/run-u8.test b/mypyc/test-data/run-u8.test
new file mode 100644
index 000000000000..c8580f05e31c
--- /dev/null
+++ b/mypyc/test-data/run-u8.test
@@ -0,0 +1,302 @@
+[case testU8BasicOps]
+from typing import Any, Final, Tuple
+
+from mypy_extensions import u8, i16, i32, i64
+
+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_alwaysdefined.py b/mypyc/test/test_alwaysdefined.py
index d6c4214ba6a2..9f1487a89bfa 100644
--- a/mypyc/test/test_alwaysdefined.py
+++ b/mypyc/test/test_alwaysdefined.py
@@ -31,7 +31,7 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
             return
         with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
             try:
-                ir = build_ir_for_single_file2(testcase.input, options)
+                ir = build_ir_for_single_file2(testcase.input, options)[0]
             except CompileError as e:
                 actual = e.messages
             else:
diff --git a/mypyc/test/test_annotate.py b/mypyc/test/test_annotate.py
new file mode 100644
index 000000000000..4a9a2c1a1b93
--- /dev/null
+++ b/mypyc/test/test_annotate.py
@@ -0,0 +1,71 @@
+"""Test cases for annotating source code to highlight inefficiencies."""
+
+from __future__ import annotations
+
+import os.path
+
+from mypy.errors import CompileError
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase
+from mypyc.annotate import generate_annotations, get_max_prio
+from mypyc.ir.pprint import format_func
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file2,
+    infer_ir_build_options_from_test_name,
+    remove_comment_lines,
+    use_custom_builtins,
+)
+
+files = ["annotate-basic.test"]
+
+
+class TestReport(MypycDataSuite):
+    files = files
+    base_path = test_temp_dir
+    optional_out = True
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        """Perform a runtime checking transformation test case."""
+        options = infer_ir_build_options_from_test_name(testcase.name)
+        if options is None:
+            # Skipped test case
+            return
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
+            expected_output = remove_comment_lines(testcase.output)
+
+            # Parse "# A: <message>" comments.
+            for i, line in enumerate(testcase.input):
+                if "# A:" in line:
+                    msg = line.rpartition("# A:")[2].strip()
+                    expected_output.append(f"main:{i + 1}: {msg}")
+
+            ir = None
+            try:
+                ir, tree, type_map, mapper = build_ir_for_single_file2(testcase.input, options)
+            except CompileError as e:
+                actual = e.messages
+            else:
+                annotations = generate_annotations("native.py", tree, ir, type_map, mapper)
+                actual = []
+                for line_num, line_anns in sorted(
+                    annotations.annotations.items(), key=lambda it: it[0]
+                ):
+                    anns = get_max_prio(line_anns)
+                    str_anns = [a.message for a in anns]
+                    s = " ".join(str_anns)
+                    actual.append(f"main:{line_num}: {s}")
+
+            try:
+                assert_test_output(testcase, actual, "Invalid source code output", expected_output)
+            except BaseException:
+                if ir:
+                    print("Generated IR:\n")
+                    for fn in ir.functions:
+                        if fn.name == "__top_level__":
+                            continue
+                        for s in format_func(fn):
+                            print(s)
+                raise
diff --git a/mypyc/test/test_cheader.py b/mypyc/test/test_cheader.py
index cc0fd9df2b34..7ab055c735ad 100644
--- a/mypyc/test/test_cheader.py
+++ b/mypyc/test/test_cheader.py
@@ -7,8 +7,8 @@
 import re
 import unittest
 
+from mypyc.ir.ops import PrimitiveDescription
 from mypyc.primitives import registry
-from mypyc.primitives.registry import CFunctionDescription
 
 
 class TestHeaderInclusion(unittest.TestCase):
@@ -27,15 +27,16 @@ def check_name(name: str) -> None:
 
         for values in [
             registry.method_call_ops.values(),
-            registry.function_ops.values(),
             registry.binary_ops.values(),
             registry.unary_ops.values(),
+            registry.function_ops.values(),
         ]:
             for ops in values:
-                if isinstance(ops, CFunctionDescription):
+                if isinstance(ops, PrimitiveDescription):
                     ops = [ops]
                 for op in ops:
-                    check_name(op.c_function_name)
+                    if op.c_function_name is not None:
+                        check_name(op.c_function_name)
 
         primitives_path = os.path.join(os.path.dirname(__file__), "..", "primitives")
         for fnam in glob.glob(f"{primitives_path}/*.py"):
diff --git a/mypyc/test/test_emit.py b/mypyc/test/test_emit.py
index 54bf4eef3c74..1baed3964299 100644
--- a/mypyc/test/test_emit.py
+++ b/mypyc/test/test_emit.py
@@ -3,8 +3,21 @@
 import unittest
 
 from mypyc.codegen.emit import Emitter, EmitterContext
+from mypyc.common import HAVE_IMMORTAL
+from mypyc.ir.class_ir import ClassIR
 from mypyc.ir.ops import BasicBlock, Register, Value
-from mypyc.ir.rtypes import int_rprimitive
+from mypyc.ir.rtypes import (
+    RInstance,
+    RTuple,
+    RUnion,
+    bool_rprimitive,
+    int_rprimitive,
+    list_rprimitive,
+    none_rprimitive,
+    object_rprimitive,
+    str_rprimitive,
+)
+from mypyc.irbuild.vtable import compute_vtable
 from mypyc.namegen import NameGenerator
 
 
@@ -12,10 +25,15 @@ class TestEmitter(unittest.TestCase):
     def setUp(self) -> None:
         self.n = Register(int_rprimitive, "n")
         self.context = EmitterContext(NameGenerator([["mod"]]))
+        self.emitter = Emitter(self.context, {})
+
+        ir = ClassIR("A", "mod")
+        compute_vtable(ir)
+        ir.mro = [ir]
+        self.instance_a = RInstance(ir)
 
     def test_label(self) -> None:
-        emitter = Emitter(self.context, {})
-        assert emitter.label(BasicBlock(4)) == "CPyL4"
+        assert self.emitter.label(BasicBlock(4)) == "CPyL4"
 
     def test_reg(self) -> None:
         names: dict[Value, str] = {self.n: "n"}
@@ -23,17 +41,16 @@ def test_reg(self) -> None:
         assert emitter.reg(self.n) == "cpy_r_n"
 
     def test_object_annotation(self) -> None:
-        emitter = Emitter(self.context, {})
-        assert emitter.object_annotation("hello, world", "line;") == " /* 'hello, world' */"
+        assert self.emitter.object_annotation("hello, world", "line;") == " /* 'hello, world' */"
         assert (
-            emitter.object_annotation(list(range(30)), "line;")
+            self.emitter.object_annotation(list(range(30)), "line;")
             == """\
  /* [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] */"""
         )
 
     def test_emit_line(self) -> None:
-        emitter = Emitter(self.context, {})
+        emitter = self.emitter
         emitter.emit_line("line;")
         emitter.emit_line("a {")
         emitter.emit_line("f();")
@@ -49,3 +66,105 @@ 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 = self.emitter
+        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 = self.emitter
+        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 }"
+        )
+
+    def test_emit_inc_ref_object(self) -> None:
+        self.emitter.emit_inc_ref("x", object_rprimitive)
+        self.assert_output("CPy_INCREF(x);\n")
+
+    def test_emit_inc_ref_int(self) -> None:
+        self.emitter.emit_inc_ref("x", int_rprimitive)
+        self.assert_output("CPyTagged_INCREF(x);\n")
+
+    def test_emit_inc_ref_rare(self) -> None:
+        self.emitter.emit_inc_ref("x", object_rprimitive, rare=True)
+        self.assert_output("CPy_INCREF(x);\n")
+        self.emitter.emit_inc_ref("x", int_rprimitive, rare=True)
+        self.assert_output("CPyTagged_IncRef(x);\n")
+
+    def test_emit_inc_ref_list(self) -> None:
+        self.emitter.emit_inc_ref("x", list_rprimitive)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_INCREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_INCREF(x);\n")
+
+    def test_emit_inc_ref_instance(self) -> None:
+        self.emitter.emit_inc_ref("x", self.instance_a)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_INCREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_INCREF(x);\n")
+
+    def test_emit_inc_ref_optional(self) -> None:
+        optional = RUnion([self.instance_a, none_rprimitive])
+        self.emitter.emit_inc_ref("o", optional)
+        self.assert_output("CPy_INCREF(o);\n")
+
+    def test_emit_dec_ref_object(self) -> None:
+        self.emitter.emit_dec_ref("x", object_rprimitive)
+        self.assert_output("CPy_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", object_rprimitive, is_xdec=True)
+        self.assert_output("CPy_XDECREF(x);\n")
+
+    def test_emit_dec_ref_int(self) -> None:
+        self.emitter.emit_dec_ref("x", int_rprimitive)
+        self.assert_output("CPyTagged_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", int_rprimitive, is_xdec=True)
+        self.assert_output("CPyTagged_XDECREF(x);\n")
+
+    def test_emit_dec_ref_rare(self) -> None:
+        self.emitter.emit_dec_ref("x", object_rprimitive, rare=True)
+        self.assert_output("CPy_DecRef(x);\n")
+        self.emitter.emit_dec_ref("x", int_rprimitive, rare=True)
+        self.assert_output("CPyTagged_DecRef(x);\n")
+
+    def test_emit_dec_ref_list(self) -> None:
+        self.emitter.emit_dec_ref("x", list_rprimitive)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_DECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", list_rprimitive, is_xdec=True)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_XDECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_XDECREF(x);\n")
+
+    def test_emit_dec_ref_instance(self) -> None:
+        self.emitter.emit_dec_ref("x", self.instance_a)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_DECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_DECREF(x);\n")
+        self.emitter.emit_dec_ref("x", self.instance_a, is_xdec=True)
+        if HAVE_IMMORTAL:
+            self.assert_output("CPy_XDECREF_NO_IMM(x);\n")
+        else:
+            self.assert_output("CPy_XDECREF(x);\n")
+
+    def test_emit_dec_ref_optional(self) -> None:
+        optional = RUnion([self.instance_a, none_rprimitive])
+        self.emitter.emit_dec_ref("o", optional)
+        self.assert_output("CPy_DECREF(o);\n")
+
+    def assert_output(self, expected: str) -> None:
+        assert "".join(self.emitter.fragments) == expected
+        self.emitter.fragments = []
diff --git a/mypyc/test/test_emitfunc.py b/mypyc/test/test_emitfunc.py
index ab1586bb22a8..275e8c383a4b 100644
--- a/mypyc/test/test_emitfunc.py
+++ b/mypyc/test/test_emitfunc.py
@@ -5,7 +5,7 @@
 from mypy.test.helpers import assert_string_arrays_equal
 from mypyc.codegen.emit import Emitter, EmitterContext
 from mypyc.codegen.emitfunc import FunctionEmitterVisitor, generate_native_function
-from mypyc.common import PLATFORM_SIZE
+from mypyc.common import HAVE_IMMORTAL, PLATFORM_SIZE
 from mypyc.ir.class_ir import ClassIR
 from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature, RuntimeArg
 from mypyc.ir.ops import (
@@ -28,6 +28,7 @@
     Integer,
     IntOp,
     LoadAddress,
+    LoadLiteral,
     LoadMem,
     Op,
     Register,
@@ -53,6 +54,7 @@
     int64_rprimitive,
     int_rprimitive,
     list_rprimitive,
+    none_rprimitive,
     object_rprimitive,
     pointer_rprimitive,
     short_int_rprimitive,
@@ -114,6 +116,7 @@ def add_local(name: str, rtype: RType) -> Register:
         compute_vtable(ir)
         ir.mro = [ir]
         self.r = add_local("r", RInstance(ir))
+        self.none = add_local("none", none_rprimitive)
 
         self.context = EmitterContext(NameGenerator([["mod"]]))
 
@@ -134,7 +137,7 @@ def test_integer(self) -> None:
     def test_tuple_get(self) -> None:
         self.assert_emit(TupleGet(self.t, 1, 0), "cpy_r_r0 = cpy_r_t.f1;")
 
-    def test_load_None(self) -> None:
+    def test_load_None(self) -> None:  # noqa: N802
         self.assert_emit(
             LoadAddress(none_object_op.type, none_object_op.src, 0),
             "cpy_r_r0 = (PyObject *)&_Py_NoneStruct;",
@@ -154,6 +157,7 @@ def test_int_sub(self) -> None:
         )
 
     def test_int_neg(self) -> None:
+        assert int_neg_op.c_function_name is not None
         self.assert_emit(
             CallC(
                 int_neg_op.c_function_name,
@@ -302,7 +306,7 @@ def test_dec_ref_tuple_nested(self) -> None:
     def test_list_get_item(self) -> None:
         self.assert_emit(
             CallC(
-                list_get_item_op.c_function_name,
+                str(list_get_item_op.c_function_name),
                 [self.m, self.k],
                 list_get_item_op.return_type,
                 list_get_item_op.steals,
@@ -316,7 +320,7 @@ def test_list_get_item(self) -> None:
     def test_list_set_item(self) -> None:
         self.assert_emit(
             CallC(
-                list_set_item_op.c_function_name,
+                str(list_set_item_op.c_function_name),
                 [self.l, self.n, self.o],
                 list_set_item_op.return_type,
                 list_set_item_op.steals,
@@ -352,7 +356,7 @@ def test_unbox_i64(self) -> None:
     def test_list_append(self) -> None:
         self.assert_emit(
             CallC(
-                list_append_op.c_function_name,
+                str(list_append_op.c_function_name),
                 [self.l, self.o],
                 list_append_op.return_type,
                 list_append_op.steals,
@@ -492,7 +496,7 @@ def test_set_attr_init_with_bitmap(self) -> None:
     def test_dict_get_item(self) -> None:
         self.assert_emit(
             CallC(
-                dict_get_item_op.c_function_name,
+                str(dict_get_item_op.c_function_name),
                 [self.d, self.o2],
                 dict_get_item_op.return_type,
                 dict_get_item_op.steals,
@@ -506,7 +510,7 @@ def test_dict_get_item(self) -> None:
     def test_dict_set_item(self) -> None:
         self.assert_emit(
             CallC(
-                dict_set_item_op.c_function_name,
+                str(dict_set_item_op.c_function_name),
                 [self.d, self.o, self.o2],
                 dict_set_item_op.return_type,
                 dict_set_item_op.steals,
@@ -520,7 +524,7 @@ def test_dict_set_item(self) -> None:
     def test_dict_update(self) -> None:
         self.assert_emit(
             CallC(
-                dict_update_op.c_function_name,
+                str(dict_update_op.c_function_name),
                 [self.d, self.o],
                 dict_update_op.return_type,
                 dict_update_op.steals,
@@ -804,9 +808,25 @@ def test_extend(self) -> None:
                 Extend(a, int_rprimitive, signed=False), """cpy_r_r0 = (uint32_t)cpy_r_a;"""
             )
 
+    def test_inc_ref_none(self) -> None:
+        b = Box(self.none)
+        self.assert_emit([b, IncRef(b)], "" if HAVE_IMMORTAL else "CPy_INCREF(cpy_r_r0);")
+
+    def test_inc_ref_bool(self) -> None:
+        b = Box(self.b)
+        self.assert_emit([b, IncRef(b)], "" if HAVE_IMMORTAL else "CPy_INCREF(cpy_r_r0);")
+
+    def test_inc_ref_int_literal(self) -> None:
+        for x in -5, 0, 1, 5, 255, 256:
+            b = LoadLiteral(x, object_rprimitive)
+            self.assert_emit([b, IncRef(b)], "" if HAVE_IMMORTAL else "CPy_INCREF(cpy_r_r0);")
+        for x in -1123355, -6, 257, 123235345:
+            b = LoadLiteral(x, object_rprimitive)
+            self.assert_emit([b, IncRef(b)], "CPy_INCREF(cpy_r_r0);")
+
     def assert_emit(
         self,
-        op: Op,
+        op: Op | list[Op],
         expected: str,
         next_block: BasicBlock | None = None,
         *,
@@ -815,7 +835,11 @@ def assert_emit(
         skip_next: bool = False,
     ) -> None:
         block = BasicBlock(0)
-        block.ops.append(op)
+        if isinstance(op, Op):
+            block.ops.append(op)
+        else:
+            block.ops.extend(op)
+            op = op[-1]
         value_names = generate_names_for_ir(self.registers, [block])
         emitter = Emitter(self.context, value_names)
         declarations = Emitter(self.context, value_names)
@@ -841,7 +865,9 @@ def assert_emit(
         else:
             expected_lines = expected.rstrip().split("\n")
         expected_lines = [line.strip(" ") for line in expected_lines]
-        assert_string_arrays_equal(expected_lines, actual_lines, msg="Generated code unexpected")
+        assert_string_arrays_equal(
+            expected_lines, actual_lines, msg="Generated code unexpected", traceback=True
+        )
         if skip_next:
             assert visitor.op_index == 1
         else:
@@ -859,6 +885,8 @@ def assert_emit_binary_op(
                     args = [left, right]
                     if desc.ordering is not None:
                         args = [args[i] for i in desc.ordering]
+                    # This only supports primitives that map to C calls
+                    assert desc.c_function_name is not None
                     self.assert_emit(
                         CallC(
                             desc.c_function_name,
diff --git a/mypyc/test/test_external.py b/mypyc/test/test_external.py
index 6deabd81255e..010c74dee42e 100644
--- a/mypyc/test/test_external.py
+++ b/mypyc/test/test_external.py
@@ -5,6 +5,7 @@
 import os
 import subprocess
 import sys
+import tempfile
 import unittest
 
 base_dir = os.path.join(os.path.dirname(__file__), "..", "..")
@@ -16,34 +17,35 @@ class TestExternal(unittest.TestCase):
     @unittest.skipIf(sys.platform.startswith("win"), "rt tests don't work on windows")
     def test_c_unit_test(self) -> None:
         """Run C unit tests in a subprocess."""
-        # Build Google Test, the C++ framework we use for testing C code.
-        # The source code for Google Test is copied to this repository.
         cppflags: list[str] = []
         env = os.environ.copy()
         if sys.platform == "darwin":
-            cppflags += ["-mmacosx-version-min=10.10", "-stdlib=libc++"]
+            cppflags += ["-O0", "-mmacosx-version-min=10.10", "-stdlib=libc++"]
+        elif sys.platform == "linux":
+            cppflags += ["-O0"]
         env["CPPFLAGS"] = " ".join(cppflags)
-        subprocess.check_call(
-            ["make", "libgtest.a"],
-            env=env,
-            cwd=os.path.join(base_dir, "mypyc", "external", "googletest", "make"),
-        )
         # Build Python wrapper for C unit tests.
-        env = os.environ.copy()
-        env["CPPFLAGS"] = " ".join(cppflags)
-        status = subprocess.check_call(
-            [sys.executable, "setup.py", "build_ext", "--inplace"],
-            env=env,
-            cwd=os.path.join(base_dir, "mypyc", "lib-rt"),
-        )
-        # Run C unit tests.
-        env = os.environ.copy()
-        if "GTEST_COLOR" not in os.environ:
-            env["GTEST_COLOR"] = "yes"  # Use fancy colors
-        status = subprocess.call(
-            [sys.executable, "-c", "import sys, test_capi; sys.exit(test_capi.run_tests())"],
-            env=env,
-            cwd=os.path.join(base_dir, "mypyc", "lib-rt"),
-        )
-        if status != 0:
-            raise AssertionError("make test: C unit test failure")
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            status = subprocess.check_call(
+                [
+                    sys.executable,
+                    "setup.py",
+                    "build_ext",
+                    f"--build-lib={tmpdir}",
+                    f"--build-temp={tmpdir}",
+                ],
+                env=env,
+                cwd=os.path.join(base_dir, "mypyc", "lib-rt"),
+            )
+            # Run C unit tests.
+            env = os.environ.copy()
+            if "GTEST_COLOR" not in os.environ:
+                env["GTEST_COLOR"] = "yes"  # Use fancy colors
+            status = subprocess.call(
+                [sys.executable, "-c", "import sys, test_capi; sys.exit(test_capi.run_tests())"],
+                env=env,
+                cwd=tmpdir,
+            )
+            if status != 0:
+                raise AssertionError("make test: C unit test failure")
diff --git a/mypyc/test/test_irbuild.py b/mypyc/test/test_irbuild.py
index fe347c855661..9c0ad06416a7 100644
--- a/mypyc/test/test_irbuild.py
+++ b/mypyc/test/test_irbuild.py
@@ -32,6 +32,7 @@
     "irbuild-str.test",
     "irbuild-bytes.test",
     "irbuild-float.test",
+    "irbuild-frozenset.test",
     "irbuild-statements.test",
     "irbuild-nested.test",
     "irbuild-classes.test",
@@ -42,6 +43,8 @@
     "irbuild-strip-asserts.test",
     "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 008963642272..7f7063cdc5e6 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_lowering.py b/mypyc/test/test_lowering.py
new file mode 100644
index 000000000000..86745b6d390b
--- /dev/null
+++ b/mypyc/test/test_lowering.py
@@ -0,0 +1,61 @@
+"""Runner for lowering transform tests."""
+
+from __future__ import annotations
+
+import os.path
+
+from mypy.errors import CompileError
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase
+from mypyc.common import TOP_LEVEL_NAME
+from mypyc.ir.pprint import format_func
+from mypyc.options import CompilerOptions
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file,
+    infer_ir_build_options_from_test_name,
+    remove_comment_lines,
+    replace_word_size,
+    use_custom_builtins,
+)
+from mypyc.transform.exceptions import insert_exception_handling
+from mypyc.transform.flag_elimination import do_flag_elimination
+from mypyc.transform.lower import lower_ir
+from mypyc.transform.refcount import insert_ref_count_opcodes
+from mypyc.transform.uninit import insert_uninit_checks
+
+
+class TestLowering(MypycDataSuite):
+    files = ["lowering-int.test", "lowering-list.test"]
+    base_path = test_temp_dir
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        options = infer_ir_build_options_from_test_name(testcase.name)
+        if options is None:
+            # Skipped test case
+            return
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
+            expected_output = remove_comment_lines(testcase.output)
+            expected_output = replace_word_size(expected_output)
+            try:
+                ir = build_ir_for_single_file(testcase.input, options)
+            except CompileError as e:
+                actual = e.messages
+            else:
+                actual = []
+                for fn in ir:
+                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith("_toplevel"):
+                        continue
+                    options = CompilerOptions()
+                    # Lowering happens after exception handling and ref count opcodes have
+                    # been added. Any changes must maintain reference counting semantics.
+                    insert_uninit_checks(fn)
+                    insert_exception_handling(fn)
+                    insert_ref_count_opcodes(fn)
+                    lower_ir(fn, options)
+                    do_flag_elimination(fn, options)
+                    actual.extend(format_func(fn))
+
+            assert_test_output(testcase, actual, "Invalid source code output", expected_output)
diff --git a/mypyc/test/test_misc.py b/mypyc/test/test_misc.py
new file mode 100644
index 000000000000..f92da2ca3fe1
--- /dev/null
+++ b/mypyc/test/test_misc.py
@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import unittest
+
+from mypyc.ir.ops import BasicBlock
+from mypyc.ir.pprint import format_blocks, generate_names_for_ir
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+from mypyc.options import CompilerOptions
+
+
+class TestMisc(unittest.TestCase):
+    def test_debug_op(self) -> None:
+        block = BasicBlock()
+        builder = LowLevelIRBuilder(errors=None, options=CompilerOptions())
+        builder.activate_block(block)
+        builder.debug_print("foo")
+
+        names = generate_names_for_ir([], [block])
+        code = format_blocks([block], names, {})
+        assert code[:-1] == ["L0:", "    r0 = 'foo'", "    CPyDebug_PrintObject(r0)"]
diff --git a/mypyc/test/test_namegen.py b/mypyc/test/test_namegen.py
index 509018b4c3bd..f88edbd00dce 100644
--- a/mypyc/test/test_namegen.py
+++ b/mypyc/test/test_namegen.py
@@ -35,6 +35,12 @@ def test_make_module_translation_map(self) -> None:
             "fu.bar": "fu.bar.",
             "foo.baz": "baz.",
         }
+        assert make_module_translation_map(["foo", "foo.foo", "bar.foo", "bar.foo.bar.foo"]) == {
+            "foo": "foo.",
+            "foo.foo": "foo.foo.",
+            "bar.foo": "bar.foo.",
+            "bar.foo.bar.foo": "foo.bar.foo.",
+        }
 
     def test_name_generator(self) -> None:
         g = NameGenerator([["foo", "foo.zar"]])
diff --git a/mypyc/test/test_optimizations.py b/mypyc/test/test_optimizations.py
new file mode 100644
index 000000000000..3f1f46ac1dd7
--- /dev/null
+++ b/mypyc/test/test_optimizations.py
@@ -0,0 +1,68 @@
+"""Runner for IR optimization tests."""
+
+from __future__ import annotations
+
+import os.path
+
+from mypy.errors import CompileError
+from mypy.test.config import test_temp_dir
+from mypy.test.data import DataDrivenTestCase
+from mypyc.common import TOP_LEVEL_NAME
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.pprint import format_func
+from mypyc.options import CompilerOptions
+from mypyc.test.testutil import (
+    ICODE_GEN_BUILTINS,
+    MypycDataSuite,
+    assert_test_output,
+    build_ir_for_single_file,
+    remove_comment_lines,
+    use_custom_builtins,
+)
+from mypyc.transform.copy_propagation import do_copy_propagation
+from mypyc.transform.flag_elimination import do_flag_elimination
+from mypyc.transform.uninit import insert_uninit_checks
+
+
+class OptimizationSuite(MypycDataSuite):
+    """Base class for IR optimization test suites.
+
+    To use this, add a base class and define "files" and "do_optimizations".
+    """
+
+    base_path = test_temp_dir
+
+    def run_case(self, testcase: DataDrivenTestCase) -> None:
+        with use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase):
+            expected_output = remove_comment_lines(testcase.output)
+            try:
+                ir = build_ir_for_single_file(testcase.input)
+            except CompileError as e:
+                actual = e.messages
+            else:
+                actual = []
+                for fn in ir:
+                    if fn.name == TOP_LEVEL_NAME and not testcase.name.endswith("_toplevel"):
+                        continue
+                    insert_uninit_checks(fn)
+                    self.do_optimizations(fn)
+                    actual.extend(format_func(fn))
+
+            assert_test_output(testcase, actual, "Invalid source code output", expected_output)
+
+    def do_optimizations(self, fn: FuncIR) -> None:
+        raise NotImplementedError
+
+
+class TestCopyPropagation(OptimizationSuite):
+    files = ["opt-copy-propagation.test"]
+
+    def do_optimizations(self, fn: FuncIR) -> None:
+        do_copy_propagation(fn, CompilerOptions())
+
+
+class TestFlagElimination(OptimizationSuite):
+    files = ["opt-flag-elimination.test"]
+
+    def do_optimizations(self, fn: FuncIR) -> None:
+        do_flag_elimination(fn, CompilerOptions())
diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py
index dc054ac9002f..e5b7e2421433 100644
--- a/mypyc/test/test_run.py
+++ b/mypyc/test/test_run.py
@@ -11,18 +11,20 @@
 import subprocess
 import sys
 import time
-from typing import Any, Iterator
+from collections.abc import Iterator
+from typing import Any
 
 from mypy import build
 from mypy.errors import CompileError
-from mypy.options import TYPE_VAR_TUPLE, UNPACK, Options
-from mypy.test.config import test_temp_dir
+from mypy.options import Options
+from mypy.test.config import mypyc_output_dir, test_temp_dir
 from mypy.test.data import DataDrivenTestCase
 from mypy.test.helpers import assert_module_equivalence, perform_file_operations
 from mypyc.build import construct_groups
 from mypyc.codegen import emitmodule
 from mypyc.errors import Errors
 from mypyc.options import CompilerOptions
+from mypyc.test.config import test_data_prefix
 from mypyc.test.test_serialization import check_serialization_roundtrip
 from mypyc.test.testutil import (
     ICODE_GEN_BUILTINS,
@@ -41,6 +43,8 @@
     "run-integers.test",
     "run-i64.test",
     "run-i32.test",
+    "run-i16.test",
+    "run-u8.test",
     "run-floats.test",
     "run-math.test",
     "run-bools.test",
@@ -57,20 +61,22 @@
     "run-classes.test",
     "run-traits.test",
     "run-generators.test",
+    "run-generics.test",
     "run-multimodule.test",
     "run-bench.test",
     "run-mypy-sim.test",
     "run-dunders.test",
+    "run-dunders-special.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")
+if sys.version_info >= (3, 12):
+    files.append("run-python312.test")
 
 setup_format = """\
 from setuptools import setup
@@ -138,13 +144,15 @@ class TestRun(MypycDataSuite):
     optional_out = True
     multi_file = False
     separate = False  # If True, using separate (incremental) compilation
+    strict_dunder_typing = False
 
     def run_case(self, testcase: DataDrivenTestCase) -> None:
         # setup.py wants to be run from the root directory of the package, which we accommodate
         # by chdiring into tmp/
-        with use_custom_builtins(
-            os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase
-        ), chdir_manager("tmp"):
+        with (
+            use_custom_builtins(os.path.join(self.data_prefix, ICODE_GEN_BUILTINS), testcase),
+            chdir_manager("tmp"),
+        ):
             self.run_case_inner(testcase)
 
     def run_case_inner(self, testcase: DataDrivenTestCase) -> None:
@@ -172,12 +180,10 @@ def run_case_inner(self, testcase: DataDrivenTestCase) -> None:
             # new by distutils, shift the mtime of all of the
             # generated artifacts back by a second.
             fudge_dir_mtimes(WORKDIR, -1)
-            # On Ubuntu, changing the mtime doesn't work reliably. As
+            # On some OS, changing the mtime doesn't work reliably. As
             # a workaround, sleep.
-            #
             # TODO: Figure out a better approach, since this slows down tests.
-            if sys.platform == "linux":
-                time.sleep(1.0)
+            time.sleep(1.0)
 
             step += 1
             with chdir_manager(".."):
@@ -196,7 +202,6 @@ def run_case_step(self, testcase: DataDrivenTestCase, incremental_step: int) ->
         options.preserve_asts = True
         options.allow_empty_bodies = True
         options.incremental = self.separate
-        options.enable_incomplete_feature = [TYPE_VAR_TUPLE, UNPACK]
 
         # Avoid checking modules/packages named 'unchecked', to provide a way
         # to test interacting with code we don't have types for.
@@ -233,7 +238,11 @@ def run_case_step(self, testcase: DataDrivenTestCase, incremental_step: int) ->
         groups = construct_groups(sources, separate, len(module_names) > 1)
 
         try:
-            compiler_options = CompilerOptions(multi_file=self.multi_file, separate=self.separate)
+            compiler_options = CompilerOptions(
+                multi_file=self.multi_file,
+                separate=self.separate,
+                strict_dunder_typing=self.strict_dunder_typing,
+            )
             result = emitmodule.parse_and_typecheck(
                 sources=sources,
                 options=options,
@@ -242,7 +251,7 @@ def run_case_step(self, testcase: DataDrivenTestCase, incremental_step: int) ->
                 alt_lib_path=".",
             )
             errors = Errors(options)
-            ir, cfiles = emitmodule.compile_modules_to_c(
+            ir, cfiles, _ = emitmodule.compile_modules_to_c(
                 result, compiler_options=compiler_options, errors=errors, groups=groups
             )
             if errors.num_errors:
@@ -273,6 +282,7 @@ def run_case_step(self, testcase: DataDrivenTestCase, incremental_step: int) ->
         if not run_setup(setup_file, ["build_ext", "--inplace"]):
             if testcase.config.getoption("--mypyc-showc"):
                 show_c(cfiles)
+            copy_output_files(mypyc_output_dir)
             assert False, "Compilation failed"
 
         # Assert that an output file got created
@@ -284,9 +294,7 @@ def run_case_step(self, testcase: DataDrivenTestCase, incremental_step: int) ->
             # No driver.py provided by test case. Use the default one
             # (mypyc/test-data/driver/driver.py) that calls each
             # function named test_*.
-            default_driver = os.path.join(
-                os.path.dirname(__file__), "..", "test-data", "driver", "driver.py"
-            )
+            default_driver = os.path.join(test_data_prefix, "driver", "driver.py")
             shutil.copy(default_driver, driver_path)
         env = os.environ.copy()
         env["MYPYC_RUN_BENCH"] = "1" if bench else "0"
@@ -315,13 +323,30 @@ def run_case_step(self, testcase: DataDrivenTestCase, incremental_step: int) ->
             # TODO: testDecorators1 hangs on 3.12, remove this once fixed
             proc.wait(timeout=30)
         output = proc.communicate()[0].decode("utf8")
+        output = output.replace(f'  File "{os.getcwd()}{os.sep}', '  File "')
         outlines = output.splitlines()
 
         if testcase.config.getoption("--mypyc-showc"):
             show_c(cfiles)
         if proc.returncode != 0:
             print()
-            print("*** Exit status: %d" % proc.returncode)
+            signal = proc.returncode == -11
+            extra = ""
+            if signal:
+                extra = " (likely segmentation fault)"
+            print(f"*** Exit status: {proc.returncode}{extra}")
+            if signal and not sys.platform.startswith("win"):
+                print()
+                if sys.platform == "darwin":
+                    debugger = "lldb"
+                else:
+                    debugger = "gdb"
+                print(
+                    f'hint: Use "pytest -n0 -s --mypyc-debug={debugger} -k <name-substring>" to run test in debugger'
+                )
+                print("hint: You may need to build a debug version of Python first and use it")
+                print('hint: See also "Debugging Segfaults" in mypyc/doc/dev-intro.md')
+            copy_output_files(mypyc_output_dir)
 
         # Verify output.
         if bench:
@@ -402,6 +427,14 @@ class TestRunSeparate(TestRun):
     files = ["run-multimodule.test", "run-mypy-sim.test"]
 
 
+class TestRunStrictDunderTyping(TestRun):
+    """Run the tests with strict dunder typing."""
+
+    strict_dunder_typing = True
+    test_name_suffix = "_dunder_typing"
+    files = ["run-dunders.test", "run-floats.test"]
+
+
 def fix_native_line_number(message: str, fnam: str, delta: int) -> str:
     """Update code locations in test case output to point to the .test file.
 
@@ -427,3 +460,17 @@ def fix_native_line_number(message: str, fnam: str, delta: int) -> str:
         message,
     )
     return message
+
+
+def copy_output_files(target_dir: str) -> None:
+    try:
+        os.mkdir(target_dir)
+    except OSError:
+        # Only copy data for the first failure, to avoid excessive output in case
+        # many tests fail
+        return
+
+    for fnam in glob.glob("build/*.[ch]"):
+        shutil.copy(fnam, target_dir)
+
+    sys.stderr.write(f"\nGenerated files: {target_dir} (for first failure only)\n\n")
diff --git a/mypyc/test/test_struct.py b/mypyc/test/test_struct.py
index 2b0298cadeda..82990e6afd82 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/mypyc/test/test_typeops.py b/mypyc/test/test_typeops.py
index 0d9860d88ffe..ff2c05ad983e 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/mypyc/test/testutil.py b/mypyc/test/testutil.py
index 796811a6363c..7b56b8aa0dec 100644
--- a/mypyc/test/testutil.py
+++ b/mypyc/test/testutil.py
@@ -7,14 +7,17 @@
 import os.path
 import re
 import shutil
-from typing import Callable, Iterator
+from collections.abc import Iterator
+from typing import Callable
 
 from mypy import build
 from mypy.errors import CompileError
+from mypy.nodes import Expression, MypyFile
 from mypy.options import Options
 from mypy.test.config import test_temp_dir
 from mypy.test.data import DataDrivenTestCase, DataSuite
 from mypy.test.helpers import assert_string_arrays_equal
+from mypy.types import Type
 from mypyc.analysis.ircheck import assert_func_ir_valid
 from mypyc.common import IS_32_BIT_PLATFORM, PLATFORM_SIZE
 from mypyc.errors import Errors
@@ -92,23 +95,23 @@ def perform_test(
 def build_ir_for_single_file(
     input_lines: list[str], compiler_options: CompilerOptions | None = None
 ) -> list[FuncIR]:
-    return build_ir_for_single_file2(input_lines, compiler_options).functions
+    return build_ir_for_single_file2(input_lines, compiler_options)[0].functions
 
 
 def build_ir_for_single_file2(
     input_lines: list[str], compiler_options: CompilerOptions | None = None
-) -> ModuleIR:
+) -> tuple[ModuleIR, MypyFile, dict[Expression, Type], Mapper]:
     program_text = "\n".join(input_lines)
 
     # By default generate IR compatible with the earliest supported Python C API.
     # If a test needs more recent API features, this should be overridden.
-    compiler_options = compiler_options or CompilerOptions(capi_version=(3, 5))
+    compiler_options = compiler_options or CompilerOptions(capi_version=(3, 9))
     options = Options()
     options.show_traceback = True
     options.hide_error_codes = True
     options.use_builtins_fixtures = True
     options.strict_optional = True
-    options.python_version = compiler_options.python_version or (3, 6)
+    options.python_version = compiler_options.python_version or (3, 8)
     options.export_types = True
     options.preserve_asts = True
     options.allow_empty_bodies = True
@@ -122,13 +125,9 @@ def build_ir_for_single_file2(
         raise CompileError(result.errors)
 
     errors = Errors(options)
+    mapper = Mapper({"__main__": None})
     modules = build_ir(
-        [result.files["__main__"]],
-        result.graph,
-        result.types,
-        Mapper({"__main__": None}),
-        compiler_options,
-        errors,
+        [result.files["__main__"]], result.graph, result.types, mapper, compiler_options, errors
     )
     if errors.num_errors:
         raise CompileError(errors.new_messages())
@@ -136,7 +135,9 @@ def build_ir_for_single_file2(
     module = list(modules.values())[0]
     for fn in module.functions:
         assert_func_ir_valid(fn)
-    return module
+    tree = result.graph[module.fullname].tree
+    assert tree is not None
+    return module, tree, result.types, mapper
 
 
 def update_testcase_output(testcase: DataDrivenTestCase, output: list[str]) -> None:
@@ -272,8 +273,8 @@ def infer_ir_build_options_from_test_name(name: str) -> CompilerOptions | None:
         return None
     if "_32bit" in name and not IS_32_BIT_PLATFORM:
         return None
-    options = CompilerOptions(strip_asserts="StripAssert" in name, capi_version=(3, 5))
-    # A suffix like _python3.8 is used to set the target C API version.
+    options = CompilerOptions(strip_asserts="StripAssert" in name, capi_version=(3, 9))
+    # A suffix like _python3_9 is used to set the target C API version.
     m = re.search(r"_python([3-9]+)_([0-9]+)(_|\b)", name)
     if m:
         options.capi_version = (int(m.group(1)), int(m.group(2)))
diff --git a/mypyc/transform/copy_propagation.py b/mypyc/transform/copy_propagation.py
new file mode 100644
index 000000000000..49de616f85a3
--- /dev/null
+++ b/mypyc/transform/copy_propagation.py
@@ -0,0 +1,94 @@
+"""Simple copy propagation optimization.
+
+Example input:
+
+    x = f()
+    y = x
+
+The register x is redundant and we can directly assign its value to y:
+
+    y = f()
+
+This can optimize away registers that are assigned to once.
+"""
+
+from __future__ import annotations
+
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.ops import Assign, AssignMulti, LoadAddress, LoadErrorValue, Register, Value
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+from mypyc.options import CompilerOptions
+from mypyc.sametype import is_same_type
+from mypyc.transform.ir_transform import IRTransform
+
+
+def do_copy_propagation(fn: FuncIR, options: CompilerOptions) -> None:
+    """Perform copy propagation optimization for fn."""
+
+    # Anything with an assignment count >1 will not be optimized
+    # here, as it would be require data flow analysis and we want to
+    # keep this simple and fast, at least until we've made data flow
+    # analysis much faster.
+    counts: dict[Value, int] = {}
+    replacements: dict[Value, Value] = {}
+    for arg in fn.arg_regs:
+        # Arguments are always assigned to initially
+        counts[arg] = 1
+
+    for block in fn.blocks:
+        for op in block.ops:
+            if isinstance(op, Assign):
+                c = counts.get(op.dest, 0)
+                counts[op.dest] = c + 1
+                # Does this look like a supported assignment?
+                # TODO: Something needs LoadErrorValue assignments to be preserved?
+                if (
+                    c == 0
+                    and is_same_type(op.dest.type, op.src.type)
+                    and not isinstance(op.src, LoadErrorValue)
+                ):
+                    replacements[op.dest] = op.src
+                elif c == 1:
+                    # Too many assignments -- don't replace this one
+                    replacements.pop(op.dest, 0)
+            elif isinstance(op, AssignMulti):
+                # Copy propagation not supported for AssignMulti destinations
+                counts[op.dest] = 2
+                replacements.pop(op.dest, 0)
+            elif isinstance(op, LoadAddress):
+                # We don't support taking the address of an arbitrary Value,
+                # so we'll need to preserve the operands of LoadAddress.
+                if isinstance(op.src, Register):
+                    counts[op.src] = 2
+                    replacements.pop(op.src, 0)
+
+    # Follow chains of propagation with more than one assignment.
+    for src, dst in list(replacements.items()):
+        if counts.get(dst, 0) > 1:
+            # Not supported
+            del replacements[src]
+        else:
+            while dst in replacements:
+                dst = replacements[dst]
+                if counts.get(dst, 0) > 1:
+                    # Not supported
+                    del replacements[src]
+        if src in replacements:
+            replacements[src] = dst
+
+    builder = LowLevelIRBuilder(None, options)
+    transform = CopyPropagationTransform(builder, replacements)
+    transform.transform_blocks(fn.blocks)
+    fn.blocks = builder.blocks
+
+
+class CopyPropagationTransform(IRTransform):
+    def __init__(self, builder: LowLevelIRBuilder, map: dict[Value, Value]) -> None:
+        super().__init__(builder)
+        self.op_map.update(map)
+        self.removed = set(map)
+
+    def visit_assign(self, op: Assign) -> Value | None:
+        if op.dest in self.removed:
+            return None
+        return self.add(op)
diff --git a/mypyc/transform/flag_elimination.py b/mypyc/transform/flag_elimination.py
new file mode 100644
index 000000000000..605e5bc46ae4
--- /dev/null
+++ b/mypyc/transform/flag_elimination.py
@@ -0,0 +1,108 @@
+"""Bool register elimination optimization.
+
+Example input:
+
+  L1:
+    r0 = f()
+    b = r0
+    goto L3
+  L2:
+    r1 = g()
+    b = r1
+    goto L3
+  L3:
+    if b goto L4 else goto L5
+
+The register b is redundant and we replace the assignments with two copies of
+the branch in L3:
+
+  L1:
+    r0 = f()
+    if r0 goto L4 else goto L5
+  L2:
+    r1 = g()
+    if r1 goto L4 else goto L5
+
+This helps generate simpler IR for tagged integers comparisons, for example.
+"""
+
+from __future__ import annotations
+
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.ops import Assign, BasicBlock, Branch, Goto, Register, Unreachable
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+from mypyc.options import CompilerOptions
+from mypyc.transform.ir_transform import IRTransform
+
+
+def do_flag_elimination(fn: FuncIR, options: CompilerOptions) -> None:
+    # Find registers that are used exactly once as source, and in a branch.
+    counts: dict[Register, int] = {}
+    branches: dict[Register, Branch] = {}
+    labels: dict[Register, BasicBlock] = {}
+    for block in fn.blocks:
+        for i, op in enumerate(block.ops):
+            for src in op.sources():
+                if isinstance(src, Register):
+                    counts[src] = counts.get(src, 0) + 1
+            if i == 0 and isinstance(op, Branch) and isinstance(op.value, Register):
+                branches[op.value] = op
+                labels[op.value] = block
+
+    # Based on these we can find the candidate registers.
+    candidates: set[Register] = {
+        r for r in branches if counts.get(r, 0) == 1 and r not in fn.arg_regs
+    }
+
+    # Remove candidates with invalid assignments.
+    for block in fn.blocks:
+        for i, op in enumerate(block.ops):
+            if isinstance(op, Assign) and op.dest in candidates:
+                next_op = block.ops[i + 1]
+                if not (isinstance(next_op, Goto) and next_op.label is labels[op.dest]):
+                    # Not right
+                    candidates.remove(op.dest)
+
+    builder = LowLevelIRBuilder(None, options)
+    transform = FlagEliminationTransform(
+        builder, {x: y for x, y in branches.items() if x in candidates}
+    )
+    transform.transform_blocks(fn.blocks)
+    fn.blocks = builder.blocks
+
+
+class FlagEliminationTransform(IRTransform):
+    def __init__(self, builder: LowLevelIRBuilder, branch_map: dict[Register, Branch]) -> None:
+        super().__init__(builder)
+        self.branch_map = branch_map
+        self.branches = set(branch_map.values())
+
+    def visit_assign(self, op: Assign) -> None:
+        old_branch = self.branch_map.get(op.dest)
+        if old_branch:
+            # Replace assignment with a copy of the old branch, which is in a
+            # separate basic block. The old branch will be deletecd in visit_branch.
+            new_branch = Branch(
+                op.src,
+                old_branch.true,
+                old_branch.false,
+                old_branch.op,
+                old_branch.line,
+                rare=old_branch.rare,
+            )
+            new_branch.negated = old_branch.negated
+            new_branch.traceback_entry = old_branch.traceback_entry
+            self.add(new_branch)
+        else:
+            self.add(op)
+
+    def visit_goto(self, op: Goto) -> None:
+        # This is a no-op if basic block already terminated
+        self.builder.goto(op.label)
+
+    def visit_branch(self, op: Branch) -> None:
+        if op in self.branches:
+            # This branch is optimized away
+            self.add(Unreachable())
+        else:
+            self.add(op)
diff --git a/mypyc/transform/ir_transform.py b/mypyc/transform/ir_transform.py
new file mode 100644
index 000000000000..326a5baca1e7
--- /dev/null
+++ b/mypyc/transform/ir_transform.py
@@ -0,0 +1,371 @@
+"""Helpers for implementing generic IR to IR transforms."""
+
+from __future__ import annotations
+
+from typing import Final, Optional
+
+from mypyc.ir.ops import (
+    Assign,
+    AssignMulti,
+    BasicBlock,
+    Box,
+    Branch,
+    Call,
+    CallC,
+    Cast,
+    ComparisonOp,
+    DecRef,
+    Extend,
+    FloatComparisonOp,
+    FloatNeg,
+    FloatOp,
+    GetAttr,
+    GetElementPtr,
+    Goto,
+    IncRef,
+    InitStatic,
+    IntOp,
+    KeepAlive,
+    LoadAddress,
+    LoadErrorValue,
+    LoadGlobal,
+    LoadLiteral,
+    LoadMem,
+    LoadStatic,
+    MethodCall,
+    Op,
+    OpVisitor,
+    PrimitiveOp,
+    RaiseStandardError,
+    Return,
+    SetAttr,
+    SetMem,
+    Truncate,
+    TupleGet,
+    TupleSet,
+    Unborrow,
+    Unbox,
+    Unreachable,
+    Value,
+)
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+
+
+class IRTransform(OpVisitor[Optional[Value]]):
+    """Identity transform.
+
+    Subclass and override to perform changes to IR.
+
+    Subclass IRTransform and override any OpVisitor visit_* methods
+    that perform any IR changes. The default implementations implement
+    an identity transform.
+
+    A visit method can return None to remove ops. In this case the
+    transform must ensure that no op uses the original removed op
+    as a source after the transform.
+
+    You can retain old BasicBlock and op references in ops. The transform
+    will automatically patch these for you as needed.
+    """
+
+    def __init__(self, builder: LowLevelIRBuilder) -> None:
+        self.builder = builder
+        # Subclasses add additional op mappings here. A None value indicates
+        # that the op/register is deleted.
+        self.op_map: dict[Value, Value | None] = {}
+
+    def transform_blocks(self, blocks: list[BasicBlock]) -> None:
+        """Transform basic blocks that represent a single function.
+
+        The result of the transform will be collected at self.builder.blocks.
+        """
+        block_map: dict[BasicBlock, BasicBlock] = {}
+        op_map = self.op_map
+        empties = set()
+        for block in blocks:
+            new_block = BasicBlock()
+            block_map[block] = new_block
+            self.builder.activate_block(new_block)
+            new_block.error_handler = block.error_handler
+            for op in block.ops:
+                new_op = op.accept(self)
+                if new_op is not op:
+                    op_map[op] = new_op
+            # A transform can produce empty blocks which can be removed.
+            if is_empty_block(new_block) and not is_empty_block(block):
+                empties.add(new_block)
+        self.builder.blocks = [block for block in self.builder.blocks if block not in empties]
+        # Update all op/block references to point to the transformed ones.
+        patcher = PatchVisitor(op_map, block_map)
+        for block in self.builder.blocks:
+            for op in block.ops:
+                op.accept(patcher)
+            if block.error_handler is not None:
+                block.error_handler = block_map.get(block.error_handler, block.error_handler)
+
+    def add(self, op: Op) -> Value:
+        return self.builder.add(op)
+
+    def visit_goto(self, op: Goto) -> None:
+        self.add(op)
+
+    def visit_branch(self, op: Branch) -> None:
+        self.add(op)
+
+    def visit_return(self, op: Return) -> None:
+        self.add(op)
+
+    def visit_unreachable(self, op: Unreachable) -> None:
+        self.add(op)
+
+    def visit_assign(self, op: Assign) -> Value | None:
+        if op.src in self.op_map and self.op_map[op.src] is None:
+            # Special case: allow removing register initialization assignments
+            return None
+        return self.add(op)
+
+    def visit_assign_multi(self, op: AssignMulti) -> Value | None:
+        return self.add(op)
+
+    def visit_load_error_value(self, op: LoadErrorValue) -> Value | None:
+        return self.add(op)
+
+    def visit_load_literal(self, op: LoadLiteral) -> Value | None:
+        return self.add(op)
+
+    def visit_get_attr(self, op: GetAttr) -> Value | None:
+        return self.add(op)
+
+    def visit_set_attr(self, op: SetAttr) -> Value | None:
+        return self.add(op)
+
+    def visit_load_static(self, op: LoadStatic) -> Value | None:
+        return self.add(op)
+
+    def visit_init_static(self, op: InitStatic) -> Value | None:
+        return self.add(op)
+
+    def visit_tuple_get(self, op: TupleGet) -> Value | None:
+        return self.add(op)
+
+    def visit_tuple_set(self, op: TupleSet) -> Value | None:
+        return self.add(op)
+
+    def visit_inc_ref(self, op: IncRef) -> Value | None:
+        return self.add(op)
+
+    def visit_dec_ref(self, op: DecRef) -> Value | None:
+        return self.add(op)
+
+    def visit_call(self, op: Call) -> Value | None:
+        return self.add(op)
+
+    def visit_method_call(self, op: MethodCall) -> Value | None:
+        return self.add(op)
+
+    def visit_cast(self, op: Cast) -> Value | None:
+        return self.add(op)
+
+    def visit_box(self, op: Box) -> Value | None:
+        return self.add(op)
+
+    def visit_unbox(self, op: Unbox) -> Value | None:
+        return self.add(op)
+
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> Value | None:
+        return self.add(op)
+
+    def visit_call_c(self, op: CallC) -> Value | None:
+        return self.add(op)
+
+    def visit_primitive_op(self, op: PrimitiveOp) -> Value | None:
+        return self.add(op)
+
+    def visit_truncate(self, op: Truncate) -> Value | None:
+        return self.add(op)
+
+    def visit_extend(self, op: Extend) -> Value | None:
+        return self.add(op)
+
+    def visit_load_global(self, op: LoadGlobal) -> Value | None:
+        return self.add(op)
+
+    def visit_int_op(self, op: IntOp) -> Value | None:
+        return self.add(op)
+
+    def visit_comparison_op(self, op: ComparisonOp) -> Value | None:
+        return self.add(op)
+
+    def visit_float_op(self, op: FloatOp) -> Value | None:
+        return self.add(op)
+
+    def visit_float_neg(self, op: FloatNeg) -> Value | None:
+        return self.add(op)
+
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> Value | None:
+        return self.add(op)
+
+    def visit_load_mem(self, op: LoadMem) -> Value | None:
+        return self.add(op)
+
+    def visit_set_mem(self, op: SetMem) -> Value | None:
+        return self.add(op)
+
+    def visit_get_element_ptr(self, op: GetElementPtr) -> Value | None:
+        return self.add(op)
+
+    def visit_load_address(self, op: LoadAddress) -> Value | None:
+        return self.add(op)
+
+    def visit_keep_alive(self, op: KeepAlive) -> Value | None:
+        return self.add(op)
+
+    def visit_unborrow(self, op: Unborrow) -> Value | None:
+        return self.add(op)
+
+
+class PatchVisitor(OpVisitor[None]):
+    def __init__(
+        self, op_map: dict[Value, Value | None], block_map: dict[BasicBlock, BasicBlock]
+    ) -> None:
+        self.op_map: Final = op_map
+        self.block_map: Final = block_map
+
+    def fix_op(self, op: Value) -> Value:
+        new = self.op_map.get(op, op)
+        assert new is not None, "use of removed op"
+        return new
+
+    def fix_block(self, block: BasicBlock) -> BasicBlock:
+        return self.block_map.get(block, block)
+
+    def visit_goto(self, op: Goto) -> None:
+        op.label = self.fix_block(op.label)
+
+    def visit_branch(self, op: Branch) -> None:
+        op.value = self.fix_op(op.value)
+        op.true = self.fix_block(op.true)
+        op.false = self.fix_block(op.false)
+
+    def visit_return(self, op: Return) -> None:
+        op.value = self.fix_op(op.value)
+
+    def visit_unreachable(self, op: Unreachable) -> None:
+        pass
+
+    def visit_assign(self, op: Assign) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_assign_multi(self, op: AssignMulti) -> None:
+        op.src = [self.fix_op(s) for s in op.src]
+
+    def visit_load_error_value(self, op: LoadErrorValue) -> None:
+        pass
+
+    def visit_load_literal(self, op: LoadLiteral) -> None:
+        pass
+
+    def visit_get_attr(self, op: GetAttr) -> None:
+        op.obj = self.fix_op(op.obj)
+
+    def visit_set_attr(self, op: SetAttr) -> None:
+        op.obj = self.fix_op(op.obj)
+        op.src = self.fix_op(op.src)
+
+    def visit_load_static(self, op: LoadStatic) -> None:
+        pass
+
+    def visit_init_static(self, op: InitStatic) -> None:
+        op.value = self.fix_op(op.value)
+
+    def visit_tuple_get(self, op: TupleGet) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_tuple_set(self, op: TupleSet) -> None:
+        op.items = [self.fix_op(item) for item in op.items]
+
+    def visit_inc_ref(self, op: IncRef) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_dec_ref(self, op: DecRef) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_call(self, op: Call) -> None:
+        op.args = [self.fix_op(arg) for arg in op.args]
+
+    def visit_method_call(self, op: MethodCall) -> None:
+        op.obj = self.fix_op(op.obj)
+        op.args = [self.fix_op(arg) for arg in op.args]
+
+    def visit_cast(self, op: Cast) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_box(self, op: Box) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_unbox(self, op: Unbox) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> None:
+        if isinstance(op.value, Value):
+            op.value = self.fix_op(op.value)
+
+    def visit_call_c(self, op: CallC) -> None:
+        op.args = [self.fix_op(arg) for arg in op.args]
+
+    def visit_primitive_op(self, op: PrimitiveOp) -> None:
+        op.args = [self.fix_op(arg) for arg in op.args]
+
+    def visit_truncate(self, op: Truncate) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_extend(self, op: Extend) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_load_global(self, op: LoadGlobal) -> None:
+        pass
+
+    def visit_int_op(self, op: IntOp) -> None:
+        op.lhs = self.fix_op(op.lhs)
+        op.rhs = self.fix_op(op.rhs)
+
+    def visit_comparison_op(self, op: ComparisonOp) -> None:
+        op.lhs = self.fix_op(op.lhs)
+        op.rhs = self.fix_op(op.rhs)
+
+    def visit_float_op(self, op: FloatOp) -> None:
+        op.lhs = self.fix_op(op.lhs)
+        op.rhs = self.fix_op(op.rhs)
+
+    def visit_float_neg(self, op: FloatNeg) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> None:
+        op.lhs = self.fix_op(op.lhs)
+        op.rhs = self.fix_op(op.rhs)
+
+    def visit_load_mem(self, op: LoadMem) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_set_mem(self, op: SetMem) -> None:
+        op.dest = self.fix_op(op.dest)
+        op.src = self.fix_op(op.src)
+
+    def visit_get_element_ptr(self, op: GetElementPtr) -> None:
+        op.src = self.fix_op(op.src)
+
+    def visit_load_address(self, op: LoadAddress) -> None:
+        if isinstance(op.src, LoadStatic):
+            new = self.fix_op(op.src)
+            assert isinstance(new, LoadStatic)
+            op.src = new
+
+    def visit_keep_alive(self, op: KeepAlive) -> None:
+        op.src = [self.fix_op(s) for s in op.src]
+
+    def visit_unborrow(self, op: Unborrow) -> None:
+        op.src = self.fix_op(op.src)
+
+
+def is_empty_block(block: BasicBlock) -> bool:
+    return len(block.ops) == 1 and isinstance(block.ops[0], Unreachable)
diff --git a/mypyc/transform/lower.py b/mypyc/transform/lower.py
new file mode 100644
index 000000000000..f5768242aff1
--- /dev/null
+++ b/mypyc/transform/lower.py
@@ -0,0 +1,35 @@
+"""Transform IR to lower-level ops.
+
+Higher-level ops are used in earlier compiler passes, as they make
+various analyses, optimizations and transforms easier to implement.
+Later passes use lower-level ops, as they are easier to generate code
+from, and they help with lower-level optimizations.
+
+Lowering of various primitive ops is implemented in the mypyc.lower
+package.
+"""
+
+from __future__ import annotations
+
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.ops import PrimitiveOp, Value
+from mypyc.irbuild.ll_builder import LowLevelIRBuilder
+from mypyc.lower.registry import lowering_registry
+from mypyc.options import CompilerOptions
+from mypyc.transform.ir_transform import IRTransform
+
+
+def lower_ir(ir: FuncIR, options: CompilerOptions) -> None:
+    builder = LowLevelIRBuilder(None, options)
+    visitor = LoweringVisitor(builder)
+    visitor.transform_blocks(ir.blocks)
+    ir.blocks = builder.blocks
+
+
+class LoweringVisitor(IRTransform):
+    def visit_primitive_op(self, op: PrimitiveOp) -> Value | None:
+        # The lowering implementation functions of various primitive ops are stored
+        # in a registry, which is populated using function decorators. The name
+        # of op (such as "int_eq") is used as the key.
+        lower_fn = lowering_registry[op.desc.name]
+        return lower_fn(self.builder, op.args, op.line)
diff --git a/mypyc/transform/refcount.py b/mypyc/transform/refcount.py
index f2ab438f6576..b2ca03d44630 100644
--- a/mypyc/transform/refcount.py
+++ b/mypyc/transform/refcount.py
@@ -18,7 +18,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Iterable, Tuple
+from collections.abc import Iterable
 
 from mypyc.analysis.dataflow import (
     AnalysisDict,
@@ -46,13 +46,13 @@
     Value,
 )
 
-Decs = Tuple[Tuple[Value, bool], ...]
-Incs = Tuple[Value, ...]
+Decs = tuple[tuple[Value, bool], ...]
+Incs = tuple[Value, ...]
 
 # A cache of basic blocks that decrement and increment specific values
 # and then jump to some target block. This lets us cut down on how
 # much code we generate in some circumstances.
-BlockCache = Dict[Tuple[BasicBlock, Decs, Incs], BasicBlock]
+BlockCache = dict[tuple[BasicBlock, Decs, Incs], BasicBlock]
 
 
 def insert_ref_count_opcodes(ir: FuncIR) -> None:
diff --git a/mypyc/transform/spill.py b/mypyc/transform/spill.py
new file mode 100644
index 000000000000..3c014ca2c0da
--- /dev/null
+++ b/mypyc/transform/spill.py
@@ -0,0 +1,107 @@
+"""Insert spills for values that are live across yields."""
+
+from __future__ import annotations
+
+from mypyc.analysis.dataflow import AnalysisResult, analyze_live_regs, get_cfg
+from mypyc.common import TEMP_ATTR_NAME
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.ops import (
+    BasicBlock,
+    Branch,
+    DecRef,
+    GetAttr,
+    IncRef,
+    LoadErrorValue,
+    Register,
+    SetAttr,
+    Value,
+)
+
+
+def insert_spills(ir: FuncIR, env: ClassIR) -> None:
+    cfg = get_cfg(ir.blocks, use_yields=True)
+    live = analyze_live_regs(ir.blocks, cfg)
+    entry_live = live.before[ir.blocks[0], 0]
+
+    entry_live = {op for op in entry_live if not (isinstance(op, Register) and op.is_arg)}
+    # TODO: Actually for now, no Registers at all -- we keep the manual spills
+    entry_live = {op for op in entry_live if not isinstance(op, Register)}
+
+    ir.blocks = spill_regs(ir.blocks, env, entry_live, live)
+
+
+def spill_regs(
+    blocks: list[BasicBlock], env: ClassIR, to_spill: set[Value], live: AnalysisResult[Value]
+) -> list[BasicBlock]:
+    for op in blocks[0].ops:
+        if isinstance(op, GetAttr) and op.attr == "__mypyc_env__":
+            env_reg = op
+            break
+    else:
+        raise AssertionError("could not find __mypyc_env__")
+
+    spill_locs = {}
+    for i, val in enumerate(to_spill):
+        name = f"{TEMP_ATTR_NAME}2_{i}"
+        env.attributes[name] = val.type
+        if val.type.error_overlap:
+            # We can safely treat as always initialized, since the type has no pointers.
+            # This way we also don't need to manage the defined attribute bitfield.
+            env._always_initialized_attrs.add(name)
+        spill_locs[val] = name
+
+    for block in blocks:
+        ops = block.ops
+        block.ops = []
+
+        for i, op in enumerate(ops):
+            to_decref = []
+
+            if isinstance(op, IncRef) and op.src in spill_locs:
+                raise AssertionError("not sure what to do with an incref of a spill...")
+            if isinstance(op, DecRef) and op.src in spill_locs:
+                # When we decref a spilled value, we turn that into
+                # NULLing out the attribute, but only if the spilled
+                # value is not live *when we include yields in the
+                # CFG*. (The original decrefs are computed without that.)
+                #
+                # We also skip a decref is the env register is not
+                # live. That should only happen when an exception is
+                # being raised, so everything should be handled there.
+                if op.src not in live.after[block, i] and env_reg in live.after[block, i]:
+                    # Skip the DecRef but null out the spilled location
+                    null = LoadErrorValue(op.src.type)
+                    block.ops.extend([null, SetAttr(env_reg, spill_locs[op.src], null, op.line)])
+                continue
+
+            if (
+                any(src in spill_locs for src in op.sources())
+                # N.B: IS_ERROR should be before a spill happens
+                # XXX: but could we have a regular branch?
+                and not (isinstance(op, Branch) and op.op == Branch.IS_ERROR)
+            ):
+                new_sources: list[Value] = []
+                stolen = op.stolen()
+                for src in op.sources():
+                    if src in spill_locs:
+                        read = GetAttr(env_reg, spill_locs[src], op.line)
+                        block.ops.append(read)
+                        new_sources.append(read)
+                        if src.type.is_refcounted and src not in stolen:
+                            to_decref.append(read)
+                    else:
+                        new_sources.append(src)
+
+                op.set_sources(new_sources)
+
+            block.ops.append(op)
+
+            for dec in to_decref:
+                block.ops.append(DecRef(dec))
+
+            if op in spill_locs:
+                # XXX: could we set uninit?
+                block.ops.append(SetAttr(env_reg, spill_locs[op], op, op.line))
+
+    return blocks
diff --git a/mypyc/transform/uninit.py b/mypyc/transform/uninit.py
index 6bf71ac4a8bc..45b403588f8e 100644
--- a/mypyc/transform/uninit.py
+++ b/mypyc/transform/uninit.py
@@ -69,14 +69,19 @@ def split_blocks_at_uninits(
                     and not (isinstance(op, Branch) and op.op == Branch.IS_ERROR)
                     and not isinstance(op, LoadAddress)
                 ):
-                    new_block, error_block = BasicBlock(), BasicBlock()
-                    new_block.error_handler = error_block.error_handler = cur_block.error_handler
-                    new_blocks += [error_block, new_block]
-
                     if src not in init_registers_set:
                         init_registers.append(src)
                         init_registers_set.add(src)
 
+                    # XXX: if src.name is empty, it should be a
+                    # temp... and it should be OK??
+                    if not src.name:
+                        continue
+
+                    new_block, error_block = BasicBlock(), BasicBlock()
+                    new_block.error_handler = error_block.error_handler = cur_block.error_handler
+                    new_blocks += [error_block, new_block]
+
                     if not src.type.error_overlap:
                         cur_block.ops.append(
                             Branch(
diff --git a/pyproject.toml b/pyproject.toml
index 3d100dff5101..8a1177f60009 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,23 +3,108 @@ requires = [
     # NOTE: this needs to be kept in sync with mypy-requirements.txt
     # and build-requirements.txt, because those are both needed for
     # self-typechecking :/
-    "setuptools >= 40.6.2",
-    "wheel >= 0.30.0",
-    # the following is from mypy-requirements.txt
-    "typing_extensions>=3.10",
+    "setuptools >= 75.1.0",
+    # the following is from mypy-requirements.txt/setup.py
+    "typing_extensions>=4.6.0",
     "mypy_extensions>=1.0.0",
-    "typed_ast>=1.4.0,<2; python_version<'3.8'",
+    "pathspec>=0.9.0",
     "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"
 
+[project]
+name = "mypy"
+description = "Optional static typing for Python"
+readme = {text = """
+Mypy -- Optional Static Typing for Python
+=========================================
+
+Add type annotations to your Python programs, and use mypy to type
+check them.  Mypy is essentially a Python linter on steroids, and it
+can catch many programming errors by analyzing your program, without
+actually having to run it.  Mypy has a powerful type system with
+features such as type inference, gradual typing, generics and union
+types.
+""", content-type = "text/x-rst"}
+authors = [{name = "Jukka Lehtosalo", email = "jukka.lehtosalo@iki.fi"}]
+license = {text = "MIT"}
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development",
+  "Typing :: Typed",
+]
+requires-python = ">=3.9"
+dependencies = [
+  # When changing this, also update build-system.requires and mypy-requirements.txt
+  "typing_extensions>=4.6.0",
+  "mypy_extensions>=1.0.0",
+  "pathspec>=0.9.0",
+  "tomli>=1.1.0; python_version<'3.11'",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dmypy = ["psutil>=4.0"]
+mypyc = ["setuptools>=50"]
+python2 = []
+reports = ["lxml"]
+install-types = ["pip"]
+faster-cache = ["orjson"]
+
+[project.urls]
+Homepage = "https://www.mypy-lang.org/"
+Documentation = "https://mypy.readthedocs.io/en/stable/index.html"
+Repository = "https://github.com/python/mypy"
+Changelog = "https://github.com/python/mypy/blob/master/CHANGELOG.md"
+Issues = "https://github.com/python/mypy/issues"
+
+[project.scripts]
+mypy = "mypy.__main__:console_entry"
+stubgen = "mypy.stubgen:main"
+stubtest = "mypy.stubtest:main"
+dmypy = "mypy.dmypy.client:console_entry"
+mypyc = "mypyc.__main__:main"
+
+[tool.setuptools.packages.find]
+include = ["mypy*", "mypyc*", "*__mypyc*"]
+exclude = ["mypyc.test-data*"]
+namespaces = false
+
+[tool.setuptools.package-data]
+mypy = [
+  "py.typed",
+  "typeshed/**/*.py",
+  "typeshed/**/*.pyi",
+  "typeshed/stdlib/VERSIONS",
+  "xml/*.xsd",
+  "xml/*.xslt",
+  "xml/*.css",
+]
+[tool.setuptools.exclude-package-data]
+mypyc = [
+  "README.md",
+  "doc/**",
+  "external/**",
+  "lib-rt/test_capi.cc",
+  "lib-rt/setup.py",
+  "test-data/**",
+]
+
 [tool.black]
 line-length = 99
-target-version = ["py37", "py38", "py39", "py310", "py311"]
+target-version = ["py39", "py310", "py311", "py312", "py313"]
 skip-magic-trailing-comma = true
 force-exclude = '''
 ^/mypy/typeshed|
@@ -27,15 +112,130 @@ 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 = "py39"
+fix = true
+
+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/*",
+]
+
+[tool.ruff.lint]
+select = [
+  "E",       # pycodestyle (error)
+  "F",       # pyflakes
+  "W",       # pycodestyle (warning)
+  "B",       # flake8-bugbear
+  "I",       # isort
+  "N",       # pep8-naming
+  "PIE",     # flake8-pie
+  "PLE",     # pylint error
+  "RUF100",  # Unused noqa comments
+  "PGH004",  # blanket noqa comments
+  "UP",      # pyupgrade
+  "C4",      # flake8-comprehensions
+  "SIM101",  # merge duplicate isinstance calls
+  "SIM201", "SIM202", "SIM222", "SIM223",  # flake8-simplify
+  "FURB168", # Prefer is operator over isinstance for None checks
+  "FURB169", # Do not use is comparison with type(None). Use None
+  "FURB187", # avoid list reverse copy
+  "FURB188", # use str.remove(pre|suf)fix
+  "ISC001",  # implicitly concatenated string
+  "RET501", "RET502",  # better return None handling
+]
+
+ignore = [
+  "B007",  # Loop control variable not used within the loop body.
+  "B011",  # Don't use assert False
+  "B023",  # Function definition does not bind loop variable
+  "E2",    # conflicts with black
+  "E402",  # module level import not at top of file
+  "E501",  # conflicts with black
+  "E721",  # Use `is` and `is not` for type comparisons, or `isinstance()` for isinstance checks
+  "E731",  # Do not assign a `lambda` expression, use a `def`
+  "E741",  # Ambiguous variable name
+  "N818",  # Exception should be named with an Error suffix
+  "N806",  # UPPER_CASE used for constant local variables
+  "UP031", # Use format specifiers instead of percent format
+  "UP032", # 'f-string always preferable to format' is controversial
+  "C409",  # https://github.com/astral-sh/ruff/issues/12912
+  "C420",  # reads a little worse. fromkeys predates dict comprehensions
+  "C416",  # There are a few cases where it's nice to have names for the dict items
+  "PIE790", # there's nothing wrong with pass
+]
+
+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
+    "UP036", # sometimes it's better to just noqa this
+    "SIM222", # automatic fix might obscure issue
+    "SIM223", # automatic fix might obscure issue
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Mixed case variable and function names.
+"mypy/fastparse.py" = ["N802", "N816"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+extra-standard-library = ["typing_extensions"]
+
+[tool.check-manifest]
+ignore = ["**/.readthedocs.yaml"]
+
+[tool.pytest.ini_options]
+minversion = "7.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$',
+  '^assert False\b',
+  '''^if __name__ == ['"]__main__['"]:$''',
 ]
diff --git a/pytest.ini b/pytest.ini
deleted file mode 100644
index a123b0f11328..000000000000
--- 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/runtests.py b/runtests.py
index 66fade81ffab..3f49107f3ce0 100755
--- a/runtests.py
+++ b/runtests.py
@@ -17,6 +17,8 @@
 MYPYC_RUN_MULTI = "TestRunMultiFile"
 MYPYC_EXTERNAL = "TestExternal"
 MYPYC_COMMAND_LINE = "TestCommandLine"
+MYPYC_SEPARATE = "TestRunSeparate"
+MYPYC_MULTIMODULE = "multimodule"  # Subset of mypyc run tests that are slow
 ERROR_STREAM = "ErrorStreamSuite"
 
 
@@ -31,6 +33,7 @@
     MYPYC_RUN_MULTI,
     MYPYC_EXTERNAL,
     MYPYC_COMMAND_LINE,
+    MYPYC_SEPARATE,
     ERROR_STREAM,
 ]
 
@@ -40,7 +43,10 @@
 
 
 # These must be enabled by explicitly including 'mypyc-extra' on the command line.
-MYPYC_OPT_IN = [MYPYC_RUN, MYPYC_RUN_MULTI]
+MYPYC_OPT_IN = [MYPYC_RUN, MYPYC_RUN_MULTI, MYPYC_SEPARATE]
+
+# These mypyc test filters cover most slow test cases
+MYPYC_SLOW = [MYPYC_RUN_MULTI, MYPYC_COMMAND_LINE, MYPYC_SEPARATE, MYPYC_MULTIMODULE]
 
 
 # We split the pytest run into three parts to improve test
@@ -48,7 +54,26 @@
 # time to run.
 cmds = {
     # Self type check
-    "self": [executable, "-m", "mypy", "--config-file", "mypy_self_check.ini", "-p", "mypy"],
+    "self": [
+        executable,
+        "-m",
+        "mypy",
+        "--config-file",
+        "mypy_self_check.ini",
+        "-p",
+        "mypy",
+        "-p",
+        "mypyc",
+    ],
+    # Type check setup.py as well
+    "self-packaging": [
+        executable,
+        "-m",
+        "mypy",
+        "--config-file",
+        "mypy_self_check.ini",
+        "setup.py",
+    ],
     # Lint
     "lint": ["pre-commit", "run", "--all-files"],
     # Fast test cases only (this is the bulk of the test suite)
@@ -67,6 +92,7 @@
         "-k",
         " or ".join([DAEMON, MYPYC_EXTERNAL, MYPYC_COMMAND_LINE, ERROR_STREAM]),
     ],
+    "mypyc-fast": ["pytest", "-q", "mypyc", "-k", f"not ({' or '.join(MYPYC_SLOW)})"],
     # Test cases that might take minutes to run
     "pytest-extra": ["pytest", "-q", "-k", " or ".join(PYTEST_OPT_IN)],
     # Mypyc tests that aren't run by default, since they are slow and rarely
@@ -77,7 +103,7 @@
 # Stop run immediately if these commands fail
 FAST_FAIL = ["self", "lint"]
 
-EXTRA_COMMANDS = ("pytest-extra", "mypyc-extra")
+EXTRA_COMMANDS = ("pytest-extra", "mypyc-fast", "mypyc-extra")
 DEFAULT_COMMANDS = [cmd for cmd in cmds if cmd not in EXTRA_COMMANDS]
 
 assert all(cmd in cmds for cmd in FAST_FAIL)
@@ -85,7 +111,13 @@
 
 def run_cmd(name: str) -> int:
     status = 0
-    cmd = cmds[name]
+    if name in cmds:
+        cmd = cmds[name]
+    else:
+        if name.endswith(".test"):
+            cmd = ["pytest", f"mypy/test/testcheck.py::TypeCheckSuite::{name}"]
+        else:
+            cmd = ["pytest", "-n0", "-k", name]
     print(f"run {name}: {cmd}")
     proc = subprocess.run(cmd, stderr=subprocess.STDOUT)
     if proc.returncode:
@@ -118,13 +150,22 @@ def main() -> None:
     prog, *args = argv
 
     if not set(args).issubset(cmds):
-        print("usage:", prog, " ".join(f"[{k}]" for k in cmds))
+        print(
+            "usage:",
+            prog,
+            " ".join(f"[{k}]" for k in cmds),
+            "[names of individual tests and files...]",
+        )
         print()
         print(
             "Run the given tests. If given no arguments, run everything except"
-            + " pytest-extra and mypyc-extra."
+            + " pytest-extra and mypyc-extra. Unrecognized arguments will be"
+            + " interpreted as individual test names / substring expressions"
+            + " (or, if they end in .test, individual test files)"
+            + " and this script will try to run them."
         )
-        exit(1)
+        if "-h" in args or "--help" in args:
+            exit(1)
 
     if not args:
         args = DEFAULT_COMMANDS.copy()
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 511f794474e7..000000000000
--- a/setup.cfg
+++ /dev/null
@@ -1,59 +0,0 @@
-[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
-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__['"]:$
diff --git a/setup.py b/setup.py
index 061bb9ddf5b5..12cc1aad4d72 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, 9, 0):  # noqa: UP036, RUF100
+    sys.stderr.write("ERROR: You need Python 3.9 or later to use mypy.\n")
     exit(1)
 
 # we'll import stuff from the source tree, let's ensure is on the sys path
@@ -18,7 +18,7 @@
 # This requires setuptools when building; setuptools is not needed
 # when installing from a wheel file (though it is still needed for
 # alternative forms of installing, as suggested by README.md).
-from setuptools import Extension, find_packages, setup
+from setuptools import Extension, setup
 from setuptools.command.build_py import build_py
 
 from mypy.version import __version__ as version
@@ -26,25 +26,12 @@
 if TYPE_CHECKING:
     from typing_extensions import TypeGuard
 
-description = "Optional static typing for Python"
-long_description = """
-Mypy -- Optional Static Typing for Python
-=========================================
-
-Add type annotations to your Python programs, and use mypy to type
-check them.  Mypy is essentially a Python linter on steroids, and it
-can catch many programming errors by analyzing your program, without
-actually having to run it.  Mypy has a powerful type system with
-features such as type inference, gradual typing, generics and union
-types.
-""".lstrip()
-
 
 def is_list_of_setuptools_extension(items: list[Any]) -> TypeGuard[list[Extension]]:
     return all(isinstance(item, Extension) for item in items)
 
 
-def find_package_data(base, globs, root="mypy"):
+def find_package_data(base: str, globs: list[str], root: str = "mypy") -> list[str]:
     """Find all interesting data files, for setup(package_data=)
 
     Arguments:
@@ -65,26 +52,19 @@ def find_package_data(base, globs, root="mypy"):
 
 
 class CustomPythonBuild(build_py):
-    def pin_version(self):
+    def pin_version(self) -> None:
         path = os.path.join(self.build_lib, "mypy")
         self.mkpath(path)
         with open(os.path.join(path, "version.py"), "w") as stream:
             stream.write(f'__version__ = "{version}"\n')
 
-    def run(self):
+    def run(self) -> None:
         self.execute(self.pin_version, ())
         build_py.run(self)
 
 
 cmdclass = {"build_py": CustomPythonBuild}
 
-package_data = ["py.typed"]
-
-package_data += find_package_data(os.path.join("mypy", "typeshed"), ["*.py", "*.pyi"])
-package_data += [os.path.join("mypy", "typeshed", "stdlib", "VERSIONS")]
-
-package_data += find_package_data(os.path.join("mypy", "xml"), ["*.xsd", "*.xslt", "*.css"])
-
 USE_MYPYC = False
 # To compile with mypyc, a mypyc checkout must be present on the PYTHONPATH
 if len(sys.argv) > 1 and "--use-mypyc" in sys.argv:
@@ -112,7 +92,6 @@ def run(self):
             "stubtest.py",
             "stubgenc.py",
             "stubdoc.py",
-            "stubutil.py",
         )
     ) + (
         # Don't want to grab this accidentally
@@ -174,70 +153,10 @@ def run(self):
         # our Appveyor builds run out of memory sometimes.
         multi_file=sys.platform == "win32" or force_multifile,
     )
-    assert is_list_of_setuptools_extension(ext_modules), "Expected mypycify to use setuptools"
 
 else:
     ext_modules = []
 
+assert is_list_of_setuptools_extension(ext_modules), "Expected mypycify to use setuptools"
 
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Environment :: Console",
-    "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",
-    "Programming Language :: Python :: 3.11",
-    "Topic :: Software Development",
-    "Typing :: Typed",
-]
-
-setup(
-    name="mypy",
-    version=version,
-    description=description,
-    long_description=long_description,
-    author="Jukka Lehtosalo",
-    author_email="jukka.lehtosalo@iki.fi",
-    url="https://www.mypy-lang.org/",
-    license="MIT License",
-    py_modules=[],
-    ext_modules=ext_modules,
-    packages=find_packages(),
-    package_data={"mypy": package_data},
-    entry_points={
-        "console_scripts": [
-            "mypy=mypy.__main__:console_entry",
-            "stubgen=mypy.stubgen:main",
-            "stubtest=mypy.stubtest:main",
-            "dmypy=mypy.dmypy.client:console_entry",
-            "mypyc=mypyc.__main__:main",
-        ]
-    },
-    classifiers=classifiers,
-    cmdclass=cmdclass,
-    # When changing this, also update mypy-requirements.txt.
-    install_requires=[
-        "typed_ast >= 1.4.0, < 2; python_version<'3.8'",
-        "typing_extensions>=3.10",
-        "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",
-        "reports": "lxml",
-        "install-types": "pip",
-    },
-    python_requires=">=3.7",
-    include_package_data=True,
-    project_urls={
-        "News": "https://mypy-lang.org/news.html",
-        "Documentation": "https://mypy.readthedocs.io/en/stable/index.html",
-        "Repository": "https://github.com/python/mypy",
-    },
-)
+setup(version=version, ext_modules=ext_modules, cmdclass=cmdclass)
diff --git a/test-data/.flake8 b/test-data/.flake8
deleted file mode 100644
index df2f9caf8c94..000000000000
--- 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/packages/modulefinder-site-packages/foo-stubs/qux.pyi b/test-data/packages/modulefinder-site-packages/foo-stubs/qux.pyi
new file mode 100644
index 000000000000..5605b1454039
--- /dev/null
+++ b/test-data/packages/modulefinder-site-packages/foo-stubs/qux.pyi
@@ -0,0 +1 @@
+qux_var: int
diff --git a/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs-stubs/__init__.pyi b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs-stubs/__init__.pyi
new file mode 100644
index 000000000000..579a7556fdd1
--- /dev/null
+++ b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs-stubs/__init__.pyi
@@ -0,0 +1 @@
+pkg_typed_w_stubs_var: str = ...
diff --git a/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs-stubs/spam.pyi b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs-stubs/spam.pyi
new file mode 100644
index 000000000000..e3ef9cce5905
--- /dev/null
+++ b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs-stubs/spam.pyi
@@ -0,0 +1 @@
+spam_var: str
diff --git a/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/__init__.py b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/__init__.py
new file mode 100644
index 000000000000..11fa3635a2c7
--- /dev/null
+++ b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/__init__.py
@@ -0,0 +1 @@
+pkg_typed_w_stubs_var = "pkg_typed_w_stubs"
diff --git a/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/__init__.pyi b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/__init__.pyi
new file mode 100644
index 000000000000..3a03f395d014
--- /dev/null
+++ b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/__init__.pyi
@@ -0,0 +1 @@
+pkg_typed_w_stubs_var: object
diff --git a/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/py.typed b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/py.typed
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/spam.py b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/spam.py
new file mode 100644
index 000000000000..0aff1579b57f
--- /dev/null
+++ b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/spam.py
@@ -0,0 +1 @@
+spam_var = "spam"
diff --git a/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/spam.pyi b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/spam.pyi
new file mode 100644
index 000000000000..8eca196a7981
--- /dev/null
+++ b/test-data/packages/modulefinder-site-packages/pkg_typed_w_stubs/spam.pyi
@@ -0,0 +1 @@
+spam_var: object
diff --git a/test-data/packages/typedpkg-stubs/pyproject.toml b/test-data/packages/typedpkg-stubs/pyproject.toml
new file mode 100644
index 000000000000..c984c5d91e0a
--- /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==1.18"]
+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 4948dc6a01df..000000000000
--- 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 000000000000..6b55d4b3df60
--- /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==1.18"]
+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 11bcfb11a104..000000000000
--- 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 000000000000..f41ad16b5bc2
--- /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==1.18"]
+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 3dab731cada9..000000000000
--- 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 000000000000..2c1c206c361d
--- /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==1.18"]
+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 a5d7df83eeea..000000000000
--- 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 000000000000..b8ae0d59072e
--- /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==1.18"]
+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 4f0d0d954a73..000000000000
--- 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/packages/typedpkg_ns_nested/pyproject.toml b/test-data/packages/typedpkg_ns_nested/pyproject.toml
new file mode 100644
index 000000000000..b5bf038b8e14
--- /dev/null
+++ b/test-data/packages/typedpkg_ns_nested/pyproject.toml
@@ -0,0 +1,11 @@
+[project]
+name = 'typedpkg_namespace.nested'
+version = '0.1'
+description = 'Two namespace packages, one of them typed'
+
+[tool.hatch.build]
+include = ["**/*.py", "**/*.pyi", "**/py.typed"]
+
+[build-system]
+requires = ["hatchling==1.18"]
+build-backend = "hatchling.build"
diff --git a/test-data/packages/typedpkg_ns_nested/typedpkg_ns/a/__init__.py b/test-data/packages/typedpkg_ns_nested/typedpkg_ns/a/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/test-data/packages/typedpkg_ns_nested/typedpkg_ns/a/py.typed b/test-data/packages/typedpkg_ns_nested/typedpkg_ns/a/py.typed
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/test-data/packages/typedpkg_ns_nested/typedpkg_ns/b/__init__.py b/test-data/packages/typedpkg_ns_nested/typedpkg_ns/b/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/__init__.pyi b/test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/__init__.pyi
new file mode 100644
index 000000000000..90afb46d6d94
--- /dev/null
+++ b/test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/__init__.pyi
@@ -0,0 +1,27 @@
+import os
+from . import demo as demo
+from typing import overload
+
+class StaticMethods:
+    def __init__(self, *args, **kwargs) -> None: ...
+    @overload
+    @staticmethod
+    def overloaded_static_method(value: int) -> int: ...
+    @overload
+    @staticmethod
+    def overloaded_static_method(value: float) -> float: ...
+    @staticmethod
+    def some_static_method(a: int, b: int) -> int: ...
+
+class TestStruct:
+    field_readwrite: int
+    field_readwrite_docstring: int
+    def __init__(self, *args, **kwargs) -> None: ...
+    @property
+    def field_readonly(self) -> int: ...
+
+def func_incomplete_signature(*args, **kwargs): ...
+def func_returning_optional() -> int | None: ...
+def func_returning_pair() -> tuple[int, float]: ...
+def func_returning_path() -> os.PathLike: ...
+def func_returning_vector() -> list[float]: ...
diff --git a/test-data/pybind11_mypy_demo/stubgen/pybind11_mypy_demo/basics.pyi b/test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/demo.pyi
similarity index 88%
rename from test-data/pybind11_mypy_demo/stubgen/pybind11_mypy_demo/basics.pyi
rename to test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/demo.pyi
index ab5a4f4e78d2..87b8ec0e4ad6 100644
--- a/test-data/pybind11_mypy_demo/stubgen/pybind11_mypy_demo/basics.pyi
+++ b/test-data/pybind11_fixtures/expected_stubs_no_docs/pybind11_fixtures/demo.pyi
@@ -1,7 +1,7 @@
-from typing import ClassVar
+from typing import ClassVar, overload
 
-from typing import overload
 PI: float
+__version__: str
 
 class Point:
     class AngleUnit:
@@ -11,12 +11,10 @@ class Point:
         radian: ClassVar[Point.AngleUnit] = ...
         def __init__(self, value: int) -> None: ...
         def __eq__(self, other: object) -> bool: ...
-        def __getstate__(self) -> int: ...
         def __hash__(self) -> int: ...
         def __index__(self) -> int: ...
         def __int__(self) -> int: ...
         def __ne__(self, other: object) -> bool: ...
-        def __setstate__(self, state: int) -> None: ...
         @property
         def name(self) -> str: ...
         @property
@@ -30,12 +28,10 @@ class Point:
         pixel: ClassVar[Point.LengthUnit] = ...
         def __init__(self, value: int) -> None: ...
         def __eq__(self, other: object) -> bool: ...
-        def __getstate__(self) -> int: ...
         def __hash__(self) -> int: ...
         def __index__(self) -> int: ...
         def __int__(self) -> int: ...
         def __ne__(self, other: object) -> bool: ...
-        def __setstate__(self, state: int) -> None: ...
         @property
         def name(self) -> str: ...
         @property
@@ -51,6 +47,7 @@ class Point:
     def __init__(self) -> None: ...
     @overload
     def __init__(self, x: float, y: float) -> None: ...
+    def as_list(self) -> list[float]: ...
     @overload
     def distance_to(self, x: float, y: float) -> float: ...
     @overload
diff --git a/test-data/pybind11_fixtures/expected_stubs_with_docs/pybind11_fixtures/__init__.pyi b/test-data/pybind11_fixtures/expected_stubs_with_docs/pybind11_fixtures/__init__.pyi
new file mode 100644
index 000000000000..db04bccab028
--- /dev/null
+++ b/test-data/pybind11_fixtures/expected_stubs_with_docs/pybind11_fixtures/__init__.pyi
@@ -0,0 +1,52 @@
+import os
+from . import demo as demo
+from typing import overload
+
+class StaticMethods:
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+    @overload
+    @staticmethod
+    def overloaded_static_method(value: int) -> int:
+        """overloaded_static_method(*args, **kwargs)
+        Overloaded function.
+
+        1. overloaded_static_method(value: int) -> int
+
+        2. overloaded_static_method(value: float) -> float
+        """
+    @overload
+    @staticmethod
+    def overloaded_static_method(value: float) -> float:
+        """overloaded_static_method(*args, **kwargs)
+        Overloaded function.
+
+        1. overloaded_static_method(value: int) -> int
+
+        2. overloaded_static_method(value: float) -> float
+        """
+    @staticmethod
+    def some_static_method(a: int, b: int) -> int:
+        """some_static_method(a: int, b: int) -> int
+
+        None
+        """
+
+class TestStruct:
+    field_readwrite: int
+    field_readwrite_docstring: int
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize self.  See help(type(self)) for accurate signature."""
+    @property
+    def field_readonly(self) -> int: ...
+
+def func_incomplete_signature(*args, **kwargs):
+    """func_incomplete_signature() -> dummy_sub_namespace::HasNoBinding"""
+def func_returning_optional() -> int | None:
+    """func_returning_optional() -> Optional[int]"""
+def func_returning_pair() -> tuple[int, float]:
+    """func_returning_pair() -> Tuple[int, float]"""
+def func_returning_path() -> os.PathLike:
+    """func_returning_path() -> os.PathLike"""
+def func_returning_vector() -> list[float]:
+    """func_returning_vector() -> List[float]"""
diff --git a/test-data/pybind11_fixtures/expected_stubs_with_docs/pybind11_fixtures/demo.pyi b/test-data/pybind11_fixtures/expected_stubs_with_docs/pybind11_fixtures/demo.pyi
new file mode 100644
index 000000000000..1be0bc905a43
--- /dev/null
+++ b/test-data/pybind11_fixtures/expected_stubs_with_docs/pybind11_fixtures/demo.pyi
@@ -0,0 +1,112 @@
+from typing import ClassVar, overload
+
+PI: float
+__version__: str
+
+class Point:
+    class AngleUnit:
+        __members__: ClassVar[dict] = ...  # read-only
+        __entries: ClassVar[dict] = ...
+        degree: ClassVar[Point.AngleUnit] = ...
+        radian: ClassVar[Point.AngleUnit] = ...
+        def __init__(self, value: int) -> None:
+            """__init__(self: pybind11_fixtures.demo.Point.AngleUnit, value: int) -> None"""
+        def __eq__(self, other: object) -> bool:
+            """__eq__(self: object, other: object) -> bool"""
+        def __hash__(self) -> int:
+            """__hash__(self: object) -> int"""
+        def __index__(self) -> int:
+            """__index__(self: pybind11_fixtures.demo.Point.AngleUnit) -> int"""
+        def __int__(self) -> int:
+            """__int__(self: pybind11_fixtures.demo.Point.AngleUnit) -> int"""
+        def __ne__(self, other: object) -> bool:
+            """__ne__(self: object, other: object) -> bool"""
+        @property
+        def name(self) -> str: ...
+        @property
+        def value(self) -> int: ...
+
+    class LengthUnit:
+        __members__: ClassVar[dict] = ...  # read-only
+        __entries: ClassVar[dict] = ...
+        inch: ClassVar[Point.LengthUnit] = ...
+        mm: ClassVar[Point.LengthUnit] = ...
+        pixel: ClassVar[Point.LengthUnit] = ...
+        def __init__(self, value: int) -> None:
+            """__init__(self: pybind11_fixtures.demo.Point.LengthUnit, value: int) -> None"""
+        def __eq__(self, other: object) -> bool:
+            """__eq__(self: object, other: object) -> bool"""
+        def __hash__(self) -> int:
+            """__hash__(self: object) -> int"""
+        def __index__(self) -> int:
+            """__index__(self: pybind11_fixtures.demo.Point.LengthUnit) -> int"""
+        def __int__(self) -> int:
+            """__int__(self: pybind11_fixtures.demo.Point.LengthUnit) -> int"""
+        def __ne__(self, other: object) -> bool:
+            """__ne__(self: object, other: object) -> bool"""
+        @property
+        def name(self) -> str: ...
+        @property
+        def value(self) -> int: ...
+    angle_unit: ClassVar[Point.AngleUnit] = ...
+    length_unit: ClassVar[Point.LengthUnit] = ...
+    x_axis: ClassVar[Point] = ...  # read-only
+    y_axis: ClassVar[Point] = ...  # read-only
+    origin: ClassVar[Point] = ...
+    x: float
+    y: float
+    @overload
+    def __init__(self) -> None:
+        """__init__(*args, **kwargs)
+        Overloaded function.
+
+        1. __init__(self: pybind11_fixtures.demo.Point) -> None
+
+        2. __init__(self: pybind11_fixtures.demo.Point, x: float, y: float) -> None
+        """
+    @overload
+    def __init__(self, x: float, y: float) -> None:
+        """__init__(*args, **kwargs)
+        Overloaded function.
+
+        1. __init__(self: pybind11_fixtures.demo.Point) -> None
+
+        2. __init__(self: pybind11_fixtures.demo.Point, x: float, y: float) -> None
+        """
+    def as_list(self) -> list[float]:
+        """as_list(self: pybind11_fixtures.demo.Point) -> List[float]"""
+    @overload
+    def distance_to(self, x: float, y: float) -> float:
+        """distance_to(*args, **kwargs)
+        Overloaded function.
+
+        1. distance_to(self: pybind11_fixtures.demo.Point, x: float, y: float) -> float
+
+        2. distance_to(self: pybind11_fixtures.demo.Point, other: pybind11_fixtures.demo.Point) -> float
+        """
+    @overload
+    def distance_to(self, other: Point) -> float:
+        """distance_to(*args, **kwargs)
+        Overloaded function.
+
+        1. distance_to(self: pybind11_fixtures.demo.Point, x: float, y: float) -> float
+
+        2. distance_to(self: pybind11_fixtures.demo.Point, other: pybind11_fixtures.demo.Point) -> float
+        """
+    @property
+    def length(self) -> float: ...
+
+def answer() -> int:
+    '''answer() -> int
+
+    answer docstring, with end quote"
+    '''
+def midpoint(left: float, right: float) -> float:
+    """midpoint(left: float, right: float) -> float"""
+def sum(arg0: int, arg1: int) -> int:
+    '''sum(arg0: int, arg1: int) -> int
+
+    multiline docstring test, edge case quotes """\'\'\'
+    '''
+def weighted_midpoint(left: float, right: float, alpha: float = ...) -> float:
+    """weighted_midpoint(left: float, right: float, alpha: float = 0.5) -> float"""
diff --git a/test-data/pybind11_mypy_demo/pyproject.toml b/test-data/pybind11_fixtures/pyproject.toml
similarity index 100%
rename from test-data/pybind11_mypy_demo/pyproject.toml
rename to test-data/pybind11_fixtures/pyproject.toml
diff --git a/test-data/pybind11_mypy_demo/setup.py b/test-data/pybind11_fixtures/setup.py
similarity index 85%
rename from test-data/pybind11_mypy_demo/setup.py
rename to test-data/pybind11_fixtures/setup.py
index 0da1cfbcef19..e227b49935ea 100644
--- a/test-data/pybind11_mypy_demo/setup.py
+++ b/test-data/pybind11_fixtures/setup.py
@@ -5,14 +5,14 @@
 # Documentation: https://pybind11.readthedocs.io/en/stable/compiling.html
 ext_modules = [
     Pybind11Extension(
-        "pybind11_mypy_demo",
+        "pybind11_fixtures",
         ["src/main.cpp"],
         cxx_std=17,
     ),
 ]
 
 setup(
-    name="pybind11-mypy-demo",
+    name="pybind11_fixtures",
     version="0.0.1",
     ext_modules=ext_modules,
 )
diff --git a/test-data/pybind11_mypy_demo/src/main.cpp b/test-data/pybind11_fixtures/src/main.cpp
similarity index 57%
rename from test-data/pybind11_mypy_demo/src/main.cpp
rename to test-data/pybind11_fixtures/src/main.cpp
index ff0f93bf7017..4d275ab1fd70 100644
--- a/test-data/pybind11_mypy_demo/src/main.cpp
+++ b/test-data/pybind11_fixtures/src/main.cpp
@@ -43,11 +43,106 @@
  */
 
 #include <cmath>
+#include <filesystem>
+#include <optional>
+#include <utility>
+#include <vector>
+
 #include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/stl/filesystem.h>
 
 namespace py = pybind11;
 
-namespace basics {
+// ----------------------------------------------------------------------------
+// Dedicated test cases
+// ----------------------------------------------------------------------------
+
+std::vector<float> funcReturningVector()
+{
+  return std::vector<float>{1.0, 2.0, 3.0};
+}
+
+std::pair<int, float> funcReturningPair()
+{
+  return std::pair{42, 1.0};
+}
+
+std::optional<int> funcReturningOptional()
+{
+  return std::nullopt;
+}
+
+std::filesystem::path funcReturningPath()
+{
+  return std::filesystem::path{"foobar"};
+}
+
+namespace dummy_sub_namespace {
+  struct HasNoBinding{};
+}
+
+// We can enforce the case of an incomplete signature by referring to a type in
+// some namespace that doesn't have a pybind11 binding.
+dummy_sub_namespace::HasNoBinding funcIncompleteSignature()
+{
+  return dummy_sub_namespace::HasNoBinding{};
+}
+
+struct TestStruct
+{
+  int field_readwrite;
+  int field_readwrite_docstring;
+  int field_readonly;
+};
+
+struct StaticMethods
+{
+  static int some_static_method(int a, int b) { return 42; }
+  static int overloaded_static_method(int value) { return 42; }
+  static double overloaded_static_method(double value) { return 1.0; }
+};
+
+// Bindings
+
+void bind_test_cases(py::module& m) {
+  m.def("func_returning_vector", &funcReturningVector);
+  m.def("func_returning_pair", &funcReturningPair);
+  m.def("func_returning_optional", &funcReturningOptional);
+  m.def("func_returning_path", &funcReturningPath);
+
+  m.def("func_incomplete_signature", &funcIncompleteSignature);
+
+  py::class_<TestStruct>(m, "TestStruct")
+      .def_readwrite("field_readwrite", &TestStruct::field_readwrite)
+      .def_readwrite("field_readwrite_docstring", &TestStruct::field_readwrite_docstring, "some docstring")
+      .def_property_readonly(
+          "field_readonly",
+          [](const TestStruct& x) {
+            return x.field_readonly;
+          },
+          "some docstring");
+
+  // Static methods
+  py::class_<StaticMethods> pyStaticMethods(m, "StaticMethods");
+
+  pyStaticMethods
+    .def_static(
+      "some_static_method",
+      &StaticMethods::some_static_method, R"#(None)#", py::arg("a"), py::arg("b"))
+    .def_static(
+      "overloaded_static_method",
+      py::overload_cast<int>(&StaticMethods::overloaded_static_method), py::arg("value"))
+    .def_static(
+      "overloaded_static_method",
+      py::overload_cast<double>(&StaticMethods::overloaded_static_method), py::arg("value"));
+}
+
+// ----------------------------------------------------------------------------
+// Original demo
+// ----------------------------------------------------------------------------
+
+namespace demo {
 
 int answer() {
   return 42;
@@ -102,6 +197,11 @@ struct Point {
     return distance_to(other.x, other.y);
   }
 
+  std::vector<double> as_vector()
+  {
+    return std::vector<double>{x, y};
+  }
+
   double x, y;
 };
 
@@ -112,20 +212,22 @@ const Point Point::y_axis = Point(0, 1);
 Point::LengthUnit Point::length_unit = Point::LengthUnit::mm;
 Point::AngleUnit Point::angle_unit = Point::AngleUnit::radian;
 
-} // namespace: basics
+} // namespace: demo
 
-void bind_basics(py::module& basics) {
+// Bindings
 
-  using namespace basics;
+void bind_demo(py::module& m) {
+
+  using namespace demo;
 
   // Functions
-  basics.def("answer", &answer);
-  basics.def("sum", &sum);
-  basics.def("midpoint", &midpoint, py::arg("left"), py::arg("right"));
-  basics.def("weighted_midpoint", weighted_midpoint, py::arg("left"), py::arg("right"), py::arg("alpha")=0.5);
+  m.def("answer", &answer, "answer docstring, with end quote\""); // tests explicit docstrings
+  m.def("sum", &sum, "multiline docstring test, edge case quotes \"\"\"'''");
+  m.def("midpoint", &midpoint, py::arg("left"), py::arg("right"));
+  m.def("weighted_midpoint", weighted_midpoint, py::arg("left"), py::arg("right"), py::arg("alpha")=0.5);
 
   // Classes
-  py::class_<Point> pyPoint(basics, "Point");
+  py::class_<Point> pyPoint(m, "Point");
   py::enum_<Point::LengthUnit> pyLengthUnit(pyPoint, "LengthUnit");
   py::enum_<Point::AngleUnit> pyAngleUnit(pyPoint, "AngleUnit");
 
@@ -134,14 +236,15 @@ void bind_basics(py::module& basics) {
     .def(py::init<double, double>(), py::arg("x"), py::arg("y"))
     .def("distance_to", py::overload_cast<double, double>(&Point::distance_to, py::const_), py::arg("x"), py::arg("y"))
     .def("distance_to", py::overload_cast<const Point&>(&Point::distance_to, py::const_), py::arg("other"))
-    .def_readwrite("x", &Point::x)
+    .def("as_list", &Point::as_vector)
+    .def_readwrite("x", &Point::x, "some docstring")
     .def_property("y",
         [](Point& self){ return self.y; },
         [](Point& self, double value){ self.y = value; }
     )
     .def_property_readonly("length", &Point::length)
     .def_property_readonly_static("x_axis", [](py::object cls){return Point::x_axis;})
-    .def_property_readonly_static("y_axis", [](py::object cls){return Point::y_axis;})
+    .def_property_readonly_static("y_axis", [](py::object cls){return Point::y_axis;}, "another docstring")
     .def_readwrite_static("length_unit", &Point::length_unit)
     .def_property_static("angle_unit",
         [](py::object& /*cls*/){ return Point::angle_unit; },
@@ -160,11 +263,17 @@ void bind_basics(py::module& basics) {
     .value("degree", Point::AngleUnit::degree);
 
   // Module-level attributes
-  basics.attr("PI") = std::acos(-1);
-  basics.attr("__version__") = "0.0.1";
+  m.attr("PI") = std::acos(-1);
+  m.attr("__version__") = "0.0.1";
 }
 
-PYBIND11_MODULE(pybind11_mypy_demo, m) {
-  auto basics = m.def_submodule("basics");
-  bind_basics(basics);
+// ----------------------------------------------------------------------------
+// Module entry point
+// ----------------------------------------------------------------------------
+
+PYBIND11_MODULE(pybind11_fixtures, m) {
+  bind_test_cases(m);
+
+  auto demo = m.def_submodule("demo");
+  bind_demo(demo);
 }
diff --git a/test-data/unit/README.md b/test-data/unit/README.md
index 97680c949bef..aaf774d1b62f 100644
--- a/test-data/unit/README.md
+++ b/test-data/unit/README.md
@@ -12,7 +12,7 @@ feature you added. If you added a new `check-*.test` file, it will be autodiscov
 Add the test in this format anywhere in the file:
 
     [case testNewSyntaxBasics]
-    # flags: --python-version 3.6
+    # flags: --python-version 3.10
     x: int
     x = 5
     y: int = 5
@@ -100,6 +100,10 @@ First install any additional dependencies needed for testing:
 
     python3 -m pip install -U -r test-requirements.txt
 
+Configure `pre-commit` to run the linters automatically when you commit:
+
+    pre-commit install
+
 The unit test suites are driven by the `pytest` framework. To run all mypy tests,
 run `pytest` in the mypy repository:
 
@@ -157,9 +161,11 @@ To run mypy on itself:
 
     python3 -m mypy --config-file mypy_self_check.ini -p mypy
 
-To run the linter:
+To run the linter (this commands just wraps `pre-commit`, so you can also
+invoke it directly like `pre-commit run -a`, and this will also run when you
+`git commit` if enabled):
 
-    flake8
+    python3 runtests.py lint
 
 You can also run all of the above tests using `runtests.py` (this includes
 type checking mypy and linting):
diff --git a/test-data/unit/check-abstract.test b/test-data/unit/check-abstract.test
index 8a13e5cb5760..455ee3c5265b 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")
@@ -196,6 +198,24 @@ x: Type[B]
 f(x)  # OK
 [out]
 
+[case testAbstractTypeInADict]
+from typing import Dict, Type
+from abc import abstractmethod
+
+class Class:
+    @abstractmethod
+    def method(self) -> None:
+        pass
+
+my_dict_init: Dict[int, Type[Class]] = {0: Class}  # E: Only concrete class can be given where "Tuple[int, Type[Class]]" is expected
+
+class Child(Class):
+    def method(self) -> None: ...
+
+other_dict_init: Dict[int, Type[Class]] = {0: Child}  # ok
+[builtins fixtures/dict.pyi]
+[out]
+
 [case testInstantiationAbstractsInTypeForAliases]
 from typing import Type
 from abc import abstractmethod
@@ -220,7 +240,8 @@ f(GoodAlias)
 [out]
 
 [case testInstantiationAbstractsInTypeForVariables]
-from typing import Type
+# flags: --no-strict-optional
+from typing import Type, overload
 from abc import abstractmethod
 
 class A:
@@ -248,6 +269,15 @@ if int():
     var_old = B # E: Can only assign concrete classes to a variable of type "Type[A]"
 if int():
     var_old = C # OK
+
+class D(A):
+    @overload
+    def __new__(cls, a) -> "D": ...
+    @overload
+    def __new__(cls) -> "D": ...
+    def __new__(cls, a=None) -> "D": ...
+if int():
+    var = D # E: Can only assign concrete classes to a variable of type "Type[A]"
 [out]
 
 [case testInstantiationAbstractsInTypeForClassMethods]
@@ -399,7 +429,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 +451,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 +539,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"
@@ -735,7 +769,45 @@ class A(metaclass=ABCMeta):
     def x(self) -> int: pass
     @x.setter
     def x(self, x: int) -> None: pass
-[out]
+
+[case testReadWriteDeleteAbstractProperty]
+# flags: --no-strict-optional
+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 +839,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
@@ -816,6 +888,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
@@ -823,9 +896,9 @@ class A(metaclass=ABCMeta):
 class B(A):
     @property
     def x(self) -> int:
-        return super().x.y # E: "int" has no attribute "y"
+        return super().x.y  # E: Call to abstract method "x" of "A" with trivial body via super() is unsafe \
+                            # E: "int" has no attribute "y"
 [builtins fixtures/property.pyi]
-[out]
 
 [case testSuperWithReadWriteAbstractProperty]
 from abc import abstractproperty, ABCMeta
@@ -917,7 +990,6 @@ class Mixin:
 class C(Mixin, A):
     pass
 [builtins fixtures/property.pyi]
-[out]
 
 [case testMixinSubtypedProperty]
 class X:
@@ -933,7 +1005,6 @@ class Mixin:
 class C(Mixin, A):
     pass
 [builtins fixtures/property.pyi]
-[out]
 
 [case testMixinTypedPropertyReversed]
 class A:
@@ -942,10 +1013,9 @@ class A:
         return "no"
 class Mixin:
     foo = "foo"
-class C(A, Mixin): # E: Definition of "foo" in base class "A" is incompatible with definition in base class "Mixin"
+class C(A, Mixin): # E: Cannot override writeable attribute "foo" in base "Mixin" with read-only property in base "A"
     pass
 [builtins fixtures/property.pyi]
-[out]
 
 -- Special cases
 -- -------------
@@ -1061,7 +1131,6 @@ b.y = 1
 -- -----------------------------------------------
 
 [case testEmptyBodyProhibitedFunction]
-# flags: --strict-optional
 from typing import overload, Union
 
 def func1(x: str) -> int: pass  # E: Missing return statement
@@ -1084,7 +1153,6 @@ def func5(x: Union[int, str]) -> Union[int, str]:  # E: Missing return statement
     """Some function."""
 
 [case testEmptyBodyProhibitedMethodNonAbstract]
-# flags: --strict-optional
 from typing import overload, Union
 
 class A:
@@ -1119,7 +1187,6 @@ class C:
 [builtins fixtures/classmethod.pyi]
 
 [case testEmptyBodyProhibitedPropertyNonAbstract]
-# flags: --strict-optional
 class A:
     @property
     def x(self) -> int: ...  # E: Missing return statement
@@ -1148,7 +1215,6 @@ class C:
 [builtins fixtures/property.pyi]
 
 [case testEmptyBodyNoteABCMeta]
-# flags: --strict-optional
 from abc import ABC
 
 class A(ABC):
@@ -1157,7 +1223,6 @@ class A(ABC):
         ...
 
 [case testEmptyBodyAllowedFunctionStub]
-# flags: --strict-optional
 import stub
 [file stub.pyi]
 from typing import overload, Union
@@ -1168,7 +1233,6 @@ def func3(x: str) -> int:
     """Some function."""
 
 [case testEmptyBodyAllowedMethodNonAbstractStub]
-# flags: --strict-optional
 import stub
 [file stub.pyi]
 from typing import overload, Union
@@ -1190,7 +1254,6 @@ class B:
 [builtins fixtures/classmethod.pyi]
 
 [case testEmptyBodyAllowedPropertyNonAbstractStub]
-# flags: --strict-optional
 import stub
 [file stub.pyi]
 class A:
@@ -1221,7 +1284,6 @@ class C:
 [builtins fixtures/property.pyi]
 
 [case testEmptyBodyAllowedMethodAbstract]
-# flags: --strict-optional
 from typing import overload, Union
 from abc import abstractmethod
 
@@ -1269,7 +1331,6 @@ class C:
 [builtins fixtures/classmethod.pyi]
 
 [case testEmptyBodyAllowedPropertyAbstract]
-# flags: --strict-optional
 from abc import abstractmethod
 class A:
     @property
@@ -1308,7 +1369,6 @@ class C:
 [builtins fixtures/property.pyi]
 
 [case testEmptyBodyImplicitlyAbstractProtocol]
-# flags: --strict-optional
 from typing import Protocol, overload, Union
 
 class P1(Protocol):
@@ -1349,7 +1409,6 @@ C3()
 [builtins fixtures/classmethod.pyi]
 
 [case testEmptyBodyImplicitlyAbstractProtocolProperty]
-# flags: --strict-optional
 from typing import Protocol
 
 class P1(Protocol):
@@ -1379,7 +1438,6 @@ C2()
 [builtins fixtures/property.pyi]
 
 [case testEmptyBodyImplicitlyAbstractProtocolStub]
-# flags: --strict-optional
 from stub import P1, P2, P3, P4
 
 class B1(P1): ...
@@ -1415,7 +1473,6 @@ class P4(Protocol):
 [builtins fixtures/classmethod.pyi]
 
 [case testEmptyBodyUnsafeAbstractSuper]
-# flags: --strict-optional
 from stub import StubProto, StubAbstract
 from typing import Protocol
 from abc import abstractmethod
@@ -1464,7 +1521,6 @@ class StubAbstract:
     def meth(self) -> int: ...
 
 [case testEmptyBodyUnsafeAbstractSuperProperty]
-# flags: --strict-optional
 from stub import StubProto, StubAbstract
 from typing import Protocol
 from abc import abstractmethod
@@ -1522,7 +1578,6 @@ class StubAbstract:
 [builtins fixtures/property.pyi]
 
 [case testEmptyBodyUnsafeAbstractSuperOverloads]
-# flags: --strict-optional
 from stub import StubProto
 from typing import Protocol, overload, Union
 
@@ -1601,13 +1656,12 @@ class Abstract:
 
 class SubProto(Proto):
     def meth(self) -> int:
-        return super().meth()
+        return super().meth()  # E: Call to abstract method "meth" of "Proto" with trivial body via super() is unsafe
 class SubAbstract(Abstract):
     def meth(self) -> int:
-        return super().meth()
+        return super().meth()  # E: Call to abstract method "meth" of "Abstract" with trivial body via super() is unsafe
 
 [case testEmptyBodyNoSuperWarningOptionalReturn]
-# flags: --strict-optional
 from typing import Protocol, Optional
 from abc import abstractmethod
 
@@ -1619,13 +1673,12 @@ class Abstract:
 
 class SubProto(Proto):
     def meth(self) -> Optional[int]:
-        return super().meth()
+        return super().meth()  # E: Call to abstract method "meth" of "Proto" with trivial body via super() is unsafe
 class SubAbstract(Abstract):
     def meth(self) -> Optional[int]:
-        return super().meth()
+        return super().meth()  # E: Call to abstract method "meth" of "Abstract" with trivial body via super() is unsafe
 
 [case testEmptyBodyTypeCheckingOnly]
-# flags: --strict-optional
 from typing import TYPE_CHECKING
 
 class C:
diff --git a/test-data/unit/check-annotated.test b/test-data/unit/check-annotated.test
index d4309b8ad213..47fe33bfb42a 100644
--- a/test-data/unit/check-annotated.test
+++ b/test-data/unit/check-annotated.test
@@ -139,7 +139,7 @@ reveal_type(f2)  # N: Revealed type is "def (a: builtins.str) -> Any"
 def f3(a: Annotated["notdefined", "metadata"]): # E: Name "notdefined" is not defined
     pass
 T = TypeVar('T')
-def f4(a: Annotated[T, "metatdata"]):
+def f4(a: Annotated[T, "metadata"]):
     pass
 reveal_type(f4)  # N: Revealed type is "def [T] (a: T`-1) -> Any"
 [builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-assert-type-fail.test b/test-data/unit/check-assert-type-fail.test
index 89b3a863f8c7..514650649641 100644
--- a/test-data/unit/check-assert-type-fail.test
+++ b/test-data/unit/check-assert-type-fail.test
@@ -31,3 +31,19 @@ def f(si: arr.array[int]):
 from typing import assert_type, Callable
 def myfunc(arg: int) -> None: pass
 assert_type(myfunc, Callable[[int], None])  # E: Expression is of type "Callable[[Arg(int, 'arg')], None]", not "Callable[[int], None]"
+
+[case testAssertTypeOverload]
+from typing import assert_type, overload
+
+class Foo:
+    @overload
+    def __new__(cls, x: int) -> Foo: ...
+    @overload
+    def __new__(cls, x: str) -> Foo: ...
+    def __new__(cls, x: "int | str") -> Foo:
+        return cls(0)
+
+assert_type(Foo, type[Foo])
+A = Foo
+assert_type(A, type[Foo])
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-async-await.test b/test-data/unit/check-async-await.test
index 83a66ef4a815..0ef08e5a0775 100644
--- a/test-data/unit/check-async-await.test
+++ b/test-data/unit/check-async-await.test
@@ -165,6 +165,33 @@ async def f() -> None:
 [out]
 main:4: error: "List[int]" has no attribute "__aiter__" (not async iterable)
 
+[case testAsyncForErrorNote]
+
+from typing import AsyncIterator, AsyncGenerator
+async def g() -> AsyncGenerator[str, None]:
+    pass
+
+async def f() -> None:
+    async for x in g():
+        pass
+[builtins fixtures/async_await.pyi]
+[typing fixtures/typing-async.pyi]
+[out]
+main:7: error: "Coroutine[Any, Any, AsyncGenerator[str, None]]" has no attribute "__aiter__" (not async iterable)
+main:7: note: Maybe you forgot to use "await"?
+
+[case testAsyncForErrorCanBeIgnored]
+
+from typing import AsyncIterator, AsyncGenerator
+async def g() -> AsyncGenerator[str, None]:
+    pass
+
+async def f() -> None:
+    async for x in g():  # type: ignore[attr-defined]
+        pass
+[builtins fixtures/async_await.pyi]
+[typing fixtures/typing-async.pyi]
+
 [case testAsyncForTypeComments]
 
 from typing import AsyncIterator, Union
@@ -183,7 +210,6 @@ async def f() -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncForComprehension]
-# flags: --python-version 3.6
 from typing import Generic, Iterable, TypeVar, AsyncIterator, Tuple
 
 T = TypeVar('T')
@@ -223,7 +249,6 @@ async def generatorexp(obj: Iterable[int]):
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncForComprehensionErrors]
-# flags: --python-version 3.6
 from typing import Generic, Iterable, TypeVar, AsyncIterator, Tuple
 
 T = TypeVar('T')
@@ -240,16 +265,10 @@ class asyncify(Generic[T], AsyncIterator[T]):
             raise StopAsyncIteration
 
 async def wrong_iterable(obj: Iterable[int]):
-    [i async for i in obj]
-    [i for i in asyncify(obj)]
-    {i: i async for i in obj}
-    {i: i for i in asyncify(obj)}
-
-[out]
-main:18: error: "Iterable[int]" has no attribute "__aiter__" (not async iterable)
-main:19: error: "asyncify[int]" has no attribute "__iter__"; maybe "__aiter__"? (not iterable)
-main:20: error: "Iterable[int]" has no attribute "__aiter__" (not async iterable)
-main:21: error: "asyncify[int]" has no attribute "__iter__"; maybe "__aiter__"? (not iterable)
+    [i async for i in obj]  # E: "Iterable[int]" has no attribute "__aiter__" (not async iterable)
+    [i for i in asyncify(obj)]  # E: "asyncify[int]" has no attribute "__iter__"; maybe "__aiter__"? (not iterable)
+    {i: i async for i in obj}  # E: "Iterable[int]" has no attribute "__aiter__" (not async iterable)
+    {i: i for i in asyncify(obj)}  # E: "asyncify[int]" has no attribute "__iter__"; maybe "__aiter__"? (not iterable)
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
 
@@ -291,7 +310,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 +332,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
@@ -340,17 +359,6 @@ async def f() -> None:
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
 
-[case testNoYieldInAsyncDef]
-# flags: --python-version 3.5
-
-async def f():
-    yield None  # E: "yield" in async function
-async def g():
-    yield  # E: "yield" in async function
-async def h():
-    x = yield  # E: "yield" in async function
-[builtins fixtures/async_await.pyi]
-
 [case testNoYieldFromInAsyncDef]
 
 async def f():
@@ -422,7 +430,6 @@ def f() -> Generator[int, str, int]:
 -- ---------------------------------------------------------------------
 
 [case testAsyncGenerator]
-# flags: --python-version 3.6
 from typing import AsyncGenerator, Generator
 
 async def f() -> int:
@@ -450,7 +457,6 @@ async def wrong_return() -> Generator[int, None, None]:  # E: The return type of
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncGeneratorReturnIterator]
-# flags: --python-version 3.6
 from typing import AsyncIterator
 
 async def gen() -> AsyncIterator[int]:
@@ -466,7 +472,6 @@ async def use_gen() -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncGeneratorManualIter]
-# flags: --python-version 3.6
 from typing import AsyncGenerator
 
 async def genfunc() -> AsyncGenerator[int, None]:
@@ -484,7 +489,6 @@ async def user() -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncGeneratorAsend]
-# flags: --python-version 3.6
 from typing import AsyncGenerator
 
 async def f() -> None:
@@ -498,14 +502,13 @@ async def gen() -> AsyncGenerator[int, str]:
 
 async def h() -> None:
     g = gen()
-    await g.asend(())  # E: Argument 1 to "asend" of "AsyncGenerator" has incompatible type "Tuple[]"; expected "str"
+    await g.asend(())  # E: Argument 1 to "asend" of "AsyncGenerator" has incompatible type "Tuple[()]"; expected "str"
     reveal_type(await g.asend('hello'))  # N: Revealed type is "builtins.int"
 
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncGeneratorAthrow]
-# flags: --python-version 3.6
 from typing import AsyncGenerator
 
 async def gen() -> AsyncGenerator[str, int]:
@@ -524,7 +527,6 @@ async def h() -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncGeneratorNoSyncIteration]
-# flags: --python-version 3.6
 from typing import AsyncGenerator
 
 async def gen() -> AsyncGenerator[int, None]:
@@ -532,17 +534,13 @@ async def gen() -> AsyncGenerator[int, None]:
         yield i
 
 def h() -> None:
-    for i in gen():
+    for i in gen():  # E: "AsyncGenerator[int, None]" has no attribute "__iter__"; maybe "__aiter__"? (not iterable)
         pass
 
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-async.pyi]
 
-[out]
-main:9: error: "AsyncGenerator[int, None]" has no attribute "__iter__"; maybe "__aiter__"? (not iterable)
-
 [case testAsyncGeneratorNoYieldFrom]
-# flags: --python-version 3.6
 from typing import AsyncGenerator
 
 async def f() -> AsyncGenerator[int, None]:
@@ -555,7 +553,6 @@ async def gen() -> AsyncGenerator[int, None]:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncGeneratorNoReturnWithValue]
-# flags: --python-version 3.6
 from typing import AsyncGenerator
 
 async def return_int() -> AsyncGenerator[int, None]:
@@ -576,6 +573,25 @@ async def return_f() -> AsyncGenerator[int, None]:
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-async.pyi]
 
+[case testImplicitAsyncGenerator]
+from typing import List
+
+async def get_list() -> List[int]:
+    return [1]
+
+async def predicate() -> bool:
+    return True
+
+async def test_implicit_generators() -> None:
+    reveal_type(await predicate() for _ in [1])  # N: Revealed type is "typing.AsyncGenerator[builtins.bool, None]"
+    reveal_type(x for x in [1] if await predicate())  # N: Revealed type is "typing.AsyncGenerator[builtins.int, None]"
+    reveal_type(x for x in await get_list())  # N: Revealed type is "typing.Generator[builtins.int, None, None]"
+    reveal_type(x for _ in [1] for x in await get_list())  # N: Revealed type is "typing.AsyncGenerator[builtins.int, None]"
+
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-async.pyi]
+
+
 -- The full matrix of coroutine compatibility
 -- ------------------------------------------
 
@@ -768,7 +784,8 @@ class Task(Future[T]):
 
 @overload
 def wait(fs: Iterable[FT]) -> Future[Tuple[List[FT], List[FT]]]: ...  \
-    # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \
+    # N: Flipping the order of overloads will fix this error
 @overload
 def wait(fs: Iterable[Awaitable[T]]) -> Future[Tuple[List[Task[T]], List[Task[T]]]]: ...
 def wait(fs: Any) -> Any:
@@ -792,6 +809,7 @@ async def precise2(futures: Iterable[Awaitable[int]]) -> None:
     done, pending = await wait(futures)
     reveal_type(done)  # N: Revealed type is "builtins.list[__main__.Task[builtins.int]]"
 
+
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
 
@@ -822,8 +840,6 @@ def bar() -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncForOutsideCoroutine]
-# flags: --python-version 3.7
-
 async def g():
     yield 0
 
@@ -844,8 +860,6 @@ async for x in g(): ... # E: "async for" outside async function
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncWithOutsideCoroutine]
-# flags: --python-version 3.7
-
 class C:
     async def __aenter__(self): pass
     async def __aexit__(self, x, y, z): pass
@@ -861,7 +875,6 @@ async with C() as x: # E: "async with" outside async function
 [typing fixtures/typing-async.pyi]
 
 [case testAwaitMissingNote]
-# flags: --python-version 3.7
 from typing import Generic, TypeVar, Generator, Any, Awaitable, Type
 
 class C:
@@ -945,17 +958,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 +985,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]
 
@@ -997,7 +1017,7 @@ crasher = [await foo(x) for x in [1, 2, 3]]  # E: "await" outside function  [top
 
 def bad() -> None:
     # These are always critical / syntax issues:
-    y = [await foo(x) for x in [1, 2, 3]]  # E: "await" outside coroutine ("async def")
+    y = [await foo(x) for x in [1, 2, 3]]  # E: "await" outside coroutine ("async def")  [await-not-async]
 async def good() -> None:
     y = [await foo(x) for x in [1, 2, 3]]  # OK
 [builtins fixtures/async_await.pyi]
@@ -1044,3 +1064,19 @@ def coro() -> Generator[int, None, None]:
 reveal_type(coro)  # N: Revealed type is "def () -> typing.AwaitableGenerator[builtins.int, None, None, typing.Generator[builtins.int, None, None]]"
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
+
+[case asyncIteratorInProtocol]
+from typing import AsyncIterator, Protocol
+
+class P(Protocol):
+    async def launch(self) -> AsyncIterator[int]:
+        raise BaseException
+
+class Launcher(P):
+    def launch(self) -> AsyncIterator[int]:  # E: Return type "AsyncIterator[int]" of "launch" incompatible with return type "Coroutine[Any, Any, AsyncIterator[int]]" in supertype "P" \
+                                             # N: Consider declaring "launch" in supertype "P" without "async" \
+                                             # N: See https://mypy.readthedocs.io/en/stable/more_types.html#asynchronous-iterators
+        raise BaseException
+
+[builtins fixtures/async_await.pyi]
+[typing fixtures/typing-async.pyi]
diff --git a/test-data/unit/check-basic.test b/test-data/unit/check-basic.test
index e10e69267c5a..6ecbbdcc13eb 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")
@@ -219,6 +219,14 @@ reveal_type(__doc__)          # N: Revealed type is "builtins.str"
 reveal_type(__file__)         # N: Revealed type is "builtins.str"
 reveal_type(__package__)      # N: Revealed type is "builtins.str"
 reveal_type(__annotations__)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
+# This will actually reveal Union[importlib.machinery.ModuleSpec, None]
+reveal_type(__spec__)         # N: Revealed type is "Union[builtins.object, None]"
+
+import module
+reveal_type(module.__name__)  # N: Revealed type is "builtins.str"
+# This will actually reveal importlib.machinery.ModuleSpec
+reveal_type(module.__spec__)  # N: Revealed type is "builtins.object"
+[file module.py]
 [builtins fixtures/primitives.pyi]
 
 
@@ -229,12 +237,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 +250,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")
@@ -371,7 +379,7 @@ from typing import List
 x: List[int]
 y: List[float]
 y = x # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[float]") \
-     # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+     # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
      # N: Consider using "Sequence" instead, which is covariant
 [builtins fixtures/list.pyi]
 
@@ -380,17 +388,15 @@ from typing import Dict
 x: Dict[str, int]
 y: Dict[str, float]
 y = x # E: Incompatible types in assignment (expression has type "Dict[str, int]", variable has type "Dict[str, float]") \
-     # N: "Dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+     # N: "dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
      # N: Consider using "Mapping" instead, which is covariant in the value type
 [builtins fixtures/dict.pyi]
 
 [case testDistinctTypes]
-# flags: --strict-optional
 import b
 
 [file a.py]
-from typing import NamedTuple
-from typing_extensions import TypedDict
+from typing import NamedTuple, TypedDict
 from enum import Enum
 class A: pass
 N = NamedTuple('N', [('x', int)])
@@ -399,8 +405,7 @@ class B(Enum):
     b = 10
 
 [file b.py]
-from typing import List, Optional, Union, Sequence, NamedTuple, Tuple, Type
-from typing_extensions import Literal, Final, TypedDict
+from typing import Final, List, Literal, Optional, Union, Sequence, NamedTuple, Tuple, Type, TypedDict
 from enum import Enum
 import a
 class A: pass
@@ -457,8 +462,8 @@ def typeddict() -> Sequence[D]:
 
 a = (a.A(), A())
 a.x  # E: "Tuple[a.A, b.A]" has no attribute "x"
-
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testReturnAnyFromFunctionDeclaredToReturnObject]
 # flags: --warn-return-any
@@ -503,3 +508,19 @@ s2: str = 42  # E: Incompatible types in assignment (expression has type "int",
 s3: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 [file c.py]
 s3: str = 'foo'
+
+[case testMultilineQuotedAnnotation]
+x: """
+
+   int |
+   str
+
+"""
+reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+y: """(
+    int |
+    str
+)
+"""
+reveal_type(y)  # N: Revealed type is "Union[builtins.int, builtins.str]"
diff --git a/test-data/unit/check-bound.test b/test-data/unit/check-bound.test
index eb97bde32e1f..1f9eba612020 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 --no-local-partial-types
 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 --no-local-partial-types
 from typing import TypeVar, Callable
 class A: pass
 T = TypeVar('T', bound=A)
diff --git a/test-data/unit/check-callable.test b/test-data/unit/check-callable.test
index 7d25eb271f53..39e6c4fa3ff1 100644
--- a/test-data/unit/check-callable.test
+++ b/test-data/unit/check-callable.test
@@ -525,7 +525,6 @@ else:
 [builtins fixtures/callable.pyi]
 
 [case testBuiltinsTypeAsCallable]
-# flags: --python-version 3.7
 from __future__ import annotations
 
 reveal_type(type)  # N: Revealed type is "def (x: Any) -> builtins.type"
@@ -587,3 +586,45 @@ class C(B):
     def f(self, x: int) -> C: ...
 class B: ...
 [builtins fixtures/classmethod.pyi]
+
+[case testCallableUnionCallback]
+from typing import Union, Callable, TypeVar
+
+TA = TypeVar("TA", bound="A")
+class A:
+    def __call__(self: TA, other: Union[Callable, TA]) -> TA: ...
+a: A
+a()  # E: Missing positional argument "other" in call to "__call__" of "A"
+a(a)
+a(lambda: None)
+
+[case testCallableSubtypingTrivialSuffix]
+from typing import Any, Protocol
+
+class Call(Protocol):
+    def __call__(self, x: int, *args: Any, **kwargs: Any) -> None: ...
+
+def f1() -> None: ...
+a1: Call = f1  # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "Call") \
+               # N: "Call.__call__" has type "Callable[[Arg(int, 'x'), VarArg(Any), KwArg(Any)], None]"
+def f2(x: str) -> None: ...
+a2: Call = f2  # E: Incompatible types in assignment (expression has type "Callable[[str], None]", variable has type "Call") \
+               # N: "Call.__call__" has type "Callable[[Arg(int, 'x'), VarArg(Any), KwArg(Any)], None]"
+def f3(y: int) -> None: ...
+a3: Call = f3  # E: Incompatible types in assignment (expression has type "Callable[[int], None]", variable has type "Call") \
+               # N: "Call.__call__" has type "Callable[[Arg(int, 'x'), VarArg(Any), KwArg(Any)], None]"
+def f4(x: int) -> None: ...
+a4: Call = f4
+
+def f5(x: int, y: int) -> None: ...
+a5: Call = f5
+
+def f6(x: int, y: int = 0) -> None: ...
+a6: Call = f6
+
+def f7(x: int, *, y: int) -> None: ...
+a7: Call = f7
+
+def f8(x: int, *args: int, **kwargs: str) -> None: ...
+a8: Call = f8
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-class-namedtuple.test b/test-data/unit/check-class-namedtuple.test
index 8ae7f6555f9d..fd564c7e96cb 100644
--- a/test-data/unit/check-class-namedtuple.test
+++ b/test-data/unit/check-class-namedtuple.test
@@ -1,13 +1,4 @@
-[case testNewNamedTupleOldPythonVersion]
-# flags: --python-version 3.5
-from typing import NamedTuple
-
-class E(NamedTuple):  # E: NamedTuple class syntax is only supported in Python 3.6
-    pass
-[builtins fixtures/tuple.pyi]
-
 [case testNewNamedTupleNoUnderscoreFields]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -17,7 +8,6 @@ class X(NamedTuple):
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleAccessingAttributes]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -31,7 +21,6 @@ x.z # E: "X" has no attribute "z"
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleAttributesAreReadOnly]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -47,7 +36,6 @@ a.x = 5 # E: Property "x" defined in "X" is read-only
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleCreateWithPositionalArguments]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -62,7 +50,6 @@ x = X(1, '2', 3)  # E: Too many arguments for "X"
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleShouldBeSingleBase]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class A: ...
@@ -71,7 +58,6 @@ class X(NamedTuple, A):  # E: NamedTuple should be a single base
 [builtins fixtures/tuple.pyi]
 
 [case testCreateNewNamedTupleWithKeywordArguments]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -85,7 +71,6 @@ x = X(y='x') # E: Missing positional argument "x" in call to "X"
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleCreateAndUseAsTuple]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -98,7 +83,6 @@ a, b, c = x  # E: Need more than 2 values to unpack (3 expected)
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleWithItemTypes]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class N(NamedTuple):
@@ -116,7 +100,6 @@ if int():
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleConstructorArgumentTypes]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class N(NamedTuple):
@@ -130,7 +113,6 @@ N(b='x', a=1)
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleAsBaseClass]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class N(NamedTuple):
@@ -151,7 +133,6 @@ if int():
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleSelfTypeWithNamedTupleAsBase]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class A(NamedTuple):
@@ -172,7 +153,6 @@ class B(A):
 [out]
 
 [case testNewNamedTupleTypeReferenceToClassDerivedFrom]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class A(NamedTuple):
@@ -194,7 +174,6 @@ class B(A):
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleSubtyping]
-# flags: --python-version 3.6
 from typing import NamedTuple, Tuple
 
 class A(NamedTuple):
@@ -222,7 +201,6 @@ if int():
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleSimpleTypeInference]
-# flags: --python-version 3.6
 from typing import NamedTuple, Tuple
 
 class A(NamedTuple):
@@ -239,7 +217,6 @@ a = (1,)  # E: Incompatible types in assignment (expression has type "Tuple[int]
 [builtins fixtures/list.pyi]
 
 [case testNewNamedTupleMissingClassAttribute]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class MyNamedTuple(NamedTuple):
@@ -250,7 +227,6 @@ MyNamedTuple.x # E: "Type[MyNamedTuple]" has no attribute "x"
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleEmptyItems]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class A(NamedTuple):
@@ -258,7 +234,6 @@ class A(NamedTuple):
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleForwardRef]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class A(NamedTuple):
@@ -271,7 +246,6 @@ a = A(1)  # E: Argument 1 to "A" has incompatible type "int"; expected "B"
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleProperty36]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class A(NamedTuple):
@@ -288,7 +262,6 @@ C(2).b
 [builtins fixtures/property.pyi]
 
 [case testNewNamedTupleAsDict]
-# flags: --python-version 3.6
 from typing import NamedTuple, Any
 
 class X(NamedTuple):
@@ -301,7 +274,6 @@ reveal_type(x._asdict())  # N: Revealed type is "builtins.dict[builtins.str, Any
 [builtins fixtures/dict.pyi]
 
 [case testNewNamedTupleReplaceTyped]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -315,7 +287,6 @@ x._replace(y=5)  # E: Argument "y" to "_replace" of "X" has incompatible type "i
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleFields]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -325,12 +296,14 @@ 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]"
 
-[builtins fixtures/dict.pyi]
+# 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-full.pyi]
 
 [case testNewNamedTupleUnit]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -342,7 +315,6 @@ x._fields[0]  # E: Tuple index out of range
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleJoinNamedTuple]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -357,7 +329,6 @@ reveal_type([X(3, 'b'), Y(1, 'a')])  # N: Revealed type is "builtins.list[Tuple[
 [builtins fixtures/list.pyi]
 
 [case testNewNamedTupleJoinTuple]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -370,7 +341,6 @@ reveal_type([X(1, 'a'), (3, 'b')])  # N: Revealed type is "builtins.list[Tuple[b
 [builtins fixtures/list.pyi]
 
 [case testNewNamedTupleWithTooManyArguments]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -380,25 +350,17 @@ class X(NamedTuple):
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleWithInvalidItems2]
-# flags: --python-version 3.6
 import typing
 
 class X(typing.NamedTuple):
     x: int
-    y = 1
-    x.x: int
+    y = 1  # E: Invalid statement in NamedTuple definition; expected "field_name: field_type [= default]"
+    x.x: int  # E: Invalid statement in NamedTuple definition; expected "field_name: field_type [= default]"
     z: str = 'z'
-    aa: int
-
-[out]
-main:6: error: Invalid statement in NamedTuple definition; expected "field_name: field_type [= default]"
-main:7: error: Invalid statement in NamedTuple definition; expected "field_name: field_type [= default]"
-main:9: error: Non-default NamedTuple fields cannot follow default fields
-
+    aa: int  # E: Non-default NamedTuple fields cannot follow default fields
 [builtins fixtures/list.pyi]
 
 [case testNewNamedTupleWithoutTypesSpecified]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -407,7 +369,6 @@ class X(NamedTuple):
 [builtins fixtures/tuple.pyi]
 
 [case testTypeUsingTypeCNamedTuple]
-# flags: --python-version 3.6
 from typing import NamedTuple, Type
 
 class N(NamedTuple):
@@ -415,13 +376,10 @@ class N(NamedTuple):
     y: str
 
 def f(a: Type[N]):
-    a()
+    a()  # E: Missing positional arguments "x", "y" in call to "N"
 [builtins fixtures/list.pyi]
-[out]
-main:9: error: Missing positional arguments "x", "y" in call to "N"
 
 [case testNewNamedTupleWithDefaults]
-# flags: --python-version 3.6
 from typing import List, NamedTuple, Optional
 
 class X(NamedTuple):
@@ -461,7 +419,6 @@ UserDefined(1)  # E: Argument 1 to "UserDefined" has incompatible type "int"; ex
 [builtins fixtures/list.pyi]
 
 [case testNewNamedTupleWithDefaultsStrictOptional]
-# flags: --strict-optional --python-version 3.6
 from typing import List, NamedTuple, Optional
 
 class HasNone(NamedTuple):
@@ -480,7 +437,6 @@ class CannotBeNone(NamedTuple):
 [builtins fixtures/list.pyi]
 
 [case testNewNamedTupleWrongType]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -489,7 +445,6 @@ class X(NamedTuple):
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleErrorInDefault]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -497,7 +452,6 @@ class X(NamedTuple):
 [builtins fixtures/tuple.pyi]
 
 [case testNewNamedTupleInheritance]
-# flags: --python-version 3.6
 from typing import NamedTuple
 
 class X(NamedTuple):
@@ -581,7 +535,7 @@ class Base(NamedTuple):
         self.x = 3  # E: Property "x" defined in "Base" is read-only
         self[1]  # E: Tuple index out of range
         reveal_type(self[T])  # N: Revealed type is "builtins.int" \
-                              # E: No overload variant of "__getitem__" of "tuple" matches argument type "object" \
+                              # E: No overload variant of "__getitem__" of "tuple" matches argument type "TypeVar" \
                               # N: Possible overload variants: \
                               # N:     def __getitem__(self, int, /) -> int \
                               # N:     def __getitem__(self, slice, /) -> Tuple[int, ...]
@@ -614,6 +568,7 @@ reveal_type(Base(1).bad_override())  # N: Revealed type is "builtins.int"
 reveal_type(takes_base(Base(1)))  # N: Revealed type is "builtins.int"
 reveal_type(takes_base(Child(1)))  # N: Revealed type is "builtins.int"
 [builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testNewNamedTupleIllegalNames]
 from typing import Callable, NamedTuple
diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
index c2eddbc597a0..e0ea00aee361 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]
@@ -112,7 +113,7 @@ A().f = None # E: Cannot assign to a method
 from typing import Protocol
 
 class Base:
-    __hash__ = None
+    __hash__: None = None
 
 class Derived(Base):
     def __hash__(self) -> int:  # E: Signature of "__hash__" incompatible with supertype "Base" \
@@ -144,8 +145,7 @@ class Base:
         pass
 
 class Derived(Base):
-    __hash__ = 1  # E: Incompatible types in assignment (expression has type "int", base class "Base" defined the type as "Callable[[Base], int]")
-
+    __hash__ = 1  # E: Incompatible types in assignment (expression has type "int", base class "Base" defined the type as "Callable[[], int]")
 
 [case testOverridePartialAttributeWithMethod]
 # This was crashing: https://github.com/python/mypy/issues/11686.
@@ -202,8 +202,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 +217,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 +458,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:
@@ -686,6 +687,20 @@ class B(A):
     def h(cls) -> int: pass
 [builtins fixtures/classmethod.pyi]
 
+[case testOverrideReplaceMethod]
+# flags: --show-error-codes
+from typing import Optional
+from typing_extensions import Self
+class A:
+    def __replace__(self, x: Optional[str]) -> Self: pass
+
+class B(A):
+    def __replace__(self, x: str) -> Self: pass # E: \
+        # E: Argument 1 of "__replace__" is incompatible with supertype "A"; supertype defines the argument type as "Optional[str]"  [override] \
+        # N: This violates the Liskov substitution principle \
+        # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
+[builtins fixtures/tuple.pyi]
+
 [case testAllowCovarianceInReadOnlyAttributes]
 from typing import Callable, TypeVar
 
@@ -708,6 +723,123 @@ class B(A):
     @dec
     def f(self) -> Y: pass
 
+[case testOverrideCallableAttributeWithMethod]
+from typing import Callable
+
+class A:
+    f1: Callable[[str], None]
+    f2: Callable[[str], None]
+    f3: Callable[[str], None]
+
+class B(A):
+    def f1(self, x: object) -> None:
+        pass
+
+    @classmethod
+    def f2(cls, x: object) -> None:
+        pass
+
+    @staticmethod
+    def f3(x: object) -> None:
+        pass
+[builtins fixtures/classmethod.pyi]
+
+[case testOverrideCallableAttributeWithMethodMutableOverride]
+# flags: --enable-error-code=mutable-override
+from typing import Callable
+
+class A:
+    f1: Callable[[str], None]
+    f2: Callable[[str], None]
+    f3: Callable[[str], None]
+
+class B(A):
+    def f1(self, x: object) -> None: pass   # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], None]", override has type "Callable[[object], None]")
+
+    @classmethod
+    def f2(cls, x: object) -> None: pass    # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], None]", override has type "Callable[[object], None]")
+
+    @staticmethod
+    def f3(x: object) -> None: pass         # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], None]", override has type "Callable[[object], None]")
+[builtins fixtures/classmethod.pyi]
+
+[case testOverrideCallableAttributeWithSettableProperty]
+from typing import Callable
+
+class A:
+    f: Callable[[str], None]
+
+class B(A):
+    @property
+    def f(self) -> Callable[[object], None]: pass
+    @func.setter
+    def f(self, x: object) -> None: pass
+[builtins fixtures/property.pyi]
+
+[case testOverrideCallableAttributeWithSettablePropertyMutableOverride]
+# flags: --enable-error-code=mutable-override
+from typing import Callable
+
+class A:
+    f: Callable[[str], None]
+
+class B(A):
+    @property
+    def f(self) -> Callable[[object], None]: pass
+    @func.setter
+    def f(self, x: object) -> None: pass
+[builtins fixtures/property.pyi]
+
+[case testOverrideCallableUnionAttributeWithMethod]
+from typing import Callable, Union
+
+class A:
+    f1: Union[Callable[[str], str], str]
+    f2: Union[Callable[[str], str], str]
+    f3: Union[Callable[[str], str], str]
+    f4: Union[Callable[[str], str], str]
+
+class B(A):
+    def f1(self, x: str) -> str:
+        pass
+
+    def f2(self, x: object) -> str:
+        pass
+
+    @classmethod
+    def f3(cls, x: str) -> str:
+        pass
+
+    @staticmethod
+    def f4(x: str) -> str:
+        pass
+[builtins fixtures/classmethod.pyi]
+
+[case testOverrideCallableUnionAttributeWithMethodMutableOverride]
+# flags: --enable-error-code=mutable-override
+from typing import Callable, Union
+
+class A:
+    f1: Union[Callable[[str], str], str]
+    f2: Union[Callable[[str], str], str]
+    f3: Union[Callable[[str], str], str]
+    f4: Union[Callable[[str], str], str]
+
+class B(A):
+    def f1(self, x: str) -> str:     # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[str], str]")
+        pass
+
+    def f2(self, x: object) -> str:  # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[object], str]")
+        pass
+
+    @classmethod
+    def f3(cls, x: str) -> str:      # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[str], str]")
+        pass
+
+    @staticmethod
+    def f4(x: str) -> str:           # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[str], str]")
+        pass
+[builtins fixtures/classmethod.pyi]
 
 -- Constructors
 -- ------------
@@ -907,7 +1039,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)
 
@@ -933,7 +1065,6 @@ if int():
     b = D2()
 
 [case testConstructorJoinsWithCustomMetaclass]
-# flags: --strict-optional
 from typing import TypeVar
 import abc
 
@@ -1017,13 +1148,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 +1192,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 +1209,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 +1219,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 +1273,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]
@@ -1158,7 +1292,7 @@ def test() -> None:
             reveal_type(x)  # N: Revealed type is "T`-1"
             reveal_type(x.returns_int())  # N: Revealed type is "builtins.int"
             return foo
-    reveal_type(Foo.bar)  # N: Revealed type is "def [T <: __main__.Foo@5] (self: __main__.Foo@5, foo: T`-1) -> T`-1"
+    reveal_type(Foo.bar)  # N: Revealed type is "def [T <: __main__.Foo@5] (self: __main__.Foo@5, foo: T`1) -> T`1"
 
 [case testGenericClassWithInvalidTypevarUseWithinFunction]
 from typing import TypeVar
@@ -1200,7 +1334,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 +1343,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 +1390,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
@@ -1624,7 +1758,6 @@ a = A()
 reveal_type(a.f)  # N: Revealed type is "__main__.D"
 
 [case testAccessingDescriptorFromClass]
-# flags: --strict-optional
 from d import D, Base
 class A(Base):
     f = D()
@@ -1642,7 +1775,6 @@ class D:
 [builtins fixtures/bool.pyi]
 
 [case testAccessingDescriptorFromClassWrongBase]
-# flags: --strict-optional
 from d import D, Base
 class A:
     f = D()
@@ -1659,13 +1791,13 @@ class D:
     def __get__(self, inst: Base, own: Type[Base]) -> str: pass
 [builtins fixtures/bool.pyi]
 [out]
-main:5: error: Argument 2 to "__get__" of "D" has incompatible type "Type[A]"; expected "Type[Base]"
-main:5: note: Revealed type is "d.D"
-main:6: error: No overload variant of "__get__" of "D" matches argument types "A", "Type[A]"
-main:6: note: Possible overload variants:
-main:6: note:     def __get__(self, inst: None, own: Type[Base]) -> D
-main:6: note:     def __get__(self, inst: Base, own: Type[Base]) -> str
-main:6: note: Revealed type is "Any"
+main:4: error: Argument 2 to "__get__" of "D" has incompatible type "Type[A]"; expected "Type[Base]"
+main:4: note: Revealed type is "d.D"
+main:5: error: No overload variant of "__get__" of "D" matches argument types "A", "Type[A]"
+main:5: note: Possible overload variants:
+main:5: note:     def __get__(self, inst: None, own: Type[Base]) -> D
+main:5: note:     def __get__(self, inst: Base, own: Type[Base]) -> str
+main:5: note: Revealed type is "Any"
 
 [case testAccessingGenericNonDataDescriptor]
 from typing import TypeVar, Type, Generic, Any
@@ -1697,7 +1829,6 @@ a.g = ''
 a.g = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 
 [case testAccessingGenericDescriptorFromClass]
-# flags: --strict-optional
 from d import D
 class A:
     f = D(10)  # type: D[A, int]
@@ -1719,7 +1850,6 @@ class D(Generic[T, V]):
 [builtins fixtures/bool.pyi]
 
 [case testAccessingGenericDescriptorFromInferredClass]
-# flags: --strict-optional
 from typing import Type
 from d import D
 class A:
@@ -1740,11 +1870,10 @@ class D(Generic[T, V]):
     def __get__(self, inst: T, own: Type[T]) -> V: pass
 [builtins fixtures/bool.pyi]
 [out]
-main:8: note: Revealed type is "d.D[__main__.A, builtins.int]"
-main:9: note: Revealed type is "d.D[__main__.A, builtins.str]"
+main:7: note: Revealed type is "d.D[__main__.A, builtins.int]"
+main:8: note: Revealed type is "d.D[__main__.A, builtins.str]"
 
 [case testAccessingGenericDescriptorFromClassBadOverload]
-# flags: --strict-optional
 from d import D
 class A:
     f = D(10)  # type: D[A, int]
@@ -1761,11 +1890,11 @@ class D(Generic[T, V]):
     def __get__(self, inst: T, own: Type[T]) -> V: pass
 [builtins fixtures/bool.pyi]
 [out]
-main:5: error: No overload variant of "__get__" of "D" matches argument types "None", "Type[A]"
-main:5: note: Possible overload variants:
-main:5: note:     def __get__(self, inst: None, own: None) -> D[A, int]
-main:5: note:     def __get__(self, inst: A, own: Type[A]) -> int
-main:5: note: Revealed type is "Any"
+main:4: error: No overload variant of "__get__" of "D" matches argument types "None", "Type[A]"
+main:4: note: Possible overload variants:
+main:4: note:     def __get__(self, inst: None, own: None) -> D[A, int]
+main:4: note:     def __get__(self, inst: A, own: Type[A]) -> int
+main:4: note: Revealed type is "Any"
 
 [case testAccessingNonDataDescriptorSubclass]
 from typing import Any
@@ -1951,6 +2080,41 @@ class B:
 def foo(x: Union[A, B]) -> None:
     reveal_type(x.attr)  # N: Revealed type is "builtins.str"
 
+[case testDescriptorGetUnionRestricted]
+from typing import Any, Union
+
+class getter:
+    def __get__(self, instance: X1, owner: Any) -> str: ...
+
+class X1:
+    prop = getter()
+
+class X2:
+    prop: str
+
+def foo(x: Union[X1, X2]) -> None:
+    reveal_type(x.prop)  # N: Revealed type is "builtins.str"
+
+[case testDescriptorGetUnionType]
+from typing import Any, Union, Type, overload
+
+class getter:
+    @overload
+    def __get__(self, instance: None, owner: Any) -> getter: ...
+    @overload
+    def __get__(self, instance: object, owner: Any) -> str: ...
+    def __get__(self, instance, owner):
+        ...
+
+class X1:
+    prop = getter()
+class X2:
+    prop = getter()
+
+def foo(x: Type[Union[X1, X2]]) -> None:
+    reveal_type(x.prop)  # N: Revealed type is "__main__.getter"
+
+
 -- _promote decorators
 -- -------------------
 
@@ -1960,8 +2124,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 +2138,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
@@ -2019,7 +2183,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
@@ -2069,7 +2233,7 @@ reveal_type(B() + A())  # N: Revealed type is "__main__.A"
 reveal_type(A() + B())  # N: Revealed type is "__main__.A"
 [builtins fixtures/isinstance.pyi]
 
-[case testBinaryOpeartorMethodPositionalArgumentsOnly]
+[case testBinaryOperatorMethodPositionalArgumentsOnly]
 class A:
     def __add__(self, other: int) -> int: pass
     def __iadd__(self, other: int) -> int: pass
@@ -2138,7 +2302,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 *
@@ -2393,10 +2557,10 @@ class B:
 [builtins fixtures/tuple.pyi]
 
 [case testReverseOperatorTypeVar1]
-from typing import TypeVar, Any
+from typing import TypeVar
 T = TypeVar("T", bound='Real')
 class Real:
-    def __add__(self, other: Any) -> str: ...
+    def __add__(self, other: object) -> str: ...
 class Fraction(Real):
     def __radd__(self, other: T) -> T: ...  # E: Signatures of "__radd__" of "Fraction" and "__add__" of "T" are unsafely overlapping
 
@@ -2431,7 +2595,7 @@ reveal_type(Real() + Fraction())      # N: Revealed type is "__main__.Real"
 reveal_type(Fraction() + Fraction())  # N: Revealed type is "builtins.str"
 
 [case testReverseOperatorTypeVar3]
-from typing import TypeVar, Any
+from typing import TypeVar
 T = TypeVar("T", bound='Real')
 class Real:
     def __add__(self, other: FractionChild) -> str: ...
@@ -2667,14 +2831,12 @@ class X:
 [out]
 tmp/foo.pyi:6: error: Signatures of "__radd__" of "B" and "__add__" of "X" are unsafely overlapping
 
-[case testUnsafeOverlappingWithLineNo]
+[case testUnsafeOverlappingNotWithAny]
 from typing import TypeVar
 class Real:
     def __add__(self, other) -> str: ...
 class Fraction(Real):
     def __radd__(self, other: Real) -> Real: ...
-[out]
-main:5: error: Signatures of "__radd__" of "Fraction" and "__add__" of "Real" are unsafely overlapping
 
 [case testOverlappingNormalAndInplaceOperatorMethod]
 import typing
@@ -2734,8 +2896,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 +2952,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()
@@ -2973,7 +3135,8 @@ from typing import Any
 class Test:
     def __setattr__() -> None: ...  # E: Method must have at least one argument. Did you forget the "self" argument? # E: Invalid signature "Callable[[], None]" for "__setattr__"
 t = Test()
-t.crash = 'test'  # E: "Test" has no attribute "crash"
+t.crash = 'test'  # E: Attribute function "__setattr__" with type "Callable[[], None]" does not accept self argument \
+                  # E: "Test" has no attribute "crash"
 
 class A:
     def __setattr__(self): ...  # E: Invalid signature "Callable[[A], Any]" for "__setattr__"
@@ -3072,8 +3235,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
@@ -3431,7 +3595,7 @@ def foo(arg: Type[Any]):
 from typing import Type, Any
 def foo(arg: Type[Any]):
     reveal_type(arg.__str__)  # N: Revealed type is "def () -> builtins.str"
-    reveal_type(arg.mro())  # N: Revealed type is "builtins.list[builtins.type[Any]]"
+    reveal_type(arg.mro())  # N: Revealed type is "builtins.list[builtins.type]"
 [builtins fixtures/type.pyi]
 [out]
 
@@ -3546,7 +3710,7 @@ def new(uc: Type[U]) -> U:
     if 1:
         u = uc(0)
         u.foo()
-        u = uc('')  # Error
+        uc('')  # Error
         u.foo(0)  # Error
         return uc()
 u = new(User)
@@ -3596,15 +3760,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 +3778,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]"
@@ -4007,10 +4171,16 @@ def f(a: Type[User]) -> int: pass  # E: Overloaded function signatures 1 and 2 o
 @overload
 def f(a: object) -> str: pass
 
+# Note: plain type is equivalent to Type[Any] so no error here
 @overload
-def g(a: Type[User]) -> int: pass  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def g(a: Type[User]) -> int: pass
 @overload
 def g(a: type) -> str: pass
+
+@overload
+def h(a: Type[User]) -> int: pass  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+@overload
+def h(a: Type[object]) -> str: pass
 [builtins fixtures/classmethod.pyi]
 [out]
 
@@ -4284,7 +4454,7 @@ class A:
     def a(self) -> None: pass
     b = 1
 class B(A):
-    a = 1  # E: Incompatible types in assignment (expression has type "int", base class "A" defined the type as "Callable[[A], None]")
+    a = 1  # E: Incompatible types in assignment (expression has type "int", base class "A" defined the type as "Callable[[], None]")
     def b(self) -> None: pass  # E: Signature of "b" incompatible with supertype "A" \
                                # N:      Superclass: \
                                # N:          int \
@@ -4377,20 +4547,20 @@ main:7: error: Incompatible types in assignment (expression has type "Callable[[
 [case testClassSpec]
 from typing import Callable
 class A():
-    b = None  # type: Callable[[A, int], int]
+    b = None  # type: Callable[[int], int]
 class B(A):
     def c(self, a: int) -> int: pass
     b = c
+reveal_type(A().b)  # N: Revealed type is "def (builtins.int) -> builtins.int"
+reveal_type(B().b)  # N: Revealed type is "def (a: builtins.int) -> builtins.int"
 
 [case testClassSpecError]
 from typing import Callable
 class A():
-    b = None  # type: Callable[[A, int], int]
+    b = None  # type: Callable[[int], int]
 class B(A):
     def c(self, a: str) -> int: pass
-    b = c
-[out]
-main:6: error: Incompatible types in assignment (expression has type "Callable[[str], int]", base class "A" defined the type as "Callable[[int], int]")
+    b = c  # E: Incompatible types in assignment (expression has type "Callable[[str], int]", base class "A" defined the type as "Callable[[int], int]")
 
 [case testClassStaticMethod]
 class A():
@@ -4412,10 +4582,11 @@ class A():
 class B(A):
     @staticmethod
     def b(a: str) -> None: pass
-    c = b
+    c = b  # E: Incompatible types in assignment (expression has type "Callable[[str], None]", base class "A" defined the type as "Callable[[int], None]")
+a: A
+reveal_type(a.a)  # N: Revealed type is "def (a: builtins.int)"
+reveal_type(a.c)  # N: Revealed type is "def (a: builtins.int)"
 [builtins fixtures/staticmethod.pyi]
-[out]
-main:8: error: Incompatible types in assignment (expression has type "Callable[[str], None]", base class "A" defined the type as "Callable[[int], None]")
 
 [case testClassStaticMethodSubclassing]
 class A:
@@ -4480,22 +4651,20 @@ class B(A):
 class A:
     x = 1
 class B(A):
-    x = "a"
+    x = "a"  # E: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
 class C(B):
-    x = object()
-[out]
-main:4: error: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
-main:6: error: Incompatible types in assignment (expression has type "object", base class "A" defined the type as "int")
+    x = object()  # E: Incompatible types in assignment (expression has type "object", base class "B" defined the type as "str")
 
 [case testClassOneErrorPerLine]
 class A:
-  x = 1
+    x = 1
 class B(A):
-  x = ""
-  x = 1.0
-[out]
-main:4: error: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
-main:5: error: Incompatible types in assignment (expression has type "float", base class "A" defined the type as "int")
+    x: str = ""  # E: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
+    x = 1.0  # E: Incompatible types in assignment (expression has type "float", variable has type "str")
+class BInfer(A):
+    x = ""  # E: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
+    x = 1.0  # E: Incompatible types in assignment (expression has type "float", variable has type "str") \
+             # E: Incompatible types in assignment (expression has type "float", base class "A" defined the type as "int")
 
 [case testClassIgnoreType_RedefinedAttributeAndGrandparentAttributeTypesNotIgnored]
 class A:
@@ -4503,8 +4672,7 @@ class A:
 class B(A):
     x = ''  # type: ignore
 class C(B):
-    x = ''  # E: Incompatible types in assignment (expression has type "str", base class "A" defined the type as "int")
-[out]
+    x = ''
 
 [case testClassIgnoreType_RedefinedAttributeTypeIgnoredInChildren]
 class A:
@@ -4513,7 +4681,6 @@ class B(A):
     x = ''  # type: ignore
 class C(B):
     x = ''  # type: ignore
-[out]
 
 [case testInvalidMetaclassStructure]
 class X(type): pass
@@ -4540,6 +4707,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
@@ -4718,12 +4918,15 @@ def g(x: Type[S]) -> str:
     return reveal_type(x * 0)  # N: Revealed type is "builtins.str"
 
 [case testMetaclassGetitem]
+import types
+
 class M(type):
     def __getitem__(self, key) -> int: return 1
 
 class A(metaclass=M): pass
 
 reveal_type(A[M])  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
 
 [case testMetaclassSelfType]
 from typing import TypeVar, Type
@@ -4961,7 +5164,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]
 
@@ -4969,20 +5172,22 @@ class A(Tuple[int, str]): pass
 -- -----------------------
 
 [case testCrashOnSelfRecursiveNamedTupleVar]
-# flags: --disable-recursive-aliases
 from typing import NamedTuple
 
-N = NamedTuple('N', [('x', N)]) # E: Cannot resolve name "N" (possible cyclic definition)
-n: N
-reveal_type(n) # N: Revealed type is "Tuple[Any, fallback=__main__.N]"
+def test() -> None:
+    N = NamedTuple('N', [('x', N)]) # E: Cannot resolve name "N" (possible cyclic definition) \
+                                    # N: Recursive types are not allowed at function scope
+    n: N
+    reveal_type(n) # N: Revealed type is "Tuple[Any, fallback=__main__.N@4]"
 [builtins fixtures/tuple.pyi]
 
 [case testCrashOnSelfRecursiveTypedDictVar]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 A = TypedDict('A', {'a': 'A'})  # type: ignore
 a: A
 [builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCrashInJoinOfSelfRecursiveNamedTuples]
 
@@ -4999,19 +5204,22 @@ lst = [n, m]
 [builtins fixtures/isinstancelist.pyi]
 
 [case testCorrectJoinOfSelfRecursiveTypedDicts]
-# flags: --disable-recursive-aliases
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
-class N(TypedDict):
-    x: N # E: Cannot resolve name "N" (possible cyclic definition)
-class M(TypedDict):
-    x: M # E: Cannot resolve name "M" (possible cyclic definition)
-
-n: N
-m: M
-lst = [n, m]
-reveal_type(lst[0]['x'])  # N: Revealed type is "Any"
+def test() -> None:
+    class N(TypedDict):
+        x: N  # E: Cannot resolve name "N" (possible cyclic definition) \
+              # N: Recursive types are not allowed at function scope
+    class M(TypedDict):
+        x: M  # E: Cannot resolve name "M" (possible cyclic definition) \
+              # N: Recursive types are not allowed at function scope
+
+    n: N
+    m: M
+    lst = [n, m]
+    reveal_type(lst[0]['x'])  # N: Revealed type is "Any"
 [builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCrashInForwardRefToNamedTupleWithIsinstance]
 from typing import Dict, NamedTuple
@@ -5028,8 +5236,7 @@ def parse_ast(name_dict: NameDict) -> None:
 [typing fixtures/typing-medium.pyi]
 
 [case testCrashInForwardRefToTypedDictWithIsinstance]
-from mypy_extensions import TypedDict
-from typing import Dict
+from typing import Dict, TypedDict
 
 NameDict = Dict[str, 'NameInfo']
 class NameInfo(TypedDict):
@@ -5040,7 +5247,7 @@ def parse_ast(name_dict: NameDict) -> None:
         pass
     reveal_type(name_dict['']['ast'])  # N: Revealed type is "builtins.bool"
 [builtins fixtures/isinstancelist.pyi]
-[typing fixtures/typing-medium.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCorrectIsinstanceInForwardRefToNewType]
 from typing import Dict, NewType
@@ -5069,6 +5276,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]
@@ -5083,6 +5291,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])"
@@ -5103,13 +5312,13 @@ x = NT(N(1))
 
 [case testNewTypeFromForwardTypedDict]
 
-from typing import NewType, Tuple
-from mypy_extensions import TypedDict
+from typing import NewType, Tuple, TypedDict
 
 NT = NewType('NT', 'N') # E: Argument 2 to NewType(...) must be subclassable (got "N")
 class N(TypedDict):
     x: int
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testCorrectAttributeInForwardRefToNamedTuple]
@@ -5125,7 +5334,7 @@ class Process(NamedTuple):
 [out]
 
 [case testCorrectItemTypeInForwardRefToTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 proc: Process
 reveal_type(proc['state'])  # N: Revealed type is "builtins.int"
 
@@ -5134,6 +5343,7 @@ def get_state(proc: 'Process') -> int:
 class Process(TypedDict):
      state: int
 [builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testCorrectDoubleForwardNamedTuple]
@@ -5152,7 +5362,7 @@ reveal_type(x.one.attr)  # N: Revealed type is "builtins.str"
 [out]
 
 [case testCrashOnDoubleForwardTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 x: A
 class A(TypedDict):
@@ -5163,6 +5373,7 @@ class B(TypedDict):
 
 reveal_type(x['one']['attr'])  # N: Revealed type is "builtins.str"
 [builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testCrashOnForwardUnionOfNamedTuples]
@@ -5182,8 +5393,7 @@ def foo(node: Node) -> int:
 [out]
 
 [case testCrashOnForwardUnionOfTypedDicts]
-from mypy_extensions import TypedDict
-from typing import Union
+from typing import TypedDict, Union
 
 NodeType = Union['Foo', 'Bar']
 class Foo(TypedDict):
@@ -5195,6 +5405,7 @@ def foo(node: NodeType) -> int:
     x = node
     return x['x']
 [builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testSupportForwardUnionOfNewTypes]
@@ -5261,8 +5472,7 @@ def f(x: ForwardUnion) -> None:
 [out]
 
 [case testCrashInvalidArgsSyntheticClassSyntax]
-from typing import List, NamedTuple
-from mypy_extensions import TypedDict
+from typing import List, NamedTuple, TypedDict
 class TD(TypedDict):
     x: List[int, str] # E: "list" expects 1 type argument, but 2 given
 class NM(NamedTuple):
@@ -5272,11 +5482,11 @@ class NM(NamedTuple):
 TD({'x': []})
 NM(x=[])
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testCrashInvalidArgsSyntheticClassSyntaxReveals]
-from typing import List, NamedTuple
-from mypy_extensions import TypedDict
+from typing import List, NamedTuple, TypedDict
 class TD(TypedDict):
     x: List[int, str] # E: "list" expects 1 type argument, but 2 given
 class NM(NamedTuple):
@@ -5291,11 +5501,11 @@ reveal_type(x1) # N: Revealed type is "TypedDict('__main__.TD', {'x': builtins.l
 reveal_type(y) # N: Revealed type is "Tuple[builtins.list[Any], fallback=__main__.NM]"
 reveal_type(y1) # N: Revealed type is "Tuple[builtins.list[Any], fallback=__main__.NM]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testCrashInvalidArgsSyntheticFunctionSyntax]
-from typing import List, NewType, NamedTuple
-from mypy_extensions import TypedDict
+from typing import List, NewType, NamedTuple, TypedDict
 TD = TypedDict('TD', {'x': List[int, str]}) # E: "list" expects 1 type argument, but 2 given
 NM = NamedTuple('NM', [('x', List[int, str])]) # E: "list" expects 1 type argument, but 2 given
 NT = NewType('NT', List[int, str]) # E: "list" expects 1 type argument, but 2 given
@@ -5305,11 +5515,11 @@ TD({'x': []})
 NM(x=[])
 NT([])
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testCrashForwardSyntheticClassSyntax]
-from typing import NamedTuple
-from mypy_extensions import TypedDict
+from typing import NamedTuple, TypedDict
 class A1(NamedTuple):
     b: 'B'
     x: int
@@ -5323,11 +5533,11 @@ y: A2
 reveal_type(x.b) # N: Revealed type is "__main__.B"
 reveal_type(y['b']) # N: Revealed type is "__main__.B"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testCrashForwardSyntheticFunctionSyntax]
-from typing import NamedTuple
-from mypy_extensions import TypedDict
+from typing import NamedTuple, TypedDict
 A1 = NamedTuple('A1', [('b', 'B'), ('x', int)])
 A2 = TypedDict('A2', {'b': 'B', 'x': int})
 class B:
@@ -5337,6 +5547,7 @@ y: A2
 reveal_type(x.b) # N: Revealed type is "__main__.B"
 reveal_type(y['b']) # N: Revealed type is "__main__.B"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 -- Special support for six
@@ -5916,8 +6127,8 @@ A = G
 x: A[B[int]] # E
 B = G
 [out]
-main:8:4: error: Type argument "G[int]" of "G" must be a subtype of "str"
-main:8:6: error: Type argument "int" of "G" must be a subtype of "str"
+main:8:6: error: Type argument "G[int]" of "G" must be a subtype of "str"
+main:8:8: error: Type argument "int" of "G" must be a subtype of "str"
 
 [case testExtremeForwardReferencing]
 from typing import TypeVar, Generic
@@ -6440,10 +6651,53 @@ from typing import TypeVar, Tuple, Callable
 T = TypeVar('T')
 def deco(f: Callable[..., T]) -> Callable[..., Tuple[T, int]]: ...
 [builtins fixtures/tuple.pyi]
-[out]
+
+[case testOverrideWithUntypedNotChecked]
+class Parent:
+    def foo(self, x):
+        ...
+    def bar(self, x):
+        ...
+    def baz(self, x: int) -> str:
+        return ""
+
+class Child(Parent):
+    def foo(self, y):  # OK: names not checked
+        ...
+    def bar(self, x, y):
+        ...
+    def baz(self, x, y):
+        return ""
+[builtins fixtures/tuple.pyi]
+
+[case testOverrideWithUntypedCheckedWithCheckUntypedDefs]
+# flags: --check-untyped-defs
+class Parent:
+    def foo(self, x):
+        ...
+    def bar(self, x):
+        ...
+    def baz(self, x: int) -> str:
+        return ""
+
+class Child(Parent):
+    def foo(self, y):  # OK: names not checked
+        ...
+    def bar(self, x, y) -> None:  # E: Signature of "bar" incompatible with supertype "Parent" \
+                                  # N:      Superclass: \
+                                  # N:          def bar(self, x: Any) -> Any \
+                                  # N:      Subclass: \
+                                  # N:          def bar(self, x: Any, y: Any) -> None
+        ...
+    def baz(self, x, y):  # E: Signature of "baz" incompatible with supertype "Parent" \
+                          # N:      Superclass: \
+                          # N:          def baz(self, x: int) -> str \
+                          # N:      Subclass: \
+                          # N:          def baz(self, x: Any, y: Any) -> Any
+        return ""
+[builtins fixtures/tuple.pyi]
 
 [case testOptionalDescriptorsBinder]
-# flags: --strict-optional
 from typing import Type, TypeVar, Optional
 T = TypeVar('T')
 
@@ -6657,7 +6911,6 @@ class C(Generic[T]):
 [builtins fixtures/isinstancelist.pyi]
 
 [case testIsInstanceTypeSubclass]
-# flags: --strict-optional
 from typing import Type, Optional
 class Base: ...
 class One(Base):
@@ -6796,11 +7049,10 @@ class C:
 [case testAttributeDefOrder2]
 class D(C):
     def g(self) -> None:
-        self.x = ''
+        self.x = ''  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 
     def f(self) -> None:
-        # https://github.com/python/mypy/issues/7162
-        reveal_type(self.x) # N: Revealed type is "builtins.str"
+        reveal_type(self.x) # N: Revealed type is "builtins.int"
 
 
 class C:
@@ -6814,7 +7066,7 @@ class E(C):
     def f(self) -> None:
         reveal_type(self.x) # N: Revealed type is "builtins.int"
 
-[targets __main__, __main__, __main__.D.g, __main__.D.f, __main__.C.__init__, __main__.E.g, __main__.E.f]
+[targets __main__, __main__, __main__.C.__init__, __main__.D.g, __main__.D.f, __main__.E.g, __main__.E.f]
 
 [case testNewReturnType1]
 class A:
@@ -7684,10 +7936,14 @@ class D:
     def __new__(cls) -> NoReturn: ...
     def __init__(self) -> NoReturn: ...
 
-reveal_type(A())  # N: Revealed type is "<nothing>"
-reveal_type(B())  # N: Revealed type is "<nothing>"
-reveal_type(C())  # N: Revealed type is "<nothing>"
-reveal_type(D())  # N: Revealed type is "<nothing>"
+if object():
+    reveal_type(A())  # N: Revealed type is "Never"
+if object():
+    reveal_type(B())  # N: Revealed type is "Never"
+if object():
+    reveal_type(C())  # N: Revealed type is "Never"
+if object():
+    reveal_type(D())  # N: Revealed type is "Never"
 
 [case testOverloadedNewAndInitNoReturn]
 from typing import NoReturn, overload
@@ -7726,13 +7982,20 @@ class D:
     def __init__(self, a: int) -> None: ...
     def __init__(self, a: int = ...) -> None: ...
 
-reveal_type(A())  # N: Revealed type is "<nothing>"
+if object():
+    reveal_type(A())  # N: Revealed type is "Never"
 reveal_type(A(1))  # N: Revealed type is "__main__.A"
-reveal_type(B())  # N: Revealed type is "<nothing>"
+
+if object():
+    reveal_type(B())  # N: Revealed type is "Never"
 reveal_type(B(1))  # N: Revealed type is "__main__.B"
-reveal_type(C())  # N: Revealed type is "<nothing>"
+
+if object():
+    reveal_type(C())  # N: Revealed type is "Never"
 reveal_type(C(1))  # N: Revealed type is "__main__.C"
-reveal_type(D())  # N: Revealed type is "<nothing>"
+
+if object():
+    reveal_type(D())  # N: Revealed type is "Never"
 reveal_type(D(1))  # N: Revealed type is "__main__.D"
 
 [case testClassScopeImportWithWrapperAndError]
@@ -7763,25 +8026,25 @@ class Parent:
 class Child(Parent):
     def foo(self, val: int) -> int:  # E: Signature of "foo" incompatible with supertype "Parent" \
                                      # N:      Superclass: \
-                                     # N:          None \
+                                     # N:          <typing special form> \
                                      # N:      Subclass: \
                                      # N:          def foo(self, val: int) -> int
         return val
     def bar(self, val: str) -> str:  # E: Signature of "bar" incompatible with supertype "Parent" \
                                      # N:      Superclass: \
-                                     # N:          None \
+                                     # N:          def __init__(self) -> bar \
                                      # N:      Subclass: \
                                      # N:          def bar(self, val: str) -> str
         return val
     def baz(self, val: float) -> float:  # E: Signature of "baz" incompatible with supertype "Parent" \
                                          # N:      Superclass: \
-                                         # N:          None \
+                                         # N:          Module \
                                          # N:      Subclass: \
                                          # N:          def baz(self, val: float) -> float
         return val
     def foobar(self) -> bool:  # E: Signature of "foobar" incompatible with supertype "Parent" \
                                # N:      Superclass: \
-                               # N:          None \
+                               # N:          TypeVar \
                                # N:      Subclass: \
                                # N:          def foobar(self) -> bool
         return False
@@ -7794,6 +8057,8 @@ a: int = child.foo(1)
 b: str = child.bar("abc")
 c: float = child.baz(3.4)
 d: bool = child.foobar()
+[builtins fixtures/module.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testGenericTupleTypeCreation]
 from typing import Generic, Tuple, TypeVar
@@ -7845,6 +8110,217 @@ class Bar(Foo):
     def x(self, value: int) -> None: ...
 [builtins fixtures/property.pyi]
 
+[case testOverridePropertyDifferentSetterBoth]
+class B: ...
+class C(B): ...
+
+class B1:
+    @property
+    def foo(self) -> str: ...
+    @foo.setter
+    def foo(self, x: C) -> None: ...
+class C1(B1):
+    @property
+    def foo(self) -> str: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+
+class B2:
+    @property
+    def foo(self) -> str: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+class C2(B2):
+    @property
+    def foo(self) -> str: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B2" defined the type as "B", \
+                 # N:  override has type "C") \
+                 # N:  Setter types should behave contravariantly
+    def foo(self, x: C) -> None: ...
+
+class B3:
+    @property
+    def foo(self) -> C: ...
+    @foo.setter
+    def foo(self, x: C) -> None: ...
+class C3(B3):
+    @property
+    def foo(self) -> C: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+
+class B4:
+    @property
+    def foo(self) -> C: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+class C4(B4):
+    @property
+    def foo(self) -> C: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B4" defined the type as "B", \
+                 # N:  override has type "C") \
+                 # N:  Setter types should behave contravariantly
+    def foo(self, x: C) -> None: ...
+
+class B5:
+    @property
+    def foo(self) -> str: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+class C5(B5):
+    @property  # E: Signature of "foo" incompatible with supertype "B5" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          C
+    def foo(self) -> C: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B5" defined the type as "B", \
+                 # N:  override has type "str")
+    def foo(self, x: str) -> None: ...
+
+class B6:
+    @property
+    def foo(self) -> B: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+class C6(B6):
+    @property
+    def foo(self) -> C: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+[builtins fixtures/property.pyi]
+
+[case testOverridePropertyDifferentSetterVarSuper]
+class B: ...
+class C(B): ...
+
+class B1:
+    foo: B
+class C1(B1):
+    @property
+    def foo(self) -> B: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B1" defined the type as "B", \
+                 # N:  override has type "C") \
+                 # N:  Setter types should behave contravariantly
+    def foo(self, x: C) -> None: ...
+
+class B2:
+    foo: C
+class C2(B2):
+    @property
+    def foo(self) -> C: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+
+class B3:
+    foo: B
+class C3(B3):
+    @property
+    def foo(self) -> C: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+[builtins fixtures/property.pyi]
+
+[case testOverridePropertyDifferentSetterVarSub]
+class B: ...
+class C(B): ...
+
+class B1:
+    @property
+    def foo(self) -> B: ...
+    @foo.setter
+    def foo(self, x: C) -> None: ...
+class C1(B1):
+    foo: C
+
+class B2:
+    @property
+    def foo(self) -> B: ...
+    @foo.setter
+    def foo(self, x: C) -> None: ...
+class C2(B2):
+    foo: B
+
+class B3:
+    @property
+    def foo(self) -> C: ...
+    @foo.setter
+    def foo(self, x: B) -> None: ...
+class C3(B3):
+    foo: C  # E: Incompatible override of a setter type \
+            # N:  (base class "B3" defined the type as "B", \
+            # N:  override has type "C") \
+            # N:  Setter types should behave contravariantly
+[builtins fixtures/property.pyi]
+
+[case testOverridePropertyInvalidSetter]
+class B1:
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+class C1(B1):
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self) -> None: ...  # E: Invalid property setter signature
+
+class B2:
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self) -> None: ...  # E: Invalid property setter signature
+class C2(B2):
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+
+class B3:
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self) -> None: ...  # E: Invalid property setter signature
+class C3(B3):
+    foo: int
+[builtins fixtures/property.pyi]
+
+[case testOverridePropertyGeneric]
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+class B1(Generic[T]):
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self, x: T) -> None: ...
+class C1(B1[str]):
+    @property
+    def foo(self) -> int: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B1" defined the type as "str", \
+                 # N:  override has type "int")
+    def foo(self, x: int) -> None: ...
+
+class B2:
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self: T, x: T) -> None: ...
+class C2(B2):
+    @property
+    def foo(self) -> int: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B2" defined the type as "C2", \
+                 # N:  override has type "int")
+    def foo(self, x: int) -> None: ...
+[builtins fixtures/property.pyi]
+
 [case testOverrideMethodProperty]
 class B:
     def foo(self) -> int:
@@ -7957,3 +8433,296 @@ f5(1)  # E: Argument 1 to "f5" has incompatible type "int"; expected "Integral"
        # N: Types from "numbers" aren't supported for static type checking \
        # N: See https://peps.python.org/pep-0484/#the-numeric-tower \
        # N: Consider using a protocol instead, such as typing.SupportsFloat
+
+[case testImplicitClassScopedNames]
+class C:
+    reveal_type(__module__)  # N: Revealed type is "builtins.str"
+    reveal_type(__qualname__)  # N: Revealed type is "builtins.str"
+    def f(self) -> None:
+        __module__  # E: Name "__module__" is not defined
+        __qualname__  # E: Name "__qualname__" is not defined
+
+[case testPropertySetterType]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: str) -> None:
+        pass
+a = A()
+a.f = ''  # OK
+reveal_type(a.f)  # N: Revealed type is "builtins.int"
+a.f = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+reveal_type(a.f)  # N: Revealed type is "builtins.int"
+[builtins fixtures/property.pyi]
+
+[case testPropertySetterTypeGeneric]
+from typing import TypeVar, Generic, List
+
+T = TypeVar("T")
+
+class B(Generic[T]):
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self, x: T) -> None: ...
+
+class C(B[List[T]]): ...
+
+a = C[str]()
+a.foo = ["foo", "bar"]
+reveal_type(a.foo)  # N: Revealed type is "builtins.int"
+a.foo = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "List[str]")
+reveal_type(a.foo)  # N: Revealed type is "builtins.int"
+[builtins fixtures/property.pyi]
+
+[case testPropertyDeleterNoSetterOK]
+class C:
+    @property
+    def x(self) -> int:
+        return 0
+    @x.deleter
+    def x(self) -> None:
+        pass
+[builtins fixtures/property.pyi]
+
+[case testPropertySetterSuperclassDeferred]
+from typing import Callable, TypeVar
+
+class B:
+    def __init__(self) -> None:
+        self.foo = f()
+
+class C(B):
+    @property
+    def foo(self) -> str: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B" defined the type as "str", \
+                 # N:  override has type "int")
+    def foo(self, x: int) -> None: ...
+
+T = TypeVar("T")
+def deco(fn: Callable[[], list[T]]) -> Callable[[], T]: ...
+
+@deco
+def f() -> list[str]: ...
+[builtins fixtures/property.pyi]
+
+[case testPropertySetterSuperclassDeferred2]
+import a
+[file a.py]
+import b
+class D(b.C):
+    @property
+    def foo(self) -> str: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "C" defined the type as "str", \
+                 # N:  override has type "int")
+    def foo(self, x: int) -> None: ...
+[file b.py]
+from a import D
+class C:
+    @property
+    def foo(self) -> str: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+[builtins fixtures/property.pyi]
+
+[case testPropertySetterDecorated]
+from typing import Callable, TypeVar, Generic
+
+class B:
+    def __init__(self) -> None:
+        self.foo: str
+        self.bar: int
+
+class C(B):
+    @property
+    def foo(self) -> str: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B" defined the type as "str", \
+                 # N:  override has type "int")
+    @deco
+    def foo(self, x: int, y: int) -> None: ...
+
+    @property
+    def bar(self) -> int: ...
+    @bar.setter
+    @deco
+    def bar(self, x: int, y: int) -> None: ...
+
+    @property
+    def baz(self) -> int: ...
+    @baz.setter
+    @deco_untyped
+    def baz(self, x: int) -> None: ...
+
+    @property
+    def tricky(self) -> int: ...
+    @tricky.setter
+    @deco_instance
+    def tricky(self, x: int) -> None: ...
+
+c: C
+c.baz = "yes"  # OK, because of untyped decorator
+c.tricky = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "List[int]")
+
+T = TypeVar("T")
+def deco(fn: Callable[[T, int, int], None]) -> Callable[[T, int], None]: ...
+def deco_untyped(fn): ...
+
+class Wrapper(Generic[T]):
+    def __call__(self, s: T, x: list[int]) -> None: ...
+def deco_instance(fn: Callable[[T, int], None]) -> Wrapper[T]: ...
+[builtins fixtures/property.pyi]
+
+[case testPropertyDeleterBodyChecked]
+class C:
+    @property
+    def foo(self) -> int: ...
+    @foo.deleter
+    def foo(self) -> None:
+        1()  # E: "int" not callable
+
+    @property
+    def bar(self) -> int: ...
+    @bar.setter
+    def bar(self, x: str) -> None: ...
+    @bar.deleter
+    def bar(self) -> None:
+        1()  # E: "int" not callable
+[builtins fixtures/property.pyi]
+
+[case testSettablePropertyGetterDecorated]
+from typing import Callable, TypeVar, Generic
+
+class C:
+    @property
+    @deco
+    def foo(self, ok: int) -> str: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+
+    @property
+    @deco_instance
+    def bar(self, ok: int) -> int: ...
+    @bar.setter
+    def bar(self, x: int) -> None: ...
+
+    @property
+    @deco_untyped
+    def baz(self) -> int: ...
+    @baz.setter
+    def baz(self, x: int) -> None: ...
+
+c: C
+reveal_type(c.foo)  # N: Revealed type is "builtins.list[builtins.str]"
+reveal_type(c.bar)  # N: Revealed type is "builtins.list[builtins.int]"
+reveal_type(c.baz)  # N: Revealed type is "Any"
+
+T = TypeVar("T")
+R = TypeVar("R")
+def deco(fn: Callable[[T, int], R]) -> Callable[[T], list[R]]: ...
+def deco_untyped(fn): ...
+
+class Wrapper(Generic[T, R]):
+    def __call__(self, s: T) -> list[R]: ...
+def deco_instance(fn: Callable[[T, int], R]) -> Wrapper[T, R]: ...
+[builtins fixtures/property.pyi]
+
+[case testOverridePropertyWithDescriptor]
+from typing import Any
+
+class StrProperty:
+    def __get__(self, instance: Any, owner: Any) -> str: ...
+
+class Base:
+    @property
+    def id(self) -> str: ...
+
+class BadBase:
+    @property
+    def id(self) -> int: ...
+
+class Derived(Base):
+    id = StrProperty()
+
+class BadDerived(BadBase):
+    id = StrProperty()  # E: Incompatible types in assignment (expression has type "str", base class "BadBase" defined the type as "int")
+[builtins fixtures/property.pyi]
+
+[case testLambdaInOverrideInference]
+class B:
+    def f(self, x: int) -> int: ...
+class C(B):
+    f = lambda s, x: x
+
+reveal_type(C().f)  # N: Revealed type is "def (x: builtins.int) -> builtins.int"
+
+[case testGenericDecoratorInOverrideInference]
+from typing import Any, Callable, TypeVar
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+T = TypeVar("T")
+def wrap(f: Callable[Concatenate[Any, P], T]) -> Callable[Concatenate[Any, P], T]: ...
+
+class Base:
+    def g(self, a: int) -> int:
+        return a + 1
+
+class Derived(Base):
+    def _g(self, a: int) -> int:
+        return a + 2
+    g = wrap(_g)
+
+reveal_type(Derived().g)  # N: Revealed type is "def (a: builtins.int) -> builtins.int"
+[builtins fixtures/paramspec.pyi]
+
+[case testClassVarOverrideWithSubclass]
+class A: ...
+class B(A): ...
+class AA:
+    cls = A
+class BB(AA):
+    cls = B
+
+[case testSelfReferenceWithinMethodFunction]
+class B:
+    x: str
+class C(B):
+    def meth(self) -> None:
+        def cb() -> None:
+            self.x: int = 1  # E: Incompatible types in assignment (expression has type "int", base class "B" defined the type as "str")
+
+[case testOverloadedDescriptorSelected]
+from typing import Generic, TypeVar, Any, overload
+
+T_co = TypeVar("T_co", covariant=True)
+class Field(Generic[T_co]):
+    @overload
+    def __get__(self: Field[bool], instance: None, owner: Any) -> BoolField: ...
+    @overload
+    def __get__(self: Field[int], instance: None, owner: Any) -> NumField: ...
+    @overload
+    def __get__(self: Field[Any], instance: None, owner: Any) -> AnyField[T_co]: ...
+    @overload
+    def __get__(self, instance: Any, owner: Any) -> T_co: ...
+
+    def __get__(self, instance: Any, owner: Any) -> Any:
+        pass
+
+class BoolField(Field[bool]): ...
+class NumField(Field[int]): ...
+class AnyField(Field[T_co]): ...
+class Custom: ...
+
+class Fields:
+    bool_f: Field[bool]
+    int_f: Field[int]
+    custom_f: Field[Custom]
+
+reveal_type(Fields.bool_f)  # N: Revealed type is "__main__.BoolField"
+reveal_type(Fields.int_f)  # N: Revealed type is "__main__.NumField"
+reveal_type(Fields.custom_f)  # N: Revealed type is "__main__.AnyField[__main__.Custom]"
diff --git a/test-data/unit/check-classvar.test b/test-data/unit/check-classvar.test
index 1e87e441dea2..63bbd7471bc8 100644
--- a/test-data/unit/check-classvar.test
+++ b/test-data/unit/check-classvar.test
@@ -200,7 +200,7 @@ f().x = 0
 [out]
 main:6: error: Cannot assign to class variable "x" via instance
 
-[case testOverrideWithIncomatibleType]
+[case testOverrideWithIncompatibleType]
 from typing import ClassVar
 class A:
     x = None  # type: ClassVar[int]
@@ -334,3 +334,12 @@ class C:
 c:C
 c.foo()  # E: Too few arguments \
          # N: "foo" is considered instance variable, to make it class variable use ClassVar[...]
+
+[case testClassVarUnionBoundOnInstance]
+from typing import Union, Callable, ClassVar
+
+class C:
+    def f(self) -> int: ...
+    g: ClassVar[Union[Callable[[C], int], int]] = f
+
+reveal_type(C().g)  # N: Revealed type is "Union[def () -> builtins.int, builtins.int]"
diff --git a/test-data/unit/check-columns.test b/test-data/unit/check-columns.test
index 7d1114ceab7a..8f91d99a0576 100644
--- a/test-data/unit/check-columns.test
+++ b/test-data/unit/check-columns.test
@@ -27,7 +27,6 @@ A().f(1, 1) # E:10: Argument 2 to "f" of "A" has incompatible type "int"; expect
 (A().f(1, 'hello', 'hi')) # E:2: Too many arguments for "f" of "A"
 
 [case testColumnsInvalidArgumentType]
-# flags: --strict-optional
 def f(x: int, y: str) -> None: ...
 def g(*x: int) -> None: pass
 def h(**x: int) -> None: pass
@@ -211,6 +210,7 @@ y: Dict[int, int] = {
 [builtins fixtures/dict.pyi]
 
 [case testColumnCannotDetermineType]
+# flags: --no-local-partial-types
 (x)  # E:2: Cannot determine type of "x"  # E:2: Name "x" is used before definition
 x = None
 
@@ -228,9 +228,19 @@ class D(TypedDict):
     x: int
 t: D = {'x':
     'y'} # E:5: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
+s: str
 
 if int():
-    del t['y'] # E:5: TypedDict "D" has no key "y"
+    del t[s]    # E:11: Expected TypedDict key to be string literal
+    del t["x"]  # E:11: Key "x" of TypedDict "D" cannot be deleted
+    del t["y"]  # E:11: TypedDict "D" has no key "y"
+
+t.pop(s)    # E:7: Expected TypedDict key to be string literal
+t.pop("y")  # E:7: TypedDict "D" has no key "y"
+
+t.setdefault(s, 123)    # E:14: Expected TypedDict key to be string literal
+t.setdefault("x", "a")  # E:19: Argument 2 to "setdefault" of "TypedDict" has incompatible type "str"; expected "int"
+t.setdefault("y", 123)  # E:14: TypedDict "D" has no key "y"
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
@@ -251,7 +261,7 @@ class D(A):
                               # N:5:          def f(self) -> None
 
 [case testColumnMissingTypeParameters]
-# flags: --disallow-any-generics
+# flags: --python-version 3.8 --disallow-any-generics
 from typing import List, Callable
 def f(x: List) -> None: pass # E:10: Missing type parameters for generic type "List"
 def g(x: list) -> None: pass # E:10: Implicit generic "Any". Use "typing.List" and specify generic parameters
@@ -311,9 +321,18 @@ T = TypeVar('T', int, str)
 class C(Generic[T]):
     pass
 
-def f(c: C[object]) -> None: pass # E:10: Value of type variable "T" of "C" cannot be "object"
+def f(c: C[object]) -> None: pass # E:12: Value of type variable "T" of "C" cannot be "object"
 (C[object]()) # E:2: Value of type variable "T" of "C" cannot be "object"
 
+[case testColumnInvalidLocationForParamSpec]
+from typing import List
+from typing_extensions import ParamSpec
+
+P = ParamSpec('P')
+def foo(x: List[P]): pass  # E:17: Invalid location for ParamSpec "P" \
+                           # N:17: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"
+[builtins fixtures/list.pyi]
+
 [case testColumnSyntaxErrorInTypeAnnotation]
 if int():
     def f(x # type: int,
@@ -386,10 +405,20 @@ 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
+
+[case testEndColumnsWithTooManyTypeVars]
+# flags: --pretty
+import typing
+
+x1: typing.List[typing.List[int, int]]
+x2: list[list[int, int]]
+[out]
+main:4:17: error: "list" expects 1 type argument, but 2 given
+    x1: typing.List[typing.List[int, int]]
+                    ^~~~~~~~~~~~~~~~~~~~~
+main:5:10: error: "list" expects 1 type argument, but 2 given
+    x2: list[list[int, int]]
+             ^~~~~~~~~~~~~~
diff --git a/test-data/unit/check-ctypes.test b/test-data/unit/check-ctypes.test
index 1eefdd3c66c1..1e58ebc77d0f 100644
--- a/test-data/unit/check-ctypes.test
+++ b/test-data/unit/check-ctypes.test
@@ -138,6 +138,7 @@ cua.raw  # E: Array attribute "raw" is only available with element type "c_char"
 
 [case testCtypesAnyArrayAttrs]
 import ctypes
+from typing import Any
 
 aa: ctypes.Array[Any]
 reveal_type(aa.value)  # N: Revealed type is "Any"
diff --git a/test-data/unit/check-custom-plugin.test b/test-data/unit/check-custom-plugin.test
index c81de675d808..72b60c874656 100644
--- a/test-data/unit/check-custom-plugin.test
+++ b/test-data/unit/check-custom-plugin.test
@@ -232,6 +232,8 @@ reveal_type(magic.non_magic_method())  # N: Revealed type is "builtins.int"
 reveal_type(magic.non_magic_field)  # N: Revealed type is "builtins.int"
 magic.nonexistent_field  # E: Field does not exist
 reveal_type(magic.fallback_example)  # N: Revealed type is "Any"
+reveal_type(magic.no_assignment_field)  # N: Revealed type is "builtins.float"
+magic.no_assignment_field = "bad"  # E: Cannot assign to field
 
 derived = DerivedMagic()
 reveal_type(derived.magic_field)  # N: Revealed type is "builtins.str"
@@ -250,6 +252,7 @@ class Magic:
     def __getattr__(self, x: Any) -> Any: ...
     def non_magic_method(self) -> int: ...
     non_magic_field: int
+    no_assignment_field: float
 
 class DerivedMagic(Magic): ...
 [file mypy.ini]
@@ -576,8 +579,7 @@ plugins=<ROOT>/test-data/unit/plugins/method_sig_hook.py
 
 [case testMethodSignatureHookNamesFullyQualified]
 # flags: --config-file tmp/mypy.ini
-from mypy_extensions import TypedDict
-from typing import NamedTuple
+from typing import NamedTuple, TypedDict
 
 class FullyQualifiedTestClass:
     @classmethod
@@ -598,6 +600,7 @@ reveal_type(FullyQualifiedTestNamedTuple('')._asdict()) # N: Revealed type is "b
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/fully_qualified_test_hook.py
 [builtins fixtures/classmethod.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testDynamicClassPlugin]
 # flags: --config-file tmp/mypy.ini
@@ -684,12 +687,16 @@ plugins=<ROOT>/test-data/unit/plugins/dyn_class.py
 [case testDynamicClassHookFromClassMethod]
 # flags: --config-file tmp/mypy.ini
 
-from mod import QuerySet, Manager
+from mod import QuerySet, Manager, GenericQuerySet
 
 MyManager = Manager.from_queryset(QuerySet)
+ManagerFromGenericQuerySet = GenericQuerySet[int].as_manager()
 
 reveal_type(MyManager())  # N: Revealed type is "__main__.MyManager"
 reveal_type(MyManager().attr)  # N: Revealed type is "builtins.str"
+reveal_type(ManagerFromGenericQuerySet())  # N: Revealed type is "__main__.ManagerFromGenericQuerySet"
+reveal_type(ManagerFromGenericQuerySet().attr)  # N: Revealed type is "builtins.int"
+queryset: GenericQuerySet[int] = ManagerFromGenericQuerySet()
 
 def func(manager: MyManager) -> None:
     reveal_type(manager)   # N: Revealed type is "__main__.MyManager"
@@ -704,6 +711,12 @@ class QuerySet:
 class Manager:
     @classmethod
     def from_queryset(cls, queryset_cls: Type[QuerySet]): ...
+T = TypeVar("T")
+class GenericQuerySet(Generic[T]):
+    attr: T
+
+    @classmethod
+    def as_manager(cls): ...
 
 [builtins fixtures/classmethod.pyi]
 [file mypy.ini]
@@ -802,7 +815,7 @@ else:
 plugins=<ROOT>/test-data/unit/plugins/union_method.py
 
 [case testGetMethodHooksOnUnionsStrictOptional]
-# flags: --config-file tmp/mypy.ini --strict-optional
+# flags: --config-file tmp/mypy.ini
 from typing import Union
 
 class Foo:
@@ -887,7 +900,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
@@ -951,6 +967,7 @@ class Cls(enum.Enum):
     attr = 'test'
 
 reveal_type(Cls.attr)  # N: Revealed type is "builtins.int"
+[builtins fixtures/enum.pyi]
 [file mypy.ini]
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/class_attr_hook.py
@@ -990,7 +1007,7 @@ reveal_type(Cls.attr) # N: Revealed type is "builtins.int"
 plugins=<ROOT>/test-data/unit/plugins/class_attr_hook.py
 
 [case testClassAttrPluginPartialType]
-# flags: --config-file tmp/mypy.ini
+# flags: --config-file tmp/mypy.ini --no-local-partial-types
 
 class Cls:
     attr = None
@@ -1008,13 +1025,68 @@ class BaseAddMethod: pass
 class MyClass(BaseAddMethod):
     pass
 
-my_class = MyClass()
 reveal_type(MyClass.foo_classmethod)  # N: Revealed type is "def ()"
 reveal_type(MyClass.foo_staticmethod)  # N: Revealed type is "def (builtins.int) -> builtins.str"
+
+my_class = MyClass()
+reveal_type(my_class.foo_classmethod)  # N: Revealed type is "def ()"
+reveal_type(my_class.foo_staticmethod)  # N: Revealed type is "def (builtins.int) -> builtins.str"
 [file mypy.ini]
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/add_classmethod.py
 
+[case testAddOverloadedMethodPlugin]
+# flags: --config-file tmp/mypy.ini
+class AddOverloadedMethod: pass
+
+class MyClass(AddOverloadedMethod):
+    pass
+
+reveal_type(MyClass.method)  # N: Revealed type is "Overload(def (self: __main__.MyClass, arg: builtins.int) -> builtins.str, def (self: __main__.MyClass, arg: builtins.str) -> builtins.int)"
+reveal_type(MyClass.clsmethod)  # N: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+reveal_type(MyClass.stmethod)  # N: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+
+my_class = MyClass()
+reveal_type(my_class.method)  # N: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+reveal_type(my_class.clsmethod)  # N: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+reveal_type(my_class.stmethod)  # N: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+[file mypy.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/add_overloaded_method.py
+
+[case testAddMethodPluginExplicitOverride]
+# flags: --python-version 3.12 --config-file tmp/mypy.ini
+from typing import override, TypeVar
+
+T = TypeVar('T', bound=type)
+
+def inject_foo(t: T) -> T:
+    # Imitates:
+    # t.foo_implicit = some_method
+    return t
+
+class BaseWithoutFoo: pass
+
+@inject_foo
+class ChildWithFoo(BaseWithoutFoo): pass
+reveal_type(ChildWithFoo.foo_implicit)  # N: Revealed type is "def (self: __main__.ChildWithFoo)"
+
+@inject_foo
+class SomeWithFoo(ChildWithFoo): pass
+reveal_type(SomeWithFoo.foo_implicit)  # N: Revealed type is "def (self: __main__.SomeWithFoo)"
+
+class ExplicitOverride(SomeWithFoo):
+    @override
+    def foo_implicit(self) -> None: pass
+
+class ImplicitOverride(SomeWithFoo):
+    def foo_implicit(self) -> None: pass  # E: Method "foo_implicit" is not using @override but is overriding a method in class "__main__.SomeWithFoo"
+[file mypy.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/add_method.py
+enable_error_code = explicit-override
+[typing fixtures/typing-override.pyi]
+
 [case testCustomErrorCodePlugin]
 # flags: --config-file tmp/mypy.ini  --show-error-codes
 def main() -> int:
@@ -1026,3 +1098,31 @@ reveal_type(1)  # N: Revealed type is "Literal[1]?"
 [file mypy.ini]
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/custom_errorcode.py
+
+
+[case testPyprojectPluginsTrailingComma]
+# flags: --config-file tmp/pyproject.toml
+[file pyproject.toml]
+# This test checks that trailing commas in string-based `plugins` are allowed.
+\[tool.mypy]
+plugins = """
+  <ROOT>/test-data/unit/plugins/function_sig_hook.py,
+  <ROOT>/test-data/unit/plugins/method_in_decorator.py,
+"""
+[out]
+
+
+
+[case magicMethodReverse]
+# flags: --config-file tmp/mypy.ini
+from typing import Literal
+
+op1: Literal[3] = 3
+op2: Literal[4] = 4
+c = op1 + op2
+reveal_type(c) # N: Revealed type is "Literal[7]"
+
+[file mypy.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/magic_method.py
+[builtins fixtures/ops.pyi]
diff --git a/test-data/unit/check-dataclass-transform.test b/test-data/unit/check-dataclass-transform.test
index be6b46d70846..8213f8df282a 100644
--- a/test-data/unit/check-dataclass-transform.test
+++ b/test-data/unit/check-dataclass-transform.test
@@ -22,7 +22,6 @@ Person('Jonh', 21, None)  # E: Too many arguments for "Person"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassTransformIsFoundInTypingExtensions]
-# flags: --python-version 3.7
 from typing import Type
 from typing_extensions import dataclass_transform
 
@@ -119,7 +118,7 @@ from typing import dataclass_transform, Type
 
 BOOLEAN_CONSTANT = True
 
-@dataclass_transform(nonexistant=True) # E: Unrecognized dataclass_transform parameter "nonexistant"
+@dataclass_transform(nonexistent=True) # E: Unrecognized dataclass_transform parameter "nonexistent"
 def foo(cls: Type) -> Type:
     return cls
 
@@ -506,7 +505,7 @@ class FunctionModel:
         integer_: tuple
 
 FunctionModel(string_="abc", integer_=1)
-FunctionModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "FunctionModel" has incompatible type "Tuple[<nothing>, ...]"; expected "int"
+FunctionModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "FunctionModel" has incompatible type "Tuple[Never, ...]"; expected "int"
 
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
@@ -529,7 +528,7 @@ class FunctionModel:
         integer_: int
 
 FunctionModel(string_="abc", integer_=1)
-FunctionModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "FunctionModel" has incompatible type "Tuple[<nothing>, ...]"; expected "int"
+FunctionModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "FunctionModel" has incompatible type "Tuple[Never, ...]"; expected "int"
 
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
@@ -552,7 +551,7 @@ class BaseClassModel(ModelBase):
         integer_: tuple
 
 BaseClassModel(string_="abc", integer_=1)
-BaseClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "BaseClassModel" has incompatible type "Tuple[<nothing>, ...]"; expected "int"
+BaseClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "BaseClassModel" has incompatible type "Tuple[Never, ...]"; expected "int"
 
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
@@ -574,7 +573,7 @@ class BaseClassModel(ModelBase):
         integer_: int
 
 BaseClassModel(string_="abc", integer_=1)
-BaseClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "BaseClassModel" has incompatible type "Tuple[<nothing>, ...]"; expected "int"
+BaseClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "BaseClassModel" has incompatible type "Tuple[Never, ...]"; expected "int"
 
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
@@ -599,7 +598,7 @@ class MetaClassModel(ModelBaseWithMeta):
         integer_: tuple
 
 MetaClassModel(string_="abc", integer_=1)
-MetaClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "MetaClassModel" has incompatible type "Tuple[<nothing>, ...]"; expected "int"
+MetaClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "MetaClassModel" has incompatible type "Tuple[Never, ...]"; expected "int"
 
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
@@ -624,7 +623,7 @@ class MetaClassModel(ModelBaseWithMeta):
         integer_: int
 
 MetaClassModel(string_="abc", integer_=1)
-MetaClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "MetaClassModel" has incompatible type "Tuple[<nothing>, ...]"; expected "int"
+MetaClassModel(string_="abc", integer_=tuple())  # E: Argument "integer_" to "MetaClassModel" has incompatible type "Tuple[Never, ...]"; expected "int"
 
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
@@ -840,6 +839,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')
+
+[typing fixtures/typing-full.pyi]
+[builtins fixtures/dataclasses.pyi]
+
 [case testDataclassTransformSimpleDescriptor]
 # flags: --python-version 3.11
 
@@ -1001,18 +1018,19 @@ class Desc:
     def __get__(self, instance: object, owner: Any) -> str: ...
     def __get__(self, instance, owner): ...
 
-    def __set__(self, instance: Any, value: bytes) -> None: ...
+    def __set__(self, instance: Any, value: bytes | None) -> None: ...
 
 @my_dataclass
 class C:
     x: Desc
 
 c = C(x=b'x')
-C(x=1)  # E: Argument "x" to "C" has incompatible type "int"; expected "bytes"
+c = C(x=None)
+C(x=1)  # E: Argument "x" to "C" has incompatible type "int"; expected "Optional[bytes]"
 reveal_type(c.x)  # N: Revealed type is "builtins.str"
 reveal_type(C.x)  # N: Revealed type is "builtins.int"
 c.x = b'x'
-c.x = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "bytes")
+c.x = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "Optional[bytes]")
 
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
@@ -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 914e1c2e0602..dbcb4c82072c 100644
--- a/test-data/unit/check-dataclasses.test
+++ b/test-data/unit/check-dataclasses.test
@@ -1,5 +1,4 @@
 [case testDataclassesBasic]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -18,7 +17,6 @@ Person('Jonh', 21, None)  # E: Too many arguments for "Person"
 [typing fixtures/typing-medium.pyi]
 
 [case testDataclassesCustomInit]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -33,7 +31,6 @@ A('1')
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesBasicInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -56,7 +53,6 @@ Person(21, 'Jonh', None)  # E: Too many arguments for "Person"
 [typing fixtures/typing-medium.pyi]
 
 [case testDataclassesDeepInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -83,7 +79,6 @@ reveal_type(D)  # N: Revealed type is "def (a: builtins.int, b: builtins.int, c:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesMultipleInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field, InitVar
 @dataclass
 class A:
@@ -106,7 +101,6 @@ reveal_type(C)  # N: Revealed type is "def (b: builtins.bool, a: builtins.bool)
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesDeepInitVarInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field, InitVar
 @dataclass
 class A:
@@ -135,7 +129,6 @@ reveal_type(D)  # N: Revealed type is "def (b: builtins.bool) -> __main__.D"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesOverriding]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -169,7 +162,6 @@ ExtraSpecialPerson(21, 'John', 0.5)
 
 [case testDataclassesOverridingWithDefaults]
 # Issue #5681 https://github.com/python/mypy/issues/5681
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Any
 
@@ -188,7 +180,6 @@ reveal_type(C)  # N: Revealed type is "def (some_int: builtins.int, some_str: bu
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassIncompatibleOverrides]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -217,7 +208,6 @@ class BadDerived3(Base):
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassMultipleInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 class Unrelated:
@@ -237,7 +227,6 @@ reveal_type(d.bar)  # N: Revealed type is "builtins.int"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassIncompatibleFrozenOverride]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass(frozen=True)
@@ -252,7 +241,6 @@ class BadDerived(Base):
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesFreezing]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass(frozen=True)
@@ -265,7 +253,6 @@ john.name = 'Ben'  # E: Property "name" defined in "Person" is read-only
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesInconsistentFreezing]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass(frozen=True)
@@ -273,7 +260,7 @@ class FrozenBase:
     pass
 
 @dataclass
-class BadNormalDerived(FrozenBase):  # E: Cannot inherit non-frozen dataclass from a frozen one
+class BadNormalDerived(FrozenBase):  # E: Non-frozen dataclass cannot inherit from a frozen dataclass
     pass
 
 @dataclass
@@ -281,13 +268,12 @@ class NormalBase:
     pass
 
 @dataclass(frozen=True)
-class BadFrozenDerived(NormalBase):  # E: Cannot inherit frozen dataclass from a non-frozen one
+class BadFrozenDerived(NormalBase):  # E: Frozen dataclass cannot inherit from a non-frozen dataclass
     pass
 
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesFields]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
 
 @dataclass
@@ -303,7 +289,6 @@ john.age = 24
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesBadInit]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
 
 @dataclass
@@ -318,7 +303,6 @@ class Person:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesMultiInit]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
 from typing import List
 
@@ -334,7 +318,6 @@ reveal_type(Person)  # N: Revealed type is "def (name: builtins.str, friend_name
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesMultiInitDefaults]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
 from typing import List, Optional
 
@@ -351,7 +334,6 @@ reveal_type(Person)  # N: Revealed type is "def (name: builtins.str, friend_name
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesDefaults]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -365,7 +347,6 @@ app = Application()
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesDefaultFactories]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
 
 @dataclass
@@ -377,7 +358,6 @@ class Application:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesDefaultFactoryTypeChecking]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
 
 @dataclass
@@ -388,7 +368,6 @@ class Application:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesDefaultOrdering]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -533,7 +512,6 @@ class Base:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesClassmethods]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -549,7 +527,6 @@ app = Application.parse('')
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesOverloadsAndClassmethods]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import overload, Union
 
@@ -582,20 +559,18 @@ reveal_type(A.foo("foo"))  # N: Revealed type is "builtins.str"
 [builtins fixtures/dataclasses.pyi]
 
 [case testClassmethodShadowingFieldDoesNotCrash]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 # This used to crash -- see #6217
 @dataclass
 class Foo:
     bar: str
-    @classmethod  # E: Name "bar" already defined on line 7
+    @classmethod  # E: Name "bar" already defined on line 6
     def bar(cls) -> "Foo":
         return cls('asdf')
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesClassVars]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import ClassVar
 
@@ -613,7 +588,6 @@ Application.COUNTER = 1
 [builtins fixtures/dataclasses.pyi]
 
 [case testTypeAliasInDataclassDoesNotCrash]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Callable
 from typing_extensions import TypeAlias
@@ -642,7 +616,6 @@ reveal_type(x)  # N: Revealed type is "typing._SpecialForm"
 [typing fixtures/typing-medium.pyi]
 
 [case testDataclassOrdering]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass(order=True)
@@ -673,7 +646,6 @@ app1 >= app3
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassOrderingWithoutEquality]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass(eq=False, order=True)  # E: "eq" must be True if "order" is True
@@ -683,7 +655,6 @@ class Application:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassOrderingWithCustomMethods]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass(order=True)
@@ -694,7 +665,6 @@ class Application:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassDefaultsInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Optional
 
@@ -712,7 +682,6 @@ reveal_type(SpecializedApplication)  # N: Revealed type is "def (id: Union[built
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenerics]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, List, Optional, TypeVar
 
@@ -744,9 +713,19 @@ s: str = a.bar()  # E: Incompatible types in assignment (expression has type "in
 
 [builtins fixtures/dataclasses.pyi]
 
+[case testDataclassGenericCovariant]
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+T_co = TypeVar("T_co", covariant=True)
+
+@dataclass
+class MyDataclass(Generic[T_co]):
+    a: T_co
+
+[builtins fixtures/dataclasses.pyi]
 
 [case testDataclassUntypedGenericInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
@@ -767,7 +746,6 @@ reveal_type(sub.attr)  # N: Revealed type is "Any"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericSubtype]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
@@ -794,7 +772,6 @@ reveal_type(sub_str.attr)  # N: Revealed type is "builtins.str"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
@@ -821,7 +798,6 @@ reveal_type(sub.three)  # N: Revealed type is "builtins.float"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassMultiGenericInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
@@ -849,7 +825,6 @@ reveal_type(sub.middle_attr)  # N: Revealed type is "builtins.str"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericsClassmethod]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
@@ -871,7 +846,6 @@ reveal_type(A(0).other)  # N: Revealed type is "def (x: builtins.int) -> __main_
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesForwardRefs]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -890,7 +864,6 @@ A(b=42)  # E: Argument "b" to "A" has incompatible type "int"; expected "B"
 
 
 [case testDataclassesInitVars]
-# flags: --python-version 3.7
 from dataclasses import InitVar, dataclass
 
 @dataclass
@@ -919,7 +892,6 @@ app.database_name  # E: "SpecializedApplication" has no attribute "database_name
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesInitVarsAndDefer]
-# flags: --python-version 3.7
 from dataclasses import InitVar, dataclass
 
 defer: Yes
@@ -939,7 +911,6 @@ class Yes: ...
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesNoInitInitVarInheritance]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field, InitVar
 
 @dataclass
@@ -956,7 +927,6 @@ sub.bar
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassFactory]
-# flags: --python-version 3.7
 from typing import Type, TypeVar
 from dataclasses import dataclass
 
@@ -972,7 +942,6 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesInitVarOverride]
-# flags: --python-version 3.7
 import dataclasses
 
 @dataclasses.dataclass
@@ -995,7 +964,6 @@ class B(A):
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesInitVarNoOverride]
-# flags: --python-version 3.7
 import dataclasses
 
 @dataclasses.dataclass
@@ -1021,7 +989,6 @@ B(1, 'a') # E: Argument 2 to "B" has incompatible type "str"; expected "int"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesInitVarPostInitOverride]
-# flags: --python-version 3.7
 import dataclasses
 
 @dataclasses.dataclass
@@ -1057,7 +1024,6 @@ C(1, 'a')  # E: Argument 2 to "C" has incompatible type "str"; expected "int"
 [builtins fixtures/primitives.pyi]
 
 [case testDataclassesInitVarIncremental]
-# flags: --python-version 3.7
 import a
 
 [file a.py]
@@ -1103,7 +1069,6 @@ tmp/a.py:12: note: Revealed type is "def (a: builtins.int) -> a.B"
 
 
 [case testNoComplainFieldNone]
-# flags: --python-version 3.7
 # flags: --no-strict-optional
 from dataclasses import dataclass, field
 from typing import Optional
@@ -1115,8 +1080,6 @@ class Foo:
 [out]
 
 [case testNoComplainFieldNoneStrict]
-# flags: --python-version 3.7
-# flags: --strict-optional
 from dataclasses import dataclass, field
 from typing import Optional
 
@@ -1127,7 +1090,7 @@ class Foo:
 [out]
 
 [case testDisallowUntypedWorksForward]
-# flags: --disallow-untyped-defs --python-version 3.7
+# flags: --disallow-untyped-defs
 from dataclasses import dataclass
 from typing import List
 
@@ -1142,7 +1105,7 @@ reveal_type(B)  # N: Revealed type is "def (x: __main__.C) -> __main__.B"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDisallowUntypedWorksForwardBad]
-# flags: --disallow-untyped-defs --python-version 3.7
+# flags: --disallow-untyped-defs
 from dataclasses import dataclass
 
 @dataclass
@@ -1154,7 +1117,6 @@ reveal_type(B)  # N: Revealed type is "def (x: Any) -> __main__.B"
 [builtins fixtures/dataclasses.pyi]
 
 [case testMemberExprWorksAsField]
-# flags: --python-version 3.7
 import dataclasses
 
 @dataclasses.dataclass
@@ -1174,7 +1136,6 @@ class C:
 [builtins fixtures/dict.pyi]
 
 [case testDataclassOrderingDeferred]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 defer: Yes
@@ -1192,7 +1153,6 @@ class Yes: ...
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassFieldDeferred]
-# flags: --python-version 3.7
 from dataclasses import field, dataclass
 
 @dataclass
@@ -1204,7 +1164,6 @@ C('no')  # E: Argument 1 to "C" has incompatible type "str"; expected "int"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassFieldDeferredFrozen]
-# flags: --python-version 3.7
 from dataclasses import field, dataclass
 
 @dataclass(frozen=True)
@@ -1217,7 +1176,6 @@ c.x = 1  # E: Property "x" defined in "C" is read-only
 [builtins fixtures/dataclasses.pyi]
 
 [case testTypeInDataclassDeferredStar]
-# flags: --python-version 3.7
 import lib
 [file lib.py]
 from dataclasses import dataclass
@@ -1236,7 +1194,7 @@ import lib
 [builtins fixtures/dataclasses.pyi]
 
 [case testDeferredDataclassInitSignature]
-# flags: --python-version 3.7 --no-strict-optional
+# flags: --no-strict-optional
 from dataclasses import dataclass
 from typing import Optional, Type
 
@@ -1253,7 +1211,6 @@ class Deferred: pass
 [builtins fixtures/dataclasses.pyi]
 
 [case testDeferredDataclassInitSignatureSubclass]
-# flags: --strict-optional --python-version 3.7
 from dataclasses import dataclass
 from typing import Optional
 
@@ -1269,7 +1226,6 @@ a = C(None, 'abc')
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesDefaultsIncremental]
-# flags: --python-version 3.7
 import a
 
 [file a.py]
@@ -1301,7 +1257,6 @@ class Person:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesDefaultsMroOtherFile]
-# flags: --python-version 3.7
 import a
 
 [file a.py]
@@ -1330,14 +1285,13 @@ class A2:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesInheritingDuplicateField]
-# flags: --python-version 3.7
 # see mypy issue #7792
 from dataclasses import dataclass
 
 @dataclass
 class A:
     x: int = 0
-    x: int = 0  # E: Name "x" already defined on line 7
+    x: int = 0  # E: Name "x" already defined on line 6
 
 @dataclass
 class B(A):
@@ -1346,7 +1300,6 @@ class B(A):
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassInheritanceNoAnnotation]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -1363,7 +1316,6 @@ reveal_type(B)  # N: Revealed type is "def (foo: builtins.int) -> __main__.B"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassInheritanceNoAnnotation2]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass(frozen=True)
@@ -1380,7 +1332,6 @@ reveal_type(B)  # N: Revealed type is "def (foo: builtins.int) -> __main__.B"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassHasAttributeWithFields]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 @dataclass
@@ -1392,7 +1343,6 @@ reveal_type(A.__dataclass_fields__)  # N: Revealed type is "builtins.dict[builti
 [builtins fixtures/dict.pyi]
 
 [case testDataclassCallableFieldAccess]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Callable
 
@@ -1410,7 +1360,6 @@ reveal_type(A.y)  # N: Revealed type is "def (builtins.int) -> builtins.int"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassCallableFieldAssignment]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Callable
 
@@ -1429,7 +1378,6 @@ a.x = x2 # E: Incompatible types in assignment (expression has type "Callable[[s
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassFieldDoesNotFailOnKwargsUnpacking]
-# flags: --python-version 3.7
 # https://github.com/python/mypy/issues/10879
 from dataclasses import dataclass, field
 
@@ -1437,16 +1385,15 @@ from dataclasses import dataclass, field
 class Foo:
     bar: float = field(**{"repr": False})
 [out]
-main:7: error: Unpacking **kwargs in "field()" is not supported
-main:7: error: No overload variant of "field" matches argument type "Dict[str, bool]"
-main:7: note: Possible overload variants:
-main:7: note:     def [_T] field(*, default: _T, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> _T
-main:7: note:     def [_T] field(*, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> _T
-main:7: note:     def field(*, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> Any
+main:6: error: Unpacking **kwargs in "field()" is not supported
+main:6: error: No overload variant of "field" matches argument type "Dict[str, bool]"
+main:6: note: Possible overload variants:
+main:6: note:     def [_T] field(*, default: _T, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> _T
+main:6: note:     def [_T] field(*, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> _T
+main:6: note:     def field(*, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., kw_only: bool = ...) -> Any
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassFieldWithPositionalArguments]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
 
 @dataclass
@@ -1460,9 +1407,8 @@ class C:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassFieldWithTypedDictUnpacking]
-# flags: --python-version 3.7
 from dataclasses import dataclass, field
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 class FieldKwargs(TypedDict):
     repr: bool
@@ -1475,6 +1421,7 @@ class Foo:
 
 reveal_type(Foo(bar=1.5))  # N: Revealed type is "__main__.Foo"
 [builtins fixtures/dataclasses.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testDataclassWithSlotsArg]
 # flags: --python-version 3.10
@@ -1509,6 +1456,22 @@ class Some:
         self.y = 1  # E: Trying to assign name "y" that is not in "__slots__" of type "__main__.Some"
 [builtins fixtures/dataclasses.pyi]
 
+[case testDataclassWithSlotsDerivedFromNonSlot]
+# flags: --python-version 3.10
+from dataclasses import dataclass
+
+class A:
+    pass
+
+@dataclass(slots=True)
+class B(A):
+    x: int
+
+    def __post_init__(self) -> None:
+        self.y = 42
+
+[builtins fixtures/dataclasses.pyi]
+
 [case testDataclassWithSlotsConflict]
 # flags: --python-version 3.10
 from dataclasses import dataclass
@@ -1547,6 +1510,35 @@ class Other:
 [builtins fixtures/dataclasses.pyi]
 
 
+[case testDataclassWithSlotsRuntimeAttr]
+# flags: --python-version 3.10
+from dataclasses import dataclass
+
+@dataclass(slots=True)
+class Some:
+    x: int
+    y: str
+    z: bool
+
+reveal_type(Some.__slots__)  # N: Revealed type is "Tuple[builtins.str, builtins.str, builtins.str]"
+
+@dataclass(slots=True)
+class Other:
+    x: int
+    y: str
+
+reveal_type(Other.__slots__)  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
+
+
+@dataclass
+class NoSlots:
+    x: int
+    y: str
+
+NoSlots.__slots__  # E: "Type[NoSlots]" has no attribute "__slots__"
+[builtins fixtures/dataclasses.pyi]
+
+
 [case testSlotsDefinitionWithTwoPasses1]
 # flags: --python-version 3.10
 # https://github.com/python/mypy/issues/11821
@@ -1613,21 +1605,25 @@ class PublishedMessages:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesAnyInherit]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Any
 B: Any
 @dataclass
 class A(B):
     a: int
+@dataclass
+class C(B):
+    generated_args: int
+    generated_kwargs: int
 
 A(a=1, b=2)
 A(1)
 A(a="foo")  # E: Argument "a" to "A" has incompatible type "str"; expected "int"
+C(generated_args="foo", generated_kwargs="bar")  # E: Argument "generated_args" to "C" has incompatible type "str"; expected "int" \
+                                                 # E: Argument "generated_kwargs" to "C" has incompatible type "str"; expected "int"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassesCallableFrozen]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Any, Callable
 @dataclass(frozen=True)
@@ -1643,7 +1639,6 @@ A(a=func).a = func  # E: Property "a" defined in "A" is read-only
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassInFunctionDoesNotCrash]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 def foo() -> None:
@@ -1673,7 +1668,6 @@ class Derived(A, B):
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericInheritance2]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Any, Callable, Generic, TypeVar, List
 
@@ -1705,7 +1699,6 @@ reveal_type(Child2[int, A]([A()], [1]).b)  # N: Revealed type is "builtins.list[
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassInheritOptionalType]
-# flags: --python-version 3.7 --strict-optional
 from dataclasses import dataclass
 from typing import Any, Callable, Generic, TypeVar, List, Optional
 
@@ -1724,7 +1717,6 @@ Child(x=None, y=None)
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericInheritanceSpecialCase1]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar, List
 
@@ -1748,7 +1740,6 @@ def g(c: Child1) -> None:
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericInheritanceSpecialCase2]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
@@ -1774,7 +1765,6 @@ Child2(y=1, key='')
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericWithBound]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 
@@ -1790,7 +1780,6 @@ C(x=2)
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassGenericBoundToInvalidTypeVarDoesNotCrash]
-# flags: --python-version 3.7
 import dataclasses
 from typing import Generic, TypeVar
 
@@ -1802,7 +1791,6 @@ class C(Generic[T]):
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassInitVarCannotBeSet]
-# flags: --python-version 3.7
 from dataclasses import dataclass, InitVar
 
 @dataclass
@@ -1822,7 +1810,6 @@ c.x  # E: "C" has no attribute "x"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassCheckTypeVarBounds]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import ClassVar, Protocol, Dict, TypeVar, Generic
 
@@ -1853,6 +1840,27 @@ class Two:
     bar: int
 t: Two
 reveal_type(t.__match_args__)  # N: Revealed type is "Tuple[Literal['bar']]"
+@dataclass
+class Empty:
+    ...
+e: Empty
+reveal_type(e.__match_args__)  # N: Revealed type is "Tuple[()]"
+[builtins fixtures/dataclasses.pyi]
+
+[case testDataclassWithMatchArgsAndKwOnly]
+# flags: --python-version 3.10
+from dataclasses import dataclass, field
+@dataclass(kw_only=True)
+class One:
+    a: int
+    b: str
+reveal_type(One.__match_args__)  # N: Revealed type is "Tuple[()]"
+
+@dataclass(kw_only=True)
+class Two:
+    a: int = field(kw_only=False)
+    b: str
+reveal_type(Two.__match_args__)  # N: Revealed type is "Tuple[Literal['a']]"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassWithoutMatchArgs]
@@ -1939,7 +1947,6 @@ B = List[C]
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassSelfType]
-# flags: --strict-optional
 from dataclasses import dataclass
 from typing import Self, TypeVar, Generic, Optional
 
@@ -2006,7 +2013,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,7 +2046,402 @@ 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"
+
+[builtins fixtures/tuple.pyi]
+
+[case testReplaceUnion]
+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) = Never
+    w: dict  # exercises meet(dict, Never) = Never
+    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 "Never"
+_ = 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[Never, Never]"; expected "Never"
+_ = 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/tuple.pyi]
+
+[case testReplaceUnionOfTypeVar]
+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: Value of type variable "_DataclassT" of "replace" cannot be "Union[TA, TB, int]"
+
+[builtins fixtures/tuple.pyi]
+
+[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: Value of type variable "_DataclassT" of "replace" cannot be "TInt"
+
+def f2(t: TAny) -> TAny:
+    return replace(t, x='spam')  # E: Value of type variable "_DataclassT" of "replace" cannot be "TAny"
+
+def f3(t: TNone) -> TNone:
+    return replace(t, x='spam')  # E: Value of type variable "_DataclassT" of "replace" cannot be "TNone"
+
+def f4(t: TUnion) -> TUnion:
+    return replace(t, x='spam')  # E: Value of type variable "_DataclassT" of "replace" cannot be "TUnion"
+
+[builtins fixtures/tuple.pyi]
+
+[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))
+
+[builtins fixtures/tuple.pyi]
+
+[case testReplaceAny]
+from dataclasses import replace
+from typing import Any
+
+a: Any
+a2 = replace(a)
+reveal_type(a2)  # N: Revealed type is "Any"
+
+[builtins fixtures/tuple.pyi]
+
+[case testReplaceNotDataclass]
+from dataclasses import replace
+
+replace(5)  # E: Value of type variable "_DataclassT" of "replace" cannot be "int"
+
+class C:
+    pass
+
+replace(C())  # E: Value of type variable "_DataclassT" of "replace" cannot be "C"
+
+replace(None)  # E: Value of type variable "_DataclassT" of "replace" cannot be "None"
+
+[builtins fixtures/tuple.pyi]
+
+[case testReplaceIsDataclass]
+from dataclasses import is_dataclass, replace
+
+def f(x: object) -> None:
+  _ = replace(x)  # E: Value of type variable "_DataclassT" of "replace" cannot be "object"
+  if is_dataclass(x):
+    _ = replace(x)  # E: Value of type variable "_DataclassT" of "replace" cannot be "Union[DataclassInstance, Type[DataclassInstance]]"
+    if not isinstance(x, type):
+      _ = replace(x)
+
+[builtins fixtures/tuple.pyi]
+
+[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]"
+
+[builtins fixtures/tuple.pyi]
+
+[case testPostInitNotMethod]
+def __post_init__() -> None:
+    pass
+
+[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
@@ -2054,3 +2455,158 @@ class Test(Protocol):
     def reset(self) -> None:
         self.x = DEFAULT
 [builtins fixtures/dataclasses.pyi]
+
+[case testProtocolNoCrashOnJoining]
+from dataclasses import dataclass
+from typing import Protocol
+
+@dataclass
+class MyDataclass(Protocol): ...
+
+a: MyDataclass
+b = [a, a]  # trigger joining the types
+
+[builtins fixtures/dataclasses.pyi]
+
+[case testPropertyAndFieldRedefinitionNoCrash]
+from dataclasses import dataclass
+
+@dataclass
+class Foo:
+    @property
+    def c(self) -> int:
+        return 0
+
+    c: int  # E: Name "c" already defined on line 5
+[builtins fixtures/dataclasses.pyi]
+
+[case testDataclassInheritanceWorksWithExplicitOverrides]
+# flags: --enable-error-code explicit-override
+from dataclasses  import dataclass
+
+@dataclass
+class Base:
+    x: int
+
+@dataclass
+class Child(Base):
+    y: int
+[builtins fixtures/dataclasses.pyi]
+
+
+[case testDataclassInheritanceWorksWithExplicitOverridesAndOrdering]
+# flags: --enable-error-code explicit-override
+from dataclasses import dataclass
+
+@dataclass(order=True)
+class Base:
+    x: int
+
+@dataclass(order=True)
+class Child(Base):
+    y: int
+[builtins fixtures/dataclasses.pyi]
+
+[case testDunderReplacePresent]
+# flags: --python-version 3.13
+from dataclasses import dataclass, field
+
+@dataclass
+class Coords:
+    x: int
+    y: int
+    # non-init fields are not allowed with replace:
+    z: int = field(init=False)
+
+
+replaced = Coords(2, 4).__replace__(x=2, y=5)
+reveal_type(replaced)  # N: Revealed type is "__main__.Coords"
+
+replaced = Coords(2, 4).__replace__(x=2)
+reveal_type(replaced)  # N: Revealed type is "__main__.Coords"
+
+Coords(2, 4).__replace__(x="asdf")  # E: Argument "x" to "__replace__" of "Coords" has incompatible type "str"; expected "int"
+Coords(2, 4).__replace__(23)          # E: Too many positional arguments for "__replace__" of "Coords"
+Coords(2, 4).__replace__(23, 25)      # E: Too many positional arguments for "__replace__" of "Coords"
+Coords(2, 4).__replace__(x=23, y=25, z=42)  # E: Unexpected keyword argument "z" for "__replace__" of "Coords"
+
+from typing import Generic, TypeVar
+T = TypeVar('T')
+
+@dataclass
+class Gen(Generic[T]):
+    x: T
+
+replaced_2 = Gen(2).__replace__(x=2)
+reveal_type(replaced_2)  # N: Revealed type is "__main__.Gen[builtins.int]"
+Gen(2).__replace__(x="not an int")  # E: Argument "x" to "__replace__" of "Gen" has incompatible type "str"; expected "int"
+
+[builtins fixtures/tuple.pyi]
+
+[case testDunderReplaceCovariantOverride]
+# flags: --python-version 3.13  --enable-error-code mutable-override
+from dataclasses import dataclass
+from typing import Optional
+from typing_extensions import dataclass_transform
+
+@dataclass
+class Base:
+    a: Optional[int]
+
+@dataclass
+class Child(Base):
+    a: int  # E: Covariant override of a mutable attribute (base class "Base" defined the type as "Optional[int]", expression has type "int")
+
+@dataclass
+class Other(Base):
+    a: str  # E: Incompatible types in assignment (expression has type "str", base class "Base" defined the type as "Optional[int]")
+
+@dataclass_transform(kw_only_default=True)
+class DCMeta(type): ...
+
+class X(metaclass=DCMeta):
+    a: Optional[int]
+
+class Y(X):
+    a: int  # E: Covariant override of a mutable attribute (base class "X" defined the type as "Optional[int]", expression has type "int")
+[builtins fixtures/tuple.pyi]
+
+
+[case testFrozenWithFinal]
+from dataclasses import dataclass
+from typing import Final
+
+@dataclass(frozen=True)
+class My:
+    a: Final = 1
+    b: Final[int] = 2
+
+reveal_type(My.a)  # N: Revealed type is "Literal[1]?"
+reveal_type(My.b)  # N: Revealed type is "builtins.int"
+My.a = 1  # E: Cannot assign to final attribute "a"
+My.b = 2  # E: Cannot assign to final attribute "b"
+
+m = My()
+reveal_type(m.a)  # N: Revealed type is "Literal[1]?"
+reveal_type(m.b)  # N: Revealed type is "builtins.int"
+
+m.a = 1  # E: Cannot assign to final attribute "a"
+m.b = 2  # E: Cannot assign to final attribute "b"
+[builtins fixtures/tuple.pyi]
+
+[case testNoCrashForDataclassNamedTupleCombination]
+# flags: --python-version 3.13
+from dataclasses import dataclass
+from typing import NamedTuple
+
+@dataclass
+class A(NamedTuple):  # E: A NamedTuple cannot be a dataclass
+    i: int
+
+class B1(NamedTuple):
+    i: int
+@dataclass
+class B2(B1):  # E: A NamedTuple cannot be a dataclass
+    pass
+
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-deprecated.test b/test-data/unit/check-deprecated.test
new file mode 100644
index 000000000000..6cc160fad81f
--- /dev/null
+++ b/test-data/unit/check-deprecated.test
@@ -0,0 +1,852 @@
+-- Type checker test cases for reporting deprecations.
+
+
+[case testDeprecatedDisabled]
+
+from typing_extensions import deprecated
+
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+f()
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedAsNoteWithErrorCode]
+# flags: --enable-error-code=deprecated --show-error-codes --report-deprecated-as-note
+
+from typing_extensions import deprecated
+
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+f() # type: ignore[deprecated]
+f() # N: function __main__.f is deprecated: use f2 instead  [deprecated]
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedAsErrorWithErrorCode]
+# flags: --enable-error-code=deprecated --show-error-codes
+
+from typing_extensions import deprecated
+
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+f() # type: ignore[deprecated]
+f() # E: function __main__.f is deprecated: use f2 instead  [deprecated]
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedFunction]
+# flags: --enable-error-code=deprecated
+
+from typing_extensions import deprecated
+
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+f  # E: function __main__.f is deprecated: use f2 instead  # type: ignore[deprecated]
+f(1)  # E: function __main__.f is deprecated: use f2 instead \
+      # E: Too many arguments for "f"
+f[1]  # E: function __main__.f is deprecated: use f2 instead \
+      # E: Value of type "Callable[[], None]" is not indexable
+g = f  # E: function __main__.f is deprecated: use f2 instead
+g()
+t = (f, f, g)  # E: function __main__.f is deprecated: use f2 instead
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedFunctionDifferentModule]
+# flags: --enable-error-code=deprecated
+
+import m
+import p.s
+import m as n
+import p.s as ps
+from m import f  # E: function m.f is deprecated: use f2 instead
+from p.s import g  # E: function p.s.g is deprecated: use g2 instead
+from k import *
+
+m.f()  # E: function m.f is deprecated: use f2 instead
+p.s.g()  # E: function p.s.g is deprecated: use g2 instead
+n.f()  # E: function m.f is deprecated: use f2 instead
+ps.g()  # E: function p.s.g is deprecated: use g2 instead
+f()
+g()
+h()  # E: function k.h is deprecated: use h2 instead
+
+[file m.py]
+from typing_extensions import deprecated
+
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+[file p/s.py]
+from typing_extensions import deprecated
+
+@deprecated("use g2 instead")
+def g() -> None: ...
+
+[file k.py]
+from typing_extensions import deprecated
+
+@deprecated("use h2 instead")
+def h() -> None: ...
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedClass]
+# flags: --enable-error-code=deprecated
+
+from typing import Callable, List, Optional, Tuple, Union
+from typing_extensions import deprecated, TypeAlias, TypeVar
+
+@deprecated("use C2 instead")
+class C: ...
+
+c: C  # E: class __main__.C is deprecated: use C2 instead
+C()  # E: class __main__.C is deprecated: use C2 instead
+C.missing()  # E: class __main__.C is deprecated: use C2 instead \
+             # E: "Type[C]" has no attribute "missing"
+C.__init__(c)  # E: class __main__.C is deprecated: use C2 instead
+C(1)  # E: class __main__.C is deprecated: use C2 instead \
+      # E: Too many arguments for "C"
+
+D = C  # E: class __main__.C is deprecated: use C2 instead
+D()
+t = (C, C, D)  # E: class __main__.C is deprecated: use C2 instead
+
+u1: Union[C, int] = 1  # E: class __main__.C is deprecated: use C2 instead
+u1 = 1
+u2 = 1  # type: Union[C, int]  # E: class __main__.C is deprecated: use C2 instead
+u2 = 1
+
+c1 = c2 = C()  # E: class __main__.C is deprecated: use C2 instead
+i, c3 = 1, C()  # E: class __main__.C is deprecated: use C2 instead
+
+class E: ...
+
+x1: Optional[C]  # E: class __main__.C is deprecated: use C2 instead
+x2: Union[D, C, E]  # E: class __main__.C is deprecated: use C2 instead
+x3: Union[D, Optional[C], E]  # E: class __main__.C is deprecated: use C2 instead
+x4: Tuple[D, C, E]  # E: class __main__.C is deprecated: use C2 instead
+x5: Tuple[Tuple[D, C], E]  # E: class __main__.C is deprecated: use C2 instead
+x6: List[C]  # E: class __main__.C is deprecated: use C2 instead
+x7: List[List[C]]  # E: class __main__.C is deprecated: use C2 instead
+x8: List[Optional[Tuple[Union[List[C], int]]]]  # E: class __main__.C is deprecated: use C2 instead
+x9: Callable[[int], C]  # E: class __main__.C is deprecated: use C2 instead
+x10: Callable[[int, C, int], int]  # E: class __main__.C is deprecated: use C2 instead
+
+T = TypeVar("T")
+A1: TypeAlias = Optional[C]  # E: class __main__.C is deprecated: use C2 instead
+x11: A1
+A2: TypeAlias = List[Union[A2, C]]  # E: class __main__.C is deprecated: use C2 instead
+x12: A2
+A3: TypeAlias = List[Optional[T]]
+x13: A3[C]  # E: class __main__.C is deprecated: use C2 instead
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedBaseClass]
+# flags: --enable-error-code=deprecated
+
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C: ...
+
+class D(C): ...  # E: class __main__.C is deprecated: use C2 instead
+class E(D): ...
+class F(D, C): ...  # E: class __main__.C is deprecated: use C2 instead
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedClassInTypeVar]
+# flags: --enable-error-code=deprecated
+
+from typing import Generic, TypeVar
+from typing_extensions import deprecated
+
+class B: ...
+@deprecated("use C2 instead")
+class C: ...
+
+T = TypeVar("T", bound=C)  # E: class __main__.C is deprecated: use C2 instead
+def f(x: T) -> T: ...
+class D(Generic[T]): ...
+
+V = TypeVar("V", B, C)  # E: class __main__.C is deprecated: use C2 instead
+def g(x: V) -> V: ...
+class E(Generic[V]): ...
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedClassInCast]
+# flags: --enable-error-code=deprecated
+
+from typing import cast, Generic
+from typing_extensions import deprecated
+
+class B: ...
+@deprecated("use C2 instead")
+class C: ...
+
+c = C()  # E: class __main__.C is deprecated: use C2 instead
+b = cast(B, c)
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedInstanceInFunctionDefinition]
+# flags: --enable-error-code=deprecated
+
+from typing import Generic, List, Optional, TypeVar
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C: ...
+
+def f1(c: C) -> None:  # E: class __main__.C is deprecated: use C2 instead
+    def g1() -> None: ...
+
+def f2(c: List[Optional[C]]) -> None:  # E: class __main__.C is deprecated: use C2 instead
+    def g2() -> None: ...
+
+def f3() -> C:  # E: class __main__.C is deprecated: use C2 instead
+    def g3() -> None: ...
+    return C()  # E: class __main__.C is deprecated: use C2 instead
+
+def f4() -> List[Optional[C]]:  # E: class __main__.C is deprecated: use C2 instead
+    def g4() -> None: ...
+    return []
+
+def f5() -> None:
+    def g5(c: C) -> None: ...  # E: class __main__.C is deprecated: use C2 instead
+
+def f6() -> None:
+    def g6() -> C: ...  # E: class __main__.C is deprecated: use C2 instead
+
+
+@deprecated("use D2 instead")
+class D:
+
+    def f1(self, c: C) -> None:  # E: class __main__.C is deprecated: use C2 instead
+        def g1() -> None: ...
+
+    def f2(self, c: List[Optional[C]]) -> None:  # E: class __main__.C is deprecated: use C2 instead
+        def g2() -> None: ...
+
+    def f3(self) -> None:
+        def g3(c: C) -> None: ...  # E: class __main__.C is deprecated: use C2 instead
+
+    def f4(self) -> None:
+        def g4() -> C: ...  # E: class __main__.C is deprecated: use C2 instead
+
+T = TypeVar("T")
+
+@deprecated("use E2 instead")
+class E(Generic[T]):
+
+    def f1(self: E[C]) -> None: ...  # E: class __main__.C is deprecated: use C2 instead
+    def f2(self, e: E[C]) -> None: ...  # E: class __main__.C is deprecated: use C2 instead
+    def f3(self) -> E[C]: ...  # E: class __main__.C is deprecated: use C2 instead
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedClassDifferentModule]
+# flags: --enable-error-code=deprecated
+
+import m
+import p.s
+import m as n
+import p.s as ps
+from m import B, C  # E: class m.B is deprecated: use B2 instead \
+                    # E: class m.C is deprecated: use C2 instead
+from p.s import D  # E: class p.s.D is deprecated: use D2 instead
+from k import *
+
+m.C()  # E: class m.C is deprecated: use C2 instead
+p.s.D()  # E: class p.s.D is deprecated: use D2 instead
+n.C()  # E: class m.C is deprecated: use C2 instead
+ps.D()  # E: class p.s.D is deprecated: use D2 instead
+C()
+D()
+E()  # E: class k.E is deprecated: use E2 instead
+
+x1: m.A  # E: class m.A is deprecated: use A2 instead
+x2: m.A = m.A()  # E: class m.A is deprecated: use A2 instead
+y1: B
+y2: B = B()
+
+[file m.py]
+from typing_extensions import deprecated
+
+@deprecated("use A2 instead")
+class A: ...
+
+@deprecated("use B2 instead")
+class B: ...
+
+@deprecated("use C2 instead")
+class C: ...
+
+[file p/s.py]
+from typing_extensions import deprecated
+
+@deprecated("use D2 instead")
+class D: ...
+
+[file k.py]
+from typing_extensions import deprecated
+
+@deprecated("use E2 instead")
+class E: ...
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedClassInitMethod]
+# flags: --enable-error-code=deprecated
+
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C:
+    def __init__(self) -> None: ...
+
+c: C  # E: class __main__.C is deprecated: use C2 instead
+C()  # E: class __main__.C is deprecated: use C2 instead
+C.__init__(c)  # E: class __main__.C is deprecated: use C2 instead
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedSpecialMethods]
+# flags: --enable-error-code=deprecated
+
+from typing import Iterator
+from typing_extensions import deprecated
+
+class A:
+    @deprecated("no A + int")
+    def __add__(self, v: int) -> None: ...
+
+    @deprecated("no int + A")
+    def __radd__(self, v: int) -> None: ...
+
+    @deprecated("no A = A + int")
+    def __iadd__(self, v: int) -> A: ...
+
+    @deprecated("no iteration")
+    def __iter__(self) -> Iterator[int]: ...
+
+    @deprecated("no in")
+    def __contains__(self, v: int) -> int: ...
+
+    @deprecated("no integer")
+    def __int__(self) -> int: ...
+
+    @deprecated("no inversion")
+    def __invert__(self) -> A: ...
+
+class B:
+    @deprecated("still no in")
+    def __contains__(self, v: int) -> int: ...
+
+a = A()
+b = B()
+a + 1  # E: function __main__.A.__add__ is deprecated: no A + int
+1 + a  # E: function __main__.A.__radd__ is deprecated: no int + A
+a += 1  # E: function __main__.A.__iadd__ is deprecated: no A = A + int
+for i in a:  # E: function __main__.A.__iter__ is deprecated: no iteration
+    reveal_type(i)  # N: Revealed type is "builtins.int"
+1 in a  # E: function __main__.A.__contains__ is deprecated: no in
+1 in b  # E: function __main__.B.__contains__ is deprecated: still no in
+~a  # E: function __main__.A.__invert__ is deprecated: no inversion
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedOverloadedInstanceMethods]
+# flags: --enable-error-code=deprecated
+
+from typing import Iterator, Union, overload
+from typing_extensions import deprecated
+
+class A:
+    @overload
+    @deprecated("pass `str` instead")
+    def f(self, v: int) -> None: ...
+    @overload
+    def f(self, v: str) -> None: ...
+    def f(self, v: Union[int, str]) -> None: ...
+
+    @overload
+    def g(self, v: int) -> None: ...
+    @overload
+    @deprecated("pass `int` instead")
+    def g(self, v: str) -> None: ...
+    def g(self, v: Union[int, str]) -> None: ...
+
+    @overload
+    def h(self, v: int) -> A: ...
+    @overload
+    def h(self, v: str) -> A: ...
+    @deprecated("use `h2` instead")
+    def h(self, v: Union[int, str]) -> A: ...
+
+class B(A): ...
+
+a = A()
+a.f(1)  # E: overload def (self: __main__.A, v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
+a.f("x")
+a.g(1)
+a.g("x")  # E: overload def (self: __main__.A, v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
+a.h(1)  # E: function __main__.A.h is deprecated: use `h2` instead
+a.h("x")  # E: function __main__.A.h is deprecated: use `h2` instead
+
+b = B()
+b.f(1)  # E: overload def (self: __main__.A, v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
+b.f("x")
+b.g(1)
+b.g("x")  # E: overload def (self: __main__.A, v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
+b.h(1)  # E: function __main__.A.h is deprecated: use `h2` instead
+b.h("x")  # E: function __main__.A.h is deprecated: use `h2` instead
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedOverloadedClassMethods]
+# flags: --enable-error-code=deprecated
+
+from typing import Iterator, Union, overload
+from typing_extensions import deprecated
+
+class A:
+    @overload
+    @classmethod
+    @deprecated("pass `str` instead")
+    def f(cls, v: int) -> None: ...
+    @overload
+    @classmethod
+    def f(cls, v: str) -> None: ...
+    @classmethod
+    def f(cls, v: Union[int, str]) -> None: ...
+
+    @overload
+    @classmethod
+    def g(cls, v: int) -> None: ...
+    @overload
+    @classmethod
+    @deprecated("pass `int` instead")
+    def g(cls, v: str) -> None: ...
+    @classmethod
+    def g(cls, v: Union[int, str]) -> None: ...
+
+    @overload
+    @classmethod
+    def h(cls, v: int) -> A: ...
+    @overload
+    @classmethod
+    def h(cls, v: str) -> A: ...
+    @deprecated("use `h2`  instead")
+    @classmethod
+    def h(cls, v: Union[int, str]) -> A: ...
+
+class B(A): ...
+
+a = A()
+a.f(1)  # E: overload def (cls: type[__main__.A], v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
+a.f("x")
+a.g(1)
+a.g("x")  # E: overload def (cls: type[__main__.A], v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
+a.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
+a.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead
+
+b = B()
+b.f(1)  # E: overload def (cls: type[__main__.A], v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
+b.f("x")
+b.g(1)
+b.g("x")  # E: overload def (cls: type[__main__.A], v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
+b.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
+b.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedOverloadedStaticMethods]
+# flags: --enable-error-code=deprecated
+
+from typing import Iterator, Union, overload
+from typing_extensions import deprecated
+
+class A:
+    @overload
+    @staticmethod
+    @deprecated("pass `str` instead")
+    def f(v: int) -> None: ...
+    @overload
+    @staticmethod
+    def f(v: str) -> None: ...
+    @staticmethod
+    def f(v: Union[int, str]) -> None: ...
+
+    @overload
+    @staticmethod
+    def g(v: int) -> None: ...
+    @overload
+    @staticmethod
+    @deprecated("pass `int` instead")
+    def g(v: str) -> None: ...
+    @staticmethod
+    def g(v: Union[int, str]) -> None: ...
+
+    @overload
+    @staticmethod
+    def h(v: int) -> A: ...
+    @overload
+    @staticmethod
+    def h(v: str) -> A: ...
+    @deprecated("use `h2`  instead")
+    @staticmethod
+    def h(v: Union[int, str]) -> A: ...
+
+class B(A): ...
+
+a = A()
+a.f(1)  # E: overload def (v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
+a.f("x")
+a.g(1)
+a.g("x")  # E: overload def (v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
+a.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
+a.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead
+
+b = B()
+b.f(1)  # E: overload def (v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
+b.f("x")
+b.g(1)
+b.g("x")  # E: overload def (v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
+b.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
+b.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead
+
+[builtins fixtures/classmethod.pyi]
+
+
+[case testDeprecatedOverloadedSpecialMethods]
+# flags: --enable-error-code=deprecated
+
+from typing import Iterator, Union, overload
+from typing_extensions import deprecated
+
+class A:
+    @overload
+    @deprecated("no A + int")
+    def __add__(self, v: int) -> None: ...
+    @overload
+    def __add__(self, v: str) -> None: ...
+    def __add__(self, v: Union[int, str]) -> None: ...
+
+    @overload
+    def __radd__(self, v: int) -> None: ...
+    @overload
+    @deprecated("no str + A")
+    def __radd__(self, v: str) -> None: ...
+    def __radd__(self, v: Union[int, str]) -> None: ...
+
+    @overload
+    def __iadd__(self, v: int) -> A: ...
+    @overload
+    def __iadd__(self, v: str) -> A: ...
+    @deprecated("no A += Any")
+    def __iadd__(self, v: Union[int, str]) -> A: ...
+
+a = A()
+a + 1  # E: overload def (__main__.A, builtins.int) of function __main__.A.__add__ is deprecated: no A + int
+a + "x"
+1 + a
+"x" + a  # E: overload def (__main__.A, builtins.str) of function __main__.A.__radd__ is deprecated: no str + A
+a += 1  # E: function __main__.A.__iadd__ is deprecated: no A += Any
+a += "x"  # E: function __main__.A.__iadd__ is deprecated: no A += Any
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedMethod]
+# flags: --enable-error-code=deprecated
+
+from typing_extensions import deprecated
+
+class C:
+    @deprecated("use g instead")
+    def f(self) -> None: ...
+
+    def g(self) -> None: ...
+
+    @staticmethod
+    @deprecated("use g instead")
+    def h() -> None: ...
+
+    @deprecated("use g instead")
+    @staticmethod
+    def k() -> None: ...
+
+C.f  # E: function __main__.C.f is deprecated: use g instead
+C().f  # E: function __main__.C.f is deprecated: use g instead
+C().f()  # E: function __main__.C.f is deprecated: use g instead
+C().f(1)  # E: function __main__.C.f is deprecated: use g instead \
+          # E: Too many arguments for "f" of "C"
+f = C().f  # E: function __main__.C.f is deprecated: use g instead
+f()
+t = (C.f, C.f, C.g)  # E: function __main__.C.f is deprecated: use g instead
+
+C().g()
+C().h()  # E: function __main__.C.h is deprecated: use g instead
+C().k()  # E: function __main__.C.k is deprecated: use g instead
+
+[builtins fixtures/callable.pyi]
+
+
+[case testDeprecatedClassWithDeprecatedMethod]
+# flags: --enable-error-code=deprecated
+
+from typing_extensions import deprecated
+
+@deprecated("use D instead")
+class C:
+    @deprecated("use g instead")
+    def f(self) -> None: ...
+    def g(self) -> None: ...
+
+C().f()  # E: class __main__.C is deprecated: use D instead \
+         # E: function __main__.C.f is deprecated: use g instead
+C().g()  # E: class __main__.C is deprecated: use D instead
+
+[builtins fixtures/callable.pyi]
+
+
+[case testDeprecatedProperty]
+# flags: --enable-error-code=deprecated
+
+from typing_extensions import deprecated
+
+class C:
+    @property
+    @deprecated("use f2 instead")
+    def f(self) -> int: ...
+
+    @property
+    def g(self) -> int: ...
+    @g.setter
+    @deprecated("use g2 instead")
+    def g(self, v: int) -> None: ...
+
+
+C.f  # E: function __main__.C.f is deprecated: use f2 instead
+C().f  # E: function __main__.C.f is deprecated: use f2 instead
+C().f()  # E: function __main__.C.f is deprecated: use f2 instead \
+         # E: "int" not callable
+C().f = 1  # E: function __main__.C.f is deprecated: use f2 instead \
+           # E: Property "f" defined in "C" is read-only
+
+
+C.g
+C().g
+C().g = 1  # E: function __main__.C.g is deprecated: use g2 instead
+C().g = "x"  # E: function __main__.C.g is deprecated: use g2 instead \
+             # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[builtins fixtures/property.pyi]
+
+
+[case testDeprecatedDescriptor]
+# flags: --enable-error-code=deprecated
+
+from typing import Any, Optional, Union, overload
+from typing_extensions import deprecated
+
+@deprecated("use E1 instead")
+class D1:
+    def __get__(self, obj: Optional[C], objtype: Any) -> Union[D1, int]: ...
+
+class D2:
+    @deprecated("use E2.__get__ instead")
+    def __get__(self, obj: Optional[C], objtype: Any) -> Union[D2, int]: ...
+
+    @deprecated("use E2.__set__ instead")
+    def __set__(self, obj: C, value: int) -> None: ...
+
+class D3:
+    @overload
+    @deprecated("use E3.__get__ instead")
+    def __get__(self, obj: None, objtype: Any) -> D3: ...
+    @overload
+    @deprecated("use E3.__get__ instead")
+    def __get__(self, obj: C, objtype: Any) -> int: ...
+    def __get__(self, obj: Optional[C], objtype: Any) -> Union[D3, int]: ...
+
+    @overload
+    def __set__(self, obj: C, value: int) -> None: ...
+    @overload
+    @deprecated("use E3.__set__ instead")
+    def __set__(self, obj: C, value: str) -> None: ...
+    def __set__(self, obj: C, value: Union[int, str]) -> None: ...
+
+class C:
+    d1 = D1()  # E: class __main__.D1 is deprecated: use E1 instead
+    d2 = D2()
+    d3 = D3()
+
+c: C
+C.d1
+c.d1
+c.d1 = 1
+
+C.d2  # E: function __main__.D2.__get__ is deprecated: use E2.__get__ instead
+c.d2  # E: function __main__.D2.__get__ is deprecated: use E2.__get__ instead
+c.d2 = 1  # E: function __main__.D2.__set__ is deprecated: use E2.__set__ instead
+
+C.d3  # E: overload def (self: __main__.D3, obj: None, objtype: Any) -> __main__.D3 of function __main__.D3.__get__ is deprecated: use E3.__get__ instead
+c.d3  # E: overload def (self: __main__.D3, obj: __main__.C, objtype: Any) -> builtins.int of function __main__.D3.__get__ is deprecated: use E3.__get__ instead
+c.d3 = 1
+c.d3 = "x"  # E: overload def (self: __main__.D3, obj: __main__.C, value: builtins.str) of function __main__.D3.__set__ is deprecated: use E3.__set__ instead
+[builtins fixtures/property.pyi]
+
+
+[case testDeprecatedOverloadedFunction]
+# flags: --enable-error-code=deprecated
+
+from typing import Union, overload
+from typing_extensions import deprecated
+
+@overload
+def f(x: int) -> int: ...
+@overload
+def f(x: str) -> str: ...
+@deprecated("use f2 instead")
+def f(x: Union[int, str]) -> Union[int, str]: ...
+
+f  # E: function __main__.f is deprecated: use f2 instead
+f(1)  # E: function __main__.f is deprecated: use f2 instead
+f("x")  # E: function __main__.f is deprecated: use f2 instead
+f(1.0)  # E: function __main__.f is deprecated: use f2 instead \
+        # E: No overload variant of "f" matches argument type "float" \
+        # N: Possible overload variants: \
+        # N:     def f(x: int) -> int \
+        # N:     def f(x: str) -> str
+
+@overload
+@deprecated("work with str instead")
+def g(x: int) -> int: ...
+@overload
+def g(x: str) -> str: ...
+def g(x: Union[int, str]) -> Union[int, str]: ...
+
+g
+g(1)  # E: overload def (x: builtins.int) -> builtins.int of function __main__.g is deprecated: work with str instead
+g("x")
+g(1.0)  # E: No overload variant of "g" matches argument type "float" \
+        # N: Possible overload variants: \
+        # N:     def g(x: int) -> int \
+        # N:     def g(x: str) -> str
+
+@overload
+def h(x: int) -> int: ...
+@deprecated("work with int instead")
+@overload  # N: @overload should be placed before @deprecated
+def h(x: str) -> str: ...
+def h(x: Union[int, str]) -> Union[int, str]: ...
+
+h
+h(1)
+h("x")  # E: overload def (x: builtins.str) -> builtins.str of function __main__.h is deprecated: work with int instead
+h(1.0)  # E: No overload variant of "h" matches argument type "float" \
+        # N: Possible overload variants: \
+        # N:     def h(x: int) -> int \
+        # N:     def h(x: str) -> str
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedImportedOverloadedFunction]
+# flags: --enable-error-code=deprecated
+
+import m
+
+m.g
+m.g(1)  # E: overload def (x: builtins.int) -> builtins.int of function m.g is deprecated: work with str instead
+m.g("x")
+
+[file m.py]
+
+from typing import Union, overload
+from typing_extensions import deprecated
+
+@overload
+@deprecated("work with str instead")
+def g(x: int) -> int: ...
+@overload
+def g(x: str) -> str: ...
+def g(x: Union[int, str]) -> Union[int, str]: ...
+[builtins fixtures/tuple.pyi]
+
+[case testDeprecatedExclude]
+# flags: --enable-error-code=deprecated --deprecated-calls-exclude=m.C --deprecated-calls-exclude=m.D --deprecated-calls-exclude=m.E.f --deprecated-calls-exclude=m.E.g --deprecated-calls-exclude=m.E.__add__
+from m import C, D, E
+
+[file m.py]
+from typing import Union, overload
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C:
+    def __init__(self) -> None: ...
+
+c: C
+C()
+C.__init__(c)
+
+class D:
+    @deprecated("use D.g instead")
+    def f(self) -> None: ...
+
+    def g(self) -> None: ...
+
+D.f
+D().f
+D().f()
+
+class E:
+    @overload
+    def f(self, x: int) -> int: ...
+    @overload
+    def f(self, x: str) -> str: ...
+    @deprecated("use E.f2 instead")
+    def f(self, x: Union[int, str]) -> Union[int, str]: ...
+
+    @deprecated("use E.h instead")
+    def g(self) -> None: ...
+
+    @overload
+    @deprecated("no A + int")
+    def __add__(self, v: int) -> None: ...
+    @overload
+    def __add__(self, v: str) -> None: ...
+    def __add__(self, v: Union[int, str]) -> None: ...
+
+E().f(1)
+E().f("x")
+
+e = E()
+e.g()
+e + 1
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-dynamic-typing.test b/test-data/unit/check-dynamic-typing.test
index dd4cc1579639..ffab5afeda3e 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
@@ -249,15 +252,15 @@ if int():
 if int():
     a = d.foo(a, a)
 d.x = a
-d.x.y.z  # E: "A" has no attribute "y"
+d.x.y.z
 
 class A: pass
 [out]
 
 [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,16 +312,18 @@ 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
 d = t
 d = g
 d = A
-t = d
-f = d
+
+d1: Any
+t = d1
+f = d1
 [builtins fixtures/tuple.pyi]
 
 
@@ -362,10 +367,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 +389,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 +420,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 +462,7 @@ if int():
 [builtins fixtures/tuple.pyi]
 
 [case testSkipTypeCheckingWithImplicitSignature]
-a = None # type: A
+a: A
 def f():
     a()
 def g(x):
@@ -469,7 +475,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 +484,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 +508,7 @@ if int():
 
 [case testSkipTypeCheckingImplicitMethod]
 
-a = None # type: A
+a: A
 class A:
     def f(self):
         a()
@@ -511,9 +517,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 +565,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 +582,7 @@ class A: pass
 class B:
     def __init__(self): pass
 
-t = None # type: type
+t: type
 t = A
 t = B
 -- Type compatibility
@@ -585,11 +591,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 +620,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 +637,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 +657,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 +670,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 +689,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)
@@ -751,6 +758,21 @@ main:5: note:          def f(self, x: A) -> None
 main:5: note:      Subclass:
 main:5: note:          def f(self, x: Any, y: Any) -> None
 
+[case testInvalidOverrideArgumentCountWithImplicitSignature4]
+# flags: --check-untyped-defs
+import typing
+class B:
+    def f(self, x: A) -> None: pass
+class A(B):
+    def f(self, x, y):
+        x()
+[out]
+main:6: error: Signature of "f" incompatible with supertype "B"
+main:6: note:      Superclass:
+main:6: note:          def f(self, x: A) -> None
+main:6: note:      Subclass:
+main:6: note:          def f(self, x: Any, y: Any) -> Any
+
 [case testInvalidOverrideWithImplicitSignatureAndClassMethod1]
 class B:
     @classmethod
diff --git a/test-data/unit/check-enum.test b/test-data/unit/check-enum.test
index b62ed3d94210..cc9048db18dc 100644
--- a/test-data/unit/check-enum.test
+++ b/test-data/unit/check-enum.test
@@ -11,12 +11,14 @@ m = Medal.gold
 if int():
     m = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "Medal")
 
+[builtins fixtures/enum.pyi]
+
 -- Creation from Enum call
 -- -----------------------
 
 [case testEnumCreatedFromStringLiteral]
 from enum import Enum
-from typing_extensions import Literal
+from typing import Literal
 
 x: Literal['ANT BEE CAT DOG'] = 'ANT BEE CAT DOG'
 Animal = Enum('Animal', x)
@@ -29,7 +31,7 @@ reveal_type(Animal.DOG)  # N: Revealed type is "Literal[__main__.Animal.DOG]?"
 
 [case testEnumCreatedFromFinalValue]
 from enum import Enum
-from typing_extensions import Final
+from typing import Final
 
 x: Final['str'] = 'ANT BEE CAT DOG'
 Animal = Enum('Animal', x)
@@ -79,6 +81,7 @@ from typing import Generic, TypeVar
 T = TypeVar("T")
 class Medal(Generic[T], metaclass=EnumMeta):  # E: Enum class cannot be generic
     q = None
+[builtins fixtures/enum.pyi]
 
 [case testEnumNameAndValue]
 from enum import Enum
@@ -151,7 +154,7 @@ def infer_truth(truth: Truth) -> None:
     reveal_type(truth.value) # N: Revealed type is "builtins.str"
 [builtins fixtures/primitives.pyi]
 
-[case testEnumValueInhomogenous]
+[case testEnumValueInhomogeneous]
 from enum import Enum
 class Truth(Enum):
     true = 'True'
@@ -175,6 +178,104 @@ def infer_truth(truth: Truth) -> None:
     reveal_type(truth.value) # N: Revealed type is "builtins.bool"
 [builtins fixtures/bool.pyi]
 
+[case testEnumTruthyness]
+# mypy: warn-unreachable
+import enum
+from typing import Literal
+
+class E(enum.Enum):
+    zero = 0
+    one = 1
+
+def print(s: str) -> None: ...
+
+if E.zero:
+    print("zero is true")
+if not E.zero:
+    print("zero is false")  # E: Statement is unreachable
+
+if E.one:
+    print("one is true")
+if not E.one:
+    print("one is false")  # E: Statement is unreachable
+
+def main(zero: Literal[E.zero], one: Literal[E.one]) -> None:
+    if zero:
+        print("zero is true")
+    if not zero:
+        print("zero is false")  # E: Statement is unreachable
+    if one:
+        print("one is true")
+    if not one:
+        print("one is false")  # E: Statement is unreachable
+[builtins fixtures/tuple.pyi]
+
+[case testEnumTruthynessCustomDunderBool]
+# mypy: warn-unreachable
+import enum
+from typing import Literal
+
+class E(enum.Enum):
+    zero = 0
+    one = 1
+    def __bool__(self) -> Literal[False]:
+        return False
+
+def print(s: str) -> None: ...
+
+if E.zero:
+    print("zero is true")  # E: Statement is unreachable
+if not E.zero:
+    print("zero is false")
+
+if E.one:
+    print("one is true")  # E: Statement is unreachable
+if not E.one:
+    print("one is false")
+
+def main(zero: Literal[E.zero], one: Literal[E.one]) -> None:
+    if zero:
+        print("zero is true")  # E: Statement is unreachable
+    if not zero:
+        print("zero is false")
+    if one:
+        print("one is true")  # E: Statement is unreachable
+    if not one:
+        print("one is false")
+[builtins fixtures/enum.pyi]
+
+[case testEnumTruthynessStrEnum]
+# mypy: warn-unreachable
+import enum
+from typing import Literal
+
+class E(enum.StrEnum):
+    empty = ""
+    not_empty = "asdf"
+
+def print(s: str) -> None: ...
+
+if E.empty:
+    print("empty is true")
+if not E.empty:
+    print("empty is false")
+
+if E.not_empty:
+    print("not_empty is true")
+if not E.not_empty:
+    print("not_empty is false")
+
+def main(empty: Literal[E.empty], not_empty: Literal[E.not_empty]) -> None:
+    if empty:
+        print("empty is true")
+    if not empty:
+        print("empty is false")
+    if not_empty:
+        print("not_empty is true")
+    if not not_empty:
+        print("not_empty is false")
+[builtins fixtures/enum.pyi]
+
 [case testEnumUnique]
 import enum
 @enum.unique
@@ -183,6 +284,7 @@ class E(enum.Enum):
     y = 1  # NOTE: This duplicate value is not detected by mypy at the moment
 x = 1
 x = E.x
+[builtins fixtures/enum.pyi]
 [out]
 main:7: error: Incompatible types in assignment (expression has type "E", variable has type "int")
 
@@ -197,6 +299,7 @@ if int():
 s = ''
 if int():
     s = N.y # E: Incompatible types in assignment (expression has type "N", variable has type "str")
+[builtins fixtures/enum.pyi]
 
 [case testIntEnum_functionTakingIntEnum]
 from enum import IntEnum
@@ -207,6 +310,7 @@ def takes_some_int_enum(n: SomeIntEnum):
 takes_some_int_enum(SomeIntEnum.x)
 takes_some_int_enum(1)  # Error
 takes_some_int_enum(SomeIntEnum(1))  # How to deal with the above
+[builtins fixtures/enum.pyi]
 [out]
 main:7: error: Argument 1 to "takes_some_int_enum" has incompatible type "int"; expected "SomeIntEnum"
 
@@ -218,6 +322,7 @@ def takes_int(i: int):
     pass
 takes_int(SomeIntEnum.x)
 takes_int(2)
+[builtins fixtures/enum.pyi]
 
 [case testIntEnum_functionReturningIntEnum]
 from enum import IntEnum
@@ -230,6 +335,7 @@ an_int = returns_some_int_enum()
 
 an_enum = SomeIntEnum.x
 an_enum = returns_some_int_enum()
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testStrEnumCreation]
@@ -244,6 +350,7 @@ reveal_type(MyStrEnum.x)  # N: Revealed type is "Literal[__main__.MyStrEnum.x]?"
 reveal_type(MyStrEnum.x.value)  # N: Revealed type is "Literal['x']?"
 reveal_type(MyStrEnum.y)  # N: Revealed type is "Literal[__main__.MyStrEnum.y]?"
 reveal_type(MyStrEnum.y.value)  # N: Revealed type is "Literal['y']?"
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testEnumMethods]
@@ -278,6 +385,7 @@ takes_int(SomeExtIntEnum.x)
 def takes_some_ext_int_enum(s: SomeExtIntEnum):
     pass
 takes_some_ext_int_enum(SomeExtIntEnum.x)
+[builtins fixtures/enum.pyi]
 
 [case testNamedTupleEnum]
 from typing import NamedTuple
@@ -297,8 +405,9 @@ f(E.X)
 from enum import IntEnum
 class E(IntEnum):
     a = 1
-x = None  # type: int
+x: int
 reveal_type(E(x))
+[builtins fixtures/tuple.pyi]
 [out]
 main:5: note: Revealed type is "__main__.E"
 
@@ -306,8 +415,9 @@ 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])
+[builtins fixtures/enum.pyi]
 [out]
 main:5: note: Revealed type is "__main__.E"
 
@@ -317,6 +427,7 @@ class E(IntEnum):
     a = 1
 E[1]  # E: Enum index should be a string (actual index type "int")
 x = E[1]  # E: Enum index should be a string (actual index type "int")
+[builtins fixtures/enum.pyi]
 
 [case testEnumIndexIsNotAnAlias]
 from enum import Enum
@@ -334,6 +445,7 @@ def get_member(name: str) -> E:
     return val
 
 reveal_type(get_member('a'))  # N: Revealed type is "__main__.E"
+[builtins fixtures/enum.pyi]
 
 [case testGenericEnum]
 from enum import Enum
@@ -346,6 +458,7 @@ class F(Generic[T], Enum):  # E: Enum class cannot be generic
     y: T
 
 reveal_type(F[int].x)  # N: Revealed type is "__main__.F[builtins.int]"
+[builtins fixtures/enum.pyi]
 
 [case testEnumFlag]
 from enum import Flag
@@ -357,6 +470,7 @@ if int():
     x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "C")
 if int():
     x = x | C.b
+[builtins fixtures/enum.pyi]
 
 [case testEnumIntFlag]
 from enum import IntFlag
@@ -368,6 +482,7 @@ if int():
     x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "C")
 if int():
     x = x | C.b
+[builtins fixtures/enum.pyi]
 
 [case testAnonymousEnum]
 from enum import Enum
@@ -378,6 +493,7 @@ class A:
         self.x = E.a
 a = A()
 reveal_type(a.x)
+[builtins fixtures/enum.pyi]
 [out]
 main:8: note: Revealed type is "__main__.E@4"
 
@@ -393,6 +509,7 @@ x = A.E.a
 y = B.E.a
 if int():
     x = y # E: Incompatible types in assignment (expression has type "__main__.B.E", variable has type "__main__.A.E")
+[builtins fixtures/enum.pyi]
 
 [case testFunctionalEnumString]
 from enum import Enum, IntEnum
@@ -402,6 +519,7 @@ reveal_type(E.foo)
 reveal_type(E.bar.value)
 reveal_type(I.bar)
 reveal_type(I.baz.value)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Any"
@@ -414,6 +532,7 @@ E = Enum('E', ('foo', 'bar'))
 F = IntEnum('F', ['bar', 'baz'])
 reveal_type(E.foo)
 reveal_type(F.baz)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Literal[__main__.F.baz]?"
@@ -426,6 +545,7 @@ reveal_type(E.foo)
 reveal_type(F.baz)
 reveal_type(E.foo.value)
 reveal_type(F.bar.name)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Literal[__main__.F.baz]?"
@@ -440,6 +560,7 @@ reveal_type(E.foo)
 reveal_type(F.baz)
 reveal_type(E.foo.value)
 reveal_type(F.bar.name)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Literal[__main__.F.baz]?"
@@ -452,55 +573,41 @@ from enum import Enum, IntEnum
 
 PictureSize = Enum('PictureSize', 'P0 P1 P2 P3 P4 P5 P6 P7 P8', type=str, module=__name__)
 fake_enum1 = Enum('fake_enum1', ['a', 'b'])
-fake_enum2 = Enum('fake_enum1', names=['a', 'b'])
-fake_enum3 = Enum(value='fake_enum1', names=['a', 'b'])
-fake_enum4 = Enum(value='fake_enum1', names=['a', 'b'] , module=__name__)
+fake_enum2 = Enum('fake_enum2', names=['a', 'b'])
+fake_enum3 = Enum(value='fake_enum3', names=['a', 'b'])
+fake_enum4 = Enum(value='fake_enum4', names=['a', 'b'] , module=__name__)
+[builtins fixtures/enum.pyi]
 
 [case testFunctionalEnumErrors]
 from enum import Enum, IntEnum
-A = Enum('A')
-B = Enum('B', 42)
-C = Enum('C', 'a b', 'x', 'y', 'z', 'p', 'q')
-D = Enum('D', foo)
+A = Enum('A')  # E: Too few arguments for Enum()
+B = Enum('B', 42)  # E: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members
+C = Enum('C', 'a b', 'x', 'y', 'z', 'p', 'q')  # E: Too many arguments for Enum()
+D = Enum('D', foo)  # E: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members \
+                    # E: Name "foo" is not defined
 bar = 'x y z'
-E = Enum('E', bar)
-I = IntEnum('I')
-J = IntEnum('I', 42)
-K = IntEnum('I', 'p q', 'x', 'y', 'z', 'p', 'q')
-L = Enum('L', ' ')
-M = Enum('M', ())
-N = IntEnum('M', [])
-P = Enum('P', [42])
-Q = Enum('Q', [('a', 42, 0)])
-R = IntEnum('R', [[0, 42]])
-S = Enum('S', {1: 1})
-T = Enum('T', keyword='a b')
-U = Enum('U', *['a'])
-V = Enum('U', **{'a': 1})
+E = Enum('E', bar)  # E: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members
+I = IntEnum('I')  # E: Too few arguments for IntEnum()
+J = IntEnum('I', 42)  # E: Second argument of IntEnum() must be string, tuple, list or dict literal for mypy to determine Enum members
+K = IntEnum('I', 'p q', 'x', 'y', 'z', 'p', 'q')  # E: Too many arguments for IntEnum()
+L = Enum('L', ' ')  # E: Enum() needs at least one item
+M = Enum('M', ())  # E: Enum() needs at least one item
+N = IntEnum('M', [])  # E: IntEnum() needs at least one item
+P = Enum('P', [42])  # E: Enum() with tuple or list expects strings or (name, value) pairs
+Q = Enum('Q', [('a', 42, 0)])  # E: Enum() with tuple or list expects strings or (name, value) pairs
+R = IntEnum('R', [[0, 42]])  # E: IntEnum() with tuple or list expects strings or (name, value) pairs
+S = Enum('S', {1: 1})  # E: Enum() with dict literal requires string literals
+T = Enum('T', keyword='a b')  # E: Unexpected keyword argument "keyword"
+U = Enum('U', *['a'])  # E: Unexpected arguments to Enum()
+V = Enum('U', **{'a': 1})  # E: Unexpected arguments to Enum()
 W = Enum('W', 'a b')
-W.c
+W.c  # E: "Type[W]" has no attribute "c"
+X = Enum('Something', 'a b')  # E: String argument 1 "Something" to enum.Enum(...) does not match variable name "X"
+reveal_type(X.a)  # N: Revealed type is "Literal[__main__.Something@23.a]?"
+X.asdf  # E: "Type[Something@23]" has no attribute "asdf"
+
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
-[out]
-main:2: error: Too few arguments for Enum()
-main:3: error: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members
-main:4: error: Too many arguments for Enum()
-main:5: error: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members
-main:5: error: Name "foo" is not defined
-main:7: error: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members
-main:8: error: Too few arguments for IntEnum()
-main:9: error: Second argument of IntEnum() must be string, tuple, list or dict literal for mypy to determine Enum members
-main:10: error: Too many arguments for IntEnum()
-main:11: error: Enum() needs at least one item
-main:12: error: Enum() needs at least one item
-main:13: error: IntEnum() needs at least one item
-main:14: error: Enum() with tuple or list expects strings or (name, value) pairs
-main:15: error: Enum() with tuple or list expects strings or (name, value) pairs
-main:16: error: IntEnum() with tuple or list expects strings or (name, value) pairs
-main:17: error: Enum() with dict literal requires string literals
-main:18: error: Unexpected keyword argument "keyword"
-main:19: error: Unexpected arguments to Enum()
-main:20: error: Unexpected arguments to Enum()
-main:22: error: "Type[W]" has no attribute "c"
 
 [case testFunctionalEnumFlag]
 from enum import Flag, IntFlag
@@ -514,6 +621,7 @@ reveal_type(B.a.name)   # N: Revealed type is "Literal['a']?"
 # TODO: The revealed type should be 'int' here
 reveal_type(A.x.value)  # N: Revealed type is "Any"
 reveal_type(B.a.value)  # N: Revealed type is "Any"
+[builtins fixtures/enum.pyi]
 
 [case testAnonymousFunctionalEnum]
 from enum import Enum
@@ -523,6 +631,7 @@ class A:
         self.x = E.a
 a = A()
 reveal_type(a.x)
+[builtins fixtures/enum.pyi]
 [out]
 main:7: note: Revealed type is "__main__.A.E@4"
 
@@ -536,6 +645,7 @@ x = A.E.a
 y = B.E.a
 if int():
     x = y # E: Incompatible types in assignment (expression has type "__main__.B.E", variable has type "__main__.A.E")
+[builtins fixtures/enum.pyi]
 
 [case testFunctionalEnumProtocols]
 from enum import IntEnum
@@ -553,6 +663,7 @@ a: E = E.x  # type: ignore[used-before-def]
 class E(Enum):
     x = 1
     y = 2
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testEnumWorkWithForward2]
@@ -563,6 +674,7 @@ F = Enum('F', {'x': 1, 'y': 2})
 def fn(x: F) -> None:
     pass
 fn(b)
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testFunctionalEnum]
@@ -580,6 +692,7 @@ Gu.a
 Gb.a
 Hu.a
 Hb.a
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testEnumIncremental]
@@ -592,6 +705,7 @@ class E(Enum):
     a = 1
     b = 2
 F = Enum('F', 'a b')
+[builtins fixtures/enum.pyi]
 [rechecked]
 [stale]
 [out1]
@@ -612,7 +726,7 @@ reveal_type(Test.a)  # N: Revealed type is "Literal[__main__.Test.a]?"
 
 [case testEnumAttributeAccessMatrix]
 from enum import Enum, IntEnum, IntFlag, Flag, EnumMeta, auto
-from typing_extensions import Literal
+from typing import Literal
 
 def is_x(val: Literal['x']) -> None: pass
 
@@ -750,6 +864,7 @@ class SomeEnum(Enum):
 from enum import Enum
 class SomeEnum(Enum):
     a = "foo"
+[builtins fixtures/enum.pyi]
 [out]
 main:2: note: Revealed type is "Literal[1]?"
 [out2]
@@ -757,7 +872,7 @@ main:2: note: Revealed type is "Literal['foo']?"
 
 [case testEnumReachabilityChecksBasic]
 from enum import Enum
-from typing_extensions import Literal
+from typing import Literal
 
 class Foo(Enum):
     A = 1
@@ -773,7 +888,7 @@ elif x is Foo.C:
     reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.C]"
 else:
     reveal_type(x)  # No output here: this branch is unreachable
-reveal_type(x) # N: Revealed type is "__main__.Foo"
+reveal_type(x) # N: Revealed type is "Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B], Literal[__main__.Foo.C]]"
 
 if Foo.A is x:
     reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.A]"
@@ -783,7 +898,7 @@ elif Foo.C is x:
     reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.C]"
 else:
     reveal_type(x)  # No output here: this branch is unreachable
-reveal_type(x) # N: Revealed type is "__main__.Foo"
+reveal_type(x) # N: Revealed type is "Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B], Literal[__main__.Foo.C]]"
 
 y: Foo
 if y is Foo.A:
@@ -809,7 +924,7 @@ reveal_type(y) # N: Revealed type is "__main__.Foo"
 
 [case testEnumReachabilityChecksWithOrdering]
 from enum import Enum
-from typing_extensions import Literal
+from typing import Literal
 
 class Foo(Enum):
     _order_ = "A B"
@@ -860,7 +975,7 @@ else:
 
 [case testEnumReachabilityChecksIndirect]
 from enum import Enum
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 
 class Foo(Enum):
     A = 1
@@ -925,7 +1040,7 @@ else:
 
 [case testEnumReachabilityNoNarrowingForUnionMessiness]
 from enum import Enum
-from typing_extensions import Literal
+from typing import Literal
 
 class Foo(Enum):
     A = 1
@@ -953,7 +1068,6 @@ else:
 [builtins fixtures/bool.pyi]
 
 [case testEnumReachabilityWithNone]
-# flags: --strict-optional
 from enum import Enum
 from typing import Optional
 
@@ -966,7 +1080,7 @@ x: Optional[Foo]
 if x:
     reveal_type(x)  # N: Revealed type is "__main__.Foo"
 else:
-    reveal_type(x)  # N: Revealed type is "Union[__main__.Foo, None]"
+    reveal_type(x)  # N: Revealed type is "None"
 
 if x is not None:
     reveal_type(x)  # N: Revealed type is "__main__.Foo"
@@ -978,12 +1092,11 @@ if x is Foo.A:
 else:
     reveal_type(x)  # N: Revealed type is "Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C], None]"
 reveal_type(x) # N: Revealed type is "Union[__main__.Foo, None]"
-[builtins fixtures/bool.pyi]
+[builtins fixtures/enum.pyi]
 
 [case testEnumReachabilityWithMultipleEnums]
 from enum import Enum
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 class Foo(Enum):
     A = 1
@@ -1016,9 +1129,7 @@ reveal_type(x3) # N: Revealed type is "Union[__main__.Foo, __main__.Bar]"
 [builtins fixtures/bool.pyi]
 
 [case testEnumReachabilityPEP484ExampleWithFinal]
-# flags: --strict-optional
-from typing import Union
-from typing_extensions import Final
+from typing import Final, Union
 from enum import Enum
 
 class Empty(Enum):
@@ -1028,7 +1139,7 @@ _empty: Final = Empty.token
 def func(x: Union[int, None, Empty] = _empty) -> int:
     boom = x + 42       # E: Unsupported left operand type for + ("None") \
                         # E: Unsupported left operand type for + ("Empty") \
-                        # N: Left operand is of type "Union[int, None, Empty]"
+                        # N: Left operand is of type "Union[int, Empty, None]"
     if x is _empty:
         reveal_type(x)  # N: Revealed type is "Literal[__main__.Empty.token]"
         return 0
@@ -1063,9 +1174,7 @@ def process(response: Union[str, Reason] = '') -> str:
 
 
 [case testEnumReachabilityPEP484ExampleSingleton]
-# flags: --strict-optional
-from typing import Union
-from typing_extensions import Final
+from typing import Final, Union
 from enum import Enum
 
 class Empty(Enum):
@@ -1075,7 +1184,7 @@ _empty = Empty.token
 def func(x: Union[int, None, Empty] = _empty) -> int:
     boom = x + 42       # E: Unsupported left operand type for + ("None") \
                         # E: Unsupported left operand type for + ("Empty") \
-                        # N: Left operand is of type "Union[int, None, Empty]"
+                        # N: Left operand is of type "Union[int, Empty, None]"
     if x is _empty:
         reveal_type(x)  # N: Revealed type is "Literal[__main__.Empty.token]"
         return 0
@@ -1088,23 +1197,25 @@ def func(x: Union[int, None, Empty] = _empty) -> int:
 [builtins fixtures/primitives.pyi]
 
 [case testEnumReachabilityPEP484ExampleSingletonWithMethod]
-# flags: --strict-optional
-from typing import Union
-from typing_extensions import Final
-from enum import Enum
+# flags: --python-version 3.11
+from typing import Final, Union
+from enum import Enum, member
 
 class Empty(Enum):
-    token = lambda x: x
+    # note, that without `member` we cannot tell that `token` is a member:
+    token = member(lambda x: x)
 
     def f(self) -> int:
         return 1
 
 _empty = Empty.token
+reveal_type(_empty)  # N: Revealed type is "__main__.Empty"
+reveal_type(Empty.f) # N: Revealed type is "def (self: __main__.Empty) -> builtins.int"
 
 def func(x: Union[int, None, Empty] = _empty) -> int:
     boom = x + 42       # E: Unsupported left operand type for + ("None") \
                         # E: Unsupported left operand type for + ("Empty") \
-                        # N: Left operand is of type "Union[int, None, Empty]"
+                        # N: Left operand is of type "Union[int, Empty, None]"
     if x is _empty:
         reveal_type(x)  # N: Revealed type is "Literal[__main__.Empty.token]"
         return 0
@@ -1121,9 +1232,10 @@ from enum import Enum
 
 class A:
     def __init__(self) -> None:
-        self.b = Enum("x", [("foo", "bar")])  # E: Enum type as attribute is not supported
+        self.b = Enum("b", [("foo", "bar")])  # E: Enum type as attribute is not supported
 
 reveal_type(A().b)  # N: Revealed type is "Any"
+[builtins fixtures/enum.pyi]
 
 [case testEnumReachabilityWithChaining]
 from enum import Enum
@@ -1219,7 +1331,7 @@ reveal_type(x)      # N: Revealed type is "__main__.Foo"
 [case testEnumReachabilityWithChainingDirectConflict]
 # flags: --warn-unreachable
 from enum import Enum
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 
 class Foo(Enum):
     A = 1
@@ -1254,7 +1366,7 @@ reveal_type(x)      # N: Revealed type is "__main__.Foo"
 [case testEnumReachabilityWithChainingBigDisjoints]
 # flags: --warn-unreachable
 from enum import Enum
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 
 class Foo(Enum):
     A = 1
@@ -1327,6 +1439,7 @@ class Foo(Enum):
 a = Foo.A
 reveal_type(a.value)    # N: Revealed type is "Union[Literal[1]?, Literal[2]?]"
 reveal_type(a._value_)  # N: Revealed type is "Union[Literal[1]?, Literal[2]?]"
+[builtins fixtures/enum.pyi]
 
 [case testNewSetsUnexpectedValueType]
 from enum import Enum
@@ -1345,7 +1458,7 @@ class Foo(bytes, Enum):
 a = Foo.A
 reveal_type(a.value)    # N: Revealed type is "Any"
 reveal_type(a._value_)  # N: Revealed type is "Any"
-[builtins fixtures/primitives.pyi]
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
 
 [case testValueTypeWithNewInParentClass]
@@ -1375,8 +1488,7 @@ reveal_type(a._value_)  # N: Revealed type is "Any"
 # as the full type, regardless of the amount of elements
 # the enum contains.
 from enum import Enum
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 class Foo(Enum):
     A = 1
@@ -1394,7 +1506,7 @@ def f(x: Foo):
 
 [case testEnumTypeCompatibleWithLiteralUnion]
 from enum import Enum
-from typing_extensions import Literal
+from typing import Literal
 
 class E(Enum):
     A = 1
@@ -1418,6 +1530,7 @@ class E(IntEnum):
     A = N(0)
 
 reveal_type(E.A.value) # N: Revealed type is "__main__.N"
+[builtins fixtures/enum.pyi]
 
 
 [case testEnumFinalValues]
@@ -1430,6 +1543,7 @@ class Medal(Enum):
 Medal.gold = 0  # E: Cannot assign to final attribute "gold"
 # Same value:
 Medal.silver = 2  # E: Cannot assign to final attribute "silver"
+[builtins fixtures/enum.pyi]
 
 
 [case testEnumFinalValuesCannotRedefineValueProp]
@@ -1437,6 +1551,7 @@ from enum import Enum
 class Types(Enum):
     key = 0
     value = 1
+[builtins fixtures/enum.pyi]
 
 
 [case testEnumReusedKeys]
@@ -1445,6 +1560,10 @@ from enum import Enum
 class Correct(Enum):
     x = 'y'
     y = 'x'
+class Correct2(Enum):
+    x = 'y'
+    __z = 'y'
+    __z = 'x'
 class Foo(Enum):
     A = 1
     A = 'a'  # E: Attempted to reuse member name "A" in Enum definition "Foo" \
@@ -1500,6 +1619,65 @@ class ErrorIntFlagWithoutValue(NonEmptyIntFlag):  # E: Cannot extend enum with e
     pass
 [builtins fixtures/bool.pyi]
 
+[case testEnumImplicitlyFinalForSubclassingWithCallableMember]
+# flags: --python-version 3.11
+from enum import Enum, IntEnum, Flag, IntFlag, member
+
+class NonEmptyEnum(Enum):
+    @member
+    def call(self) -> None: ...
+class NonEmptyIntEnum(IntEnum):
+    @member
+    def call(self) -> None: ...
+class NonEmptyFlag(Flag):
+    @member
+    def call(self) -> None: ...
+class NonEmptyIntFlag(IntFlag):
+    @member
+    def call(self) -> None: ...
+
+class ErrorEnumWithoutValue(NonEmptyEnum):  # E: Cannot extend enum with existing members: "NonEmptyEnum"
+    pass
+class ErrorIntEnumWithoutValue(NonEmptyIntEnum):  # E: Cannot extend enum with existing members: "NonEmptyIntEnum"
+    pass
+class ErrorFlagWithoutValue(NonEmptyFlag):  # E: Cannot extend enum with existing members: "NonEmptyFlag"
+    pass
+class ErrorIntFlagWithoutValue(NonEmptyIntFlag):  # E: Cannot extend enum with existing members: "NonEmptyIntFlag"
+    pass
+[builtins fixtures/bool.pyi]
+
+[case testEnumCanExtendEnumsWithNonMembers]
+# flags: --python-version 3.11
+from enum import Enum, IntEnum, Flag, IntFlag, nonmember
+
+class NonEmptyEnum(Enum):
+    x = nonmember(1)
+class NonEmptyIntEnum(IntEnum):
+    x = nonmember(1)
+class NonEmptyFlag(Flag):
+    x = nonmember(1)
+class NonEmptyIntFlag(IntFlag):
+    x = nonmember(1)
+
+class ErrorEnumWithoutValue(NonEmptyEnum):
+    pass
+class ErrorIntEnumWithoutValue(NonEmptyIntEnum):
+    pass
+class ErrorFlagWithoutValue(NonEmptyFlag):
+    pass
+class ErrorIntFlagWithoutValue(NonEmptyIntFlag):
+    pass
+[builtins fixtures/bool.pyi]
+
+[case testLambdaIsNotEnumMember]
+from enum import Enum
+
+class My(Enum):
+    x = lambda a: a
+
+class Other(My): ...
+[builtins fixtures/bool.pyi]
+
 [case testSubclassingNonFinalEnums]
 from enum import Enum, IntEnum, Flag, IntFlag, EnumMeta
 
@@ -1724,6 +1902,10 @@ from enum import Enum
 class A(Enum):
     class Inner: pass
 class B(A): pass  # E: Cannot extend enum with existing members: "A"
+
+class A1(Enum):
+    class __Inner: pass
+class B1(A1): pass
 [builtins fixtures/bool.pyi]
 
 [case testEnumFinalSpecialProps]
@@ -1780,7 +1962,8 @@ class B(A):
     x = 1  # E: Cannot override writable attribute "x" with a final one
 
 class A1(Enum):
-    x: int = 1
+    x: int = 1  # E: Enum members must be left unannotated \
+                # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members
 class B1(A1):  # E: Cannot extend enum with existing members: "A1"
     pass
 
@@ -1795,6 +1978,7 @@ class A3(Enum):
     x: Final[int]  # type: ignore
 class B3(A3):
     x = 1  # E: Cannot override final attribute "x" (previously declared in base class "A3")
+
 [builtins fixtures/bool.pyi]
 
 [case testEnumNotFinalWithMethodsAndUninitializedValuesStub]
@@ -1802,17 +1986,32 @@ import lib
 
 [file lib.pyi]
 from enum import Enum
-class A(Enum):
+class A(Enum):  # E: Detected enum "lib.A" in a type stub with zero members. There is a chance this is due to a recent change in the semantics of enum membership. If so, use `member = value` to mark an enum member, instead of `member: type` \
+                # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members
     x: int
-class B(A):  # E: Cannot extend enum with existing members: "A"
+class B(A):
     x = 1    # E: Cannot override writable attribute "x" with a final one
 
 class C(Enum):
     x = 1
-class D(C):  # E: Cannot extend enum with existing members: "C"
+class D(C):  # E: Cannot extend enum with existing members: "C" \
+             # E: Detected enum "lib.D" in a type stub with zero members. There is a chance this is due to a recent change in the semantics of enum membership. If so, use `member = value` to mark an enum member, instead of `member: type` \
+             # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members
     x: int   # E: Cannot assign to final name "x"
 [builtins fixtures/bool.pyi]
 
+[case testEnumNotFinalWithMethodsAndUninitializedValuesStubMember]
+# flags: --python-version 3.11
+# This was added in 3.11
+import lib
+
+[file lib.pyi]
+from enum import Enum, member
+class A(Enum):
+    @member
+    def x(self) -> None: ...
+[builtins fixtures/bool.pyi]
+
 [case testEnumLiteralValues]
 from enum import Enum
 
@@ -2046,7 +2245,7 @@ class C(Enum):
     _ignore_ = 'X'
 
 C._ignore_ # E: "Type[C]" has no attribute "_ignore_"
-[typing fixtures/typing-medium.pyi]
+[builtins fixtures/enum.pyi]
 
 [case testCanOverrideDunderAttributes]
 import typing
@@ -2111,7 +2310,7 @@ class Mixed(Enum):
         reveal_type(Mixed.b.value)  # N: Revealed type is "None"
 
         # Inferring Any here instead of a union seems to be a deliberate
-        # choice; see the testEnumValueInhomogenous case above.
+        # choice; see the testEnumValueInhomogeneous case above.
         reveal_type(self.value)  # N: Revealed type is "Any"
 
         for field in Mixed:
@@ -2125,3 +2324,203 @@ class AllPartialList(Enum):
 
     def check(self) -> None:
         reveal_type(self.value)  # N: Revealed type is "builtins.list[Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testEnumPrivateAttributeNotMember]
+from enum import Enum
+
+class MyEnum(Enum):
+    A = 1
+    B = 2
+    __my_dict = {A: "ham", B: "spam"}
+
+# TODO: change the next line to use MyEnum._MyEnum__my_dict when mypy implements name mangling
+x: MyEnum = MyEnum.__my_dict  # E: Incompatible types in assignment (expression has type "Dict[int, str]", variable has type "MyEnum")
+[builtins fixtures/enum.pyi]
+
+[case testEnumWithPrivateAttributeReachability]
+# flags: --warn-unreachable
+from enum import Enum
+
+class MyEnum(Enum):
+    A = 1
+    B = 2
+    __my_dict = {A: "ham", B: "spam"}
+
+e: MyEnum
+if e == MyEnum.A:
+    reveal_type(e)  # N: Revealed type is "Literal[__main__.MyEnum.A]"
+elif e == MyEnum.B:
+    reveal_type(e)  # N: Revealed type is "Literal[__main__.MyEnum.B]"
+else:
+    reveal_type(e)  # E: Statement is unreachable
+[builtins fixtures/dict.pyi]
+
+
+[case testEnumNonMemberSupport]
+# flags: --python-version 3.11
+# This was added in 3.11
+from enum import Enum, nonmember
+
+class My(Enum):
+    a = 1
+    b = 2
+    c = nonmember(3)
+
+reveal_type(My.a)  # N: Revealed type is "Literal[__main__.My.a]?"
+reveal_type(My.b)  # N: Revealed type is "Literal[__main__.My.b]?"
+reveal_type(My.c)  # N: Revealed type is "builtins.int"
+
+def accepts_my(my: My):
+    reveal_type(my.value)  # N: Revealed type is "Union[Literal[1]?, Literal[2]?]"
+
+class Other(Enum):
+    a = 1
+    @nonmember
+    class Support:
+        b = 2
+
+reveal_type(Other.a)  # N: Revealed type is "Literal[__main__.Other.a]?"
+reveal_type(Other.Support.b)  # N: Revealed type is "builtins.int"
+[builtins fixtures/dict.pyi]
+
+
+[case testEnumMemberSupport]
+# flags: --python-version 3.11
+# This was added in 3.11
+from enum import Enum, member
+
+class A(Enum):
+    x = member(1)
+    y = 2
+
+reveal_type(A.x)  # N: Revealed type is "Literal[__main__.A.x]?"
+reveal_type(A.x.value)  # N: Revealed type is "Literal[1]?"
+reveal_type(A.y)  # N: Revealed type is "Literal[__main__.A.y]?"
+reveal_type(A.y.value)  # N: Revealed type is "Literal[2]?"
+
+def some_a(a: A):
+    reveal_type(a.value)  # N: Revealed type is "Union[Literal[1]?, Literal[2]?]"
+[builtins fixtures/dict.pyi]
+
+
+[case testEnumMemberAndNonMemberSupport]
+# flags: --python-version 3.11 --warn-unreachable
+# This was added in 3.11
+from enum import Enum, member, nonmember
+
+class A(Enum):
+    x = 1
+    y = member(2)
+    z = nonmember(3)
+
+def some_a(a: A):
+    if a is not A.x and a is not A.z:
+        reveal_type(a)  # N: Revealed type is "Literal[__main__.A.y]"
+    if a is not A.y and a is not A.z:
+        reveal_type(a)  # N: Revealed type is "Literal[__main__.A.x]"
+    if a is not A.x:
+        reveal_type(a)  # N: Revealed type is "Literal[__main__.A.y]"
+    if a is not A.y:
+        reveal_type(a)  # N: Revealed type is "Literal[__main__.A.x]"
+[builtins fixtures/dict.pyi]
+
+
+[case testErrorOnAnnotatedMember]
+from enum import Enum
+
+class Medal(Enum):
+    gold: int = 1  # E: Enum members must be left unannotated \
+                   # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members
+    silver: str = 2  # E: Enum members must be left unannotated \
+                     # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members \
+                     # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+    bronze = 3
+[builtins fixtures/enum.pyi]
+
+[case testEnumMemberWithPlaceholder]
+from enum import Enum
+
+class Pet(Enum):
+    CAT = ...
+    DOG: str = ...  # E: Enum members must be left unannotated \
+                    # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members \
+                    # E: Incompatible types in assignment (expression has type "ellipsis", variable has type "str")
+[builtins fixtures/enum.pyi]
+
+[case testEnumValueWithPlaceholderNodeType]
+# https://github.com/python/mypy/issues/11971
+from enum import Enum
+from typing import Any, Callable, Dict
+class Foo(Enum):
+    Bar: Foo = Callable[[str], None]  # E: Enum members must be left unannotated \
+                                      # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members \
+                                      # E: Incompatible types in assignment (expression has type "<typing special form>", variable has type "Foo")
+    Baz: Any = Callable[[Dict[str, "Missing"]], None]  # E: Enum members must be left unannotated \
+                                                       # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members \
+                                                       # E: Type application targets a non-generic function or class \
+                                                       # E: Name "Missing" is not defined
+
+reveal_type(Foo.Bar)  # N: Revealed type is "Literal[__main__.Foo.Bar]?"
+reveal_type(Foo.Bar.value)  # N: Revealed type is "__main__.Foo"
+reveal_type(Foo.Baz)  # N: Revealed type is "Literal[__main__.Foo.Baz]?"
+reveal_type(Foo.Baz.value)  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+
+[case testEnumWithOnlyImplicitMembersUsingAnnotationOnly]
+# flags: --warn-unreachable
+import enum
+
+
+class E(enum.IntEnum):
+    A: int
+    B: int
+
+
+def do_check(value: E) -> None:
+    reveal_type(value)  # N: Revealed type is "__main__.E"
+    # this is a nonmember check, not an emum member check, and it should not narrow the value
+    if value is E.A:
+        return
+
+    reveal_type(value)  # N: Revealed type is "__main__.E"
+    "should be reachable"
+
+[builtins fixtures/primitives.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testStrEnumClassCorrectIterable]
+from enum import StrEnum
+from typing import Type, TypeVar
+
+class Choices(StrEnum):
+    LOREM = "lorem"
+    IPSUM = "ipsum"
+
+var = list(Choices)
+reveal_type(var)  # N: Revealed type is "builtins.list[__main__.Choices]"
+
+e: type[StrEnum]
+reveal_type(list(e))  # N: Revealed type is "builtins.list[enum.StrEnum]"
+
+T = TypeVar("T", bound=StrEnum)
+def list_vals(e: Type[T]) -> list[T]:
+    reveal_type(list(e))  # N: Revealed type is "builtins.list[T`-1]"
+    return list(e)
+
+reveal_type(list_vals(Choices))  # N: Revealed type is "builtins.list[__main__.Choices]"
+[builtins fixtures/enum.pyi]
+
+[case testEnumAsClassMemberNoCrash]
+# https://github.com/python/mypy/issues/18736
+from enum import Enum
+
+class Base:
+    def __init__(self, namespace: tuple[str, ...]) -> None:
+        # Not a bug: trigger defer
+        names = [name for name in namespace if fail]  # E: Name "fail" is not defined
+        self.o = Enum("o", names)  # E: Enum type as attribute is not supported \
+                                   # E: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-errorcodes.test b/test-data/unit/check-errorcodes.test
index 1e7dc9364855..21112b7d85a2 100644
--- a/test-data/unit/check-errorcodes.test
+++ b/test-data/unit/check-errorcodes.test
@@ -105,6 +105,19 @@ x # type: ignore[name-defined, attr-defined] # E: Unused "type: ignore[attr-defi
 # flags: --warn-unused-ignores
 "x" # type: ignore[name-defined] # E: Unused "type: ignore" comment  [unused-ignore]
 
+[case testErrorCodeWarnUnusedIgnores7_WarnWhenErrorCodeDisabled]
+# flags: --warn-unused-ignores --disable-error-code name-defined
+x              # type: ignore                              # E: Unused "type: ignore" comment  [unused-ignore]
+x              # type: ignore[name-defined]                # E: Unused "type: ignore" comment  [unused-ignore]
+"x".foobar(y)  # type: ignore[name-defined, attr-defined]  # E: Unused "type: ignore[name-defined]" comment  [unused-ignore]
+
+[case testErrorCodeWarnUnusedIgnores8_IgnoreUnusedIgnore]
+# flags: --warn-unused-ignores --disable-error-code name-defined
+"x"  # type: ignore[unused-ignore]
+"x"  # type: ignore[name-defined, unused-ignore]
+"x"  # type: ignore[xyz, unused-ignore]
+x    # type: ignore[name-defined, unused-ignore]
+
 [case testErrorCodeMissingWhenRequired]
 # flags: --enable-error-code ignore-without-code
 "x" # type: ignore # E: "type: ignore" comment without error code  [ignore-without-code]
@@ -124,10 +137,10 @@ z # type: ignore[ignore-without-code] # E: Unused "type: ignore" comment  [unuse
 # flags: --enable-error-code ignore-without-code
 # type: ignore  # whole file ignore
 x
-y # type: ignore  # ignore the lack of error code since we're ignore the whole file
+y # type: ignore  # ignore the lack of error code since we ignore the whole file
 
 [case testErrorCodeMissingMultiple]
-# flags: --enable-error-code ignore-without-code --python-version 3.7
+# flags: --enable-error-code ignore-without-code
 from __future__ import annotations
 class A:
     attr: int
@@ -183,7 +196,7 @@ from defusedxml import xyz  # type: ignore[import]
 
 [case testErrorCodeBadIgnore]
 import nostub # type: ignore xyz  # E: Invalid "type: ignore" comment  [syntax] \
-                                  # E: Cannot find implementation or library stub for module named "nostub"  [import] \
+                                  # E: Cannot find implementation or library stub for module named "nostub"  [import-not-found] \
                                   # N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
 import nostub # type: ignore[  # E: Invalid "type: ignore" comment  [syntax]
 import nostub # type: ignore[foo  # E: Invalid "type: ignore" comment  [syntax]
@@ -211,7 +224,7 @@ def f(x,  # type: int  # type: ignore[
     pass
 [out]
 main:2: error: Invalid "type: ignore" comment  [syntax]
-main:2: error: Cannot find implementation or library stub for module named "nostub"  [import]
+main:2: error: Cannot find implementation or library stub for module named "nostub"  [import-not-found]
 main:2: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
 main:3: error: Invalid "type: ignore" comment  [syntax]
 main:4: error: Invalid "type: ignore" comment  [syntax]
@@ -328,7 +341,7 @@ a: A
 a.x = ''  # E: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]
 
 [case testErrorCodeMissingTypeArg]
-# flags: --disallow-any-generics
+# flags: --python-version 3.8 --disallow-any-generics
 from typing import List, TypeVar
 x: List  # E: Missing type parameters for generic type "List"  [type-arg]
 y: list  # E: Implicit generic "Any". Use "typing.List" and specify generic parameters  [type-arg]
@@ -449,7 +462,7 @@ y: Dict[int, int] = {1: ''}  # E: Dict entry 0 has incompatible type "int": "str
 [builtins fixtures/dict.pyi]
 
 [case testErrorCodeTypedDict]
-from typing_extensions import TypedDict
+from typing import TypedDict
 class D(TypedDict):
     x: int
 class E(TypedDict):
@@ -460,7 +473,7 @@ a: D = {'x': ''}  # E: Incompatible types (expression has type "str", TypedDict
 b: D = {'y': ''}  # E: Missing key "x" for TypedDict "D"  [typeddict-item] \
                   # E: Extra key "y" for TypedDict "D"  [typeddict-unknown-key]
 c = D(x=0) if int() else E(x=0, y=0)
-c = {}  # E: Expected TypedDict key "x" but found no keys  [typeddict-item]
+c = {}  # E: Missing key "x" for TypedDict "D"  [typeddict-item]
 d: D = {'x': '', 'y': 1}  # E: Extra key "y" for TypedDict "D"  [typeddict-unknown-key] \
                           # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")  [typeddict-item]
 
@@ -472,7 +485,7 @@ a['y']  # E: TypedDict "D" has no key "y"  [typeddict-item]
 [typing fixtures/typing-typeddict.pyi]
 
 [case testErrorCodeTypedDictNoteIgnore]
-from typing_extensions import TypedDict
+from typing import TypedDict
 class A(TypedDict):
     one_commonpart: int
     two_commonparts: int
@@ -484,7 +497,7 @@ not_exist = a['not_exist'] # type: ignore[typeddict-item]
 [typing fixtures/typing-typeddict.pyi]
 
 [case testErrorCodeTypedDictSubCodeIgnore]
-from typing_extensions import TypedDict
+from typing import TypedDict
 class D(TypedDict):
     x: int
 d: D = {'x': 1, 'y': 2}  # type: ignore[typeddict-item]
@@ -522,13 +535,16 @@ if int() is str():  # E: Non-overlapping identity check (left operand type: "int
 [builtins fixtures/primitives.pyi]
 
 [case testErrorCodeMissingModule]
-from defusedxml import xyz  # E: Cannot find implementation or library stub for module named "defusedxml"  [import]
-from nonexistent import foobar  # E: Cannot find implementation or library stub for module named "nonexistent"  [import]
-import nonexistent2  # E: Cannot find implementation or library stub for module named "nonexistent2"  [import]
-from nonexistent3 import *  # E: Cannot find implementation or library stub for module named "nonexistent3"  [import]
+from defusedxml import xyz  # E: Library stubs not installed for "defusedxml"  [import-untyped] \
+                            # N: Hint: "python3 -m pip install types-defusedxml" \
+                            # N: (or run "mypy --install-types" to install all missing stub packages)
+from nonexistent import foobar  # E: Cannot find implementation or library stub for module named "nonexistent"  [import-not-found]
+import nonexistent2  # E: Cannot find implementation or library stub for module named "nonexistent2"  [import-not-found]
+from nonexistent3 import *  # E: Cannot find implementation or library stub for module named "nonexistent3"  [import-not-found]
 from pkg import bad  # E: Module "pkg" has no attribute "bad"  [attr-defined]
-from pkg.bad2 import bad3  # E: Cannot find implementation or library stub for module named "pkg.bad2"  [import] \
+from pkg.bad2 import bad3  # E: Cannot find implementation or library stub for module named "pkg.bad2"  [import-not-found] \
                            # N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
+
 [file pkg/__init__.py]
 
 [case testErrorCodeAlreadyDefined]
@@ -553,15 +569,15 @@ from typing import Callable
 
 def f() -> None: pass
 
-x = f()  # E: "f" does not return a value  [func-returns-value]
+x = f()  # E: "f" does not return a value (it only ever returns None)  [func-returns-value]
 
 class A:
     def g(self) -> None: pass
 
-y = A().g()  # E: "g" of "A" does not return a value  [func-returns-value]
+y = A().g()  # E: "g" of "A" does not return a value (it only ever returns None)  [func-returns-value]
 
 c: Callable[[], None]
-z = c()  # E: Function does not return a value  [func-returns-value]
+z = c()  # E: Function does not return a value (it only ever returns None)  [func-returns-value]
 
 [case testErrorCodeInstantiateAbstract]
 from abc import abstractmethod
@@ -649,7 +665,7 @@ def g() -> int:
 x: List[int]  # type: ignore[name-defined]
 
 [case testErrorCodeProtocolProblemsIgnore]
-from typing_extensions import Protocol
+from typing import Protocol
 
 class P(Protocol):
     def f(self, x: str) -> None: ...
@@ -726,13 +742,12 @@ main:2: error: Syntax error in type comment "int"  [syntax]
 [case testErrorCode__exit__Return]
 class InvalidReturn:
     def __exit__(self, x, y, z) -> bool:  # E: "bool" is invalid as return type for "__exit__" that always returns False  [exit-return] \
-# N: Use "typing_extensions.Literal[False]" as the return type or change it to "None" \
+# N: Use "typing.Literal[False]" as the return type or change it to "None" \
 # N: If return type of "__exit__" implies that it may return True, the context manager may swallow exceptions
         return False
 [builtins fixtures/bool.pyi]
 
 [case testErrorCodeOverloadedOperatorMethod]
-# flags: --strict-optional
 from typing import Optional, overload
 
 class A:
@@ -758,7 +773,6 @@ class C:
 x - C()  # type: ignore[operator]
 
 [case testErrorCodeMultiLineBinaryOperatorOperand]
-# flags: --strict-optional
 from typing import Optional
 
 class C: pass
@@ -830,13 +844,14 @@ Foo = NamedTuple("Bar", [])  # E: First argument to namedtuple() should be "Foo"
 [builtins fixtures/tuple.pyi]
 
 [case testTypedDictNameMismatch]
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 Foo = TypedDict("Bar", {})  # E: First argument "Bar" to TypedDict() does not match variable name "Foo"  [name-match]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTruthyBool]
-# flags: --enable-error-code truthy-bool
+# flags: --enable-error-code truthy-bool --no-local-partial-types
 from typing import List, Union, Any
 
 class Foo:
@@ -848,34 +863,48 @@ foo = Foo()
 if foo:  # E: "__main__.foo" has type "Foo" which does not implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
     pass
 
+not foo  # E: "__main__.foo" has type "Foo" which does not implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
+
 zero = 0
 if zero:
     pass
 
+not zero
+
 false = False
 if false:
     pass
 
+not false
+
 null = None
 if null:
     pass
 
+not null
+
 s = ''
 if s:
     pass
 
+not s
+
 good_union: Union[str, int] = 5
 if good_union:
     pass
 if not good_union:
     pass
 
+not good_union
+
 bad_union: Union[Foo, Bar] = Foo()
 if bad_union:  # E: "__main__.bad_union" has type "Union[Foo, Bar]" of which no members implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
     pass
 if not bad_union:  # E: "__main__.bad_union" has type "Union[Foo, Bar]" of which no members implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
     pass
 
+not bad_union  # E: "__main__.bad_union" has type "Union[Foo, Bar]" of which no members implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
+
 # 'object' is special and is treated as potentially falsy
 obj: object = Foo()
 if obj:
@@ -883,21 +912,34 @@ if obj:
 if not obj:
     pass
 
+not obj
+
 lst: List[int] = []
 if lst:
     pass
 
+not lst
+
 a: Any
 if a:
     pass
 
+not a
+
 any_or_object: Union[object, Any]
 if any_or_object:
     pass
+
+not any_or_object
+
+if (my_foo := Foo()):  # E: "__main__.my_foo" has type "Foo" which does not implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
+    pass
+
+if my_a := (a or Foo()):  # E: "__main__.Foo" returns "Foo" which does not implement __bool__ or __len__ so it could always be true in boolean context  [truthy-bool]
+    pass
 [builtins fixtures/list.pyi]
 
 [case testTruthyFunctions]
-# flags: --strict-optional
 def f():
     pass
 if f:  # E: Function "f" could always be true in boolean context  [truthy-function]
@@ -906,13 +948,17 @@ if not f:  # E: Function "f" could always be true in boolean context  [truthy-fu
     pass
 conditional_result = 'foo' if f else 'bar'  # E: Function "f" could always be true in boolean context  [truthy-function]
 
+not f  # E: Function "f" could always be true in boolean context  [truthy-function]
+
 [case testTruthyIterable]
-# flags: --strict-optional --enable-error-code truthy-iterable
+# flags: --enable-error-code truthy-iterable
 from typing import Iterable
 def func(var: Iterable[str]) -> None:
     if var:  # E: "var" has type "Iterable[str]" which can always be true in boolean context. Consider using "Collection[str]" instead.  [truthy-iterable]
         ...
 
+    not var  # E: "var" has type "Iterable[str]" which can always be true in boolean context. Consider using "Collection[str]" instead.  [truthy-iterable]
+
 [case testNoOverloadImplementation]
 from typing import overload
 
@@ -961,7 +1007,7 @@ reveal_type(t)  # N: Revealed type is "__main__.TensorType"
 [builtins fixtures/tuple.pyi]
 
 [case testNoteAboutChangedTypedDictErrorCode]
-from typing_extensions import TypedDict
+from typing import TypedDict
 class D(TypedDict):
     x: int
 
@@ -978,11 +1024,13 @@ def f(d: D, s: str) -> None:
 [typing fixtures/typing-typeddict.pyi]
 
 [case testRecommendErrorCode]
-# type: ignore[whatever]  # E: type ignore with error code is not supported for modules; use `# mypy: disable-error-code="whatever"`  [syntax]
+# type: ignore[whatever]  # E: type ignore with error code is not supported for modules; use `# mypy: disable-error-code="whatever"`  [syntax] \
+                          # N: Error code "syntax" not covered by "type: ignore" comment
 1 + "asdf"
 
 [case testRecommendErrorCode2]
-# type: ignore[whatever, other]  # E: type ignore with error code is not supported for modules; use `# mypy: disable-error-code="whatever, other"`  [syntax]
+# type: ignore[whatever, other]  # E: type ignore with error code is not supported for modules; use `# mypy: disable-error-code="whatever, other"`  [syntax] \
+                                 # N: Error code "syntax" not covered by "type: ignore" comment
 1 + "asdf"
 
 [case testShowErrorCodesInConfig]
@@ -995,7 +1043,6 @@ var: int = ""  # E: Incompatible types in assignment (expression has type "str",
 show_error_codes = True
 
 [case testErrorCodeUnsafeSuper_no_empty]
-# flags: --strict-optional
 from abc import abstractmethod
 
 class Base:
@@ -1008,7 +1055,6 @@ class Sub(Base):
 [builtins fixtures/exception.pyi]
 
 [case testDedicatedErrorCodeForEmpty_no_empty]
-# flags: --strict-optional
 from typing import Optional
 def foo() -> int: ...  # E: Missing return statement  [empty-body]
 def bar() -> None: ...
@@ -1077,3 +1123,133 @@ A.f = h  # type: ignore[assignment]  # E: Unused "type: ignore" comment, use nar
 [case testUnusedIgnoreEnableCode]
 # flags: --enable-error-code=unused-ignore
 x = 1  # type: ignore  # E: Unused "type: ignore" comment  [unused-ignore]
+
+[case testErrorCodeUnsafeOverloadError]
+from typing import overload, Union
+
+@overload
+def unsafe_func(x: int) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types  [overload-overlap]
+@overload
+def unsafe_func(x: object) -> str: ...
+def unsafe_func(x: object) -> Union[int, str]:
+    if isinstance(x, int):
+        return 42
+    else:
+        return "some string"
+[builtins fixtures/isinstancelist.pyi]
+
+
+###
+# unimported-reveal
+###
+
+[case testUnimportedRevealType]
+# flags: --enable-error-code=unimported-reveal
+x = 1
+reveal_type(x)
+[out]
+main:3: error: Name "reveal_type" is not defined  [unimported-reveal]
+main:3: note: Did you forget to import it from "typing_extensions"? (Suggestion: "from typing_extensions import reveal_type")
+main:3: note: Revealed type is "builtins.int"
+[builtins fixtures/isinstancelist.pyi]
+
+[case testUnimportedRevealTypePy311]
+# flags: --enable-error-code=unimported-reveal --python-version=3.11
+x = 1
+reveal_type(x)
+[out]
+main:3: error: Name "reveal_type" is not defined  [unimported-reveal]
+main:3: note: Did you forget to import it from "typing"? (Suggestion: "from typing import reveal_type")
+main:3: note: Revealed type is "builtins.int"
+[builtins fixtures/isinstancelist.pyi]
+
+[case testUnimportedRevealTypeInUncheckedFunc]
+# flags: --enable-error-code=unimported-reveal
+def unchecked():
+    x = 1
+    reveal_type(x)
+[out]
+main:4: error: Name "reveal_type" is not defined  [unimported-reveal]
+main:4: note: Did you forget to import it from "typing_extensions"? (Suggestion: "from typing_extensions import reveal_type")
+main:4: note: Revealed type is "Any"
+main:4: note: 'reveal_type' always outputs 'Any' in unchecked functions
+[builtins fixtures/isinstancelist.pyi]
+
+[case testUnimportedRevealTypeImportedTypingExtensions]
+# flags: --enable-error-code=unimported-reveal
+from typing_extensions import reveal_type
+x = 1
+reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/isinstancelist.pyi]
+
+[case testUnimportedRevealTypeImportedTyping311]
+# flags: --enable-error-code=unimported-reveal --python-version=3.11
+from typing import reveal_type
+x = 1
+reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testUnimportedRevealLocals]
+# flags: --enable-error-code=unimported-reveal
+x = 1
+reveal_locals()
+[out]
+main:3: note: Revealed local types are:
+main:3: note:     x: builtins.int
+main:3: error: Name "reveal_locals" is not defined  [unimported-reveal]
+[builtins fixtures/isinstancelist.pyi]
+
+[case testCovariantMutableOverride]
+# flags: --enable-error-code=mutable-override
+from typing import Any
+
+class C:
+    x: float
+    y: float
+    z: float
+    w: Any
+    @property
+    def foo(self) -> float: ...
+    @property
+    def bar(self) -> float: ...
+    @bar.setter
+    def bar(self, val: float) -> None: ...
+    baz: float
+    bad1: float
+    bad2: float
+class D(C):
+    x: int  # E: Covariant override of a mutable attribute (base class "C" defined the type as "float", expression has type "int")  [mutable-override]
+    y: float
+    z: Any
+    w: float
+    foo: int
+    bar: int  # E: Covariant override of a mutable attribute (base class "C" defined the type as "float", expression has type "int")  [mutable-override]
+    def one(self) -> None:
+        self.baz = 5
+    bad1 = 5  # E: Covariant override of a mutable attribute (base class "C" defined the type as "float", expression has type "int")  [mutable-override]
+    def other(self) -> None:
+        self.bad2: int = 5  # E: Covariant override of a mutable attribute (base class "C" defined the type as "float", expression has type "int")  [mutable-override]
+[builtins fixtures/property.pyi]
+
+[case testNarrowedTypeNotSubtype]
+from typing_extensions import TypeIs
+
+def f(x: str) -> TypeIs[int]:  # E: Narrowed type "int" is not a subtype of input type "str"  [narrowed-type-not-subtype]
+    pass
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testOverloadedFunctionSignature]
+from typing import overload, Union
+
+@overload
+def process(response1: float,response2: float) -> float:
+    ...
+@overload
+def process(response1: int,response2: int) -> int: # E: Overloaded function signature 2 will never be matched: signature 1's parameter type(s) are the same or broader  [overload-cannot-match]
+    ...
+
+def process(response1,response2)-> Union[float,int]:
+   return response1 + response2
diff --git a/test-data/unit/check-expressions.test b/test-data/unit/check-expressions.test
index 1fa551f6a2e4..81eb4c7c0dc8 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,11 +338,11 @@ 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"
+    reveal_type(j) # N: Revealed type is "Literal['']"
 [builtins fixtures/bool.pyi]
 
 [case testAndOr]
@@ -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,13 +980,12 @@ 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()
 
 [case testAssertType]
-from typing import assert_type, Any
-from typing_extensions import Literal
+from typing import assert_type, Any, Literal
 a: int = 1
 returned = assert_type(a, int)
 reveal_type(returned)  # N: Revealed type is "builtins.int"
@@ -942,8 +997,7 @@ assert_type(42, int)  # E: Expression is of type "Literal[42]", not "int"
 [builtins fixtures/tuple.pyi]
 
 [case testAssertTypeGeneric]
-from typing import assert_type, TypeVar, Generic
-from typing_extensions import Literal
+from typing import assert_type, Literal, TypeVar, Generic
 T = TypeVar("T")
 def f(x: T) -> T: return x
 assert_type(f(1), int)
@@ -956,25 +1010,23 @@ y: Gen[Literal[1]] = assert_type(Gen(1), Gen[Literal[1]])
 [builtins fixtures/tuple.pyi]
 
 [case testAssertTypeUncheckedFunction]
-from typing import assert_type
-from typing_extensions import Literal
+from typing import Literal, assert_type
 def f():
     x = 42
     assert_type(x, Literal[42])
 [out]
-main:5: error: Expression is of type "Any", not "Literal[42]"
-main:5: note: "assert_type" expects everything to be "Any" in unchecked functions
+main:4: error: Expression is of type "Any", not "Literal[42]"
+main:4: note: "assert_type" expects everything to be "Any" in unchecked functions
 [builtins fixtures/tuple.pyi]
 
 [case testAssertTypeUncheckedFunctionWithUntypedCheck]
 # flags: --check-untyped-defs
-from typing import assert_type
-from typing_extensions import Literal
+from typing import Literal, assert_type
 def f():
     x = 42
     assert_type(x, Literal[42])
 [out]
-main:6: error: Expression is of type "int", not "Literal[42]"
+main:5: error: Expression is of type "int", not "Literal[42]"
 [builtins fixtures/tuple.pyi]
 
 [case testAssertTypeNoPromoteUnion]
@@ -989,6 +1041,23 @@ def reduce_it(s: Scalar) -> Scalar:
 assert_type(reduce_it(True), Scalar)
 [builtins fixtures/tuple.pyi]
 
+[case testAssertTypeWithDeferredNodes]
+from typing import Callable, TypeVar, assert_type
+
+T = TypeVar("T")
+
+def dec(f: Callable[[], T]) -> Callable[[], T]:
+    return f
+
+def func() -> None:
+    some = _inner_func()
+    assert_type(some, int)
+
+@dec
+def _inner_func() -> int:
+    return 1
+[builtins fixtures/tuple.pyi]
+
 -- None return type
 -- ----------------
 
@@ -1003,17 +1072,18 @@ 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
+    a = f()         # E: "f" does not return a value (it only ever returns None)
 if int():
-    o = a()         # E: Function does not return a value
+    o = a()         # E: Function does not return a value (it only ever returns None)
 if int():
-    o = A().g(a)    # E: "g" of "A" does not return a value
+    o = A().g(a)    # E: "g" of "A" does not return a value (it only ever returns None)
 if int():
-    o = A.g(a, a)   # E: "g" of "A" does not return a value
-A().g(f())      # E: "f" does not return a value
-x: A = f()      # E: "f" does not return a value
+    o = A.g(a, a)   # E: "g" of "A" does not return a value (it only ever returns None)
+A().g(f())      # E: "f" does not return a value (it only ever returns None)
+x: A = f()      # E: "f" does not return a value (it only ever returns None)
 f()
 A().g(a)
 [builtins fixtures/tuple.pyi]
@@ -1022,15 +1092,15 @@ A().g(a)
 import typing
 def f() -> None: pass
 
-if f():   # E: "f" does not return a value
+if f():   # E: "f" does not return a value (it only ever returns None)
     pass
-elif f(): # E: "f" does not return a value
+elif f(): # E: "f" does not return a value (it only ever returns None)
     pass
-while f(): # E: "f" does not return a value
+while f(): # E: "f" does not return a value (it only ever returns None)
     pass
 def g() -> object:
-    return f() # E: "f" does not return a value
-raise f() # E: "f" does not return a value
+    return f() # E: "f" does not return a value (it only ever returns None)
+raise f() # E: "f" does not return a value (it only ever returns None)
 [builtins fixtures/exception.pyi]
 
 [case testNoneReturnTypeWithExpressions]
@@ -1040,14 +1110,14 @@ def f() -> None: pass
 class A:
     def __add__(self, x: 'A') -> 'A': pass
 
-a = None # type: 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
-f() == a    # E: "f" does not return a value
-a != f()    # E: "f" does not return a value
+a: A
+[f()]       # E: "f" does not return a value (it only ever returns None)
+f() + a     # E: "f" does not return a value (it only ever returns None)
+a + f()     # E: "f" does not return a value (it only ever returns None)
+f() == a    # E: "f" does not return a value (it only ever returns None)
+a != f()    # E: "f" does not return a value (it only ever returns None)
 cast(A, f())
-f().foo     # E: "f" does not return a value
+f().foo     # E: "f" does not return a value (it only ever returns None)
 [builtins fixtures/list.pyi]
 
 [case testNoneReturnTypeWithExpressions2]
@@ -1058,15 +1128,16 @@ class A:
     def __add__(self, x: 'A') -> 'A':
         pass
 
-a, b = None, None # type: (A, 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
-a in f()   # E: "f" does not return a value
--f()       # E: "f" does not return a value
-not f()    # E: "f" does not return a value
-f() and b  # E: "f" does not return a value
-b or f()   # E: "f" does not return a value
+a: A
+b: bool
+f() in a   # E: "f" does not return a value (it only ever returns None)  # E: Unsupported right operand type for in ("A")
+a < f()    # E: "f" does not return a value (it only ever returns None)
+f() <= a   # E: "f" does not return a value (it only ever returns None)
+a in f()   # E: "f" does not return a value (it only ever returns None)
+-f()       # E: "f" does not return a value (it only ever returns None)
+not f()    # E: "f" does not return a value (it only ever returns None)
+f() and b  # E: "f" does not return a value (it only ever returns None)
+b or f()   # E: "f" does not return a value (it only ever returns None)
 [builtins fixtures/bool.pyi]
 
 
@@ -1075,7 +1146,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,16 +1173,16 @@ class B: pass
 
 [case testSlicingWithInvalidBase]
 
-a = None # type: 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"
+a: A
+a[1:2] # E: Invalid index type "slice[int, int, None]" for "A"; expected type "int"
+a[:]   # E: Invalid index type "slice[None, None, None]" for "A"; expected type "int"
 class A:
   def __getitem__(self, n: int) -> 'A': pass
 [builtins fixtures/slice.pyi]
 
 [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 +1215,7 @@ class SupportsIndex(Protocol):
 
 [case testNoneSliceBounds]
 from typing import Any
-a = None # type: Any
+a: Any
 a[None:1]
 a[1:None]
 a[None:]
@@ -1151,9 +1223,8 @@ a[:None]
 [builtins fixtures/slice.pyi]
 
 [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 +1253,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 +1283,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 +1292,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 +1301,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 +1324,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 +1339,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 +1353,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 +1367,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 +1384,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 +1404,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 +1416,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]
@@ -1365,7 +1437,7 @@ if int():
 [case testConditionalExpressionWithEmptyCondition]
 import typing
 def f() -> None: pass
-x = 1 if f() else 2 # E: "f" does not return a value
+x = 1 if f() else 2 # E: "f" does not return a value (it only ever returns None)
 
 [case testConditionalExpressionWithSubtyping]
 import typing
@@ -1394,10 +1466,9 @@ if int():
 
 [case testConditionalExpressionUnion]
 from typing import Union
-reveal_type(1 if bool() else 2) # N: Revealed type is "builtins.int"
-reveal_type(1 if bool() else '') # N: Revealed type is "builtins.object"
-x: Union[int, str] = reveal_type(1 if bool() else '') \
-    # N: Revealed type is "Union[Literal[1]?, Literal['']?]"
+reveal_type(1 if bool() else 2) # N: Revealed type is "Union[Literal[1]?, Literal[2]?]"
+reveal_type(1 if bool() else '') # N: Revealed type is "Union[Literal[1]?, Literal['']?]"
+x: Union[int, str] = reveal_type(1 if bool() else '') # N: Revealed type is "Union[Literal[1]?, Literal['']?]"
 class A:
     pass
 class B(A):
@@ -1411,26 +1482,33 @@ b = B()
 c = C()
 d = D()
 reveal_type(a if bool() else b) # N: Revealed type is "__main__.A"
-reveal_type(b if bool() else c) # N: Revealed type is "builtins.object"
-reveal_type(c if bool() else b) # N: Revealed type is "builtins.object"
-reveal_type(c if bool() else a) # N: Revealed type is "builtins.object"
-reveal_type(d if bool() else b) # N: Revealed type is "__main__.A"
+reveal_type(b if bool() else c) # N: Revealed type is "Union[__main__.B, __main__.C]"
+reveal_type(c if bool() else b) # N: Revealed type is "Union[__main__.C, __main__.B]"
+reveal_type(c if bool() else a) # N: Revealed type is "Union[__main__.C, __main__.A]"
+reveal_type(d if bool() else b) # N: Revealed type is "Union[__main__.D, __main__.B]"
 [builtins fixtures/bool.pyi]
 
 [case testConditionalExpressionUnionWithAny]
 from typing import Union, Any
 a: Any
 x: Union[int, str] = reveal_type(a if int() else 1)  # N: Revealed type is "Union[Any, Literal[1]?]"
-reveal_type(a if int() else 1)  # N: Revealed type is "Any"
+reveal_type(a if int() else 1)  # N: Revealed type is "Union[Any, Literal[1]?]"
 
 [case testConditionalExpressionStatementNoReturn]
 from typing import List, Union
 x = []
 y = ""
 x.append(y) if bool() else x.append(y)
-z = x.append(y) if bool() else x.append(y) # E: "append" of "list" does not return a value
+z = x.append(y) if bool() else x.append(y) # E: "append" of "list" does not return a value (it only ever returns None)
 [builtins fixtures/list.pyi]
 
+[case testConditionalExpressionWithUnreachableBranches]
+from typing import TypeVar
+T = TypeVar("T", int, str)
+def foo(x: T) -> T:
+    return x + 1 if isinstance(x, int) else x + "a"
+[builtins fixtures/isinstancelist.pyi]
+
 -- Special cases
 -- -------------
 
@@ -1441,14 +1519,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 +1540,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 +1549,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 +1580,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 = ...
@@ -1512,8 +1591,7 @@ if str():
 ....a  # E: "ellipsis" has no attribute "a"
 
 class A: pass
-[builtins fixtures/dict.pyi]
-[out]
+[builtins fixtures/dict-full.pyi]
 
 
 -- Yield expression
@@ -1527,7 +1605,7 @@ def f(x: int) -> None:
 [builtins fixtures/for.pyi]
 [out]
 main:1: error: The return type of a generator function should be "Generator" or one of its supertypes
-main:2: error: "f" does not return a value
+main:2: error: "f" does not return a value (it only ever returns None)
 main:2: error: Argument 1 to "f" has incompatible type "str"; expected "int"
 
 [case testYieldExpressionWithNone]
@@ -1547,7 +1625,7 @@ from typing import Iterator
 def f() -> Iterator[int]:
     yield 5
 def g() -> Iterator[int]:
-    a = yield from f()  # E: Function does not return a value
+    a = yield from f()  # E: Function does not return a value (it only ever returns None)
 
 [case testYieldFromGeneratorHasValue]
 from typing import Iterator, Generator
@@ -1562,12 +1640,12 @@ def g() -> Iterator[int]:
 [case testYieldFromTupleExpression]
 from typing import Generator
 def g() -> Generator[int, None, None]:
-    x = yield from ()  # E: Function does not return a value
-    x = yield from (0, 1, 2)  # E: Function does not return a value
-    x = yield from (0, "ERROR")  # E: Incompatible types in "yield from" (actual type "object", expected type "int") \
-                                 # E: Function does not return a value
+    x = yield from ()  # E: Function does not return a value (it only ever returns None)
+    x = yield from (0, 1, 2)  # E: Function does not return a value (it only ever returns None)
+    x = yield from (0, "ERROR")  # E: Incompatible types in "yield from" (actual type "Union[int, str]", expected type "int") \
+                                 # E: Function does not return a value (it only ever returns None)
     x = yield from ("ERROR",)  # E: Incompatible types in "yield from" (actual type "str", expected type "int") \
-                               # E: Function does not return a value
+                               # E: Function does not return a value (it only ever returns None)
 [builtins fixtures/tuple.pyi]
 
 -- dict(...)
@@ -1988,7 +2066,7 @@ x is 42
 [typing fixtures/typing-full.pyi]
 
 [case testStrictEqualityStrictOptional]
-# flags: --strict-equality --strict-optional
+# flags: --strict-equality
 
 x: str
 if x is not None:  # OK even with strict-optional
@@ -2004,7 +2082,7 @@ if x is not None:  # OK without strict-optional
 [builtins fixtures/bool.pyi]
 
 [case testStrictEqualityEqNoOptionalOverlap]
-# flags: --strict-equality --strict-optional
+# flags: --strict-equality
 from typing import Optional
 
 x: Optional[str]
@@ -2201,7 +2279,7 @@ def f(x: T) -> T:
 
 [case testStrictEqualityWithALiteral]
 # flags: --strict-equality
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 
 def returns_a_or_b() -> Literal['a', 'b']:
     ...
@@ -2288,6 +2366,51 @@ b"x" in data
 [builtins fixtures/primitives.pyi]
 [typing fixtures/typing-full.pyi]
 
+[case testStrictEqualityWithDifferentMapTypes]
+# flags: --strict-equality
+from typing import Mapping
+
+class A(Mapping[int, str]): ...
+class B(Mapping[int, str]): ...
+
+a: A
+b: B
+assert a == b
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testStrictEqualityWithRecursiveMapTypes]
+# flags: --strict-equality
+from typing import Dict
+
+R = Dict[str, R]
+
+a: R
+b: R
+assert a == b
+
+R2 = Dict[int, R2]
+c: R2
+assert a == c  # E: Non-overlapping equality check (left operand type: "Dict[str, R]", right operand type: "Dict[int, R2]")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testStrictEqualityWithRecursiveListTypes]
+# flags: --strict-equality
+from typing import List, Union
+
+R = List[Union[str, R]]
+
+a: R
+b: R
+assert a == b
+
+R2 = List[Union[int, R2]]
+c: R2
+assert a == c
+[builtins fixtures/list.pyi]
+[typing fixtures/typing-full.pyi]
+
 [case testUnimportedHintAny]
 def f(x: Any) -> None:  # E: Name "Any" is not defined \
                         # N: Did you forget to import it from "typing"? (Suggestion: "from typing import Any")
@@ -2328,5 +2451,7 @@ def f() -> int:  # E: Missing return statement
 from typing import TypeVar
 T = TypeVar("T")
 x: int
-x + T  # E: Unsupported operand types for + ("int" and "object")
-T()  # E: "object" not callable
+x + T  # E: Unsupported left operand type for + ("int")
+T()  # E: "TypeVar" not callable
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
diff --git a/test-data/unit/check-fastparse.test b/test-data/unit/check-fastparse.test
index 2e4473c2716b..f93e4fe07218 100644
--- a/test-data/unit/check-fastparse.test
+++ b/test-data/unit/check-fastparse.test
@@ -31,7 +31,6 @@ def f(x):  # E: Invalid type comment or annotation
   pass
 
 [case testFastParseInvalidTypes3]
-# flags: --python-version 3.6
 # All of these should not crash
 from typing import Callable, Tuple, Iterable
 
@@ -228,8 +227,8 @@ def g():  # E: Type signature has too many arguments
 assert 1, 2
 assert (1, 2)  # E: Assertion is always true, perhaps remove parentheses?
 assert (1, 2), 3  # E: Assertion is always true, perhaps remove parentheses?
-assert ()
 assert (1,)  # E: Assertion is always true, perhaps remove parentheses?
+assert ()
 [builtins fixtures/tuple.pyi]
 
 [case testFastParseAssertMessage]
@@ -242,37 +241,37 @@ assert 1, f()  # E: Name "f" is not defined
 
 [case testFastParserConsistentFunctionTypes]
 
-def f(x, y, z):
+def f1(x, y, z):
   # type: (int, int, int) -> int
   pass
 
-def f(x,  # type: int  # E: Function has duplicate type signatures
+def f2(x,  # type: int  # E: Function has duplicate type signatures
       y,  # type: int
       z   # type: int
     ):
     # type: (int, int, int) -> int
     pass
 
-def f(x,  # type: int
+def f3(x,  # type: int
       y,  # type: int
       z   # type: int
     ):
     # type: (...) -> int
     pass
 
-def f(x, y, z):
+def f4(x, y, z):
   # type: (int, int, int) -> int
   pass
 
-def f(x) -> int:  # E: Function has duplicate type signatures
+def f5(x) -> int:  # E: Function has duplicate type signatures
   # type: (int) -> int
   pass
 
-def f(x: int, y: int, z: int):
+def f6(x: int, y: int, z: int):
   # type: (...) -> int
   pass
 
-def f(x: int):  # E: Function has duplicate type signatures
+def f7(x: int):  # E: Function has duplicate type signatures
   # type: (int) -> int
   pass
 
diff --git a/test-data/unit/check-final.test b/test-data/unit/check-final.test
index da034caced76..d78c2a8e57f2 100644
--- a/test-data/unit/check-final.test
+++ b/test-data/unit/check-final.test
@@ -194,6 +194,7 @@ def g(x: int) -> Final[int]: ...  # E: Final can be only used as an outermost qu
 [out]
 
 [case testFinalDefiningNotInMethodExtensions]
+# flags: --python-version 3.14
 from typing_extensions import Final
 
 def f(x: Final[int]) -> int: ...  # E: Final can be only used as an outermost qualifier in a variable annotation
@@ -299,6 +300,50 @@ class P(Protocol):
         pass
 [out]
 
+[case testFinalInProtocol]
+from typing import Final, Protocol, final
+
+class P(Protocol):
+    var1 : Final[int] = 0 # E: Protocol member cannot be final
+
+    @final # E: Protocol member cannot be final
+    def meth1(self) -> None:
+        var2: Final = 0
+
+    def meth2(self) -> None:
+        var3: Final = 0
+
+    def meth3(self) -> None:
+        class Inner:
+            var3: Final = 0  # OK
+
+            @final
+            def inner(self) -> None: ...
+
+    class Inner:
+        var3: Final = 0  # OK
+
+        @final
+        def inner(self) -> None: ...
+
+[out]
+
+[case testFinalWithClassVarInProtocol]
+from typing import Protocol, Final, final, ClassVar
+
+class P(Protocol):
+    var1 : Final[ClassVar[int]] = 0 # E: Variable should not be annotated with both ClassVar and Final
+    var2: ClassVar[int] = 1
+
+    @final # E: Protocol member cannot be final
+    def meth1(self) -> None:
+        ...
+
+    def meth2(self) -> None:
+        var3: Final[ClassVar[int]] = 0 # E: Variable should not be annotated with both ClassVar and Final # E: ClassVar can only be used for assignments in class body
+
+[out]
+
 [case testFinalNotInLoops]
 from typing import Final
 
@@ -1075,7 +1120,7 @@ class B:
 [out]
 
 [case testFinalInDeferredMethod]
-from typing_extensions import Final
+from typing import Final
 
 class A:
     def __init__(self) -> None:
@@ -1084,6 +1129,7 @@ class A:
 [builtins fixtures/tuple.pyi]
 
 [case testFinalUsedWithClassVar]
+# flags: --python-version 3.12
 from typing import Final, ClassVar
 
 class A:
@@ -1092,6 +1138,15 @@ class A:
     c: ClassVar[Final] = 1  # E: Final can be only used as an outermost qualifier in a variable annotation
 [out]
 
+[case testFinalUsedWithClassVarAfterPy313]
+# flags: --python-version 3.13
+from typing import Final, ClassVar
+
+class A:
+    a: Final[ClassVar[int]] = 1
+    b: ClassVar[Final[int]] = 1
+    c: ClassVar[Final] = 1
+
 [case testFinalClassWithAbstractMethod]
 from typing import final
 from abc import ABC, abstractmethod
@@ -1117,3 +1172,103 @@ from typing import Final
 class MyClass:
     a: None
     a: Final[int] = 1  # E: Cannot redefine an existing name as final  # E: Name "a" already defined on line 5
+
+[case testFinalOverrideAllowedForPrivate]
+from typing import Final, final
+
+class Parent:
+    __foo: Final[int] = 0
+    @final
+    def __bar(self) -> None: ...
+
+class Child(Parent):
+    __foo: Final[int] = 1
+    @final
+    def __bar(self) -> None: ...
+
+[case testFinalWithoutBool]
+from typing import Literal, final
+
+class A:
+    pass
+
+@final
+class B:
+    pass
+
+@final
+class C:
+    def __len__(self) -> Literal[1]: return 1
+
+reveal_type(A() and 42)  # N: Revealed type is "Union[__main__.A, Literal[42]?]"
+reveal_type(B() and 42)  # N: Revealed type is "Literal[42]?"
+reveal_type(C() and 42)  # N: Revealed type is "Literal[42]?"
+
+[builtins fixtures/bool.pyi]
+
+[case testFinalWithoutBoolButWithLen]
+from typing import Literal, final
+
+# Per Python data model, __len__ is called if __bool__ does not exist.
+# In a @final class, __bool__ would not exist.
+
+@final
+class A:
+    def __len__(self) -> int: ...
+
+@final
+class B:
+    def __len__(self) -> Literal[1]: return 1
+
+@final
+class C:
+    def __len__(self) -> Literal[0]: return 0
+
+reveal_type(A() and 42)  # N: Revealed type is "Union[__main__.A, Literal[42]?]"
+reveal_type(B() and 42)  # N: Revealed type is "Literal[42]?"
+reveal_type(C() and 42)  # N: Revealed type is "__main__.C"
+
+[builtins fixtures/bool.pyi]
+
+[case testCanAccessFinalClassInit]
+from typing import final
+
+@final
+class FinalClass:
+    pass
+
+def check_final_class() -> None:
+    new_instance = FinalClass()
+    new_instance.__init__()
+
+class FinalInit:
+    @final
+    def __init__(self) -> None:
+        pass
+
+def check_final_init() -> None:
+    new_instance = FinalInit()
+    new_instance.__init__()
+[builtins fixtures/tuple.pyi]
+
+[case testNarrowingOfFinalPersistsInFunctions]
+from typing import Final, Union
+
+def _init() -> Union[int, None]:
+    return 0
+
+FOO: Final = _init()
+
+class Example:
+
+    if FOO is not None:
+        reveal_type(FOO)  # N: Revealed type is "builtins.int"
+
+        def fn(self) -> int:
+            return FOO
+
+if FOO is not None:
+    reveal_type(FOO)  # N: Revealed type is "builtins.int"
+
+    def func() -> int:
+        return FOO
diff --git a/test-data/unit/check-flags.test b/test-data/unit/check-flags.test
index 39fcef1db673..f628fdd68ce8 100644
--- a/test-data/unit/check-flags.test
+++ b/test-data/unit/check-flags.test
@@ -79,6 +79,13 @@ async def g(x: int) -> Any:
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
 
+[case testDisallowUntypedDefsAndGeneric]
+# flags: --disallow-untyped-defs --disallow-any-generics
+def get_tasks(self):
+    return 'whatever'
+[out]
+main:2: error: Function is missing a return type annotation
+
 [case testDisallowUntypedDefsUntypedDecorator]
 # flags: --disallow-untyped-decorators
 def d(p):
@@ -340,7 +347,7 @@ def f() -> int:
 
 [case testNoReturnDisallowsReturn]
 # flags: --warn-no-return
-from mypy_extensions import NoReturn
+from typing import NoReturn
 
 def f() -> NoReturn:
   if bool():
@@ -351,7 +358,7 @@ def f() -> NoReturn:
 
 [case testNoReturnWithoutImplicitReturn]
 # flags: --warn-no-return
-from mypy_extensions import NoReturn
+from typing import NoReturn
 
 def no_return() -> NoReturn: pass
 def f() -> NoReturn:
@@ -360,7 +367,7 @@ def f() -> NoReturn:
 
 [case testNoReturnDisallowsImplicitReturn]
 # flags: --warn-no-return
-from mypy_extensions import NoReturn
+from typing import NoReturn
 
 def f() -> NoReturn:  # E: Implicit return in function which does not return
   non_trivial_function = 1
@@ -384,7 +391,7 @@ x = force_forward_reference()
 
 [case testNoReturnNoWarnNoReturn]
 # flags: --warn-no-return
-from mypy_extensions import NoReturn
+from typing import NoReturn
 
 def no_return() -> NoReturn: pass
 def f() -> int:
@@ -396,7 +403,7 @@ def f() -> int:
 
 [case testNoReturnInExpr]
 # flags: --warn-no-return
-from mypy_extensions import NoReturn
+from typing import NoReturn
 
 def no_return() -> NoReturn: pass
 def f() -> int:
@@ -406,14 +413,14 @@ reveal_type(f() or no_return())  # N: Revealed type is "builtins.int"
 
 [case testNoReturnVariable]
 # flags: --warn-no-return
-from mypy_extensions import NoReturn
+from typing import NoReturn
 
-x = 0  # type: NoReturn  # E: Incompatible types in assignment (expression has type "int", variable has type "NoReturn")
+x = 0  # type: NoReturn  # E: Incompatible types in assignment (expression has type "int", variable has type "Never")
 [builtins fixtures/dict.pyi]
 
 [case testNoReturnAsync]
 # flags: --warn-no-return
-from mypy_extensions import NoReturn
+from typing import NoReturn
 
 async def f() -> NoReturn: ...
 
@@ -427,7 +434,7 @@ async def h() -> NoReturn:  # E: Implicit return in function which does not retu
 [typing fixtures/typing-async.pyi]
 
 [case testNoWarnNoReturn]
-# flags: --no-warn-no-return --strict-optional
+# flags: --no-warn-no-return
 import typing
 
 def implicit_optional_return(arg) -> typing.Optional[str]:
@@ -477,7 +484,7 @@ def no_return() -> NoReturn: pass
 def f() -> NoReturn:
   no_return()
 
-x: NoReturn = 0 # E: Incompatible types in assignment (expression has type "int", variable has type "NoReturn")
+x: NoReturn = 0 # E: Incompatible types in assignment (expression has type "int", variable has type "Never")
 [builtins fixtures/dict.pyi]
 
 [case testShowErrorContextFunction]
@@ -540,21 +547,30 @@ tmp/b.py:1: error: Unsupported operand types for + ("int" and "str")
 [case testFollowImportsNormal]
 # flags: --follow-imports=normal
 from mod import x
-x + ""
+x + 0
+x + ""  # E: Unsupported operand types for + ("int" and "str")
+import mod
+mod.x + 0
+mod.x + ""  # E: Unsupported operand types for + ("int" and "str")
+mod.y  # E: "object" has no attribute "y"
+mod + 0  # E: Unsupported left operand type for + ("object")
 [file mod.py]
-1 + ""
+1 + ""  # E: Unsupported operand types for + ("int" and "str")
 x = 0
-[out]
-tmp/mod.py:1: error: Unsupported operand types for + ("int" and "str")
-main:3: error: Unsupported operand types for + ("int" and "str")
+x += ""  # E: Unsupported operand types for + ("int" and "str")
 
 [case testFollowImportsSilent]
 # flags: --follow-imports=silent
 from mod import x
 x + ""  # E: Unsupported operand types for + ("int" and "str")
+import mod
+mod.x + ""  # E: Unsupported operand types for + ("int" and "str")
+mod.y  # E: "object" has no attribute "y"
+mod + 0  # E: Unsupported left operand type for + ("object")
 [file mod.py]
 1 + ""
 x = 0
+x += ""
 
 [case testFollowImportsSilentTypeIgnore]
 # flags: --warn-unused-ignores --follow-imports=silent
@@ -565,20 +581,55 @@ x = 3  # type: ignore
 [case testFollowImportsSkip]
 # flags: --follow-imports=skip
 from mod import x
+reveal_type(x)  # N: Revealed type is "Any"
 x + ""
+import mod
+reveal_type(mod.x)  # N: Revealed type is "Any"
 [file mod.py]
 this deliberate syntax error will not be reported
-[out]
 
 [case testFollowImportsError]
 # flags: --follow-imports=error
-from mod import x
+from mod import x  # E: Import of "mod" ignored \
+                   # N: (Using --follow-imports=error, module not passed on command line)
 x + ""
+reveal_type(x)  # N: Revealed type is "Any"
+import mod
+reveal_type(mod.x) # N: Revealed type is "Any"
 [file mod.py]
 deliberate syntax error
-[out]
-main:2: error: Import of "mod" ignored
-main:2: note: (Using --follow-imports=error, module not passed on command line)
+
+[case testFollowImportsSelective]
+# flags: --config-file tmp/mypy.ini
+import normal
+import silent
+import skip
+import error  # E: Import of "error" ignored \
+              # N: (Using --follow-imports=error, module not passed on command line)
+reveal_type(normal.x)  # N: Revealed type is "builtins.int"
+reveal_type(silent.x)  # N: Revealed type is "builtins.int"
+reveal_type(skip)  # N: Revealed type is "Any"
+reveal_type(error)  # N: Revealed type is "Any"
+[file mypy.ini]
+\[mypy]
+\[mypy-normal]
+follow_imports = normal
+\[mypy-silent]
+follow_imports = silent
+\[mypy-skip]
+follow_imports = skip
+\[mypy-error]
+follow_imports = error
+[file normal.py]
+x = 0
+x += ''  # E: Unsupported operand types for + ("int" and "str")
+[file silent.py]
+x = 0
+x += ''
+[file skip.py]
+bla bla
+[file error.py]
+bla bla
 
 [case testIgnoreMissingImportsFalse]
 from mod import x
@@ -591,6 +642,15 @@ main:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missin
 from mod import x
 [out]
 
+[case testNoConfigFile]
+# flags: --config-file=
+# type: ignore
+
+[file mypy.ini]
+\[mypy]
+warn_unused_ignores = True
+[out]
+
 [case testPerFileIncompleteDefsBasic]
 # flags: --config-file tmp/mypy.ini
 import standard, incomplete
@@ -868,6 +928,16 @@ implicit_optional = true
 module = 'optional'
 strict_optional = true
 
+[case testSilentMissingImportsOff]
+-- ignore_missing_imports is False by default.
+import missing  # E: Cannot find implementation or library stub for module named "missing" \
+                # N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
+reveal_type(missing.x)  # N: Revealed type is "Any"
+
+[case testSilentMissingImportsOn]
+# flags: --ignore-missing-imports
+import missing
+reveal_type(missing.x)  # N: Revealed type is "Any"
 
 [case testDisallowImplicitTypesIgnoreMissingTypes]
 # flags: --ignore-missing-imports --disallow-any-unimported
@@ -893,6 +963,12 @@ from missing import Unchecked
 
 t: Unchecked = 12  # E: Type of variable becomes "Any" due to an unfollowed import
 
+[case testAllowImplicitAnyVariableDefinition]
+# flags: --ignore-missing-imports --allow-any-unimported
+from missing import Unchecked
+
+t: Unchecked = 12
+
 [case testDisallowImplicitAnyGeneric]
 # flags: --ignore-missing-imports --disallow-any-unimported
 from missing import Unchecked
@@ -924,9 +1000,9 @@ class A(List[Unchecked]): # E: Base type becomes "List[Any]" due to an unfollowe
 from missing import Unchecked
 from typing import List
 
-X = List[Unchecked]
+X = List[Unchecked]  # E: Type alias target becomes "List[Any]" due to an unfollowed import
 
-def f(x: X) -> None:  # E: Argument 1 to "f" becomes "List[Any]" due to an unfollowed import
+def f(x: X) -> None:
     pass
 [builtins fixtures/list.pyi]
 
@@ -1006,25 +1082,25 @@ main:6: error: A type on this line becomes "Any" due to an unfollowed import
 
 [case testDisallowUnimportedAnyTypedDictSimple]
 # flags: --ignore-missing-imports --disallow-any-unimported
-from mypy_extensions import TypedDict
+from typing import TypedDict
 from x import Unchecked
 
 M = TypedDict('M', {'x': str, 'y': Unchecked})  # E: Type of a TypedDict key becomes "Any" due to an unfollowed import
 
 def f(m: M) -> M: pass  # no error
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testDisallowUnimportedAnyTypedDictGeneric]
 # flags: --ignore-missing-imports --disallow-any-unimported
-
-from mypy_extensions import TypedDict
-from typing import List
+from typing import List, TypedDict
 from x import Unchecked
 
 M = TypedDict('M', {'x': str, 'y': List[Unchecked]})  # E: Type of a TypedDict key becomes "List[Any]" due to an unfollowed import
 
 def f(m: M) -> M: pass  # no error
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testDisallowAnyDecoratedUnannotatedDecorator]
 # flags: --disallow-any-decorated
@@ -1261,13 +1337,14 @@ def k(s: E) -> None: pass
 
 [case testDisallowAnyExprTypedDict]
 # flags: --disallow-any-expr
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 Movie = TypedDict('Movie', {'name': str, 'year': int})
 
 def g(m: Movie) -> Movie:
     return m
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testDisallowIncompleteDefs]
 # flags: --disallow-incomplete-defs
@@ -1407,8 +1484,7 @@ n: N
 
 [case testCheckDisallowAnyGenericsTypedDict]
 # flags: --disallow-any-generics
-from typing import Dict, Any, Optional
-from mypy_extensions import TypedDict
+from typing import Dict, Any, Optional, TypedDict
 
 VarsDict = Dict[str, Any]
 HostsDict = Dict[str, Optional[VarsDict]]
@@ -1421,6 +1497,7 @@ GroupDataDict = TypedDict(
 
 GroupsDict = Dict[str, GroupDataDict]  # type: ignore
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 [case testCheckDisallowAnyGenericsStubOnly]
@@ -1447,6 +1524,29 @@ class Queue(Generic[_T]): ...
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
 
+[case testDisallowAnyGenericsBuiltinTuplePre39]
+# flags: --disallow-any-generics --python-version 3.8
+s = tuple([1, 2, 3])
+def f(t: tuple) -> None: pass  # E: Implicit generic "Any". Use "typing.Tuple" and specify generic parameters
+[builtins fixtures/tuple.pyi]
+
+[case testDisallowAnyGenericsBuiltinListPre39]
+# flags: --disallow-any-generics --python-version 3.8
+l = list([1, 2, 3])
+def f(t: list) -> None: pass  # E: Implicit generic "Any". Use "typing.List" and specify generic parameters
+[builtins fixtures/list.pyi]
+
+[case testDisallowAnyGenericsBuiltinSetPre39]
+# flags: --disallow-any-generics --python-version 3.8
+l = set({1, 2, 3})
+def f(s: set) -> None: pass  # E: Implicit generic "Any". Use "typing.Set" and specify generic parameters
+[builtins fixtures/set.pyi]
+
+[case testDisallowAnyGenericsBuiltinDictPre39]
+# flags: --disallow-any-generics --python-version 3.8
+l = dict([('a', 1)])
+def f(d: dict) -> None: pass  # E: Implicit generic "Any". Use "typing.Dict" and specify generic parameters
+[builtins fixtures/dict.pyi]
 
 [case testCheckDefaultAllowAnyGeneric]
 from typing import TypeVar, Callable
@@ -1611,14 +1711,22 @@ from other_module_2 import a  # E: Module "other_module_2" does not explicitly e
 reveal_type(a)  # N: Revealed type is "builtins.int"
 
 import other_module_2
-# TODO: this should also reveal builtins.int, see #13965
-reveal_type(other_module_2.a)  # E: "object" does not explicitly export attribute "a"  [attr-defined] \
-                               # N: Revealed type is "Any"
+reveal_type(other_module_2.a)  # E: Module "other_module_2" does not explicitly export attribute "a"  [attr-defined] \
+                               # N: Revealed type is "builtins.int"
+
+from other_module_2 import b  # E: Module "other_module_2" does not explicitly export attribute "b"  [attr-defined]
+reveal_type(b)  # N: Revealed type is "def (a: builtins.int) -> builtins.str"
+
+import other_module_2
+reveal_type(other_module_2.b)  # E: Module "other_module_2" does not explicitly export attribute "b"  [attr-defined] \
+                               # N: Revealed type is "def (a: builtins.int) -> builtins.str"
 
 [file other_module_1.py]
 a = 5
+def b(a: int) -> str: ...
 [file other_module_2.py]
-from other_module_1 import a
+from other_module_1 import a, b
+[builtins fixtures/module.pyi]
 
 [case testNoImplicitReexportRespectsAll]
 # flags: --no-implicit-reexport
@@ -1647,13 +1755,17 @@ __all__ = ('b',)
 [builtins fixtures/tuple.pyi]
 
 [case testNoImplicitReexportGetAttr]
-# flags: --no-implicit-reexport --python-version 3.7
+# flags: --no-implicit-reexport
 from other_module_2 import a  # E: Module "other_module_2" does not explicitly export attribute "a"
+reveal_type(a)  # N: Revealed type is "builtins.int"
+from other_module_2 import b  # E: Module "other_module_2" does not explicitly export attribute "b"
+reveal_type(b)  # N: Revealed type is "builtins.str"
 [file other_module_1.py]
-from typing import Any
-def __getattr__(name: str) -> Any: ...
+b: str = "asdf"
+def __getattr__(name: str) -> int: ...
 [file other_module_2.py]
-from other_module_1 import a
+from other_module_1 import a, b
+def __getattr__(name: str) -> bytes: ...
 [builtins fixtures/tuple.pyi]
 
 [case textNoImplicitReexportSuggestions]
@@ -1718,51 +1830,51 @@ x: A  # E:4: Missing type parameters for generic type "A"
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitDefSignature]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 
 from typing import Any, List
 
-def f(x: Any) -> None:  # E: Explicit "Any" is not allowed
+def f(x: Any) -> None:  # E: Explicit "Any" is not allowed  [explicit-any]
     pass
 
-def g() -> Any:  # E: Explicit "Any" is not allowed
+def g() -> Any:  # E: Explicit "Any" is not allowed  [explicit-any]
     pass
 
-def h() -> List[Any]:  # E: Explicit "Any" is not allowed
+def h() -> List[Any]:  # E: Explicit "Any" is not allowed  [explicit-any]
     pass
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitVarDeclaration]
-# flags: --python-version 3.6 --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any
-v: Any = ''  # E: Explicit "Any" is not allowed
-w = ''  # type: Any  # E: Explicit "Any" is not allowed
+v: Any = ''  # E: Explicit "Any" is not allowed  [explicit-any]
+w = ''  # type: Any  # E: Explicit "Any" is not allowed  [explicit-any]
 class X:
-    y = ''  # type: Any  # E: Explicit "Any" is not allowed
+    y = ''  # type: Any  # E: Explicit "Any" is not allowed  [explicit-any]
 
 [case testDisallowAnyExplicitGenericVarDeclaration]
-# flags: --python-version 3.6 --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, List
-v: List[Any] = []  # E: Explicit "Any" is not allowed
+v: List[Any] = []  # E: Explicit "Any" is not allowed  [explicit-any]
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitInheritance]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, List
 
-class C(Any):  # E: Explicit "Any" is not allowed
+class C(Any):  # E: Explicit "Any" is not allowed  [explicit-any]
     pass
 
-class D(List[Any]):  # E: Explicit "Any" is not allowed
+class D(List[Any]):  # E: Explicit "Any" is not allowed  [explicit-any]
     pass
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitAlias]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, List
 
-X = Any  # E: Explicit "Any" is not allowed
-Y = List[Any]  # E: Explicit "Any" is not allowed
+X = Any  # E: Explicit "Any" is not allowed  [explicit-any]
+Y = List[Any]  # E: Explicit "Any" is not allowed  [explicit-any]
 
 def foo(x: X) -> Y:  # no error
     x.nonexistent()  # no error
@@ -1770,73 +1882,73 @@ def foo(x: X) -> Y:  # no error
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitGenericAlias]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, TypeVar, Tuple
 
 T = TypeVar('T')
 
-TupleAny = Tuple[Any, T]  # E: Explicit "Any" is not allowed
+TupleAny = Tuple[Any, T]  # E: Explicit "Any" is not allowed  [explicit-any]
 
 def foo(x: TupleAny[str]) -> None:  # no error
     pass
 
-def goo(x: TupleAny[Any]) -> None:  # E: Explicit "Any" is not allowed
+def goo(x: TupleAny[Any]) -> None:  # E: Explicit "Any" is not allowed  [explicit-any]
     pass
 [builtins fixtures/tuple.pyi]
 
 [case testDisallowAnyExplicitCast]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, List, cast
 
 x = 1
-y = cast(Any, x)  # E: Explicit "Any" is not allowed
-z = cast(List[Any], x)  # E: Explicit "Any" is not allowed
+y = cast(Any, x)  # E: Explicit "Any" is not allowed  [explicit-any]
+z = cast(List[Any], x)  # E: Explicit "Any" is not allowed  [explicit-any]
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitNamedTuple]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, List, NamedTuple
 
-Point = NamedTuple('Point', [('x', List[Any]), ('y', Any)])  # E: Explicit "Any" is not allowed
+Point = NamedTuple('Point', [('x', List[Any]), ('y', Any)])  # E: Explicit "Any" is not allowed  [explicit-any]
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitTypeVarConstraint]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, List, TypeVar
 
-T = TypeVar('T', Any, List[Any])  # E: Explicit "Any" is not allowed
+T = TypeVar('T', Any, List[Any])  # E: Explicit "Any" is not allowed  [explicit-any]
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitNewType]
-# flags: --disallow-any-explicit
+# flags: --disallow-any-explicit --show-error-codes
 from typing import Any, List, NewType
 
 # this error does not come from `--disallow-any-explicit` flag
-Baz = NewType('Baz', Any)  # E: Argument 2 to NewType(...) must be subclassable (got "Any")
-Bar = NewType('Bar', List[Any])  # E: Explicit "Any" is not allowed
+Baz = NewType('Baz', Any)  # E: Argument 2 to NewType(...) must be subclassable (got "Any")  [valid-newtype]
+Bar = NewType('Bar', List[Any])  # E: Explicit "Any" is not allowed  [explicit-any]
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExplicitTypedDictSimple]
-# flags: --disallow-any-explicit
-from mypy_extensions import TypedDict
-from typing import Any
+# flags: --disallow-any-explicit --show-error-codes
+from typing import Any, TypedDict
 
-M = TypedDict('M', {'x': str, 'y': Any})  # E: Explicit "Any" is not allowed
+M = TypedDict('M', {'x': str, 'y': Any})  # E: Explicit "Any" is not allowed  [explicit-any]
 M(x='x', y=2)  # no error
 def f(m: M) -> None: pass  # no error
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testDisallowAnyExplicitTypedDictGeneric]
-# flags: --disallow-any-explicit
-from mypy_extensions import TypedDict
-from typing import Any, List
+# flags: --disallow-any-explicit --show-error-codes
+from typing import Any, List, TypedDict
 
-M = TypedDict('M', {'x': str, 'y': List[Any]})  # E: Explicit "Any" is not allowed
+M = TypedDict('M', {'x': str, 'y': List[Any]})  # E: Explicit "Any" is not allowed  [explicit-any]
 N = TypedDict('N', {'x': str, 'y': List})  # no error
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testDisallowAnyGenericsTupleNoTypeParams]
-# flags: --python-version 3.6 --disallow-any-generics
+# flags: --disallow-any-generics
 from typing import Tuple
 
 def f(s: Tuple) -> None: pass  # E: Missing type parameters for generic type "Tuple"
@@ -1851,8 +1963,9 @@ x: Tuple = ()  # E: Missing type parameters for generic type "Tuple"
 # flags: --disallow-any-generics
 from typing import Tuple, List
 
-def f(s: List[Tuple]) -> None: pass  # E: Missing type parameters for generic type "Tuple"
-def g(s: List[Tuple[str, str]]) -> None: pass  # no error
+def f(s: Tuple) -> None: pass  # E: Missing type parameters for generic type "Tuple"
+def g(s: List[Tuple]) -> None: pass  # E: Missing type parameters for generic type "Tuple"
+def h(s: List[Tuple[str, str]]) -> None: pass  # no error
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyGenericsTypeType]
@@ -1877,7 +1990,7 @@ def g(l: L[str]) -> None: pass  # no error
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyGenericsGenericAlias]
-# flags: --python-version 3.6 --disallow-any-generics
+# flags: --disallow-any-generics
 from typing import TypeVar, Tuple
 
 T = TypeVar('T')
@@ -1892,20 +2005,42 @@ x: A = ('a', 'b', 1)  # E: Missing type parameters for generic type "A"
 [builtins fixtures/tuple.pyi]
 
 [case testDisallowAnyGenericsPlainList]
-# flags: --python-version 3.6 --disallow-any-generics
+# flags: --disallow-any-generics
 from typing import List
 
 def f(l: List) -> None: pass  # E: Missing type parameters for generic type "List"
-def g(l: List[str]) -> None: pass  # no error
+def g(l: List[str]) -> None: pass
 def h(l: List[List]) -> None: pass   # E: Missing type parameters for generic type "List"
 def i(l: List[List[List[List]]]) -> None: pass  # E: Missing type parameters for generic type "List"
+def j() -> List: pass  # E: Missing type parameters for generic type "List"
 
 x = []  # E: Need type annotation for "x" (hint: "x: List[<type>] = ...")
 y: List = []  # E: Missing type parameters for generic type "List"
 [builtins fixtures/list.pyi]
 
+[case testDisallowAnyGenericsPlainDict]
+# flags: --disallow-any-generics
+from typing import List, Dict
+
+def f(d: Dict) -> None: pass  # E: Missing type parameters for generic type "Dict"
+def g(d: Dict[str, Dict]) -> None: pass  # E: Missing type parameters for generic type "Dict"
+def h(d: List[Dict]) -> None: pass  # E: Missing type parameters for generic type "Dict"
+
+d: Dict = {}  # E: Missing type parameters for generic type "Dict"
+[builtins fixtures/dict.pyi]
+
+[case testDisallowAnyGenericsPlainSet]
+# flags: --disallow-any-generics
+from typing import Set
+
+def f(s: Set) -> None: pass  # E: Missing type parameters for generic type "Set"
+def g(s: Set[Set]) -> None: pass  # E: Missing type parameters for generic type "Set"
+
+s: Set = set()  # E: Missing type parameters for generic type "Set"
+[builtins fixtures/set.pyi]
+
 [case testDisallowAnyGenericsCustomGenericClass]
-# flags: --python-version 3.6 --disallow-any-generics
+# flags: --disallow-any-generics
 from typing import Generic, TypeVar, Any
 
 T = TypeVar('T')
@@ -2077,6 +2212,61 @@ y = 1
 f(reveal_type(y)) # E: Call to untyped function "f" in typed context \
                   # N: Revealed type is "builtins.int"
 
+[case testDisallowUntypedCallsAllowListFlags]
+# flags: --disallow-untyped-calls  --untyped-calls-exclude=foo --untyped-calls-exclude=bar.A
+from foo import test_foo
+from bar import A, B
+from baz import test_baz
+from foobar import bad
+
+test_foo(42)  # OK
+test_baz(42)  # E: Call to untyped function "test_baz" in typed context
+bad(42)  # E: Call to untyped function "bad" in typed context
+
+a: A
+b: B
+a.meth()  # OK
+b.meth()  # E: Call to untyped function "meth" in typed context
+[file foo.py]
+def test_foo(x): pass
+[file foobar.py]
+def bad(x): pass
+[file bar.py]
+class A:
+    def meth(self): pass
+class B:
+    def meth(self): pass
+[file baz.py]
+def test_baz(x): pass
+
+[case testDisallowUntypedCallsAllowListConfig]
+# flags: --config-file tmp/mypy.ini
+from foo import test_foo
+from bar import A, B
+from baz import test_baz
+
+test_foo(42)  # OK
+test_baz(42)  # E: Call to untyped function "test_baz" in typed context
+
+a: A
+b: B
+a.meth()  # OK
+b.meth()  # E: Call to untyped function "meth" in typed context
+[file foo.py]
+def test_foo(x): pass
+[file bar.py]
+class A:
+    def meth(self): pass
+class B:
+    def meth(self): pass
+[file baz.py]
+def test_baz(x): pass
+
+[file mypy.ini]
+\[mypy]
+disallow_untyped_calls = True
+untyped_calls_exclude = foo, bar.A
+
 [case testPerModuleErrorCodes]
 # flags: --config-file tmp/mypy.ini
 import tests.foo
@@ -2095,6 +2285,38 @@ allow_untyped_defs = True
 allow_untyped_calls = True
 disable_error_code = var-annotated
 
+[case testPerFileIgnoreErrors]
+# flags: --config-file tmp/mypy.ini
+import foo, bar
+[file foo.py]
+x: str = 5
+[file bar.py]
+x: str = 5  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+[file mypy.ini]
+\[mypy]
+\[mypy-foo]
+ignore_errors = True
+
+[case testPerFileUntypedDefs]
+# flags: --config-file tmp/mypy.ini
+import x, y, z
+[file x.py]
+def f(a): ...  # E: Function is missing a type annotation
+def g(a: int) -> int: return f(a)
+[file y.py]
+def f(a): pass
+def g(a: int) -> int: return f(a)
+[file z.py]
+def f(a): pass  # E: Function is missing a type annotation
+def g(a: int) -> int: return f(a)  # E: Call to untyped function "f" in typed context
+[file mypy.ini]
+\[mypy]
+disallow_untyped_defs = True
+\[mypy-y]
+disallow_untyped_defs = False
+\[mypy-z]
+disallow_untyped_calls = True
+
 [case testPerModuleErrorCodesOverride]
 # flags: --config-file tmp/mypy.ini
 import tests.foo
@@ -2123,23 +2345,20 @@ x: int = ""  # E: Incompatible types in assignment (expression has type "str", v
 # flags: --hide-error-codes
 x: int = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 
-[case testTypeVarTupleDisabled_no_incomplete]
-from typing_extensions import TypeVarTuple
-Ts = TypeVarTuple("Ts")  # E: "TypeVarTuple" support is experimental, use --enable-incomplete-feature=TypeVarTuple to enable
-[builtins fixtures/tuple.pyi]
-
-[case testTypeVarTupleEnabled_no_incomplete]
-# flags: --enable-incomplete-feature=TypeVarTuple
-from typing_extensions import TypeVarTuple
-Ts = TypeVarTuple("Ts")  # OK
-[builtins fixtures/tuple.pyi]
-
-
 [case testDisableBytearrayPromotion]
-# flags: --disable-bytearray-promotion
+# flags: --disable-bytearray-promotion --strict-equality
 def f(x: bytes) -> None: ...
 f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
 f(memoryview(b"asdf"))
+ba = bytearray(b"")
+if ba == b"":
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+if b"" == ba:
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+if ba == bytes():
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+if bytes() == ba:
+    f(ba)  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
 [builtins fixtures/primitives.pyi]
 
 [case testDisableMemoryviewPromotion]
@@ -2174,3 +2393,94 @@ def f(x: bytes, y: bytearray, z: memoryview) -> None:
     x in y
     x in z
 [builtins fixtures/primitives.pyi]
+
+[case testStrictBytes]
+# flags: --strict-bytes
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+f(memoryview(b"asdf"))  # E: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
+[builtins fixtures/primitives.pyi]
+
+[case testNoStrictBytes]
+# flags: --no-strict-bytes
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))
+f(memoryview(b"asdf"))
+[builtins fixtures/primitives.pyi]
+
+[case testStrictBytesDisabledByDefault]
+# TODO: probably change this default in Mypy v2.0, with https://github.com/python/mypy/pull/18371
+# (this would also obsolete the testStrictBytesEnabledByStrict test, below)
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))
+f(memoryview(b"asdf"))
+[builtins fixtures/primitives.pyi]
+
+[case testStrictBytesEnabledByStrict]
+# flags: --strict --disable-error-code type-arg
+# The type-arg thing is just work around the primitives.pyi isinstance Tuple not having type parameters,
+#   which isn't important for this.
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+f(memoryview(b"asdf"))  # E: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
+[builtins fixtures/primitives.pyi]
+
+[case testNoCrashFollowImportsForStubs]
+# flags: --config-file tmp/mypy.ini
+{**{"x": "y"}}
+
+[file mypy.ini]
+\[mypy]
+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)
+
+[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]
+
+[case testNestedGenericInAliasDisallow]
+# flags: --disallow-any-generics
+from typing import TypeVar, Generic, List, Union
+
+class C(Generic[T]): ...
+
+A = Union[C, List]  # E: Missing type parameters for generic type "C" \
+                    # E: Missing type parameters for generic type "List"
+[builtins fixtures/list.pyi]
+
+[case testNestedGenericInAliasAllow]
+# flags: --allow-any-generics
+from typing import TypeVar, Generic, List, Union
+
+class C(Generic[T]): ...
+
+A = Union[C, List]  # OK
+[builtins fixtures/list.pyi]
+
+[case testNotesOnlyResultInExitSuccess]
+-- check_untyped_defs is False by default.
+def f():
+    x: int = "no"  # N: By default the bodies of untyped functions are not checked, consider using --check-untyped-defs
diff --git a/test-data/unit/check-formatting.test b/test-data/unit/check-formatting.test
index 588b2c11714e..dce26b37dfc8 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]
 
@@ -98,7 +103,6 @@ a = None # type: Any
 [typing fixtures/typing-medium.pyi]
 
 [case testStringInterpolationC]
-# flags: --python-version 3.6
 '%c' % 1
 '%c' % 1.0   # E: "%c" requires int or char (expression has type "float")
 '%c' % 's'
@@ -139,8 +143,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
@@ -225,18 +231,12 @@ t5: Iterable[str] = ('A', 'B')
 -- Bytes interpolation
 -- --------------------
 
-
-[case testBytesInterpolationBefore35]
-# flags: --python-version 3.4
-b'%b' % 1  # E: Unsupported left operand type for % ("bytes")
-
 [case testBytesInterpolation]
 b'%b' % 1  # E: Incompatible types in string interpolation (expression has type "int", placeholder has type "bytes")
 b'%b' % b'1'
 b'%a' % 3
 
 [case testBytesInterpolationC]
-# flags: --python-version 3.6
 b'%c' % 1
 b'%c' % 1.0   # E: "%c" requires an integer in range(256) or a single byte (expression has type "float")
 b'%c' % 's'   # E: "%c" requires an integer in range(256) or a single byte (expression has type "str")
@@ -484,8 +484,25 @@ class D(bytes):
 '{}'.format(D())
 [builtins fixtures/primitives.pyi]
 
+[case testNoSpuriousFormattingErrorsDuringFailedOverlodMatch]
+from typing import overload, Callable
+
+@overload
+def sub(pattern: str, repl: Callable[[str], str]) -> str: ...
+@overload
+def sub(pattern: bytes, repl: Callable[[bytes], bytes]) -> bytes: ...
+def sub(pattern: object, repl: object) -> object:
+    pass
+
+def better_snakecase(text: str) -> str:
+    # Mypy used to emit a spurious error here
+    # warning about interpolating bytes into an f-string:
+    text = sub(r"([A-Z])([A-Z]+)([A-Z](?:[^A-Z]|$))", lambda match: f"{match}")
+    return text
+[builtins fixtures/primitives.pyi]
+
 [case testFormatCallFinal]
-from typing_extensions import Final
+from typing import Final
 
 FMT: Final = '{.x}, {:{:d}}'
 
@@ -494,7 +511,7 @@ FMT.format(1, 2, 'no')  # E: "int" has no attribute "x" \
 [builtins fixtures/primitives.pyi]
 
 [case testFormatCallFinalChar]
-from typing_extensions import Final
+from typing import Final
 
 GOOD: Final = 'c'
 BAD: Final = 'no'
@@ -525,7 +542,7 @@ x: Any
 [builtins fixtures/primitives.pyi]
 
 [case testFormatCallAccessorsIndices]
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 class User(TypedDict):
     id: int
@@ -537,6 +554,7 @@ u: User
 def f() -> str: ...
 '{[f()]}'.format(u)  # E: Invalid index expression in format field accessor "[f()]"
 [builtins fixtures/primitives.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testFormatCallFlags]
 from typing import Union
@@ -571,3 +589,45 @@ class S:
 '{:%}'.format(0.001)
 [builtins fixtures/primitives.pyi]
 [typing fixtures/typing-medium.pyi]
+
+[case testEnumWithStringToFormatValue]
+from enum import Enum
+
+class Responses(str, Enum):
+    TEMPLATED = 'insert {} here'
+    TEMPLATED_WITH_KW = 'insert {value} here'
+    NORMAL = 'something'
+
+Responses.TEMPLATED.format(42)
+Responses.TEMPLATED_WITH_KW.format(value=42)
+Responses.TEMPLATED.format()  # E: Cannot find replacement for positional format specifier 0
+Responses.TEMPLATED_WITH_KW.format()  # E: Cannot find replacement for named format specifier "value"
+Responses.NORMAL.format(42)  # E: Not all arguments converted during string formatting
+Responses.NORMAL.format(value=42)  # E: Not all arguments converted during string formatting
+[builtins fixtures/primitives.pyi]
+
+[case testNonStringEnumToFormatValue]
+from enum import Enum
+
+class Responses(Enum):
+    TEMPLATED = 'insert {value} here'
+
+Responses.TEMPLATED.format(value=42)  # E: "Responses" has no attribute "format"
+[builtins fixtures/primitives.pyi]
+
+[case testStrEnumWithStringToFormatValue]
+# flags: --python-version 3.11
+from enum import StrEnum
+
+class Responses(StrEnum):
+    TEMPLATED = 'insert {} here'
+    TEMPLATED_WITH_KW = 'insert {value} here'
+    NORMAL = 'something'
+
+Responses.TEMPLATED.format(42)
+Responses.TEMPLATED_WITH_KW.format(value=42)
+Responses.TEMPLATED.format()  # E: Cannot find replacement for positional format specifier 0
+Responses.TEMPLATED_WITH_KW.format()  # E: Cannot find replacement for named format specifier "value"
+Responses.NORMAL.format(42)  # E: Not all arguments converted during string formatting
+Responses.NORMAL.format(value=42)  # E: Not all arguments converted during string formatting
+[builtins fixtures/primitives.pyi]
diff --git a/test-data/unit/check-functions.test b/test-data/unit/check-functions.test
index b5d540b105e3..ac93c6c20354 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():
@@ -39,11 +40,10 @@ class B(A):
 class C(A):
     def f(self, *, b: int, a: str) -> None: pass  # Fail
 [out]
-main:10: error: Signature of "f" incompatible with supertype "A"
-main:10: note:      Superclass:
-main:10: note:          def f(self, *, a: int, b: str) -> None
-main:10: note:      Subclass:
-main:10: note:          def f(self, *, b: int, a: str) -> None
+main:10: error: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "str"
+main:10: note: This violates the Liskov substitution principle
+main:10: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
+main:10: error: Argument 2 of "f" is incompatible with supertype "A"; supertype defines the argument type as "int"
 
 [case testPositionalOverridingArgumentNameInsensitivity]
 import typing
@@ -82,9 +82,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():
@@ -105,16 +105,38 @@ if int():
     h = h
 
 [case testSubtypingFunctionsDoubleCorrespondence]
+def l(x) -> None: ...
+def r(__x, *, x) -> None: ...
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, NamedArg(Any, 'x')], None]")
 
+[case testSubtypingFunctionsDoubleCorrespondenceNamedOptional]
 def l(x) -> None: ...
-def r(__, *, x) -> None: ...
-r = l # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, NamedArg(Any, 'x')], None]")
+def r(__x, *, x = 1) -> None: ...
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, DefaultNamedArg(Any, 'x')], None]")
 
-[case testSubtypingFunctionsRequiredLeftArgNotPresent]
+[case testSubtypingFunctionsDoubleCorrespondenceBothNamedOptional]
+def l(x = 1) -> None: ...
+def r(__x, *, x = 1) -> None: ...
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, DefaultNamedArg(Any, 'x')], None]")
+
+[case testSubtypingFunctionsTrivialSuffixRequired]
+def l(__x) -> None: ...
+def r(x, *args, **kwargs) -> None: ...
+
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Arg(Any, 'x'), VarArg(Any), KwArg(Any)], None]")
+[builtins fixtures/dict.pyi]
+
+[case testSubtypingFunctionsTrivialSuffixOptional]
+def l(__x = 1) -> None: ...
+def r(x = 1, *args, **kwargs) -> None: ...
 
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[DefaultArg(Any)], None]", variable has type "Callable[[DefaultArg(Any, 'x'), VarArg(Any), KwArg(Any)], None]")
+[builtins fixtures/dict.pyi]
+
+[case testSubtypingFunctionsRequiredLeftArgNotPresent]
 def l(x, y) -> None: ...
 def r(x) -> None: ...
-r = l # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], None]", variable has type "Callable[[Any], None]")
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], None]", variable has type "Callable[[Any], None]")
 
 [case testSubtypingFunctionsImplicitNames]
 from typing import Any
@@ -132,7 +154,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 +182,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 +260,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)
@@ -248,7 +271,7 @@ if int():
 if int():
     f = o   # E: Incompatible types in assignment (expression has type "object", variable has type "Callable[[], None]")
 if int():
-    f = f() # E: Function does not return a value
+    f = f() # E: Function does not return a value (it only ever returns None)
 
 if int():
     f = f
@@ -272,8 +295,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 +309,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 +336,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 +365,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 +379,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 +418,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 +473,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 +598,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 +611,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 +652,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 +665,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 +677,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 +686,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 +699,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 +920,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"
 
@@ -913,10 +938,19 @@ f(None) # E: Too many arguments for "f"
 from typing import Any, Callable
 def dec1(f: Callable[[Any], None]) -> Callable[[], None]: pass
 def dec2(f: Callable[[Any, Any], None]) -> Callable[[Any], None]: pass
-@dec1 # E: Argument 1 to "dec2" has incompatible type "Callable[[Any], Any]"; expected "Callable[[Any, Any], None]"
-@dec2
+@dec1
+@dec2  # E: Argument 1 to "dec2" has incompatible type "Callable[[Any], Any]"; expected "Callable[[Any, Any], None]"
 def f(x): pass
 
+def faulty(c: Callable[[int], None]) -> Callable[[tuple[int, int]], None]:
+    return lambda x: None
+
+@faulty  # E: Argument 1 to "faulty" has incompatible type "Callable[[Tuple[int, int]], None]"; expected "Callable[[int], None]"
+@faulty  # E: Argument 1 to "faulty" has incompatible type "Callable[[str], None]"; expected "Callable[[int], None]"
+def g(x: str) -> None:
+    return None
+[builtins fixtures/tuple.pyi]
+
 [case testInvalidDecorator2]
 from typing import Any, Callable
 def dec1(f: Callable[[Any, Any], None]) -> Callable[[], None]: pass
@@ -1425,6 +1459,20 @@ else:
                                     # N: Redefinition: \
                                     # N:     def f(x: int = ...) -> None
 
+[case testIncompatibleConditionalFunctionDefinition4]
+from typing import Any, Union, TypeVar
+T1 = TypeVar('T1')
+T2 = TypeVar('T2', bound=Union[int, str])
+x = None # type: Any
+if x:
+    def f(x: T1) -> T1: pass
+else:
+    def f(x: T2) -> T2: pass # E: All conditional function variants must have identical signatures \
+                             # N: Original: \
+                             # N:     def [T1] f(x: T1) -> T1 \
+                             # N: Redefinition: \
+                             # N:     def [T2: Union[int, str]] f(x: T2) -> T2
+
 [case testConditionalFunctionDefinitionUsingDecorator1]
 from typing import Callable
 
@@ -1457,7 +1505,7 @@ def dec(f) -> Callable[[int], None]: pass
 
 x = int()
 if x:
-    def f(x: int) -> None: pass
+    def f(x: int, /) -> None: pass
 else:
     @dec
     def f(): pass
@@ -1472,9 +1520,12 @@ x = int()
 if x:
     def f(x: str) -> None: pass
 else:
-    # TODO: Complain about incompatible redefinition
     @dec
-    def f(): pass
+    def f(): pass   # E: All conditional function variants must have identical signatures \
+                    # N: Original: \
+                    # N:     def f(x: str) -> None \
+                    # N: Redefinition: \
+                    # N:     def f(int, /) -> None
 
 [case testConditionalFunctionDefinitionUnreachable]
 def bar() -> None:
@@ -1582,7 +1633,7 @@ else:
     def f():
         yield
 [file m.py]
-def f(): pass
+def f() -> None: pass
 
 [case testDefineConditionallyAsImportedAndDecoratedWithInference]
 if int():
@@ -1761,7 +1812,7 @@ def a(f: F):
     f("foo") # E: Argument 1 has incompatible type "str"; expected "int"
 [builtins fixtures/dict.pyi]
 
-[case testCallableParsingInInheritence]
+[case testCallableParsingInInheritance]
 
 from collections import namedtuple
 class C(namedtuple('t', 'x')):
@@ -1776,10 +1827,11 @@ def Arg(x, y): pass
 F = Callable[[Arg(int, 'x')], int]  # E: Invalid argument constructor "__main__.Arg"
 
 [case testCallableParsingFromExpr]
-
+# flags: --python-version 3.9
 from typing import Callable, List
 from mypy_extensions import Arg, VarArg, KwArg
 import mypy_extensions
+import types  # Needed for type checking
 
 def WrongArg(x, y): return y
 # Note that for this test, the 'Value of type "int" is not indexable' errors are silly,
@@ -1796,10 +1848,22 @@ L = Callable[[Arg(name='x', type=int)], int] # ok
 # I have commented out the following test because I don't know how to expect the "defined here" note part of the error.
 # M = Callable[[Arg(gnome='x', type=int)], int]   E: Invalid type alias: expression is not a valid type   E: Unexpected keyword argument "gnome" for "Arg"
 N = Callable[[Arg(name=None, type=int)], int] # ok
-O = Callable[[List[Arg(int)]], int]  # E: Invalid type alias: expression is not a valid type  # E: Value of type "int" is not indexable  # E: Type expected within [...] # E: The type "Type[List[Any]]" is not generic and not indexable
+O = Callable[[List[Arg(int)]], int]  # E: Invalid type alias: expression is not a valid type \
+                                     # E: Value of type "int" is not indexable \
+                                     # E: Type expected within [...]
 P = Callable[[mypy_extensions.VarArg(int)], int] # ok
-Q = Callable[[Arg(int, type=int)], int]  # E: Invalid type alias: expression is not a valid type  # E: Value of type "int" is not indexable  # E: "Arg" gets multiple values for keyword argument "type"
-R = Callable[[Arg(int, 'x', name='y')], int]  # E: Invalid type alias: expression is not a valid type  # E: Value of type "int" is not indexable  # E: "Arg" gets multiple values for keyword argument "name"
+Q = Callable[[Arg(int, type=int)], int]  # E: Invalid type alias: expression is not a valid type \
+                                         # E: Value of type "int" is not indexable \
+                                         # E: "Arg" gets multiple values for keyword argument "type"
+R = Callable[[Arg(int, 'x', name='y')], int]  # E: Invalid type alias: expression is not a valid type \
+                                              # E: Value of type "int" is not indexable \
+                                              # E: "Arg" gets multiple values for keyword argument "name"
+
+
+
+
+
+
 
 [builtins fixtures/dict.pyi]
 
@@ -1945,9 +2009,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 +2204,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 +2213,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 +2224,7 @@ class A(Generic[t]):
     def foo(self) -> t:
         return None
 [builtins fixtures/bool.pyi]
+
 [case testAcceptContravariantArgument]
 from typing import TypeVar, Generic
 
@@ -2245,13 +2312,26 @@ def dec(f: Callable[[A, str], None]) -> Callable[[A, int], None]: pass
 [out]
 
 [case testUnknownFunctionNotCallable]
+from typing import TypeVar
+
 def f() -> None:
     pass
 def g(x: int) -> None:
     pass
 h = f if bool() else g
-reveal_type(h) # N: Revealed type is "builtins.function"
-h(7) # E: Cannot call function of unknown type
+reveal_type(h) # N: Revealed type is "Union[def (), def (x: builtins.int)]"
+h(7) # E: Too many arguments for "f"
+
+T = TypeVar("T")
+def join(x: T, y: T) -> T: ...
+
+h2 = join(f, g)
+reveal_type(h2)  # N: Revealed type is "builtins.function"
+h2(7)  # E: Cannot call function of unknown type
+
+h3 = join(g, f)
+reveal_type(h3)  # N: Revealed type is "builtins.function"
+h3(7)  # E: Cannot call function of unknown type
 [builtins fixtures/bool.pyi]
 
 [case testFunctionWithNameUnderscore]
@@ -2300,7 +2380,7 @@ a.__eq__(other=a) # E: Unexpected keyword argument "other" for "__eq__" of "A"
 
 [builtins fixtures/bool.pyi]
 
--- Type variable shenanagins
+-- Type variable shenanigans
 -- -------------------------
 
 [case testGenericFunctionTypeDecl]
@@ -2323,7 +2403,7 @@ T = TypeVar('T')
 def deco() -> Callable[[T], T]: pass
 reveal_type(deco)  # N: Revealed type is "def () -> def [T] (T`-1) -> T`-1"
 f = deco()
-reveal_type(f)  # N: Revealed type is "def [T] (T`-1) -> T`-1"
+reveal_type(f)  # N: Revealed type is "def [T] (T`1) -> T`1"
 i = f(3)
 reveal_type(i)  # N: Revealed type is "builtins.int"
 
@@ -2336,7 +2416,7 @@ U = TypeVar('U')
 def deco(x: U) -> Callable[[T, U], T]: pass
 reveal_type(deco)  # N: Revealed type is "def [U] (x: U`-1) -> def [T] (T`-2, U`-1) -> T`-2"
 f = deco("foo")
-reveal_type(f)  # N: Revealed type is "def [T] (T`-2, builtins.str) -> T`-2"
+reveal_type(f)  # N: Revealed type is "def [T] (T`1, builtins.str) -> T`1"
 i = f(3, "eggs")
 reveal_type(i)  # N: Revealed type is "builtins.int"
 
@@ -2347,9 +2427,9 @@ T = TypeVar('T')
 R = TypeVar('R')
 def deco() -> Callable[[T], Callable[[T, R], R]]: pass
 f = deco()
-reveal_type(f)  # N: Revealed type is "def [T] (T`-1) -> def [R] (T`-1, R`-2) -> R`-2"
+reveal_type(f)  # N: Revealed type is "def [T] (T`2) -> def [R] (T`2, R`1) -> R`1"
 g = f(3)
-reveal_type(g)  # N: Revealed type is "def [R] (builtins.int, R`-2) -> R`-2"
+reveal_type(g)  # N: Revealed type is "def [R] (builtins.int, R`3) -> R`3"
 s = g(4, "foo")
 reveal_type(s)  # N: Revealed type is "builtins.str"
 
@@ -2423,14 +2503,14 @@ from typing import Union, Dict, List
 def f() -> List[Union[str, int]]:
     x = ['a']
     return x # E: Incompatible return value type (got "List[str]", expected "List[Union[str, int]]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+      # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
       # N: Consider using "Sequence" instead, which is covariant \
       # N: Perhaps you need a type annotation for "x"? Suggestion: "List[Union[str, int]]"
 
 def g() -> Dict[str, Union[str, int]]:
     x = {'a': 'a'}
     return x # E: Incompatible return value type (got "Dict[str, str]", expected "Dict[str, Union[str, int]]") \
-      # N: "Dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+      # N: "dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
       # N: Consider using "Mapping" instead, which is covariant in the value type \
       # N: Perhaps you need a type annotation for "x"? Suggestion: "Dict[str, Union[str, int]]"
 
@@ -2442,7 +2522,7 @@ def h() -> Dict[Union[str, int], str]:
 def i() -> List[Union[int, float]]:
     x: List[int] = [1]
     return x # E: Incompatible return value type (got "List[int]", expected "List[Union[int, float]]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+      # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
       # N: Consider using "Sequence" instead, which is covariant
 
 [builtins fixtures/dict.pyi]
@@ -2538,7 +2618,6 @@ reveal_type(bar(None))  # N: Revealed type is "None"
 [out]
 
 [case testNoComplainOverloadNoneStrict]
-# flags: --strict-optional
 from typing import overload, Optional
 @overload
 def bar(x: None) -> None:
@@ -2567,7 +2646,6 @@ xx: Optional[int] = X(x_in)
 [out]
 
 [case testNoComplainInferredNoneStrict]
-# flags: --strict-optional
 from typing import TypeVar, Optional
 T = TypeVar('T')
 def X(val: T) -> T: ...
@@ -2725,6 +2803,49 @@ f: Callable[[Sequence[TI]], None]
 g: Callable[[Union[Sequence[TI], Sequence[TS]]], None]
 f = g
 
+[case testOverrideDecoratedProperty]
+class Base:
+    @property
+    def foo(self) -> int: ...
+
+class decorator:
+    def __init__(self, fn):
+        self.fn = fn
+    def __call__(self, decorated_self) -> int:
+        return self.fn(decorated_self)
+
+class Child(Base):
+    @property
+    @decorator
+    def foo(self) -> int:
+        return 42
+reveal_type(Child().foo)  # N: Revealed type is "builtins.int"
+Child().foo = 1  # E: Property "foo" defined in "Child" is read-only
+
+reveal_type(Child().foo)  # N: Revealed type is "builtins.int"
+
+class BadChild1(Base):
+    @decorator
+    def foo(self) -> int:  # E: Signature of "foo" incompatible with supertype "Base" \
+                           # N:      Superclass: \
+                           # N:          int \
+                           # N:      Subclass: \
+                           # N:          decorator
+        return 42
+
+class not_a_decorator:
+    def __init__(self, fn): ...
+
+class BadChild2(Base):
+    # Override error not shown as accessing 'foo' on BadChild2 returns Any.
+    @property
+    @not_a_decorator
+    def foo(self) -> int:
+        return 42
+reveal_type(BadChild2().foo)  # E: "not_a_decorator" not callable \
+                              # N: Revealed type is "Any"
+[builtins fixtures/property.pyi]
+
 [case explicitOverride]
 # flags: --python-version 3.12
 from typing import override
@@ -2752,8 +2873,7 @@ class E(D): pass
 class F(E):
     @override
     def f(self, x: int) -> str: pass
-[typing fixtures/typing-full.pyi]
-[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-override.pyi]
 
 [case explicitOverrideStaticmethod]
 # flags: --python-version 3.12
@@ -2785,8 +2905,8 @@ class D(A):
     def f(x: str) -> str: pass  # E: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "int" \
                                 # N: This violates the Liskov substitution principle \
                                 # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
-[typing fixtures/typing-full.pyi]
-[builtins fixtures/callable.pyi]
+[typing fixtures/typing-override.pyi]
+[builtins fixtures/staticmethod.pyi]
 
 [case explicitOverrideClassmethod]
 # flags: --python-version 3.12
@@ -2818,8 +2938,8 @@ class D(A):
     def f(cls, x: str) -> str: pass  # E: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "int" \
                                      # N: This violates the Liskov substitution principle \
                                      # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
-[typing fixtures/typing-full.pyi]
-[builtins fixtures/callable.pyi]
+[typing fixtures/typing-override.pyi]
+[builtins fixtures/classmethod.pyi]
 
 [case explicitOverrideProperty]
 # flags: --python-version 3.12
@@ -2853,8 +2973,8 @@ class D(A):
                               # N:          str \
                               # N:      Subclass: \
                               # N:          int
+[typing fixtures/typing-override.pyi]
 [builtins fixtures/property.pyi]
-[typing fixtures/typing-full.pyi]
 
 [case explicitOverrideSettableProperty]
 # flags: --python-version 3.12
@@ -2891,8 +3011,8 @@ class D(A):
 
     @f.setter
     def f(self, value: int) -> None: pass
+[typing fixtures/typing-override.pyi]
 [builtins fixtures/property.pyi]
-[typing fixtures/typing-full.pyi]
 
 [case invalidExplicitOverride]
 # flags: --python-version 3.12
@@ -2907,8 +3027,7 @@ class A: pass
 def g() -> None:
     @override  # E: "override" used with a non-method
     def h(b: bool) -> int: pass
-[typing fixtures/typing-full.pyi]
-[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-override.pyi]
 
 [case explicitOverrideSpecialMethods]
 # flags: --python-version 3.12
@@ -2924,8 +3043,7 @@ class B(A):
 class C:
     @override
     def __init__(self, a: int) -> None: pass
-[typing fixtures/typing-full.pyi]
-[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-override.pyi]
 
 [case explicitOverrideFromExtensions]
 from typing_extensions import override
@@ -2936,7 +3054,6 @@ class A:
 class B(A):
     @override
     def f2(self, x: int) -> str: pass  # E: Method "f2" is marked as an override, but no base method was found with this name
-[typing fixtures/typing-full.pyi]
 [builtins fixtures/tuple.pyi]
 
 [case explicitOverrideOverloads]
@@ -2953,8 +3070,7 @@ class B(A):
     def f2(self, x: str) -> str: pass
     @override
     def f2(self, x: int | str) -> str: pass
-[typing fixtures/typing-full.pyi]
-[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-override.pyi]
 
 [case explicitOverrideNotOnOverloadsImplementation]
 # flags: --python-version 3.12
@@ -2978,8 +3094,7 @@ class C(A):
     @overload
     def f(self, y: str) -> str: pass
     def f(self, y: int | str) -> str: pass
-[typing fixtures/typing-full.pyi]
-[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-override.pyi]
 
 [case explicitOverrideOnMultipleOverloads]
 # flags: --python-version 3.12
@@ -3005,5 +3120,482 @@ class C(A):
     def f(self, y: str) -> str: pass
     @override
     def f(self, y: int | str) -> str: pass
+[typing fixtures/typing-override.pyi]
+
+[case explicitOverrideCyclicDependency]
+# flags: --python-version 3.12
+import b
+[file a.py]
+from typing import override
+import b
+import c
+
+class A(b.B):
+    @override  # This is fine
+    @c.deco
+    def meth(self) -> int: ...
+[file b.py]
+import a
+import c
+
+class B:
+    @c.deco
+    def meth(self) -> int: ...
+[file c.py]
+from typing import TypeVar, Tuple, Callable
+T = TypeVar('T')
+def deco(f: Callable[..., T]) -> Callable[..., Tuple[T, int]]: ...
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-override.pyi]
+
+[case requireExplicitOverrideMethod]
+# flags: --enable-error-code explicit-override --python-version 3.12
+from typing import override
+
+class A:
+    def f(self, x: int) -> str: pass
+
+class B(A):
+    @override
+    def f(self, y: int) -> str: pass
+
+class C(A):
+    def f(self, y: int) -> str: pass  # E: Method "f" is not using @override but is overriding a method in class "__main__.A"
+
+class D(B):
+    def f(self, y: int) -> str: pass  # E: Method "f" is not using @override but is overriding a method in class "__main__.B"
+[typing fixtures/typing-override.pyi]
+
+[case requireExplicitOverrideSpecialMethod]
+# flags: --enable-error-code explicit-override --python-version 3.12
+from typing import Callable, Self, TypeVar, override, overload
+
+T = TypeVar('T')
+def some_decorator(f: Callable[..., T]) -> Callable[..., T]: ...
+
+# Don't require override decorator for __init__ and __new__
+# See: https://github.com/python/typing/issues/1376
+class A:
+    def __init__(self) -> None: pass
+    def __new__(cls) -> Self: pass
+
+class B(A):
+    def __init__(self) -> None: pass
+    def __new__(cls) -> Self: pass
+
+class C(A):
+    @some_decorator
+    def __init__(self) -> None: pass
+
+    @some_decorator
+    def __new__(cls) -> Self: pass
+
+class D(A):
+    @overload
+    def __init__(self, x: int) -> None: ...
+    @overload
+    def __init__(self, x: str) -> None: ...
+    def __init__(self, x): pass
+
+    @overload
+    def __new__(cls, x: int) -> Self: pass
+    @overload
+    def __new__(cls, x: str) -> Self: pass
+    def __new__(cls, x): pass
+[typing fixtures/typing-override.pyi]
+
+[case requireExplicitOverrideProperty]
+# flags: --enable-error-code explicit-override --python-version 3.12
+from typing import override
+
+class A:
+    @property
+    def prop(self) -> int: pass
+
+class B(A):
+    @override
+    @property
+    def prop(self) -> int: pass
+
+class C(A):
+    @property
+    def prop(self) -> int: pass  # E: Method "prop" is not using @override but is overriding a method in class "__main__.A"
+[typing fixtures/typing-override.pyi]
+[builtins fixtures/property.pyi]
+
+[case requireExplicitOverrideOverload]
+# flags: --enable-error-code explicit-override --python-version 3.12
+from typing import overload, override
+
+class A:
+    @overload
+    def f(self, x: int) -> str: ...
+    @overload
+    def f(self, x: str) -> str: ...
+    def f(self, x): pass
+
+class B(A):
+    @overload
+    def f(self, y: int) -> str: ...
+    @overload
+    def f(self, y: str) -> str: ...
+    @override
+    def f(self, y): pass
+
+class C(A):
+    @overload
+    @override
+    def f(self, y: int) -> str: ...
+    @overload
+    def f(self, y: str) -> str: ...
+    def f(self, y): pass
+
+class D(A):
+    @overload
+    def f(self, y: int) -> str: ...
+    @overload
+    def f(self, y: str) -> str: ...
+    def f(self, y): pass  # E: Method "f" is not using @override but is overriding a method in class "__main__.A"
+[typing fixtures/typing-override.pyi]
+
+[case requireExplicitOverrideMultipleInheritance]
+# flags: --enable-error-code explicit-override --python-version 3.12
+from typing import override
+
+class A:
+    def f(self, x: int) -> str: pass
+class B:
+    def f(self, y: int) -> str: pass
+
+class C(A, B):
+    @override
+    def f(self, z: int) -> str: pass
+
+class D(A, B):
+    def f(self, z: int) -> str: pass  # E: Method "f" is not using @override but is overriding a method in class "__main__.A"
+[typing fixtures/typing-override.pyi]
+
+[case testExplicitOverrideAllowedForPrivate]
+# flags: --enable-error-code explicit-override --python-version 3.12
+
+class B:
+    def __f(self, y: int) -> str: pass
+
+class C(B):
+    def __f(self, y: int) -> str: pass  # OK
+[typing fixtures/typing-override.pyi]
+
+[case testOverrideUntypedDef]
+# flags: --python-version 3.12
+from typing import override
+
+class Parent: pass
+
+class Child(Parent):
+    @override
+    def foo(self, y): pass  # E: Method "foo" is marked as an override, but no base method was found with this name
+
+[typing fixtures/typing-override.pyi]
+
+[case testOverrideOnUnknownBaseClass]
+# flags: --python-version 3.12
+from typing import overload, override
+
+from unknown import UnknownParent  # type: ignore[import-not-found]
+
+class UnknownChild(UnknownParent):
+    @override
+    def foo(self, y): pass  # OK
+    @override
+    def bar(self, y: str) -> None: pass  # OK
+
+    @override
+    @overload
+    def baz(self, y: str) -> None: ...
+    @override
+    @overload
+    def baz(self, y: int) -> None: ...
+    def baz(self, y: str | int) -> None: ...
+[typing fixtures/typing-override.pyi]
+
+[case testCallableProperty]
+from typing import Callable
+
+class something_callable:
+    def __call__(self, fn) -> str: ...
+
+def decorator(fn: Callable[..., int]) -> something_callable: ...
+
+class A:
+    @property
+    @decorator
+    def f(self) -> int: ...
+
+reveal_type(A.f)  # N: Revealed type is "__main__.something_callable"
+reveal_type(A().f)  # N: Revealed type is "builtins.str"
+[builtins fixtures/property.pyi]
+
+[case testFinalOverrideOnUntypedDef]
+from typing import final
+
+class Base:
+    @final
+    def foo(self):
+        pass
+
+class Derived(Base):
+    def foo(self):  # E: Cannot override final attribute "foo" (previously declared in base class "Base")
+        pass
+
+[case testTypeVarIdClashPolymorphic]
+from typing import Callable, Generic, TypeVar
+
+A = TypeVar("A")
+B = TypeVar("B")
+
+class Gen(Generic[A]): ...
+
+def id_(x: A) -> A: ...
+def f(x: Gen[A], y: A) -> Gen[Gen[A]]: ...
+def g(x: Gen[A], id_: Callable[[B], B], f: Callable[[A, B], Gen[A]]) -> A: ...
+
+def test(x: Gen[Gen[A]]) -> Gen[A]:
+    return g(x, id_, f)  # Technically OK
+
+x: Gen[Gen[int]]
+reveal_type(g(x, id_, f))  # N: Revealed type is "__main__.Gen[builtins.int]"
+
+def h(x: A, y: A) -> A: ...
+def gn(id_: Callable[[B], B], step: Callable[[A, B], A]) -> A: ...
+
+def fn(x: A) -> A:
+    return gn(id_, h)  # Technically OK
+
+[case testTypeVarIdsNested]
+from typing import Callable, TypeVar
+
+A = TypeVar("A")
+B = TypeVar("B")
+
+def f(x: Callable[[A], A]) -> Callable[[B], B]:
+    def g(x: B) -> B: ...
+    return g
+
+reveal_type(f(f))  # N: Revealed type is "def [B] (B`1) -> B`1"
+reveal_type(f(f)(f))  # N: Revealed type is "def [A] (x: def (A`-1) -> A`-1) -> def [B] (B`-2) -> B`-2"
+
+[case testGenericUnionFunctionJoin]
+from typing import TypeVar, Union
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+def f(x: T, y: S) -> Union[T, S]: ...
+def g(x: T, y: S) -> Union[T, S]: ...
+
+x = [f, g]
+reveal_type(x)  # N: Revealed type is "builtins.list[def [T, S] (x: T`4, y: S`5) -> Union[T`4, S`5]]"
+[builtins fixtures/list.pyi]
+
+[case testTypeVariableClashErrorMessage]
+from typing import TypeVar
+
+T = TypeVar("T")
+
+class C:  # Note: Generic[T] missing
+    def bad_idea(self, x: T) -> None:
+        self.x = x
+
+    def nope(self, x: T) -> None:
+        self.x = x  # E: Incompatible types in assignment (expression has type "T@nope", variable has type "T@bad_idea")
+
+[case testNoCrashOnBadCallablePropertyOverride]
+from typing import Callable, Union
+
+class C: ...
+class D: ...
+
+A = Callable[[C], None]
+B = Callable[[D], None]
+
+class Foo:
+    @property
+    def method(self) -> Callable[[int, Union[A, B]], None]:
+        ...
+
+class Bar(Foo):
+    @property
+    def method(self) -> Callable[[int, A], None]:  # E: Argument 2 of "method" is incompatible with supertype "Foo"; supertype defines the argument type as "Union[Callable[[C], None], Callable[[D], None]]" \
+                                                   # N: This violates the Liskov substitution principle \
+                                                   # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
+        ...
+[builtins fixtures/property.pyi]
+
+[case testNoCrashOnUnpackOverride]
+from typing import TypedDict, Unpack
+
+class Params(TypedDict):
+    x: int
+    y: str
+
+class Other(TypedDict):
+    x: int
+    y: int
+
+class B:
+    def meth(self, **kwargs: Unpack[Params]) -> None:
+        ...
+class C(B):
+    def meth(self, **kwargs: Unpack[Other]) -> None:  # E: Signature of "meth" incompatible with supertype "B" \
+                                                      # N:      Superclass: \
+                                                      # N:          def meth(*, x: int, y: str) -> None \
+                                                      # N:      Subclass: \
+                                                      # N:          def meth(*, x: int, y: int) -> None
+        ...
+[builtins fixtures/dict.pyi]
 [typing fixtures/typing-full.pyi]
+
+[case testOverrideErrorLocationNamed]
+class B:
+    def meth(
+        self, *,
+        x: int,
+        y: str,
+    ) -> None:
+        ...
+class C(B):
+    def meth(
+        self, *,
+        y: int,  # E: Argument 1 of "meth" is incompatible with supertype "B"; supertype defines the argument type as "str" \
+                 # N: This violates the Liskov substitution principle \
+                 # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
+        x: int,
+    ) -> None:
+        ...
 [builtins fixtures/tuple.pyi]
+
+[case testLambdaAlwaysAllowed]
+# flags: --disallow-untyped-calls
+from typing import Callable, Optional
+
+def func() -> Optional[str]: ...
+var: Optional[str]
+
+factory: Callable[[], Optional[str]]
+for factory in (
+    lambda: var,
+    func,
+):
+    reveal_type(factory)  # N: Revealed type is "def () -> Union[builtins.str, None]"
+    var = factory()
+[builtins fixtures/tuple.pyi]
+
+[case testLambdaInDeferredDecoratorNoCrash]
+def foo(x):
+    pass
+
+class Bar:
+    def baz(self, x):
+        pass
+
+class Qux(Bar):
+    @foo(lambda x: None)
+    def baz(self, x) -> None:
+        pass
+[builtins fixtures/tuple.pyi]
+
+[case testGeneratorInDeferredDecoratorNoCrash]
+from typing import Protocol, TypeVar
+
+T = TypeVar("T", covariant=True)
+
+class SupportsNext(Protocol[T]):
+    def __next__(self) -> T: ...
+
+def next(i: SupportsNext[T]) -> T: ...
+
+def foo(x):
+    pass
+
+class Bar:
+    def baz(self, x):
+        pass
+
+class Qux(Bar):
+    @next(f for f in [foo])
+    def baz(self, x) -> None:
+        pass
+[builtins fixtures/tuple.pyi]
+
+[case testDistinctFormatting]
+from typing import Awaitable, Callable, ParamSpec
+
+P = ParamSpec("P")
+
+class A: pass
+class B(A): pass
+
+def decorator(f: Callable[P, None]) -> Callable[[Callable[P, A]], None]:
+    return lambda _: None
+
+def key(x: int) -> None: ...
+def fn_b(b: int) -> B: ...
+
+decorator(key)(fn_b)  # E: Argument 1 has incompatible type "Callable[[Arg(int, 'b')], B]"; expected "Callable[[Arg(int, 'x')], A]"
+
+def decorator2(f: Callable[P, None]) -> Callable[
+    [Callable[P, Awaitable[None]]],
+    Callable[P, Awaitable[None]],
+]:
+    return lambda f: f
+
+def key2(x: int) -> None:
+    ...
+
+@decorator2(key2)  # E: Argument 1 has incompatible type "Callable[[Arg(int, 'y')], Coroutine[Any, Any, None]]"; expected "Callable[[Arg(int, 'x')], Awaitable[None]]"
+async def foo2(y: int) -> None:
+    ...
+
+class Parent:
+    def method_without(self) -> "Parent": ...
+    def method_with(self, param: str) -> "Parent": ...
+
+class Child(Parent):
+    method_without: Callable[[], "Child"]
+    method_with: Callable[[str], "Child"]  # E: Incompatible types in assignment (expression has type "Callable[[str], Child]", base class "Parent" defined the type as "Callable[[Arg(str, 'param')], Parent]")
+[builtins fixtures/tuple.pyi]
+
+[case testDistinctFormattingUnion]
+from typing import Callable, Union
+from mypy_extensions import Arg
+
+def f(x: Callable[[Arg(int, 'x')], None]) -> None: pass
+
+y: Callable[[Union[int, str]], None]
+f(y)  # E: Argument 1 to "f" has incompatible type "Callable[[Union[int, str]], None]"; expected "Callable[[Arg(int, 'x')], None]"
+[builtins fixtures/tuple.pyi]
+
+[case testAbstractOverloadsWithoutImplementationAllowed]
+from abc import abstractmethod
+from typing import overload, Union
+
+class Foo:
+    @overload
+    @abstractmethod
+    def foo(self, value: int) -> int:
+        ...
+    @overload
+    @abstractmethod
+    def foo(self, value: str) -> str:
+        ...
+
+class Bar(Foo):
+    @overload
+    def foo(self, value: int) -> int:
+        ...
+    @overload
+    def foo(self, value: str) -> str:
+        ...
+
+    def foo(self, value: Union[int, str]) -> Union[int, str]:
+        return super().foo(value)  # E: Call to abstract method "foo" of "Foo" with trivial body via super() is unsafe
diff --git a/test-data/unit/check-functools.test b/test-data/unit/check-functools.test
index ebfe86f2b241..53ddc96cbe19 100644
--- a/test-data/unit/check-functools.test
+++ b/test-data/unit/check-functools.test
@@ -102,7 +102,6 @@ Ord() >= 1  # E: Unsupported left operand type for >= ("Ord")
 [builtins fixtures/dict.pyi]
 
 [case testCachedProperty]
-# flags: --python-version 3.8
 from functools import cached_property
 class Parent:
     @property
@@ -145,3 +144,517 @@ def f(d: D[C]) -> None:
 
 d: D[int]  # E: Type argument "int" of "D" must be a subtype of "C"
 [builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialBasic]
+from typing import Callable
+import functools
+
+def foo(a: int, b: str, c: int = 5) -> int: ...  # N: "foo" defined here
+
+p1 = functools.partial(foo)
+p1(1, "a", 3)  # OK
+p1(1, "a", c=3)  # OK
+p1(1, b="a", c=3)  # OK
+
+reveal_type(p1)  # N: Revealed type is "functools.partial[builtins.int]"
+
+def takes_callable_int(f: Callable[..., int]) -> None: ...
+def takes_callable_str(f: Callable[..., str]) -> None: ...
+takes_callable_int(p1)
+takes_callable_str(p1)  # E: Argument 1 to "takes_callable_str" has incompatible type "partial[int]"; expected "Callable[..., str]" \
+                        # N: "partial[int].__call__" has type "Callable[[VarArg(Any), KwArg(Any)], int]"
+
+p2 = functools.partial(foo, 1)
+p2("a")  # OK
+p2("a", 3)  # OK
+p2("a", c=3)  # OK
+p2(1, 3)  # E: Argument 1 to "foo" has incompatible type "int"; expected "str"
+p2(1, "a", 3)  # E: Too many arguments for "foo" \
+               # E: Argument 1 to "foo" has incompatible type "int"; expected "str" \
+               # E: Argument 2 to "foo" has incompatible type "str"; expected "int"
+p2(a=1, b="a", c=3)  # E: Unexpected keyword argument "a" for "foo"
+
+p3 = functools.partial(foo, b="a")
+p3(1)  # OK
+p3(1, c=3)  # OK
+p3(a=1)  # OK
+p3(1, b="a", c=3)  # OK, keywords can be clobbered
+p3(1, 3)  # E: Too many positional arguments for "foo" \
+          # E: Argument 2 to "foo" has incompatible type "int"; expected "str"
+
+functools.partial(foo, "a")  # E: Argument 1 to "foo" has incompatible type "str"; expected "int"
+functools.partial(foo, b=1)  # E: Argument "b" to "foo" has incompatible type "int"; expected "str"
+functools.partial(foo, a=1, b=2, c=3)  # E: Argument "b" to "foo" has incompatible type "int"; expected "str"
+functools.partial(1)  # E: "int" not callable \
+                      # E: Argument 1 to "partial" has incompatible type "int"; expected "Callable[..., Never]"
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialStar]
+import functools
+from typing import List
+
+def foo(a: int, b: str, *args: int, d: str, **kwargs: int) -> int: ...
+
+p1 = functools.partial(foo, 1, d="a", x=9)
+p1("a", 2, 3, 4)  # OK
+p1("a", 2, 3, 4, d="a")  # OK
+p1("a", 2, 3, 4, "a")  # E: Argument 5 to "foo" has incompatible type "str"; expected "int"
+p1("a", 2, 3, 4, x="a")  # E: Argument "x" to "foo" has incompatible type "str"; expected "int"
+
+p2 = functools.partial(foo, 1, "a")
+p2(2, 3, 4, d="a")  # OK
+p2("a")  # E: Missing named argument "d" for "foo" \
+         # E: Argument 1 to "foo" has incompatible type "str"; expected "int"
+p2(2, 3, 4)  # E: Missing named argument "d" for "foo"
+
+functools.partial(foo, 1, "a", "b", "c", d="a")  # E: Argument 3 to "foo" has incompatible type "str"; expected "int" \
+                                                 # E: Argument 4 to "foo" has incompatible type "str"; expected "int"
+
+def bar(*a: bytes, **k: int):
+    p1("a", 2, 3, 4, d="a", **k)
+    p1("a", d="a", **k)
+    p1("a", **k)  # E: Argument 2 to "foo" has incompatible type "**Dict[str, int]"; expected "str"
+    p1(**k)  # E: Argument 1 to "foo" has incompatible type "**Dict[str, int]"; expected "str"
+    p1(*a)  # E: Expected iterable as variadic argument
+
+
+def baz(a: int, b: int) -> int: ...
+def test_baz(xs: List[int]):
+    p3 = functools.partial(baz, *xs)
+    p3()
+    p3(1)  # E: Too many arguments for "baz"
+
+
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialGeneric]
+from typing import TypeVar
+import functools
+
+T = TypeVar("T")
+U = TypeVar("U")
+
+def foo(a: T, b: T) -> T: ...
+
+p1 = functools.partial(foo, 1)
+reveal_type(p1(2))  # N: Revealed type is "builtins.int"
+p1("a")  # E: Argument 1 to "foo" has incompatible type "str"; expected "int"
+
+p2 = functools.partial(foo, "a")
+p2(1)  # E: Argument 1 to "foo" has incompatible type "int"; expected "str"
+reveal_type(p2("a"))  # N: Revealed type is "builtins.str"
+
+def bar(a: T, b: U) -> U: ...
+
+p3 = functools.partial(bar, 1)
+reveal_type(p3(2))  # N: Revealed type is "builtins.int"
+reveal_type(p3("a"))  # N: Revealed type is "builtins.str"
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialCallable]
+from typing import Callable
+import functools
+
+def main1(f: Callable[[int, str], int]) -> None:
+    p = functools.partial(f, 1)
+    p("a")  # OK
+    p(1)  # E: Argument 1 has incompatible type "int"; expected "str"
+
+    functools.partial(f, a=1)  # E: Unexpected keyword argument "a"
+
+class CallbackProto:
+    def __call__(self, a: int, b: str) -> int: ...
+
+def main2(f: CallbackProto) -> None:
+    p = functools.partial(f, b="a")
+    p(1)  # OK
+    p("a")  # E: Argument 1 to "__call__" of "CallbackProto" has incompatible type "str"; expected "int"
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialOverload]
+from typing import overload
+import functools
+
+@overload
+def foo(a: int, b: str) -> int: ...
+@overload
+def foo(a: str, b: int) -> str: ...
+def foo(*a, **k): ...
+
+p1 = functools.partial(foo)
+reveal_type(p1(1, "a"))  # N: Revealed type is "builtins.int"
+reveal_type(p1("a", 1))  # N: Revealed type is "builtins.int"
+p1(1, 2)  # TODO: false negative
+p1("a", "b")  # TODO: false negative
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialTypeGuard]
+# flags: --python-version 3.8
+import functools
+from typing_extensions import TypeGuard
+
+def is_str_list(val: list[object]) -> TypeGuard[list[str]]: ...  # E: "list" is not subscriptable, use "typing.List" instead
+
+reveal_type(functools.partial(is_str_list, [1, 2, 3]))  # N: Revealed type is "functools.partial[builtins.bool]"
+reveal_type(functools.partial(is_str_list, [1, 2, 3])())  # N: Revealed type is "builtins.bool"
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialType]
+import functools
+from typing import Type
+
+class A:
+    def __init__(self, a: int, b: str) -> None: ...  # N: "A" defined here
+
+p = functools.partial(A, 1)
+reveal_type(p)  # N: Revealed type is "functools.partial[__main__.A]"
+
+p("a")  # OK
+p(1)  # E: Argument 1 to "A" has incompatible type "int"; expected "str"
+p(z=1)  # E: Unexpected keyword argument "z" for "A"
+
+def main(t: Type[A]) -> None:
+    p = functools.partial(t, 1)
+    reveal_type(p)  # N: Revealed type is "functools.partial[__main__.A]"
+
+    p("a")  # OK
+    p(1)  # E: Argument 1 to "A" has incompatible type "int"; expected "str"
+    p(z=1)  # E: Unexpected keyword argument "z" for "A"
+
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialTypeVarTuple]
+import functools
+import typing
+Ts = typing.TypeVarTuple("Ts")
+def foo(fn: typing.Callable[[typing.Unpack[Ts]], None], /, *arg: typing.Unpack[Ts], kwarg: str) -> None: ...
+p = functools.partial(foo, kwarg="asdf")
+
+def bar(a: int, b: str, c: float) -> None: ...
+p(bar, 1, "a", 3.0)  # OK
+p(bar, 1, "a", 3.0, kwarg="asdf")  # OK
+p(bar, 1, "a", "b")  # E: Argument 1 to "foo" has incompatible type "Callable[[int, str, float], None]"; expected "Callable[[int, str, str], None]"
+[builtins fixtures/dict.pyi]
+
+[case testFunctoolsPartialUnion]
+import functools
+from typing import Any, Callable, Union
+
+cls1: Any
+cls2: Union[Any, Any]
+reveal_type(functools.partial(cls1, 2)())  # N: Revealed type is "Any"
+reveal_type(functools.partial(cls2, 2)())  # N: Revealed type is "Any"
+
+fn1: Union[Callable[[int], int], Callable[[int], int]]
+reveal_type(functools.partial(fn1, 2)())  # N: Revealed type is "builtins.int"
+
+fn2: Union[Callable[[int], int], Callable[[int], str]]
+reveal_type(functools.partial(fn2, 2)())  # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+fn3: Union[Callable[[int], int], str]
+reveal_type(functools.partial(fn3, 2)())  # E: "str" not callable \
+                                          # N: Revealed type is "builtins.int" \
+                                          # E: Argument 1 to "partial" has incompatible type "Union[Callable[[int], int], str]"; expected "Callable[..., int]"
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialUnionOfTypeAndCallable]
+import functools
+from typing import Callable, Union, Type
+from typing_extensions import TypeAlias
+
+class FooBar:
+    def __init__(self, arg1: str) -> None:
+        pass
+
+def f1(t: Union[Type[FooBar], Callable[..., 'FooBar']]) -> None:
+    val = functools.partial(t)
+
+FooBarFunc: TypeAlias = Callable[..., 'FooBar']
+
+def f2(t: Union[Type[FooBar], FooBarFunc]) -> None:
+    val = functools.partial(t)
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialExplicitType]
+from functools import partial
+from typing import Type, TypeVar, Callable
+
+T = TypeVar("T")
+def generic(string: str, integer: int, resulting_type: Type[T]) -> T: ...
+
+p: partial[str] = partial(generic, resulting_type=str)
+q: partial[bool] = partial(generic, resulting_type=str)  # E: Argument "resulting_type" to "generic" has incompatible type "Type[str]"; expected "Type[bool]"
+
+pc: Callable[..., str] = partial(generic, resulting_type=str)
+qc: Callable[..., bool] = partial(generic, resulting_type=str)  # E: Incompatible types in assignment (expression has type "partial[str]", variable has type "Callable[..., bool]") \
+                                                                # N: "partial[str].__call__" has type "Callable[[VarArg(Any), KwArg(Any)], str]"
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialNestedPartial]
+from functools import partial
+from typing import Any
+
+def foo(x: int) -> int: ...
+p = partial(partial, foo)
+reveal_type(p()(1))  # N: Revealed type is "builtins.int"
+p()("no")  # E: Argument 1 to "foo" has incompatible type "str"; expected "int"
+
+q = partial(partial, partial, foo)
+q()()("no")  # E: Argument 1 to "foo" has incompatible type "str"; expected "int"
+
+r = partial(partial, foo, 1)
+reveal_type(r()())  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialTypeObject]
+import functools
+from typing import Type, Generic, TypeVar
+
+class A:
+    def __init__(self, val: int) -> None: ...
+
+cls1: Type[A]
+reveal_type(functools.partial(cls1, 2)())  # N: Revealed type is "__main__.A"
+functools.partial(cls1, "asdf")  # E: Argument 1 to "A" has incompatible type "str"; expected "int"
+
+T = TypeVar("T")
+class B(Generic[T]):
+    def __init__(self, val: T) -> None: ...
+
+cls2: Type[B[int]]
+reveal_type(functools.partial(cls2, 2)())  # N: Revealed type is "__main__.B[builtins.int]"
+functools.partial(cls2, "asdf")  # E: Argument 1 to "B" has incompatible type "str"; expected "int"
+
+def foo(cls3: Type[B[T]]):
+    reveal_type(functools.partial(cls3, "asdf"))  # N: Revealed type is "functools.partial[__main__.B[T`-1]]" \
+                                                  # E: Argument 1 to "B" has incompatible type "str"; expected "T"
+    reveal_type(functools.partial(cls3, 2)())  # N: Revealed type is "__main__.B[T`-1]" \
+                                               # E: Argument 1 to "B" has incompatible type "int"; expected "T"
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialTypedDictUnpack]
+from typing import TypedDict
+from typing_extensions import Unpack
+from functools import partial
+
+class D1(TypedDict, total=False):
+    a1: int
+
+def fn1(a1: int) -> None: ...  # N: "fn1" defined here
+def main1(**d1: Unpack[D1]) -> None:
+    partial(fn1, **d1)()
+    partial(fn1, **d1)(**d1)
+    partial(fn1, **d1)(a1=1)
+    partial(fn1, **d1)(a1="asdf")  # E: Argument "a1" to "fn1" has incompatible type "str"; expected "int"
+    partial(fn1, **d1)(oops=1)  # E: Unexpected keyword argument "oops" for "fn1"
+
+def fn2(**kwargs: Unpack[D1]) -> None: ...  # N: "fn2" defined here
+def main2(**d1: Unpack[D1]) -> None:
+    partial(fn2, **d1)()
+    partial(fn2, **d1)(**d1)
+    partial(fn2, **d1)(a1=1)
+    partial(fn2, **d1)(a1="asdf")  # E: Argument "a1" to "fn2" has incompatible type "str"; expected "int"
+    partial(fn2, **d1)(oops=1)  # E: Unexpected keyword argument "oops" for "fn2"
+
+class D2(TypedDict, total=False):
+    a1: int
+    a2: str
+
+class A2Good(TypedDict, total=False):
+    a2: str
+class A2Bad(TypedDict, total=False):
+    a2: int
+
+def fn3(a1: int, a2: str) -> None: ...  # N: "fn3" defined here
+def main3(a2good: A2Good, a2bad: A2Bad, **d2: Unpack[D2]) -> None:
+    partial(fn3, **d2)()
+    partial(fn3, **d2)(a1=1, a2="asdf")
+
+    partial(fn3, **d2)(**d2)
+
+    partial(fn3, **d2)(a1="asdf")  # E: Argument "a1" to "fn3" has incompatible type "str"; expected "int"
+    partial(fn3, **d2)(a1=1, a2="asdf", oops=1)  # E: Unexpected keyword argument "oops" for "fn3"
+
+    partial(fn3, **d2)(**a2good)
+    partial(fn3, **d2)(**a2bad)  # E: Argument "a2" to "fn3" has incompatible type "int"; expected "str"
+
+def fn4(**kwargs: Unpack[D2]) -> None: ...  # N: "fn4" defined here
+def main4(a2good: A2Good, a2bad: A2Bad, **d2: Unpack[D2]) -> None:
+    partial(fn4, **d2)()
+    partial(fn4, **d2)(a1=1, a2="asdf")
+
+    partial(fn4, **d2)(**d2)
+
+    partial(fn4, **d2)(a1="asdf")  # E: Argument "a1" to "fn4" has incompatible type "str"; expected "int"
+    partial(fn4, **d2)(a1=1, a2="asdf", oops=1)  # E: Unexpected keyword argument "oops" for "fn4"
+
+    partial(fn3, **d2)(**a2good)
+    partial(fn3, **d2)(**a2bad)  # E: Argument "a2" to "fn3" has incompatible type "int"; expected "str"
+
+def main5(**d2: Unpack[D2]) -> None:
+    partial(fn1, **d2)()  # E: Extra argument "a2" from **args for "fn1"
+    partial(fn2, **d2)()  # E: Extra argument "a2" from **args for "fn2"
+
+def main6(a2good: A2Good, a2bad: A2Bad, **d1: Unpack[D1]) -> None:
+    partial(fn3, **d1)()  # E: Missing positional argument "a1" in call to "fn3"
+    partial(fn3, **d1)("asdf")  # E: Too many positional arguments for "fn3" \
+                                # E: Too few arguments for "fn3" \
+                                # E: Argument 1 to "fn3" has incompatible type "str"; expected "int"
+    partial(fn3, **d1)(a2="asdf")
+    partial(fn3, **d1)(**a2good)
+    partial(fn3, **d1)(**a2bad)  # E: Argument "a2" to "fn3" has incompatible type "int"; expected "str"
+
+    partial(fn4, **d1)()
+    partial(fn4, **d1)("asdf")  # E: Too many positional arguments for "fn4" \
+                                # E: Argument 1 to "fn4" has incompatible type "str"; expected "int"
+    partial(fn4, **d1)(a2="asdf")
+    partial(fn4, **d1)(**a2good)
+    partial(fn4, **d1)(**a2bad)  # E: Argument "a2" to "fn4" has incompatible type "int"; expected "str"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+
+[case testFunctoolsPartialNestedGeneric]
+from functools import partial
+from typing import Generic, TypeVar, List
+
+T = TypeVar("T")
+def get(n: int, args: List[T]) -> T: ...
+first = partial(get, 0)
+
+x: List[str]
+reveal_type(first(x))  # N: Revealed type is "builtins.str"
+reveal_type(first([1]))  # N: Revealed type is "builtins.int"
+
+first_kw = partial(get, n=0)
+reveal_type(first_kw(args=[1]))  # N: Revealed type is "builtins.int"
+
+# TODO: this is indeed invalid, but the error is incomprehensible.
+first_kw([1])  # E: Too many positional arguments for "get" \
+               # E: Too few arguments for "get" \
+               # E: Argument 1 to "get" has incompatible type "List[int]"; expected "int"
+[builtins fixtures/list.pyi]
+
+[case testFunctoolsPartialHigherOrder]
+from functools import partial
+from typing import Callable
+
+def fn(a: int, b: str, c: bytes) -> int: ...
+
+def callback1(fn: Callable[[str, bytes], int]) -> None: ...
+def callback2(fn: Callable[[str, int], int]) -> None: ...
+
+callback1(partial(fn, 1))
+# TODO: false negative
+# https://github.com/python/mypy/issues/17461
+callback2(partial(fn, 1))
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialClassObjectMatchingPartial]
+from functools import partial
+
+class A:
+    def __init__(self, var: int, b: int, c: int) -> None: ...
+
+p = partial(A, 1)
+reveal_type(p)  # N: Revealed type is "functools.partial[__main__.A]"
+p(1, "no")  # E: Argument 2 to "A" has incompatible type "str"; expected "int"
+
+q: partial[A] = partial(A, 1)  # OK
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialTypeVarBound]
+from typing import Callable, TypeVar, Type
+import functools
+
+T = TypeVar("T", bound=Callable[[str, int], str])
+S = TypeVar("S", bound=Type[int])
+
+def foo(f: T) -> T:
+    g = functools.partial(f, "foo")
+    return f
+
+def bar(f: S) -> S:
+    g = functools.partial(f, "foo")
+    return f
+[builtins fixtures/primitives.pyi]
+
+[case testFunctoolsPartialAbstractType]
+# flags: --python-version 3.9
+from abc import ABC, abstractmethod
+from functools import partial
+
+class A(ABC):
+    def __init__(self) -> None: ...
+    @abstractmethod
+    def method(self) -> None: ...
+
+def f1(cls: type[A]) -> None:
+    cls()
+    partial_cls = partial(cls)
+    partial_cls()
+
+def f2() -> None:
+    A()  # E: Cannot instantiate abstract class "A" with abstract attribute "method"
+    partial_cls = partial(A)  # E: Cannot instantiate abstract class "A" with abstract attribute "method"
+    partial_cls()  # E: Cannot instantiate abstract class "A" with abstract attribute "method"
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialSelfType]
+from functools import partial
+from typing_extensions import Self
+
+class A:
+    def __init__(self, ts: float, msg: str) -> None: ...
+
+    @classmethod
+    def from_msg(cls, msg: str) -> Self:
+        factory = partial(cls, ts=0)
+        return factory(msg=msg)
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialTypeVarValues]
+from functools import partial
+from typing import TypeVar
+
+T = TypeVar("T", int, str)
+
+def f(x: int, y: T) -> T:
+    return y
+
+def g(x: T, y: int) -> T:
+    return x
+
+def h(x: T, y: T) -> T:
+    return x
+
+fp = partial(f, 1)
+reveal_type(fp(1))  # N: Revealed type is "builtins.int"
+reveal_type(fp("a"))  # N: Revealed type is "builtins.str"
+fp(object())  # E: Value of type variable "T" of "f" cannot be "object"
+
+gp = partial(g, 1)
+reveal_type(gp(1))  # N: Revealed type is "builtins.int"
+gp("a")  # E: Argument 1 to "g" has incompatible type "str"; expected "int"
+
+hp = partial(h, 1)
+reveal_type(hp(1))  # N: Revealed type is "builtins.int"
+hp("a")  # E: Argument 1 to "h" has incompatible type "str"; expected "int"
+[builtins fixtures/tuple.pyi]
+
+[case testFunctoolsPartialOverloadedCallableProtocol]
+from functools import partial
+from typing import Callable, Protocol, overload
+
+class P(Protocol):
+    @overload
+    def __call__(self, x: int) -> int: ...
+    @overload
+    def __call__(self, x: str) -> str: ...
+
+def f(x: P):
+    reveal_type(partial(x, 1)())  # N: Revealed type is "builtins.int"
+
+    # TODO: but this is incorrect, predating the functools.partial plugin
+    reveal_type(partial(x, "a")())  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-generic-alias.test b/test-data/unit/check-generic-alias.test
index 574a57607d11..3ae815a5cd48 100644
--- a/test-data/unit/check-generic-alias.test
+++ b/test-data/unit/check-generic-alias.test
@@ -1,7 +1,7 @@
 -- Test cases for generic aliases
 
 [case testGenericBuiltinWarning]
-# flags: --python-version 3.7
+# flags: --python-version 3.8
 t1: list
 t2: list[int]  # E: "list" is not subscriptable, use "typing.List" instead
 t3: list[str]  # E: "list" is not subscriptable, use "typing.List" instead
@@ -21,14 +21,14 @@ t11: type[int]  # E: "type" expects no type arguments, but 1 given
 
 
 [case testGenericBuiltinSetWarning]
-# flags: --python-version 3.7
+# flags: --python-version 3.8
 t1: set
 t2: set[int]  # E: "set" is not subscriptable, use "typing.Set" instead
 [builtins fixtures/set.pyi]
 
 
 [case testGenericCollectionsWarning]
-# flags: --python-version 3.7
+# flags: --python-version 3.8
 import collections
 
 t01: collections.deque
@@ -44,7 +44,6 @@ t10: collections.ChainMap[int, str]  # E: "ChainMap" is not subscriptable, use "
 
 
 [case testGenericBuiltinFutureAnnotations]
-# flags: --python-version 3.7
 from __future__ import annotations
 t1: list
 t2: list[int]
@@ -64,7 +63,6 @@ t11: type[int]
 
 
 [case testGenericCollectionsFutureAnnotations]
-# flags: --python-version 3.7
 from __future__ import annotations
 import collections
 
@@ -200,7 +198,6 @@ t23: collections.abc.ValuesView[str]
 
 
 [case testGenericBuiltinTupleTyping]
-# flags: --python-version 3.6
 from typing import Tuple
 
 t01: Tuple = ()
@@ -248,7 +245,6 @@ reveal_type(tuple[int, ...]())  # N: Revealed type is "builtins.tuple[builtins.i
 [builtins fixtures/tuple.pyi]
 
 [case testTypeAliasWithBuiltinTupleInStub]
-# flags: --python-version 3.6
 import m
 reveal_type(m.a)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 reveal_type(m.b)  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
@@ -261,7 +257,6 @@ b: B
 [builtins fixtures/tuple.pyi]
 
 [case testTypeAliasWithBuiltinListInStub]
-# flags: --python-version 3.6
 import m
 reveal_type(m.a)  # N: Revealed type is "builtins.list[builtins.int]"
 reveal_type(m.b)  # N: Revealed type is "builtins.list[builtins.list[builtins.int]]"
@@ -280,7 +275,6 @@ d: type[str]
 
 
 [case testTypeAliasWithBuiltinListAliasInStub]
-# flags: --python-version 3.6
 import m
 reveal_type(m.a()[0])  # N: Revealed type is "builtins.int"
 
diff --git a/test-data/unit/check-generic-subtyping.test b/test-data/unit/check-generic-subtyping.test
index a34e054fd827..89465869f09d 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
@@ -302,7 +306,7 @@ main:14: error: Signature of "f" incompatible with supertype "A"
 main:14: note:      Superclass:
 main:14: note:          def [S] f(self, x: int, y: S) -> None
 main:14: note:      Subclass:
-main:14: note:          def [T1 <: str, S] f(self, x: T1, y: S) -> None
+main:14: note:          def [T1: str, S] f(self, x: T1, y: S) -> None
 
 -- Inheritance from generic types with implicit dynamic supertype
 -- --------------------------------------------------------------
@@ -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
@@ -430,7 +434,7 @@ B(1)
 C(1)
 C('a')  # E: Argument 1 to "C" has incompatible type "str"; expected "int"
 D(A(1))
-D(1)  # E: Argument 1 to "D" has incompatible type "int"; expected "A[<nothing>]"
+D(1)  # E: Argument 1 to "D" has incompatible type "int"; expected "A[Never]"
 
 
 [case testInheritedConstructor2]
@@ -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]")
@@ -1052,3 +1065,158 @@ class F(E[T_co], Generic[T_co]): ...  # E: Variance of TypeVar "T_co" incompatib
 
 class G(Generic[T]): ...
 class H(G[T_contra], Generic[T_contra]): ...  # E: Variance of TypeVar "T_contra" incompatible with variance in parent type
+
+[case testParameterizedGenericOverrideWithProperty]
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+class A(Generic[T]):
+    def __init__(self, val: T):
+        self.member: T = val
+
+class B(A[str]):
+    member: str
+
+class GoodPropertyOverride(A[str]):
+    @property
+    def member(self) -> str: ...
+    @member.setter
+    def member(self, val: str): ...
+
+class BadPropertyOverride(A[str]):
+    @property  # E: Signature of "member" incompatible with supertype "A" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          int
+    def member(self) -> int: ...
+    @member.setter
+    def member(self, val: int): ...
+
+class BadGenericPropertyOverride(A[str], Generic[T]):
+    @property  # E: Signature of "member" incompatible with supertype "A" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          T
+    def member(self) -> T: ...
+    @member.setter
+    def member(self, val: T): ...
+[builtins fixtures/property.pyi]
+
+[case testParameterizedGenericPropertyOverrideWithProperty]
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+class A(Generic[T]):
+    @property
+    def member(self) -> T: ...
+    @member.setter
+    def member(self, val: T): ...
+
+class B(A[str]):
+    member: str
+
+class GoodPropertyOverride(A[str]):
+    @property
+    def member(self) -> str: ...
+    @member.setter
+    def member(self, val: str): ...
+
+class BadPropertyOverride(A[str]):
+    @property  # E: Signature of "member" incompatible with supertype "A" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          int
+    def member(self) -> int: ...
+    @member.setter
+    def member(self, val: int): ...
+
+class BadGenericPropertyOverride(A[str], Generic[T]):
+    @property  # E: Signature of "member" incompatible with supertype "A" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          T
+    def member(self) -> T: ...
+    @member.setter
+    def member(self, val: T): ...
+[builtins fixtures/property.pyi]
+
+[case testParameterizedGenericOverrideSelfWithProperty]
+from typing_extensions import Self
+
+class A:
+    def __init__(self, val: Self):
+        self.member: Self = val
+
+class GoodPropertyOverride(A):
+    @property
+    def member(self) -> "GoodPropertyOverride": ...
+    @member.setter
+    def member(self, val: "GoodPropertyOverride"): ...
+
+class GoodPropertyOverrideSelf(A):
+    @property
+    def member(self) -> Self: ...
+    @member.setter
+    def member(self, val: Self): ...
+[builtins fixtures/property.pyi]
+
+[case testParameterizedGenericOverrideWithSelfProperty]
+from typing import TypeVar, Generic
+from typing_extensions import Self
+
+T = TypeVar("T")
+
+class A(Generic[T]):
+    def __init__(self, val: T):
+        self.member: T = val
+
+class B(A["B"]):
+    member: Self
+
+class GoodPropertyOverride(A["GoodPropertyOverride"]):
+    @property
+    def member(self) -> Self: ...
+    @member.setter
+    def member(self, val: Self): ...
+[builtins fixtures/property.pyi]
+
+[case testMultipleInheritanceCompatibleTypeVar]
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+U = TypeVar("U")
+
+class A(Generic[T]):
+    x: T
+    def fn(self, t: T) -> None: ...
+
+class A2(A[T]):
+    y: str
+    z: str
+
+class B(Generic[T]):
+    x: T
+    def fn(self, t: T) -> None: ...
+
+class C1(A2[str], B[str]): pass
+class C2(A2[str], B[int]): pass  # E: Definition of "fn" in base class "A" is incompatible with definition in base class "B" \
+                                 # E: Definition of "x" in base class "A" is incompatible with definition in base class "B"
+class C3(A2[T], B[T]): pass
+class C4(A2[U], B[U]): pass
+class C5(A2[U], B[T]): pass  # E: Definition of "fn" in base class "A" is incompatible with definition in base class "B" \
+                             # E: Definition of "x" in base class "A" is incompatible with definition in base class "B"
+
+class D1(A[str], B[str]): pass
+class D2(A[str], B[int]): pass  # E: Definition of "fn" in base class "A" is incompatible with definition in base class "B" \
+                                # E: Definition of "x" in base class "A" is incompatible with definition in base class "B"
+class D3(A[T], B[T]): pass
+class D4(A[U], B[U]): pass
+class D5(A[U], B[T]): pass  # E: Definition of "fn" in base class "A" is incompatible with definition in base class "B" \
+                            # E: Definition of "x" in base class "A" is incompatible with definition in base class "B"
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
index 06b80be85096..767b55efcac2 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,11 +454,13 @@ A[int, str, int]() # E: Type application has too many types (2 expected)
 [out]
 
 [case testInvalidTypeApplicationType]
-a = None # type: A
+import types
+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
-[out]
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testTypeApplicationArgTypes]
 from typing import TypeVar, Generic
@@ -501,8 +515,10 @@ Alias[int]("a")  # E: Argument 1 to "Node" has incompatible type "str"; expected
 [out]
 
 [case testTypeApplicationCrash]
+# flags: --python-version 3.8
+import types
 type[int] # this was crashing, see #2302 (comment)  # E: The type "Type[type]" is not generic and not indexable
-[out]
+[builtins fixtures/tuple.pyi]
 
 
 -- Generic type aliases
@@ -546,7 +562,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
@@ -561,7 +577,7 @@ def func(x: IntNode[T]) -> IntNode[T]:
     return x
 reveal_type(func) # N: Revealed type is "def [T] (x: __main__.Node[builtins.int, T`-1]) -> __main__.Node[builtins.int, T`-1]"
 
-func(1) # E: Argument 1 to "func" has incompatible type "int"; expected "Node[int, <nothing>]"
+func(1) # E: Argument 1 to "func" has incompatible type "int"; expected "Node[int, Never]"
 func(Node('x', 1)) # E: Argument 1 to "Node" has incompatible type "str"; expected "int"
 reveal_type(func(Node(1, 'x'))) # N: Revealed type is "__main__.Node[builtins.int, builtins.str]"
 
@@ -576,7 +592,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]
@@ -584,7 +600,7 @@ main:13: error: Argument 2 to "Node" has incompatible type "int"; expected "str"
 
 -- Error formatting is a bit different (and probably better) with new analyzer
 [case testGenericTypeAliasesWrongAliases]
-# flags: --show-column-numbers --python-version 3.6 --no-strict-optional
+# flags: --show-column-numbers --no-strict-optional
 from typing import TypeVar, Generic, List, Callable, Tuple, Union
 T = TypeVar('T')
 S = TypeVar('S')
@@ -612,13 +628,14 @@ reveal_type(y)
 X = T # Error
 
 [builtins fixtures/list.pyi]
+[typing fixtures/typing-full.pyi]
 [out]
 main:9:5: error: "Node" expects 2 type arguments, but 1 given
 main:11:5: error: "Node" expects 2 type arguments, but 3 given
 main:15:10: error: "list" expects 1 type argument, but 2 given
 main:16:19: error: "list" expects 1 type argument, but 2 given
 main:17:25: error: "Node" expects 2 type arguments, but 1 given
-main:19:5: error: Bad number of arguments for type alias, expected: 1, given: 2
+main:19:5: error: Bad number of arguments for type alias, expected 1, given 2
 main:22:13: note: Revealed type is "__main__.Node[builtins.int, builtins.str]"
 main:24:13: note: Revealed type is "__main__.Node[__main__.Node[builtins.int, builtins.int], builtins.list[builtins.int]]"
 main:26:5: error: Type variable "__main__.T" is invalid as target for type alias
@@ -655,7 +672,7 @@ reveal_type(a) # N: Revealed type is "other.array[Any, other.dtype[builtins.floa
 [out]
 main:3: error: Type argument "float" of "Array" must be a subtype of "generic"  [type-var]
     a: other.Array[float]
-       ^
+                   ^
 [file other.py]
 from typing import Any, Generic, TypeVar
 
@@ -686,7 +703,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)
@@ -697,7 +714,7 @@ reveal_type(z) # N: Revealed type is "__main__.Node[Any, Any]"
 
 [out]
 
-[case testGenericTypeAliasesAcessingMethods]
+[case testGenericTypeAliasesAccessingMethods]
 from typing import TypeVar, Generic, List
 T = TypeVar('T')
 class Node(Generic[T]):
@@ -707,7 +724,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]"
@@ -822,7 +839,7 @@ reveal_type(x) # N: Revealed type is "builtins.int"
 def f2(x: IntTP[T]) -> IntTP[T]:
     return x
 
-f2((1, 2, 3)) # E: Argument 1 to "f2" has incompatible type "Tuple[int, int, int]"; expected "Tuple[int, <nothing>]"
+f2((1, 2, 3)) # E: Argument 1 to "f2" has incompatible type "Tuple[int, int, int]"; expected "Tuple[int, Never]"
 reveal_type(f2((1, 'x'))) # N: Revealed type is "Tuple[builtins.int, builtins.str]"
 
 [builtins fixtures/for.pyi]
@@ -848,7 +865,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 +901,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]")
@@ -892,7 +909,7 @@ n.y = 'x' # E: Incompatible types in assignment (expression has type "str", vari
 def f(x: Node[T, T]) -> TupledNode[T]:
     return Node(x.x, (x.x, x.x))
 
-f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "Node[<nothing>, <nothing>]"
+f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "Node[Never, Never]"
 f(Node(1, 'x')) # E: Cannot infer type argument 1 of "f"
 reveal_type(Node('x', 'x')) # N: Revealed type is "a.Node[builtins.str, builtins.str]"
 
@@ -932,7 +949,7 @@ Transform = Callable[[T, int], Tuple[T, R]]
 
 [case testGenericTypeAliasesImportingWithoutTypeVarError]
 from a import Alias
-x: Alias[int, str]  # E: Bad number of arguments for type alias, expected: 1, given: 2
+x: Alias[int, str]  # E: Bad number of arguments for type alias, expected 1, given 2
 reveal_type(x)  # N: Revealed type is "builtins.list[builtins.list[Any]]"
 
 [file a.py]
@@ -941,7 +958,6 @@ T = TypeVar('T')
 
 Alias = List[List[T]]
 [builtins fixtures/list.pyi]
-[out]
 
 [case testGenericAliasWithTypeVarsFromDifferentModules]
 from mod import Alias, TypeVar
@@ -988,8 +1004,8 @@ reveal_type(x)  # N: Revealed type is "Union[builtins.int, None]"
 reveal_type(y)  # N: Revealed type is "builtins.int"
 
 U[int]  # E: Type application targets a non-generic function or class
-O[int]  # E: Bad number of arguments for type alias, expected: 0, given: 1  # E: Type application is only supported for generic classes
-[out]
+O[int]  # E: Bad number of arguments for type alias, expected 0, given 1 \
+        # E: Type application is only supported for generic classes
 
 [case testAliasesInClassBodyNormalVsSubscripted]
 
@@ -1115,6 +1131,7 @@ reveal_type(Bad) # N: Revealed type is "Any"
 [out]
 
 [case testNoSubscriptionOfBuiltinAliases]
+# flags: --python-version 3.8
 from typing import List, TypeVar
 
 list[int]() # E: "list" is not subscriptable
@@ -1282,9 +1299,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 +1330,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 +1352,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 +1397,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 +1410,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 +1422,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 +1441,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 +1470,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")
@@ -1467,6 +1486,30 @@ if int():
     b = f(b)
 [builtins fixtures/list.pyi]
 
+[case testGenericDictWithOverload]
+from typing import Dict, Generic, TypeVar, Any, overload
+T = TypeVar("T")
+
+class Key(Generic[T]): ...
+class CustomDict(dict):
+    @overload  # type: ignore[override]
+    def __setitem__(self, key: Key[T], value: T) -> None: ...
+    @overload
+    def __setitem__(self, key: str, value: Any) -> None: ...
+    def __setitem__(self, key, value):
+        return super().__setitem__(key, value)
+
+def a1(d: Dict[str, Any]) -> None:
+    if (var := d.get("arg")) is None:
+        var = d["arg"] = {}
+        reveal_type(var)  # N: Revealed type is "builtins.dict[Any, Any]"
+
+def a2(d: CustomDict) -> None:
+    if (var := d.get("arg")) is None:
+        var = d["arg"] = {}
+        reveal_type(var)  # N: Revealed type is "builtins.dict[Any, Any]"
+[builtins fixtures/dict.pyi]
+
 
 -- Type variable scoping
 -- ---------------------
@@ -1571,17 +1614,17 @@ if int():
 if int():
     y1 = f3
 if int():
-    y1 = f4 # E: Incompatible types in assignment (expression has type "Callable[[int], A]", variable has type "Callable[[A], A]")
+    y1 = f4 # E: Incompatible types in assignment (expression has type "Callable[[int], A@f4]", variable has type "Callable[[A@f1], A@f1]")
 
 y2 = f2
 if int():
     y2 = f2
 if int():
-    y2 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[A], B]")
+    y2 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A@f1], A@f1]", variable has type "Callable[[A@f2], B]")
 if int():
-    y2 = f3 # E: Incompatible types in assignment (expression has type "Callable[[B], B]", variable has type "Callable[[A], B]")
+    y2 = f3 # E: Incompatible types in assignment (expression has type "Callable[[B@f3], B@f3]", variable has type "Callable[[A], B@f2]")
 if int():
-    y2 = f4 # E: Incompatible types in assignment (expression has type "Callable[[int], A]", variable has type "Callable[[A], B]")
+    y2 = f4 # E: Incompatible types in assignment (expression has type "Callable[[int], A@f4]", variable has type "Callable[[A@f2], B]")
 
 y3 = f3
 if int():
@@ -1597,7 +1640,7 @@ y4 = f4
 if int():
     y4 = f4
 if int():
-    y4 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[int], A]")
+    y4 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A@f1], A@f1]", variable has type "Callable[[int], A@f4]")
 if int():
     y4 = f2
 if int():
@@ -1618,26 +1661,26 @@ def outer(t: T) -> None:
     y1 = f1
     if int():
         y1 = f2
-        y1 = f3 # E: Incompatible types in assignment (expression has type "Callable[[T], A]", variable has type "Callable[[A], A]")
-        y1 = f4 # E: Incompatible types in assignment (expression has type "Callable[[A], T]", variable has type "Callable[[A], A]")
+        y1 = f3 # E: Incompatible types in assignment (expression has type "Callable[[T], A@f3]", variable has type "Callable[[A@f1], A@f1]")
+        y1 = f4 # E: Incompatible types in assignment (expression has type "Callable[[A@f4], T]", variable has type "Callable[[A@f1], A@f1]")
         y1 = f5 # E: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[A], A]")
 
     y2 = f2
     if int():
-        y2 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[A], B]")
+        y2 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A@f1], A@f1]", variable has type "Callable[[A@f2], B]")
 
     y3 = f3
     if int():
-        y3 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[T], A]")
+        y3 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A@f1], A@f1]", variable has type "Callable[[T], A@f3]")
         y3 = f2
-        y3 = f4 # E: Incompatible types in assignment (expression has type "Callable[[A], T]", variable has type "Callable[[T], A]")
+        y3 = f4 # E: Incompatible types in assignment (expression has type "Callable[[A@f4], T]", variable has type "Callable[[T], A@f3]")
         y3 = f5 # E: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[T], A]")
 
     y4 = f4
     if int():
-        y4 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[A], T]")
+        y4 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A@f1], A@f1]", variable has type "Callable[[A@f4], T]")
         y4 = f2
-        y4 = f3 # E: Incompatible types in assignment (expression has type "Callable[[T], A]", variable has type "Callable[[A], T]")
+        y4 = f3 # E: Incompatible types in assignment (expression has type "Callable[[T], A@f3]", variable has type "Callable[[A@f4], T]")
         y4 = f5 # E: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[A], T]")
 
     y5 = f5
@@ -1646,7 +1689,6 @@ def outer(t: T) -> None:
         y5 = f2
         y5 = f3
         y5 = f4
-[out]
 
 [case testSubtypingWithGenericFunctionUsingTypevarWithValues]
 from typing import TypeVar, Callable
@@ -1731,8 +1773,7 @@ T = TypeVar('T')
 class C(Generic[T]):
     def __init__(self) -> None: pass
 x = C # type: Callable[[], C[int]]
-y = C # type: Callable[[], int] # E: Incompatible types in assignment (expression has type "Type[C[Any]]", variable has type "Callable[[], int]")
-
+y = C # type: Callable[[], int] # E: Incompatible types in assignment (expression has type "Type[C[T]]", variable has type "Callable[[], int]")
 
 -- Special cases
 -- -------------
@@ -2265,7 +2306,7 @@ class Box(Generic[T]):
 
 class IteratorBox(Box[Iterator[T]]): ...
 
-@IteratorBox.wrap  # E: Argument 1 to "wrap" of "Box" has incompatible type "Callable[[], int]"; expected "Callable[[], Iterator[<nothing>]]"
+@IteratorBox.wrap  # E: Argument 1 to "wrap" of "Box" has incompatible type "Callable[[], int]"; expected "Callable[[], Iterator[Never]]"
 def g() -> int:
     ...
 [builtins fixtures/classmethod.pyi]
@@ -2283,6 +2324,19 @@ def func(x: S) -> S:
     return C[S].get()
 [builtins fixtures/classmethod.pyi]
 
+[case testGenericStaticMethodInGenericFunction]
+from typing import Generic, TypeVar
+T = TypeVar('T')
+S = TypeVar('S')
+
+class C(Generic[T]):
+    @staticmethod
+    def get() -> T: ...
+
+def func(x: S) -> S:
+    return C[S].get()
+[builtins fixtures/staticmethod.pyi]
+
 [case testMultipleAssignmentFromAnyIterable]
 from typing import Any
 class A:
@@ -2309,7 +2363,6 @@ class B(A):
 [builtins fixtures/classmethod.pyi]
 
 [case testSubclassingGenericSelfClassMethodOptional]
-# flags: --strict-optional
 from typing import TypeVar, Type, Optional
 
 AT = TypeVar('AT', bound='A')
@@ -2700,6 +2753,7 @@ reveal_type(func(1))  # N: Revealed type is "builtins.int"
 [builtins fixtures/tuple.pyi]
 
 [case testGenericLambdaGenericMethodNoCrash]
+# flags: --new-type-inference
 from typing import TypeVar, Union, Callable, Generic
 
 S = TypeVar("S")
@@ -2710,7 +2764,7 @@ def f(x: Callable[[G[T]], int]) -> T: ...
 class G(Generic[T]):
     def g(self, x: S) -> Union[S, T]: ...
 
-f(lambda x: x.g(0))  # E: Cannot infer type argument 1 of "f"
+reveal_type(f(lambda x: x.g(0)))  # N: Revealed type is "builtins.int"
 
 [case testDictStarInference]
 class B: ...
@@ -2733,3 +2787,779 @@ 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`11) -> builtins.list[S`11]"
+reveal_type(mix([id, id, id]))  # N: Revealed type is "def [S] (S`13) -> builtins.list[S`13]"
+[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"
+reveal_type(dec2(test2))  # N: Revealed type is "def [T] (T`3) -> def (T`3) -> T`3"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableNewVariable]
+# 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: List[U]) -> List[U]:
+    ...
+reveal_type(dec(test))  # N: Revealed type is "def [U] (builtins.list[U`-1]) -> builtins.list[U`-1]"
+[builtins fixtures/list.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: --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: --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: --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 testInferenceAgainstGenericSecondary]
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+def dec(f: Callable[[List[T]], List[int]]) -> Callable[[T], T]: ...
+
+@dec
+def id(x: U) -> U:
+    ...
+reveal_type(id)  # N: Revealed type is "def (builtins.int) -> builtins.int"
+[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"
+
+[case testInferenceAgainstGenericBoundsAndValues]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+class B: ...
+class C(B): ...
+
+S = TypeVar('S')
+T = TypeVar('T')
+UB = TypeVar('UB', bound=B)
+UC = TypeVar('UC', bound=C)
+V = TypeVar('V', int, str)
+
+def dec1(f: Callable[[S], T]) -> Callable[[S], List[T]]:
+    ...
+def dec2(f: Callable[[UC], T]) -> Callable[[UC], List[T]]:
+    ...
+def id1(x: UB) -> UB:
+    ...
+def id2(x: V) -> V:
+    ...
+
+reveal_type(dec1(id1))  # N: Revealed type is "def [S <: __main__.B] (S`1) -> builtins.list[S`1]"
+reveal_type(dec1(id2))  # N: Revealed type is "def [S in (builtins.int, builtins.str)] (S`3) -> builtins.list[S`3]"
+reveal_type(dec2(id1))  # N: Revealed type is "def [UC <: __main__.C] (UC`5) -> builtins.list[UC`5]"
+reveal_type(dec2(id2))  # N: Revealed type is "def (Never) -> builtins.list[Never]" \
+                        # E: Argument 1 to "dec2" has incompatible type "Callable[[V], V]"; expected "Callable[[Never], Never]"
+
+[case testInferenceAgainstGenericLambdas]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+
+def dec1(f: Callable[[T], T]) -> Callable[[T], List[T]]:
+    ...
+def dec2(f: Callable[[S], T]) -> Callable[[S], List[T]]:
+    ...
+def dec3(f: Callable[[List[S]], T]) -> Callable[[S], T]:
+    def g(x: S) -> T:
+        return f([x])
+    return g
+def dec4(f: Callable[[S], List[T]]) -> Callable[[S], T]:
+    ...
+def dec5(f: Callable[[int], T]) -> Callable[[int], List[T]]:
+    def g(x: int) -> List[T]:
+        return [f(x)] * x
+    return g
+
+I = TypeVar("I", bound=int)
+def dec4_bound(f: Callable[[I], List[T]]) -> Callable[[I], T]:
+    ...
+
+reveal_type(dec1(lambda x: x))  # N: Revealed type is "def [T] (T`3) -> builtins.list[T`3]"
+reveal_type(dec2(lambda x: x))  # N: Revealed type is "def [S] (S`5) -> builtins.list[S`5]"
+reveal_type(dec3(lambda x: x[0]))  # N: Revealed type is "def [S] (S`8) -> S`8"
+reveal_type(dec4(lambda x: [x]))  # N: Revealed type is "def [S] (S`12) -> S`12"
+reveal_type(dec1(lambda x: 1))  # N: Revealed type is "def (builtins.int) -> builtins.list[builtins.int]"
+reveal_type(dec5(lambda x: x))  # N: Revealed type is "def (builtins.int) -> builtins.list[builtins.int]"
+reveal_type(dec3(lambda x: x))  # N: Revealed type is "def [S] (S`20) -> builtins.list[S`20]"
+reveal_type(dec4(lambda x: x))  # N: Revealed type is "def [T] (builtins.list[T`24]) -> T`24"
+dec4_bound(lambda x: x)  # E: Value of type variable "I" of "dec4_bound" cannot be "List[T]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecBasicInList]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple
+from typing_extensions import ParamSpec
+
+T = TypeVar('T')
+P = ParamSpec('P')
+U = TypeVar('U')
+V = TypeVar('V')
+
+def dec(f: Callable[P, T]) -> Callable[P, List[T]]: ...
+def id(x: U) -> U: ...
+def either(x: U, y: U) -> U: ...
+def pair(x: U, y: V) -> Tuple[U, V]: ...
+reveal_type(dec(id))  # N: Revealed type is "def [T] (x: T`3) -> builtins.list[T`3]"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (x: T`5, y: T`5) -> builtins.list[T`5]"
+reveal_type(dec(pair))  # N: Revealed type is "def [U, V] (x: U`-1, y: V`-2) -> builtins.list[Tuple[U`-1, V`-2]]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecBasicDeList]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple
+from typing_extensions import ParamSpec
+
+T = TypeVar('T')
+P = ParamSpec('P')
+U = TypeVar('U')
+V = TypeVar('V')
+
+def dec(f: Callable[P, List[T]]) -> Callable[P, T]: ...
+def id(x: U) -> U: ...
+def either(x: U, y: U) -> U: ...
+reveal_type(dec(id))  # N: Revealed type is "def [T] (x: builtins.list[T`3]) -> T`3"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (x: builtins.list[T`5], y: builtins.list[T`5]) -> T`5"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecPopOff]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple
+from typing_extensions import ParamSpec, Concatenate
+
+T = TypeVar('T')
+S = TypeVar('S')
+P = ParamSpec('P')
+U = TypeVar('U')
+V = TypeVar('V')
+
+def dec(f: Callable[Concatenate[T, P], S]) -> Callable[P, Callable[[T], S]]: ...
+def id(x: U) -> U: ...
+def either(x: U, y: U) -> U: ...
+def pair(x: U, y: V) -> Tuple[U, V]: ...
+reveal_type(dec(id))  # N: Revealed type is "def () -> def [T] (T`2) -> T`2"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (y: T`5) -> def (T`5) -> T`5"
+reveal_type(dec(pair))  # N: Revealed type is "def [V] (y: V`-2) -> def [T] (T`8) -> Tuple[T`8, V`-2]"
+reveal_type(dec(dec))  # N: Revealed type is "def () -> def [T, P, S] (def (T`-1, *P.args, **P.kwargs) -> S`-3) -> def (*P.args, **P.kwargs) -> def (T`-1) -> S`-3"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecPopOn]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple
+from typing_extensions import ParamSpec, Concatenate
+
+T = TypeVar('T')
+S = TypeVar('S')
+P = ParamSpec('P')
+U = TypeVar('U')
+V = TypeVar('V')
+
+def dec(f: Callable[P, Callable[[T], S]]) -> Callable[Concatenate[T, P], S]: ...
+def id() -> Callable[[U], U]: ...
+def either(x: U) -> Callable[[U], U]: ...
+def pair(x: U) -> Callable[[V], Tuple[V, U]]: ...
+reveal_type(dec(id))  # N: Revealed type is "def [T] (T`3) -> T`3"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (T`6, x: T`6) -> T`6"
+reveal_type(dec(pair))  # N: Revealed type is "def [T, U] (T`9, x: U`-1) -> Tuple[T`9, U`-1]"
+# This is counter-intuitive but looks correct, dec matches itself only if P can be empty
+reveal_type(dec(dec))  # N: Revealed type is "def [T, S] (T`13, f: def () -> def (T`13) -> S`14) -> S`14"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecVsParamSpec]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple, Generic
+from typing_extensions import ParamSpec, Concatenate
+
+T = TypeVar('T')
+P = ParamSpec('P')
+Q = ParamSpec('Q')
+
+class Foo(Generic[P]): ...
+class Bar(Generic[P, T]): ...
+
+def dec(f: Callable[P, T]) -> Callable[P, List[T]]: ...
+def f(*args: Q.args, **kwargs: Q.kwargs) -> Foo[Q]: ...
+reveal_type(dec(f))  # N: Revealed type is "def [P] (*P.args, **P.kwargs) -> builtins.list[__main__.Foo[P`2]]"
+g: Callable[Concatenate[int, Q], Foo[Q]]
+reveal_type(dec(g))  # N: Revealed type is "def [Q] (builtins.int, *Q.args, **Q.kwargs) -> builtins.list[__main__.Foo[Q`-1]]"
+h: Callable[Concatenate[T, Q], Bar[Q, T]]
+reveal_type(dec(h))  # N: Revealed type is "def [T, Q] (T`-1, *Q.args, **Q.kwargs) -> builtins.list[__main__.Bar[Q`-2, T`-1]]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecVsParamSpecConcatenate]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple, Generic
+from typing_extensions import ParamSpec, Concatenate
+
+T = TypeVar('T')
+P = ParamSpec('P')
+Q = ParamSpec('Q')
+
+class Foo(Generic[P]): ...
+
+def dec(f: Callable[P, int]) -> Callable[P, Foo[P]]: ...
+h: Callable[Concatenate[T, Q], int]
+g: Callable[Concatenate[T, Q], int]
+h = g
+reveal_type(dec(h))  # N: Revealed type is "def [T, Q] (T`-1, *Q.args, **Q.kwargs) -> __main__.Foo[[T`-1, **Q`-2]]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecSecondary]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple, Generic
+from typing_extensions import ParamSpec, Concatenate
+
+T = TypeVar('T')
+P = ParamSpec('P')
+Q = ParamSpec('Q')
+
+class Foo(Generic[P]): ...
+
+def dec(f: Callable[P, Foo[P]]) -> Callable[P, Foo[P]]: ...
+g: Callable[[T], Foo[[int]]]
+reveal_type(dec(g))  # N: Revealed type is "def (builtins.int) -> __main__.Foo[[builtins.int]]"
+h: Callable[Q, Foo[[int]]]
+reveal_type(dec(g))  # N: Revealed type is "def (builtins.int) -> __main__.Foo[[builtins.int]]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericParamSpecSecondOrder]
+# flags: --new-type-inference
+from typing import TypeVar, Callable
+from typing_extensions import ParamSpec, Concatenate
+
+T = TypeVar('T')
+S = TypeVar('S')
+P = ParamSpec('P')
+Q = ParamSpec('Q')
+U = TypeVar('U')
+W = ParamSpec('W')
+
+def transform(
+    dec: Callable[[Callable[P, T]], Callable[Q, S]]
+) -> Callable[[Callable[Concatenate[int, P], T]], Callable[Concatenate[int, Q], S]]: ...
+
+def dec(f: Callable[W, U]) -> Callable[W, U]: ...
+def dec2(f: Callable[Concatenate[str, W], U]) -> Callable[Concatenate[bytes, W], U]: ...
+reveal_type(transform(dec))  # N: Revealed type is "def [P, T] (def (builtins.int, *P.args, **P.kwargs) -> T`3) -> def (builtins.int, *P.args, **P.kwargs) -> T`3"
+reveal_type(transform(dec2))  # N: Revealed type is "def [W, T] (def (builtins.int, builtins.str, *W.args, **W.kwargs) -> T`7) -> def (builtins.int, builtins.bytes, *W.args, **W.kwargs) -> T`7"
+[builtins fixtures/tuple.pyi]
+
+[case testNoAccidentalVariableClashInNestedGeneric]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, Generic, Tuple
+
+T = TypeVar('T')
+S = TypeVar('S')
+U = TypeVar('U')
+
+def pipe(x: T, f1: Callable[[T], S], f2: Callable[[S], U]) -> U: ...
+def and_then(a: T) -> Callable[[S], Tuple[S, T]]: ...
+
+def apply(a: S, b: T) -> None:
+    v1 = and_then(b)
+    v2: Callable[[Tuple[S, T]], None]
+    return pipe(a, v1, v2)
+[builtins fixtures/tuple.pyi]
+
+[case testInferenceAgainstGenericParamSpecSpuriousBoundsNotUsed]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, Generic
+from typing_extensions import ParamSpec, Concatenate
+
+Q = ParamSpec("Q")
+class Foo(Generic[Q]): ...
+
+T1 = TypeVar("T1", bound=Foo[...])
+T2 = TypeVar("T2", bound=Foo[...])
+P = ParamSpec("P")
+def pop_off(fn: Callable[Concatenate[T1, P], T2]) -> Callable[P, Callable[[T1], T2]]:
+    ...
+
+@pop_off
+def test(command: Foo[Q]) -> Foo[Q]: ...
+reveal_type(test)  # N: Revealed type is "def () -> def [Q] (__main__.Foo[Q`-1]) -> __main__.Foo[Q`-1]"
+[builtins fixtures/tuple.pyi]
+
+[case testInferenceAgainstGenericVariadicBasicInList]
+# flags: --new-type-inference
+from typing import Tuple, TypeVar, List, Callable
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+def dec(f: Callable[[Unpack[Ts]], T]) -> Callable[[Unpack[Ts]], List[T]]: ...
+
+U = TypeVar("U")
+V = TypeVar("V")
+def id(x: U) -> U: ...
+def either(x: U, y: U) -> U: ...
+def pair(x: U, y: V) -> Tuple[U, V]: ...
+
+reveal_type(dec(id))  # N: Revealed type is "def [T] (T`3) -> builtins.list[T`3]"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (T`5, T`5) -> builtins.list[T`5]"
+reveal_type(dec(pair))  # N: Revealed type is "def [U, V] (U`-1, V`-2) -> builtins.list[Tuple[U`-1, V`-2]]"
+[builtins fixtures/tuple.pyi]
+
+[case testInferenceAgainstGenericVariadicBasicDeList]
+# flags: --new-type-inference
+from typing import Tuple, TypeVar, List, Callable
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+def dec(f: Callable[[Unpack[Ts]], List[T]]) -> Callable[[Unpack[Ts]], T]: ...
+
+U = TypeVar("U")
+V = TypeVar("V")
+def id(x: U) -> U: ...
+def either(x: U, y: U) -> U: ...
+
+reveal_type(dec(id))  # N: Revealed type is "def [T] (builtins.list[T`3]) -> T`3"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (builtins.list[T`5], builtins.list[T`5]) -> T`5"
+[builtins fixtures/tuple.pyi]
+
+[case testInferenceAgainstGenericVariadicPopOff]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+def dec(f: Callable[[T, Unpack[Ts]], S]) -> Callable[[Unpack[Ts]], Callable[[T], S]]: ...
+
+U = TypeVar("U")
+V = TypeVar("V")
+def id(x: U) -> U: ...
+def either(x: U, y: U) -> U: ...
+def pair(x: U, y: V) -> Tuple[U, V]: ...
+
+reveal_type(dec(id))  # N: Revealed type is "def () -> def [T] (T`2) -> T`2"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (T`5) -> def (T`5) -> T`5"
+reveal_type(dec(pair))  # N: Revealed type is "def [V] (V`-2) -> def [T] (T`8) -> Tuple[T`8, V`-2]"
+reveal_type(dec(dec))  # N: Revealed type is "def () -> def [T, Ts, S] (def (T`-1, *Unpack[Ts`-2]) -> S`-3) -> def (*Unpack[Ts`-2]) -> def (T`-1) -> S`-3"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericVariadicPopOn]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Tuple
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+def dec(f: Callable[[Unpack[Ts]], Callable[[T], S]]) -> Callable[[T, Unpack[Ts]], S]: ...
+
+U = TypeVar("U")
+V = TypeVar("V")
+def id() -> Callable[[U], U]: ...
+def either(x: U) -> Callable[[U], U]: ...
+def pair(x: U) -> Callable[[V], Tuple[V, U]]: ...
+
+reveal_type(dec(id))  # N: Revealed type is "def [T] (T`3) -> T`3"
+reveal_type(dec(either))  # N: Revealed type is "def [T] (T`6, T`6) -> T`6"
+reveal_type(dec(pair))  # N: Revealed type is "def [T, U] (T`9, U`-1) -> Tuple[T`9, U`-1]"
+# This is counter-intuitive but looks correct, dec matches itself only if Ts is empty
+reveal_type(dec(dec))  # N: Revealed type is "def [T, S] (T`13, def () -> def (T`13) -> S`14) -> S`14"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericVariadicVsVariadic]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List, Generic
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+Us = TypeVarTuple("Us")
+
+class Foo(Generic[Unpack[Ts]]): ...
+class Bar(Generic[Unpack[Ts], T]): ...
+
+def dec(f: Callable[[Unpack[Ts]], T]) -> Callable[[Unpack[Ts]], List[T]]: ...
+def f(*args: Unpack[Us]) -> Foo[Unpack[Us]]: ...
+reveal_type(dec(f))  # N: Revealed type is "def [Ts] (*Unpack[Ts`2]) -> builtins.list[__main__.Foo[Unpack[Ts`2]]]"
+g: Callable[[Unpack[Us]], Foo[Unpack[Us]]]
+reveal_type(dec(g))  # N: Revealed type is "def [Ts] (*Unpack[Ts`4]) -> builtins.list[__main__.Foo[Unpack[Ts`4]]]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericVariadicVsVariadicConcatenate]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, Generic
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+Us = TypeVarTuple("Us")
+
+class Foo(Generic[Unpack[Ts]]): ...
+
+def dec(f: Callable[[Unpack[Ts]], int]) -> Callable[[Unpack[Ts]], Foo[Unpack[Ts]]]: ...
+h: Callable[[T, Unpack[Us]], int]
+g: Callable[[T, Unpack[Us]], int]
+h = g
+reveal_type(dec(h))  # N: Revealed type is "def [T, Us] (T`-1, *Unpack[Us`-2]) -> __main__.Foo[T`-1, Unpack[Us`-2]]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericVariadicSecondary]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, Generic
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+Us = TypeVarTuple("Us")
+
+class Foo(Generic[Unpack[Ts]]): ...
+
+def dec(f: Callable[[Unpack[Ts]], Foo[Unpack[Ts]]]) -> Callable[[Unpack[Ts]], Foo[Unpack[Ts]]]: ...
+g: Callable[[T], Foo[int]]
+reveal_type(dec(g))  # N: Revealed type is "def (builtins.int) -> __main__.Foo[builtins.int]"
+h: Callable[[Unpack[Us]], Foo[int]]
+reveal_type(dec(h))  # N: Revealed type is "def (builtins.int) -> __main__.Foo[builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testTypeApplicationGenericConstructor]
+from typing import Generic, TypeVar, Callable
+
+T = TypeVar("T")
+S = TypeVar("S")
+class C(Generic[T]):
+    def __init__(self, f: Callable[[S], T], x: S) -> None:
+        self.x = f(x)
+
+reveal_type(C[int])  # N: Revealed type is "def [S] (f: def (S`-1) -> builtins.int, x: S`-1) -> __main__.C[builtins.int]"
+Alias = C[int]
+C[int, str]  # E: Type application has too many types (1 expected)
+
+[case testHigherOrderGenericPartial]
+from typing import TypeVar, Callable
+
+T = TypeVar("T")
+S = TypeVar("S")
+U = TypeVar("U")
+def apply(f: Callable[[T], S], x: T) -> S: ...
+def id(x: U) -> U: ...
+
+A1 = TypeVar("A1")
+A2 = TypeVar("A2")
+R = TypeVar("R")
+def fake_partial(fun: Callable[[A1, A2], R], arg: A1) -> Callable[[A2], R]: ...
+
+f_pid = fake_partial(apply, id)
+reveal_type(f_pid)  # N: Revealed type is "def [A2] (A2`2) -> A2`2"
+reveal_type(f_pid(1))  # N: Revealed type is "builtins.int"
+
+[case testInvalidTypeVarParametersConcrete]
+from typing import Callable, Generic, ParamSpec, Protocol, TypeVar, overload
+
+P = ParamSpec('P')
+P2 = ParamSpec('P2')
+R = TypeVar('R')
+R2 = TypeVar('R2')
+
+class C(Generic[P, R, P2, R2]): ...
+
+class Proto(Protocol[P, R]):
+    @overload
+    def __call__(self, f: Callable[P2, R2]) -> C[P2, R2, ..., R]: ...
+    @overload
+    def __call__(self, **kwargs) -> C[P, R, ..., [int, str]]: ...  # E: Cannot use "[int, str]" for regular type variable, only for ParamSpec
+[builtins fixtures/tuple.pyi]
+
+[case testInvalidTypeVarParametersArbitrary]
+from typing import Callable, Generic, ParamSpec, Protocol, TypeVar, overload
+
+P = ParamSpec('P')
+P2 = ParamSpec('P2')
+R = TypeVar('R')
+R2 = TypeVar('R2')
+
+class C(Generic[P, R, P2, R2]): ...
+
+class Proto(Protocol[P, R]):
+    @overload
+    def __call__(self, f: Callable[P2, R2]) -> C[P2, R2, ..., R]: ...
+    @overload
+    def __call__(self, **kwargs) -> C[P, R, ..., ...]: ...  # E: Cannot use "[VarArg(Any), KwArg(Any)]" for regular type variable, only for ParamSpec
+[builtins fixtures/tuple.pyi]
+
+[case testGenericOverloadOverlapUnion]
+from typing import TypeVar, overload, Union, Generic
+
+K = TypeVar("K")
+V = TypeVar("V")
+T = TypeVar("T")
+
+class C(Generic[K, V]):
+    @overload
+    def pop(self, key: K) -> V: ...
+    @overload
+    def pop(self, key: K, default: Union[V, T] = ...) -> Union[V, T]: ...
+    def pop(self, key: K, default: Union[V, T] = ...) -> Union[V, T]:
+        ...
+
+[case testOverloadedGenericInit]
+from typing import TypeVar, overload, Union, Generic
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+class Int(Generic[T]): ...
+class Str(Generic[T]): ...
+
+class C(Generic[T]):
+    @overload
+    def __init__(self: C[Int[S]], x: int, y: S) -> None: ...
+    @overload
+    def __init__(self: C[Str[S]], x: str, y: S) -> None: ...
+    def __init__(self, x, y) -> None: ...
+
+def foo(x: T):
+    reveal_type(C)  # N: Revealed type is "Overload(def [T, S] (x: builtins.int, y: S`-1) -> __main__.C[__main__.Int[S`-1]], def [T, S] (x: builtins.str, y: S`-1) -> __main__.C[__main__.Str[S`-1]])"
+    reveal_type(C(0, x))  # N: Revealed type is "__main__.C[__main__.Int[T`-1]]"
+    reveal_type(C("yes", x))  # N: Revealed type is "__main__.C[__main__.Str[T`-1]]"
diff --git a/test-data/unit/check-incremental.test b/test-data/unit/check-incremental.test
index 661afca807f4..9d5902246ae5 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
@@ -1833,6 +1833,21 @@ main:3: note: Revealed type is "builtins.int"
 main:3: note: Revealed type is "Any"
 
 
+[case testIncrementalIgnoreErrors]
+# flags: --config-file tmp/mypy.ini
+import a
+[file a.py]
+import module_that_will_be_deleted
+[file module_that_will_be_deleted.py]
+
+[file mypy.ini]
+\[mypy]
+\[mypy-a]
+ignore_errors = True
+[delete module_that_will_be_deleted.py.2]
+[out1]
+[out2]
+
 [case testIncrementalNamedTupleInMethod]
 from ntcrash import nope
 [file ntcrash.py]
@@ -1878,11 +1893,12 @@ main:1: error: Module "ntcrash" has no attribute "nope"
 [case testIncrementalTypedDictInMethod]
 from tdcrash import nope
 [file tdcrash.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class C:
     def f(self) -> None:
         A = TypedDict('A', {'x': int, 'y': int})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out1]
 main:1: error: Module "tdcrash" has no attribute "nope"
 [out2]
@@ -1891,12 +1907,13 @@ main:1: error: Module "tdcrash" has no attribute "nope"
 [case testIncrementalTypedDictInMethod2]
 from tdcrash import nope
 [file tdcrash.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class C:
     class D:
         def f(self) -> None:
             A = TypedDict('A', {'x': int, 'y': int})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out1]
 main:1: error: Module "tdcrash" has no attribute "nope"
 [out2]
@@ -1905,13 +1922,14 @@ main:1: error: Module "tdcrash" has no attribute "nope"
 [case testIncrementalTypedDictInMethod3]
 from tdcrash import nope
 [file tdcrash.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class C:
     def a(self):
         class D:
             def f(self) -> None:
                 A = TypedDict('A', {'x': int, 'y': int})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out1]
 main:1: error: Module "tdcrash" has no attribute "nope"
 [out2]
@@ -1920,8 +1938,7 @@ main:1: error: Module "tdcrash" has no attribute "nope"
 [case testIncrementalNewTypeInMethod]
 from ntcrash import nope
 [file ntcrash.py]
-from mypy_extensions import TypedDict
-from typing import NewType, NamedTuple
+from typing import NewType, NamedTuple, TypedDict
 class C:
     def f(self) -> None:
         X = NewType('X', int)
@@ -1934,6 +1951,7 @@ def f() -> None:
     B = NamedTuple('B', [('x', X)])
 
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out1]
 main:1: error: Module "ntcrash" has no attribute "nope"
 [out2]
@@ -2073,10 +2091,11 @@ reveal_type(b.x)
 y: b.A
 reveal_type(y)
 [file b.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 A = TypedDict('A', {'x': int, 'y': str})
 x: A
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out1]
 main:2: note: Revealed type is "TypedDict('b.A', {'x': builtins.int, 'y': builtins.str})"
 main:4: note: Revealed type is "TypedDict('b.A', {'x': builtins.int, 'y': builtins.str})"
@@ -2517,14 +2536,14 @@ x = NT(N(1))
 [out]
 
 [case testNewTypeFromForwardTypedDictIncremental]
-from typing import NewType, Tuple, Dict
-from mypy_extensions import TypedDict
+from typing import NewType, Tuple, TypedDict, Dict
 
 NT = NewType('NT', N) # type: ignore
 class N(TypedDict):
     x: A
 A = Dict[str, int]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 -- Some crazy self-referential named tuples, types dicts, and aliases
@@ -2603,7 +2622,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 +2644,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'
@@ -2901,7 +2920,6 @@ tmp/main.py:2: error: Expression has type "Any"
 tmp/main.py:2: error: Expression has type "Any"
 
 [case testIncrementalStrictOptional]
-# flags: --strict-optional
 import a
 1 + a.foo()
 [file a.py]
@@ -2911,8 +2929,8 @@ from typing import Optional
 def foo() -> Optional[int]: return 0
 [out1]
 [out2]
-main:3: error: Unsupported operand types for + ("int" and "None")
-main:3: note: Right operand is of type "Optional[int]"
+main:2: error: Unsupported operand types for + ("int" and "None")
+main:2: note: Right operand is of type "Optional[int]"
 
 [case testAttrsIncrementalSubclassingCached]
 from a import A
@@ -3016,7 +3034,7 @@ class NoInit:
 class NoCmp:
     x: int
 
-[builtins fixtures/list.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 [rechecked]
 [stale]
 [out1]
@@ -3036,10 +3054,10 @@ main:15: error: Unsupported left operand type for >= ("NoCmp")
 [case testAttrsIncrementalDunder]
 from a import A
 reveal_type(A)  # N: Revealed type is "def (a: builtins.int) -> a.A"
-reveal_type(A.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(A.__le__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(A.__gt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(A.__ge__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
+reveal_type(A.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`3, other: _AT`3) -> builtins.bool"
+reveal_type(A.__le__)  # N: Revealed type is "def [_AT] (self: _AT`4, other: _AT`4) -> builtins.bool"
+reveal_type(A.__gt__)  # N: Revealed type is "def [_AT] (self: _AT`5, other: _AT`5) -> builtins.bool"
+reveal_type(A.__ge__)  # N: Revealed type is "def [_AT] (self: _AT`6, other: _AT`6) -> builtins.bool"
 
 A(1) < A(2)
 A(1) <= A(2)
@@ -3073,10 +3091,10 @@ class A:
 [stale]
 [out2]
 main:2: note: Revealed type is "def (a: builtins.int) -> a.A"
-main:3: note: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-main:4: note: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-main:5: note: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-main:6: note: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
+main:3: note: Revealed type is "def [_AT] (self: _AT`1, other: _AT`1) -> builtins.bool"
+main:4: note: Revealed type is "def [_AT] (self: _AT`2, other: _AT`2) -> builtins.bool"
+main:5: note: Revealed type is "def [_AT] (self: _AT`3, other: _AT`3) -> builtins.bool"
+main:6: note: Revealed type is "def [_AT] (self: _AT`4, other: _AT`4) -> builtins.bool"
 main:15: error: Unsupported operand types for < ("A" and "int")
 main:16: error: Unsupported operand types for <= ("A" and "int")
 main:17: error: Unsupported operand types for > ("A" and "int")
@@ -3457,7 +3475,6 @@ main:2: error: Cannot find implementation or library stub for module named "a"
 main:2: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
 
 [case testIncrementalInheritanceAddAnnotation]
-# flags: --strict-optional
 import a
 [file a.py]
 import b
@@ -3740,7 +3757,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.9/@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 +3792,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.9/@deps.meta.json.2]
 [file b.py.2]
 # uh
 -- Every file should get reloaded, since the cache was invalidated
@@ -3798,7 +3815,6 @@ import b
 [rechecked b]
 
 [case testIncrementalDataclassesSubclassingCached]
-# flags: --python-version 3.7
 from a import A
 from dataclasses import dataclass
 
@@ -3831,7 +3847,6 @@ class A:
 [out2]
 
 [case testIncrementalDataclassesSubclassingCachedType]
-# flags: --python-version 3.7
 import b
 
 [file b.py]
@@ -3865,7 +3880,6 @@ class A:
 tmp/b.py:8: note: Revealed type is "def (x: builtins.int) -> b.B"
 
 [case testIncrementalDataclassesArguments]
-# flags: --python-version 3.7
 import b
 
 [file b.py]
@@ -3914,7 +3928,6 @@ tmp/b.py:15: error: Unsupported left operand type for > ("NoCmp")
 tmp/b.py:16: error: Unsupported left operand type for >= ("NoCmp")
 
 [case testIncrementalDataclassesDunder]
-# flags: --python-version 3.7
 import b
 
 [file b.py]
@@ -3965,10 +3978,10 @@ class A:
 tmp/b.py:3: note: Revealed type is "def (a: builtins.int) -> a.A"
 tmp/b.py:4: note: Revealed type is "def (builtins.object, builtins.object) -> builtins.bool"
 tmp/b.py:5: note: Revealed type is "def (builtins.object, builtins.object) -> builtins.bool"
-tmp/b.py:6: note: Revealed type is "def [_DT] (self: _DT`-1, other: _DT`-1) -> builtins.bool"
-tmp/b.py:7: note: Revealed type is "def [_DT] (self: _DT`-1, other: _DT`-1) -> builtins.bool"
-tmp/b.py:8: note: Revealed type is "def [_DT] (self: _DT`-1, other: _DT`-1) -> builtins.bool"
-tmp/b.py:9: note: Revealed type is "def [_DT] (self: _DT`-1, other: _DT`-1) -> builtins.bool"
+tmp/b.py:6: note: Revealed type is "def [_DT] (self: _DT`1, other: _DT`1) -> builtins.bool"
+tmp/b.py:7: note: Revealed type is "def [_DT] (self: _DT`2, other: _DT`2) -> builtins.bool"
+tmp/b.py:8: note: Revealed type is "def [_DT] (self: _DT`3, other: _DT`3) -> builtins.bool"
+tmp/b.py:9: note: Revealed type is "def [_DT] (self: _DT`4, other: _DT`4) -> builtins.bool"
 tmp/b.py:18: error: Unsupported operand types for < ("A" and "int")
 tmp/b.py:19: error: Unsupported operand types for <= ("A" and "int")
 tmp/b.py:20: error: Unsupported operand types for > ("A" and "int")
@@ -3979,7 +3992,6 @@ tmp/b.py:27: error: Unsupported operand types for < ("A" and "int")
 tmp/b.py:28: error: Unsupported operand types for <= ("A" and "int")
 
 [case testIncrementalDataclassesSubclassModified]
-# flags: --python-version 3.7
 from b import B
 B(5, 'foo')
 
@@ -4009,11 +4021,10 @@ class B(A):
 [builtins fixtures/dataclasses.pyi]
 [out1]
 [out2]
-main:3: error: Argument 2 to "B" has incompatible type "str"; expected "int"
+main:2: error: Argument 2 to "B" has incompatible type "str"; expected "int"
 [rechecked b]
 
 [case testIncrementalDataclassesSubclassModifiedErrorFirst]
-# flags: --python-version 3.7
 from b import B
 B(5, 'foo')
 
@@ -4042,13 +4053,12 @@ class B(A):
 
 [builtins fixtures/dataclasses.pyi]
 [out1]
-main:3: error: Argument 2 to "B" has incompatible type "str"; expected "int"
+main:2: error: Argument 2 to "B" has incompatible type "str"; expected "int"
 
 [out2]
 [rechecked b]
 
 [case testIncrementalDataclassesThreeFiles]
-# flags: --python-version 3.7
 from c import C
 C('foo', 5, True)
 
@@ -4087,10 +4097,9 @@ class C(A, B):
 [out1]
 [out2]
 tmp/c.py:7: error: Incompatible types in assignment (expression has type "bool", base class "B" defined the type as "str")
-main:3: error: Argument 2 to "C" has incompatible type "int"; expected "bool"
+main:2: error: Argument 2 to "C" has incompatible type "int"; expected "bool"
 
 [case testIncrementalDataclassesThreeRuns]
-# flags: --python-version 3.7
 from a import A
 A(5)
 
@@ -4118,7 +4127,7 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 [out1]
 [out2]
-main:3: error: Argument 1 to "A" has incompatible type "int"; expected "str"
+main:2: error: Argument 1 to "A" has incompatible type "int"; expected "str"
 [out3]
 
 [case testParentPatchingMess]
@@ -4141,7 +4150,7 @@ from d import k
 [case testCachedBadProtocolNote]
 import b
 [file a.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 [file b.py]
 from typing import Iterable
@@ -4153,8 +4162,8 @@ from typing import Iterable
 from a import Point
 p: Point
 it: Iterable[int] = p  # change
-[typing fixtures/typing-medium.pyi]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
 [out]
 tmp/b.py:4: error: Incompatible types in assignment (expression has type "Point", variable has type "Iterable[int]")
 tmp/b.py:4: note: Following member(s) of "Point" have conflicts:
@@ -4596,7 +4605,6 @@ def outer() -> None:
 [out2]
 
 [case testRecursiveAliasImported]
-# flags: --disable-recursive-aliases
 import a
 
 [file a.py]
@@ -4622,16 +4630,10 @@ B = List[A]
 
 [builtins fixtures/list.pyi]
 [out]
-tmp/lib.pyi:4: error: Module "other" has no attribute "B"
-tmp/other.pyi:3: error: Cannot resolve name "B" (possible cyclic definition)
 [out2]
-tmp/lib.pyi:4: error: Module "other" has no attribute "B"
-tmp/other.pyi:3: error: Cannot resolve name "B" (possible cyclic definition)
-tmp/a.py:3: note: Revealed type is "builtins.list[Any]"
-
-[case testRecursiveNamedTupleTypedDict-skip]
-# https://github.com/python/mypy/issues/7125
+tmp/a.py:3: note: Revealed type is "builtins.list[builtins.list[...]]"
 
+[case testRecursiveNamedTupleTypedDict]
 import a
 [file a.py]
 import lib
@@ -4643,15 +4645,16 @@ reveal_type(x.x['x'])
 [file lib.pyi]
 from typing import NamedTuple
 from other import B
-A = NamedTuple('A', [('x', B)])  # type: ignore
+A = NamedTuple('A', [('x', B)])
 [file other.pyi]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 from lib import A
 B = TypedDict('B', {'x': A})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 [out2]
-tmp/a.py:3: note: Revealed type is "Tuple[TypedDict('other.B', {'x': Any}), fallback=lib.A]"
+tmp/a.py:3: note: Revealed type is "Tuple[TypedDict('other.B', {'x': Tuple[..., fallback=lib.A]}), fallback=lib.A]"
 
 [case testFollowImportSkipNotInvalidatedOnPresent]
 # flags: --follow-imports=skip
@@ -5077,10 +5080,10 @@ plugins=<ROOT>/test-data/unit/plugins/config_data.py
 import mod
 reveal_type(mod.a)
 [file mod.py]
-from typing_extensions import Literal
+from typing import Literal
 a = 1
 [file mod.py.2]
-from typing_extensions import Literal
+from typing import Literal
 a: Literal[2] = 2
 [builtins fixtures/tuple.pyi]
 [out]
@@ -5144,7 +5147,6 @@ tmp/b.py:4: error: First argument to namedtuple() should be "NT", not "BadName"
 tmp/b.py:4: error: First argument to namedtuple() should be "NT", not "BadName"
 
 [case testNewAnalyzerIncrementalMethodNamedTuple]
-
 import a
 [file a.py]
 from b import C
@@ -5233,11 +5235,7 @@ class Sub(Base):
 
 [builtins fixtures/property.pyi]
 [out]
-tmp/a.py:3: error: Cannot determine type of "foo"
-tmp/a.py:4: error: Cannot determine type of "foo"
 [out2]
-tmp/a.py:3: error: Cannot determine type of "foo"
-tmp/a.py:4: error: Cannot determine type of "foo"
 
 [case testRedefinitionClass]
 import b
@@ -5271,7 +5269,7 @@ reveal_type(Foo().x)
 [builtins fixtures/isinstance.pyi]
 [out]
 [out2]
-tmp/b.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+tmp/b.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 
 [case testIsInstanceAdHocIntersectionIncrementalNoChangeSameName]
 import b
@@ -5294,7 +5292,7 @@ reveal_type(Foo().x)
 [builtins fixtures/isinstance.pyi]
 [out]
 [out2]
-tmp/b.py:2: note: Revealed type is "a.<subclass of "B" and "B">"
+tmp/b.py:2: note: Revealed type is "a.<subclass of "c.B" and "a.B">"
 
 
 [case testIsInstanceAdHocIntersectionIncrementalNoChangeTuple]
@@ -5316,7 +5314,7 @@ reveal_type(Foo().x)
 [builtins fixtures/isinstance.pyi]
 [out]
 [out2]
-tmp/b.py:2: note: Revealed type is "a.<subclass of "tuple" and "B">"
+tmp/b.py:2: note: Revealed type is "a.<subclass of "Tuple[builtins.int, ...]" and "a.B">"
 
 [case testIsInstanceAdHocIntersectionIncrementalIsInstanceChange]
 import c
@@ -5350,9 +5348,9 @@ from b import y
 reveal_type(y)
 [builtins fixtures/isinstance.pyi]
 [out]
-tmp/c.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+tmp/c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 [out2]
-tmp/c.py:2: note: Revealed type is "a.<subclass of "A" and "C">"
+tmp/c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.C">"
 
 [case testIsInstanceAdHocIntersectionIncrementalUnderlyingObjChang]
 import c
@@ -5378,9 +5376,9 @@ from b import y
 reveal_type(y)
 [builtins fixtures/isinstance.pyi]
 [out]
-tmp/c.py:2: note: Revealed type is "b.<subclass of "A" and "B">"
+tmp/c.py:2: note: Revealed type is "b.<subclass of "a.A" and "a.B">"
 [out2]
-tmp/c.py:2: note: Revealed type is "b.<subclass of "A" and "C">"
+tmp/c.py:2: note: Revealed type is "b.<subclass of "a.A" and "a.C">"
 
 [case testIsInstanceAdHocIntersectionIncrementalIntersectionToUnreachable]
 import c
@@ -5411,9 +5409,10 @@ from b import z
 reveal_type(z)
 [builtins fixtures/isinstance.pyi]
 [out]
-tmp/c.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+tmp/c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 [out2]
-tmp/c.py:2: note: Revealed type is "a.A"
+tmp/b.py:2: error: Cannot determine type of "y"
+tmp/c.py:2: note: Revealed type is "Any"
 
 [case testIsInstanceAdHocIntersectionIncrementalUnreachaableToIntersection]
 import c
@@ -5444,9 +5443,63 @@ from b import z
 reveal_type(z)
 [builtins fixtures/isinstance.pyi]
 [out]
-tmp/c.py:2: note: Revealed type is "a.A"
+tmp/b.py:2: error: Cannot determine type of "y"
+tmp/c.py:2: note: Revealed type is "Any"
+[out2]
+tmp/c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
+
+[case testIsInstanceAdHocIntersectionIncrementalNestedClass]
+import b
+[file a.py]
+class A:
+    class B: ...
+    class C: ...
+    class D:
+        def __init__(self) -> None:
+            x: A.B
+            assert isinstance(x, A.C)
+            self.x = x
+[file b.py]
+from a import A
+[file b.py.2]
+from a import A
+reveal_type(A.D.x)
+[builtins fixtures/isinstance.pyi]
+[out]
+[out2]
+tmp/b.py:2: note: Revealed type is "a.<subclass of "a.A.B" and "a.A.C">"
+
+[case testIsInstanceAdHocIntersectionIncrementalUnions]
+import c
+[file a.py]
+import b
+class A:
+    p: b.D
+class B:
+    p: b.D
+class C:
+    p: b.D
+    c: str
+x: A
+assert isinstance(x, (B, C))
+y = x
+[file b.py]
+class D:
+    p: int
+[file c.py]
+from a import y
+[file c.py.2]
+from a import y, C
+reveal_type(y)
+reveal_type(y.p.p)
+assert isinstance(y, C)
+reveal_type(y.c)
+[builtins fixtures/isinstance.pyi]
+[out]
 [out2]
-tmp/c.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+tmp/c.py:2: note: Revealed type is "Union[a.<subclass of "a.A" and "a.B">, a.<subclass of "a.A" and "a.C">]"
+tmp/c.py:3: note: Revealed type is "builtins.int"
+tmp/c.py:5: note: Revealed type is "builtins.str"
 
 [case testStubFixupIssues]
 import a
@@ -5506,7 +5559,6 @@ class Foo:
 class C: pass
 
 [case testIncrementalNestedNamedTuple]
-# flags: --python-version 3.6
 import a
 
 [file a.py]
@@ -5673,7 +5725,6 @@ A().g()
 [out2]
 
 [case testIncrementalWithDifferentKindsOfNestedTypesWithinMethod]
-# flags: --python-version 3.7
 
 import a
 
@@ -5685,8 +5736,8 @@ import b
 b.xyz
 
 [file b.py]
-from typing import NamedTuple, NewType
-from typing_extensions import TypedDict, TypeAlias
+from typing import NamedTuple, NewType, TypedDict
+from typing_extensions import TypeAlias
 from enum import Enum
 from dataclasses import dataclass
 
@@ -5722,6 +5773,7 @@ class C:
         n: N = N(NT1(c=1))
 
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out2]
 tmp/a.py:2: error: "object" has no attribute "xyz"
 
@@ -5756,7 +5808,6 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testNamedTupleUpdateNonRecursiveToRecursiveCoarse]
-# flags: --strict-optional
 import c
 [file a.py]
 from b import M
@@ -5799,7 +5850,6 @@ tmp/c.py:5: error: Incompatible types in assignment (expression has type "Option
 tmp/c.py:7: note: Revealed type is "Tuple[Union[Tuple[Union[..., None], builtins.int, fallback=b.M], None], builtins.int, fallback=a.N]"
 
 [case testTupleTypeUpdateNonRecursiveToRecursiveCoarse]
-# flags: --strict-optional
 import c
 [file a.py]
 from b import M
@@ -5832,7 +5882,6 @@ tmp/c.py:4: note: Revealed type is "Tuple[Union[Tuple[Union[..., None], builtins
 tmp/c.py:5: error: Incompatible types in assignment (expression has type "Optional[N]", variable has type "int")
 
 [case testTypeAliasUpdateNonRecursiveToRecursiveCoarse]
-# flags: --strict-optional
 import c
 [file a.py]
 from b import M
@@ -5865,7 +5914,6 @@ tmp/c.py:4: note: Revealed type is "Tuple[Union[Tuple[Union[..., None], builtins
 tmp/c.py:5: error: Incompatible types in assignment (expression has type "Optional[N]", variable has type "int")
 
 [case testTypedDictUpdateNonRecursiveToRecursiveCoarse]
-# flags: --strict-optional
 import c
 [file a.py]
 from b import M
@@ -5940,6 +5988,44 @@ tmp/b.py:4: note: Revealed type is "def ()"
 tmp/b.py:5: note: Revealed type is "def (builtins.int) -> builtins.str"
 tmp/b.py:6: note: Revealed type is "def ()"
 tmp/b.py:7: note: Revealed type is "def (builtins.int) -> builtins.str"
+
+[case testIncrementalAddOverloadedMethodPlugin]
+# flags: --config-file tmp/mypy.ini
+import b
+
+[file mypy.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/add_overloaded_method.py
+
+[file a.py]
+class AddOverloadedMethod: pass
+
+class MyClass(AddOverloadedMethod):
+    pass
+
+[file b.py]
+import a
+
+[file b.py.2]
+import a
+
+reveal_type(a.MyClass.method)
+reveal_type(a.MyClass.clsmethod)
+reveal_type(a.MyClass.stmethod)
+
+my_class = a.MyClass()
+reveal_type(my_class.method)
+reveal_type(my_class.clsmethod)
+reveal_type(my_class.stmethod)
+[rechecked b]
+[out2]
+tmp/b.py:3: note: Revealed type is "Overload(def (self: a.MyClass, arg: builtins.int) -> builtins.str, def (self: a.MyClass, arg: builtins.str) -> builtins.int)"
+tmp/b.py:4: note: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+tmp/b.py:5: note: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+tmp/b.py:8: note: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+tmp/b.py:9: note: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+tmp/b.py:10: note: Revealed type is "Overload(def (arg: builtins.int) -> builtins.str, def (arg: builtins.str) -> builtins.int)"
+
 [case testGenericNamedTupleSerialization]
 import b
 [file a.py]
@@ -5990,7 +6076,8 @@ tmp/b.py:3: error: Incompatible types in assignment (expression has type "int",
 [case testUnpackKwargsSerialize]
 import m
 [file lib.py]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -6006,6 +6093,7 @@ foo(name='Jennifer', age=38)
 from lib import foo
 foo(name='Jennifer', age="38")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 [out2]
 tmp/m.py:2: error: Argument "age" to "foo" has incompatible type "str"; expected "int"
@@ -6060,7 +6148,6 @@ tmp/m.py:9: note:     Got:
 tmp/m.py:9: note:         def update() -> str
 
 [case testAbstractBodyTurnsEmptyCoarse]
-# flags: --strict-optional
 from b import Base
 
 class Sub(Base):
@@ -6080,7 +6167,7 @@ class Base:
     def meth(self) -> int: ...
 [out]
 [out2]
-main:6: error: Call to abstract method "meth" of "Base" with trivial body via super() is unsafe
+main:5: error: Call to abstract method "meth" of "Base" with trivial body via super() is unsafe
 
 [case testNoCrashDoubleReexportFunctionEmpty]
 import m
@@ -6188,7 +6275,7 @@ import f
 # modify
 
 [file f.py]
-from typing_extensions import TypedDict
+from typing import TypedDict
 import c
 class D(TypedDict):
     x: c.C
@@ -6209,6 +6296,7 @@ class C: ...
 class C: ...
 [file pb1.py.2]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 [out2]
 [out3]
@@ -6287,6 +6375,7 @@ class C: ...
 [out3]
 
 [case testNoCrashOnPartialLambdaInference]
+# flags: --no-local-partial-types
 import m
 [file m.py]
 from typing import TypeVar, Callable
@@ -6331,7 +6420,7 @@ reveal_type(D.meth)
 reveal_type(D().meth)
 [out]
 [out2]
-tmp/m.py:4: note: Revealed type is "def [Self <: lib.C] (self: Self`0, other: Self`0) -> Self`0"
+tmp/m.py:4: note: Revealed type is "def [Self <: lib.C] (self: Self`1, other: Self`1) -> Self`1"
 tmp/m.py:5: note: Revealed type is "def (other: m.D) -> m.D"
 
 [case testIncrementalNestedGenericCallableCrash]
@@ -6375,8 +6464,7 @@ y: int = x
 [case testGenericTypedDictWithError]
 import b
 [file a.py]
-from typing import Generic, TypeVar
-from typing_extensions import TypedDict
+from typing import Generic, TypeVar, TypedDict
 
 TValue = TypeVar("TValue")
 class Dict(TypedDict, Generic[TValue]):
@@ -6398,6 +6486,7 @@ def f(d: Dict[TValue]) -> TValue:
 def g(d: Dict[TValue]) -> TValue:
     return d["y"]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 tmp/b.py:6: error: TypedDict "a.Dict[TValue]" has no key "x"
 [out2]
@@ -6428,3 +6517,348 @@ P = ParamSpec("P")
 class C(Generic[P]):
     def __init__(self, fn: Callable[P, int]) -> None: ...
 [builtins fixtures/dict.pyi]
+
+[case testVariadicClassIncrementalUpdateRegularToVariadic]
+from typing import Any
+from lib import C
+
+x: C[int, str]
+
+[file lib.py]
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+S = TypeVar("S")
+class C(Generic[T, S]): ...
+
+[file lib.py.2]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]): ...
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicClassIncrementalUpdateVariadicToRegular]
+from typing import Any
+from lib import C
+
+x: C[int, str, int]
+
+[file lib.py]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]): ...
+[file lib.py.2]
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+S = TypeVar("S")
+class C(Generic[T, S]): ...
+[builtins fixtures/tuple.pyi]
+[out2]
+main:4: error: "C" expects 2 type arguments, but 3 given
+
+[case testVariadicTupleIncrementalUpdateNoCrash]
+import m
+[file m.py]
+from typing import Any
+from lib import C
+
+x: C[Any]
+[file m.py.2]
+from lib import C
+
+x: C[int]
+[file lib.py]
+from typing import Generic, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Tuple[Unpack[Ts]]): ...
+[builtins fixtures/tuple.pyi]
+
+[case testNoIncrementalCrashOnInvalidTypedDict]
+import m
+[file m.py]
+import counts
+[file m.py.2]
+import counts
+# touch
+[file counts.py]
+from typing import TypedDict
+Counts = TypedDict("Counts", {k: int for k in "abc"})  # type: ignore
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testNoIncrementalCrashOnInvalidTypedDictFunc]
+import m
+[file m.py]
+import counts
+[file m.py.2]
+import counts
+# touch
+[file counts.py]
+from typing import TypedDict
+def test() -> None:
+    Counts = TypedDict("Counts", {k: int for k in "abc"})  # type: ignore
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testNoIncrementalCrashOnTypedDictMethod]
+import a
+[file a.py]
+from b import C
+x: C
+[file a.py.2]
+from b import C
+x: C
+reveal_type(x.h)
+[file b.py]
+from typing import TypedDict
+class C:
+    def __init__(self) -> None:
+        self.h: Hidden
+        class Hidden(TypedDict):
+            x: int
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+[out]
+[out2]
+tmp/a.py:3: note: Revealed type is "TypedDict('b.C.Hidden@5', {'x': builtins.int})"
+
+[case testNoIncrementalCrashOnInvalidEnumMethod]
+import a
+[file a.py]
+from lib import TheClass
+[file a.py.2]
+from lib import TheClass
+x: TheClass
+reveal_type(x.enum_type)
+[file lib.py]
+import enum
+
+class TheClass:
+    def __init__(self) -> None:
+        names = ["foo"]
+        pyenum = enum.Enum('Blah', {  # type: ignore[misc]
+            x.upper(): x
+            for x in names
+        })
+        self.enum_type = pyenum
+[builtins fixtures/tuple.pyi]
+[out]
+[out2]
+tmp/a.py:3: note: Revealed type is "def (value: builtins.object) -> lib.TheClass.pyenum@6"
+
+
+[case testIncrementalFunctoolsPartial]
+import a
+
+[file a.py]
+from typing import Callable
+from partial import p1, p2
+
+p1(1, "a", 3)  # OK
+p1(1, "a", c=3)  # OK
+p1(1, b="a", c=3)  # OK
+
+reveal_type(p1)
+
+def takes_callable_int(f: Callable[..., int]) -> None: ...
+def takes_callable_str(f: Callable[..., str]) -> None: ...
+takes_callable_int(p1)
+takes_callable_str(p1)
+
+p2("a")  # OK
+p2("a", 3)  # OK
+p2("a", c=3)  # OK
+p2(1, 3)
+p2(1, "a", 3)
+p2(a=1, b="a", c=3)
+
+[file a.py.2]
+from typing import Callable
+from partial import p3
+
+p3(1)  # OK
+p3(1, c=3)  # OK
+p3(a=1)  # OK
+p3(1, b="a", c=3)  # OK, keywords can be clobbered
+p3(1, 3)
+
+[file partial.py]
+from typing import Callable
+import functools
+
+def foo(a: int, b: str, c: int = 5) -> int: ...
+
+p1 = functools.partial(foo)
+p2 = functools.partial(foo, 1)
+p3 = functools.partial(foo, b="a")
+[builtins fixtures/dict.pyi]
+[out]
+tmp/a.py:8: note: Revealed type is "functools.partial[builtins.int]"
+tmp/a.py:13: error: Argument 1 to "takes_callable_str" has incompatible type "partial[int]"; expected "Callable[..., str]"
+tmp/a.py:13: note: "partial[int].__call__" has type "Callable[[VarArg(Any), KwArg(Any)], int]"
+tmp/a.py:18: error: Argument 1 to "foo" has incompatible type "int"; expected "str"
+tmp/a.py:19: error: Too many arguments for "foo"
+tmp/a.py:19: error: Argument 1 to "foo" has incompatible type "int"; expected "str"
+tmp/a.py:19: error: Argument 2 to "foo" has incompatible type "str"; expected "int"
+tmp/a.py:20: error: Unexpected keyword argument "a" for "foo"
+tmp/partial.py:4: note: "foo" defined here
+[out2]
+tmp/a.py:8: error: Too many positional arguments for "foo"
+tmp/a.py:8: error: Argument 2 to "foo" has incompatible type "int"; expected "str"
+
+
+[case testStartUsingTypeGuard]
+import a
+[file a.py]
+from lib import guard
+from typing import Union
+from typing_extensions import assert_type
+x: Union[int, str]
+
+[file a.py.2]
+from lib import guard
+from typing import Union
+from typing_extensions import assert_type
+x: Union[int, str]
+if guard(x):
+    assert_type(x, int)
+else:
+    assert_type(x, Union[int, str])
+[file lib.py]
+from typing_extensions import TypeGuard
+def guard(x: object) -> TypeGuard[int]:
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testStartUsingTypeIs]
+import a
+[file a.py]
+from lib import guard
+from typing import Union
+from typing_extensions import assert_type
+x: Union[int, str]
+
+[file a.py.2]
+from lib import guard
+from typing import Union
+from typing_extensions import assert_type
+x: Union[int, str]
+if guard(x):
+    assert_type(x, int)
+else:
+    assert_type(x, str)
+[file lib.py]
+from typing_extensions import TypeIs
+def guard(x: object) -> TypeIs[int]:
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testTypeGuardToTypeIs]
+import a
+[file a.py]
+from lib import guard
+from typing import Union
+from typing_extensions import assert_type
+x: Union[int, str]
+if guard(x):
+    assert_type(x, int)
+else:
+    assert_type(x, Union[int, str])
+[file a.py.2]
+from lib import guard
+from typing import Union
+from typing_extensions import assert_type
+x: Union[int, str]
+if guard(x):
+    assert_type(x, int)
+else:
+    assert_type(x, str)
+[file lib.py]
+from typing_extensions import TypeGuard
+def guard(x: object) -> TypeGuard[int]:
+    pass
+[file lib.py.2]
+from typing_extensions import TypeIs
+def guard(x: object) -> TypeIs[int]:
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testStartUsingPEP604Union]
+# flags: --python-version 3.10
+import a
+[file a.py]
+import lib
+
+[file a.py.2]
+from lib import IntOrStr
+assert isinstance(1, IntOrStr)
+
+[file lib.py]
+from typing_extensions import TypeAlias
+
+IntOrStr: TypeAlias = int | str
+assert isinstance(1, IntOrStr)
+[builtins fixtures/type.pyi]
+
+[case testPropertySetterTypeIncremental]
+import b
+[file a.py]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: str) -> None:
+        pass
+[file b.py]
+from a import A
+[file b.py.2]
+from a import A
+a = A()
+a.f = ''  # OK
+reveal_type(a.f)
+a.f = 1
+reveal_type(a.f)
+[builtins fixtures/property.pyi]
+[out]
+[out2]
+tmp/b.py:4: note: Revealed type is "builtins.int"
+tmp/b.py:5: error: Incompatible types in assignment (expression has type "int", variable has type "str")
+tmp/b.py:6: note: Revealed type is "builtins.int"
+
+[case testSerializeDeferredGenericNamedTuple]
+import pkg
+[file pkg/__init__.py]
+from .lib import NT
+[file pkg/lib.py]
+from typing import Generic, NamedTuple, TypeVar
+from pkg import does_not_exist  # type: ignore
+from pkg.missing import also_missing  # type: ignore
+
+T = TypeVar("T", bound=does_not_exist)
+class NT(NamedTuple, Generic[T]):
+    values: also_missing[T]
+[file pkg/__init__.py.2]
+# touch
+from .lib import NT
+[builtins fixtures/tuple.pyi]
+[out]
+[out2]
+
+[case testNewRedefineAffectsCache]
+# flags: --local-partial-types --allow-redefinition-new
+# flags2: --local-partial-types
+# flags3: --local-partial-types --allow-redefinition-new
+x = 0
+if int():
+    x = ""
+[out]
+[out2]
+main:6: error: Incompatible types in assignment (expression has type "str", variable has type "int")
diff --git a/test-data/unit/check-inference-context.test b/test-data/unit/check-inference-context.test
index 625ab091a6a9..17ae6d9934b7 100644
--- a/test-data/unit/check-inference-context.test
+++ b/test-data/unit/check-inference-context.test
@@ -13,31 +13,31 @@ 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()
 if int():
     ab = f()
 if int():
-    b = f() # E: Incompatible types in assignment (expression has type "A[<nothing>]", variable has type "B")
+    b = f() # E: Incompatible types in assignment (expression has type "A[Never]", variable has type "B")
 [case testBasicContextInferenceForConstructor]
 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()
 if int():
     ab = A()
 if int():
-    b = A() # E: Incompatible types in assignment (expression has type "A[<nothing>]", variable has type "B")
+    b = A() # E: Incompatible types in assignment (expression has type "A[Never]", variable has type "B")
 [case testIncompatibleContextInference]
 from typing import TypeVar, Generic
 T = TypeVar('T')
@@ -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,12 +367,12 @@ 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")
+a = [] # E: Incompatible types in assignment (expression has type "List[Never]", variable has type "A")
 
 aa = []
 ao = []
@@ -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"
@@ -622,8 +625,10 @@ reveal_type((lambda x, y: x + y)(1, 2))  # N: Revealed type is "builtins.int"
 reveal_type((lambda s, i: s)(i=0, s='x')) # N: Revealed type is "Literal['x']?"
 reveal_type((lambda s, i: i)(i=0, s='x')) # N: Revealed type is "Literal[0]?"
 reveal_type((lambda x, s, i: x)(1.0, i=0, s='x')) # N: Revealed type is "builtins.float"
-(lambda x, s, i: x)() # E: Too few arguments
-(lambda: 0)(1) # E: Too many arguments
+if object():
+    (lambda x, s, i: x)() # E: Too few arguments
+if object():
+    (lambda: 0)(1) # E: Too many arguments
 -- varargs are not handled, but it should not crash
 reveal_type((lambda *k, s, i: i)(type, i=0, s='x')) # N: Revealed type is "Any"
 reveal_type((lambda s, *k, i: i)(i=0, s='x')) # N: Revealed type is "Any"
@@ -680,6 +685,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,14 +693,15 @@ f(lambda: None)
 g(lambda: None)
 
 [case testIsinstanceInInferredLambda]
-from typing import TypeVar, Callable
+# flags: --new-type-inference
+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
-f(lambda x: 0 if isinstance(x, B) else 1) # E: Cannot infer type argument 1 of "f"
+def f(func: Callable[[T], S], *z: T, r: Optional[S] = None) -> S: pass
+reveal_type(f(lambda x: 0 if isinstance(x, B) else 1))  # N: Revealed type is "Union[Literal[0]?, Literal[1]?]"
 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
 f(
@@ -739,7 +746,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 +771,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 +789,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 +809,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 +830,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]
@@ -833,7 +842,7 @@ T = TypeVar('T')
 def f(x: Union[List[T], str]) -> None: pass
 f([1])
 f('')
-f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "Union[List[<nothing>], str]"
+f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "Union[List[Never], str]"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testIgnoringInferenceContext]
@@ -847,7 +856,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
@@ -902,7 +911,7 @@ from typing import TypeVar, Callable, Generic
 T = TypeVar('T')
 class A(Generic[T]):
     pass
-reveal_type(A()) # N: Revealed type is "__main__.A[<nothing>]"
+reveal_type(A()) # N: Revealed type is "__main__.A[Never]"
 b = reveal_type(A())  # type: A[int] # N: Revealed type is "__main__.A[builtins.int]"
 
 [case testUnionWithGenericTypeItemContext]
@@ -913,11 +922,10 @@ 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]
-# flags: --strict-optional
 from typing import TypeVar, Union, List
 
 T = TypeVar('T')
@@ -941,11 +949,10 @@ 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]
-# flags: --strict-optional
 from typing import TypeVar, Generic
 
 _KT = TypeVar('_KT')
@@ -1213,7 +1220,6 @@ x: Iterable[Union[A, B]] = f(B())
 [builtins fixtures/list.pyi]
 
 [case testWideOuterContextOptional]
-# flags: --strict-optional
 from typing import Optional, Type, TypeVar
 
 class Custom:
@@ -1227,7 +1233,6 @@ def b(x: T) -> Optional[T]:
     return a(x)
 
 [case testWideOuterContextOptionalGenericReturn]
-# flags: --strict-optional
 from typing import Optional, Type, TypeVar, Iterable
 
 class Custom:
@@ -1241,7 +1246,6 @@ def b(x: T) -> Iterable[Optional[T]]:
     return a(x)
 
 [case testWideOuterContextOptionalMethod]
-# flags: --strict-optional
 from typing import Optional, Type, TypeVar
 
 class A: pass
@@ -1274,7 +1278,6 @@ def bar(xs: List[S]) -> S:
 [builtins fixtures/list.pyi]
 
 [case testWideOuterContextOptionalTypeVarReturn]
-# flags: --strict-optional
 from typing import Callable, Iterable, List, Optional, TypeVar
 
 class C:
@@ -1290,7 +1293,6 @@ def g(l: List[C], x: str) -> Optional[C]:
 [builtins fixtures/list.pyi]
 
 [case testWideOuterContextOptionalTypeVarReturnLambda]
-# flags: --strict-optional
 from typing import Callable, Iterable, List, Optional, TypeVar
 
 class C:
@@ -1303,13 +1305,32 @@ def g(l: List[C], x: str) -> Optional[C]:
     return f(l, lambda c: reveal_type(c).x)  # N: Revealed type is "__main__.C"
 [builtins fixtures/list.pyi]
 
+[case testPartialTypeContextWithTwoLambdas]
+from typing import Any, Generic, TypeVar, Callable
+
+def int_to_any(x: int) -> Any: ...
+def any_to_int(x: Any) -> int: ...
+def any_to_str(x: Any) -> str: ...
+
+T = TypeVar("T")
+class W(Generic[T]):
+    def __init__(
+        self, serialize: Callable[[T], Any], deserialize: Callable[[Any], T]
+    ) -> None:
+        ...
+reveal_type(W(lambda x: int_to_any(x), lambda x: any_to_int(x)))  # N: Revealed type is "__main__.W[builtins.int]"
+W(
+    lambda x: int_to_any(x),  # E: Argument 1 to "int_to_any" has incompatible type "str"; expected "int"
+    lambda x: any_to_str(x)
+)
+
 [case testWideOuterContextEmpty]
 from typing import List, TypeVar
 
 T = TypeVar('T', bound=int)
 def f(x: List[T]) -> T: ...
 
-# mypy infers List[<nothing>] here, and <nothing> is a subtype of str
+# mypy infers List[Never] here, and Never is a subtype of str
 y: str = f([])
 [builtins fixtures/list.pyi]
 
@@ -1319,15 +1340,10 @@ from typing import List, TypeVar
 T = TypeVar('T', bound=int)
 def f(x: List[T]) -> List[T]: ...
 
-# TODO: improve error message for such cases, see #3283 and #5706
-y: List[str] = f([]) \
- # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[str]") \
- # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
- # N: Consider using "Sequence" instead, which is covariant
+y: List[str] = f([])
 [builtins fixtures/list.pyi]
 
 [case testWideOuterContextNoArgs]
-# flags: --strict-optional
 from typing import TypeVar, Optional
 
 T = TypeVar('T', bound=int)
@@ -1336,16 +1352,12 @@ def f(x: Optional[T] = None) -> T: ...
 y: str = f()
 
 [case testWideOuterContextNoArgsError]
-# flags: --strict-optional
 from typing import TypeVar, Optional, List
 
 T = TypeVar('T', bound=int)
 def f(x: Optional[T] = None) -> List[T]: ...
 
-y: List[str] = f()  \
-      # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[str]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
-      # N: Consider using "Sequence" instead, which is covariant
+y: List[str] = f()
 [builtins fixtures/list.pyi]
 
 [case testUseCovariantGenericOuterContext]
@@ -1379,7 +1391,7 @@ from typing import Union, List, Any
 
 def f(x: Union[List[str], Any]) -> None:
     a = x if x else []
-    reveal_type(a)  # N: Revealed type is "Union[builtins.list[Union[builtins.str, Any]], builtins.list[builtins.str], Any]"
+    reveal_type(a)  # N: Revealed type is "Union[builtins.list[builtins.str], Any, builtins.list[Union[builtins.str, Any]]]"
 [builtins fixtures/list.pyi]
 
 [case testConditionalExpressionWithEmptyIteableAndUnionWithAny]
@@ -1387,7 +1399,7 @@ from typing import Union, Iterable, Any
 
 def f(x: Union[Iterable[str], Any]) -> None:
     a = x if x else []
-    reveal_type(a)  # N: Revealed type is "Union[builtins.list[Union[builtins.str, Any]], typing.Iterable[builtins.str], Any]"
+    reveal_type(a)  # N: Revealed type is "Union[typing.Iterable[builtins.str], Any, builtins.list[Union[builtins.str, Any]]]"
 [builtins fixtures/list.pyi]
 
 [case testInferMultipleAnyUnionCovariant]
@@ -1419,7 +1431,6 @@ bar({1: 2})
 [builtins fixtures/dict.pyi]
 
 [case testOptionalTypeNarrowedByGenericCall]
-# flags: --strict-optional
 from typing import Dict, Optional
 
 d: Dict[str, str] = {}
@@ -1431,7 +1442,6 @@ def foo(arg: Optional[str] = None) -> None:
 [builtins fixtures/dict.pyi]
 
 [case testOptionalTypeNarrowedByGenericCall2]
-# flags: --strict-optional
 from typing import Dict, Optional
 
 d: Dict[str, str] = {}
@@ -1443,7 +1453,6 @@ if x:
 [builtins fixtures/dict.pyi]
 
 [case testOptionalTypeNarrowedByGenericCall3]
-# flags: --strict-optional
 from typing import Generic, TypeVar, Union
 
 T = TypeVar("T")
@@ -1456,7 +1465,6 @@ def foo(arg: Union[str, int]) -> None:
 [builtins fixtures/isinstance.pyi]
 
 [case testOptionalTypeNarrowedByGenericCall4]
-# flags: --strict-optional
 from typing import Optional, List, Generic, TypeVar
 
 T = TypeVar("T", covariant=True)
@@ -1474,3 +1482,16 @@ b: Any
 i = i if isinstance(i, int) else b
 reveal_type(i)  # N: Revealed type is "Union[Any, builtins.int]"
 [builtins fixtures/isinstance.pyi]
+
+[case testLambdaInferenceUsesNarrowedTypes]
+from typing import Optional, Callable
+
+def f1(key: Callable[[], str]) -> None: ...
+def f2(key: object) -> None: ...
+
+def g(b: Optional[str]) -> None:
+    if b:
+        f1(lambda: reveal_type(b))  # N: Revealed type is "builtins.str"
+        z: Callable[[], str] = lambda: reveal_type(b)  # N: Revealed type is "builtins.str"
+        f2(lambda: reveal_type(b))  # N: Revealed type is "builtins.str"
+        lambda: reveal_type(b)  # N: Revealed type is "builtins.str"
diff --git a/test-data/unit/check-inference.test b/test-data/unit/check-inference.test
index 166e173e7301..25565946158e 100644
--- a/test-data/unit/check-inference.test
+++ b/test-data/unit/check-inference.test
@@ -33,8 +33,8 @@ class B: pass
 [case testLvarInitializedToVoid]
 import typing
 def f() -> None:
-    a = g()    # E: "g" does not return a value
-    #b, c = g() # "g" does not return a value TODO
+    a = g()    # E: "g" does not return a value (it only ever returns None)
+    #b, c = g() # "g" does not return a value (it only ever returns None) TODO
 
 def g() -> None: pass
 [out]
@@ -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"
 
@@ -871,10 +876,10 @@ g('a')() # E: "List[str]" not callable
 # The next line is a case where there are multiple ways to satisfy a constraint
 # involving a Union. Either T = List[str] or T = str would turn out to be valid,
 # but mypy doesn't know how to branch on these two options (and potentially have
-# to backtrack later) and defaults to T = <nothing>. The result is an
+# to backtrack later) and defaults to T = Never. The result is an
 # awkward error message. Either a better error message, or simply accepting the
 # call, would be preferable here.
-g(['a']) # E: Argument 1 to "g" has incompatible type "List[str]"; expected "List[<nothing>]"
+g(['a']) # E: Argument 1 to "g" has incompatible type "List[str]"; expected "List[Never]"
 
 h(g(['a']))
 
@@ -908,7 +913,6 @@ def call(c: Callable[[int], Any], i: int) -> None:
 [out]
 
 [case testCallableMeetAndJoin]
-# flags: --python-version 3.6
 from typing import Callable, Any, TypeVar
 
 class A: ...
@@ -968,7 +972,7 @@ from typing import TypeVar, Union, List
 T = TypeVar('T')
 def f() -> List[T]: pass
 d1 = f() # type: Union[List[int], str]
-d2 = f() # type: Union[int, str] # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "Union[int, str]")
+d2 = f() # type: Union[int, str] # E: Incompatible types in assignment (expression has type "List[Never]", variable has type "Union[int, str]")
 def g(x: T) -> List[T]: pass
 d3 = g(1) # type: Union[List[int], List[str]]
 [builtins fixtures/list.pyi]
@@ -984,7 +988,7 @@ a = k2
 if int():
     a = k2
 if int():
-    a = k1 # E: Incompatible types in assignment (expression has type "Callable[[int, List[T]], List[Union[T, int]]]", variable has type "Callable[[S, List[T]], List[Union[T, int]]]")
+    a = k1 # E: Incompatible types in assignment (expression has type "Callable[[int, List[T@k1]], List[Union[T@k1, int]]]", variable has type "Callable[[S, List[T@k2]], List[Union[T@k2, int]]]")
 b = k1
 if int():
     b = k1
@@ -1031,7 +1035,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 +1046,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 +1119,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 +1139,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 +1161,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")
@@ -1170,7 +1180,7 @@ for e, f in [[]]:  # E: Need type annotation for "e" \
 [case testForStatementInferenceWithVoid]
 def f() -> None: pass
 
-for x in f(): # E: "f" does not return a value
+for x in f(): # E: "f" does not return a value (it only ever returns None)
     pass
 [builtins fixtures/for.pyi]
 
@@ -1228,13 +1238,43 @@ class B: pass
 [builtins fixtures/for.pyi]
 [out]
 
+[case testForStatementIndexNarrowing]
+from typing import TypedDict
+
+class X(TypedDict):
+    hourly: int
+    daily: int
+
+x: X
+for a in ("hourly", "daily"):
+    reveal_type(a)  # N: Revealed type is "Union[Literal['hourly']?, Literal['daily']?]"
+    reveal_type(x[a])  # N: Revealed type is "builtins.int"
+    reveal_type(a.upper())  # N: Revealed type is "builtins.str"
+    c = a
+    reveal_type(c)  # N: Revealed type is "builtins.str"
+    a = "monthly"
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+    a = "yearly"
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+    a = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+    d = a
+    reveal_type(d)  # N: Revealed type is "builtins.str"
+
+b: str
+for b in ("hourly", "daily"):
+    reveal_type(b)  # N: Revealed type is "builtins.str"
+    reveal_type(b.upper())  # N: Revealed type is "builtins.str"
+[builtins fixtures/for.pyi]
+[typing fixtures/typing-full.pyi]
+
 
 -- Regression tests
 -- ----------------
 
 
 [case testMultipleAssignmentWithPartialDefinition]
-a = None # type: A
+a: A
 if int():
     x, a = a, a
     if int():
@@ -1246,7 +1286,7 @@ if int():
 class A: pass
 
 [case testMultipleAssignmentWithPartialDefinition2]
-a = None # type: A
+a: A
 if int():
     a, x = [a, a]
     if int():
@@ -1260,7 +1300,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 +1315,7 @@ class A: pass
 class A: pass
 class B: pass
 
-if A:
+if int():
     a = A()
     if int():
         a = A()
@@ -1365,21 +1405,22 @@ class B: pass
 [builtins fixtures/list.pyi]
 
 [case testUninferableLambda]
+# flags: --new-type-inference
 from typing import TypeVar, Callable
 X = TypeVar('X')
 def f(x: Callable[[X], X]) -> X: pass
-y = f(lambda x: x) # E: Cannot infer type argument 1 of "f"
+y = f(lambda x: x)  # E: Need type annotation for "y"
 
 [case testUninferableLambdaWithTypeError]
+# flags: --new-type-inference
 from typing import TypeVar, Callable
 X = TypeVar('X')
 def f(x: Callable[[X], X], y: str) -> X: pass
-y = f(lambda x: x, 1) # Fail
-[out]
-main:4: error: Cannot infer type argument 1 of "f"
-main:4: error: Argument 2 to "f" has incompatible type "int"; expected "str"
+y = f(lambda x: x, 1) # E: Need type annotation for "y" \
+                      # E: 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
@@ -1391,7 +1432,6 @@ f(b)
 g(b)
 
 [case testLambdaDefaultContext]
-# flags: --strict-optional
 from typing import Callable
 def f(a: Callable[..., None] = lambda *a, **k: None):
     pass
@@ -1428,22 +1468,26 @@ class Wrapper:
 
 def f(cond: bool) -> Any:
     f = Wrapper if cond else lambda x: x
-    reveal_type(f)  # N: Revealed type is "def (x: Any) -> Any"
+    reveal_type(f)  # N: Revealed type is "Union[def (x: Any) -> __main__.Wrapper, def (x: Any) -> Any]"
     return f(3)
 
 def g(cond: bool) -> Any:
     f = lambda x: x if cond else Wrapper
-    reveal_type(f)  # N: Revealed type is "def (x: Any) -> Any"
+    reveal_type(f)  # N: Revealed type is "def (x: Any) -> Union[Any, def (x: Any) -> __main__.Wrapper]"
+    return f(3)
+
+def h(cond: bool) -> Any:
+    f = (lambda x: x) if cond else Wrapper
+    reveal_type(f)  # N: Revealed type is "Union[def (x: Any) -> Any, def (x: Any) -> __main__.Wrapper]"
     return f(3)
 
 -- Boolean operators
 -- -----------------
 
-
 [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 +1508,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 +1525,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()]
@@ -1492,7 +1536,7 @@ if int():
 if int():
     a = x3 \
      # E: Incompatible types in assignment (expression has type "List[B]", variable has type "List[A]") \
-     # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+     # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
      # N: Consider using "Sequence" instead, which is covariant
 [builtins fixtures/list.pyi]
 [typing fixtures/typing-medium.pyi]
@@ -1504,7 +1548,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()]
@@ -1515,7 +1559,7 @@ if int():
 if int():
     a = x3 \
      # E: Incompatible types in assignment (expression has type "List[B]", variable has type "List[A]") \
-     # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+     # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
      # N: Consider using "Sequence" instead, which is covariant
 [builtins fixtures/list.pyi]
 [typing fixtures/typing-medium.pyi]
@@ -1626,7 +1670,7 @@ class A:
         self.a.append('')  # E: Argument 1 to "append" of "list" has incompatible type "str"; expected "int"
 [builtins fixtures/list.pyi]
 
-[case testInferListInitializedToEmptyInClassBodyAndOverriden]
+[case testInferListInitializedToEmptyInClassBodyAndOverridden]
 from typing import List
 
 class A:
@@ -1685,12 +1729,14 @@ b[{}] = 1
 [builtins fixtures/dict.pyi]
 
 [case testInferDictInitializedToEmptyAndUpdatedFromMethod]
+# flags: --no-local-partial-types
 map = {}
 def add() -> None:
     map[1] = 2
 [builtins fixtures/dict.pyi]
 
 [case testInferDictInitializedToEmptyAndUpdatedFromMethodUnannotated]
+# flags: --no-local-partial-types
 map = {}
 def add():
     map[1] = 2
@@ -1800,7 +1846,6 @@ reveal_type(C().a)  # N: Revealed type is "builtins.dict[builtins.int, builtins.
 [builtins fixtures/dict.pyi]
 
 [case testInferAttributeInitializedToNoneAndAssigned]
-# flags: --strict-optional
 class C:
     def __init__(self) -> None:
         self.a = None
@@ -1847,7 +1892,6 @@ reveal_type(C().a)  # N: Revealed type is "builtins.dict[Any, Any]"
 [builtins fixtures/dict.pyi]
 
 [case testInferAttributeInitializedToNoneAndAssignedOtherMethod]
-# flags: --strict-optional
 class C:
     def __init__(self) -> None:
         self.a = None
@@ -1880,7 +1924,7 @@ reveal_type(C().a)  # N: Revealed type is "builtins.dict[Any, Any]"
 [builtins fixtures/dict.pyi]
 
 [case testInferAttributeInitializedToNoneAndAssignedClassBody]
-# flags: --strict-optional
+# flags: --no-local-partial-types
 class C:
     a = None
     def __init__(self) -> None:
@@ -1915,6 +1959,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 +1982,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 +1999,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 +2011,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 +2026,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
@@ -2024,6 +2073,7 @@ x = 1
 [out]
 
 [case testPartiallyInitializedVariableDoesNotEscapeScope2]
+# flags: --no-local-partial-types
 x = None
 def f() -> None:
     x = None
@@ -2069,36 +2119,32 @@ class C:
 -- ------------------------
 
 [case testPartialTypeErrorSpecialCase1]
+# flags: --no-local-partial-types
 # This used to crash.
 class A:
     x = None
     def f(self) -> None:
-        for a in self.x:
+        for a in self.x:  # E: "None" has no attribute "__iter__" (not iterable)
             pass
 [builtins fixtures/for.pyi]
-[out]
-main:5: error: "None" has no attribute "__iter__" (not iterable)
 
 [case testPartialTypeErrorSpecialCase2]
 # This used to crash.
 class A:
-    x = []
+    x = []  # E: Need type annotation for "x" (hint: "x: List[<type>] = ...")
     def f(self) -> None:
         for a in self.x:
             pass
 [builtins fixtures/for.pyi]
-[out]
-main:3: error: Need type annotation for "x" (hint: "x: List[<type>] = ...")
 
 [case testPartialTypeErrorSpecialCase3]
+# flags: --no-local-partial-types
 class A:
     x = None
     def f(self) -> None:
-        for a in A.x:
+        for a in A.x:  # E: "None" has no attribute "__iter__" (not iterable)
             pass
 [builtins fixtures/for.pyi]
-[out]
-main:4: error: "None" has no attribute "__iter__" (not iterable)
 
 [case testPartialTypeErrorSpecialCase4]
 # This used to crash.
@@ -2106,7 +2152,7 @@ arr = []
 arr.append(arr.append(1))
 [builtins fixtures/list.pyi]
 [out]
-main:3: error: "append" of "list" does not return a value
+main:3: error: "append" of "list" does not return a value (it only ever returns None)
 
 -- Multipass
 -- ---------
@@ -2339,8 +2385,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
@@ -2443,10 +2489,11 @@ T = TypeVar('T')
 class C(Sequence[T], Generic[T]): pass
 C[0] = 0
 [out]
-main:4: error: Unsupported target for indexed assignment ("Type[C[Any]]")
+main:4: error: Unsupported target for indexed assignment ("Type[C[T]]")
 main:4: error: Invalid type: try using Literal[0] instead?
 
 [case testNoCrashOnPartialMember]
+# flags: --no-local-partial-types
 class C:
     x = None
     def __init__(self) -> None:
@@ -2467,6 +2514,7 @@ reveal_type(x) # N: Revealed type is "builtins.str"
 [out]
 
 [case testNoCrashOnPartialVariable2]
+# flags: --no-local-partial-types
 from typing import Tuple, TypeVar
 T = TypeVar('T', bound=str)
 
@@ -2522,7 +2570,6 @@ if bool():
 [out]
 
 [case testDontMarkUnreachableAfterInferenceUninhabited2]
-# flags: --strict-optional
 from typing import TypeVar, Optional
 T = TypeVar('T')
 def f(x: Optional[T] = None) -> T: pass
@@ -2593,7 +2640,7 @@ x = ''
 reveal_type(x) # N: Revealed type is "builtins.str"
 
 [case testLocalPartialTypesWithGlobalInitializedToNoneStrictOptional]
-# flags: --local-partial-types --strict-optional
+# flags: --local-partial-types
 x = None
 
 def f() -> None:
@@ -2745,7 +2792,7 @@ class B(A):
 reveal_type(B.x) # N: Revealed type is "None"
 
 [case testLocalPartialTypesWithInheritance2]
-# flags: --local-partial-types --strict-optional
+# flags: --local-partial-types
 class A:
     x: str
 
@@ -2753,7 +2800,7 @@ class B(A):
     x = None  # E: Incompatible types in assignment (expression has type "None", base class "A" defined the type as "str")
 
 [case testLocalPartialTypesWithAnyBaseClass]
-# flags: --local-partial-types --strict-optional
+# flags: --local-partial-types
 from typing import Any
 
 A: Any
@@ -2765,7 +2812,7 @@ class C(B):
     y = None
 
 [case testLocalPartialTypesInMultipleMroItems]
-# flags: --local-partial-types --strict-optional
+# flags: --local-partial-types
 from typing import Optional
 
 class A:
@@ -3090,7 +3137,6 @@ class B(A):
     x = 2  # E: Incompatible types in assignment (expression has type "int", base class "A" defined the type as "str")
 
 [case testInheritedAttributeStrictOptional]
-# flags: --strict-optional
 class A:
     x: str
 
@@ -3116,7 +3162,7 @@ T = TypeVar('T')
 def f() -> Callable[..., NoReturn]: ...
 
 x = f()
-reveal_type(x)  # N: Revealed type is "def (*Any, **Any) -> <nothing>"
+reveal_type(x)  # N: Revealed type is "def (*Any, **Any) -> Never"
 
 [case testDeferralInNestedScopes]
 
@@ -3193,7 +3239,6 @@ x: Inv[int]
 reveal_type(f(x))  # N: Revealed type is "builtins.int"
 
 [case testOptionalTypeVarAgainstOptional]
-# flags: --strict-optional
 from typing import Optional, TypeVar, Iterable, Iterator, List
 
 _T = TypeVar('_T')
@@ -3240,7 +3285,6 @@ reveal_type(b) # N: Revealed type is "collections.defaultdict[builtins.int, buil
 [builtins fixtures/dict.pyi]
 
 [case testPartialDefaultDictListValueStrictOptional]
-# flags: --strict-optional
 from collections import defaultdict
 a = defaultdict(list)
 a['x'].append(1)
@@ -3317,7 +3361,6 @@ def g() -> None: pass
 reveal_type(f(g))  # N: Revealed type is "None"
 
 [case testInferCallableReturningNone2]
-# flags: --strict-optional
 from typing import Callable, TypeVar
 
 T = TypeVar("T")
@@ -3388,7 +3431,6 @@ def collection_from_dict_value(model: Type[T2]) -> None:
 [builtins fixtures/isinstancelist.pyi]
 
 [case testRegression11705_Strict]
-# flags: --strict-optional
 # See: https://github.com/python/mypy/issues/11705
 from typing import Dict, Optional, NamedTuple
 class C(NamedTuple):
@@ -3438,7 +3480,6 @@ foo(("a", {"a": "b"}, "b"))
 [builtins fixtures/dict.pyi]
 
 [case testUseSupertypeAsInferenceContext]
-# flags: --strict-optional
 from typing import List, Optional
 
 class B:
@@ -3537,6 +3578,14 @@ T = TypeVar("T")
 def type_or_callable(value: T, tp: Union[Type[T], Callable[[int], T]]) -> T: ...
 reveal_type(type_or_callable(A("test"), A))  # N: Revealed type is "__main__.A"
 
+[case testUpperBoundAsInferenceFallback]
+from typing import Callable, TypeVar, Any, Mapping, Optional
+T = TypeVar("T", bound=Mapping[str, Any])
+def raises(opts: Optional[T]) -> T: pass
+def assertRaises(cb: Callable[..., object]) -> None: pass
+assertRaises(raises)  # OK
+[builtins fixtures/dict.pyi]
+
 [case testJoinWithAnyFallback]
 from unknown import X  # type: ignore[import]
 
@@ -3548,3 +3597,385 @@ class E(D): ...
 
 reveal_type([E(), D()])  # N: Revealed type is "builtins.list[__main__.D]"
 reveal_type([D(), E()])  # N: Revealed type is "builtins.list[__main__.D]"
+
+[case testCallableInferenceAgainstCallablePosVsStar]
+from typing import TypeVar, Callable, Tuple
+
+T = TypeVar('T')
+S = TypeVar('S')
+
+def f(x: Callable[[T, S], None]) -> Tuple[T, S]: ...
+def g(*x: int) -> None: ...
+reveal_type(f(g))  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallableStarVsPos]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T, S]):
+    def __call__(self, __x: T, *args: S) -> None: ...
+
+def f(x: Call[T, S]) -> Tuple[T, S]: ...
+def g(*x: int) -> None: ...
+reveal_type(f(g))  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallableNamedVsStar]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T, S]):
+    def __call__(self, *, x: T, y: S) -> None: ...
+
+def f(x: Call[T, S]) -> Tuple[T, S]: ...
+def g(**kwargs: int) -> None: ...
+reveal_type(f(g))  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallableStarVsNamed]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T, S]):
+    def __call__(self, *, x: T, **kwargs: S) -> None: ...
+
+def f(x: Call[T, S]) -> Tuple[T, S]: ...
+def g(**kwargs: int) -> None: pass
+reveal_type(f(g))  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallableNamedVsNamed]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T, S]):
+    def __call__(self, *, x: T, y: S) -> None: ...
+
+def f(x: Call[T, S]) -> Tuple[T, S]: ...
+
+# Note: order of names is different w.r.t. protocol
+def g(*, y: int, x: str) -> None: pass
+reveal_type(f(g))  # N: Revealed type is "Tuple[builtins.str, builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallablePosOnlyVsNamed]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T]):
+    def __call__(self, *, x: T) -> None: ...
+
+def f(x: Call[T]) -> Tuple[T, T]: ...
+
+def g(__x: str) -> None: pass
+reveal_type(f(g))  # N: Revealed type is "Tuple[Never, Never]" \
+                   # E: Argument 1 to "f" has incompatible type "Callable[[str], None]"; expected "Call[Never]" \
+                   # N: "Call[Never].__call__" has type "Callable[[NamedArg(Never, 'x')], None]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallableNamedVsPosOnly]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T]):
+    def __call__(self, __x: T) -> None: ...
+
+def f(x: Call[T]) -> Tuple[T, T]: ...
+
+def g(*, x: str) -> None: pass
+reveal_type(f(g))  # N: Revealed type is "Tuple[Never, Never]" \
+                   # E: Argument 1 to "f" has incompatible type "Callable[[NamedArg(str, 'x')], None]"; expected "Call[Never]" \
+                   # N: "Call[Never].__call__" has type "Callable[[Never], None]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallablePosOnlyVsKwargs]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T]):
+    def __call__(self, __x: T) -> None: ...
+
+def f(x: Call[T]) -> Tuple[T, T]: ...
+
+def g(**x: str) -> None: pass
+reveal_type(f(g))  # N: Revealed type is "Tuple[Never, Never]" \
+                   # E: Argument 1 to "f" has incompatible type "Callable[[KwArg(str)], None]"; expected "Call[Never]" \
+                   # N: "Call[Never].__call__" has type "Callable[[Never], None]"
+[builtins fixtures/list.pyi]
+
+[case testCallableInferenceAgainstCallableNamedVsArgs]
+from typing import TypeVar, Callable, Tuple, Protocol
+
+T = TypeVar('T', contravariant=True)
+S = TypeVar('S', contravariant=True)
+
+class Call(Protocol[T]):
+    def __call__(self, *, x: T) -> None: ...
+
+def f(x: Call[T]) -> Tuple[T, T]: ...
+
+def g(*args: str) -> None: pass
+reveal_type(f(g))  # N: Revealed type is "Tuple[Never, Never]" \
+                   # E: Argument 1 to "f" has incompatible type "Callable[[VarArg(str)], None]"; expected "Call[Never]" \
+                   # N: "Call[Never].__call__" has type "Callable[[NamedArg(Never, 'x')], None]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstTypeVarActualBound]
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+S = TypeVar("S")
+def test(f: Callable[[T], S]) -> Callable[[T], S]: ...
+
+F = TypeVar("F", bound=Callable[..., object])
+def dec(f: F) -> F:
+    reveal_type(test(f))  # N: Revealed type is "def (Any) -> builtins.object"
+    return f
+
+[case testInferenceAgainstTypeVarActualUnionBound]
+from typing import Protocol, TypeVar, Union
+
+T_co = TypeVar("T_co", covariant=True)
+class SupportsFoo(Protocol[T_co]):
+    def foo(self) -> T_co: ...
+
+class A:
+    def foo(self) -> A: ...
+class B:
+    def foo(self) -> B: ...
+
+def foo(f: SupportsFoo[T_co]) -> T_co: ...
+
+ABT = TypeVar("ABT", bound=Union[A, B])
+def simpler(k: ABT):
+    foo(k)
+
+[case testInferenceWorksWithEmptyCollectionsNested]
+from typing import List, TypeVar, NoReturn
+T = TypeVar('T')
+def f(a: List[T], b: List[T]) -> T: pass
+x = ["yes"]
+reveal_type(f(x, []))  # N: Revealed type is "builtins.str"
+reveal_type(f(["yes"], []))  # N: Revealed type is "builtins.str"
+
+empty: List[NoReturn]
+f(x, empty)  # E: Cannot infer type argument 1 of "f"
+f(["no"], empty)  # E: Cannot infer type argument 1 of "f"
+[builtins fixtures/list.pyi]
+
+[case testInferenceWorksWithEmptyCollectionsUnion]
+from typing import Any, Dict, NoReturn, NoReturn, Union
+
+def foo() -> Union[Dict[str, Any], Dict[int, Any]]:
+    return {}
+
+empty: Dict[NoReturn, NoReturn]
+def bar() -> Union[Dict[str, Any], Dict[int, Any]]:
+    return empty
+[builtins fixtures/dict.pyi]
+
+[case testUpperBoundInferenceFallbackNotOverused]
+from typing import TypeVar, Protocol, List
+
+S = TypeVar("S", covariant=True)
+class Foo(Protocol[S]):
+    def foo(self) -> S: ...
+def foo(x: Foo[S]) -> S: ...
+
+T = TypeVar("T", bound="Base")
+class Base:
+    def foo(self: T) -> T: ...
+class C(Base):
+    pass
+
+def f(values: List[T]) -> T: ...
+x = foo(f([C()]))
+reveal_type(x)  # N: Revealed type is "__main__.C"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableUnion]
+from typing import Callable, TypeVar, List, Union
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+def dec(f: Callable[[S], T]) -> Callable[[S], List[T]]: ...
+@dec
+def func(arg: T) -> Union[T, str]:
+    ...
+reveal_type(func)  # N: Revealed type is "def [S] (S`1) -> builtins.list[Union[S`1, builtins.str]]"
+reveal_type(func(42))  # N: Revealed type is "builtins.list[Union[builtins.int, builtins.str]]"
+
+def dec2(f: Callable[[S], List[T]]) -> Callable[[S], T]: ...
+@dec2
+def func2(arg: T) -> List[Union[T, str]]:
+    ...
+reveal_type(func2)  # N: Revealed type is "def [S] (S`4) -> Union[S`4, builtins.str]"
+reveal_type(func2(42))  # N: Revealed type is "Union[builtins.int, builtins.str]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallbackProtoMultiple]
+from typing import Callable, Protocol, TypeVar
+from typing_extensions import Concatenate, ParamSpec
+
+V_co = TypeVar("V_co", covariant=True)
+class Metric(Protocol[V_co]):
+    def __call__(self) -> V_co: ...
+
+T = TypeVar("T")
+P = ParamSpec("P")
+def simple_metric(func: Callable[Concatenate[int, P], T]) -> Callable[P, T]: ...
+
+@simple_metric
+def Negate(count: int, /, metric: Metric[float]) -> float: ...
+@simple_metric
+def Combine(count: int, m1: Metric[T], m2: Metric[T], /, *more: Metric[T]) -> T: ...
+
+reveal_type(Negate)  # N: Revealed type is "def (metric: __main__.Metric[builtins.float]) -> builtins.float"
+reveal_type(Combine)  # N: Revealed type is "def [T] (def () -> T`5, def () -> T`5, *more: def () -> T`5) -> T`5"
+
+def m1() -> float: ...
+def m2() -> float: ...
+reveal_type(Combine(m1, m2))  # N: Revealed type is "builtins.float"
+[builtins fixtures/list.pyi]
+
+[case testInferenceWithUninhabitedType]
+from typing import Dict, Generic, List, Never, TypeVar
+
+T = TypeVar("T")
+
+class A(Generic[T]): ...
+class B(Dict[T, T]): ...
+
+def func1(a: A[T], b: T) -> T: ...
+def func2(a: T, b: A[T]) -> T: ...
+
+def a1(a: A[Dict[str, int]]) -> None:
+    reveal_type(func1(a, {}))  # N: Revealed type is "builtins.dict[builtins.str, builtins.int]"
+    reveal_type(func2({}, a))  # N: Revealed type is "builtins.dict[builtins.str, builtins.int]"
+
+def a2(check: bool, a: B[str]) -> None:
+    reveal_type(a if check else {})  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
+
+def a3() -> None:
+    a = {}  # E: Need type annotation for "a" (hint: "a: Dict[<type>, <type>] = ...")
+    b = {1: {}}  # E: Need type annotation for "b"
+    c = {1: {}, 2: {"key": {}}}  # E: Need type annotation for "c"
+    reveal_type(a)  # N: Revealed type is "builtins.dict[Any, Any]"
+    reveal_type(b)  # N: Revealed type is "builtins.dict[builtins.int, builtins.dict[Any, Any]]"
+    reveal_type(c)  # N: Revealed type is "builtins.dict[builtins.int, builtins.dict[builtins.str, builtins.dict[Any, Any]]]"
+
+def a4(x: List[str], y: List[Never]) -> None:
+    z1 = [x, y]
+    z2 = [y, x]
+    reveal_type(z1)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z2)  # N: Revealed type is "builtins.list[builtins.object]"
+    z1[1].append("asdf")  # E: "object" has no attribute "append"
+[builtins fixtures/dict.pyi]
+
+[case testTupleJoinFallbackInference]
+foo = [
+    (1, ("a", "b")),
+    (2, []),
+]
+reveal_type(foo)  # N: Revealed type is "builtins.list[Tuple[builtins.int, typing.Sequence[builtins.str]]]"
+[builtins fixtures/tuple.pyi]
+
+[case testForLoopIndexVaribaleNarrowing1]
+# flags: --local-partial-types
+from typing import Union
+x: Union[int, str]
+x = "abc"
+for x in list[int]():
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testForLoopIndexVaribaleNarrowing2]
+# flags: --enable-error-code=redundant-expr
+from typing import Union
+x: Union[int, str]
+x = "abc"
+for x in list[int]():
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNarrowInFunctionDefer]
+from typing import Optional, Callable, TypeVar
+
+def top() -> None:
+    x: Optional[int]
+    assert x is not None
+
+    def foo() -> None:
+        defer()
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+
+T = TypeVar("T")
+def deco(fn: Callable[[], T]) -> Callable[[], T]: ...
+
+@deco
+def defer() -> int: ...
+
+[case testDeferMethodOfNestedClass]
+from typing import Optional, Callable, TypeVar
+
+class Out:
+    def meth(self) -> None:
+        class In:
+            def meth(self) -> None:
+                reveal_type(defer())  # N: Revealed type is "builtins.int"
+
+T = TypeVar("T")
+def deco(fn: Callable[[], T]) -> Callable[[], T]: ...
+
+@deco
+def defer() -> int: ...
+
+[case testVariableDeferredWithNestedFunction]
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+def deco(fn: Callable[[], T]) -> Callable[[], T]: ...
+
+@deco
+def f() -> None:
+    x = 1
+    f()  # defer current node
+    x = x
+
+    def nested() -> None:
+        ...
+
+    # The type below should not be Any.
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+
+[case testInferenceMappingTypeVarGet]
+from typing import Generic, TypeVar, Union
+
+_T = TypeVar("_T")
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+class Mapping(Generic[_K, _V]):
+    def get(self, key: _K, default: Union[_V, _T]) -> Union[_V, _T]: ...
+
+def check(mapping: Mapping[str, _T]) -> None:
+    ok1 = mapping.get("", "")
+    reveal_type(ok1)  # N: Revealed type is "Union[_T`-1, builtins.str]"
+    ok2: Union[_T, str] = mapping.get("", "")
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-inline-config.test b/test-data/unit/check-inline-config.test
index 0cc2bd71270a..c81dcac94afd 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]
@@ -164,7 +165,6 @@ main:1: error: Unrecognized option: skip_file = True
 main:1: error: Setting "strict" not supported in inline configuration: specify it in a configuration file instead, or set individual inline flags (see "mypy -h" for the list of flags enabled in strict mode)
 
 [case testInlineErrorCodes]
-# flags: --strict-optional
 # mypy: enable-error-code="ignore-without-code,truthy-bool"
 class Foo:
     pass
@@ -174,7 +174,7 @@ if foo: ...  # E: "__main__.foo" has type "Foo" which does not implement __bool_
 42 + "no"  # type: ignore  # E: "type: ignore" comment without error code (consider "type: ignore[operator]" instead)
 
 [case testInlineErrorCodesOverrideConfig]
-# flags: --strict-optional --config-file tmp/mypy.ini
+# flags: --config-file tmp/mypy.ini
 import foo
 import tests.bar
 import tests.baz
@@ -242,7 +242,6 @@ class C:
         self.x = 1
 
 [case testIgnoreErrorsWithUnsafeSuperCall_no_empty]
-# flags: --strict-optional
 
 from m import C
 
@@ -324,3 +323,7 @@ class Foo:
 foo = Foo()
 if foo: ...
 42 + "no"  # type: ignore
+
+
+[case testInlinePythonVersion]
+# mypy: python-version=3.10  # E: python_version not supported in inline configuration
diff --git a/test-data/unit/check-isinstance.test b/test-data/unit/check-isinstance.test
index 2d010b8ba38d..058db1ea8197 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]
 
@@ -115,8 +115,8 @@ if int():
     x = B()
     x.z
     x = foo()
-    x.z          # E: "A" has no attribute "z"
-    x.y
+    reveal_type(x)  # N: Revealed type is "Any"
+reveal_type(x)  # N: Revealed type is "__main__.A"
 
 [case testSingleMultiAssignment]
 x = 'a'
@@ -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):
@@ -1359,7 +1359,7 @@ class B: pass
 
 x = B()
 if isinstance(x, A):
-    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "B" and "A">"
+    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
 else:
     reveal_type(x)  # N: Revealed type is "__main__.B"
 reveal_type(x)  # N: Revealed type is "__main__.B"
@@ -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: ...
@@ -1800,7 +1801,6 @@ if issubclass(fm, Bar):
 [builtins fixtures/isinstance.pyi]
 
 [case testIssubclassWithMetaclassesStrictOptional]
-# flags: --strict-optional
 class FooMetaclass(type): ...
 class BarMetaclass(type): ...
 class Foo(metaclass=FooMetaclass): ...
@@ -1812,9 +1812,9 @@ reveal_type(fm)  # N: Revealed type is "__main__.FooMetaclass"
 if issubclass(fm, Foo):
     reveal_type(fm)  # N: Revealed type is "Type[__main__.Foo]"
 if issubclass(fm, Bar):
-    reveal_type(fm)  # N: Revealed type is "<nothing>"
+    reveal_type(fm)  # N: Revealed type is "Type[__main__.Bar]"
 if issubclass(fm, Baz):
-    reveal_type(fm)  # N: Revealed type is "<nothing>"
+    reveal_type(fm)  # N: Revealed type is "Type[__main__.Baz]"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsinstanceAndNarrowTypeVariable]
@@ -1833,6 +1833,30 @@ def f(x: T) -> None:
     reveal_type(x) # N: Revealed type is "T`-1"
 [builtins fixtures/isinstance.pyi]
 
+[case testIsinstanceAndNegativeNarrowTypeVariableWithUnionBound]
+from typing import Union, TypeVar
+
+class A:
+    a: int
+class B:
+    b: int
+
+T = TypeVar("T", bound=Union[A, B])
+
+def f(x: T) -> T:
+    if isinstance(x, A):
+        reveal_type(x)      # N: Revealed type is "__main__.A"
+        x.a
+        x.b                 # E: "A" has no attribute "b"
+    else:
+        reveal_type(x)      # N: Revealed type is "T`-1"
+        x.a                 # E: "T" has no attribute "a"
+        x.b
+    x.a                     # E: Item "B" of the upper bound "Union[A, B]" of type variable "T" has no attribute "a"
+    x.b                     # E: Item "A" of the upper bound "Union[A, B]" of type variable "T" has no attribute "b"
+    return x
+[builtins fixtures/isinstance.pyi]
+
 [case testIsinstanceAndTypeType]
 from typing import Type
 def f(x: Type[int]) -> None:
@@ -1891,21 +1915,31 @@ if isinstance(x, str, 1): # E: Too many arguments for "isinstance"
     reveal_type(x) # N: Revealed type is "builtins.int"
 [builtins fixtures/isinstancelist.pyi]
 
-[case testIsinstanceNarrowAny]
+[case testIsinstanceNarrowAnyExplicit]
 from typing import Any
 
 def narrow_any_to_str_then_reassign_to_int() -> None:
-    v = 1 # type: Any
+    v: Any = 1
 
     if isinstance(v, str):
         reveal_type(v)  # N: Revealed type is "builtins.str"
         v = 2
         reveal_type(v)  # N: Revealed type is "Any"
+[builtins fixtures/isinstance.pyi]
+
+[case testIsinstanceNarrowAnyImplicit]
+def foo(): ...
+
+def narrow_any_to_str_then_reassign_to_int() -> None:
+    v = foo()
 
+    if isinstance(v, str):
+        reveal_type(v)  # N: Revealed type is "builtins.str"
+        v = 2
+        reveal_type(v)  # N: Revealed type is "builtins.int"
 [builtins fixtures/isinstance.pyi]
 
 [case testNarrowTypeAfterInList]
-# flags: --strict-optional
 from typing import List, Optional
 
 x: List[int]
@@ -1923,7 +1957,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInListOfOptional]
-# flags: --strict-optional
 from typing import List, Optional
 
 x: List[Optional[int]]
@@ -1937,7 +1970,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInListNonOverlapping]
-# flags: --strict-optional
 from typing import List, Optional
 
 x: List[str]
@@ -1951,7 +1983,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInListNested]
-# flags: --strict-optional
 from typing import List, Optional, Any
 
 x: Optional[int]
@@ -1966,7 +1997,6 @@ if x in nested_any:
 [out]
 
 [case testNarrowTypeAfterInTuple]
-# flags: --strict-optional
 from typing import Optional
 class A: pass
 class B(A): pass
@@ -1981,7 +2011,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInNamedTuple]
-# flags: --strict-optional
 from typing import NamedTuple, Optional
 class NT(NamedTuple):
     x: int
@@ -1997,7 +2026,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInDict]
-# flags: --strict-optional
 from typing import Dict, Optional
 x: Dict[str, int]
 y: Optional[str]
@@ -2014,7 +2042,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInNoAnyOrObject]
-# flags: --strict-optional
 from typing import Any, List, Optional
 x: List[Any]
 z: List[object]
@@ -2034,7 +2061,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInUserDefined]
-# flags: --strict-optional
 from typing import Container, Optional
 
 class C(Container[int]):
@@ -2056,7 +2082,6 @@ else:
 [out]
 
 [case testNarrowTypeAfterInSet]
-# flags: --strict-optional
 from typing import Optional, Set
 s: Set[str]
 
@@ -2073,9 +2098,7 @@ else:
 [out]
 
 [case testNarrowTypeAfterInTypedDict]
-# flags: --strict-optional
-from typing import Optional
-from mypy_extensions import TypedDict
+from typing import Optional, TypedDict
 class TD(TypedDict):
     a: int
     b: str
@@ -2086,8 +2109,8 @@ def f() -> None:
     if x not in td:
         return
     reveal_type(x) # N: Revealed type is "builtins.str"
-[typing fixtures/typing-typeddict.pyi]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testIsinstanceWidensWithAnyArg]
@@ -2149,7 +2172,6 @@ else:
 [builtins fixtures/isinstance.pyi]
 
 [case testIsInstanceInitialNoneCheckSkipsImpossibleCasesNoStrictOptional]
-# flags: --strict-optional
 from typing import Optional, Union
 
 class A: pass
@@ -2166,7 +2188,7 @@ def foo2(x: Optional[str]) -> None:
     if x is None:
         reveal_type(x)      # N: Revealed type is "None"
     elif isinstance(x, A):
-        reveal_type(x)      # N: Revealed type is "__main__.<subclass of "str" and "A">"
+        reveal_type(x)      # N: Revealed type is "__main__.<subclass of "builtins.str" and "__main__.A">"
     else:
         reveal_type(x)      # N: Revealed type is "builtins.str"
 [builtins fixtures/isinstance.pyi]
@@ -2190,29 +2212,29 @@ def foo2(x: Optional[str]) -> None:
     if x is None:
         reveal_type(x)      # N: Revealed type is "None"
     elif isinstance(x, A):
-        reveal_type(x)      # N: Revealed type is "__main__.<subclass of "str" and "A">"
+        reveal_type(x)      # N: Revealed type is "__main__.<subclass of "builtins.str" and "__main__.A">"
     else:
         reveal_type(x)      # N: Revealed type is "builtins.str"
 [builtins fixtures/isinstance.pyi]
 
-[case testNoneCheckDoesNotNarrowWhenUsingTypeVars]
-# flags: --strict-optional
-
-# Note: this test (and the following one) are testing checker.conditional_type_map:
-# if you set the 'prohibit_none_typevar_overlap' keyword argument to False when calling
-# 'is_overlapping_types', the binder will incorrectly infer that 'out' has a type of
-# Union[T, None] after the if statement.
-
+[case testNoneCheckDoesNotMakeTypeVarOptional]
 from typing import TypeVar
 
 T = TypeVar('T')
 
-def foo(x: T) -> T:
+def foo_if(x: T) -> T:
     out = None
     out = x
     if out is None:
         pass
     return out
+
+def foo_while(x: T) -> T:
+    out = None
+    out = x
+    while out is None:
+        pass
+    return out
 [builtins fixtures/isinstance.pyi]
 
 [case testNoneCheckDoesNotNarrowWhenUsingTypeVarsNoStrictOptional]
@@ -2248,7 +2270,6 @@ def bar(x: Union[List[str], List[int], None]) -> None:
 [builtins fixtures/isinstancelist.pyi]
 
 [case testNoneAndGenericTypesOverlapStrictOptional]
-# flags: --strict-optional
 from typing import Union, Optional, List
 
 # This test is the same as the one above, except for strict-optional.
@@ -2302,15 +2323,15 @@ class C:
 
 x: A
 if isinstance(x, B):
-    reveal_type(x)           # N: Revealed type is "__main__.<subclass of "A" and "B">"
+    reveal_type(x)           # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
     if isinstance(x, C):
-        reveal_type(x)       # N: Revealed type is "__main__.<subclass of "A", "B", and "C">"
+        reveal_type(x)       # N: Revealed type is "__main__.<subclass of "__main__.A", "__main__.B", and "__main__.C">"
         reveal_type(x.f1())  # N: Revealed type is "builtins.int"
         reveal_type(x.f2())  # N: Revealed type is "builtins.int"
         reveal_type(x.f3())  # N: Revealed type is "builtins.int"
-        x.bad()              # E: "<subclass of "A", "B", and "C">" has no attribute "bad"
+        x.bad()              # E: "<subclass of "__main__.A", "__main__.B", and "__main__.C">" has no attribute "bad"
     else:
-        reveal_type(x)       # N: Revealed type is "__main__.<subclass of "A" and "B">"
+        reveal_type(x)       # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
 else:
     reveal_type(x)           # N: Revealed type is "__main__.A"
 [builtins fixtures/isinstance.pyi]
@@ -2323,11 +2344,11 @@ class B: pass
 
 x: A
 if isinstance(x, B):
-    reveal_type(x)      # N: Revealed type is "__main__.<subclass of "A" and "B">"
+    reveal_type(x)      # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
     if isinstance(x, A):
-        reveal_type(x)  # N: Revealed type is "__main__.<subclass of "A" and "B">"
+        reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
     if isinstance(x, B):
-        reveal_type(x)  # N: Revealed type is "__main__.<subclass of "A" and "B">"
+        reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsInstanceAdHocIntersectionIncompatibleClasses]
@@ -2348,7 +2369,7 @@ else:
 
 y: C
 if isinstance(y, B):
-    reveal_type(y)        # N: Revealed type is "__main__.<subclass of "C" and "B">"
+    reveal_type(y)        # N: Revealed type is "__main__.<subclass of "__main__.C" and "__main__.B">"
     if isinstance(y, A):  # E: Subclass of "C", "B", and "A" cannot exist: would have incompatible method signatures
         reveal_type(y)    # E: Statement is unreachable
 [builtins fixtures/isinstance.pyi]
@@ -2357,7 +2378,7 @@ if isinstance(y, B):
 # flags: --warn-unreachable
 
 from abc import abstractmethod
-from typing_extensions import Literal
+from typing import Literal
 
 class A0:
     def f(self) -> Literal[0]:
@@ -2382,19 +2403,19 @@ class B:
 
     def t1(self) -> None:
         if isinstance(self, A1):
-            reveal_type(self)           # N: Revealed type is "__main__.<subclass of "A1" and "B">"
+            reveal_type(self)           # N: Revealed type is "__main__.<subclass of "__main__.A1" and "__main__.B">"
             x0: Literal[0] = self.f()   # E: Incompatible types in assignment (expression has type "Literal[1]", variable has type "Literal[0]")
             x1: Literal[1] = self.f()
 
     def t2(self) -> None:
         if isinstance(self, (A0, A1)):
-            reveal_type(self)           # N: Revealed type is "__main__.<subclass of "A1" and "B">1"
+            reveal_type(self)           # N: Revealed type is "__main__.<subclass of "__main__.A1" and "__main__.B">"
             x0: Literal[0] = self.f()   # E: Incompatible types in assignment (expression has type "Literal[1]", variable has type "Literal[0]")
             x1: Literal[1] = self.f()
 
     def t3(self) -> None:
         if isinstance(self, (A1, A2)):
-            reveal_type(self)           # N: Revealed type is "Union[__main__.<subclass of "A1" and "B">2, __main__.<subclass of "A2" and "B">]"
+            reveal_type(self)           # N: Revealed type is "Union[__main__.<subclass of "__main__.A1" and "__main__.B">, __main__.<subclass of "__main__.A2" and "__main__.B">]"
             x0: Literal[0] = self.f()   # E: Incompatible types in assignment (expression has type "Literal[1, 2]", variable has type "Literal[0]")
             x1: Literal[1] = self.f()   # E: Incompatible types in assignment (expression has type "Literal[1, 2]", variable has type "Literal[1]")
 
@@ -2421,14 +2442,14 @@ else:
 
 y: A[Parent]
 if isinstance(y, B):
-    reveal_type(y)      # N: Revealed type is "__main__.<subclass of "A" and "B">"
+    reveal_type(y)      # N: Revealed type is "__main__.<subclass of "__main__.A[__main__.Parent]" and "__main__.B">"
     reveal_type(y.f())  # N: Revealed type is "__main__.Parent"
 else:
     reveal_type(y)      # N: Revealed type is "__main__.A[__main__.Parent]"
 
 z: A[Child]
 if isinstance(z, B):
-    reveal_type(z)      # N: Revealed type is "__main__.<subclass of "A" and "B">1"
+    reveal_type(z)      # N: Revealed type is "__main__.<subclass of "__main__.A[__main__.Child]" and "__main__.B">"
     reveal_type(z.f())  # N: Revealed type is "__main__.Child"
 else:
     reveal_type(z)      # N: Revealed type is "__main__.A[__main__.Child]"
@@ -2449,10 +2470,10 @@ T1 = TypeVar('T1', A, B)
 def f1(x: T1) -> T1:
     if isinstance(x, A):
         reveal_type(x)      # N: Revealed type is "__main__.A" \
-                            # N: Revealed type is "__main__.<subclass of "B" and "A">"
+                            # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
         if isinstance(x, B):
-            reveal_type(x)  # N: Revealed type is "__main__.<subclass of "A" and "B">" \
-                            # N: Revealed type is "__main__.<subclass of "B" and "A">"
+            reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">" \
+                            # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
         else:
             reveal_type(x)  # N: Revealed type is "__main__.A"
     else:
@@ -2491,7 +2512,7 @@ T1 = TypeVar('T1', A, B)
 def f1(x: T1) -> T1:
     if isinstance(x, A):
         # The error message is confusing, but we indeed do run into problems if
-        # 'x' is a subclass of A and B
+        # 'x' is a subclass of __main__.A and __main__.B
         return A()   # E: Incompatible return value type (got "A", expected "B")
     else:
         return B()
@@ -2519,10 +2540,10 @@ def accept_concrete(c: Concrete) -> None: pass
 x: A
 if isinstance(x, B):
     var = x
-    reveal_type(var)      # N: Revealed type is "__main__.<subclass of "A" and "B">"
+    reveal_type(var)      # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
     accept_a(var)
     accept_b(var)
-    accept_concrete(var)  # E: Argument 1 to "accept_concrete" has incompatible type "<subclass of "A" and "B">"; expected "Concrete"
+    accept_concrete(var)  # E: Argument 1 to "accept_concrete" has incompatible type "<subclass of "__main__.A" and "__main__.B">"; expected "Concrete"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsInstanceAdHocIntersectionReinfer]
@@ -2532,14 +2553,14 @@ class B: pass
 
 x: A
 assert isinstance(x, B)
-reveal_type(x)      # N: Revealed type is "__main__.<subclass of "A" and "B">"
+reveal_type(x)      # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
 
 y: A
 assert isinstance(y, B)
-reveal_type(y)      # N: Revealed type is "__main__.<subclass of "A" and "B">1"
+reveal_type(y)      # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
 
 x = y
-reveal_type(x)      # N: Revealed type is "__main__.<subclass of "A" and "B">1"
+reveal_type(x)      # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsInstanceAdHocIntersectionWithUnions]
@@ -2552,15 +2573,15 @@ class D: pass
 
 v1: A
 if isinstance(v1, (B, C)):
-    reveal_type(v1)  # N: Revealed type is "Union[__main__.<subclass of "A" and "B">, __main__.<subclass of "A" and "C">]"
+    reveal_type(v1)  # N: Revealed type is "Union[__main__.<subclass of "__main__.A" and "__main__.B">, __main__.<subclass of "__main__.A" and "__main__.C">]"
 
 v2: Union[A, B]
 if isinstance(v2, C):
-    reveal_type(v2)  # N: Revealed type is "Union[__main__.<subclass of "A" and "C">1, __main__.<subclass of "B" and "C">]"
+    reveal_type(v2)  # N: Revealed type is "Union[__main__.<subclass of "__main__.A" and "__main__.C">, __main__.<subclass of "__main__.B" and "__main__.C">]"
 
 v3: Union[A, B]
 if isinstance(v3, (C, D)):
-    reveal_type(v3)  # N: Revealed type is "Union[__main__.<subclass of "A" and "C">2, __main__.<subclass of "A" and "D">, __main__.<subclass of "B" and "C">1, __main__.<subclass of "B" and "D">]"
+    reveal_type(v3)  # N: Revealed type is "Union[__main__.<subclass of "__main__.A" and "__main__.C">, __main__.<subclass of "__main__.A" and "__main__.D">, __main__.<subclass of "__main__.B" and "__main__.C">, __main__.<subclass of "__main__.B" and "__main__.D">]"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsInstanceAdHocIntersectionSameNames]
@@ -2570,7 +2591,7 @@ class A: pass
 
 x: A
 if isinstance(x, A2):
-    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "A" and "A">"
+    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "foo.A">"
 
 [file foo.py]
 class A: pass
@@ -2600,7 +2621,7 @@ class Ambiguous:
 # We bias towards assuming these two classes could be overlapping
 foo: Concrete
 if isinstance(foo, Ambiguous):
-    reveal_type(foo)    # N: Revealed type is "__main__.<subclass of "Concrete" and "Ambiguous">"
+    reveal_type(foo)    # N: Revealed type is "__main__.<subclass of "__main__.Concrete" and "__main__.Ambiguous">"
     reveal_type(foo.x)  # N: Revealed type is "builtins.int"
 [builtins fixtures/isinstance.pyi]
 
@@ -2617,11 +2638,11 @@ class C:
 
 x: Type[A]
 if issubclass(x, B):
-    reveal_type(x)        # N: Revealed type is "Type[__main__.<subclass of "A" and "B">]"
+    reveal_type(x)        # N: Revealed type is "Type[__main__.<subclass of "__main__.A" and "__main__.B">]"
     if issubclass(x, C):  # E: Subclass of "A", "B", and "C" cannot exist: would have incompatible method signatures
         reveal_type(x)    # E: Statement is unreachable
     else:
-        reveal_type(x)    # N: Revealed type is "Type[__main__.<subclass of "A" and "B">]"
+        reveal_type(x)    # N: Revealed type is "Type[__main__.<subclass of "__main__.A" and "__main__.B">]"
 else:
     reveal_type(x)        # N: Revealed type is "Type[__main__.A]"
 [builtins fixtures/isinstance.pyi]
@@ -2650,6 +2671,33 @@ y: Any
 if type(y) is int:
     reveal_type(y) # N: Revealed type is "builtins.int"
 
+[case testTypeEqualsCheckUsingIsNonOverlapping]
+# flags: --warn-unreachable
+from typing import Union
+
+y: str
+if type(y) is int:  # E: Subclass of "str" and "int" cannot exist: would have incompatible method signatures
+    y # E: Statement is unreachable
+else:
+    reveal_type(y) # N: Revealed type is "builtins.str"
+[builtins fixtures/isinstance.pyi]
+
+[case testTypeEqualsCheckUsingIsNonOverlappingChild-xfail]
+# flags: --warn-unreachable
+from typing import Union
+
+class A: ...
+class B: ...
+class C(A): ...
+x: Union[B, C]
+# C instance cannot be exactly its parent A, we need reversed subtyping relationship
+# here (type(parent) is Child).
+if type(x) is A:
+    reveal_type(x)  # E: Statement is unreachable
+else:
+    reveal_type(x)  # N: Revealed type is "Union[__main__.B, __main__.C]"
+[builtins fixtures/isinstance.pyi]
+
 [case testTypeEqualsNarrowingUnionWithElse]
 from typing import Union
 
@@ -2906,3 +2954,31 @@ if hasattr(mod, "y"):
 [file mod.py]
 def __getattr__(attr: str) -> str: ...
 [builtins fixtures/module.pyi]
+
+[case testTypeIsntLostAfterNarrowing]
+from typing import Any
+
+var: Any
+reveal_type(var)  # N: Revealed type is "Any"
+assert isinstance(var, (bool, str))
+reveal_type(var)  # N: Revealed type is "Union[builtins.bool, builtins.str]"
+
+if isinstance(var, bool):
+    reveal_type(var)  # N: Revealed type is "builtins.bool"
+
+# Type of var shouldn't fall back to Any
+reveal_type(var)  # N: Revealed type is "Union[builtins.bool, builtins.str]"
+[builtins fixtures/isinstance.pyi]
+
+[case testReuseIntersectionForRepeatedIsinstanceCalls]
+
+class A: ...
+class B: ...
+
+a: A
+if isinstance(a, B):
+    c = a
+if isinstance(a, B):
+    c = a
+
+[builtins fixtures/isinstance.pyi]
diff --git a/test-data/unit/check-kwargs.test b/test-data/unit/check-kwargs.test
index 81fdc444aced..1418f9c3d184 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,13 +344,12 @@ class A: pass
 from typing import Mapping
 class MappingSubclass(Mapping[str, str]): pass
 def f(**kwargs: 'A') -> None: pass
-d = None # type: MappingSubclass
-f(**d)
+d: MappingSubclass
+f(**d)  # E: Argument 1 to "f" has incompatible type "**MappingSubclass"; expected "A"
 class A: pass
 [builtins fixtures/dict.pyi]
 
 [case testInvalidTypeForKeywordVarArg]
-# flags: --strict-optional
 from typing import Dict, Any, Optional
 class A: pass
 def f(**kwargs: 'A') -> None: pass
@@ -352,14 +358,17 @@ f(**d)         # E: Keywords must be strings
 f(**A())       # E: Argument after ** must be a mapping, not "A"
 kwargs: Optional[Any]
 f(**kwargs)    # E: Argument after ** must be a mapping, not "Optional[Any]"
+
+def g(a: int) -> None: pass
+g(a=1, **4)  # E: Argument after ** must be a mapping, not "int"
 [builtins fixtures/dict.pyi]
 
 [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 +377,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 +389,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 +401,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-lists.test b/test-data/unit/check-lists.test
index 899b7c5b209f..77acdafd3319 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]
@@ -79,7 +89,6 @@ reveal_type(c)  # N: Revealed type is "builtins.list[builtins.int]"
 [builtins fixtures/list.pyi]
 
 [case testComprehensionShadowBinder]
-# flags: --strict-optional
 def foo(x: object) -> None:
     if isinstance(x, str):
         [reveal_type(x) for x in [1, 2, 3]]  # N: Revealed type is "builtins.int"
diff --git a/test-data/unit/check-literal.test b/test-data/unit/check-literal.test
index 1a529051259f..f36eff28f33f 100644
--- a/test-data/unit/check-literal.test
+++ b/test-data/unit/check-literal.test
@@ -4,7 +4,7 @@
 --
 
 [case testLiteralInvalidString]
-from typing_extensions import Literal
+from typing import Literal
 def f1(x: 'A[') -> None: pass  # E: Invalid type comment or annotation
 def g1(x: Literal['A[']) -> None: pass
 reveal_type(f1)  # N: Revealed type is "def (x: Any)"
@@ -12,19 +12,23 @@ reveal_type(g1)  # N: Revealed type is "def (x: Literal['A['])"
 
 def f2(x: 'A B') -> None: pass  # E: Invalid type comment or annotation
 def g2(x: Literal['A B']) -> None: pass
+def h2(x: 'A|int') -> None: pass  # E: Name "A" is not defined
+def i2(x: Literal['A|B']) -> None: pass
 reveal_type(f2)  # N: Revealed type is "def (x: Any)"
 reveal_type(g2)  # N: Revealed type is "def (x: Literal['A B'])"
+reveal_type(h2)  # N: Revealed type is "def (x: Union[Any, builtins.int])"
+reveal_type(i2)  # N: Revealed type is "def (x: Literal['A|B'])"
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testLiteralInvalidTypeComment]
-from typing_extensions import Literal
+from typing import Literal
 def f(x):  # E: Syntax error in type comment "(A[) -> None"
     # type: (A[) -> None
     pass
 
 [case testLiteralInvalidTypeComment2]
-from typing_extensions import Literal
+from typing import Literal
 def f(x):  # E: Invalid type comment or annotation
     # type: ("A[") -> None
     pass
@@ -48,10 +52,19 @@ y: Literal[43]
 y = 43
 [typing fixtures/typing-medium.pyi]
 
-[case testLiteralInsideOtherTypes]
-from typing import Tuple
+[case testLiteralFromTypingExtensionsWorks]
 from typing_extensions import Literal
 
+x: Literal[42]
+x = 43  # E: Incompatible types in assignment (expression has type "Literal[43]", variable has type "Literal[42]")
+
+y: Literal[43]
+y = 43
+[builtins fixtures/tuple.pyi]
+
+[case testLiteralInsideOtherTypes]
+from typing import Literal, Tuple
+
 x: Tuple[1]                         # E: Invalid type: try using Literal[1] instead?
 def foo(x: Tuple[1]) -> None: ...   # E: Invalid type: try using Literal[1] instead?
 
@@ -64,9 +77,7 @@ reveal_type(bar)                    # N: Revealed type is "def (x: Tuple[Literal
 [out]
 
 [case testLiteralInsideOtherTypesTypeCommentsPython3]
-# flags: --python-version 3.7
-from typing import Tuple, Optional
-from typing_extensions import Literal
+from typing import Literal, Tuple, Optional
 
 x = None  # type: Optional[Tuple[1]]  # E: Invalid type: try using Literal[1] instead?
 def foo(x):                           # E: Invalid type: try using Literal[1] instead?
@@ -87,7 +98,7 @@ reveal_type(bar)                    # N: Revealed type is "def (x: Tuple[Literal
 from wrapper import *
 
 [file wrapper.pyi]
-from typing_extensions import Literal
+from typing import Literal
 
 alias_1 = Literal['a+b']
 alias_2 = Literal['1+2']
@@ -150,7 +161,7 @@ reveal_type(expr_com_6)  # N: Revealed type is "Literal['"foo"']"
 [out]
 
 [case testLiteralMixingUnicodeAndBytesPython3]
-from typing_extensions import Literal
+from typing import Literal
 
 a_ann: Literal[u"foo"]
 b_ann: Literal["foo"]
@@ -214,8 +225,7 @@ accepts_bytes(c_alias)
 [out]
 
 [case testLiteralMixingUnicodeAndBytesPython3ForwardStrings]
-from typing import TypeVar, Generic
-from typing_extensions import Literal
+from typing import Literal, TypeVar, Generic
 
 a_unicode_wrapper: u"Literal[u'foo']"
 b_unicode_wrapper: u"Literal['foo']"
@@ -278,9 +288,8 @@ reveal_type(c_bytes_wrapper_alias)    # N: Revealed type is "__main__.Wrap[Liter
 [builtins fixtures/tuple.pyi]
 [out]
 
-[case testLiteralUnicodeWeirdCharacters]
-from typing import Any
-from typing_extensions import Literal
+[case testLiteralUnicodeWeirdCharacters-skip_path_normalization]
+from typing import Any, Literal
 
 a1: Literal["\x00\xAC\x62 \u2227 \u03bb(p)"]
 b1: Literal["\x00¬b ∧ λ(p)"]
@@ -334,10 +343,10 @@ a1 = b3
 a1 = c3  # E: Incompatible types in assignment (expression has type "Literal['¬b ∧ λ(p)']", variable has type "Literal['\x00¬b ∧ λ(p)']")
 [builtins fixtures/tuple.pyi]
 
-[out skip-path-normalization]
+[out]
 
 [case testLiteralRenamingImportWorks]
-from typing_extensions import Literal as Foo
+from typing import Literal as Foo
 
 x: Foo[3]
 reveal_type(x)   # N: Revealed type is "Literal[3]"
@@ -357,13 +366,13 @@ reveal_type(x)  # N: Revealed type is "Literal[3]"
 reveal_type(y)  # N: Revealed type is "Literal[4]"
 
 [file other_module.py]
-from typing_extensions import Literal as Foo
+from typing import Literal as Foo
 Bar = Foo[4]
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testLiteralRenamingImportNameConfusion]
-from typing_extensions import Literal as Foo
+from typing import Literal as Foo
 
 x: Foo["Foo"]
 reveal_type(x)  # N: Revealed type is "Literal['Foo']"
@@ -393,39 +402,46 @@ indirect = f()
 --
 
 [case testLiteralBasicIntUsage]
-from typing_extensions import Literal
+from typing import Literal
 
 a1: Literal[4]
 b1: Literal[0x2a]
 c1: Literal[-300]
+d1: Literal[+8]
 
 reveal_type(a1)  # N: Revealed type is "Literal[4]"
 reveal_type(b1)  # N: Revealed type is "Literal[42]"
 reveal_type(c1)  # N: Revealed type is "Literal[-300]"
+reveal_type(d1)  # N: Revealed type is "Literal[8]"
 
 a2t = Literal[4]
 b2t = Literal[0x2a]
 c2t = Literal[-300]
+d2t = Literal[+8]
 a2: a2t
 b2: b2t
 c2: c2t
+d2: d2t
 
 reveal_type(a2)  # N: Revealed type is "Literal[4]"
 reveal_type(b2)  # N: Revealed type is "Literal[42]"
 reveal_type(c2)  # N: Revealed type is "Literal[-300]"
+reveal_type(d2)  # N: Revealed type is "Literal[8]"
 
 def f1(x: Literal[4]) -> Literal[4]: pass
 def f2(x: Literal[0x2a]) -> Literal[0x2a]: pass
 def f3(x: Literal[-300]) -> Literal[-300]: pass
+def f4(x: Literal[+8]) -> Literal[+8]: pass
 
 reveal_type(f1)  # N: Revealed type is "def (x: Literal[4]) -> Literal[4]"
 reveal_type(f2)  # N: Revealed type is "def (x: Literal[42]) -> Literal[42]"
 reveal_type(f3)  # N: Revealed type is "def (x: Literal[-300]) -> Literal[-300]"
+reveal_type(f4)  # N: Revealed type is "def (x: Literal[8]) -> Literal[8]"
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testLiteralBasicBoolUsage]
-from typing_extensions import Literal
+from typing import Literal
 
 a1: Literal[True]
 b1: Literal[False]
@@ -450,7 +466,7 @@ reveal_type(f2)  # N: Revealed type is "def (x: Literal[False]) -> Literal[False
 [out]
 
 [case testLiteralBasicStrUsage]
-from typing_extensions import Literal
+from typing import Literal
 
 a: Literal[""]
 b: Literal["  foo bar  "]
@@ -478,8 +494,8 @@ reveal_type(f5)  # N: Revealed type is "def (x: Literal['foo']) -> Literal['foo'
 [builtins fixtures/tuple.pyi]
 [out]
 
-[case testLiteralBasicStrUsageSlashes]
-from typing_extensions import Literal
+[case testLiteralBasicStrUsageSlashes-skip_path_normalization]
+from typing import Literal
 
 a: Literal[r"foo\nbar"]
 b: Literal["foo\nbar"]
@@ -487,13 +503,13 @@ b: Literal["foo\nbar"]
 reveal_type(a)
 reveal_type(b)
 [builtins fixtures/tuple.pyi]
-[out skip-path-normalization]
+[out]
 main:6: note: Revealed type is "Literal['foo\\nbar']"
 main:7: note: Revealed type is "Literal['foo\nbar']"
 
 [case testLiteralBasicNoneUsage]
 # Note: Literal[None] and None are equivalent
-from typing_extensions import Literal
+from typing import Literal
 a: Literal[None]
 reveal_type(a)   # N: Revealed type is "None"
 
@@ -508,7 +524,7 @@ reveal_type(f3)  # N: Revealed type is "def (x: None)"
 [out]
 
 [case testLiteralCallingUnionFunction]
-from typing_extensions import Literal
+from typing import Literal
 
 def func(x: Literal['foo', 'bar', '  foo  ']) -> None: ...
 
@@ -534,8 +550,7 @@ func(f)  # E: Argument 1 to "func" has incompatible type "Literal['foo', 'bar',
 [out]
 
 [case testLiteralDisallowAny]
-from typing import Any
-from typing_extensions import Literal
+from typing import Any, Literal
 from missing_module import BadAlias     # E: Cannot find implementation or library stub for module named "missing_module" \
                                         # N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
 
@@ -548,7 +563,7 @@ reveal_type(b)                          # N: Revealed type is "Any"
 [out]
 
 [case testLiteralDisallowActualTypes]
-from typing_extensions import Literal
+from typing import Literal
 
 a: Literal[int]     # E: Parameter 1 of Literal[...] is invalid
 b: Literal[float]   # E: Parameter 1 of Literal[...] is invalid
@@ -564,7 +579,7 @@ reveal_type(d)      # N: Revealed type is "Any"
 
 [case testLiteralDisallowFloatsAndComplex]
 
-from typing_extensions import Literal
+from typing import Literal
 a1: Literal[3.14]    # E: Parameter 1 of Literal[...] cannot be of type "float"
 b1: 3.14             # E: Invalid type: float literals cannot be used as a type
 c1: Literal[3j]      # E: Parameter 1 of Literal[...] cannot be of type "complex"
@@ -587,50 +602,47 @@ d2: d2t              # E: Variable "__main__.d2t" is not valid as a type \
 [out]
 
 [case testLiteralDisallowComplexExpressions]
-from typing_extensions import Literal
+from typing import Literal
 def dummy() -> int: return 3
 a: Literal[3 + 4]               # E: Invalid type: Literal[...] cannot contain arbitrary expressions
 b: Literal["  foo  ".trim()]    # E: Invalid type: Literal[...] cannot contain arbitrary expressions
-c: Literal[+42]                 # E: Invalid type: Literal[...] cannot contain arbitrary expressions
 d: Literal[~12]                 # E: Invalid type: Literal[...] cannot contain arbitrary expressions
 e: Literal[dummy()]             # E: Invalid type: Literal[...] cannot contain arbitrary expressions
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testLiteralDisallowCollections]
-from typing_extensions import Literal
-a: Literal[{"a": 1, "b": 2}]    # E: Invalid type: Literal[...] cannot contain arbitrary expressions
+from typing import Literal
+a: Literal[{"a": 1, "b": 2}]    # E: Parameter 1 of Literal[...] is invalid
 b: Literal[{1, 2, 3}]           # E: Invalid type: Literal[...] cannot contain arbitrary expressions
-c: {"a": 1, "b": 2}             # E: Invalid type comment or annotation
+c: {"a": 1, "b": 2}             # E: Inline TypedDict is experimental, must be enabled with --enable-incomplete-feature=InlineTypedDict \
+                                # E: Invalid type: try using Literal[1] instead? \
+                                # E: Invalid type: try using Literal[2] instead?
 d: {1, 2, 3}                    # E: Invalid type comment or annotation
 [builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testLiteralDisallowCollections2]
-
-from typing_extensions import Literal
+from typing import Literal
 a: (1, 2, 3)                    # E: Syntax error in type annotation \
                                 # N: Suggestion: Use Tuple[T1, ..., Tn] instead of (T1, ..., Tn)
 b: Literal[[1, 2, 3]]           # E: Parameter 1 of Literal[...] is invalid
-c: [1, 2, 3]                    # E: Bracketed expression "[...]" is not valid as a type \
-                                # N: Did you mean "List[...]"?
+c: [1, 2, 3]                    # E: Bracketed expression "[...]" is not valid as a type
 [builtins fixtures/tuple.pyi]
-[out]
 
 [case testLiteralDisallowCollectionsTypeAlias]
-
-from typing_extensions import Literal
-at = Literal[{"a": 1, "b": 2}]  # E: Invalid type alias: expression is not a valid type
+from typing import Literal
+at = Literal[{"a": 1, "b": 2}]  # E: Parameter 1 of Literal[...] is invalid
 bt = {"a": 1, "b": 2}
-a: at                           # E: Variable "__main__.at" is not valid as a type \
-                                # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
+a: at
+reveal_type(a)                  # N: Revealed type is "Any"
 b: bt                           # E: Variable "__main__.bt" is not valid as a type \
                                 # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
 [builtins fixtures/dict.pyi]
-[out]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testLiteralDisallowCollectionsTypeAlias2]
-
-from typing_extensions import Literal
+from typing import Literal
 at = Literal[{1, 2, 3}]         # E: Invalid type alias: expression is not a valid type
 bt = {1, 2, 3}
 a: at                           # E: Variable "__main__.at" is not valid as a type \
@@ -638,11 +650,11 @@ a: at                           # E: Variable "__main__.at" is not valid as a ty
 b: bt                           # E: Variable "__main__.bt" is not valid as a type \
                                 # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
 [builtins fixtures/set.pyi]
+[typing fixtures/typing-full.pyi]
 [out]
 
 [case testLiteralDisallowTypeVar]
-from typing import TypeVar, Tuple
-from typing_extensions import Literal
+from typing import Literal, TypeVar, Tuple
 
 T = TypeVar('T')
 
@@ -659,8 +671,7 @@ def foo(b: Literal[T]) -> Tuple[T]: pass   # E: Parameter 1 of Literal[...] is i
 --
 
 [case testLiteralMultipleValues]
-# flags: --strict-optional
-from typing_extensions import Literal
+from typing import Literal
 a: Literal[1, 2, 3]
 b: Literal["a", "b", "c"]
 c: Literal[1, "b", True, None]
@@ -678,7 +689,7 @@ reveal_type(e)   # N: Revealed type is "Union[None, None, None]"
 [out]
 
 [case testLiteralMultipleValuesExplicitTuple]
-from typing_extensions import Literal
+from typing import Literal
 # Unfortunately, it seems like typed_ast is unable to distinguish this from
 # Literal[1, 2, 3]. So we treat the two as being equivalent for now.
 a: Literal[1, 2, 3]
@@ -689,9 +700,8 @@ reveal_type(b)  # N: Revealed type is "Union[Literal[1], Literal[2], Literal[3]]
 [out]
 
 [case testLiteralNestedUsage]
-# flags: --strict-optional
 
-from typing_extensions import Literal
+from typing import Literal
 a: Literal[Literal[3], 4, Literal["foo"]]
 reveal_type(a)  # N: Revealed type is "Union[Literal[3], Literal[4], Literal['foo']]"
 
@@ -711,7 +721,7 @@ reveal_type(combined)  # N: Revealed type is "Union[Literal['r'], Literal['w'],
 [out]
 
 [case testLiteralBiasTowardsAssumingForwardReference]
-from typing_extensions import Literal
+from typing import Literal
 
 a: "Foo"
 reveal_type(a)      # N: Revealed type is "__main__.Foo"
@@ -729,7 +739,7 @@ class Foo: pass
 [out]
 
 [case testLiteralBiasTowardsAssumingForwardReferenceForTypeAliases]
-from typing_extensions import Literal
+from typing import Literal
 
 a: "Foo"
 reveal_type(a)      # N: Revealed type is "Literal[5]"
@@ -751,18 +761,18 @@ Foo = Literal[5]
 [out]
 
 [case testLiteralBiasTowardsAssumingForwardReferencesForTypeComments]
-from typing_extensions import Literal
+from typing 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]
@@ -774,7 +784,7 @@ class Foo: pass
 --
 
 [case testLiteralCallingFunction]
-from typing_extensions import Literal
+from typing import Literal
 def foo(x: Literal[3]) -> None: pass
 
 a: Literal[1]
@@ -788,7 +798,7 @@ foo(c)  # E: Argument 1 to "foo" has incompatible type "int"; expected "Literal[
 [out]
 
 [case testLiteralCallingFunctionWithUnionLiteral]
-from typing_extensions import Literal
+from typing import Literal
 def foo(x: Literal[1, 2, 3]) -> None: pass
 
 a: Literal[1]
@@ -804,7 +814,7 @@ foo(d)  # E: Argument 1 to "foo" has incompatible type "int"; expected "Literal[
 [out]
 
 [case testLiteralCallingFunctionWithStandardBase]
-from typing_extensions import Literal
+from typing import Literal
 def foo(x: int) -> None: pass
 
 a: Literal[1]
@@ -818,9 +828,7 @@ foo(c)  # E: Argument 1 to "foo" has incompatible type "Literal[4, 'foo']"; expe
 [out]
 
 [case testLiteralCheckSubtypingStrictOptional]
-# flags: --strict-optional
-from typing import Any, NoReturn
-from typing_extensions import Literal
+from typing import Any, Literal, NoReturn
 
 lit: Literal[1]
 def f_lit(x: Literal[1]) -> None: pass
@@ -834,19 +842,17 @@ b: NoReturn
 c: None
 
 fa(lit)
-fb(lit)  # E: Argument 1 to "fb" has incompatible type "Literal[1]"; expected "NoReturn"
+fb(lit)  # E: Argument 1 to "fb" has incompatible type "Literal[1]"; expected "Never"
 fc(lit)  # E: Argument 1 to "fc" has incompatible type "Literal[1]"; expected "None"
 
 f_lit(a)
 f_lit(b)
 f_lit(c) # E: Argument 1 to "f_lit" has incompatible type "None"; expected "Literal[1]"
 [builtins fixtures/tuple.pyi]
-[out]
 
 [case testLiteralCheckSubtypingNoStrictOptional]
 # flags: --no-strict-optional
-from typing import Any, NoReturn
-from typing_extensions import Literal
+from typing import Any, Literal, NoReturn
 
 lit: Literal[1]
 def f_lit(x: Literal[1]) -> None: pass
@@ -860,18 +866,16 @@ b: NoReturn
 c: None
 
 fa(lit)
-fb(lit)  # E: Argument 1 to "fb" has incompatible type "Literal[1]"; expected "NoReturn"
+fb(lit)  # E: Argument 1 to "fb" has incompatible type "Literal[1]"; expected "Never"
 fc(lit)  # E: Argument 1 to "fc" has incompatible type "Literal[1]"; expected "None"
 
 f_lit(a)
 f_lit(b)
 f_lit(c)
 [builtins fixtures/tuple.pyi]
-[out]
 
 [case testLiteralCallingOverloadedFunction]
-from typing import overload, Generic, TypeVar, Any
-from typing_extensions import Literal
+from typing import overload, Generic, Literal, TypeVar, Any
 
 T = TypeVar('T')
 class IOLike(Generic[T]): pass
@@ -903,8 +907,7 @@ foo(d)
 [out]
 
 [case testLiteralVariance]
-from typing import Generic, TypeVar
-from typing_extensions import Literal
+from typing import Generic, Literal, TypeVar
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
@@ -935,8 +938,7 @@ c2 = c3
 [out]
 
 [case testLiteralInListAndSequence]
-from typing import List, Sequence
-from typing_extensions import Literal
+from typing import List, Literal, Sequence
 
 def foo(x: List[Literal[1, 2]]) -> None: pass
 def bar(x: Sequence[Literal[1, 2]]) -> None: pass
@@ -945,7 +947,7 @@ a: List[Literal[1]]
 b: List[Literal[1, 2, 3]]
 
 foo(a)  # E: Argument 1 to "foo" has incompatible type "List[Literal[1]]"; expected "List[Literal[1, 2]]" \
-        # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+        # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
         # N: Consider using "Sequence" instead, which is covariant
 foo(b)  # E: Argument 1 to "foo" has incompatible type "List[Literal[1, 2, 3]]"; expected "List[Literal[1, 2]]"
 bar(a)
@@ -954,7 +956,7 @@ bar(b)  # E: Argument 1 to "bar" has incompatible type "List[Literal[1, 2, 3]]";
 [out]
 
 [case testLiteralRenamingDoesNotChangeTypeChecking]
-from typing_extensions import Literal as Foo
+from typing import Literal as Foo
 from other_module import Bar1, Bar2, c
 
 def func(x: Foo[15]) -> None: pass
@@ -966,7 +968,7 @@ func(b)  # E: Argument 1 to "func" has incompatible type "Literal[14]"; expected
 func(c)
 
 [file other_module.py]
-from typing_extensions import Literal
+from typing import Literal
 
 Bar1 = Literal[15]
 Bar2 = Literal[14]
@@ -980,7 +982,7 @@ c: Literal[15]
 --
 
 [case testLiteralInferredInAssignment]
-from typing_extensions import Literal
+from typing import Literal
 
 int1: Literal[1] = 1
 int2 = 1
@@ -1014,7 +1016,7 @@ reveal_type(none3)  # N: Revealed type is "None"
 [out]
 
 [case testLiteralInferredOnlyForActualLiterals]
-from typing_extensions import Literal
+from typing import Literal
 
 w: Literal[1]
 x: Literal["foo"]
@@ -1055,7 +1057,7 @@ combined = h
 [out]
 
 [case testLiteralInferredTypeMustMatchExpected]
-from typing_extensions import Literal
+from typing import Literal
 
 a: Literal[1] = 2           # E: Incompatible types in assignment (expression has type "Literal[2]", variable has type "Literal[1]")
 b: Literal["foo"] = "bar"   # E: Incompatible types in assignment (expression has type "Literal['bar']", variable has type "Literal['foo']")
@@ -1069,7 +1071,7 @@ f: Literal[True, 4] = False         # E: Incompatible types in assignment (expre
 [out]
 
 [case testLiteralInferredInCall]
-from typing_extensions import Literal
+from typing import Literal
 
 def f_int_lit(x: Literal[1]) -> None: pass
 def f_int(x: int) -> None: pass
@@ -1115,7 +1117,7 @@ f_none_lit(n1)
 [out]
 
 [case testLiteralInferredInReturnContext]
-from typing_extensions import Literal
+from typing import Literal
 
 def f1() -> int:
     return 1
@@ -1136,8 +1138,7 @@ def f5(x: Literal[2]) -> Literal[1]:
 [out]
 
 [case testLiteralInferredInListContext]
-from typing import List
-from typing_extensions import Literal
+from typing import List, Literal
 
 a: List[Literal[1]] = [1, 1, 1]
 b = [1, 1, 1]
@@ -1181,8 +1182,7 @@ bad: List[Literal[1, 2]] = [1, 2, 3]  # E: List item 2 has incompatible type "Li
 [case testLiteralInferredInTupleContext]
 # Note: most of the 'are we handling context correctly' tests should have been
 # handled up above, so we keep things comparatively simple for tuples and dicts.
-from typing import Tuple
-from typing_extensions import Literal
+from typing import Literal, Tuple
 
 a: Tuple[Literal[1], Literal[2]] = (1, 2)
 b: Tuple[int, Literal[1, 2], Literal[3], Tuple[Literal["foo"]]] = (1, 2, 3, ("foo",))
@@ -1195,8 +1195,7 @@ reveal_type(d)  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
 [out]
 
 [case testLiteralInferredInDictContext]
-from typing import Dict
-from typing_extensions import Literal
+from typing import Dict, Literal
 
 a = {"x": 1, "y": 2}
 b: Dict[str, Literal[1, 2]] = {"x": 1, "y": 2}
@@ -1208,8 +1207,7 @@ reveal_type(a)  # N: Revealed type is "builtins.dict[builtins.str, builtins.int]
 [out]
 
 [case testLiteralInferredInOverloadContextBasic]
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 @overload
 def func(x: Literal[1]) -> str: ...
@@ -1237,8 +1235,7 @@ reveal_type(func(c))  # N: Revealed type is "builtins.object"
 [out]
 
 [case testLiteralOverloadProhibitUnsafeOverlaps]
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 @overload
 def func1(x: Literal[1]) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
@@ -1262,8 +1259,7 @@ def func3(x): pass
 [out]
 
 [case testLiteralInferredInOverloadContextUnionMath]
-from typing import overload, Union
-from typing_extensions import Literal
+from typing import overload, Literal, Union
 
 class A: pass
 class B: pass
@@ -1308,8 +1304,7 @@ reveal_type(func(f))  # E: No overload variant of "func" matches argument type "
 
 [case testLiteralInferredInOverloadContextUnionMathOverloadingReturnsBestType]
 # This test is a transliteration of check-overloading::testUnionMathOverloadingReturnsBestType
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 @overload
 def f(x: Literal[1, 2]) -> int: ...
@@ -1331,8 +1326,7 @@ reveal_type(f(z))  # N: Revealed type is "builtins.int" \
 [out]
 
 [case testLiteralInferredInOverloadContextWithTypevars]
-from typing import TypeVar, overload, Union
-from typing_extensions import Literal
+from typing import Literal, TypeVar, overload, Union
 
 T = TypeVar('T')
 
@@ -1383,8 +1377,7 @@ reveal_type(f4(b))      # N: Revealed type is "builtins.str"
 
 [case testLiteralInferredInOverloadContextUnionMathTrickyOverload]
 # This test is a transliteration of check-overloading::testUnionMathTrickyOverload1
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 @overload
 def f(x: Literal['a'], y: Literal['a']) -> int: ...
@@ -1406,7 +1399,7 @@ f(x, y)  # E: Argument 1 to "f" has incompatible type "Literal['a', 'b']"; expec
 ---
 
 [case testLiteralFallbackOperatorsWorkCorrectly]
-from typing_extensions import Literal
+from typing import Literal
 
 a: Literal[3]
 b: int
@@ -1438,7 +1431,7 @@ reveal_type(b)          # N: Revealed type is "builtins.int"
 [builtins fixtures/primitives.pyi]
 
 [case testLiteralFallbackInheritedMethodsWorkCorrectly]
-from typing_extensions import Literal
+from typing import Literal
 a: Literal['foo']
 b: str
 
@@ -1450,7 +1443,7 @@ reveal_type(a.strip())          # N: Revealed type is "builtins.str"
 [out]
 
 [case testLiteralFallbackMethodsDoNotCoerceToLiteral]
-from typing_extensions import Literal
+from typing import Literal
 
 a: Literal[3]
 b: int
@@ -1498,10 +1491,9 @@ issubclass(int, indirect.Literal[3])  # E: Cannot use issubclass() with Literal
 [out]
 
 [case testLiteralErrorsWhenSubclassed]
-
-from typing_extensions import Literal
-from typing_extensions import Literal as Renamed
-import typing_extensions as indirect
+from typing import Literal
+from typing import Literal as Renamed
+import typing as indirect
 
 Alias = Literal[3]
 
@@ -1516,9 +1508,9 @@ class Bad4(Alias): pass                 # E: Invalid base class "Alias"
 # TODO: We don't seem to correctly handle invoking types like
 # 'Final' and 'Protocol' as well. When fixing this, also fix
 # those types?
-from typing_extensions import Literal
-from typing_extensions import Literal as Renamed
-import typing_extensions as indirect
+from typing import Literal
+from typing import Literal as Renamed
+import typing as indirect
 
 Alias = Literal[3]
 
@@ -1540,8 +1532,7 @@ indirect.Literal()
 --
 
 [case testLiteralAndGenericsWithSimpleFunctions]
-from typing import TypeVar
-from typing_extensions import Literal
+from typing import Literal, TypeVar
 
 T = TypeVar('T')
 def foo(x: T) -> T: pass
@@ -1571,8 +1562,7 @@ expects_int(foo(foo(a)))
 [out]
 
 [case testLiteralAndGenericWithUnion]
-from typing import TypeVar, Union
-from typing_extensions import Literal
+from typing import Literal, TypeVar, Union
 
 T = TypeVar('T')
 def identity(x: T) -> T: return x
@@ -1583,8 +1573,7 @@ b: Union[int, Literal['foo']] = identity('bar')  # E: Argument 1 to "identity" h
 [out]
 
 [case testLiteralAndGenericsNoMatch]
-from typing import TypeVar, Union, List
-from typing_extensions import Literal
+from typing import Literal, TypeVar, Union, List
 
 def identity(x: T) -> T:
     return x
@@ -1600,8 +1589,7 @@ z: Bad = identity([42])  # E: List item 0 has incompatible type "Literal[42]"; e
 [out]
 
 [case testLiteralAndGenericsWithSimpleClasses]
-from typing import TypeVar, Generic
-from typing_extensions import Literal
+from typing import Literal, TypeVar, Generic
 
 T = TypeVar('T')
 class Wrapper(Generic[T]):
@@ -1637,8 +1625,7 @@ expects_literal_wrapper(Wrapper(5))  # E: Argument 1 to "Wrapper" has incompatib
 [out]
 
 [case testLiteralAndGenericsRespectsUpperBound]
-from typing import TypeVar
-from typing_extensions import Literal
+from typing import Literal, TypeVar
 
 TLiteral = TypeVar('TLiteral', bound=Literal[3])
 TInt = TypeVar('TInt', bound=int)
@@ -1677,8 +1664,7 @@ reveal_type(func2(c))   # N: Revealed type is "builtins.int"
 [out]
 
 [case testLiteralAndGenericsRespectsValueRestriction]
-from typing import TypeVar
-from typing_extensions import Literal
+from typing import Literal, TypeVar
 
 TLiteral = TypeVar('TLiteral', Literal[3], Literal['foo'])
 TNormal = TypeVar('TNormal', int, str)
@@ -1734,8 +1720,7 @@ reveal_type(func2(s2))      # N: Revealed type is "builtins.str"
 [out]
 
 [case testLiteralAndGenericsWithOverloads]
-from typing import TypeVar, overload, Union
-from typing_extensions import Literal
+from typing import Literal, TypeVar, overload, Union
 
 @overload
 def func1(x: Literal[4]) -> Literal[19]: ...
@@ -1760,8 +1745,7 @@ reveal_type(func1(identity(b)))  # N: Revealed type is "builtins.int"
 --
 
 [case testLiteralMeets]
-from typing import TypeVar, List, Callable, Union
-from typing_extensions import Literal
+from typing import TypeVar, List, Literal, Callable, Union, Optional
 
 a: Callable[[Literal[1]], int]
 b: Callable[[Literal[2]], str]
@@ -1794,19 +1778,20 @@ 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"
+if object():
+    reveal_type(unify(f2))  # N: Revealed type is "Never"
 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]
 
 [case testLiteralMeetsWithStrictOptional]
-# flags: --strict-optional
-from typing import TypeVar, Callable, Union
-from typing_extensions import Literal
+from typing import TypeVar, Callable, Literal, Union
 
 a: Callable[[Literal[1]], int]
 b: Callable[[Literal[2]], str]
@@ -1821,7 +1806,7 @@ T = TypeVar('T')
 def unify(func: Callable[[T, T], None]) -> T: pass
 def func(x: Literal[1], y: Literal[2]) -> None: pass
 
-reveal_type(unify(func))  # N: Revealed type is "<nothing>"
+reveal_type(unify(func))  # N: Revealed type is "Never"
 [builtins fixtures/list.pyi]
 [out]
 
@@ -1831,9 +1816,7 @@ reveal_type(unify(func))  # N: Revealed type is "<nothing>"
 --
 
 [case testLiteralIntelligentIndexingTuples]
-# flags: --strict-optional
-from typing import Tuple, NamedTuple, Optional, Final
-from typing_extensions import Literal
+from typing import Literal, Tuple, NamedTuple, Optional, Final
 
 class A: pass
 class B: pass
@@ -1875,13 +1858,13 @@ reveal_type(tup2[idx3])       # N: Revealed type is "__main__.D"
 reveal_type(tup2[idx4])       # N: Revealed type is "__main__.E"
 reveal_type(tup2[idx_neg1])   # N: Revealed type is "__main__.E"
 tup2[idx5]                    # E: Tuple index out of range
-reveal_type(tup2[idx2:idx4])  # N: Revealed type is "Tuple[__main__.C, __main__.D, fallback=__main__.Tup2Class]"
-reveal_type(tup2[::idx2])     # N: Revealed type is "Tuple[__main__.A, __main__.C, __main__.E, fallback=__main__.Tup2Class]"
+reveal_type(tup2[idx2:idx4])  # N: Revealed type is "Tuple[__main__.C, __main__.D]"
+reveal_type(tup2[::idx2])     # N: Revealed type is "Tuple[__main__.A, __main__.C, __main__.E]"
+tup3: Tup2Class = tup2[:]     # E: Incompatible types in assignment (expression has type "Tuple[A, B, C, D, E]", variable has type "Tup2Class")
 [builtins fixtures/slice.pyi]
 
 [case testLiteralIntelligentIndexingTypedDict]
-from typing_extensions import Literal
-from mypy_extensions import TypedDict
+from typing import Literal, TypedDict
 
 class Unrelated: pass
 u: Unrelated
@@ -1905,8 +1888,9 @@ reveal_type(d.get(a_key, u))  # N: Revealed type is "Union[builtins.int, __main_
 reveal_type(d.get(b_key, u))  # N: Revealed type is "Union[builtins.str, __main__.Unrelated]"
 reveal_type(d.get(c_key, u))  # N: Revealed type is "builtins.object"
 
-reveal_type(d.pop(a_key))     # E: Key "a" of TypedDict "Outer" cannot be deleted \
-                              # N: Revealed type is "builtins.int"
+reveal_type(d.pop(a_key))     # N: Revealed type is "builtins.int" \
+                              # E: Key "a" of TypedDict "Outer" cannot be deleted
+
 reveal_type(d.pop(b_key))     # N: Revealed type is "builtins.str"
 d.pop(c_key)                  # E: TypedDict "Outer" has no key "c"
 
@@ -1918,9 +1902,7 @@ del d[c_key]                  # E: TypedDict "Outer" has no key "c"
 [out]
 
 [case testLiteralIntelligentIndexingUsingFinal]
-from typing import Tuple, NamedTuple
-from typing_extensions import Literal, Final
-from mypy_extensions import TypedDict
+from typing import Final, Literal, Tuple, NamedTuple, TypedDict
 
 int_key_good: Final = 0
 int_key_bad: Final = 3
@@ -1957,8 +1939,7 @@ c[str_key_bad]                       # E: TypedDict "MyDict" has no key "missing
 [out]
 
 [case testLiteralIntelligentIndexingTupleUnions]
-from typing import Tuple, NamedTuple
-from typing_extensions import Literal
+from typing import Literal, Tuple, NamedTuple
 
 class A: pass
 class B: pass
@@ -1980,15 +1961,14 @@ reveal_type(tup1[0::idx1])      # N: Revealed type is "Union[Tuple[__main__.A, _
 tup1[idx_bad]                   # E: Tuple index out of range
 
 reveal_type(tup2[idx1])         # N: Revealed type is "Union[__main__.B, __main__.C]"
-reveal_type(tup2[idx1:idx2])    # N: Revealed type is "Union[Tuple[__main__.B, __main__.C, fallback=__main__.Tup2Class], Tuple[__main__.B, __main__.C, __main__.D, fallback=__main__.Tup2Class], Tuple[__main__.C, fallback=__main__.Tup2Class], Tuple[__main__.C, __main__.D, fallback=__main__.Tup2Class]]"
-reveal_type(tup2[0::idx1])      # N: Revealed type is "Union[Tuple[__main__.A, __main__.B, __main__.C, __main__.D, __main__.E, fallback=__main__.Tup2Class], Tuple[__main__.A, __main__.C, __main__.E, fallback=__main__.Tup2Class]]"
+reveal_type(tup2[idx1:idx2])    # N: Revealed type is "Union[Tuple[__main__.B, __main__.C], Tuple[__main__.B, __main__.C, __main__.D], Tuple[__main__.C], Tuple[__main__.C, __main__.D]]"
+reveal_type(tup2[0::idx1])      # N: Revealed type is "Union[Tuple[__main__.A, __main__.B, __main__.C, __main__.D, __main__.E], Tuple[__main__.A, __main__.C, __main__.E]]"
 tup2[idx_bad]                   # E: Tuple index out of range
 [builtins fixtures/slice.pyi]
 [out]
 
 [case testLiteralIntelligentIndexingTypedDictUnions]
-from typing_extensions import Literal, Final
-from mypy_extensions import TypedDict
+from typing import Final, Literal, TypedDict
 
 class A: pass
 class B: pass
@@ -2013,7 +1993,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]?]"
@@ -2039,9 +2019,7 @@ del test[bad_keys]              # E: Key "a" of TypedDict "Test" cannot be delet
 [out]
 
 [case testLiteralIntelligentIndexingMultiTypedDict]
-from typing import Union
-from typing_extensions import Literal
-from mypy_extensions import TypedDict
+from typing import Literal, TypedDict, Union
 
 class A: pass
 class B: pass
@@ -2066,7 +2044,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"
@@ -2079,7 +2057,7 @@ reveal_type(x.get(bad_keys, 3))     # N: Revealed type is "builtins.object"
 --
 
 [case testLiteralFinalInferredAsLiteral]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 var1: Final = 1
 var2: Final = "foo"
@@ -2133,8 +2111,8 @@ force4(reveal_type(f.instancevar4))  # N: Revealed type is "None"
 [builtins fixtures/primitives.pyi]
 [out]
 
-[case testLiteralFinalDirectInstanceTypesSupercedeInferredLiteral]
-from typing_extensions import Final, Literal
+[case testLiteralFinalDirectInstanceTypesSupersedeInferredLiteral]
+from typing import Final, Literal
 
 var1: Final[int] = 1
 var2: Final[str] = "foo"
@@ -2189,7 +2167,7 @@ force4(f.instancevar4)
 [out]
 
 [case testLiteralFinalDirectLiteralTypesForceLiteral]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 var1: Final[Literal[1]] = 1
 var2: Final[Literal["foo"]] = "foo"
@@ -2244,8 +2222,7 @@ force4(reveal_type(f.instancevar4))  # N: Revealed type is "None"
 [out]
 
 [case testLiteralFinalErasureInMutableDatastructures1]
-# flags: --strict-optional
-from typing_extensions import Final
+from typing import Final
 
 var1: Final = [0, None]
 var2: Final = (0, None)
@@ -2255,7 +2232,7 @@ reveal_type(var2)  # N: Revealed type is "Tuple[Literal[0]?, None]"
 [builtins fixtures/tuple.pyi]
 
 [case testLiteralFinalErasureInMutableDatastructures2]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 var1: Final = []
 var1.append(0)
@@ -2273,7 +2250,7 @@ reveal_type(var3)  # N: Revealed type is "builtins.list[Literal[0]]"
 [builtins fixtures/list.pyi]
 
 [case testLiteralFinalMismatchCausesError]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 var1: Final[Literal[4]]     = 1      # E: Incompatible types in assignment (expression has type "Literal[1]", variable has type "Literal[4]")
 var2: Final[Literal['bad']] = "foo"  # E: Incompatible types in assignment (expression has type "Literal['foo']", variable has type "Literal['bad']")
@@ -2303,8 +2280,7 @@ Foo().instancevar1 = 10  # E: Cannot assign to final attribute "instancevar1" \
 [out]
 
 [case testLiteralFinalGoesOnlyOneLevelDown]
-from typing import Tuple
-from typing_extensions import Final, Literal
+from typing import Final, Literal, Tuple
 
 a: Final = 1
 b: Final = (1, 2)
@@ -2321,8 +2297,7 @@ force2(b)  # ok
 [out]
 
 [case testLiteralFinalCollectionPropagation]
-from typing import List
-from typing_extensions import Final, Literal
+from typing import Final, List, Literal
 
 a: Final = 1
 implicit = [a]
@@ -2351,7 +2326,7 @@ force2(reveal_type(direct[0]))   # E: Argument 1 to "force2" has incompatible ty
 [out]
 
 [case testLiteralFinalStringTypesPython3]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 a: Final = u"foo"
 b: Final = "foo"
@@ -2374,8 +2349,7 @@ force_bytes(reveal_type(c))    # N: Revealed type is "Literal[b'foo']"
 [out]
 
 [case testLiteralFinalPropagatesThroughGenerics]
-from typing import TypeVar, Generic
-from typing_extensions import Final, Literal
+from typing import TypeVar, Generic, Final, Literal
 
 
 T = TypeVar('T')
@@ -2430,8 +2404,7 @@ over_literal(reveal_type(WrapperClass(var3)))   # N: Revealed type is "__main__.
 [out]
 
 [case testLiteralFinalUsedInLiteralType]
-
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 a: Final[int] = 3
 b: Final = 3
 c: Final[Literal[3]] = 3
@@ -2445,7 +2418,7 @@ d_wrap: Literal[4, d]  # E: Parameter 2 of Literal[...] is invalid
 [out]
 
 [case testLiteralWithFinalPropagation]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 a: Final = 3
 b: Final = a
@@ -2459,7 +2432,7 @@ expect_3(c)  # E: Argument 1 to "expect_3" has incompatible type "int"; expected
 [out]
 
 [case testLiteralWithFinalPropagationIsNotLeaking]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 final_tuple_direct: Final = (2, 3)
 final_tuple_indirect: Final = final_tuple_direct
@@ -2489,15 +2462,14 @@ expect_2(final_set_2.pop())  # E: Argument 1 to "expect_2" has incompatible type
 --
 
 [case testLiteralWithEnumsBasic]
-
-from typing_extensions import Literal
+from typing import Literal
 from enum import Enum
 
 class Color(Enum):
     RED = 1
     GREEN = 2
     BLUE = 3
-
+    __ROUGE = RED
     def func(self) -> int: pass
 
 r: Literal[Color.RED]
@@ -2506,6 +2478,8 @@ b: Literal[Color.BLUE]
 bad1: Literal[Color]         # E: Parameter 1 of Literal[...] is invalid
 bad2: Literal[Color.func]    # E: Parameter 1 of Literal[...] is invalid
 bad3: Literal[Color.func()]  # E: Invalid type: Literal[...] cannot contain arbitrary expressions
+# TODO: change the next line to use Color._Color__ROUGE when mypy implements name mangling
+bad4: Literal[Color.__ROUGE]  # E: Parameter 1 of Literal[...] is invalid
 
 def expects_color(x: Color) -> None: pass
 def expects_red(x: Literal[Color.RED]) -> None: pass
@@ -2525,7 +2499,7 @@ reveal_type(r.func())     # N: Revealed type is "builtins.int"
 [out]
 
 [case testLiteralWithEnumsDefinedInClass]
-from typing_extensions import Literal
+from typing import Literal
 from enum import Enum
 
 class Wrapper:
@@ -2548,7 +2522,7 @@ reveal_type(r)    # N: Revealed type is "Literal[__main__.Wrapper.Color.RED]"
 [out]
 
 [case testLiteralWithEnumsSimilarDefinitions]
-from typing_extensions import Literal
+from typing import Literal
 import mod_a
 import mod_b
 
@@ -2583,7 +2557,7 @@ class Test(Enum):
 [out]
 
 [case testLiteralWithEnumsDeclaredUsingCallSyntax]
-from typing_extensions import Literal
+from typing import Literal
 from enum import Enum
 
 A = Enum('A', 'FOO BAR')
@@ -2604,7 +2578,7 @@ reveal_type(d)  # N: Revealed type is "Literal[__main__.D.FOO]"
 [out]
 
 [case testLiteralWithEnumsDerivedEnums]
-from typing_extensions import Literal
+from typing import Literal
 from enum import Enum, IntEnum, IntFlag, Flag
 
 def expects_int(x: int) -> None: pass
@@ -2634,7 +2608,7 @@ expects_int(d)  # E: Argument 1 to "expects_int" has incompatible type "Literal[
 [out]
 
 [case testLiteralWithEnumsAliases]
-from typing_extensions import Literal
+from typing import Literal
 from enum import Enum
 
 class Test(Enum):
@@ -2649,7 +2623,7 @@ reveal_type(x)  # N: Revealed type is "Literal[__main__.Test.FOO]"
 [out]
 
 [case testLiteralUsingEnumAttributesInLiteralContexts]
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 from enum import Enum
 
 class Test1(Enum):
@@ -2683,7 +2657,7 @@ expects_test2_foo(final2)
 [out]
 
 [case testLiteralUsingEnumAttributeNamesInLiteralContexts]
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 from enum import Enum
 
 class Test1(Enum):
@@ -2718,8 +2692,7 @@ reveal_type(Test5.FOO.name)  # N: Revealed type is "Literal['FOO']?"
 
 [case testLiteralBinderLastValueErased]
 # mypy: strict-equality
-
-from typing_extensions import Literal
+from typing import Literal
 
 def takes_three(x: Literal[3]) -> None: ...
 x: object
@@ -2742,22 +2715,32 @@ def test() -> None:
         ...
 [builtins fixtures/bool.pyi]
 
-[case testNegativeIntLiteral]
-from typing_extensions import Literal
+[case testUnaryOpLiteral]
+from typing import Literal
 
 a: Literal[-2] = -2
 b: Literal[-1] = -1
 c: Literal[0] = 0
 d: Literal[1] = 1
 e: Literal[2] = 2
+f: Literal[+1] = 1
+g: Literal[+2] = 2
+h: Literal[1] = +1
+i: Literal[+2] = 2
+j: Literal[+3] = +3
+
+x: Literal[+True] = True  # E: Invalid type: Literal[...] cannot contain arbitrary expressions
+y: Literal[-True] = -1  # E: Invalid type: Literal[...] cannot contain arbitrary expressions
+z: Literal[~0] = 0  # E: Invalid type: Literal[...] cannot contain arbitrary expressions
 [out]
-[builtins fixtures/float.pyi]
+[builtins fixtures/ops.pyi]
 
 [case testNegativeIntLiteralWithFinal]
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 
 ONE: Final = 1
 x: Literal[-1] = -ONE
+y: Literal[+1] = +ONE
 
 TWO: Final = 2
 THREE: Final = 3
@@ -2765,10 +2748,10 @@ THREE: Final = 3
 err_code = -TWO
 if bool():
     err_code = -THREE
-[builtins fixtures/float.pyi]
+[builtins fixtures/ops.pyi]
 
 [case testAliasForEnumTypeAsLiteral]
-from typing_extensions import Literal
+from typing import Literal
 from enum import Enum
 
 class Foo(Enum):
@@ -2782,6 +2765,28 @@ reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.A]"
 reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A]"
 [builtins fixtures/tuple.pyi]
 
+[case testLiteralUnionEnumAliasAssignable]
+from enum import Enum
+from typing import Literal, Union
+
+class E(Enum):
+    A = 'a'
+    B = 'b'
+    C = 'c'
+
+A = Literal[E.A]
+B = Literal[E.B, E.C]
+
+def f(x: Union[A, B]) -> None: ...
+def f2(x: Union[A, Literal[E.B, E.C]]) -> None: ...
+def f3(x: Union[Literal[E.A], B]) -> None: ...
+
+def main(x: E) -> None:
+    f(x)
+    f2(x)
+    f3(x)
+[builtins fixtures/tuple.pyi]
+
 [case testStrictEqualityLiteralTrueVsFalse]
 # mypy: strict-equality
 
@@ -2799,9 +2804,7 @@ assert c.a is False
 
 [case testConditionalBoolLiteralUnionNarrowing]
 # flags: --warn-unreachable
-
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 class Truth:
     def __bool__(self) -> Literal[True]: ...
@@ -2863,8 +2866,7 @@ else:
 [case testLiteralAndInstanceSubtyping]
 # https://github.com/python/mypy/issues/7399
 # https://github.com/python/mypy/issues/11232
-from typing import Tuple, Union
-from typing_extensions import Literal, Final
+from typing import Final, Literal, Tuple, Union
 
 x: bool
 
@@ -2906,7 +2908,7 @@ def incorrect_return2() -> Union[Tuple[Literal[True], int], Tuple[Literal[False]
 [builtins fixtures/bool.pyi]
 
 [case testLiteralSubtypeContext]
-from typing_extensions import Literal
+from typing import Literal
 
 class A:
     foo: Literal['bar', 'spam']
@@ -2917,8 +2919,7 @@ reveal_type(B().foo)  # N: Revealed type is "Literal['spam']"
 [builtins fixtures/tuple.pyi]
 
 [case testLiteralSubtypeContextNested]
-from typing import List
-from typing_extensions import Literal
+from typing import List, Literal
 
 class A:
     foo: List[Literal['bar', 'spam']]
@@ -2929,8 +2930,7 @@ reveal_type(B().foo)  # N: Revealed type is "builtins.list[Union[Literal['bar'],
 [builtins fixtures/tuple.pyi]
 
 [case testLiteralSubtypeContextGeneric]
-from typing_extensions import Literal
-from typing import Generic, List, TypeVar
+from typing import Generic, List, Literal, TypeVar
 
 T = TypeVar("T", bound=str)
 
@@ -2945,3 +2945,34 @@ class C(B[Literal["word"]]):
 reveal_type(C().collection)  # N: Revealed type is "builtins.list[Literal['word']]"
 reveal_type(C().word)  # N: Revealed type is "Literal['word']"
 [builtins fixtures/tuple.pyi]
+
+[case testLiteralTernaryUnionNarrowing]
+from typing import Literal, Optional
+
+SEP = Literal["a", "b"]
+
+class Base:
+    def feed_data(
+        self,
+        sep: SEP,
+    ) -> int:
+        return 0
+
+class C(Base):
+    def feed_data(
+        self,
+        sep: Optional[SEP] = None,
+    ) -> int:
+        if sep is None:
+            sep = "a" if int() else "b"
+            reveal_type(sep)  # N: Revealed type is "Union[Literal['a'], Literal['b']]"
+        return super().feed_data(sep)
+[builtins fixtures/primitives.pyi]
+
+[case testLiteralInsideAType]
+from typing import Literal, Type, Union
+
+x: Type[Literal[1]]  # E: Type[...] can't contain "Literal[...]"
+y: Type[Union[Literal[1], Literal[2]]]  # E: Type[...] can't contain "Union[Literal[...], Literal[...]]"
+z: Type[Literal[1, 2]]  # E: Type[...] can't contain "Union[Literal[...], Literal[...]]"
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-lowercase.test b/test-data/unit/check-lowercase.test
index d1ebbdd282fa..ab6d68929f8e 100644
--- a/test-data/unit/check-lowercase.test
+++ b/test-data/unit/check-lowercase.test
@@ -49,3 +49,17 @@ x: type[type]
 y: int
 
 y = x  # E: Incompatible types in assignment (expression has type "type[type]", variable has type "int")
+
+[case testLowercaseSettingOnTypeAnnotationHint]
+# flags: --python-version 3.9 --no-force-uppercase-builtins
+x = []  # E: Need type annotation for "x" (hint: "x: list[<type>] = ...")
+y = {}  # E: Need type annotation for "y" (hint: "y: dict[<type>, <type>] = ...")
+z = set()  # E: Need type annotation for "z" (hint: "z: set[<type>] = ...")
+[builtins fixtures/primitives.pyi]
+
+[case testLowercaseSettingOnRevealTypeType]
+# flags: --python-version 3.9 --no-force-uppercase-builtins
+def f(t: type[int]) -> None:
+    reveal_type(t)  # N: Revealed type is "type[builtins.int]"
+reveal_type(f)  # N: Revealed type is "def (t: type[builtins.int])"
+[builtins fixtures/primitives.pyi]
diff --git a/test-data/unit/check-modules.test b/test-data/unit/check-modules.test
index 8a30237843a5..000dae86131d 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():
@@ -518,8 +519,7 @@ def bar(x: Both, y: Both = ...) -> Both:
 [out]
 
 [case testEllipsisDefaultArgValueInNonStubsMethods]
-from typing import Generic, TypeVar
-from typing_extensions import Protocol
+from typing import Generic, Protocol, TypeVar
 from abc import abstractmethod
 
 T = TypeVar('T')
@@ -566,7 +566,6 @@ x = 1
 x = 1
 
 [case testAssignToFuncDefViaImport]
-# flags: --strict-optional
 
 # Errors differ with the new analyzer. (Old analyzer gave error on the
 # input, which is maybe better, but no error about f, which seems
@@ -585,6 +584,7 @@ x = 1+0
 
 
 [case testConditionalImportAndAssign]
+# flags: --no-strict-optional
 try:
     from m import x
 except:
@@ -676,6 +676,7 @@ class B(A): ...
 
 
 [case testImportVariableAndAssignNone]
+# flags: --no-strict-optional
 try:
     from m import x
 except:
@@ -684,6 +685,7 @@ except:
 x = 1
 
 [case testImportFunctionAndAssignNone]
+# flags: --no-strict-optional
 try:
     from m import f
 except:
@@ -709,6 +711,7 @@ except:
 def f(): pass
 
 [case testAssignToFuncDefViaGlobalDecl2]
+# flags: --no-strict-optional
 import typing
 from m import f
 def g() -> None:
@@ -721,6 +724,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 +734,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 +743,7 @@ def f(): pass
 [out]
 
 [case testConditionalImportAndAssignNoneToModule]
+# flags: --no-strict-optional
 if object():
     import m
 else:
@@ -758,6 +764,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 +937,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]
@@ -1381,14 +1388,14 @@ import b
 import b
 class C:
     def f1(self) -> None:
-        self.x2
+        reveal_type(self.x2)
     def f2(self) -> None:
         self.x2 = b.b
 [file b.py]
 import a
 b = 1 + int()
 [out]
-tmp/a.py:4: error: Cannot determine type of "x2"
+tmp/a.py:4: note: Revealed type is "builtins.int"
 
 [case testErrorInPassTwo1]
 import b
@@ -1501,7 +1508,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 +1539,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 +1568,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]
@@ -1810,6 +1817,8 @@ m = n  # E: Cannot assign multiple modules to name "m" without explicit "types.M
 from stub import Iterable  # E: Module "stub" does not explicitly export attribute "Iterable"
 from stub import D  # E: Module "stub" does not explicitly export attribute "D"
 from stub import C
+from stub import foo
+from stub import bar  # E: Module "stub" does not explicitly export attribute "bar"
 
 c = C()
 reveal_type(c.x)  # N: Revealed type is "builtins.int"
@@ -1820,6 +1829,8 @@ reveal_type(it)  # N: Revealed type is "typing.Iterable[builtins.int]"
 from typing import Iterable
 from substub import C as C
 from substub import C as D
+from package import foo as foo
+import package.bar as bar
 
 def fun(x: Iterable[str]) -> Iterable[int]: pass
 
@@ -1827,6 +1838,10 @@ def fun(x: Iterable[str]) -> Iterable[int]: pass
 class C:
     x: int
 
+[file package/foo.pyi]
+
+[file package/bar.pyi]
+
 [builtins fixtures/module.pyi]
 
 [case testNoReExportFromStubsMemberType]
@@ -1854,7 +1869,8 @@ import stub
 
 reveal_type(stub.y)  # N: Revealed type is "builtins.int"
 reveal_type(stub.z)  # E: Module "stub" does not explicitly export attribute "z" \
-                     # N: Revealed type is "Any"
+                     # N: Revealed type is "builtins.int"
+
 
 [file stub.pyi]
 from substub import y as y
@@ -2058,19 +2074,7 @@ def __getattr__(name): ...
 
 [builtins fixtures/module.pyi]
 
-[case testModuleLevelGetattrNotStub36]
-# flags: --python-version 3.6
-import has_getattr
-reveal_type(has_getattr.any_attribute)  # E: Module has no attribute "any_attribute" \
-                                        # N: Revealed type is "Any"
-[file has_getattr.py]
-def __getattr__(name) -> str: ...
-
-[builtins fixtures/module.pyi]
-
-[case testModuleLevelGetattrNotStub37]
-# flags: --python-version 3.7
-
+[case testModuleLevelGetattrNotStub]
 import has_getattr
 reveal_type(has_getattr.any_attribute)  # N: Revealed type is "builtins.str"
 
@@ -2102,19 +2106,7 @@ def __getattr__(name: str) -> int: ...
 
 [builtins fixtures/module.pyi]
 
-[case testModuleLevelGetattrImportFromNotStub36]
-# flags: --python-version 3.6
-from non_stub import name  # E: Module "non_stub" has no attribute "name"
-reveal_type(name)  # N: Revealed type is "Any"
-
-[file non_stub.py]
-from typing import Any
-def __getattr__(name: str) -> Any: ...
-
-[builtins fixtures/module.pyi]
-
-[case testModuleLevelGetattrImportFromNotStub37]
-# flags: --python-version 3.7
+[case testModuleLevelGetattrImportFromNotStub]
 from non_stub import name
 reveal_type(name)  # N: Revealed type is "Any"
 
@@ -2149,7 +2141,6 @@ def __getattr__(name: str) -> int: ...
 
 
 [case testModuleLevelGetattrAssignedGood]
-# flags: --python-version 3.7
 import non_stub
 reveal_type(non_stub.name)  # N: Revealed type is "builtins.int"
 
@@ -2160,7 +2151,6 @@ def make_getattr_good() -> Callable[[str], int]: ...
 __getattr__ = make_getattr_good()  # OK
 
 [case testModuleLevelGetattrAssignedBad]
-# flags: --python-version 3.7
 import non_stub
 reveal_type(non_stub.name)
 
@@ -2172,10 +2162,9 @@ __getattr__ = make_getattr_bad()
 
 [out]
 tmp/non_stub.py:4: error: Invalid signature "Callable[[], int]" for "__getattr__"
-main:3: note: Revealed type is "builtins.int"
+main:2: note: Revealed type is "builtins.int"
 
 [case testModuleLevelGetattrImportedGood]
-# flags: --python-version 3.7
 import non_stub
 reveal_type(non_stub.name)  # N: Revealed type is "builtins.int"
 
@@ -2186,7 +2175,6 @@ from has_getattr import __getattr__
 def __getattr__(name: str) -> int: ...
 
 [case testModuleLevelGetattrImportedBad]
-# flags: --python-version 3.7
 import non_stub
 reveal_type(non_stub.name)
 
@@ -2198,7 +2186,7 @@ def __getattr__() -> int: ...
 
 [out]
 tmp/has_getattr.py:1: error: Invalid signature "Callable[[], int]" for "__getattr__"
-main:3: note: Revealed type is "builtins.int"
+main:2: note: Revealed type is "builtins.int"
 
 [builtins fixtures/module.pyi]
 
@@ -2894,7 +2882,7 @@ CustomDict(foo="abc", bar="def")
 [file foo/__init__.py]
 [file foo/bar/__init__.py]
 [file foo/bar/custom_dict.py]
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 CustomDict = TypedDict(
     "CustomDict",
@@ -2938,7 +2926,7 @@ reveal_type(abc.__name__)       # N: Revealed type is "builtins.str"
 reveal_type(builtins.__name__)  # N: Revealed type is "builtins.str"
 reveal_type(typing.__name__)    # N: Revealed type is "builtins.str"
 
-[case testSpecialAttrsAreAvaliableInClasses]
+[case testSpecialAttrsAreAvailableInClasses]
 class Some:
     name = __name__
 reveal_type(Some.name)  # N: Revealed type is "builtins.str"
@@ -3134,26 +3122,25 @@ import google.cloud
 from google.cloud import x
 
 [case testErrorFromGoogleCloud]
-import google.cloud
+import google.cloud  # E: Cannot find implementation or library stub for module named "google.cloud" \
+                     # E: Cannot find implementation or library stub for module named "google"
 from google.cloud import x
-import google.non_existent
+import google.non_existent  # E: Cannot find implementation or library stub for module named "google.non_existent"
 from google.non_existent import x
-[out]
-main:1: error: Library stubs not installed for "google.cloud"
-main:1: note: Hint: "python3 -m pip install types-google-cloud-ndb"
-main:1: note: (or run "mypy --install-types" to install all missing stub packages)
-main:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
-main:1: error: Cannot find implementation or library stub for module named "google"
-main:3: error: Cannot find implementation or library stub for module named "google.non_existent"
+
+import google.cloud.ndb  # E: Library stubs not installed for "google.cloud.ndb" \
+                         # N: Hint: "python3 -m pip install types-google-cloud-ndb" \
+                         # N: (or run "mypy --install-types" to install all missing stub packages) \
+                         # N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
+from google.cloud import ndb
 
 [case testMissingSubmoduleOfInstalledStubPackage]
-import bleach.xyz
-from bleach.abc import fgh
+import bleach.exists
+import bleach.xyz  # E: Cannot find implementation or library stub for module named "bleach.xyz" \
+                   # N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
+from bleach.abc import fgh  # E: Cannot find implementation or library stub for module named "bleach.abc"
 [file bleach/__init__.pyi]
-[out]
-main:1: error: Cannot find implementation or library stub for module named "bleach.xyz"
-main:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
-main:2: error: Cannot find implementation or library stub for module named "bleach.abc"
+[file bleach/exists.pyi]
 
 [case testMissingSubmoduleOfInstalledStubPackageIgnored]
 # flags: --ignore-missing-imports
@@ -3204,7 +3191,7 @@ from test1 import aaaa  # E: Module "test1" has no attribute "aaaa"
 import b
 [file a.py]
 class Foo:
-    def frobnicate(self, x, *args, **kwargs): pass
+    def frobnicate(self, x: str, *args, **kwargs): pass
 [file b.py]
 from a import Foo
 class Bar(Foo):
@@ -3212,21 +3199,21 @@ class Bar(Foo):
 [file b.py.2]
 from a import Foo
 class Bar(Foo):
-    def frobnicate(self, *args) -> None: pass
+    def frobnicate(self, *args: int) -> None: pass
 [file b.py.3]
 from a import Foo
 class Bar(Foo):
-    def frobnicate(self, *args) -> None: pass # type: ignore[override] # I know
+    def frobnicate(self, *args: int) -> None: pass # type: ignore[override] # I know
 [builtins fixtures/dict.pyi]
 [out1]
 tmp/b.py:3: error: Signature of "frobnicate" incompatible with supertype "Foo"
 tmp/b.py:3: note:      Superclass:
-tmp/b.py:3: note:          def frobnicate(self, x: Any, *args: Any, **kwargs: Any) -> Any
+tmp/b.py:3: note:          def frobnicate(self, x: str, *args: Any, **kwargs: Any) -> Any
 tmp/b.py:3: note:      Subclass:
 tmp/b.py:3: note:          def frobnicate(self) -> None
 [out2]
 tmp/b.py:3: error: Signature of "frobnicate" incompatible with supertype "Foo"
 tmp/b.py:3: note:      Superclass:
-tmp/b.py:3: note:          def frobnicate(self, x: Any, *args: Any, **kwargs: Any) -> Any
+tmp/b.py:3: note:          def frobnicate(self, x: str, *args: Any, **kwargs: Any) -> Any
 tmp/b.py:3: note:      Subclass:
-tmp/b.py:3: note:          def frobnicate(self, *args: Any) -> None
+tmp/b.py:3: note:          def frobnicate(self, *args: int) -> None
diff --git a/test-data/unit/check-multiple-inheritance.test b/test-data/unit/check-multiple-inheritance.test
index d03f2e35e1c4..9cb3bd2e7ca2 100644
--- a/test-data/unit/check-multiple-inheritance.test
+++ b/test-data/unit/check-multiple-inheritance.test
@@ -706,3 +706,29 @@ class C34(B3, B4): ...
 class C41(B4, B1): ...
 class C42(B4, B2): ...
 class C43(B4, B3): ...
+
+[case testMultipleInheritanceExplicitDiamondResolution]
+# Adapted from #14279
+class A:
+    class M:
+        pass
+
+class B0(A):
+    class M(A.M):
+        pass
+
+class B1(A):
+    class M(A.M):
+        pass
+
+class C(B0,B1):
+    class M(B0.M, B1.M):
+        pass
+
+class D0(B0):
+    pass
+class D1(B1):
+    pass
+
+class D(D0,D1,C):
+    pass
diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test
index 6b9f139f541c..13f977a1e463 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]
@@ -22,34 +22,26 @@ a, b, c = x # E: Need more than 2 values to unpack (3 expected)
 x[2] # E: Tuple index out of range
 [builtins fixtures/tuple.pyi]
 
-[case testNamedTupleNoUnderscoreFields]
+[case testNamedTupleInvalidFields]
 from collections import namedtuple
 
-X = namedtuple('X', 'x, _y, _z')  # E: "namedtuple()" field names cannot start with an underscore: _y, _z
+X = namedtuple('X', 'x, _y')  # E: "namedtuple()" field name "_y" starts with an underscore
+Y = namedtuple('Y', ['x', '1'])  # E: "namedtuple()" field name "1" is not a valid identifier
+Z = namedtuple('Z', ['x', 'def'])  # E: "namedtuple()" field name "def" is a keyword
+A = namedtuple('A', ['x', 'x'])  # E: "namedtuple()" has duplicate field name "x"
 [builtins fixtures/tuple.pyi]
 
 [case testNamedTupleAccessingAttributes]
 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"
 [builtins fixtures/tuple.pyi]
 
-[case testNamedTupleClassPython35]
-# flags: --python-version 3.5
-from typing import NamedTuple
-
-class A(NamedTuple):
-    x = 3  # type: int
-[builtins fixtures/tuple.pyi]
-[out]
-main:4: error: NamedTuple class syntax is only supported in Python 3.6
-
-[case testNamedTupleClassInStubPython35]
-# flags: --python-version 3.5
+[case testNamedTupleClassInStub]
 import foo
 
 [file foo.pyi]
@@ -63,13 +55,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
@@ -77,8 +69,7 @@ a.y = 5 # E: Property "y" defined in "X" is read-only
 
 
 [case testTypingNamedTupleAttributesAreReadOnly]
-from typing import NamedTuple
-from typing_extensions import Protocol
+from typing import NamedTuple, Protocol
 
 class HasX(Protocol):
     x: str
@@ -90,8 +81,8 @@ a: HasX = A("foo")
 a.x = "bar"
 [builtins fixtures/tuple.pyi]
 [out]
-main:10: error: Incompatible types in assignment (expression has type "A", variable has type "HasX")
-main:10: note: Protocol member HasX.x expected settable variable, got read-only attribute
+main:9: error: Incompatible types in assignment (expression has type "A", variable has type "HasX")
+main:9: note: Protocol member HasX.x expected settable variable, got read-only attribute
 
 
 [case testNamedTupleCreateWithPositionalArguments]
@@ -136,13 +127,14 @@ E = namedtuple('E', 'a b', 0)
 [builtins fixtures/bool.pyi]
 
 [out]
+main:4: error: Boolean literal expected as the "rename" argument to namedtuple()
+main:5: error: Boolean literal expected as the "rename" argument to namedtuple()
 main:5: error: Argument "rename" to "namedtuple" has incompatible type "str"; expected "int"
 main:6: error: Unexpected keyword argument "unrecognized_arg" for "namedtuple"
 <ROOT>/test-data/unit/lib-stub/collections.pyi:3: note: "namedtuple" defined here
 main:7: error: Too many positional arguments for "namedtuple"
 
 [case testNamedTupleDefaults]
-# flags: --python-version 3.7
 from collections import namedtuple
 
 X = namedtuple('X', ['x', 'y'], defaults=(1,))
@@ -157,6 +149,23 @@ Z = namedtuple('Z', ['x', 'y'], defaults='not a tuple')  # E: List or tuple lite
 
 [builtins fixtures/list.pyi]
 
+[case testNamedTupleRename]
+from collections import namedtuple
+
+X = namedtuple('X', ['abc', 'def'], rename=False)  # E: "namedtuple()" field name "def" is a keyword
+Y = namedtuple('Y', ['x', 'x', 'def', '42', '_x'], rename=True)
+y = Y(x=0, _1=1, _2=2, _3=3, _4=4)
+reveal_type(y.x)  # N: Revealed type is "Any"
+reveal_type(y._1)  # N: Revealed type is "Any"
+reveal_type(y._2)  # N: Revealed type is "Any"
+reveal_type(y._3)  # N: Revealed type is "Any"
+reveal_type(y._4)  # N: Revealed type is "Any"
+y._0  # E: "Y" has no attribute "_0"
+y._5  # E: "Y" has no attribute "_5"
+y._x  # E: "Y" has no attribute "_x"
+
+[builtins fixtures/list.pyi]
+
 [case testNamedTupleWithItemTypes]
 from typing import NamedTuple
 N = NamedTuple('N', [('a', int),
@@ -292,7 +301,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 +366,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 +375,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 +400,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 +414,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 +432,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 +468,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 +481,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 +491,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 +508,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 +520,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]
 
@@ -539,7 +548,7 @@ b = B._make([''])  # type: B
 [case testNamedTupleIncompatibleRedefinition]
 from typing import NamedTuple
 class Crash(NamedTuple):
-    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[int, ...], object], int]")
+    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[object], int]")
 [builtins fixtures/tuple.pyi]
 
 [case testNamedTupleInClassNamespace]
@@ -618,16 +627,18 @@ tmp/b.py:4: note: Revealed type is "Tuple[Any, fallback=a.N]"
 tmp/b.py:7: note: Revealed type is "Tuple[Any, fallback=a.N]"
 
 [case testSimpleSelfReferentialNamedTuple]
-# flags: --disable-recursive-aliases
 from typing import NamedTuple
-class MyNamedTuple(NamedTuple):
-    parent: 'MyNamedTuple' # E: Cannot resolve name "MyNamedTuple" (possible cyclic definition)
 
-def bar(nt: MyNamedTuple) -> MyNamedTuple:
-    return nt
+def test() -> None:
+    class MyNamedTuple(NamedTuple):
+        parent: 'MyNamedTuple'  # E: Cannot resolve name "MyNamedTuple" (possible cyclic definition) \
+                                # N: Recursive types are not allowed at function scope
 
-x: MyNamedTuple
-reveal_type(x.parent) # N: Revealed type is "Any"
+    def bar(nt: MyNamedTuple) -> MyNamedTuple:
+        return nt
+
+    x: MyNamedTuple
+    reveal_type(x.parent) # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]
 
 -- Some crazy self-referential named tuples and types dicts
@@ -656,106 +667,111 @@ class B:
 [out]
 
 [case testSelfRefNT1]
-# flags: --disable-recursive-aliases
 from typing import Tuple, NamedTuple
 
-Node = NamedTuple('Node', [
-        ('name', str),
-        ('children', Tuple['Node', ...]), # E: Cannot resolve name "Node" (possible cyclic definition)
-    ])
-n: Node
-reveal_type(n) # N: Revealed type is "Tuple[builtins.str, builtins.tuple[Any, ...], fallback=__main__.Node]"
+def test() -> None:
+    Node = NamedTuple('Node', [
+            ('name', str),
+            ('children', Tuple['Node', ...]),  # E: Cannot resolve name "Node" (possible cyclic definition) \
+                                               # N: Recursive types are not allowed at function scope
+        ])
+    n: Node
+    reveal_type(n) # N: Revealed type is "Tuple[builtins.str, builtins.tuple[Any, ...], fallback=__main__.Node@4]"
 [builtins fixtures/tuple.pyi]
 
 [case testSelfRefNT2]
-# flags: --disable-recursive-aliases
 from typing import Tuple, NamedTuple
 
-A = NamedTuple('A', [
-        ('x', str),
-        ('y', Tuple['B', ...]), # E: Cannot resolve name "B" (possible cyclic definition)
-    ])
-class B(NamedTuple):
-    x: A
-    y: int
+def test() -> None:
+    A = NamedTuple('A', [
+            ('x', str),
+            ('y', Tuple['B', ...]),  # E: Cannot resolve name "B" (possible cyclic definition) \
+                                     # N: Recursive types are not allowed at function scope
+        ])
+    class B(NamedTuple):
+        x: A
+        y: int
 
-n: A
-reveal_type(n) # N: Revealed type is "Tuple[builtins.str, builtins.tuple[Any, ...], fallback=__main__.A]"
+    n: A
+    reveal_type(n) # N: Revealed type is "Tuple[builtins.str, builtins.tuple[Any, ...], fallback=__main__.A@4]"
 [builtins fixtures/tuple.pyi]
 
 [case testSelfRefNT3]
-# flags: --disable-recursive-aliases
 from typing import NamedTuple, Tuple
 
-class B(NamedTuple):
-    x: Tuple[A, int] # E: Cannot resolve name "A" (possible cyclic definition)
-    y: int
+def test() -> None:
+    class B(NamedTuple):
+        x: Tuple[A, int]  # E: Cannot resolve name "A" (possible cyclic definition) \
+                          # N: Recursive types are not allowed at function scope
+        y: int
 
-A = NamedTuple('A', [
-        ('x', str),
-        ('y', 'B'),
-    ])
-n: B
-m: A
-reveal_type(n.x) # N: Revealed type is "Tuple[Any, builtins.int]"
-reveal_type(m[0]) # N: Revealed type is "builtins.str"
-lst = [m, n]
-reveal_type(lst[0]) # N: Revealed type is "Tuple[builtins.object, builtins.object]"
+    A = NamedTuple('A', [
+            ('x', str),
+            ('y', 'B'),
+        ])
+    n: B
+    m: A
+    reveal_type(n.x) # N: Revealed type is "Tuple[Any, builtins.int]"
+    reveal_type(m[0]) # N: Revealed type is "builtins.str"
+    lst = [m, n]
+    reveal_type(lst[0]) # N: Revealed type is "Tuple[builtins.object, builtins.object]"
 [builtins fixtures/tuple.pyi]
 
 [case testSelfRefNT4]
-# flags: --disable-recursive-aliases
 from typing import NamedTuple
 
-class B(NamedTuple):
-    x: A # E: Cannot resolve name "A" (possible cyclic definition)
-    y: int
+def test() -> None:
+    class B(NamedTuple):
+        x: A  # E: Cannot resolve name "A" (possible cyclic definition) \
+              # N: Recursive types are not allowed at function scope
+        y: int
 
-class A(NamedTuple):
-    x: str
-    y: B
+    class A(NamedTuple):
+        x: str
+        y: B
 
-n: A
-reveal_type(n.y[0]) # N: Revealed type is "Any"
+    n: A
+    reveal_type(n.y[0]) # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]
 
 [case testSelfRefNT5]
-# flags: --disable-recursive-aliases
 from typing import NamedTuple
 
-B = NamedTuple('B', [
-        ('x', A), # E: Cannot resolve name "A" (possible cyclic definition)  # E: Name "A" is used before definition
-        ('y', int),
-    ])
-A = NamedTuple('A', [
-        ('x', str),
-        ('y', 'B'),
-    ])
-n: A
-def f(m: B) -> None: pass
-reveal_type(n) # N: Revealed type is "Tuple[builtins.str, Tuple[Any, builtins.int, fallback=__main__.B], fallback=__main__.A]"
-reveal_type(f) # N: Revealed type is "def (m: Tuple[Any, builtins.int, fallback=__main__.B])"
+def test() -> None:
+    B = NamedTuple('B', [
+            ('x', A),  # E: Cannot resolve name "A" (possible cyclic definition)  \
+                       # N: Recursive types are not allowed at function scope \
+                       # E: Name "A" is used before definition
+            ('y', int),
+        ])
+    A = NamedTuple('A', [
+            ('x', str),
+            ('y', 'B'),
+        ])
+    n: A
+    def f(m: B) -> None: pass
+    reveal_type(n) # N: Revealed type is "Tuple[builtins.str, Tuple[Any, builtins.int, fallback=__main__.B@4], fallback=__main__.A@8]"
+    reveal_type(f) # N: Revealed type is "def (m: Tuple[Any, builtins.int, fallback=__main__.B@4])"
 [builtins fixtures/tuple.pyi]
 
 [case testRecursiveNamedTupleInBases]
-# flags: --disable-recursive-aliases
 from typing import List, NamedTuple, Union
 
-Exp = Union['A', 'B']  # E: Cannot resolve name "Exp" (possible cyclic definition) \
-                       # E: Cannot resolve name "A" (possible cyclic definition)
-class A(NamedTuple('A', [('attr', List[Exp])])): pass
-class B(NamedTuple('B', [('val', object)])): pass
+def test() -> None:
+    Exp = Union['A', 'B']  # E: Cannot resolve name "Exp" (possible cyclic definition) \
+                           # N: Recursive types are not allowed at function scope \
+                           # E: Cannot resolve name "A" (possible cyclic definition)
+    class A(NamedTuple('A', [('attr', List[Exp])])): pass
+    class B(NamedTuple('B', [('val', object)])): pass
 
-def my_eval(exp: Exp) -> int:
-    reveal_type(exp) # N: Revealed type is "Union[Any, Tuple[builtins.object, fallback=__main__.B]]"
+    exp: Exp
+    reveal_type(exp)  # N: Revealed type is "Union[Any, Tuple[builtins.object, fallback=__main__.B@6]]"
     if isinstance(exp, A):
-        my_eval(exp[0][0])
-        return my_eval(exp.attr[0])
+        reveal_type(exp[0][0])  # N: Revealed type is "Union[Any, Tuple[builtins.object, fallback=__main__.B@6]]"
+        reveal_type(exp.attr[0])  # N: Revealed type is "Union[Any, Tuple[builtins.object, fallback=__main__.B@6]]"
     if isinstance(exp, B):
-        return exp.val  # E: Incompatible return value type (got "object", expected "int")
-    return 0
-
-my_eval(A([B(1), B(2)])) # OK
+        reveal_type(exp.val)  # N: Revealed type is "builtins.object"
+    reveal_type(A([B(1), B(2)]))  # N: Revealed type is "Tuple[builtins.list[Union[Any, Tuple[builtins.object, fallback=__main__.B@6]]], fallback=__main__.A@5]"
 [builtins fixtures/isinstancelist.pyi]
 [out]
 
@@ -782,17 +798,18 @@ tp = NamedTuple('tp', [('x', int)])
 [out]
 
 [case testSubclassOfRecursiveNamedTuple]
-# flags: --disable-recursive-aliases
 from typing import List, NamedTuple
 
-class Command(NamedTuple):
-    subcommands: List['Command'] # E: Cannot resolve name "Command" (possible cyclic definition)
+def test() -> None:
+    class Command(NamedTuple):
+        subcommands: List['Command']  # E: Cannot resolve name "Command" (possible cyclic definition) \
+                                      # N: Recursive types are not allowed at function scope
 
-class HelpCommand(Command):
-    pass
+    class HelpCommand(Command):
+        pass
 
-hc = HelpCommand(subcommands=[])
-reveal_type(hc)  # N: Revealed type is "Tuple[builtins.list[Any], fallback=__main__.HelpCommand]"
+    hc = HelpCommand(subcommands=[])
+    reveal_type(hc)  # N: Revealed type is "Tuple[builtins.list[Any], fallback=__main__.HelpCommand@7]"
 [builtins fixtures/list.pyi]
 [out]
 
@@ -889,7 +906,7 @@ reveal_type(Child.class_method())  # N: Revealed type is "Tuple[builtins.str, fa
 [builtins fixtures/classmethod.pyi]
 
 [case testNamedTupleAsConditionalStrictOptionalDisabled]
-# flags: --no-strict-optional
+# flags: --no-strict-optional --warn-unreachable
 from typing import NamedTuple
 
 class C(NamedTuple):
@@ -938,7 +955,18 @@ 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 testEmptyNamedTupleTypeRepr]
+from typing import NamedTuple
+
+N = NamedTuple('N', [])
+n: N
+reveal_type(N)  # N: Revealed type is "def () -> Tuple[(), fallback=__main__.N]"
+reveal_type(n)  # N: Revealed type is "Tuple[(), fallback=__main__.N]"
 [builtins fixtures/tuple.pyi]
 
 [case testNamedTupleWrongfile]
@@ -983,7 +1011,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
@@ -1046,7 +1074,7 @@ def good6() -> NamedTuple:
 def bad1() -> NamedTuple:
     return 1  # E: Incompatible return value type (got "int", expected "NamedTuple")
 def bad2() -> NamedTuple:
-    return ()  # E: Incompatible return value type (got "Tuple[]", expected "NamedTuple")
+    return ()  # E: Incompatible return value type (got "Tuple[()]", expected "NamedTuple")
 def bad3() -> NamedTuple:
     return (1, 2)  # E: Incompatible return value type (got "Tuple[int, int]", expected "NamedTuple")
 
@@ -1214,7 +1242,7 @@ nti: NT[int]
 reveal_type(nti * x)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 
 nts: NT[str]
-reveal_type(nts * x)  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
+reveal_type(nts * x)  # N: Revealed type is "builtins.tuple[Union[builtins.int, builtins.str], ...]"
 [builtins fixtures/tuple.pyi]
 [typing fixtures/typing-namedtuple.pyi]
 
@@ -1275,9 +1303,9 @@ reveal_type(foo(nti, nts))  # N: Revealed type is "Tuple[builtins.int, builtins.
 reveal_type(foo(nts, nti))  # N: Revealed type is "Tuple[builtins.int, builtins.object, fallback=__main__.NT[builtins.object]]"
 
 reveal_type(foo(nti, x))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
-reveal_type(foo(nts, x))  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
+reveal_type(foo(nts, x))  # N: Revealed type is "builtins.tuple[Union[builtins.int, builtins.str], ...]"
 reveal_type(foo(x, nti))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
-reveal_type(foo(x, nts))  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
+reveal_type(foo(x, nts))  # N: Revealed type is "builtins.tuple[Union[builtins.int, builtins.str], ...]"
 [builtins fixtures/tuple.pyi]
 [typing fixtures/typing-namedtuple.pyi]
 
@@ -1337,3 +1365,168 @@ 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]
+
+[case testNoClassKeywordsForNamedTuple]
+from typing import NamedTuple
+class Test1(NamedTuple, x=1, y=2):  # E: Unexpected keyword argument "x" for "__init_subclass__" of "NamedTuple" \
+                                    # E: Unexpected keyword argument "y" for "__init_subclass__" of "NamedTuple"
+    ...
+
+class Meta(type): ...
+
+class Test2(NamedTuple, metaclass=Meta):  # E: Unexpected keyword argument "metaclass" for "__init_subclass__" of "NamedTuple"
+    ...
+
+# Technically this would work, but it is just easier for the implementation:
+class Test3(NamedTuple, metaclass=type):  # E: Unexpected keyword argument "metaclass" for "__init_subclass__" of "NamedTuple"
+    ...
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
+
+
+[case testNamedTupleDunderReplace]
+# flags: --python-version 3.13
+from typing import NamedTuple
+
+class A(NamedTuple):
+    x: int
+
+A(x=0).__replace__(x=1)
+A(x=0).__replace__(x="asdf")  # E: Argument "x" to "__replace__" of "A" has incompatible type "str"; expected "int"
+A(x=0).__replace__(y=1)  # E: Unexpected keyword argument "y" for "__replace__" of "A"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
+
+[case testUnpackSelfNamedTuple]
+import typing
+
+class Foo(typing.NamedTuple):
+    bar: int
+    def baz(self: typing.Self) -> None:
+        x, = self
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
+
+[case testNameErrorInNamedTupleNestedInFunction1]
+from typing import NamedTuple
+
+def bar() -> None:
+    class MyNamedTuple(NamedTuple):
+        a: int
+        def foo(self) -> None:
+            ...
+    int_set: Set[int]  # E: Name "Set" is not defined \
+                       # N: Did you forget to import it from "typing"? (Suggestion: "from typing import Set")
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
+
+[case testNameErrorInNamedTupleNestedInFunction2]
+from typing import NamedTuple
+
+def bar() -> None:
+    class MyNamedTuple(NamedTuple):
+        a: int
+        def foo(self) -> None:
+            misspelled_var_name  # E: Name "misspelled_var_name" is not defined
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
+
+
+[case testNamedTupleFinalAndClassVar]
+from typing import NamedTuple, Final, ClassVar
+
+class My(NamedTuple):
+    a: Final      # E: Final[...] can't be used inside a NamedTuple
+    b: Final[int] # E: Final[...] can't be used inside a NamedTuple
+    c: ClassVar       # E: ClassVar[...] can't be used inside a NamedTuple
+    d: ClassVar[int]  # E: ClassVar[...] can't be used inside a NamedTuple
+
+Func = NamedTuple('Func', [
+    ('a', Final),         # E: Final[...] can't be used inside a NamedTuple
+    ('b', Final[int]),    # E: Final[...] can't be used inside a NamedTuple
+    ('c', ClassVar),      # E: ClassVar[...] can't be used inside a NamedTuple
+    ('d', ClassVar[int]), # E: ClassVar[...] can't be used inside a NamedTuple
+])
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
+
+[case testGenericNamedTupleRecursiveBound]
+from typing import Generic, NamedTuple, TypeVar
+T = TypeVar("T", bound="NT")
+class NT(NamedTuple, Generic[T]):
+    parent: T
+    item: int
+
+def main(n: NT[T]) -> None:
+    reveal_type(n.parent)  # N: Revealed type is "T`-1"
+    reveal_type(n.item)  # N: Revealed type is "builtins.int"
+
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
+
+[case testNamedTupleOverlappingCheck]
+from typing import overload, NamedTuple, Union
+
+class AKey(NamedTuple):
+    k: str
+
+class A(NamedTuple):
+    key: AKey
+
+
+class BKey(NamedTuple):
+    k: str
+
+class B(NamedTuple):
+    key: BKey
+
+@overload
+def f(arg: A) -> A: ...
+@overload
+def f(arg: B) -> B: ...
+def f(arg: Union[A, B]) -> Union[A, B]: ...
+
+def g(x: Union[A, B, str]) -> Union[A, B, str]:
+    if isinstance(x, str):
+        return x
+    else:
+        reveal_type(x)  # N: Revealed type is "Union[Tuple[Tuple[builtins.str, fallback=__main__.AKey], fallback=__main__.A], Tuple[Tuple[builtins.str, fallback=__main__.BKey], fallback=__main__.B]]"
+        return x._replace()
+
+# no errors should be raised above.
+[builtins fixtures/tuple.pyi]
+
+[case testNamedTupleUnionAnyMethodCall]
+from collections import namedtuple
+from typing import Any, Union
+
+T = namedtuple("T", ["x"])
+
+class C(T):
+    def f(self) -> bool:
+        return True
+
+c: Union[C, Any]
+reveal_type(c.f())  # N: Revealed type is "Union[builtins.bool, Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testNamedTupleAsClassMemberNoCrash]
+# https://github.com/python/mypy/issues/18736
+from collections import namedtuple
+
+class Base:
+    def __init__(self, namespace: tuple[str, ...]) -> None:
+        # Not a bug: trigger defer
+        names = [name for name in namespace if fail]  # E: Name "fail" is not defined
+        self.n = namedtuple("n", names)  # E: NamedTuple type as an attribute is not supported
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-narrowing.test b/test-data/unit/check-narrowing.test
index c329ccf840a8..dc2cfd46d9ad 100644
--- a/test-data/unit/check-narrowing.test
+++ b/test-data/unit/check-narrowing.test
@@ -1,8 +1,6 @@
 [case testNarrowingParentWithStrsBasic]
-# flags: --python-version 3.7
 from dataclasses import dataclass
-from typing import NamedTuple, Tuple, Union
-from typing_extensions import Literal, TypedDict
+from typing import Literal, NamedTuple, Tuple, TypedDict, Union
 
 class Object1:
     key: Literal["A"]
@@ -81,13 +79,12 @@ if x5["key"] == "A":
 else:
     reveal_type(x5)         # N: Revealed type is "TypedDict('__main__.TypedDict2', {'key': Literal['B'], 'foo': builtins.str})"
 [builtins fixtures/primitives.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingParentWithEnumsBasic]
-# flags: --python-version 3.7
 from enum import Enum
 from dataclasses import dataclass
-from typing import NamedTuple, Tuple, Union
-from typing_extensions import Literal, TypedDict
+from typing import Literal, NamedTuple, Tuple, TypedDict, Union
 
 class Key(Enum):
     A = 1
@@ -170,13 +167,12 @@ if x5["key"] is Key.A:
     reveal_type(x5)         # N: Revealed type is "TypedDict('__main__.TypedDict1', {'key': Literal[__main__.Key.A], 'foo': builtins.int})"
 else:
     reveal_type(x5)         # N: Revealed type is "TypedDict('__main__.TypedDict2', {'key': Literal[__main__.Key.B], 'foo': builtins.str})"
-[builtins fixtures/narrowing.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingParentWithIsInstanceBasic]
-# flags: --python-version 3.7
 from dataclasses import dataclass
-from typing import NamedTuple, Tuple, Union
-from typing_extensions import TypedDict
+from typing import NamedTuple, Tuple, TypedDict, Union
 
 class Object1:
     key: int
@@ -236,13 +232,13 @@ if isinstance(x5["key"], int):
     reveal_type(x5)         # N: Revealed type is "TypedDict('__main__.TypedDict1', {'key': builtins.int})"
 else:
     reveal_type(x5)         # N: Revealed type is "TypedDict('__main__.TypedDict2', {'key': builtins.str})"
-[builtins fixtures/narrowing.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingParentMultipleKeys]
 # flags: --warn-unreachable
 from enum import Enum
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 class Key(Enum):
     A = 1
@@ -274,8 +270,7 @@ else:
 
 [case testNarrowingTypedDictParentMultipleKeys]
 # flags: --warn-unreachable
-from typing import Union
-from typing_extensions import Literal, TypedDict
+from typing import Literal, TypedDict, Union
 
 class TypedDict1(TypedDict):
     key: Literal['A', 'C']
@@ -298,11 +293,11 @@ if x['key'] == 'D':
 else:
     reveal_type(x)  # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key': Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key': Union[Literal['B'], Literal['C']]})]"
 [builtins fixtures/primitives.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingPartialTypedDictParentMultipleKeys]
 # flags: --warn-unreachable
-from typing import Union
-from typing_extensions import Literal, TypedDict
+from typing import Literal, TypedDict, Union
 
 class TypedDict1(TypedDict, total=False):
     key: Literal['A', 'C']
@@ -325,10 +320,10 @@ if x['key'] == 'D':
 else:
     reveal_type(x)  # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key'?: Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key'?: Union[Literal['B'], Literal['C']]})]"
 [builtins fixtures/primitives.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingNestedTypedDicts]
-from typing import Union
-from typing_extensions import TypedDict, Literal
+from typing import Literal, TypedDict, Union
 
 class A(TypedDict):
     key: Literal['A']
@@ -353,11 +348,11 @@ if unknown['inner']['key'] == 'C':
     reveal_type(unknown)            # N: Revealed type is "TypedDict('__main__.Y', {'inner': Union[TypedDict('__main__.B', {'key': Literal['B']}), TypedDict('__main__.C', {'key': Literal['C']})]})"
     reveal_type(unknown['inner'])   # N: Revealed type is "TypedDict('__main__.C', {'key': Literal['C']})"
 [builtins fixtures/primitives.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingParentWithMultipleParents]
 from enum import Enum
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 class Key(Enum):
     A = 1
@@ -401,8 +396,7 @@ else:
 
 [case testNarrowingParentWithParentMixtures]
 from enum import Enum
-from typing import Union, NamedTuple
-from typing_extensions import Literal, TypedDict
+from typing import Literal, Union, NamedTuple, TypedDict
 
 class Key(Enum):
     A = 1
@@ -451,8 +445,7 @@ else:
 
 [case testNarrowingParentWithProperties]
 from enum import Enum
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 class Key(Enum):
     A = 1
@@ -479,8 +472,7 @@ else:
 
 [case testNarrowingParentWithAny]
 from enum import Enum
-from typing import Union, Any
-from typing_extensions import Literal
+from typing import Literal, Union, Any
 
 class Key(Enum):
     A = 1
@@ -504,8 +496,7 @@ else:
 [builtins fixtures/tuple.pyi]
 
 [case testNarrowingParentsHierarchy]
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 from enum import Enum
 
 class Key(Enum):
@@ -583,8 +574,7 @@ else:
 
 [case testNarrowingParentsHierarchyTypedDict]
 # flags: --warn-unreachable
-from typing import Union
-from typing_extensions import TypedDict, Literal
+from typing import Literal, TypedDict, Union
 from enum import Enum
 
 class Key(Enum):
@@ -621,12 +611,12 @@ if y["model"]["key"] is Key.C:
 else:
     reveal_type(y)              # N: Revealed type is "Union[TypedDict('__main__.Parent1', {'model': TypedDict('__main__.Model1', {'key': Literal[__main__.Key.A]}), 'foo': builtins.int}), TypedDict('__main__.Parent2', {'model': TypedDict('__main__.Model2', {'key': Literal[__main__.Key.B]}), 'bar': builtins.str})]"
     reveal_type(y["model"])     # N: Revealed type is "Union[TypedDict('__main__.Model1', {'key': Literal[__main__.Key.A]}), TypedDict('__main__.Model2', {'key': Literal[__main__.Key.B]})]"
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingParentsHierarchyTypedDictWithStr]
 # flags: --warn-unreachable
-from typing import Union
-from typing_extensions import TypedDict, Literal
+from typing import Literal, TypedDict, Union
 
 class Parent1(TypedDict):
     model: Model1
@@ -658,10 +648,10 @@ else:
     reveal_type(y)              # N: Revealed type is "Union[TypedDict('__main__.Parent1', {'model': TypedDict('__main__.Model1', {'key': Literal['A']}), 'foo': builtins.int}), TypedDict('__main__.Parent2', {'model': TypedDict('__main__.Model2', {'key': Literal['B']}), 'bar': builtins.str})]"
     reveal_type(y["model"])     # N: Revealed type is "Union[TypedDict('__main__.Model1', {'key': Literal['A']}), TypedDict('__main__.Model2', {'key': Literal['B']})]"
 [builtins fixtures/primitives.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingExprPropagation]
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 class A:
     tag: Literal['A']
@@ -682,7 +672,7 @@ if not (abo is None or abo.tag != "B"):
 
 [case testNarrowingEqualityFlipFlop]
 # flags: --warn-unreachable --strict-equality
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 from enum import Enum
 
 class State(Enum):
@@ -747,8 +737,7 @@ def test3(switch: FlipFlopEnum) -> None:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingEqualityRequiresExplicitStrLiteral]
-# flags: --strict-optional
-from typing_extensions import Literal, Final
+from typing import Final, Literal
 
 A_final: Final = "A"
 A_literal: Literal["A"]
@@ -794,9 +783,7 @@ reveal_type(x_union)      # N: Revealed type is "Union[Literal['A'], Literal['B'
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingEqualityRequiresExplicitEnumLiteral]
-# flags: --strict-optional
-from typing import Union
-from typing_extensions import Literal, Final
+from typing import Final, Literal, Union
 from enum import Enum
 
 class Foo(Enum):
@@ -837,8 +824,7 @@ def bar(x: Union[SingletonFoo, Foo], y: SingletonFoo) -> None:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingEqualityDisabledForCustomEquality]
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 from enum import Enum
 
 class Custom:
@@ -879,9 +865,8 @@ else:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingEqualityDisabledForCustomEqualityChain]
-# flags: --strict-optional --strict-equality --warn-unreachable
-from typing import Union
-from typing_extensions import Literal
+# flags: --strict-equality --warn-unreachable
+from typing import Literal, Union
 
 class Custom:
     def __eq__(self, other: object) -> bool: return True
@@ -916,9 +901,8 @@ else:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingUnreachableCases]
-# flags: --strict-optional --strict-equality --warn-unreachable
-from typing import Union
-from typing_extensions import Literal
+# flags: --strict-equality --warn-unreachable
+from typing import Literal, Union
 
 a: Literal[1]
 b: Literal[1, 2]
@@ -964,9 +948,8 @@ else:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingUnreachableCases2]
-# flags: --strict-optional --strict-equality --warn-unreachable
-from typing import Union
-from typing_extensions import Literal
+# flags: --strict-equality --warn-unreachable
+from typing import Literal, Union
 
 a: Literal[1, 2, 3, 4]
 b: Literal[1, 2, 3, 4]
@@ -1004,15 +987,14 @@ else:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingLiteralTruthiness]
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 
 str_or_false: Union[Literal[False], str]
 
 if str_or_false:
     reveal_type(str_or_false)   # N: Revealed type is "builtins.str"
 else:
-    reveal_type(str_or_false)   # N: Revealed type is "Union[Literal[False], builtins.str]"
+    reveal_type(str_or_false)   # N: Revealed type is "Union[Literal[False], Literal['']]"
 
 true_or_false: Literal[True, False]
 
@@ -1022,9 +1004,123 @@ else:
     reveal_type(true_or_false)  # N: Revealed type is "Literal[False]"
 [builtins fixtures/primitives.pyi]
 
-[case testNarrowingLiteralIdentityCheck]
+[case testNarrowingFalseyToLiteral]
 from typing import Union
-from typing_extensions import Literal
+
+a: str
+b: bytes
+c: int
+d: Union[str, bytes, int]
+
+if not a:
+    reveal_type(a)  # N: Revealed type is "Literal['']"
+if not b:
+    reveal_type(b)  # N: Revealed type is "Literal[b'']"
+if not c:
+    reveal_type(c)  # N: Revealed type is "Literal[0]"
+if not d:
+    reveal_type(d)  # N: Revealed type is "Union[Literal[''], Literal[b''], Literal[0]]"
+
+[case testNarrowingIsInstanceFinalSubclass]
+# flags: --warn-unreachable
+
+from typing import final
+
+class N: ...
+@final
+class F1: ...
+@final
+class F2: ...
+
+n: N
+f1: F1
+
+if isinstance(f1, F1):
+    reveal_type(f1)  # N: Revealed type is "__main__.F1"
+else:
+    reveal_type(f1)  # E: Statement is unreachable
+
+if isinstance(n, F1):  # E: Subclass of "N" and "F1" cannot exist: "F1" is final
+    reveal_type(n)  # E: Statement is unreachable
+else:
+    reveal_type(n)  # N: Revealed type is "__main__.N"
+
+if isinstance(f1, N):  # E: Subclass of "F1" and "N" cannot exist: "F1" is final
+    reveal_type(f1)  # E: Statement is unreachable
+else:
+    reveal_type(f1)  # N: Revealed type is "__main__.F1"
+
+if isinstance(f1, F2):  # E: Subclass of "F1" and "F2" cannot exist: "F1" is final \
+                        # E: Subclass of "F1" and "F2" cannot exist: "F2" is final
+    reveal_type(f1)  # E: Statement is unreachable
+else:
+    reveal_type(f1)  # N: Revealed type is "__main__.F1"
+[builtins fixtures/isinstance.pyi]
+
+
+[case testNarrowingIsInstanceFinalSubclassWithUnions]
+# flags: --warn-unreachable
+
+from typing import final, Union
+
+class N: ...
+@final
+class F1: ...
+@final
+class F2: ...
+
+n_f1: Union[N, F1]
+n_f2: Union[N, F2]
+f1_f2: Union[F1, F2]
+
+if isinstance(n_f1, F1):
+    reveal_type(n_f1)  # N: Revealed type is "__main__.F1"
+else:
+    reveal_type(n_f1)  # N: Revealed type is "__main__.N"
+
+if isinstance(n_f2, F1):  # E: Subclass of "N" and "F1" cannot exist: "F1" is final \
+                          # E: Subclass of "F2" and "F1" cannot exist: "F2" is final \
+                          # E: Subclass of "F2" and "F1" cannot exist: "F1" is final
+    reveal_type(n_f2)  # E: Statement is unreachable
+else:
+    reveal_type(n_f2)  # N: Revealed type is "Union[__main__.N, __main__.F2]"
+
+if isinstance(f1_f2, F1):
+    reveal_type(f1_f2)  # N: Revealed type is "__main__.F1"
+else:
+    reveal_type(f1_f2)  # N: Revealed type is "__main__.F2"
+[builtins fixtures/isinstance.pyi]
+
+
+[case testNarrowingIsSubclassFinalSubclassWithTypeVar]
+# flags: --warn-unreachable
+
+from typing import final, Type, TypeVar
+
+@final
+class A: ...
+@final
+class B: ...
+
+T = TypeVar("T", A, B)
+
+def f(cls: Type[T]) -> T:
+    if issubclass(cls, A):
+        reveal_type(cls)  # N: Revealed type is "Type[__main__.A]"
+        x: bool
+        if x:
+            return A()
+        else:
+            return B()  # E: Incompatible return value type (got "B", expected "A")
+    assert False
+
+reveal_type(f(A))  # N: Revealed type is "__main__.A"
+reveal_type(f(B))  # N: Revealed type is "__main__.B"
+[builtins fixtures/isinstance.pyi]
+
+
+[case testNarrowingLiteralIdentityCheck]
+from typing import Literal, Union
 
 str_or_false: Union[Literal[False], str]
 
@@ -1064,9 +1160,7 @@ else:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingBooleanIdentityCheck]
-# flags: --strict-optional
-from typing import Optional
-from typing_extensions import Literal
+from typing import Literal, Optional
 
 bool_val: bool
 
@@ -1087,9 +1181,7 @@ else:
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingBooleanTruthiness]
-# flags: --strict-optional
-from typing import Optional
-from typing_extensions import Literal
+from typing import Literal, Optional
 
 bool_val: bool
 
@@ -1109,9 +1201,7 @@ reveal_type(opt_bool_val)   # N: Revealed type is "Union[builtins.bool, None]"
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingBooleanBoolOp]
-# flags: --strict-optional
-from typing import Optional
-from typing_extensions import Literal
+from typing import Literal, Optional
 
 bool_a: bool
 bool_b: bool
@@ -1138,9 +1228,7 @@ reveal_type(x) # N: Revealed type is "builtins.bool"
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingTypedDictUsingEnumLiteral]
-# flags: --python-version 3.6
-from typing import Union
-from typing_extensions import TypedDict, Literal
+from typing import Literal, TypedDict, Union
 from enum import Enum
 
 class E(Enum):
@@ -1160,9 +1248,9 @@ def f(d: Union[Foo, Bar]) -> None:
     d['x']
     reveal_type(d)  # N: Revealed type is "TypedDict('__main__.Foo', {'tag': Literal[__main__.E.FOO], 'x': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingUsingMetaclass]
-# flags: --strict-optional
 from typing import Type
 
 class M(type):
@@ -1182,7 +1270,6 @@ def f(t: Type[C]) -> None:
     reveal_type(t)  # N: Revealed type is "Type[__main__.C]"
 
 [case testNarrowingUsingTypeVar]
-# flags: --strict-optional
 from typing import Type, TypeVar
 
 class A: pass
@@ -1197,13 +1284,12 @@ def f(t: Type[T], a: A, b: B) -> None:
         reveal_type(a)  # N: Revealed type is "__main__.A"
 
     if type(b) is t:
-        reveal_type(b)  # N: Revealed type is "<nothing>"
+        reveal_type(b)  # N: Revealed type is "T`-1"
     else:
         reveal_type(b)  # N: Revealed type is "__main__.B"
 
 [case testNarrowingNestedUnionOfTypedDicts]
-from typing import Union
-from typing_extensions import Literal, TypedDict
+from typing import Literal, TypedDict, Union
 
 class A(TypedDict):
     tag: Literal["A"]
@@ -1227,9 +1313,8 @@ elif abc["tag"] == "C":
     reveal_type(abc) # N: Revealed type is "TypedDict('__main__.C', {'tag': Literal['C'], 'c': builtins.int})"
 else:
     reveal_type(abc) # N: Revealed type is "TypedDict('__main__.B', {'tag': Literal['B'], 'b': builtins.int})"
-
 [builtins fixtures/primitives.pyi]
-
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNarrowingRuntimeCover]
 from typing import Dict, List, Union
@@ -1269,3 +1354,1073 @@ def g() -> None:
         def foo(): ...
     foo()
 [builtins fixtures/dict.pyi]
+
+
+[case testNarrowingOptionalEqualsNone]
+from typing import Optional
+
+class A: ...
+
+val: Optional[A]
+
+if val == None:
+    reveal_type(val)  # N: Revealed type is "Union[__main__.A, None]"
+else:
+    reveal_type(val)  # N: Revealed type is "__main__.A"
+if val != None:
+    reveal_type(val)  # N: Revealed type is "__main__.A"
+else:
+    reveal_type(val)  # N: Revealed type is "Union[__main__.A, None]"
+
+if val in (None,):
+    reveal_type(val)  # N: Revealed type is "Union[__main__.A, None]"
+else:
+    reveal_type(val)  # N: Revealed type is "Union[__main__.A, None]"
+if val not in (None,):
+    reveal_type(val)  # N: Revealed type is "Union[__main__.A, None]"
+else:
+    reveal_type(val)  # N: Revealed type is "Union[__main__.A, None]"
+[builtins fixtures/primitives.pyi]
+
+[case testNarrowingWithTupleOfTypes]
+from typing import Tuple, Type
+
+class Base: ...
+
+class Impl1(Base): ...
+class Impl2(Base): ...
+
+impls: Tuple[Type[Base], ...] = (Impl1, Impl2)
+some: object
+
+if isinstance(some, impls):
+    reveal_type(some)  # N: Revealed type is "__main__.Base"
+else:
+    reveal_type(some)  # N: Revealed type is "builtins.object"
+
+raw: Tuple[type, ...]
+if isinstance(some, raw):
+    reveal_type(some)  # N: Revealed type is "builtins.object"
+else:
+    reveal_type(some)  # N: Revealed type is "builtins.object"
+[builtins fixtures/dict.pyi]
+
+
+[case testNarrowingWithTupleOfTypesPy310Plus]
+# flags: --python-version 3.10
+class Base: ...
+
+class Impl1(Base): ...
+class Impl2(Base): ...
+
+some: int | Base
+
+impls: tuple[type[Base], ...] = (Impl1, Impl2)
+if isinstance(some, impls):
+    reveal_type(some)  # N: Revealed type is "__main__.Base"
+else:
+    reveal_type(some)  # N: Revealed type is "Union[builtins.int, __main__.Base]"
+
+raw: tuple[type, ...]
+if isinstance(some, raw):
+    reveal_type(some)  # N: Revealed type is "Union[builtins.int, __main__.Base]"
+else:
+    reveal_type(some)  # N: Revealed type is "Union[builtins.int, __main__.Base]"
+[builtins fixtures/dict.pyi]
+
+[case testNarrowingWithAnyOps]
+from typing import Any
+
+class C: ...
+class D(C): ...
+tp: Any
+
+c: C
+if isinstance(c, tp) or isinstance(c, D):
+    reveal_type(c)  # N: Revealed type is "Union[Any, __main__.D]"
+else:
+    reveal_type(c)  # N: Revealed type is "__main__.C"
+reveal_type(c)  # N: Revealed type is "__main__.C"
+
+c1: C
+if isinstance(c1, tp) and isinstance(c1, D):
+    reveal_type(c1)  # N: Revealed type is "Any"
+else:
+    reveal_type(c1)  # N: Revealed type is "__main__.C"
+reveal_type(c1)  # N: Revealed type is "__main__.C"
+
+c2: C
+if isinstance(c2, D) or isinstance(c2, tp):
+    reveal_type(c2)  # N: Revealed type is "Union[__main__.D, Any]"
+else:
+    reveal_type(c2)  # N: Revealed type is "__main__.C"
+reveal_type(c2)  # N: Revealed type is "__main__.C"
+
+c3: C
+if isinstance(c3, D) and isinstance(c3, tp):
+    reveal_type(c3)  # N: Revealed type is "Any"
+else:
+    reveal_type(c3)  # N: Revealed type is "__main__.C"
+reveal_type(c3)  # N: Revealed type is "__main__.C"
+
+t: Any
+if isinstance(t, (list, tuple)) and isinstance(t, tuple):
+    reveal_type(t)  # N: Revealed type is "builtins.tuple[Any, ...]"
+else:
+    reveal_type(t)  # N: Revealed type is "Any"
+reveal_type(t)  # N: Revealed type is "Any"
+[builtins fixtures/isinstancelist.pyi]
+
+[case testNarrowingLenItemAndLenCompare]
+from typing import Any
+
+x: Any
+if len(x) == x:
+    reveal_type(x) # N: Revealed type is "Any"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTuple]
+from typing import Tuple, Union
+
+VarTuple = Union[Tuple[int, int], Tuple[int, int, int]]
+
+x: VarTuple
+a = b = c = 0
+if len(x) == 3:
+    a, b, c = x
+else:
+    a, b = x
+
+if len(x) != 3:
+    a, b = x
+else:
+    a, b, c = x
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenHomogeneousTuple]
+from typing import Tuple
+
+x: Tuple[int, ...]
+if len(x) == 3:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int]"
+else:
+    reveal_type(x) # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+
+if len(x) != 3:
+    reveal_type(x) # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+else:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTypeUnaffected]
+from typing import Union, List
+
+x: Union[str, List[int]]
+if len(x) == 3:
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, builtins.list[builtins.int]]"
+else:
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, builtins.list[builtins.int]]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenAnyListElseNotAffected]
+from typing import Any
+
+def f(self, value: Any) -> Any:
+    if isinstance(value, list) and len(value) == 0:
+        reveal_type(value) # N: Revealed type is "builtins.list[Any]"
+        return value
+    reveal_type(value) # N: Revealed type is "Any"
+    return None
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenMultiple]
+from typing import Tuple, Union
+
+VarTuple = Union[Tuple[int, int], Tuple[int, int, int]]
+
+x: VarTuple
+y: VarTuple
+if len(x) == len(y) == 3:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int]"
+    reveal_type(y) # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenFinal]
+from typing import Final, Tuple, Union
+
+VarTuple = Union[Tuple[int, int], Tuple[int, int, int]]
+
+x: VarTuple
+fin: Final = 3
+if len(x) == fin:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenGreaterThan]
+from typing import Tuple, Union
+
+VarTuple = Union[Tuple[int], Tuple[int, int], Tuple[int, int, int]]
+
+x: VarTuple
+if len(x) > 1:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+else:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int]"
+
+if len(x) < 2:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int]"
+else:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+
+if len(x) >= 2:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+else:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int]"
+
+if len(x) <= 2:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int], Tuple[builtins.int, builtins.int]]"
+else:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenBothSidesUnionTuples]
+from typing import Tuple, Union
+
+VarTuple = Union[
+    Tuple[int],
+    Tuple[int, int],
+    Tuple[int, int, int],
+    Tuple[int, int, int, int],
+]
+
+x: VarTuple
+if 2 <= len(x) <= 3:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+else:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int], Tuple[builtins.int, builtins.int, builtins.int, builtins.int]]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenGreaterThanHomogeneousTupleShort]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple
+
+VarTuple = Tuple[int, ...]
+
+x: VarTuple
+if len(x) < 3:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[()], Tuple[builtins.int], Tuple[builtins.int, builtins.int]]"
+else:
+    reveal_type(x) # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int, Unpack[builtins.tuple[builtins.int, ...]]]"
+reveal_type(x)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenBiggerThanHomogeneousTupleLong]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple
+
+VarTuple = Tuple[int, ...]
+
+x: VarTuple
+if len(x) < 30:
+    reveal_type(x) # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+else:
+    reveal_type(x) # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenBothSidesHomogeneousTuple]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple
+
+x: Tuple[int, ...]
+if 1 < len(x) < 4:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+else:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[()], Tuple[builtins.int], Tuple[builtins.int, builtins.int, builtins.int, builtins.int, Unpack[builtins.tuple[builtins.int, ...]]]]"
+reveal_type(x)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenUnionTupleUnreachable]
+# flags: --warn-unreachable
+from typing import Tuple, Union
+
+x: Union[Tuple[int, int], Tuple[int, int, int]]
+if len(x) >= 4:
+    reveal_type(x) # E: Statement is unreachable
+else:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+
+if len(x) < 2:
+    reveal_type(x) # E: Statement is unreachable
+else:
+    reveal_type(x) # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenMixedTypes]
+from typing import Tuple, List, Union
+
+x: Union[Tuple[int, int], Tuple[int, int, int], List[int]]
+a = b = c = 0
+if len(x) == 3:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int, builtins.int], builtins.list[builtins.int]]"
+    a, b, c = x
+else:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], builtins.list[builtins.int]]"
+    a, b = x
+
+if len(x) != 3:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], builtins.list[builtins.int]]"
+    a, b = x
+else:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int, builtins.int], builtins.list[builtins.int]]"
+    a, b, c = x
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTypeVarTupleEquals]
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def foo(x: Tuple[int, Unpack[Ts], str]) -> None:
+    if len(x) == 5:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+
+    if len(x) != 5:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTypeVarTupleGreaterThan]
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def foo(x: Tuple[int, Unpack[Ts], str]) -> None:
+    if len(x) > 5:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+        reveal_type(x[5])  # N: Revealed type is "builtins.object"
+        reveal_type(x[-6])  # N: Revealed type is "builtins.object"
+        reveal_type(x[-1])  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+
+    if len(x) < 5:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+        x[5]  # E: Tuple index out of range \
+              # N: Variadic tuple can have length 5
+        x[-6]  # E: Tuple index out of range \
+               # N: Variadic tuple can have length 5
+    x[2]  # E: Tuple index out of range \
+          # N: Variadic tuple can have length 2
+    x[-3]  # E: Tuple index out of range \
+           # N: Variadic tuple can have length 2
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTypeVarTupleUnreachable]
+# flags: --warn-unreachable
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def foo(x: Tuple[int, Unpack[Ts], str]) -> None:
+    if len(x) == 1:
+        reveal_type(x)  # E: Statement is unreachable
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+
+    if len(x) != 1:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+    else:
+        reveal_type(x)  # E: Statement is unreachable
+
+def bar(x: Tuple[int, Unpack[Ts], str]) -> None:
+    if len(x) >= 2:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+    else:
+        reveal_type(x)  # E: Statement is unreachable
+
+    if len(x) < 2:
+        reveal_type(x)  # E: Statement is unreachable
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenVariadicTupleEquals]
+from typing import Tuple
+from typing_extensions import Unpack
+
+def foo(x: Tuple[int, Unpack[Tuple[float, ...]], str]) -> None:
+    if len(x) == 4:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.float, builtins.float, builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+
+    if len(x) != 4:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.float, builtins.float, builtins.str]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenVariadicTupleGreaterThan]
+from typing import Tuple
+from typing_extensions import Unpack
+
+def foo(x: Tuple[int, Unpack[Tuple[float, ...]], str]) -> None:
+    if len(x) > 3:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.float, builtins.float, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.str], Tuple[builtins.int, builtins.float, builtins.str]]"
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+
+    if len(x) < 3:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.float, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenVariadicTupleUnreachable]
+# flags: --warn-unreachable
+from typing import Tuple
+from typing_extensions import Unpack
+
+def foo(x: Tuple[int, Unpack[Tuple[float, ...]], str]) -> None:
+    if len(x) == 1:
+        reveal_type(x)  # E: Statement is unreachable
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+
+    if len(x) != 1:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+    else:
+        reveal_type(x)  # E: Statement is unreachable
+
+def bar(x: Tuple[int, Unpack[Tuple[float, ...]], str]) -> None:
+    if len(x) >= 2:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+    else:
+        reveal_type(x)  # E: Statement is unreachable
+
+    if len(x) < 2:
+        reveal_type(x)  # E: Statement is unreachable
+    else:
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenBareExpressionPrecise]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple
+
+x: Tuple[int, ...]
+assert x
+reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]]]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenBareExpressionTypeVarTuple]
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def test(*xs: Unpack[Ts]) -> None:
+    assert xs
+    xs[0]  # OK
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenBareExpressionWithNonePrecise]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple, Optional
+
+x: Optional[Tuple[int, ...]]
+if x:
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]]]"
+else:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[()], None]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenBareExpressionWithNoneImprecise]
+from typing import Tuple, Optional
+
+x: Optional[Tuple[int, ...]]
+if x:
+    reveal_type(x)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+else:
+    reveal_type(x)  # N: Revealed type is "Union[builtins.tuple[builtins.int, ...], None]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenMixWithAnyPrecise]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Any
+
+x: Any
+if isinstance(x, (list, tuple)) and len(x) == 0:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[()], builtins.list[Any]]"
+else:
+    reveal_type(x)  # N: Revealed type is "Any"
+reveal_type(x)  # N: Revealed type is "Any"
+
+x1: Any
+if isinstance(x1, (list, tuple)) and len(x1) > 1:
+    reveal_type(x1)  # N: Revealed type is "Union[Tuple[Any, Any, Unpack[builtins.tuple[Any, ...]]], builtins.list[Any]]"
+else:
+    reveal_type(x1)  # N: Revealed type is "Any"
+reveal_type(x1)  # N: Revealed type is "Any"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenMixWithAnyImprecise]
+from typing import Any
+
+x: Any
+if isinstance(x, (list, tuple)) and len(x) == 0:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[()], builtins.list[Any]]"
+else:
+    reveal_type(x)  # N: Revealed type is "Any"
+reveal_type(x)  # N: Revealed type is "Any"
+
+x1: Any
+if isinstance(x1, (list, tuple)) and len(x1) > 1:
+    reveal_type(x1)  # N: Revealed type is "Union[builtins.tuple[Any, ...], builtins.list[Any]]"
+else:
+    reveal_type(x1)  # N: Revealed type is "Any"
+reveal_type(x1)  # N: Revealed type is "Any"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenExplicitLiteralTypes]
+from typing import Literal, Tuple, Union
+
+VarTuple = Union[
+    Tuple[int],
+    Tuple[int, int],
+    Tuple[int, int, int],
+]
+x: VarTuple
+
+supported: Literal[2]
+if len(x) == supported:
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
+else:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+
+not_supported_yet: Literal[2, 3]
+if len(x) == not_supported_yet:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int], Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+else:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int], Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenUnionOfVariadicTuples]
+from typing import Tuple, Union
+
+x: Union[Tuple[int, ...], Tuple[str, ...]]
+if len(x) == 2:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.str, builtins.str]]"
+else:
+    reveal_type(x)  # N: Revealed type is "Union[builtins.tuple[builtins.int, ...], builtins.tuple[builtins.str, ...]]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenUnionOfNamedTuples]
+from typing import NamedTuple, Union
+
+class Point2D(NamedTuple):
+    x: int
+    y: int
+class Point3D(NamedTuple):
+    x: int
+    y: int
+    z: int
+
+x: Union[Point2D, Point3D]
+if len(x) == 2:
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.int, fallback=__main__.Point2D]"
+else:
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.int, fallback=__main__.Point3D]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTupleSubclass]
+from typing import Tuple
+
+class Ints(Tuple[int, ...]):
+    size: int
+
+x: Ints
+if len(x) == 2:
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.int, fallback=__main__.Ints]"
+    reveal_type(x.size)  # N: Revealed type is "builtins.int"
+else:
+    reveal_type(x)  # N: Revealed type is "__main__.Ints"
+    reveal_type(x.size)  # N: Revealed type is "builtins.int"
+
+reveal_type(x)  # N: Revealed type is "__main__.Ints"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTupleSubclassCustomNotAllowed]
+from typing import Tuple
+
+class Ints(Tuple[int, ...]):
+    def __len__(self) -> int:
+        return 0
+
+x: Ints
+if len(x) > 2:
+    reveal_type(x)  # N: Revealed type is "__main__.Ints"
+else:
+    reveal_type(x)  # N: Revealed type is "__main__.Ints"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenTupleSubclassPreciseNotAllowed]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple
+
+class Ints(Tuple[int, ...]):
+    size: int
+
+x: Ints
+if len(x) > 2:
+    reveal_type(x)  # N: Revealed type is "__main__.Ints"
+else:
+    reveal_type(x)  # N: Revealed type is "__main__.Ints"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenUnknownLen]
+from typing import Any, Tuple, Union
+
+x: Union[Tuple[int, int], Tuple[int, int, int]]
+
+n: int
+if len(x) == n:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+else:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+
+a: Any
+if len(x) == a:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+else:
+    reveal_type(x)  # N: Revealed type is "Union[Tuple[builtins.int, builtins.int], Tuple[builtins.int, builtins.int, builtins.int]]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingLenUnionWithUnreachable]
+from typing import Union, Sequence
+
+def f(x: Union[int, Sequence[int]]) -> None:
+    if (
+        isinstance(x, tuple)
+        and len(x) == 2
+        and isinstance(x[0], int)
+        and isinstance(x[1], int)
+    ):
+        reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
+[builtins fixtures/len.pyi]
+
+[case testNarrowingIsSubclassNoneType1]
+from typing import Type, Union
+
+def f(cls: Type[Union[None, int]]) -> None:
+    if issubclass(cls, int):
+        reveal_type(cls)  # N: Revealed type is "Type[builtins.int]"
+    else:
+        reveal_type(cls)  # N: Revealed type is "Type[None]"
+[builtins fixtures/isinstance.pyi]
+
+[case testNarrowingIsSubclassNoneType2]
+from typing import Type, Union
+
+def f(cls: Type[Union[None, int]]) -> None:
+    if issubclass(cls, type(None)):
+        reveal_type(cls)  # N: Revealed type is "Type[None]"
+    else:
+        reveal_type(cls)  # N: Revealed type is "Type[builtins.int]"
+[builtins fixtures/isinstance.pyi]
+
+[case testNarrowingIsSubclassNoneType3]
+from typing import Type, Union
+
+NoneType_ = type(None)
+
+def f(cls: Type[Union[None, int]]) -> None:
+    if issubclass(cls, NoneType_):
+        reveal_type(cls)  # N: Revealed type is "Type[None]"
+    else:
+        reveal_type(cls)  # N: Revealed type is "Type[builtins.int]"
+[builtins fixtures/isinstance.pyi]
+
+[case testNarrowingIsSubclassNoneType4]
+# flags: --python-version 3.10
+
+from types import NoneType
+from typing import Type, Union
+
+def f(cls: Type[Union[None, int]]) -> None:
+    if issubclass(cls, NoneType):
+        reveal_type(cls)  # N: Revealed type is "Type[None]"
+    else:
+        reveal_type(cls)  # N: Revealed type is "Type[builtins.int]"
+[builtins fixtures/isinstance.pyi]
+
+[case testNarrowingIsInstanceNoIntersectionWithFinalTypeAndNoneType]
+# flags: --warn-unreachable --python-version 3.10
+
+from types import NoneType
+from typing import final
+
+class X: ...
+class Y: ...
+@final
+class Z: ...
+
+x: X
+
+if isinstance(x, (Y, Z)):
+    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.X" and "__main__.Y">"
+if isinstance(x, (Y, NoneType)):
+    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.X" and "__main__.Y">"
+if isinstance(x, (Y, Z, NoneType)):
+    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.X" and "__main__.Y">"
+if isinstance(x, (Z, NoneType)):  # E: Subclass of "X" and "Z" cannot exist: "Z" is final \
+                                  # E: Subclass of "X" and "NoneType" cannot exist: "NoneType" is final
+    reveal_type(x)  # E: Statement is unreachable
+
+[builtins fixtures/isinstance.pyi]
+
+[case testTypeNarrowingReachableNegative]
+# flags: --warn-unreachable
+from typing import Literal
+
+x: Literal[-1]
+
+if x == -1:
+    assert True
+
+[typing fixtures/typing-medium.pyi]
+[builtins fixtures/ops.pyi]
+
+[case testTypeNarrowingReachableNegativeUnion]
+from typing import Literal
+
+x: Literal[-1, 1]
+
+if x == -1:
+    reveal_type(x)  # N: Revealed type is "Literal[-1]"
+else:
+    reveal_type(x)  # N: Revealed type is "Literal[1]"
+
+[typing fixtures/typing-medium.pyi]
+[builtins fixtures/ops.pyi]
+
+[case testNarrowingWithIntEnum]
+# mypy: strict-equality
+from __future__ import annotations
+from typing import Any
+from enum import IntEnum
+
+class IE(IntEnum):
+    X = 1
+    Y = 2
+
+def f1(x: int) -> None:
+    if x == IE.X:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+    if x != IE.X:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+
+def f2(x: IE) -> None:
+    if x == 1:
+        reveal_type(x)  # N: Revealed type is "__main__.IE"
+    else:
+        reveal_type(x)  # N: Revealed type is "__main__.IE"
+
+def f3(x: object) -> None:
+    if x == IE.X:
+        reveal_type(x)  # N: Revealed type is "builtins.object"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.object"
+
+def f4(x: int | Any) -> None:
+    if x == IE.X:
+        reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
+    else:
+        reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
+
+def f5(x: int) -> None:
+    if x is IE.X:
+        reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.X]"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+    if x is not IE.X:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+    else:
+        reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.X]"
+
+def f6(x: IE) -> None:
+     if x == IE.X:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.X]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.Y]"
+[builtins fixtures/primitives.pyi]
+
+[case testNarrowingWithIntEnum2]
+# mypy: strict-equality
+from __future__ import annotations
+from typing import Any
+from enum import IntEnum, Enum
+
+class MyDecimal: ...
+
+class IE(IntEnum):
+    X = 1
+    Y = 2
+
+class IE2(IntEnum):
+    X = 1
+    Y = 2
+
+class E(Enum):
+    X = 1
+    Y = 2
+
+def f1(x: IE | MyDecimal) -> None:
+     if x == IE.X:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, __main__.MyDecimal]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, __main__.MyDecimal]"
+
+def f2(x: E | bytes) -> None:
+     if x == E.X:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.E.X]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[Literal[__main__.E.Y], builtins.bytes]"
+
+def f3(x: IE | IE2) -> None:
+     if x == IE.X:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, __main__.IE2]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, __main__.IE2]"
+
+def f4(x: IE | E) -> None:
+     if x == IE.X:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.X]"
+     elif x == E.X:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.E.X]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[Literal[__main__.IE.Y], Literal[__main__.E.Y]]"
+
+def f5(x: E | str | int) -> None:
+     if x == E.X:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.E.X]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[Literal[__main__.E.Y], builtins.str, builtins.int]"
+
+def f6(x: IE | Any) -> None:
+     if x == IE.X:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, Any]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, Any]"
+
+def f7(x: IE | None) -> None:
+     if x == IE.X:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.X]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[Literal[__main__.IE.Y], None]"
+
+def f8(x: IE | None) -> None:
+     if x is None:
+         reveal_type(x)  # N: Revealed type is "None"
+     elif x == IE.X:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.X]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.Y]"
+[builtins fixtures/primitives.pyi]
+
+[case testNarrowingWithStrEnum]
+# mypy: strict-equality
+from enum import StrEnum
+
+class SE(StrEnum):
+    A = 'a'
+    B = 'b'
+
+def f1(x: str) -> None:
+    if x == SE.A:
+        reveal_type(x)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.str"
+
+def f2(x: SE) -> None:
+    if x == 'a':
+        reveal_type(x)  # N: Revealed type is "__main__.SE"
+    else:
+        reveal_type(x)  # N: Revealed type is "__main__.SE"
+
+def f3(x: object) -> None:
+    if x == SE.A:
+        reveal_type(x)  # N: Revealed type is "builtins.object"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.object"
+
+def f4(x: SE) -> None:
+     if x == SE.A:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.SE.A]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Literal[__main__.SE.B]"
+[builtins fixtures/primitives.pyi]
+
+[case testConsistentNarrowingEqAndIn]
+# flags: --python-version 3.10
+
+# https://github.com/python/mypy/issues/17864
+def f(x: str | int) -> None:
+    if x == "x":
+        reveal_type(x)  # N: Revealed type is "Union[builtins.str, builtins.int]"
+        y = x
+
+    if x in ["x"]:
+        # TODO: we should fix this reveal https://github.com/python/mypy/issues/3229
+        reveal_type(x)  # N: Revealed type is "Union[builtins.str, builtins.int]"
+        y = x
+        z = x
+    z = y
+[builtins fixtures/primitives.pyi]
+
+[case testConsistentNarrowingInWithCustomEq]
+# flags: --python-version 3.10
+
+# https://github.com/python/mypy/issues/17864
+class C:
+    def __init__(self, x: int) -> None:
+        self.x = x
+
+    def __eq__(self, other: object) -> bool:
+        raise
+        # Example implementation:
+        # if isinstance(other, C) and other.x == self.x:
+        #     return True
+        # return NotImplemented
+
+class D(C):
+    pass
+
+def f(x: C) -> None:
+    if x in [D(5)]:
+        reveal_type(x)  # D  # N: Revealed type is "__main__.C"
+
+f(C(5))
+[builtins fixtures/primitives.pyi]
+
+[case testNarrowingTypeVarNone]
+# flags: --warn-unreachable
+
+# https://github.com/python/mypy/issues/18126
+from typing import TypeVar
+
+T = TypeVar("T")
+
+def fn_if(arg: T) -> None:
+    if arg is None:
+        return None
+    return None
+
+def fn_while(arg: T) -> None:
+    while arg is None:
+        return None
+    return None
+[builtins fixtures/primitives.pyi]
+
+[case testRefinePartialTypeWithinLoop]
+# flags: --no-local-partial-types
+
+x = None
+for _ in range(2):
+    if x is not None:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+    x = 1
+reveal_type(x)  # N: Revealed type is "Union[builtins.int, None]"
+
+def f() -> bool: ...
+
+y = None
+while f():
+    reveal_type(y)  # N: Revealed type is "None" \
+                    # N: Revealed type is "Union[builtins.int, None]"
+    y = 1
+reveal_type(y)  # N: Revealed type is "Union[builtins.int, None]"
+
+z = []  # E: Need type annotation for "z" (hint: "z: List[<type>] = ...")
+def g() -> None:
+    for i in range(2):
+        while f():
+            if z:
+                z[0] + "v"  # E: Unsupported operand types for + ("int" and "str")
+            z.append(1)
+
+class A:
+    def g(self) -> None:
+        z = []  # E: Need type annotation for "z" (hint: "z: List[<type>] = ...")
+        for i in range(2):
+            while f():
+                if z:
+                    z[0] + "v"  # E: Unsupported operand types for + ("int" and "str")
+                z.append(1)
+
+[builtins fixtures/primitives.pyi]
+
+[case testAvoidFalseUnreachableInLoop]
+# flags: --warn-unreachable --python-version 3.11
+
+def f() -> int | None: ...
+def b() -> bool: ...
+
+x: int | None
+x = 1
+while x is not None or b():
+    x = f()
+
+[builtins fixtures/bool.pyi]
+
+[case testAvoidFalseRedundantExprInLoop]
+# flags: --enable-error-code redundant-expr --python-version 3.11
+
+def f() -> int | None: ...
+def b() -> bool: ...
+
+x: int | None
+x = 1
+while x is not None and b():
+    x = f()
+
+[builtins fixtures/primitives.pyi]
+
+[case testNarrowingTypeVarMultiple]
+from typing import TypeVar
+
+class A: ...
+class B: ...
+
+T = TypeVar("T")
+def foo(x: T) -> T:
+    if isinstance(x, A):
+        pass
+    elif isinstance(x, B):
+        pass
+    else:
+        raise
+    reveal_type(x)  # N: Revealed type is "T`-1"
+    return x
+[builtins fixtures/isinstance.pyi]
+
+[case testDoNotNarrowToNever]
+def any():
+    return 1
+
+def f() -> None:
+    x = "a"
+    x = any()
+    assert isinstance(x, int)
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/isinstance.pyi]
diff --git a/test-data/unit/check-native-int.test b/test-data/unit/check-native-int.test
index 1e945d0af27d..2f852ca522c5 100644
--- a/test-data/unit/check-native-int.test
+++ b/test-data/unit/check-native-int.test
@@ -69,7 +69,6 @@ reveal_type(join(a, n64))  # N: Revealed type is "Any"
 [builtins fixtures/dict.pyi]
 
 [case testNativeIntMeets]
-# flags: --strict-optional
 from typing import TypeVar, Callable, Any
 from mypy_extensions import i32, i64
 
@@ -87,8 +86,10 @@ reveal_type(meet(f32, f))  # N: Revealed type is "mypy_extensions.i32"
 reveal_type(meet(f, f32))  # N: Revealed type is "mypy_extensions.i32"
 reveal_type(meet(f64, f))  # N: Revealed type is "mypy_extensions.i64"
 reveal_type(meet(f, f64))  # N: Revealed type is "mypy_extensions.i64"
-reveal_type(meet(f32, f64))  # N: Revealed type is "<nothing>"
-reveal_type(meet(f64, f32))  # N: Revealed type is "<nothing>"
+if object():
+    reveal_type(meet(f32, f64))  # N: Revealed type is "Never"
+if object():
+    reveal_type(meet(f64, f32))  # N: Revealed type is "Never"
 
 reveal_type(meet(f, fa))    # N: Revealed type is "builtins.int"
 reveal_type(meet(f32, fa))  # N: Revealed type is "mypy_extensions.i32"
@@ -128,7 +129,6 @@ reveal_type(y)  # N: Revealed type is "builtins.int"
 [builtins fixtures/dict.pyi]
 
 [case testNativeIntFloatConversion]
-# flags: --strict-optional
 from typing import TypeVar, Callable
 from mypy_extensions import i32
 
@@ -148,8 +148,10 @@ def meet(c1: Callable[[T], None], c2: Callable[[T], None]) -> T:
 def ff(x: float) -> None: pass
 def fi32(x: i32) -> None: pass
 
-reveal_type(meet(ff, fi32))  # N: Revealed type is "<nothing>"
-reveal_type(meet(fi32, ff))  # N: Revealed type is "<nothing>"
+if object():
+    reveal_type(meet(ff, fi32))  # N: Revealed type is "Never"
+if object():
+    reveal_type(meet(fi32, ff))  # N: Revealed type is "Never"
 [builtins fixtures/dict.pyi]
 
 [case testNativeIntForLoopRange]
diff --git a/test-data/unit/check-newsemanal.test b/test-data/unit/check-newsemanal.test
index 99f4141a4d64..b6756abafc49 100644
--- a/test-data/unit/check-newsemanal.test
+++ b/test-data/unit/check-newsemanal.test
@@ -229,7 +229,7 @@ class C(B):
 [targets b, a, b, a, __main__]
 
 [case testNewAnalyzerTypedDictClass]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 import a
 class T1(TypedDict):
     x: A
@@ -237,7 +237,7 @@ class A: pass
 reveal_type(T1(x=A())) # E
 
 [file a.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 from b import TD1 as TD2, TD3
 class T2(TD3):
     x: int
@@ -246,7 +246,8 @@ reveal_type(T2(x=2)) # E
 [file b.py]
 from a import TypedDict as TD1
 from a import TD2 as TD3
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [out]
 tmp/a.py:5: note: Revealed type is "TypedDict('a.T2', {'x': builtins.int})"
@@ -254,7 +255,7 @@ main:6: note: Revealed type is "TypedDict('__main__.T1', {'x': __main__.A})"
 
 
 [case testNewAnalyzerTypedDictClassInheritance]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class T2(T1):
     y: int
@@ -275,7 +276,8 @@ x: T2
 reveal_type(x) # N: Revealed type is "TypedDict('__main__.T2', {'x': builtins.str, 'y': builtins.int})"
 y: T4
 reveal_type(y) # N: Revealed type is "TypedDict('__main__.T4', {'x': builtins.str, 'y': __main__.A})"
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNewAnalyzerRedefinitionAndDeferral1a]
 import a
@@ -434,13 +436,14 @@ def main() -> None:
             x  # E: Name "x" is not defined
 
 [case testNewAnalyzerCyclicDefinitions]
-# flags: --disable-recursive-aliases --disable-error-code used-before-def
+# flags: --disable-error-code used-before-def
 gx = gy  # E: Cannot resolve name "gy" (possible cyclic definition)
 gy = gx
 def main() -> None:
     class C:
         def meth(self) -> None:
-            lx = ly  # E: Cannot resolve name "ly" (possible cyclic definition)
+            lx = ly  # E: Cannot resolve name "ly" (possible cyclic definition) \
+                     # N: Recursive types are not allowed at function scope
             ly = lx
 
 [case testNewAnalyzerCyclicDefinitionCrossModule]
@@ -992,7 +995,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 +1012,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]
@@ -1495,22 +1498,25 @@ reveal_type(x[0][0])  # N: Revealed type is "__main__.C"
 [builtins fixtures/list.pyi]
 
 [case testNewAnalyzerAliasToNotReadyDirectBase]
-# flags: --disable-recursive-aliases --disable-error-code used-before-def
+# flags: --disable-error-code used-before-def
 from typing import List
 
-x: B
-B = List[C]
-class C(B): pass
+def test() -> None:
+    x: B
+    B = List[C]
+    class C(B): pass
 
-reveal_type(x)
-reveal_type(x[0][0])
+    reveal_type(x)
+    reveal_type(x[0][0])
 [builtins fixtures/list.pyi]
 [out]
-main:4: error: Cannot resolve name "B" (possible cyclic definition)
 main:5: error: Cannot resolve name "B" (possible cyclic definition)
-main:5: error: Cannot resolve name "C" (possible cyclic definition)
-main:8: note: Revealed type is "Any"
+main:5: note: Recursive types are not allowed at function scope
+main:6: error: Cannot resolve name "B" (possible cyclic definition)
+main:6: note: Recursive types are not allowed at function scope
+main:6: error: Cannot resolve name "C" (possible cyclic definition)
 main:9: note: Revealed type is "Any"
+main:10: note: Revealed type is "Any"
 
 [case testNewAnalyzerAliasToNotReadyTwoDeferralsFunction]
 # flags: --disable-error-code used-before-def
@@ -1530,25 +1536,21 @@ reveal_type(f)  # N: Revealed type is "def (x: builtins.list[a.C]) -> builtins.l
 [builtins fixtures/list.pyi]
 
 [case testNewAnalyzerAliasToNotReadyDirectBaseFunction]
-# flags: --disable-recursive-aliases --disable-error-code used-before-def
+# flags: --disable-error-code used-before-def
 import a
 [file a.py]
 from typing import List
 from b import D
 
 def f(x: B) -> List[B]: ...
-B = List[C] # E
+B = List[C]
 class C(B): pass
 
 [file b.py]
 from a import f
 class D: ...
-reveal_type(f)  # N
+reveal_type(f)  # N: Revealed type is "def (x: builtins.list[a.C]) -> builtins.list[builtins.list[a.C]]"
 [builtins fixtures/list.pyi]
-[out]
-tmp/b.py:3: note: Revealed type is "def (x: builtins.list[Any]) -> builtins.list[builtins.list[Any]]"
-tmp/a.py:5: error: Cannot resolve name "B" (possible cyclic definition)
-tmp/a.py:5: error: Cannot resolve name "C" (possible cyclic definition)
 
 [case testNewAnalyzerAliasToNotReadyMixed]
 from typing import List, Union
@@ -1659,15 +1661,14 @@ tmp/a.py:10: error: Type argument "str" of "C" must be a subtype of "int"
 tmp/a.py:11: error: Type argument "str" of "C" must be a subtype of "int"
 
 [case testNewAnalyzerTypeArgBoundCheckDifferentNodes]
-from typing import TypeVar, Generic, NamedTuple, NewType, Union, Any, cast, overload
-from mypy_extensions import TypedDict
+from typing import TypeVar, TypedDict, Generic, NamedTuple, NewType, Union, Any, cast, overload
 
 T = TypeVar('T', bound=int)
 class C(Generic[T]): pass
 class C2(Generic[T]): pass
 
-A = C[str] # E: Type argument "str" of "C" must be a subtype of "int" \
-           # E: Value of type variable "T" of "C" cannot be "str"
+A = C[str] # E: Value of type variable "T" of "C" cannot be "str" \
+           # E: Type argument "str" of "C" must be a subtype of "int"
 B = Union[C[str], int] # E: Type argument "str" of "C" must be a subtype of "int"
 S = TypeVar('S', bound=C[str]) # E: Type argument "str" of "C" must be a subtype of "int"
 U = TypeVar('U', C[str], str) # E: Type argument "str" of "C" must be a subtype of "int"
@@ -1706,7 +1707,8 @@ def g(x: int) -> int: ...
 def g(x: Union[C[str], int]) -> int:  # E: Type argument "str" of "C" must be a subtype of "int"
     y: C[object]  # E: Type argument "object" of "C" must be a subtype of "int"
     return 0
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNewAnalyzerTypeArgBoundCheckWithStrictOptional]
 # flags: --config-file tmp/mypy.ini
@@ -1908,9 +1910,9 @@ else:
     @dec
     def f(x: int) -> None:
         1()  # E: "int" not callable
-reveal_type(f) # N: Revealed type is "def (x: builtins.str)"
+reveal_type(f) # N: Revealed type is "def (builtins.str)"
 [file m.py]
-def f(x: str) -> None: pass
+def f(x: str, /) -> None: pass
 
 [case testNewAnalyzerConditionallyDefineFuncOverVar]
 from typing import Callable
@@ -1947,7 +1949,7 @@ class NTStr(NamedTuple):
     y: str
 
 t1: T
-reveal_type(t1.__iter__) # N: Revealed type is "def () -> typing.Iterator[__main__.A]"
+reveal_type(t1.__iter__) # N: Revealed type is "def () -> typing.Iterator[Union[__main__.B, __main__.C]]"
 
 t2: NTInt
 reveal_type(t2.__iter__) # N: Revealed type is "def () -> typing.Iterator[builtins.int]"
@@ -1960,7 +1962,6 @@ t: Union[Tuple[int, int], Tuple[str, str]]
 for x in t:
     reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
 [builtins fixtures/for.pyi]
-[out]
 
 [case testNewAnalyzerFallbackUpperBoundCheckAndFallbacks]
 from typing import TypeVar, Generic, Tuple
@@ -1973,10 +1974,9 @@ S = TypeVar('S', bound='Tuple[G[A], ...]')
 
 class GG(Generic[S]): pass
 
-g: GG[Tuple[G[B], G[C]]] \
-  # E: Type argument "Tuple[G[B], G[C]]" of "GG" must be a subtype of "Tuple[G[A], ...]" \
-  # E: Type argument "B" of "G" must be a subtype of "A" \
-  # E: Type argument "C" of "G" must be a subtype of "A"
+g: GG[Tuple[G[B], G[C]]] # E: Type argument "Tuple[G[B], G[C]]" of "GG" must be a subtype of "Tuple[G[A], ...]" \
+                         # E: Type argument "B" of "G" must be a subtype of "A" \
+                         # E: Type argument "C" of "G" must be a subtype of "A"
 
 T = TypeVar('T', bound=A, covariant=True)
 
@@ -1984,7 +1984,7 @@ class G(Generic[T]): pass
 
 t: Tuple[G[B], G[C]] # E: Type argument "B" of "G" must be a subtype of "A" \
                      # E: Type argument "C" of "G" must be a subtype of "A"
-reveal_type(t.__iter__) # N: Revealed type is "def () -> typing.Iterator[builtins.object]"
+reveal_type(t.__iter__) # N: Revealed type is "def () -> typing.Iterator[__main__.G[__main__.B]]"
 [builtins fixtures/tuple.pyi]
 
 [case testNewAnalyzerClassKeywordsForward]
@@ -2071,6 +2071,7 @@ from enum import Enum
 
 A = Enum('A', ['x', 'y'])
 A = Enum('A', ['z', 't'])  # E: Name "A" already defined on line 3
+[builtins fixtures/tuple.pyi]
 
 [case testNewAnalyzerNewTypeRedefinition]
 from typing import NewType
@@ -2118,25 +2119,29 @@ class B(List[C]):
 [builtins fixtures/list.pyi]
 
 [case testNewAnalyzerNewTypeForwardClassAliasDirect]
-# flags: --disable-recursive-aliases --disable-error-code used-before-def
+# flags: --disable-error-code used-before-def
 from typing import NewType, List
 
-x: D
-reveal_type(x[0][0])
+def test() -> None:
+    x: D
+    reveal_type(x[0][0])
 
-D = List[C]
-C = NewType('C', 'B')
+    D = List[C]
+    C = NewType('C', 'B')
 
-class B(D):
-    pass
+    class B(D):
+        pass
 [builtins fixtures/list.pyi]
 [out]
-main:4: error: Cannot resolve name "D" (possible cyclic definition)
-main:5: note: Revealed type is "Any"
-main:7: error: Cannot resolve name "D" (possible cyclic definition)
-main:7: error: Cannot resolve name "C" (possible cyclic definition)
-main:8: error: Argument 2 to NewType(...) must be a valid type
-main:8: error: Cannot resolve name "B" (possible cyclic definition)
+main:5: error: Cannot resolve name "D" (possible cyclic definition)
+main:5: note: Recursive types are not allowed at function scope
+main:6: note: Revealed type is "Any"
+main:8: error: Cannot resolve name "D" (possible cyclic definition)
+main:8: note: Recursive types are not allowed at function scope
+main:8: error: Cannot resolve name "C" (possible cyclic definition)
+main:9: error: Argument 2 to NewType(...) must be a valid type
+main:9: error: Cannot resolve name "B" (possible cyclic definition)
+main:9: note: Recursive types are not allowed at function scope
 
 -- Copied from check-classes.test (tricky corner cases).
 [case testNewAnalyzerNoCrashForwardRefToBrokenDoubleNewTypeClass]
@@ -2149,26 +2154,29 @@ x: C
 class C:
     def frob(self, foos: Dict[Any, Foos]) -> None:
         foo = foos.get(1)
+        assert foo
         dict(foo)
 [builtins fixtures/dict.pyi]
 
 [case testNewAnalyzerForwardTypeAliasInBase]
-# flags: --disable-recursive-aliases
 from typing import List, Generic, TypeVar, NamedTuple
 T = TypeVar('T')
 
-class C(A, B): # E: Cannot resolve name "A" (possible cyclic definition)
-    pass
-class G(Generic[T]): pass
-A = G[C] # E: Cannot resolve name "A" (possible cyclic definition)
-class B(NamedTuple):
-    x: int
+def test() -> None:
+    class C(A, B):  # E: Cannot resolve name "A" (possible cyclic definition) \
+                    # N: Recursive types are not allowed at function scope
+        pass
+    class G(Generic[T]): pass
+    A = G[C]  # E: Cannot resolve name "A" (possible cyclic definition) \
+              # N: Recursive types are not allowed at function scope
+    class B(NamedTuple):
+        x: int
 
-y: C
-reveal_type(y.x)  # N: Revealed type is "builtins.int"
-reveal_type(y[0])  # N: Revealed type is "builtins.int"
-x: A
-reveal_type(x)  # N: Revealed type is "__main__.G[Tuple[builtins.int, fallback=__main__.C]]"
+    y: C
+    reveal_type(y.x)  # N: Revealed type is "builtins.int"
+    reveal_type(y[0])  # N: Revealed type is "builtins.int"
+    x: A
+    reveal_type(x)  # N: Revealed type is "__main__.G@7[Tuple[builtins.int, fallback=__main__.C@5]]"
 [builtins fixtures/list.pyi]
 
 [case testNewAnalyzerDuplicateTypeVar]
@@ -2177,8 +2185,7 @@ from typing import TypeVar, Generic, Any
 T = TypeVar('T', bound='B[Any]')
 # The "int" error is because of typing fixture.
 T = TypeVar('T', bound='C')  # E: Cannot redefine "T" as a type variable \
-                           # E: Invalid assignment target \
-                           # E: "int" not callable
+                           # E: Invalid assignment target
 
 class B(Generic[T]):
     x: T
@@ -2187,6 +2194,8 @@ class C: ...
 x: B[int]  # E: Type argument "int" of "B" must be a subtype of "B[Any]"
 y: B[B[Any]]
 reveal_type(y.x)  # N: Revealed type is "__main__.B[Any]"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testNewAnalyzerDuplicateTypeVarImportCycle]
 # flags: --disable-error-code used-before-def
@@ -2209,12 +2218,13 @@ class C: ...
 x: B[int]
 y: B[B[Any]]
 reveal_type(y.x)
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
 [out]
 tmp/b.py:8: error: Type argument "int" of "B" must be a subtype of "B[Any]"
 tmp/b.py:10: note: Revealed type is "b.B[Any]"
 tmp/a.py:5: error: Cannot redefine "T" as a type variable
 tmp/a.py:5: error: Invalid assignment target
-tmp/a.py:5: error: "int" not callable
 
 [case testNewAnalyzerDuplicateTypeVarImportCycleWithAliases]
 # flags: --disable-error-code used-before-def
@@ -2518,8 +2528,7 @@ tmp/unittest/suite.pyi:6: error: Name "Iterable" is not defined
 tmp/unittest/suite.pyi:6: note: Did you forget to import it from "typing"? (Suggestion: "from typing import Iterable")
 
 [case testNewAnalyzerNewTypeSpecialCase]
-from typing import NewType
-from typing_extensions import Final, Literal
+from typing import Final, Literal, NewType
 
 X = NewType('X', int)
 
@@ -2570,20 +2579,7 @@ import n
 [file n.pyi]
 class C: pass
 
-[case testNewAnalyzerModuleGetAttrInPython36]
-# flags: --python-version 3.6
-import m
-import n
-
-x: m.n.C # E: Name "m.n.C" is not defined
-y: n.D # E: Name "n.D" is not defined
-[file m.py]
-import n
-[file n.py]
-def __getattr__(x): pass
-
-[case testNewAnalyzerModuleGetAttrInPython37]
-# flags: --python-version 3.7
+[case testNewAnalyzerModuleGetAttr]
 import m
 import n
 
@@ -2595,9 +2591,9 @@ import n
 def __getattr__(x): pass
 
 [case testNewAnalyzerReportLoopInMRO2]
-# flags: --disable-recursive-aliases
 def f() -> None:
-    class A(A): ... # E: Cannot resolve name "A" (possible cyclic definition)
+    class A(A): ...  # E: Cannot resolve name "A" (possible cyclic definition) \
+                     # N: Recursive types are not allowed at function scope
 
 [case testNewAnalyzerUnsupportedBaseClassInsideFunction]
 class C:
@@ -2748,13 +2744,11 @@ T = TypeVar('T')
 
 class C(Generic[T]):
     pass
-# TODO: Error message is confusing
+
 C = C[int]  # E: Cannot assign to a type \
-            # E: Incompatible types in assignment (expression has type "Type[C[Any]]", variable has type "Type[C[Any]]")
+            # E: Incompatible types in assignment (expression has type "Type[C[int]]", variable has type "Type[C[T]]")
 x: C
 reveal_type(x) # N: Revealed type is "__main__.C[Any]"
-[out]
-[out2]
 
 [case testNewAnalyzerClassVariableOrdering]
 def foo(x: str) -> None: pass
@@ -2782,7 +2776,7 @@ class C:
 reveal_type(C.A)  # N: Revealed type is "def () -> a.A"
 
 [case testNewAnalyzerFinalLiteralInferredAsLiteralWithDeferral]
-from typing_extensions import Final, Literal
+from typing import Final, Literal
 
 defer: Yes
 
@@ -3145,6 +3139,22 @@ from typing import Final
 x: Final = 0
 x = x # E: Cannot assign to final name "x"
 
+[case testNewAnalyzerIdentityAssignmentClassImplicit]
+class C: ...
+class A:
+    C = C[str]  # E: "C" expects no type arguments, but 1 given
+[builtins fixtures/tuple.pyi]
+
+[case testNewAnalyzerIdentityAssignmentClassExplicit]
+from typing_extensions import TypeAlias
+
+class A:
+    C: TypeAlias = C
+class C: ...
+c: A.C
+reveal_type(c)  # N: Revealed type is "__main__.C"
+[builtins fixtures/tuple.pyi]
+
 [case testNewAnalyzerClassPropertiesInAllScopes]
 from abc import abstractmethod, ABCMeta
 
@@ -3218,19 +3228,18 @@ class User:
         self.first_name = value
 
     def __init__(self, name: str) -> None:
-        self.name = name  # E: Cannot assign to a method \
-                          # E: Incompatible types in assignment (expression has type "str", variable has type "Callable[..., Any]")
+        self.name = name  # E: Cannot assign to a method
 
 [case testNewAnalyzerMemberNameMatchesTypedDict]
-from typing import Union, Any
-from typing_extensions import TypedDict
+from typing import TypedDict, Union, Any
 
 class T(TypedDict):
     b: b.T
 
 class b:
     T: Union[Any]
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNewAnalyzerMemberNameMatchesNamedTuple]
 from typing import Union, Any, NamedTuple
@@ -3247,3 +3256,21 @@ class b:
 x = x[1]  # E: Cannot resolve name "x" (possible cyclic definition)
 y = 1[y]  # E: Value of type "int" is not indexable \
           # E: Cannot determine type of "y"
+
+[case testForwardBaseDeferAttr]
+from typing import Optional, Callable, TypeVar
+
+class C(B):
+    def a(self) -> None:
+        reveal_type(self._foo)  # N: Revealed type is "Union[builtins.int, None]"
+        self._foo = defer()
+
+class B:
+    def __init__(self) -> None:
+        self._foo: Optional[int] = None
+
+T = TypeVar("T")
+def deco(fn: Callable[[], T]) -> Callable[[], T]: ...
+
+@deco
+def defer() -> int: ...
diff --git a/test-data/unit/check-newsyntax.test b/test-data/unit/check-newsyntax.test
index 63284c34bd8b..3ed4c6d3d8e2 100644
--- a/test-data/unit/check-newsyntax.test
+++ b/test-data/unit/check-newsyntax.test
@@ -1,15 +1,8 @@
-[case testNewSyntaxRequire36]
-# flags: --python-version 3.5
-x: int = 5  # E: Variable annotation syntax is only supported in Python 3.6 and greater
-[out]
-
 [case testNewSyntaxSyntaxError]
-# flags: --python-version 3.6
 x: int: int  # E: invalid syntax
 [out]
 
 [case testNewSyntaxBasics]
-# flags: --python-version 3.6
 x: int
 x = 5
 y: int = 5
@@ -19,11 +12,10 @@ a = 5  # E: Incompatible types in assignment (expression has type "int", variabl
 b: str = 5  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 
 zzz: int
-zzz: str  # E: Name "zzz" already defined on line 10
+zzz: str  # E: Name "zzz" already defined on line 9
 [out]
 
 [case testNewSyntaxWithDict]
-# flags: --python-version 3.6
 from typing import Dict, Any
 
 d: Dict[int, str] = {}
@@ -34,7 +26,6 @@ d['ab'] = 'ab'  # E: Invalid index type "str" for "Dict[int, str]"; expected typ
 [out]
 
 [case testNewSyntaxWithRevealType]
-# flags: --python-version 3.6
 from typing import Dict
 
 def tst_local(dct: Dict[int, T]) -> Dict[T, int]:
@@ -46,7 +37,6 @@ reveal_type(tst_local({1: 'a'}))  # N: Revealed type is "builtins.dict[builtins.
 [out]
 
 [case testNewSyntaxWithInstanceVars]
-# flags: --python-version 3.6
 class TstInstance:
     a: str
     def __init__(self) -> None:
@@ -59,20 +49,17 @@ TstInstance().a = 'ab'
 [out]
 
 [case testNewSyntaxWithClassVars]
-# flags: --strict-optional --python-version 3.6
 class CCC:
     a: str = None  # E: Incompatible types in assignment (expression has type "None", variable has type "str")
 [out]
 
 [case testNewSyntaxWithStrictOptional]
-# flags: --strict-optional --python-version 3.6
 strict: int
 strict = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 strict2: int = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 [out]
 
 [case testNewSyntaxWithStrictOptionalFunctions]
-# flags: --strict-optional --python-version 3.6
 def f() -> None:
     x: int
     if int():
@@ -80,7 +67,6 @@ def f() -> None:
 [out]
 
 [case testNewSyntaxWithStrictOptionalClasses]
-# flags: --strict-optional --python-version 3.6
 class C:
     def meth(self) -> None:
         x: int = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
@@ -88,30 +74,18 @@ class C:
 [out]
 
 [case testNewSyntaxSpecialAssign]
-# flags: --python-version 3.6
 class X:
     x: str
     x[0]: int
     x.x: int
 
 [out]
-main:4: error: Unexpected type declaration
-main:4: error: Unsupported target for indexed assignment ("str")
-main:5: error: Type cannot be declared in assignment to non-self attribute
-main:5: error: "str" has no attribute "x"
-
-[case testNewSyntaxAsyncComprehensionError]
-# flags: --python-version 3.5
-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
+main:3: error: Unexpected type declaration
+main:3: error: Unsupported target for indexed assignment ("str")
+main:4: error: Type cannot be declared in assignment to non-self attribute
+main:4: error: "str" has no attribute "x"
 
 [case testNewSyntaxFStringBasics]
-# flags: --python-version 3.6
 f'foobar'
 f'{"foobar"}'
 f'foo{"bar"}'
@@ -123,22 +97,19 @@ a = f'{"foobar"}'
 [builtins fixtures/f_string.pyi]
 
 [case testNewSyntaxFStringExpressionsOk]
-# flags: --python-version 3.6
 f'.{1 + 1}.'
 f'.{1 + 1}.{"foo" + "bar"}'
 [builtins fixtures/f_string.pyi]
 
 [case testNewSyntaxFStringExpressionsErrors]
-# flags: --python-version 3.6
 f'{1 + ""}'
 f'.{1 + ""}'
 [builtins fixtures/f_string.pyi]
 [out]
+main:1: error: Unsupported operand types for + ("int" and "str")
 main:2: error: Unsupported operand types for + ("int" and "str")
-main:3: error: Unsupported operand types for + ("int" and "str")
 
 [case testNewSyntaxFStringParseFormatOptions]
-# flags: --python-version 3.6
 value = 10.5142
 width = 10
 precision = 4
@@ -146,7 +117,6 @@ f'result: {value:{width}.{precision}}'
 [builtins fixtures/f_string.pyi]
 
 [case testNewSyntaxFStringSingleField]
-# flags: --python-version 3.6
 v = 1
 reveal_type(f'{v}') # N: Revealed type is "builtins.str"
 reveal_type(f'{1}') # N: Revealed type is "builtins.str"
diff --git a/test-data/unit/check-newtype.test b/test-data/unit/check-newtype.test
index 0ff6b8396fa7..a0a30079f062 100644
--- a/test-data/unit/check-newtype.test
+++ b/test-data/unit/check-newtype.test
@@ -379,3 +379,9 @@ N = NewType('N', XXX)  # E: Argument 2 to NewType(...) must be subclassable (got
                        # E: Name "XXX" is not defined
 x: List[Union[N, int]]
 [builtins fixtures/list.pyi]
+
+[case testTypingExtensionsNewType]
+from typing_extensions import NewType
+N = NewType("N", int)
+x: N
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-optional.test b/test-data/unit/check-optional.test
index ae247b0047f1..5ed4c15f470e 100644
--- a/test-data/unit/check-optional.test
+++ b/test-data/unit/check-optional.test
@@ -53,14 +53,14 @@ x = None  # type:  Optional[int]
 if x:
   reveal_type(x)  # N: Revealed type is "builtins.int"
 else:
-  reveal_type(x)  # N: Revealed type is "Union[builtins.int, None]"
+  reveal_type(x)  # N: Revealed type is "Union[Literal[0], None]"
 [builtins fixtures/bool.pyi]
 
 [case testIfNotCases]
 from typing import Optional
 x = None  # type:  Optional[int]
 if not x:
-  reveal_type(x)  # N: Revealed type is "Union[builtins.int, None]"
+  reveal_type(x)  # N: Revealed type is "Union[Literal[0], None]"
 else:
   reveal_type(x)  # N: Revealed type is "builtins.int"
 [builtins fixtures/bool.pyi]
@@ -109,13 +109,13 @@ reveal_type(z2)  # N: Revealed type is "Union[builtins.int, builtins.str, None]"
 from typing import Optional
 x = None  # type: Optional[str]
 y1 = x and 'b'
-reveal_type(y1)  # N: Revealed type is "Union[builtins.str, None]"
+reveal_type(y1)  # N: Revealed type is "Union[Literal[''], None, builtins.str]"
 y2 = x and 1  # x could be '', so...
-reveal_type(y2)  # N: Revealed type is "Union[builtins.str, None, builtins.int]"
+reveal_type(y2)  # N: Revealed type is "Union[Literal[''], None, builtins.int]"
 z1 = 'b' and x
 reveal_type(z1)  # N: Revealed type is "Union[builtins.str, None]"
 z2 = int() and x
-reveal_type(z2)  # N: Revealed type is "Union[builtins.int, builtins.str, None]"
+reveal_type(z2)  # N: Revealed type is "Union[Literal[0], builtins.str, None]"
 
 [case testLambdaReturningNone]
 f = lambda: None
@@ -321,10 +321,13 @@ def f() -> Generator[None, None, None]:
 [out]
 
 [case testNoneAndStringIsNone]
-a = None
+a: None = None
 b = "foo"
 reveal_type(a and b)  # N: Revealed type is "None"
 
+c = None
+reveal_type(c and b)  # N: Revealed type is "None"
+
 [case testNoneMatchesObjectInOverload]
 import a
 a.f(None)
@@ -361,9 +364,9 @@ def f() -> None:
 def g(x: Optional[int]) -> int:
   pass
 
-x = f()  # E: "f" does not return a value
-f() + 1  # E: "f" does not return a value
-g(f())  # E: "f" does not return a value
+x = f()  # E: "f" does not return a value (it only ever returns None)
+f() + 1  # E: "f" does not return a value (it only ever returns None)
+g(f())  # E: "f" does not return a value (it only ever returns None)
 
 [case testEmptyReturn]
 def f() -> None:
@@ -395,7 +398,7 @@ def lookup_field(name, obj):
         attr = None
 
 [case testTernaryWithNone]
-reveal_type(None if bool() else 0)  # N: Revealed type is "Union[Literal[0]?, None]"
+reveal_type(None if bool() else 0)  # N: Revealed type is "Union[None, Literal[0]?]"
 [builtins fixtures/bool.pyi]
 
 [case testListWithNone]
@@ -581,7 +584,7 @@ x is not None and x + '42'  # E: Unsupported operand types for + ("int" and "str
 [case testInvalidBooleanBranchIgnored]
 from typing import Optional
 
-x = None
+x: None = None
 x is not None and x + 42
 [builtins fixtures/isinstance.pyi]
 
@@ -725,7 +728,6 @@ def g(x: Optional[int]) -> int:
         reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
     reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
     return x
-
 [builtins fixtures/bool.pyi]
 
 [case testOptionalAssignAny2]
@@ -738,12 +740,11 @@ def g(x: Optional[int]) -> int:
         reveal_type(x)  # N: Revealed type is "None"
         x = 1
         reveal_type(x)  # N: Revealed type is "builtins.int"
-        # Since we've assigned to x, the special case None behavior shouldn't happen
+        # Same as above, even after we've assigned to x
         x = f()
-        reveal_type(x)  # N: Revealed type is "Union[builtins.int, None]"
-    reveal_type(x)  # N: Revealed type is "Union[builtins.int, None]"
-    return x  # E: Incompatible return value type (got "Optional[int]", expected "int")
-
+        reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
+    reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
+    return x
 [builtins fixtures/bool.pyi]
 
 [case testOptionalAssignAny3]
@@ -755,11 +756,9 @@ def g(x: Optional[int]) -> int:
     if x is not None:
         return x
     reveal_type(x)  # N: Revealed type is "None"
-    if 1:
-        x = f()
-        reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
-        return x
-
+    x = f()
+    reveal_type(x)  # N: Revealed type is "Union[builtins.int, Any]"
+    return x
 [builtins fixtures/bool.pyi]
 
 [case testStrictOptionalCovarianceCrossModule]
@@ -783,7 +782,7 @@ asdf(x)
 strict_optional = False
 [out]
 main:4: error: Argument 1 to "asdf" has incompatible type "List[str]"; expected "List[Optional[str]]"
-main:4: note: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
+main:4: note: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
 main:4: note: Consider using "Sequence" instead, which is covariant
 [builtins fixtures/list.pyi]
 
diff --git a/test-data/unit/check-overloading.test b/test-data/unit/check-overloading.test
index 4209f4ec9164..243568c54253 100644
--- a/test-data/unit/check-overloading.test
+++ b/test-data/unit/check-overloading.test
@@ -373,7 +373,8 @@ def foo(t, s): pass
 
 class Wrapper(Generic[T]):
     @overload
-    def foo(self, t: List[T], s: T) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def foo(self, t: List[T], s: T) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \
+                                                 # N: Flipping the order of overloads will fix this error
     @overload
     def foo(self, t: T, s: T) -> str: ...
     def foo(self, t, s): pass
@@ -384,7 +385,8 @@ class Dummy(Generic[T]): pass
 # cause the constraint solver to not infer T = object like it did in the
 # first example?
 @overload
-def bar(d: Dummy[T], t: List[T], s: T) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def bar(d: Dummy[T], t: List[T], s: T) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \
+                                                    # N: Flipping the order of overloads will fix this error
 @overload
 def bar(d: Dummy[T], t: T, s: T) -> str: ...
 def bar(d: Dummy[T], t, s): pass
@@ -450,7 +452,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 +495,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 +518,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 +554,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 +577,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 +598,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 +616,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 +635,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 +658,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 +774,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():
@@ -1133,7 +1147,7 @@ def f(x: str) -> None: pass
 f(1.1)
 f('')
 f(1)
-f(()) # E: No overload variant of "f" matches argument type "Tuple[]" \
+f(()) # E: No overload variant of "f" matches argument type "Tuple[()]" \
       # N: Possible overload variants: \
       # N:     def f(x: float) -> None \
       # N:     def f(x: str) -> None
@@ -1215,6 +1229,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
@@ -1261,7 +1276,7 @@ f('x')() # E: "str" not callable
 f(1)() # E: "bool" not callable
 f(1.1) # E: No overload variant of "f" matches argument type "float" \
        # N: Possible overload variants: \
-       # N:     def [T <: str] f(x: T) -> T \
+       # N:     def [T: str] f(x: T) -> T \
        # N:     def f(x: int) -> bool
 f(mystr())() # E: "mystr" not callable
 [builtins fixtures/primitives.pyi]
@@ -1283,8 +1298,8 @@ def g(x: U, y: V) -> None:
     f(x)() # E: "mystr" not callable
     f(y) # E: No overload variant of "f" matches argument type "V" \
          # N: Possible overload variants: \
-         # N:     def [T <: str] f(x: T) -> T \
-         # N:     def [T <: str] f(x: List[T]) -> None
+         # N:     def [T: str] f(x: T) -> T \
+         # N:     def [T: str] f(x: List[T]) -> None
     a = f([x])
     reveal_type(a)  # N: Revealed type is "None"
     f([y]) # E: Value of type variable "T" of "f" cannot be "V"
@@ -1312,8 +1327,9 @@ def h(x: Sequence[str]) -> int: pass
 @overload
 def h(x: Sequence[T]) -> None: pass  # E: Overloaded function signature 2 will never be matched: signature 1's parameter type(s) are the same or broader
 
+# Safety of this highly depends on the implementation, so we lean towards being silent.
 @overload
-def i(x: List[str]) -> int: pass  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def i(x: List[str]) -> int: pass
 @overload
 def i(x: List[T]) -> None: pass
 [builtins fixtures/list.pyi]
@@ -1335,7 +1351,7 @@ f(b'1')() # E: "str" not callable
 f(1.0) # E: No overload variant of "f" matches argument type "float" \
        # N: Possible overload variants: \
        # N:     def f(x: int) -> int \
-       # N:     def [AnyStr in (bytes, str)] f(x: AnyStr) -> str
+       # N:     def [AnyStr: (bytes, str)] f(x: AnyStr) -> str
 
 @overload
 def g(x: AnyStr, *a: AnyStr) -> None: pass
@@ -1399,7 +1415,7 @@ main:18: note: Revealed type is "builtins.str"
 main:19: note: Revealed type is "Any"
 main:20: note: Revealed type is "Union[builtins.int, builtins.str]"
 main:21: error: Argument 1 to "foo" has incompatible type "List[bool]"; expected "List[int]"
-main:21: note: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
+main:21: note: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
 main:21: note: Consider using "Sequence" instead, which is covariant
 main:22: error: Argument 1 to "foo" has incompatible type "List[object]"; expected "List[int]"
 main:23: error: Argument 1 to "foo" has incompatible type "List[Union[int, str]]"; expected "List[int]"
@@ -1739,14 +1755,11 @@ reveal_type(f(d))  # N: Revealed type is "builtins.list[builtins.int]"
 from typing import overload, Any
 
 @overload
-def f(*, x: int = 3, y: int = 3) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f(*, x: int = 3, y: int = 3) -> int: ...
 @overload
 def f(**kwargs: str) -> str: ...
 def f(*args, **kwargs): pass
 
-# Checking an overload flagged as unsafe is a bit weird, but this is the
-# cleanest way to make sure 'Any' ambiguity checks work correctly with
-# keyword arguments.
 a: Any
 i: int
 reveal_type(f(x=a, y=i))  # N: Revealed type is "builtins.int"
@@ -2150,8 +2163,9 @@ from wrapper import *
 [file wrapper.pyi]
 from typing import overload
 
+# Safety of this highly depends on the implementation, so we lean towards being silent.
 @overload
-def foo1(*x: int) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(*x: int) -> int: ...
 @overload
 def foo1(x: int, y: int, z: int) -> str: ...
 
@@ -2160,8 +2174,9 @@ def foo2(*x: int) -> int: ...
 @overload
 def foo2(x: int, y: str, z: int) -> str: ...
 
+# Note: this is technically unsafe, but we don't report this for now.
 @overload
-def bar1(x: int, y: int, z: int) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def bar1(x: int, y: int, z: int) -> str: ...
 @overload
 def bar1(*x: int) -> int: ...
 
@@ -2172,43 +2187,70 @@ def bar2(*x: int) -> int: ...
 [builtins fixtures/tuple.pyi]
 
 [case testOverloadDetectsPossibleMatchesWithGenerics]
-from typing import overload, TypeVar, Generic
+# flags: --strict-optional
+from typing import overload, TypeVar, Generic, Optional, List
 
 T = TypeVar('T')
+# The examples below are unsafe, but it is a quite common pattern
+# so we ignore the possibility of type variables taking value `None`
+# for the purpose of overload overlap checks.
 
 @overload
-def foo(x: None, y: None) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo(x: None, y: None) -> str: ...
 @overload
 def foo(x: T, y: T) -> int: ...
 def foo(x): ...
 
+oi: Optional[int]
+reveal_type(foo(None, None))  # N: Revealed type is "builtins.str"
+reveal_type(foo(None, 42))  # N: Revealed type is "builtins.int"
+reveal_type(foo(42, 42))  # N: Revealed type is "builtins.int"
+reveal_type(foo(oi, None))  # N: Revealed type is "Union[builtins.int, builtins.str]"
+reveal_type(foo(oi, 42))  # N: Revealed type is "builtins.int"
+reveal_type(foo(oi, oi))  # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+@overload
+def foo_list(x: None) -> None: ...
+@overload
+def foo_list(x: T) -> List[T]: ...
+def foo_list(x): ...
+
+reveal_type(foo_list(oi))  # N: Revealed type is "Union[builtins.list[builtins.int], None]"
+
 # What if 'T' is 'object'?
 @overload
-def bar(x: None, y: int) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def bar(x: None, y: int) -> str: ...
 @overload
 def bar(x: T, y: T) -> int: ...
 def bar(x, y): ...
 
 class Wrapper(Generic[T]):
     @overload
-    def foo(self, x: None, y: None) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def foo(self, x: None, y: None) -> str: ...
     @overload
     def foo(self, x: T, y: None) -> int: ...
     def foo(self, x): ...
 
     @overload
-    def bar(self, x: None, y: int) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def bar(self, x: None, y: int) -> str: ...
     @overload
     def bar(self, x: T, y: T) -> int: ...
     def bar(self, x, y): ...
 
+@overload
+def baz(x: str, y: str) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+@overload
+def baz(x: T, y: T) -> int: ...
+def baz(x): ...
+[builtins fixtures/tuple.pyi]
+
 [case testOverloadFlagsPossibleMatches]
 from wrapper import *
 [file wrapper.pyi]
 from typing import overload
 
 @overload
-def foo1(x: str) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(x: str) -> str: ...
 @overload
 def foo1(x: str, y: str = ...) -> int: ...
 
@@ -2228,12 +2270,12 @@ from wrapper import *
 from typing import overload
 
 @overload
-def foo1(*args: int) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(*args: int) -> int: ...
 @overload
 def foo1(**kwargs: int) -> str: ...
 
 @overload
-def foo2(**kwargs: int) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo2(**kwargs: int) -> str: ...
 @overload
 def foo2(*args: int) -> int: ...
 [builtins fixtures/dict.pyi]
@@ -2274,13 +2316,14 @@ def foo2(x: int, *args: int) -> str: ...
 @overload
 def foo2(*args2: str) -> int: ...
 
+# The two examples are unsafe, but this is hard to detect.
 @overload
-def foo3(*args: int) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo3(*args: int) -> int: ...
 @overload
 def foo3(x: int, *args2: int) -> str: ...
 
 @overload
-def foo4(x: int, *args: int) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo4(x: int, *args: int) -> str: ...
 @overload
 def foo4(*args2: int) -> int: ...
 [builtins fixtures/tuple.pyi]
@@ -2317,13 +2360,13 @@ def foo4(x: Other = ..., *args: str) -> int: ...
 from typing import overload
 
 @overload
-def foo1(x: int = 0, y: int = 0) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(x: int = 0, y: int = 0) -> int: ...
 @overload
 def foo1(*xs: int) -> str: ...
 def foo1(*args): pass
 
 @overload
-def foo2(*xs: int) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo2(*xs: int) -> str: ...
 @overload
 def foo2(x: int = 0, y: int = 0) -> int: ...
 def foo2(*args): pass
@@ -2372,12 +2415,12 @@ from wrapper import *
 from typing import overload
 
 @overload
-def foo1(x: str, y: str = ..., z: str = ...) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(x: str, y: str = ..., z: str = ...) -> str: ...
 @overload
 def foo1(*x: str) -> int: ...
 
 @overload
-def foo2(*x: str) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo2(*x: str) -> int: ...
 @overload
 def foo2(x: str, y: str = ..., z: str = ...) -> str: ...
 
@@ -2393,12 +2436,12 @@ from wrapper import *
 from typing import overload
 
 @overload
-def foo1(x: str, y: str = ..., z: int = ...) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(x: str, y: str = ..., z: int = ...) -> str: ...
 @overload
 def foo1(*x: str) -> int: ...
 
 @overload
-def foo2(x: str, y: str = ..., z: int = ...) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo2(x: str, y: str = ..., z: int = ...) -> str: ...
 @overload
 def foo2(*x: str) -> int: ...
 [builtins fixtures/tuple.pyi]
@@ -2409,7 +2452,7 @@ from wrapper import *
 from typing import overload
 
 @overload
-def foo1(*, x: str, y: str, z: str) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(*, x: str, y: str, z: str) -> str: ...
 @overload
 def foo1(**x: str) -> int: ...
 
@@ -2441,12 +2484,12 @@ def foo2(**x: str) -> int: ...
 def foo2(*, x: str, y: str, z: int) -> str: ...
 
 @overload
-def foo3(*, x: str, y: str, z: int = ...) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo3(*, x: str, y: str, z: int = ...) -> str: ...
 @overload
 def foo3(**x: str) -> int: ...
 
 @overload
-def foo4(**x: str) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo4(**x: str) -> int: ...
 @overload
 def foo4(*, x: str, y: str, z: int = ...) -> str: ...
 [builtins fixtures/dict.pyi]
@@ -2457,12 +2500,13 @@ from wrapper import *
 from typing import overload
 
 @overload
-def foo1(x: str, *, y: str, z: str) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo1(x: str, *, y: str, z: str) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \
+                                                 # N: Flipping the order of overloads will fix this error
 @overload
 def foo1(**x: str) -> int: ...
 
 @overload
-def foo2(**x: str) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def foo2(**x: str) -> int: ...
 @overload
 def foo2(x: str, *, y: str, z: str) -> str: ...
 
@@ -2647,8 +2691,7 @@ reveal_type(f(**{'a': 4, 'b': 4, 'c': 4}))   # N: Revealed type is "builtins.tup
 [builtins fixtures/dict.pyi]
 
 [case testOverloadKwargsSelectionWithTypedDict]
-from typing import overload, Tuple
-from typing_extensions import TypedDict
+from typing import overload, Tuple, TypedDict
 @overload
 def f(*, x: int) -> Tuple[int]: ...
 @overload
@@ -2669,6 +2712,7 @@ reveal_type(f(**a))  # N: Revealed type is "Tuple[builtins.int]"
 reveal_type(f(**b))  # N: Revealed type is "Tuple[builtins.int, builtins.int]"
 reveal_type(f(**c))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testOverloadVarargsAndKwargsSelection]
 from typing import overload, Any, Tuple, Dict
@@ -2758,7 +2802,8 @@ def h(x: List[Union[C, D]]) -> str: ...
 def h(x): ...
 
 @overload
-def i(x: List[Union[A, B]]) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def i(x: List[Union[A, B]]) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \
+                                         # N: Flipping the order of overloads will fix this error
 @overload
 def i(x: List[Union[A, B, C]]) -> str: ...
 def i(x): ...
@@ -2770,8 +2815,9 @@ from typing import TypeVar, overload
 
 T = TypeVar('T')
 
+# Note: this is unsafe, but it is hard to detect.
 @overload
-def f(x: int) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f(x: int) -> str: ...
 @overload
 def f(x: T) -> T: ...
 def f(x): ...
@@ -2787,14 +2833,15 @@ from typing import TypeVar, overload, List
 
 T = TypeVar('T')
 
+# Note: first two examples are unsafe, but it is hard to detect.
 @overload
-def f1(x: List[int]) -> str: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f1(x: List[int]) -> str: ...
 @overload
 def f1(x: List[T]) -> T: ...
 def f1(x): ...
 
 @overload
-def f2(x: List[int]) -> List[str]: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f2(x: List[int]) -> List[str]: ...
 @overload
 def f2(x: List[T]) -> List[T]: ...
 def f2(x): ...
@@ -2819,17 +2866,15 @@ from typing import TypeVar, overload, Generic
 T = TypeVar('T')
 
 class Wrapper(Generic[T]):
+    # Similar to above: this is unsafe, but it is hard to detect.
     @overload
-    def f(self, x: int) -> str: ...   # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def f(self, x: int) -> str: ...
     @overload
     def f(self, x: T) -> T: ...
     def f(self, x): ...
 
-    # TODO: This shouldn't trigger an error message?
-    # Related to testTypeCheckOverloadImplementationTypeVarDifferingUsage2?
-    # See https://github.com/python/mypy/issues/5510
     @overload
-    def g(self, x: int) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def g(self, x: int) -> int: ...
     @overload
     def g(self, x: T) -> T: ...
     def g(self, x): ...
@@ -2840,28 +2885,27 @@ from typing import TypeVar, overload, Generic, List
 T = TypeVar('T')
 
 class Wrapper(Generic[T]):
+    # Similar to above: first two examples are unsafe, but it is hard to detect.
     @overload
-    def f1(self, x: List[int]) -> str: ...   # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def f1(self, x: List[int]) -> str: ...
     @overload
     def f1(self, x: List[T]) -> T: ...
     def f1(self, x): ...
 
     @overload
-    def f2(self, x: List[int]) -> List[str]: ...   # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def f2(self, x: List[int]) -> List[str]: ...
     @overload
     def f2(self, x: List[T]) -> List[T]: ...
     def f2(self, x): ...
 
-    # TODO: This shouldn't trigger an error message?
-    # See https://github.com/python/mypy/issues/5510
     @overload
-    def g1(self, x: List[int]) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def g1(self, x: List[int]) -> int: ...
     @overload
     def g1(self, x: List[T]) -> T: ...
     def g1(self, x): ...
 
     @overload
-    def g2(self, x: List[int]) -> List[int]: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def g2(self, x: List[int]) -> List[int]: ...
     @overload
     def g2(self, x: List[T]) -> List[T]: ...
     def g2(self, x): ...
@@ -2869,8 +2913,7 @@ class Wrapper(Generic[T]):
 [builtins fixtures/list.pyi]
 
 [case testOverloadTypedDictDifferentRequiredKeysMeansDictsAreDisjoint]
-from typing import overload
-from mypy_extensions import TypedDict
+from typing import TypedDict, overload
 
 A = TypedDict('A', {'x': int, 'y': int})
 B = TypedDict('B', {'x': int, 'y': str})
@@ -2881,10 +2924,10 @@ def f(x: A) -> int: ...
 def f(x: B) -> str: ...
 def f(x): pass
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testOverloadedTypedDictPartiallyOverlappingRequiredKeys]
-from typing import overload, Union
-from mypy_extensions import TypedDict
+from typing import overload, TypedDict, Union
 
 A = TypedDict('A', {'x': int, 'y': Union[int, str]})
 B = TypedDict('B', {'x': int, 'y': Union[str, float]})
@@ -2901,10 +2944,10 @@ def g(x: A) -> int: ...
 def g(x: B) -> object: ...
 def g(x): pass
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testOverloadedTypedDictFullyNonTotalDictsAreAlwaysPartiallyOverlapping]
-from typing import overload
-from mypy_extensions import TypedDict
+from typing import TypedDict, overload
 
 A = TypedDict('A', {'x': int, 'y': str}, total=False)
 B = TypedDict('B', {'a': bool}, total=False)
@@ -2922,10 +2965,10 @@ def g(x: A) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap wit
 def g(x: C) -> str: ...
 def g(x): pass
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testOverloadedTotalAndNonTotalTypedDictsCanPartiallyOverlap]
-from typing import overload, Union
-from mypy_extensions import TypedDict
+from typing import overload, TypedDict, Union
 
 A = TypedDict('A', {'x': int, 'y': str})
 B = TypedDict('B', {'x': Union[int, str], 'y': str, 'z': int}, total=False)
@@ -2943,10 +2986,10 @@ def f2(x: A) -> str: ...
 def f2(x): pass
 
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testOverloadedTypedDictsWithSomeOptionalKeysArePartiallyOverlapping]
-from typing import overload, Union
-from mypy_extensions import TypedDict
+from typing import overload, TypedDict, Union
 
 class A(TypedDict):
     x: int
@@ -2965,6 +3008,7 @@ def f(x: C) -> str: ...
 def f(x): pass
 
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testOverloadedPartiallyOverlappingInheritedTypes1]
 from typing import overload, List, Union, TypeVar, Generic
@@ -3038,13 +3082,14 @@ class C: pass
 S = TypeVar('S', A, B)
 
 @overload
-def f(x: S) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f(x: S) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types \
+                         # N: Flipping the order of overloads will fix this error
 @overload
 def f(x: Union[B, C]) -> str: ...
 def f(x): pass
 
 @overload
-def g(x: Union[B, C]) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def g(x: Union[B, C]) -> int: ...
 @overload
 def g(x: S) -> str: ...
 def g(x): pass
@@ -3251,7 +3296,6 @@ f(x, B())  # E: Argument 1 to "f" has incompatible type "Union[A, B]"; expected
 [builtins fixtures/tuple.pyi]
 
 [case testOverloadInferUnionWithMixOfPositionalAndOptionalArgs]
-# flags: --strict-optional
 from typing import overload, Union, Optional
 
 class A: ...
@@ -3358,11 +3402,11 @@ def wrapper() -> None:
 
     # Note: These should be fine, but mypy has an unrelated bug
     #       that makes them error out?
-    a2_overload: A = SomeType().foo(obj1)  # E: Argument 1 to "foo" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "W1[<nothing>]"
-    a2_union: A    = SomeType().bar(obj1)  # E: Argument 1 to "bar" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "Union[W1[<nothing>], W2[<nothing>]]"
+    a2_overload: A = SomeType().foo(obj1)  # E: Argument 1 to "foo" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "W1[Never]"
+    a2_union: A    = SomeType().bar(obj1)  # E: Argument 1 to "bar" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "Union[W1[Never], W2[Never]]"
 
-    SomeType().foo(obj1)  # E: Argument 1 to "foo" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "W1[<nothing>]"
-    SomeType().bar(obj1)  # E: Argument 1 to "bar" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "Union[W1[<nothing>], W2[<nothing>]]"
+    SomeType().foo(obj1)  # E: Argument 1 to "foo" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "W1[Never]"
+    SomeType().bar(obj1)  # E: Argument 1 to "bar" of "SomeType" has incompatible type "Union[W1[A], W2[A]]"; expected "Union[W1[Never], W2[Never]]"
 
 [case testOverloadingInferUnionReturnWithBadObjectTypevarReturn]
 from typing import overload, Union, TypeVar, Generic
@@ -3386,8 +3430,8 @@ class SomeType(Generic[T]):
 def wrapper(mysterious: T) -> T:
     obj1: Union[W1[A], W2[B]]
 
-    SomeType().foo(obj1)  # E: Argument 1 to "foo" of "SomeType" has incompatible type "Union[W1[A], W2[B]]"; expected "W1[<nothing>]"
-    SomeType().bar(obj1)  # E: Argument 1 to "bar" of "SomeType" has incompatible type "Union[W1[A], W2[B]]"; expected "Union[W1[<nothing>], W2[<nothing>]]"
+    SomeType().foo(obj1)  # E: Argument 1 to "foo" of "SomeType" has incompatible type "Union[W1[A], W2[B]]"; expected "W1[Never]"
+    SomeType().bar(obj1)  # E: Argument 1 to "bar" of "SomeType" has incompatible type "Union[W1[A], W2[B]]"; expected "Union[W1[Never], W2[Never]]"
 
     SomeType[A]().foo(obj1)  # E: Argument 1 to "foo" of "SomeType" has incompatible type "Union[W1[A], W2[B]]"; expected "W1[A]"
     SomeType[A]().bar(obj1)  # E: Argument 1 to "bar" of "SomeType" has incompatible type "Union[W1[A], W2[B]]"; expected "Union[W1[A], W2[A]]"
@@ -3568,7 +3612,7 @@ def test(x: T) -> T:
 from typing import overload, Optional
 
 @overload
-def f(x: None) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f(x: None) -> int: ...
 @overload
 def f(x: object) -> str: ...
 def f(x): ...
@@ -3590,11 +3634,10 @@ reveal_type(g(b))  # N: Revealed type is "builtins.str"
 reveal_type(g(c))  # N: Revealed type is "builtins.str"
 
 [case testOverloadsAndNoneWithStrictOptional]
-# flags: --strict-optional
 from typing import overload, Optional
 
 @overload
-def f(x: None) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f(x: None) -> int: ...
 @overload
 def f(x: object) -> str: ...
 def f(x): ...
@@ -3638,7 +3681,6 @@ reveal_type(mymap(f3, seq))  # N: Revealed type is "typing.Iterable[builtins.str
 [typing fixtures/typing-medium.pyi]
 
 [case testOverloadsNoneAndTypeVarsWithStrictOptional]
-# flags: --strict-optional
 from typing import Callable, Iterable, TypeVar, overload, Optional
 
 T = TypeVar('T')
@@ -3695,7 +3737,6 @@ def test_narrow_int() -> None:
 [typing fixtures/typing-medium.pyi]
 
 [case testOverloadsAndNoReturnNarrowTypeWithStrictOptional1]
-# flags: --strict-optional
 from typing import overload, Union, NoReturn
 
 @overload
@@ -3759,7 +3800,6 @@ def test_narrow_none() -> None:
 [typing fixtures/typing-medium.pyi]
 
 [case testOverloadsAndNoReturnNarrowTypeWithStrictOptional2]
-# flags: --strict-optional
 from typing import overload, Union, TypeVar, NoReturn, Optional
 
 T = TypeVar('T')
@@ -3823,7 +3863,6 @@ def test_narrow_none_v2() -> None:
 [typing fixtures/typing-medium.pyi]
 
 [case testOverloadsAndNoReturnNarrowTypeWithStrictOptional3]
-# flags: --strict-optional
 from typing import overload, TypeVar, NoReturn, Optional
 
 @overload
@@ -3944,7 +3983,7 @@ from typing import overload, Any, Optional, Union
 
 class FakeAttribute:
     @overload
-    def dummy(self, instance: None, owner: Any) -> 'FakeAttribute': ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def dummy(self, instance: None, owner: Any) -> 'FakeAttribute': ...
     @overload
     def dummy(self, instance: object, owner: Any) -> int: ...
     def dummy(self, instance: Optional[object], owner: Any) -> Union['FakeAttribute', int]: ...
@@ -3989,7 +4028,7 @@ T = TypeVar('T')
 
 class FakeAttribute(Generic[T]):
     @overload
-    def dummy(self, instance: None, owner: Type[T]) -> 'FakeAttribute[T]': ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def dummy(self, instance: None, owner: Type[T]) -> 'FakeAttribute[T]': ...
     @overload
     def dummy(self, instance: T, owner: Type[T]) -> int: ...
     def dummy(self, instance: Optional[T], owner: Type[T]) -> Union['FakeAttribute[T]', int]: ...
@@ -4508,6 +4547,23 @@ reveal_type(Child().foo("..."))               # N: Revealed type is "builtins.st
 reveal_type(Child().foo(x))                   # N: Revealed type is "Union[__main__.Child, builtins.str]"
 reveal_type(Child().foo(3).child_only())      # N: Revealed type is "builtins.int"
 
+[case testOverloadAndSelfTypesGenericNoOverlap]
+from typing import Generic, TypeVar, Any, overload, Self, Union
+
+T = TypeVar("T")
+class C(Generic[T]):
+    @overload
+    def get(self, obj: None) -> Self: ...
+    @overload
+    def get(self, obj: Any) -> T: ...
+    def get(self, obj: Union[Any, None]) -> Union[T, Self]:
+        return self
+
+class D(C[int]): ...
+d: D
+reveal_type(d.get(None))  # N: Revealed type is "__main__.D"
+reveal_type(d.get("whatever"))  # N: Revealed type is "builtins.int"
+
 [case testOverloadAndClassTypes]
 from typing import overload, Union, TypeVar, Type
 
@@ -4635,7 +4691,6 @@ def none_second(x: int) -> int:
     return x
 
 [case testOverloadsWithNoneComingSecondIsOkInStrictOptional]
-# flags: --strict-optional
 from typing import overload, Optional
 
 @overload
@@ -4659,8 +4714,8 @@ def none_loose_impl(x: int) -> int: ...
 def none_loose_impl(x: int) -> int:
     return x
 [out]
-main:22: error: Overloaded function implementation does not accept all possible arguments of signature 1
-main:22: error: Overloaded function implementation cannot produce return type of signature 1
+main:21: error: Overloaded function implementation does not accept all possible arguments of signature 1
+main:21: error: Overloaded function implementation cannot produce return type of signature 1
 
 [case testTooManyUnionsException]
 from typing import overload, Union
@@ -4745,7 +4800,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]
@@ -4853,7 +4908,7 @@ T = TypeVar('T')
 
 def f() -> None:
     @overload
-    def g(x: str) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+    def g(x: str) -> int: ...
     @overload
     def g(x: T) -> T: ...
     def g(x):
@@ -4894,7 +4949,7 @@ x: Any
 reveal_type(attr(x)) # N: Revealed type is "Any"
 attr("hi", 1)  # E: No overload variant of "attr" matches argument types "str", "int" \
                # N: Possible overload variants: \
-               # N:     def [T in (int, float)] attr(default: T = ..., blah: int = ...) -> T \
+               # N:     def [T: (int, float)] attr(default: T, blah: int = ...) -> T \
                # N:     def attr(default: Any = ...) -> int
 [file lib.pyi]
 from typing import overload, Any, TypeVar
@@ -4902,7 +4957,7 @@ from typing import overload, Any, TypeVar
 T = TypeVar('T', int, float)
 
 @overload
-def attr(default: T = ..., blah: int = ...) -> T: ...
+def attr(default: T, blah: int = ...) -> T: ...
 @overload
 def attr(default: Any = ...) -> int: ...
 [out]
@@ -4917,7 +4972,7 @@ x: Any
 reveal_type(attr(x)) # N: Revealed type is "Any"
 attr("hi", 1)  # E: No overload variant of "attr" matches argument types "str", "int" \
                # N: Possible overload variants: \
-               # N:     def [T <: int] attr(default: T = ..., blah: int = ...) -> T \
+               # N:     def [T: int] attr(default: T = ..., blah: int = ...) -> T \
                # N:     def attr(default: Any = ...) -> int
 [file lib.pyi]
 from typing import overload, TypeVar, Any
@@ -4958,7 +5013,7 @@ children: List[Child]
 parents: List[Parent]
 
 @overload
-def f(x: Child) -> List[Child]: pass    # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f(x: Child) -> List[Child]: pass
 @overload
 def f(x: Parent) -> List[Parent]: pass
 def f(x: Union[Child, Parent]) -> Union[List[Child], List[Parent]]:
@@ -5212,8 +5267,7 @@ tmp/lib.pyi:3: error: Name "overload" is not defined
 main:3: note: Revealed type is "Any"
 
 [case testLiteralSubtypeOverlap]
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 class MyInt(int): ...
 
@@ -5269,7 +5323,7 @@ def f1(g: G[A, B]) -> B: ...
 def f1(g: Any) -> Any: ...
 
 @overload
-def f2(g: G[A, Any]) -> A: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def f2(g: G[A, Any]) -> A: ...
 @overload
 def f2(g: G[A, B], x: int = ...) -> B: ...
 def f2(g: Any, x: int = ...) -> Any: ...
@@ -5405,26 +5459,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 +5785,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 +5805,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 +5825,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 +5841,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 +5872,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 +5883,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 +5893,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 +5912,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 +5935,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 +5957,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 +5974,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 +5990,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 +6000,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 +6243,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 +6262,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 +6283,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 +6307,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]
@@ -6405,8 +6462,8 @@ class D: ...
 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 \
+    def f1(g: B) -> B: ...  # E: Incompatible redefinition (redefinition with type "Callable[[B], B]", original type "Callable[[A], A]")
+    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: ...
@@ -6422,17 +6479,17 @@ if True:
         def f2(g: B) -> B: ...
     elif maybe_true:  # E: Name "maybe_true" is not defined
         @overload  # E: Single overload definition, multiple required
-        def f2(g: C) -> C: ...
+        def f2(g: C) -> C: ...  # E: Incompatible redefinition (redefinition with type "Callable[[C], C]", original type "Callable[[A], A]")
 def f2(g): ...  # E: Name "f2" already defined on line 21
 
 @overload  # E: Single overload definition, multiple required
 def f3(g: A) -> A: ...
 if True:
     @overload  # E: Single overload definition, multiple required
-    def f3(g: B) -> B: ...
+    def f3(g: B) -> B: ...  # E: Incompatible redefinition (redefinition with type "Callable[[B], B]", original type "Callable[[A], A]")
     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
@@ -6447,7 +6504,7 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 @overload
-def func(x: Callable[Concatenate[Any, P], R]) -> Callable[P, R]: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def func(x: Callable[Concatenate[Any, P], R]) -> Callable[P, R]: ...
 @overload
 def func(x: Callable[P, R]) -> Callable[Concatenate[str, P], R]: ...
 def func(x: Callable[..., R]) -> Callable[..., R]: ...
@@ -6465,8 +6522,7 @@ eggs = lambda: 'eggs'
 reveal_type(func(eggs))  # N: Revealed type is "def (builtins.str) -> builtins.str"
 
 spam: Callable[..., str] = lambda x, y: 'baz'
-reveal_type(func(spam))  # N: Revealed type is "def (*Any, **Any) -> builtins.str"
-
+reveal_type(func(spam))  # N: Revealed type is "def (*Any, **Any) -> Any"
 [builtins fixtures/paramspec.pyi]
 
 [case testGenericOverloadOverlapWithType]
@@ -6545,3 +6601,169 @@ class Snafu(object):
 reveal_type(Snafu().snafu('123'))  # N: Revealed type is "builtins.str"
 reveal_type(Snafu.snafu('123'))  # N: Revealed type is "builtins.str"
 [builtins fixtures/staticmethod.pyi]
+
+[case testOverloadedWithInternalTypeVars]
+# flags: --new-type-inference
+import m
+
+[file m.pyi]
+from typing import Callable, TypeVar, overload
+
+T = TypeVar("T")
+S = TypeVar("S", bound=str)
+
+@overload
+def foo(x: int = ...) -> Callable[[T], T]: ...
+@overload
+def foo(x: S = ...) -> Callable[[T], T]: ...
+
+[case testOverloadGenericStarArgOverlap]
+from typing import Any, Callable, TypeVar, overload, Union, Tuple, List
+
+F = TypeVar("F", bound=Callable[..., Any])
+S = TypeVar("S", bound=int)
+
+def id(f: F) -> F: ...
+
+@overload
+def struct(*cols: S) -> int: ...
+@overload
+def struct(__cols: Union[List[S], Tuple[S, ...]]) -> int: ...
+@id
+def struct(*cols: Union[S, Union[List[S], Tuple[S, ...]]]) -> int:
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testRegularGenericDecoratorOverload]
+from typing import Callable, overload, TypeVar, List
+
+S = TypeVar("S")
+T = TypeVar("T")
+def transform(func: Callable[[S], List[T]]) -> Callable[[S], T]: ...
+
+@overload
+def foo(x: int) -> List[float]: ...
+@overload
+def foo(x: str) -> List[str]: ...
+def foo(x): ...
+
+reveal_type(transform(foo))  # N: Revealed type is "Overload(def (builtins.int) -> builtins.float, def (builtins.str) -> builtins.str)"
+
+@transform
+@overload
+def bar(x: int) -> List[float]: ...
+@transform
+@overload
+def bar(x: str) -> List[str]: ...
+@transform
+def bar(x): ...
+
+reveal_type(bar)  # N: Revealed type is "Overload(def (builtins.int) -> builtins.float, def (builtins.str) -> builtins.str)"
+[builtins fixtures/paramspec.pyi]
+
+[case testOverloadOverlapWithNameOnlyArgs]
+from typing import overload
+
+@overload
+def d(x: int) -> int: ...
+@overload
+def d(f: int, *, x: int) -> str: ...
+def d(*args, **kwargs): ...
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadCallableGenericSelf]
+from typing import Any, TypeVar, Generic, overload, reveal_type
+
+T = TypeVar("T")
+
+class MyCallable(Generic[T]):
+    def __init__(self, t: T):
+        self.t = t
+
+    @overload
+    def __call__(self: "MyCallable[int]") -> str: ...
+    @overload
+    def __call__(self: "MyCallable[str]") -> int: ...
+    def __call__(self): ...
+
+c = MyCallable(5)
+reveal_type(c)  # N: Revealed type is "__main__.MyCallable[builtins.int]"
+reveal_type(c())  # N: Revealed type is "builtins.str"
+
+c2 = MyCallable("test")
+reveal_type(c2)  # N: Revealed type is "__main__.MyCallable[builtins.str]"
+reveal_type(c2()) # should be int  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadWithStarAnyFallback]
+from typing import overload, Any
+
+class A:
+    @overload
+    def f(self, e: str) -> str: ...
+    @overload
+    def f(self, *args: Any, **kwargs: Any) -> Any: ...
+    def f(self, *args, **kwargs):
+        pass
+
+class B:
+    @overload
+    def f(self, e: str, **kwargs: Any) -> str: ...
+    @overload
+    def f(self, *args: Any, **kwargs: Any) -> Any: ...
+    def f(self, *args, **kwargs):
+        pass
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadsSafeOverlapAllowed]
+from lib import *
+[file lib.pyi]
+from typing import overload
+
+@overload
+def bar(x: object) -> object: ...
+@overload
+def bar(x: int = ...) -> int: ...
+
+[case testOverloadsInvariantOverlapAllowed]
+from lib import *
+[file lib.pyi]
+from typing import overload, List
+
+@overload
+def bar(x: List[int]) -> List[int]: ...
+@overload
+def bar(x: List[object]) -> List[object]: ...
+
+[case testOverloadsNoneAnyOverlapAllowed]
+from lib import *
+[file lib.pyi]
+from typing import overload, Any
+
+@overload
+def foo(x: None) -> int: ...
+@overload
+def foo(x: object) -> str: ...
+
+@overload
+def bar(x: int) -> int: ...
+@overload
+def bar(x: Any) -> str: ...
+
+[case testOverloadOnInvalidTypeArgument]
+from typing import TypeVar, Self, Generic, overload
+
+class C: pass
+
+T = TypeVar("T", bound=C)
+
+class D(Generic[T]):
+    @overload
+    def f(self, x: int) -> int: ...
+    @overload
+    def f(self, x: str) -> str: ...
+    def f(Self, x): ...
+
+a: D[str]  # E: Type argument "str" of "D" must be a subtype of "C"
+reveal_type(a.f(1))  # N: Revealed type is "builtins.int"
+reveal_type(a.f("x"))  # N: Revealed type is "builtins.str"
diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
index 901e73008d56..6f01b15e11f6 100644
--- a/test-data/unit/check-parameter-specification.test
+++ b/test-data/unit/check-parameter-specification.test
@@ -14,7 +14,7 @@ P5 = ParamSpec("P5", covariant=True, bound=int)  # E: The variance and bound arg
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecLocations]
-from typing import Callable, List
+from typing import Any, Callable, List, Type
 from typing_extensions import ParamSpec, Concatenate
 P = ParamSpec('P')
 
@@ -23,19 +23,106 @@ x: P  # E: ParamSpec "P" is unbound
 def foo1(x: Callable[P, int]) -> Callable[P, str]:  ...
 
 def foo2(x: P) -> P: ...  # E: Invalid location for ParamSpec "P" \
-                          # N: You can use ParamSpec as the first argument to Callable, e.g., 'Callable[P, int]'
+                          # N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"
 
 def foo3(x: Concatenate[int, P]) -> int: ...  # E: Invalid location for Concatenate \
                                               # N: You can use Concatenate as the first argument to Callable
 
 def foo4(x: List[P]) -> None: ...  # E: Invalid location for ParamSpec "P" \
-                                   # N: You can use ParamSpec as the first argument to Callable, e.g., 'Callable[P, int]'
+                                   # N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"
 
 def foo5(x: Callable[[int, str], P]) -> None: ...  # E: Invalid location for ParamSpec "P" \
-                                                   # N: You can use ParamSpec as the first argument to Callable, e.g., 'Callable[P, int]'
+                                                   # N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"
 
 def foo6(x: Callable[[P], int]) -> None: ...  # E: Invalid location for ParamSpec "P" \
-                                              # N: You can use ParamSpec as the first argument to Callable, e.g., 'Callable[P, int]'
+                                              # N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"
+
+def foo7(
+    *args: P.args, **kwargs: P.kwargs  # E: ParamSpec "P" is unbound
+) -> Callable[[Callable[P, T]], Type[T]]:
+    ...
+
+def wrapper(f: Callable[P, int]) -> None:
+    def inner(*args: P.args, **kwargs: P.kwargs) -> None: ...  # OK
+
+    def extra_args_left(x: int, *args: P.args, **kwargs: P.kwargs) -> None: ...  # OK
+    def extra_args_between(*args: P.args, x: int, **kwargs: P.kwargs) -> None: ...  # E: Arguments not allowed after ParamSpec.args
+
+    def swapped(*args: P.kwargs, **kwargs: P.args) -> None: ... # E: Use "P.args" for variadic "*" parameter \
+                                                                # E: Use "P.kwargs" for variadic "**" parameter
+    def bad_kwargs(*args: P.args, **kwargs: P.args) -> None: ...  # E: Use "P.kwargs" for variadic "**" parameter
+    def bad_args(*args: P.kwargs, **kwargs: P.kwargs) -> None: ...  # E: Use "P.args" for variadic "*" parameter
+
+    def misplaced(x: P.args) -> None:  ...  # E: ParamSpec components are not allowed here
+    def bad_kwargs_any(*args: P.args, **kwargs: Any) -> None: ... # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecImports]
+import lib
+from lib import Base
+
+class C(Base[[int]]):
+    def test(self, x: int): ...
+
+class D(lib.Base[[int]]):
+    def test(self, x: int): ...
+
+class E(lib.Base[...]): ...
+reveal_type(E().test)  # N: Revealed type is "def (*Any, **Any)"
+
+[file lib.py]
+from typing import Generic
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+class Base(Generic[P]):
+    def test(self, *args: P.args, **kwargs: P.kwargs) -> None:
+        ...
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecEllipsisInAliases]
+from typing import Any, Callable, Generic, TypeVar
+from typing_extensions import ParamSpec
+
+P = ParamSpec('P')
+R = TypeVar('R')
+Alias = Callable[P, R]
+
+class B(Generic[P]): ...
+Other = B[P]
+
+T = TypeVar('T', bound=Alias[..., Any])
+Alias[..., Any]  # E: Type application is only supported for generic classes
+B[...]
+Other[...]
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecEllipsisInConcatenate]
+from typing import Any, Callable, Generic, TypeVar
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec('P')
+R = TypeVar('R')
+Alias = Callable[P, R]
+
+IntFun = Callable[Concatenate[int, ...], None]
+f: IntFun
+reveal_type(f)  # N: Revealed type is "def (builtins.int, *Any, **Any)"
+
+g: Callable[Concatenate[int, ...], None]
+reveal_type(g)  # N: Revealed type is "def (builtins.int, *Any, **Any)"
+
+class B(Generic[P]):
+    def test(self, *args: P.args, **kwargs: P.kwargs) -> None:
+        ...
+
+x: B[Concatenate[int, ...]]
+reveal_type(x.test)  # N: Revealed type is "def (builtins.int, *Any, **Any)"
+
+Bad = Callable[Concatenate[int, [int, str]], None]  # E: The last parameter to Concatenate needs to be a ParamSpec \
+                                                    # E: Bracketed expression "[...]" is not valid as a type
+def bad(fn: Callable[Concatenate[P, int], None]):  # E: The last parameter to Concatenate needs to be a ParamSpec
+    ...
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecContextManagerLike]
@@ -171,7 +258,6 @@ reveal_type(f(g, 1, y='x'))  # N: Revealed type is "None"
 f(g, 'x', y='x')  # E: Argument 2 to "f" has incompatible type "str"; expected "int"
 f(g, 1, y=1)  # E: Argument "y" to "f" has incompatible type "int"; expected "str"
 f(g)  # E: Missing positional arguments "x", "y" in call to "f"
-
 [builtins fixtures/dict.pyi]
 
 [case testParamSpecSpecialCase]
@@ -257,8 +343,9 @@ class C(Generic[P]):
         a = kwargs
         args = kwargs  # E: Incompatible types in assignment (expression has type "P.kwargs", variable has type "P.args")
         kwargs = args  # E: Incompatible types in assignment (expression has type "P.args", variable has type "P.kwargs")
-        args = a
-        kwargs = a
+        a1: Any
+        args = a1
+        kwargs = a1
 [builtins fixtures/dict.pyi]
 
 [case testParamSpecSubtypeChecking2]
@@ -347,14 +434,19 @@ P = ParamSpec('P')
 T = TypeVar('T')
 
 # Similar to atexit.register
-def register(f: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> Callable[P, T]: ...  # N: "register" defined here
+def register(f: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> Callable[P, T]: ...
 
 def f(x: int) -> None: pass
+def g(x: int, y: str) -> None: pass
 
 reveal_type(register(lambda: f(1)))  # N: Revealed type is "def ()"
-reveal_type(register(lambda x: f(x), x=1))  # N: Revealed type is "def (x: Any)"
-register(lambda x: f(x))  # E: Missing positional argument "x" in call to "register"
-register(lambda x: f(x), y=1)  # E: Unexpected keyword argument "y" for "register"
+reveal_type(register(lambda x: f(x), x=1))  # N: Revealed type is "def (x: Literal[1]?)"
+register(lambda x: f(x))  # E: Cannot infer type of lambda \
+                          # E: Argument 1 to "register" has incompatible type "Callable[[Any], None]"; expected "Callable[[], None]"
+register(lambda x: f(x), y=1)  # E: Argument 1 to "register" has incompatible type "Callable[[Arg(int, 'x')], None]"; expected "Callable[[Arg(int, 'y')], None]"
+reveal_type(register(lambda x: f(x), 1))  # N: Revealed type is "def (Literal[1]?)"
+reveal_type(register(lambda x, y: g(x, y), 1, "a"))  # N: Revealed type is "def (Literal[1]?, Literal['a']?)"
+reveal_type(register(lambda x, y: g(x, y), 1, y="a"))  # N: Revealed type is "def (Literal[1]?, y: Literal['a']?)"
 [builtins fixtures/dict.pyi]
 
 [case testParamSpecInvalidCalls]
@@ -570,7 +662,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: --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
@@ -592,14 +684,10 @@ 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
 
 [case testNonStrictParamSpecConcatenateNamedArgs]
-# flags: --python-version 3.8
-
 # 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
@@ -620,9 +708,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
@@ -643,8 +728,6 @@ reveal_type(n(42))  # N: Revealed type is "None"
 [builtins fixtures/paramspec.pyi]
 
 [case testCallablesAsParameters]
-# flags: --python-version 3.8
-
 # credits to https://github.com/microsoft/pyright/issues/2705
 from typing_extensions import ParamSpec, Concatenate
 from typing import Generic, Callable, Any
@@ -662,9 +745,7 @@ 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]]"
+main:14: note: Revealed type is "__main__.Foo[[builtins.int, b: builtins.str]]"
 
 [case testSolveParamSpecWithSelfType]
 from typing_extensions import ParamSpec, Concatenate
@@ -840,16 +921,15 @@ class A:
     def func(self, action: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs) -> _R:
         ...
 
-reveal_type(A.func)  # N: Revealed type is "def [_P, _R] (self: __main__.A, action: def (*_P.args, **_P.kwargs) -> _R`-2, *_P.args, **_P.kwargs) -> _R`-2"
-reveal_type(A().func)  # N: Revealed type is "def [_P, _R] (action: def (*_P.args, **_P.kwargs) -> _R`5, *_P.args, **_P.kwargs) -> _R`5"
+reveal_type(A.func)  # N: Revealed type is "def [_P, _R] (self: __main__.A, action: def (*_P.args, **_P.kwargs) -> _R`6, *_P.args, **_P.kwargs) -> _R`6"
+reveal_type(A().func)  # N: Revealed type is "def [_P, _R] (action: def (*_P.args, **_P.kwargs) -> _R`10, *_P.args, **_P.kwargs) -> _R`10"
 
 def f(x: int) -> int:
     ...
 
 reveal_type(A().func(f, 42))  # N: Revealed type is "builtins.int"
 
-# TODO: this should reveal `int`
-reveal_type(A().func(lambda x: x + x, 42))  # N: Revealed type is "Any"
+reveal_type(A().func(lambda x: x + x, 42))  # N: Revealed type is "builtins.int"
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecConstraintOnOtherParamSpec]
@@ -873,8 +953,8 @@ class A:
     def func(self, action: Job[_P, None]) -> Job[_P, None]:
         ...
 
-reveal_type(A.func)  # N: Revealed type is "def [_P] (self: __main__.A, action: __main__.Job[_P`-1, None]) -> __main__.Job[_P`-1, None]"
-reveal_type(A().func)  # N: Revealed type is "def [_P] (action: __main__.Job[_P`3, None]) -> __main__.Job[_P`3, None]"
+reveal_type(A.func)  # N: Revealed type is "def [_P] (self: __main__.A, action: __main__.Job[_P`4, None]) -> __main__.Job[_P`4, None]"
+reveal_type(A().func)  # N: Revealed type is "def [_P] (action: __main__.Job[_P`6, None]) -> __main__.Job[_P`6, None]"
 reveal_type(A().func(Job(lambda x: x)))  # N: Revealed type is "__main__.Job[[x: Any], None]"
 
 def f(x: int, y: int) -> None: ...
@@ -1036,10 +1116,32 @@ j = Job(generic_f)
 reveal_type(j)  # N: Revealed type is "__main__.Job[[x: _T`-1]]"
 
 jf = j.into_callable()
-reveal_type(jf)  # N: Revealed type is "def [_T] (x: _T`-1)"
+reveal_type(jf)  # N: Revealed type is "def [_T] (x: _T`4)"
 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`3], _T`3]"
+
+jf = j.into_callable()
+reveal_type(jf)  # N: Revealed type is "def [_T] (x: _T`4) -> _T`4"
+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
@@ -1111,7 +1213,7 @@ def func(callback: Callable[P, str]) -> Callable[P, str]:
     return inner
 [builtins fixtures/paramspec.pyi]
 
-[case testParamSpecArgsAndKwargsMissmatch]
+[case testParamSpecArgsAndKwargsMismatch]
 from typing import Callable
 from typing_extensions import ParamSpec
 
@@ -1182,7 +1284,7 @@ def f1(f: Callable[P, int], *args, **kwargs: P.kwargs) -> int: ...  # E: ParamSp
 def f2(f: Callable[P, int], *args: P.args, **kwargs) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
 def f3(f: Callable[P, int], *args: P.args) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
 def f4(f: Callable[P, int], **kwargs: P.kwargs) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
-def f5(f: Callable[P, int], *args: P.args, extra_keyword_arg: int, **kwargs: P.kwargs) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
+def f5(f: Callable[P, int], *args: P.args, extra_keyword_arg: int, **kwargs: P.kwargs) -> int: ...  # E: Arguments not allowed after ParamSpec.args
 
 # Error message test:
 P1 = ParamSpec('P1')
@@ -1212,7 +1314,7 @@ def f1(f: Callable[Concatenate[int, P], int], *args, **kwargs: P.kwargs) -> int:
 def f2(f: Callable[Concatenate[int, P], int], *args: P.args, **kwargs) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
 def f3(f: Callable[Concatenate[int, P], int], *args: P.args) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
 def f4(f: Callable[Concatenate[int, P], int], **kwargs: P.kwargs) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
-def f5(f: Callable[Concatenate[int, P], int], *args: P.args, extra_keyword_arg: int, **kwargs: P.kwargs) -> int: ...  # E: ParamSpec must have "*args" typed as "P.args" and "**kwargs" typed as "P.kwargs"
+def f5(f: Callable[Concatenate[int, P], int], *args: P.args, extra_keyword_arg: int, **kwargs: P.kwargs) -> int: ...  # E: Arguments not allowed after ParamSpec.args
 [builtins fixtures/paramspec.pyi]
 
 
@@ -1244,22 +1346,28 @@ from typing import Callable, ParamSpec
 P1 = ParamSpec('P1')
 P2 = ParamSpec('P2')
 
-def f0(f: Callable[P1, int], *args: P1.args, **kwargs: P2.kwargs): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs"
+def f0(f: Callable[P1, int], *args: P1.args, **kwargs: P2.kwargs): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs" \
+                                                                        # E: ParamSpec "P2" is unbound
 
-def f1(*args: P1.args): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs"
-def f2(**kwargs: P1.kwargs): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs"
-def f3(*args: P1.args, **kwargs: int): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs"
-def f4(*args: int, **kwargs: P1.kwargs): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs"
+def f1(*args: P1.args): ...  # E: ParamSpec "P1" is unbound
+def f2(**kwargs: P1.kwargs): ...  # E: ParamSpec "P1" is unbound
+def f3(*args: P1.args, **kwargs: int): ...  # E: ParamSpec "P1" is unbound
+def f4(*args: int, **kwargs: P1.kwargs): ...  # E: ParamSpec "P1" is unbound
 
 # Error message is based on the `args` definition:
-def f5(*args: P2.args, **kwargs: P1.kwargs): ...  # E: ParamSpec must have "*args" typed as "P2.args" and "**kwargs" typed as "P2.kwargs"
-def f6(*args: P1.args, **kwargs: P2.kwargs): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs"
+def f5(*args: P2.args, **kwargs: P1.kwargs): ...  # E: ParamSpec "P2" is unbound \
+                                                  # E: ParamSpec "P1" is unbound
+def f6(*args: P1.args, **kwargs: P2.kwargs): ...  # E: ParamSpec "P1" is unbound \
+                                                  # E: ParamSpec "P2" is unbound
 
 # Multiple `ParamSpec` variables can be found, they should not affect error message:
 P3 = ParamSpec('P3')
 
-def f7(first: Callable[P3, int], *args: P1.args, **kwargs: P2.kwargs): ...  # E: ParamSpec must have "*args" typed as "P1.args" and "**kwargs" typed as "P1.kwargs"
-def f8(first: Callable[P3, int], *args: P2.args, **kwargs: P1.kwargs): ...  # E: ParamSpec must have "*args" typed as "P2.args" and "**kwargs" typed as "P2.kwargs"
+def f7(first: Callable[P3, int], *args: P1.args, **kwargs: P2.kwargs): ...  # E: ParamSpec "P1" is unbound \
+                                                                            # E: ParamSpec "P2" is unbound
+def f8(first: Callable[P3, int], *args: P2.args, **kwargs: P1.kwargs): ...  # E: ParamSpec "P2" is unbound \
+                                                                            # E: ParamSpec "P1" is unbound
+
 [builtins fixtures/paramspec.pyi]
 
 
@@ -1272,8 +1380,8 @@ P = ParamSpec('P')
 class Some(Generic[P]):
     def call(self, *args: P.args, **kwargs: P.kwargs): ...
 
-# TODO: this probably should be reported.
-def call(*args: P.args, **kwargs: P.kwargs): ...
+def call(*args: P.args, **kwargs: P.kwargs): ...  # E: ParamSpec "P" is unbound
+
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecInferenceCrash]
@@ -1292,8 +1400,7 @@ reveal_type(bar(C(fn=foo, x=1)))  # N: Revealed type is "__main__.C[[x: builtins
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecClassConstructor]
-# flags: --strict-optional
-from typing import ParamSpec, Callable
+from typing import ParamSpec, Callable, TypeVar
 
 P = ParamSpec("P")
 
@@ -1301,7 +1408,10 @@ class SomeClass:
     def __init__(self, a: str) -> None:
         pass
 
-def func(t: Callable[P, SomeClass], val: Callable[P, SomeClass]) -> None:
+def func(t: Callable[P, SomeClass], val: Callable[P, SomeClass]) -> Callable[P, SomeClass]:
+    pass
+
+def func_regular(t: Callable[[T], SomeClass], val: Callable[[T], SomeClass]) -> Callable[[T], SomeClass]:
     pass
 
 def constructor(a: str) -> SomeClass:
@@ -1310,9 +1420,13 @@ def constructor(a: str) -> SomeClass:
 def wrong_constructor(a: bool) -> SomeClass:
     return SomeClass("a")
 
+def wrong_name_constructor(b: bool) -> SomeClass:
+    return SomeClass("a")
+
 func(SomeClass, constructor)
-func(SomeClass, wrong_constructor)  # E: Argument 1 to "func" has incompatible type "Type[SomeClass]"; expected "Callable[[VarArg(<nothing>), KwArg(<nothing>)], SomeClass]" \
-				    # E: Argument 2 to "func" has incompatible type "Callable[[bool], SomeClass]"; expected "Callable[[VarArg(<nothing>), KwArg(<nothing>)], SomeClass]"
+reveal_type(func(SomeClass, wrong_constructor))  # N: Revealed type is "def (a: Never) -> __main__.SomeClass"
+reveal_type(func_regular(SomeClass, wrong_constructor))  # N: Revealed type is "def (Never) -> __main__.SomeClass"
+reveal_type(func(SomeClass, wrong_name_constructor))  # N: Revealed type is "def (Never) -> __main__.SomeClass"
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecInTypeAliasBasic]
@@ -1365,6 +1479,17 @@ y: C[int, str]
 reveal_type(y)  # N: Revealed type is "def (builtins.int, builtins.int, builtins.str) -> builtins.int"
 [builtins fixtures/paramspec.pyi]
 
+[case testParamSpecInTypeAliasIllegalBare]
+from typing import ParamSpec
+from typing_extensions import Concatenate, TypeAlias
+
+P = ParamSpec("P")
+Bad1: TypeAlias = P                     # E: Invalid location for ParamSpec "P" \
+                                        # N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"
+Bad2: TypeAlias = Concatenate[int, P]   # E: Invalid location for Concatenate \
+                                        # N: You can use Concatenate as the first argument to Callable
+[builtins fixtures/paramspec.pyi]
+
 [case testParamSpecInTypeAliasRecursive]
 from typing import ParamSpec, Callable, Union
 
@@ -1410,15 +1535,15 @@ from typing import ParamSpec, Generic, List, TypeVar, Callable
 P = ParamSpec("P")
 T = TypeVar("T")
 A = List[T]
-def f(x: A[[int, str]]) -> None: ...  # E: Bracketed expression "[...]" is not valid as a type \
-                                      # N: Did you mean "List[...]"?
+def f(x: A[[int, str]]) -> None: ...  # E: Bracketed expression "[...]" is not valid as a type
 def g(x: A[P]) -> None: ...  # E: Invalid location for ParamSpec "P" \
-                             # N: You can use ParamSpec as the first argument to Callable, e.g., 'Callable[P, int]'
+                             # N: You can use ParamSpec as the first argument to Callable, e.g., "Callable[P, int]"
 
 C = Callable[P, T]
-x: C[int]  # E: Bad number of arguments for type alias, expected: 2, given: 1
+x: C[int]  # E: Bad number of arguments for type alias, expected 2, given 1
 y: C[int, str]  # E: Can only replace ParamSpec with a parameter types list or another ParamSpec, got "int"
-z: C[int, str, bytes]  # E: Bad number of arguments for type alias, expected: 2, given: 3
+z: C[int, str, bytes]  # E: Bad number of arguments for type alias, expected 2, given 3
+
 [builtins fixtures/paramspec.pyi]
 
 [case testTrivialParametersHandledCorrectly]
@@ -1452,8 +1577,7 @@ reveal_type(gs)  # N: Revealed type is "builtins.list[def (builtins.int, builtin
 
 T = TypeVar("T")
 class C(Generic[T]): ...
-C[Callable[P, int]]()  # E: The first argument to Callable must be a list of types, parameter specification, or "..." \
-                       # N: See https://mypy.readthedocs.io/en/stable/kinds_of_types.html#callable-types-and-lambdas
+C[Callable[P, int]]()
 [builtins fixtures/paramspec.pyi]
 
 [case testConcatDeferralNoCrash]
@@ -1493,7 +1617,7 @@ from typing_extensions import Concatenate, ParamSpec
 P = ParamSpec("P")
 
 @overload
-def command() -> Callable[[Callable[Concatenate[object, object, P], object]], None]:  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+def command() -> Callable[[Callable[Concatenate[object, object, P], object]], None]:
     ...
 
 @overload
@@ -1520,3 +1644,962 @@ 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 [T] (x: T`3) -> builtins.list[T`3]"
+
+class A: ...
+TA = TypeVar("TA", bound=A)
+
+def test_with_bound(x: TA) -> TA: ...
+reveal_type(dec(test_with_bound))  # N: Revealed type is "def [T <: __main__.A] (x: T`5) -> builtins.list[T`5]"
+dec(test_with_bound)(0)  # E: Value of type variable "T" of function cannot be "int"
+dec(test_with_bound)(A())  # OK
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecArgumentParamInferenceRegular]
+from typing import TypeVar, Generic
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+class Foo(Generic[P]):
+    def call(self, *args: P.args, **kwargs: P.kwargs) -> None: ...
+def test(*args: P.args, **kwargs: P.kwargs) -> Foo[P]: ...
+
+reveal_type(test(1, 2))  # N: Revealed type is "__main__.Foo[[Literal[1]?, Literal[2]?]]"
+reveal_type(test(x=1, y=2))  # N: Revealed type is "__main__.Foo[[x: Literal[1]?, y: Literal[2]?]]"
+ints = [1, 2, 3]
+reveal_type(test(*ints))  # N: Revealed type is "__main__.Foo[[*builtins.int]]"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecArgumentParamInferenceGeneric]
+# flags: --new-type-inference
+from typing import Callable, TypeVar
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+R = TypeVar("R")
+def call(f: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+    return f(*args, **kwargs)
+
+T = TypeVar("T")
+def identity(x: T) -> T:
+    return x
+
+reveal_type(call(identity, 2))  # N: Revealed type is "builtins.int"
+y: int = call(identity, 2)
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecNestedApplyNoCrash]
+# flags: --new-type-inference
+from typing import Callable, TypeVar
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+def apply(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T: ...
+def test() -> int: ...
+reveal_type(apply(apply, test))  # N: Revealed type is "builtins.int"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecNestedApplyPosVsNamed]
+from typing import Callable, TypeVar
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+def apply(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> None: ...
+
+def test(x: int) -> int: ...
+apply(apply, test, x=42)  # OK
+apply(apply, test, 42)  # Also OK (but requires some special casing)
+apply(apply, test, "bad")  # E: Argument 1 to "apply" has incompatible type "Callable[[Callable[P, T], **P], None]"; expected "Callable[[Callable[[int], int], str], None]"
+
+def test2(x: int, y: str) -> None: ...
+apply(apply, test2, 42, "yes")
+apply(apply, test2, "no", 42)  # E: Argument 1 to "apply" has incompatible type "Callable[[Callable[P, T], **P], None]"; expected "Callable[[Callable[[int, str], None], str, int], None]"
+apply(apply, test2, x=42, y="yes")
+apply(apply, test2, y="yes", x=42)
+apply(apply, test2, y=42, x="no")  # E: Argument 1 to "apply" has incompatible type "Callable[[Callable[P, T], **P], None]"; expected "Callable[[Callable[[int, str], None], int, str], None]"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecApplyPosVsNamedOptional]
+from typing import Callable, TypeVar
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+def apply(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> None: ...
+def test(x: str = ..., y: int = ...) -> int: ...
+apply(test, y=42)  # OK
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecPrefixSubtypingGenericInvalid]
+from typing import Generic
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+
+class A(Generic[P]):
+    def foo(self, *args: P.args, **kwargs: P.kwargs):
+        ...
+
+def bar(b: A[P]) -> A[Concatenate[int, P]]:
+    return b  # E: Incompatible return value type (got "A[P]", expected "A[[int, **P]]")
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecPrefixSubtypingProtocolInvalid]
+from typing import Protocol
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+
+class A(Protocol[P]):
+    def foo(self, *args: P.args, **kwargs: P.kwargs):
+        ...
+
+def bar(b: A[P]) -> A[Concatenate[int, P]]:
+    return b  # E: Incompatible return value type (got "A[P]", expected "A[[int, **P]]") \
+              # N: Following member(s) of "A[P]" have conflicts: \
+              # N:     Expected: \
+              # N:         def foo(self, int, /, *args: P.args, **kwargs: P.kwargs) -> Any \
+              # N:     Got: \
+              # N:         def foo(self, *args: P.args, **kwargs: P.kwargs) -> Any
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecPrefixSubtypingValidNonStrict]
+from typing import Protocol
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+
+class A(Protocol[P]):
+    def foo(self, a: int, *args: P.args, **kwargs: P.kwargs):
+        ...
+
+class B(Protocol[P]):
+    def foo(self, a: int, b: int, *args: P.args, **kwargs: P.kwargs):
+        ...
+
+def bar(b: B[P]) -> A[Concatenate[int, P]]:
+    return b
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecPrefixSubtypingInvalidStrict]
+# flags: --extra-checks
+from typing import Protocol
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+
+class A(Protocol[P]):
+    def foo(self, a: int, *args: P.args, **kwargs: P.kwargs):
+        ...
+
+class B(Protocol[P]):
+    def foo(self, a: int, b: int, *args: P.args, **kwargs: P.kwargs):
+        ...
+
+def bar(b: B[P]) -> A[Concatenate[int, P]]:
+    return b  # E: Incompatible return value type (got "B[P]", expected "A[[int, **P]]") \
+              # N: Following member(s) of "B[P]" have conflicts: \
+              # N:     Expected: \
+              # N:         def foo(self, a: int, int, /, *args: P.args, **kwargs: P.kwargs) -> Any \
+              # N:     Got: \
+              # N:         def foo(self, a: int, b: int, *args: P.args, **kwargs: P.kwargs) -> Any
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecDecoratorOverload]
+from typing import Callable, overload, TypeVar, List
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+T = TypeVar("T")
+def transform(func: Callable[P, List[T]]) -> Callable[P, T]: ...
+
+@overload
+def foo(x: int) -> List[float]: ...
+@overload
+def foo(x: str) -> List[str]: ...
+def foo(x): ...
+
+reveal_type(transform(foo))  # N: Revealed type is "Overload(def (x: builtins.int) -> builtins.float, def (x: builtins.str) -> builtins.str)"
+
+@transform
+@overload
+def bar(x: int) -> List[float]: ...
+@transform
+@overload
+def bar(x: str) -> List[str]: ...
+@transform
+def bar(x): ...
+
+reveal_type(bar)  # N: Revealed type is "Overload(def (x: builtins.int) -> builtins.float, def (x: builtins.str) -> builtins.str)"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecDecoratorOverloadNoCrashOnInvalidTypeVar]
+from typing import Any, Callable, List
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+T = 1
+
+Alias = Callable[P, List[T]]  # type: ignore
+def dec(fn: Callable[P, T]) -> Alias[P, T]: ...  # type: ignore
+f: Any
+dec(f)  # No crash
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecErrorNestedParams]
+from typing import Generic
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+class C(Generic[P]): ...
+c: C[int, [int, str], str]  # E: Nested parameter specifications are not allowed
+reveal_type(c)  # N: Revealed type is "__main__.C[Any]"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecInheritNoCrashOnNested]
+from typing import Generic
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+class C(Generic[P]): ...
+class D(C[int, [int, str], str]): ... # E: Nested parameter specifications are not allowed
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecConcatenateSelfType]
+from typing import Callable
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+class A:
+    def __init__(self, a_param_1: str) -> None: ...
+
+    @classmethod
+    def add_params(cls: Callable[P, A]) -> Callable[Concatenate[float, P], A]:
+        def new_constructor(i: float, *args: P.args, **kwargs: P.kwargs) -> A:
+            return cls(*args, **kwargs)
+        return new_constructor
+
+    @classmethod
+    def remove_params(cls: Callable[Concatenate[str, P], A]) -> Callable[P, A]:
+        def new_constructor(*args: P.args, **kwargs: P.kwargs) -> A:
+            return cls("my_special_str", *args, **kwargs)
+        return new_constructor
+
+reveal_type(A.add_params())  # N: Revealed type is "def (builtins.float, a_param_1: builtins.str) -> __main__.A"
+reveal_type(A.remove_params())  # N: Revealed type is "def () -> __main__.A"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecConcatenateCallbackProtocol]
+from typing import Protocol, TypeVar
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+R = TypeVar("R", covariant=True)
+
+class Path: ...
+
+class Function(Protocol[P, R]):
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R: ...
+
+def file_cache(fn: Function[Concatenate[Path, P], R]) -> Function[P, R]:
+    def wrapper(*args: P.args, **kw: P.kwargs) -> R:
+        return fn(Path(), *args, **kw)
+    return wrapper
+
+@file_cache
+def get_thing(path: Path, *, some_arg: int) -> int: ...
+reveal_type(get_thing)  # N: Revealed type is "__main__.Function[[*, some_arg: builtins.int], builtins.int]"
+get_thing(some_arg=1)  # OK
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecConcatenateKeywordOnly]
+from typing import Callable, TypeVar
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+class Path: ...
+
+def file_cache(fn: Callable[Concatenate[Path, P], R]) -> Callable[P, R]:
+    def wrapper(*args: P.args, **kw: P.kwargs) -> R:
+        return fn(Path(), *args, **kw)
+    return wrapper
+
+@file_cache
+def get_thing(path: Path, *, some_arg: int) -> int: ...
+reveal_type(get_thing)  # N: Revealed type is "def (*, some_arg: builtins.int) -> builtins.int"
+get_thing(some_arg=1)  # OK
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecConcatenateCallbackApply]
+from typing import Callable, Protocol
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+
+class FuncType(Protocol[P]):
+    def __call__(self, x: int, s: str, *args: P.args, **kw_args: P.kwargs) -> str: ...
+
+def forwarder1(fp: FuncType[P], *args: P.args, **kw_args: P.kwargs) -> str:
+    return fp(0, '', *args, **kw_args)
+
+def forwarder2(fp: Callable[Concatenate[int, str, P], str], *args: P.args, **kw_args: P.kwargs) -> str:
+    return fp(0, '', *args, **kw_args)
+
+def my_f(x: int, s: str, d: bool) -> str: ...
+forwarder1(my_f, True)  # OK
+forwarder2(my_f, True)  # OK
+forwarder1(my_f, 1.0)  # E: Argument 2 to "forwarder1" has incompatible type "float"; expected "bool"
+forwarder2(my_f, 1.0)  # E: Argument 2 to "forwarder2" has incompatible type "float"; expected "bool"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecCallbackProtocolSelf]
+from typing import Callable, Protocol, TypeVar
+from typing_extensions import ParamSpec, Concatenate
+
+Params = ParamSpec("Params")
+Result = TypeVar("Result", covariant=True)
+
+class FancyMethod(Protocol):
+    def __call__(self, arg1: int, arg2: str) -> bool: ...
+    def return_me(self: Callable[Params, Result]) -> Callable[Params, Result]: ...
+    def return_part(self: Callable[Concatenate[int, Params], Result]) -> Callable[Params, Result]: ...
+
+m: FancyMethod
+reveal_type(m.return_me())  # N: Revealed type is "def (arg1: builtins.int, arg2: builtins.str) -> builtins.bool"
+reveal_type(m.return_part())  # N: Revealed type is "def (arg2: builtins.str) -> builtins.bool"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecInferenceCallableAgainstAny]
+from typing import Callable, TypeVar, Any
+from typing_extensions import ParamSpec, Concatenate
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+class A: ...
+a = A()
+
+def a_func(
+    func: Callable[Concatenate[A, _P], _R],
+) -> Callable[Concatenate[Any, _P], _R]:
+    def wrapper(__a: Any, *args: _P.args, **kwargs: _P.kwargs) -> _R:
+        return func(a, *args, **kwargs)
+    return wrapper
+
+def test(a, *args): ...
+x: Any
+y: object
+
+a_func(test)
+x = a_func(test)
+y = a_func(test)
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecInferenceWithCallbackProtocol]
+from typing import Protocol, Callable, ParamSpec
+
+class CB(Protocol):
+    def __call__(self, x: str, y: int) -> None: ...
+
+P = ParamSpec('P')
+def g(fn: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+
+cb: CB
+g(cb, y=0, x='a')  # OK
+g(cb, y='a', x=0)  # E: Argument "y" to "g" has incompatible type "str"; expected "int" \
+                   # E: Argument "x" to "g" has incompatible type "int"; expected "str"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecBadRuntimeTypeApplication]
+from typing import ParamSpec, TypeVar, Generic, Callable
+
+R = TypeVar("R")
+P = ParamSpec("P")
+class C(Generic[P, R]):
+    x: Callable[P, R]
+
+bad = C[int, str]()  # E: Can only replace ParamSpec with a parameter types list or another ParamSpec, got "int"
+reveal_type(bad)  # N: Revealed type is "__main__.C[Any, Any]"
+reveal_type(bad.x)  # N: Revealed type is "def (*Any, **Any) -> Any"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecNoCrashOnUnificationAlias]
+import mod
+[file mod.pyi]
+from typing import Callable, Protocol, TypeVar, overload
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+R_co = TypeVar("R_co", covariant=True)
+Handler = Callable[P, R_co]
+
+class HandlerDecorator(Protocol):
+    def __call__(self, handler: Handler[P, R_co]) -> Handler[P, R_co]: ...
+
+@overload
+def event(event_handler: Handler[P, R_co]) -> Handler[P, R_co]: ...
+@overload
+def event(namespace: str, *args, **kwargs) -> HandlerDecorator: ...
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecNoCrashOnUnificationCallable]
+import mod
+[file mod.pyi]
+from typing import Callable, Protocol, TypeVar, overload
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+R_co = TypeVar("R_co", covariant=True)
+
+class HandlerDecorator(Protocol):
+    def __call__(self, handler: Callable[P, R_co]) -> Callable[P, R_co]: ...
+
+@overload
+def event(event_handler: Callable[P, R_co]) -> Callable[P, R_co]: ...
+@overload
+def event(namespace: str, *args, **kwargs) -> HandlerDecorator: ...
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecNoCrashOnUnificationPrefix]
+from typing import Any, Callable, TypeVar, overload
+from typing_extensions import ParamSpec, Concatenate
+
+T = TypeVar("T")
+U = TypeVar("U")
+V = TypeVar("V")
+W = TypeVar("W")
+P = ParamSpec("P")
+
+@overload
+def call(
+    func: Callable[Concatenate[T, P], U],
+    x: T,
+    *args: Any,
+    **kwargs: Any,
+) -> U: ...
+@overload
+def call(
+    func: Callable[Concatenate[T, U, P], V],
+    x: T,
+    y: U,
+    *args: Any,
+    **kwargs: Any,
+) -> V: ...
+def call(*args: Any, **kwargs: Any) -> Any: ...
+
+def test1(x: int) -> str: ...
+def test2(x: int, y: int) -> str: ...
+reveal_type(call(test1, 1))  # N: Revealed type is "builtins.str"
+reveal_type(call(test2, 1, 2))  # N: Revealed type is "builtins.str"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecCorrectParameterNameInference]
+from typing import Callable, Protocol
+from typing_extensions import ParamSpec, Concatenate
+
+def a(i: int) -> None: ...
+def b(__i: int) -> None: ...
+
+class WithName(Protocol):
+    def __call__(self, i: int) -> None: ...
+NoName = Callable[[int], None]
+
+def f1(__fn: WithName, i: int) -> None: ...
+def f2(__fn: NoName, i: int) -> None: ...
+
+P = ParamSpec("P")
+def d(f: Callable[P, None], fn: Callable[Concatenate[Callable[P, None], P], None]) -> Callable[P, None]:
+    def inner(*args: P.args, **kwargs: P.kwargs) -> None:
+        fn(f, *args, **kwargs)
+    return inner
+
+reveal_type(d(a, f1))  # N: Revealed type is "def (i: builtins.int)"
+reveal_type(d(a, f2))  # N: Revealed type is "def (i: builtins.int)"
+reveal_type(d(b, f1))  # E: Cannot infer type argument 1 of "d" \
+                       # N: Revealed type is "def (*Any, **Any)"
+reveal_type(d(b, f2))  # N: Revealed type is "def (builtins.int)"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecGenericWithNamedArg1]
+from typing import Callable, TypeVar
+from typing_extensions import ParamSpec
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+def run(func: Callable[[], R], *args: object, backend: str = "asyncio") -> R: ...
+class Result: ...
+def run_portal() -> Result: ...
+def submit(func: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs) -> R: ...
+
+reveal_type(submit(  # N: Revealed type is "__main__.Result"
+    run,
+    run_portal,
+    backend="asyncio",
+))
+submit(
+    run,  # E: Argument 1 to "submit" has incompatible type "Callable[[Callable[[], R], VarArg(object), DefaultNamedArg(str, 'backend')], R]"; expected "Callable[[Callable[[], Result], int], Result]"
+    run_portal,
+    backend=int(),
+)
+[builtins fixtures/paramspec.pyi]
+
+[case testInferenceAgainstGenericCallableUnionParamSpec]
+from typing import Callable, TypeVar, List, Union
+from typing_extensions import ParamSpec
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+def dec(f: Callable[P, T]) -> Callable[P, List[T]]: ...
+@dec
+def func(arg: T) -> Union[T, str]:
+    ...
+reveal_type(func)  # N: Revealed type is "def [T] (arg: T`-1) -> builtins.list[Union[T`-1, builtins.str]]"
+reveal_type(func(42))  # N: Revealed type is "builtins.list[Union[builtins.int, builtins.str]]"
+
+def dec2(f: Callable[P, List[T]]) -> Callable[P, T]: ...
+@dec2
+def func2(arg: T) -> List[Union[T, str]]:
+    ...
+reveal_type(func2)  # N: Revealed type is "def [T] (arg: T`-1) -> Union[T`-1, builtins.str]"
+reveal_type(func2(42))  # N: Revealed type is "Union[builtins.int, builtins.str]"
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecPreciseKindsUsedIfPossible]
+from typing import Callable, Generic
+from typing_extensions import ParamSpec
+
+P = ParamSpec('P')
+
+class Case(Generic[P]):
+    def __init__(self, *args: P.args, **kwargs: P.kwargs) -> None:
+        pass
+
+def _test(a: int, b: int = 0) -> None: ...
+
+def parametrize(
+    func: Callable[P, None], *cases: Case[P], **named_cases: Case[P]
+) -> Callable[[], None]:
+    ...
+
+parametrize(_test, Case(1, 2), Case(3, 4))
+parametrize(_test, Case(1, b=2), Case(3, b=4))
+parametrize(_test, Case(1, 2), Case(3))
+parametrize(_test, Case(1, 2), Case(3, b=4))
+[builtins fixtures/paramspec.pyi]
+
+[case testRunParamSpecInsufficientArgs]
+from typing_extensions import ParamSpec, Concatenate
+from typing import Callable
+
+_P = ParamSpec("_P")
+
+def run(predicate: Callable[_P, None], *args: _P.args, **kwargs: _P.kwargs) -> None:  # N: "run" defined here
+    predicate()  # E: Too few arguments
+    predicate(*args)  # E: Too few arguments
+    predicate(**kwargs)  # E: Too few arguments
+    predicate(*args, **kwargs)
+
+def fn() -> None: ...
+def fn_args(x: int) -> None: ...
+def fn_posonly(x: int, /) -> None: ...
+
+run(fn)
+run(fn_args, 1)
+run(fn_args, x=1)
+run(fn_posonly, 1)
+run(fn_posonly, x=1)  # E: Unexpected keyword argument "x" for "run"
+
+[builtins fixtures/paramspec.pyi]
+
+[case testRunParamSpecConcatenateInsufficientArgs]
+from typing_extensions import ParamSpec, Concatenate
+from typing import Callable
+
+_P = ParamSpec("_P")
+
+def run(predicate: Callable[Concatenate[int, _P], None], *args: _P.args, **kwargs: _P.kwargs) -> None:  # N: "run" defined here
+    predicate()  # E: Too few arguments
+    predicate(1)  # E: Too few arguments
+    predicate(1, *args)  # E: Too few arguments
+    predicate(1, *args)  # E: Too few arguments
+    predicate(1, **kwargs)  # E: Too few arguments
+    predicate(*args, **kwargs)  # E: Argument 1 has incompatible type "*_P.args"; expected "int"
+    predicate(1, *args, **kwargs)
+
+def fn() -> None: ...
+def fn_args(x: int, y: str) -> None: ...
+def fn_posonly(x: int, /) -> None: ...
+def fn_posonly_args(x: int, /, y: str) -> None: ...
+
+run(fn)  # E: Argument 1 to "run" has incompatible type "Callable[[], None]"; expected "Callable[[int], None]"
+run(fn_args, 1, 'a')  # E: Too many arguments for "run" \
+                      # E: Argument 2 to "run" has incompatible type "int"; expected "str"
+run(fn_args, y='a')
+run(fn_args, 'a')
+run(fn_posonly)
+run(fn_posonly, x=1)  # E: Unexpected keyword argument "x" for "run"
+run(fn_posonly_args)  # E: Missing positional argument "y" in call to "run"
+run(fn_posonly_args, 'a')
+run(fn_posonly_args, y='a')
+
+[builtins fixtures/paramspec.pyi]
+
+[case testRunParamSpecConcatenateInsufficientArgsInDecorator]
+from typing_extensions import ParamSpec, Concatenate
+from typing import Callable
+
+P = ParamSpec("P")
+
+def decorator(fn: Callable[Concatenate[str, P], None]) -> Callable[P, None]:
+    def inner(*args: P.args, **kwargs: P.kwargs) -> None:
+        fn("value")  # E: Too few arguments
+        fn("value", *args)  # E: Too few arguments
+        fn("value", **kwargs)  # E: Too few arguments
+        fn(*args, **kwargs)  # E: Argument 1 has incompatible type "*P.args"; expected "str"
+        fn("value", *args, **kwargs)
+    return inner
+
+@decorator
+def foo(s: str, s2: str) -> None: ...
+
+[builtins fixtures/paramspec.pyi]
+
+[case testRunParamSpecOverload]
+from typing_extensions import ParamSpec
+from typing import Callable, NoReturn, TypeVar, Union, overload
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+@overload
+def capture(
+    sync_fn: Callable[P, NoReturn],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> int: ...
+@overload
+def capture(
+    sync_fn: Callable[P, T],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> Union[T, int]: ...
+def capture(
+    sync_fn: Callable[P, T],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> Union[T, int]:
+    return sync_fn(*args, **kwargs)
+
+def fn() -> str: return ''
+def err() -> NoReturn: ...
+
+reveal_type(capture(fn))  # N: Revealed type is "Union[builtins.str, builtins.int]"
+reveal_type(capture(err))  # N: Revealed type is "builtins.int"
+
+[builtins fixtures/paramspec.pyi]
+
+[case testRunParamSpecOverlappingOverloadsOrder]
+from typing import Any, Callable, overload
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+
+class Base:
+    pass
+class Child(Base):
+    def __call__(self) -> str: ...
+class NotChild:
+    def __call__(self) -> str: ...
+
+@overload
+def handle(func: Base) -> int: ...
+@overload
+def handle(func: Callable[P, str], *args: P.args, **kwargs: P.kwargs) -> str: ...
+def handle(func: Any, *args: Any, **kwargs: Any) -> Any:
+    return func(*args, **kwargs)
+
+@overload
+def handle_reversed(func: Callable[P, str], *args: P.args, **kwargs: P.kwargs) -> str: ...
+@overload
+def handle_reversed(func: Base) -> int: ...
+def handle_reversed(func: Any, *args: Any, **kwargs: Any) -> Any:
+    return func(*args, **kwargs)
+
+reveal_type(handle(Child()))  # N: Revealed type is "builtins.int"
+reveal_type(handle(NotChild()))  # N: Revealed type is "builtins.str"
+
+reveal_type(handle_reversed(Child()))  # N: Revealed type is "builtins.str"
+reveal_type(handle_reversed(NotChild()))  # N: Revealed type is "builtins.str"
+
+[builtins fixtures/paramspec.pyi]
+
+[case testBindPartial]
+from functools import partial
+from typing_extensions import ParamSpec
+from typing import Callable, TypeVar
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+def run(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, **kwargs)
+    return func2(*args)
+
+def run2(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, *args)
+    return func2(**kwargs)
+
+def run3(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, *args, **kwargs)
+    return func2()
+
+def run4(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, *args, **kwargs)
+    return func2(**kwargs)
+
+def run_bad(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, *args, **kwargs)
+    return func2(*args)  # E: Too many arguments
+
+def run_bad2(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, **kwargs)
+    return func2(**kwargs)  # E: Too few arguments
+
+def run_bad3(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, *args)
+    return func2()  # E: Too few arguments
+
+[builtins fixtures/paramspec.pyi]
+
+[case testBindPartialConcatenate]
+from functools import partial
+from typing_extensions import Concatenate, ParamSpec
+from typing import Callable, TypeVar
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+def run(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, 1, **kwargs)
+    return func2(*args)
+
+def run2(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, **kwargs)
+    p = [""]
+    func2(1, *p)  # E: Too few arguments \
+                  # E: Argument 2 has incompatible type "*List[str]"; expected "P.args"
+    func2(1, 2, *p)  # E: Too few arguments \
+                     # E: Argument 2 has incompatible type "int"; expected "P.args" \
+                     # E: Argument 3 has incompatible type "*List[str]"; expected "P.args"
+    func2(1, *args, *p)  # E: Argument 3 has incompatible type "*List[str]"; expected "P.args"
+    func2(1, *p, *args)  # E: Argument 2 has incompatible type "*List[str]"; expected "P.args"
+    return func2(1, *args)
+
+def run3(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, 1, *args)
+    d = {"":""}
+    func2(**d)  # E: Too few arguments \
+                # E: Argument 1 has incompatible type "**Dict[str, str]"; expected "P.kwargs"
+    return func2(**kwargs)
+
+def run4(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, 1)
+    return func2(*args, **kwargs)
+
+def run5(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, 1, *args, **kwargs)
+    func2()
+    return func2(**kwargs)
+
+def run_bad(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, *args)  # E: Argument 1 has incompatible type "*P.args"; expected "int"
+    return func2(1, **kwargs)  # E: Argument 1 has incompatible type "int"; expected "P.args"
+
+def run_bad2(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, 1, *args)
+    func2()  # E: Too few arguments
+    func2(*args, **kwargs)  # E: Too many arguments
+    return func2(1, **kwargs)  # E: Argument 1 has incompatible type "int"; expected "P.args"
+
+def run_bad3(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, 1, **kwargs)
+    func2()  # E: Too few arguments
+    return func2(1, *args)  # E: Argument 1 has incompatible type "int"; expected "P.args"
+
+def run_bad4(func: Callable[Concatenate[int, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, 1)
+    func2()  # E: Too few arguments
+    func2(*args)  # E: Too few arguments
+    func2(1, *args)  # E: Too few arguments \
+                     # E: Argument 1 has incompatible type "int"; expected "P.args"
+    func2(1, **kwargs)  # E: Too few arguments \
+                        # E: Argument 1 has incompatible type "int"; expected "P.args"
+    return func2(**kwargs)  # E: Too few arguments
+
+[builtins fixtures/paramspec.pyi]
+
+[case testOtherVarArgs]
+from functools import partial
+from typing_extensions import Concatenate, ParamSpec
+from typing import Callable, TypeVar, Tuple
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+def run(func: Callable[Concatenate[int, str, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    func2 = partial(func, **kwargs)
+    args_prefix: Tuple[int, str] = (1, 'a')
+    func2(*args_prefix)  # E: Too few arguments
+    func2(*args, *args_prefix)  # E: Argument 1 has incompatible type "*P.args"; expected "int" \
+                                # E: Argument 1 has incompatible type "*P.args"; expected "str" \
+                                # E: Argument 2 has incompatible type "*Tuple[int, str]"; expected "P.args"
+    return func2(*args_prefix, *args)
+
+[builtins fixtures/paramspec.pyi]
+
+[case testParamSpecScoping]
+from typing import Any, Callable, Generic
+from typing_extensions import Concatenate, ParamSpec
+
+P = ParamSpec("P")
+P2 = ParamSpec("P2")
+
+def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+def contains_other(f: Callable[P2, None], c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+
+def contains_only_other(c: Callable[P2, None], *args: P.args, **kwargs: P.kwargs) -> None: ...  # E: ParamSpec "P" is unbound
+
+def puts_p_into_scope(f: Callable[P, int]) -> None:
+    def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+    def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...
+
+def puts_p_into_scope_concatenate(f: Callable[Concatenate[int, P], int]) -> None:
+    def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+    def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...
+
+def wrapper() -> None:
+    def puts_p_into_scope1(f: Callable[P, int]) -> None:
+        def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+        def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...
+
+class Wrapper:
+    def puts_p_into_scope1(self, f: Callable[P, int]) -> None:
+        def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+        def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...
+
+    def contains(self, c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+
+    def uses(self, *args: P.args, **kwargs: P.kwargs) -> None: ...  # E: ParamSpec "P" is unbound
+
+    def method(self) -> None:
+        def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+        def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...  # E: ParamSpec "P" is unbound
+
+class GenericWrapper(Generic[P]):
+    x: P.args  # E: ParamSpec components are not allowed here
+    y: P.kwargs  # E: ParamSpec components are not allowed here
+
+    def contains(self, c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+
+    def puts_p_into_scope1(self, f: Callable[P, int]) -> None:
+        def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+        def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...
+
+    def uses(self, *args: P.args, **kwargs: P.kwargs) -> None: ...
+
+    def method(self) -> None:
+        def contains(c: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
+        def inherits(*args: P.args, **kwargs: P.kwargs) -> None: ...
+[builtins fixtures/paramspec.pyi]
+
+[case testCallbackProtocolClassObjectParamSpec]
+from typing import Any, Callable, Protocol, Optional, Generic
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+
+class App: ...
+
+class MiddlewareFactory(Protocol[P]):
+    def __call__(self, app: App, /, *args: P.args, **kwargs: P.kwargs) -> App:
+        ...
+
+class Capture(Generic[P]): ...
+
+class ServerErrorMiddleware(App):
+    def __init__(
+        self,
+        app: App,
+        handler: Optional[str] = None,
+        debug: bool = False,
+    ) -> None: ...
+
+def fn(f: MiddlewareFactory[P]) -> Capture[P]: ...
+
+reveal_type(fn(ServerErrorMiddleware))  # N: Revealed type is "__main__.Capture[[handler: Union[builtins.str, None] =, debug: builtins.bool =]]"
+[builtins fixtures/paramspec.pyi]
+
+[case testRunParamSpecDuplicateArgsKwargs]
+from typing_extensions import ParamSpec, Concatenate
+from typing import Callable, Union
+
+_P = ParamSpec("_P")
+
+def run(predicate: Callable[_P, None], *args: _P.args, **kwargs: _P.kwargs) -> None:
+    predicate(*args, *args, **kwargs)  # E: ParamSpec.args should only be passed once
+    predicate(*args, **kwargs, **kwargs)  # E: ParamSpec.kwargs should only be passed once
+    predicate(*args, *args, **kwargs, **kwargs)  # E: ParamSpec.args should only be passed once \
+                                                 # E: ParamSpec.kwargs should only be passed once
+    copy_args = args
+    copy_kwargs = kwargs
+    predicate(*args, *copy_args, **kwargs)  # E: ParamSpec.args should only be passed once
+    predicate(*copy_args, *args, **kwargs)  # E: ParamSpec.args should only be passed once
+    predicate(*args, **copy_kwargs, **kwargs)  # E: ParamSpec.kwargs should only be passed once
+    predicate(*args, **kwargs, **copy_kwargs)  # E: ParamSpec.kwargs should only be passed once
+
+def run2(predicate: Callable[Concatenate[int, _P], None], *args: _P.args, **kwargs: _P.kwargs) -> None:
+    predicate(*args, *args, **kwargs)  # E: ParamSpec.args should only be passed once \
+                                       # E: Argument 1 has incompatible type "*_P.args"; expected "int"
+    predicate(*args, **kwargs, **kwargs)  # E: ParamSpec.kwargs should only be passed once \
+                                          # E: Argument 1 has incompatible type "*_P.args"; expected "int"
+    predicate(1, *args, *args, **kwargs)  # E: ParamSpec.args should only be passed once
+    predicate(1, *args, **kwargs, **kwargs)  # E: ParamSpec.kwargs should only be passed once
+    predicate(1, *args, *args, **kwargs, **kwargs)  # E: ParamSpec.args should only be passed once \
+                                                    # E: ParamSpec.kwargs should only be passed once
+    copy_args = args
+    copy_kwargs = kwargs
+    predicate(1, *args, *copy_args, **kwargs)  # E: ParamSpec.args should only be passed once
+    predicate(1, *copy_args, *args, **kwargs)  # E: ParamSpec.args should only be passed once
+    predicate(1, *args, **copy_kwargs, **kwargs)  # E: ParamSpec.kwargs should only be passed once
+    predicate(1, *args, **kwargs, **copy_kwargs)  # E: ParamSpec.kwargs should only be passed once
+
+def run3(predicate: Callable[Concatenate[int, str, _P], None], *args: _P.args, **kwargs: _P.kwargs) -> None:
+    base_ok: tuple[int, str]
+    predicate(*base_ok, *args, **kwargs)
+    base_bad: tuple[Union[int, str], ...]
+    predicate(*base_bad, *args, **kwargs)  # E: Argument 1 has incompatible type "*Tuple[Union[int, str], ...]"; expected "int" \
+                                           # E: Argument 1 has incompatible type "*Tuple[Union[int, str], ...]"; expected "str" \
+                                           # E: Argument 1 has incompatible type "*Tuple[Union[int, str], ...]"; expected "_P.args"
+[builtins fixtures/paramspec.pyi]
diff --git a/test-data/unit/check-plugin-attrs.test b/test-data/unit/check-plugin-attrs.test
index 9aa31c1ed10b..c44854b7fc42 100644
--- a/test-data/unit/check-plugin-attrs.test
+++ b/test-data/unit/check-plugin-attrs.test
@@ -185,10 +185,10 @@ from attr import attrib, attrs
 class A:
     a: int
 reveal_type(A)  # N: Revealed type is "def (a: builtins.int) -> __main__.A"
-reveal_type(A.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(A.__le__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(A.__gt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(A.__ge__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
+reveal_type(A.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`3, other: _AT`3) -> builtins.bool"
+reveal_type(A.__le__)  # N: Revealed type is "def [_AT] (self: _AT`4, other: _AT`4) -> builtins.bool"
+reveal_type(A.__gt__)  # N: Revealed type is "def [_AT] (self: _AT`5, other: _AT`5) -> builtins.bool"
+reveal_type(A.__ge__)  # N: Revealed type is "def [_AT] (self: _AT`6, other: _AT`6) -> builtins.bool"
 
 A(1) < A(2)
 A(1) <= A(2)
@@ -360,7 +360,8 @@ class A:
 
 a = A(5)
 a.a = 16  # E: Property "a" defined in "A" is read-only
-[builtins fixtures/bool.pyi]
+[builtins fixtures/plugin_attrs.pyi]
+
 [case testAttrsNextGenFrozen]
 from attr import frozen, field
 
@@ -370,7 +371,7 @@ class A:
 
 a = A(5)
 a.a = 16  # E: Property "a" defined in "A" is read-only
-[builtins fixtures/bool.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 
 [case testAttrsNextGenDetect]
 from attr import define, field
@@ -420,7 +421,7 @@ reveal_type(A)  # N: Revealed type is "def (a: builtins.int, b: builtins.bool) -
 reveal_type(B)  # N: Revealed type is "def (a: builtins.bool, b: builtins.int) -> __main__.B"
 reveal_type(C)  # N: Revealed type is "def (a: builtins.int) -> __main__.C"
 
-[builtins fixtures/bool.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 
 [case testAttrsDataClass]
 import attr
@@ -672,6 +673,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 +689,7 @@ A(B(None))
 [builtins fixtures/list.pyi]
 
 [case testAttrsForwardReferenceInClass]
+# flags: --no-strict-optional
 import attr
 @attr.s(auto_attribs=True)
 class A:
@@ -987,10 +990,10 @@ class C(A, B): pass
 @attr.s
 class D(A): pass
 
-reveal_type(A.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(B.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(C.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
-reveal_type(D.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`-1, other: _AT`-1) -> builtins.bool"
+reveal_type(A.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`29, other: _AT`29) -> builtins.bool"
+reveal_type(B.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`30, other: _AT`30) -> builtins.bool"
+reveal_type(C.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`31, other: _AT`31) -> builtins.bool"
+reveal_type(D.__lt__)  # N: Revealed type is "def [_AT] (self: _AT`32, other: _AT`32) -> builtins.bool"
 
 A() < A()
 B() < B()
@@ -1053,6 +1056,31 @@ C()
 C(_x=42)  # E: Unexpected keyword argument "_x" for "C"
 [builtins fixtures/list.pyi]
 
+[case testAttrsAliasForInit]
+from attrs import define, field
+
+@define
+class C1:
+    _x: int = field(alias="x1")
+
+c1 = C1(x1=42)
+reveal_type(c1._x)  # N: Revealed type is "builtins.int"
+c1.x1  # E: "C1" has no attribute "x1"
+C1(_x=42)  # E: Unexpected keyword argument "_x" for "C1"
+
+alias = "x2"
+@define
+class C2:
+    _x: int = field(alias=alias)  # E: "alias" argument to attrs field must be a string literal
+
+@define
+class C3:
+    _x: int = field(alias="_x")
+
+c3 = C3(_x=1)
+reveal_type(c3._x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/plugin_attrs.pyi]
+
 [case testAttrsAutoMustBeAll]
 import attr
 @attr.s(auto_attribs=True)
@@ -1128,7 +1156,7 @@ c = NonFrozenFrozen(1, 2)
 c.a = 17  # E: Property "a" defined in "NonFrozenFrozen" is read-only
 c.b = 17  # E: Property "b" defined in "NonFrozenFrozen" is read-only
 
-[builtins fixtures/bool.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 [case testAttrsCallableAttributes]
 from typing import Callable
 import attr
@@ -1151,7 +1179,7 @@ class G:
 class FFrozen(F):
     def bar(self) -> bool:
         return self._cb(5, 6)
-[builtins fixtures/callable.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 
 [case testAttrsWithFactory]
 from typing import List
@@ -1173,12 +1201,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[Never]", 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]
 
@@ -1196,7 +1225,6 @@ class C:
 [builtins fixtures/bool.pyi]
 
 [case testAttrsOptionalConverter]
-# flags: --strict-optional
 import attr
 from attr.converters import optional
 from typing import Optional
@@ -1216,7 +1244,6 @@ A(None, None)
 [builtins fixtures/plugin_attrs.pyi]
 
 [case testAttrsOptionalConverterNewPackage]
-# flags: --strict-optional
 import attrs
 from attrs.converters import optional
 from typing import Optional
@@ -1424,7 +1451,7 @@ class C:
     total = attr.ib(type=Bad)  # E: Name "Bad" is not defined
 
 C(0).total = 1  # E: Property "total" defined in "C" is read-only
-[builtins fixtures/bool.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 
 [case testTypeInAttrDeferredStar]
 import lib
@@ -1567,6 +1594,9 @@ reveal_type(f(A)[0])  # N: Revealed type is "attr.Attribute[builtins.int]"
 reveal_type(f(A).b)  # N: Revealed type is "attr.Attribute[builtins.int]"
 f(A).x  # E: "____main___A_AttrsAttributes__" has no attribute "x"
 
+for ff in f(A):
+    reveal_type(ff)  # N: Revealed type is "attr.Attribute[Any]"
+
 [builtins fixtures/plugin_attrs.pyi]
 
 [case testAttrsGenericFields]
@@ -1593,14 +1623,17 @@ def f(t: TA) -> None:
 
 [case testNonattrsFields]
 from typing import Any, cast, Type
-from attrs import fields
+from attrs import fields, has
 
 class A:
     b: int
     c: str
 
-fields(A)  # E: Argument 1 to "fields" has incompatible type "Type[A]"; expected an attrs class
-fields(None)  # E: Argument 1 to "fields" has incompatible type "None"; expected an attrs class
+if has(A):
+    fields(A)
+else:
+    fields(A)  # E: Argument 1 to "fields" has incompatible type "Type[A]"; expected "Type[AttrsInstance]"
+fields(None)  # E: Argument 1 to "fields" has incompatible type "None"; expected "Type[AttrsInstance]"
 fields(cast(Any, 42))
 fields(cast(Type[Any], 43))
 
@@ -1627,6 +1660,24 @@ reveal_type(A.__attrs_init__)  # N: Revealed type is "def (self: __main__.A, b:
 [case testAttrsClassWithSlots]
 import attr
 
+@attr.define
+class Define:
+    b: int = attr.ib()
+
+    def __attrs_post_init__(self) -> None:
+        self.b = 1
+        self.c = 2  # E: Trying to assign name "c" that is not in "__slots__" of type "__main__.Define"
+
+
+@attr.define(slots=False)
+class DefineSlotsFalse:
+    b: int = attr.ib()
+
+    def __attrs_post_init__(self) -> None:
+        self.b = 1
+        self.c = 2
+
+
 @attr.s(slots=True)
 class A:
     b: int = attr.ib()
@@ -1654,6 +1705,48 @@ class C:
         self.c = 2  # E: Trying to assign name "c" that is not in "__slots__" of type "__main__.C"
 [builtins fixtures/plugin_attrs.pyi]
 
+[case testAttrsClassWithSlotsDerivedFromNonSlots]
+import attrs
+
+class A:
+    pass
+
+@attrs.define(slots=True)
+class B(A):
+    x: int
+
+    def __attrs_post_init__(self) -> None:
+        self.y = 42
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testRuntimeSlotsAttr]
+from attr import dataclass
+
+@dataclass(slots=True)
+class Some:
+    x: int
+    y: str
+    z: bool
+
+reveal_type(Some.__slots__)  # N: Revealed type is "Tuple[builtins.str, builtins.str, builtins.str]"
+
+@dataclass(slots=True)
+class Other:
+    x: int
+    y: str
+
+reveal_type(Other.__slots__)  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
+
+
+@dataclass
+class NoSlots:
+    x: int
+    y: str
+
+NoSlots.__slots__  # E: "Type[NoSlots]" has no attribute "__slots__"
+[builtins fixtures/plugin_attrs.pyi]
+
 [case testAttrsWithMatchArgs]
 # flags: --python-version 3.10
 import attr
@@ -1743,6 +1836,7 @@ class B:
 class AB(A, B):
     pass
 [builtins fixtures/plugin_attrs.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testAttrsForwardReferenceInTypeVarBound]
 from typing import TypeVar, Generic
@@ -1849,7 +1943,7 @@ class C:
         default=None, converter=default_if_none(factory=dict) \
         # E: Unsupported converter, only named functions, types and lambdas are currently supported
     )
-[builtins fixtures/dict.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 
 [case testAttrsUnannotatedConverter]
 import attr
@@ -1920,7 +2014,7 @@ class Sub(Base):
 
     @property
     def name(self) -> str: ...
-[builtins fixtures/property.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 
 [case testOverrideWithPropertyInFrozenClassChecked]
 from attrs import frozen
@@ -1943,7 +2037,7 @@ class Sub(Base):
 
 # This matches runtime semantics
 reveal_type(Sub)  # N: Revealed type is "def (*, name: builtins.str, first_name: builtins.str, last_name: builtins.str) -> __main__.Sub"
-[builtins fixtures/property.pyi]
+[builtins fixtures/plugin_attrs.pyi]
 
 [case testFinalInstanceAttribute]
 from attrs import define
@@ -2064,8 +2158,8 @@ T = TypeVar('T')
 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>
+    z: str  # exercises meet(str, bytes) = Never
+    w: dict  # exercises meet(dict, Never) = Never
 
 
 @attrs.define
@@ -2077,8 +2171,8 @@ class B:
 
 a_or_b: A[int] | B
 a2 = attrs.evolve(a_or_b, x=42, y=True)
-a2 = attrs.evolve(a_or_b, x=42, y=True, z='42')  # E: Argument "z" to "evolve" of "Union[A[int], B]" has incompatible type "str"; expected <nothing>
-a2 = attrs.evolve(a_or_b, x=42, y=True, w={})  # E: Argument "w" to "evolve" of "Union[A[int], B]" has incompatible type "Dict[<nothing>, <nothing>]"; expected <nothing>
+a2 = attrs.evolve(a_or_b, x=42, y=True, z='42')  # E: Argument "z" to "evolve" of "Union[A[int], B]" has incompatible type "str"; expected "Never"
+a2 = attrs.evolve(a_or_b, x=42, y=True, w={})  # E: Argument "w" to "evolve" of "Union[A[int], B]" has incompatible type "Dict[Never, Never]"; expected "Never"
 
 [builtins fixtures/plugin_attrs.pyi]
 
@@ -2102,7 +2196,8 @@ TA = TypeVar('TA', bound=A)
 TB = TypeVar('TB', bound=B)
 
 def f(b_or_t: TA | TB | int) -> None:
-    a2 = attrs.evolve(b_or_t)   # E: Argument 1 to "evolve" has type "Union[TA, TB, int]" whose item "TB" is not bound to an attrs class  # E: Argument 1 to "evolve" has incompatible type "Union[TA, TB, int]" whose item "int" is not an attrs class
+    a2 = attrs.evolve(b_or_t)  # E: Argument 1 to "evolve" has type "Union[TA, TB, int]" whose item "TB" is not bound to an attrs class \
+                               # E: Argument 1 to "evolve" has incompatible type "Union[TA, TB, int]" whose item "int" is not an attrs class
 
 
 [builtins fixtures/plugin_attrs.pyi]
@@ -2151,7 +2246,8 @@ def h(t: TNone) -> None:
     _ = attrs.evolve(t, x=42)  # E: Argument 1 to "evolve" has a variable type "TNone" not bound to an attrs class
 
 def x(t: TUnion) -> None:
-    _ = attrs.evolve(t, x=42)  # E: Argument 1 to "evolve" has incompatible type "TUnion" whose item "str" is not an attrs class  # E: Argument 1 to "evolve" has incompatible type "TUnion" whose item "int" is not an attrs class
+    _ = attrs.evolve(t, x=42)  # E: Argument 1 to "evolve" has incompatible type "TUnion" whose item "str" is not an attrs class \
+                               # E: Argument 1 to "evolve" has incompatible type "TUnion" whose item "int" is not an attrs class
 
 [builtins fixtures/plugin_attrs.pyi]
 
@@ -2203,3 +2299,200 @@ c = attrs.assoc(c, name=42)  # E: Argument "name" to "assoc" of "C" has incompat
 
 [builtins fixtures/plugin_attrs.pyi]
 [typing fixtures/typing-medium.pyi]
+
+[case testFrozenInheritFromGeneric]
+from typing import Generic, TypeVar
+from attrs import field, frozen
+
+T = TypeVar('T')
+
+def f(s: str) -> int:
+    ...
+
+@frozen
+class A(Generic[T]):
+    x: T
+    y: int = field(converter=f)
+
+@frozen
+class B(A[int]):
+    pass
+
+b = B(42, 'spam')
+reveal_type(b.x)  # N: Revealed type is "builtins.int"
+reveal_type(b.y)  # N: Revealed type is "builtins.int"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testDefaultHashability]
+from attrs import define
+
+@define
+class A:
+    a: int
+
+reveal_type(A.__hash__)  # N: Revealed type is "None"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testFrozenHashability]
+from attrs import frozen
+
+@frozen
+class A:
+    a: int
+
+reveal_type(A.__hash__)  # N: Revealed type is "def (self: builtins.object) -> builtins.int"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testManualHashHashability]
+from attrs import define
+
+@define(hash=True)
+class A:
+    a: int
+
+reveal_type(A.__hash__)  # N: Revealed type is "def (self: builtins.object) -> builtins.int"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testManualUnsafeHashHashability]
+from attrs import define
+
+@define(unsafe_hash=True)
+class A:
+    a: int
+
+reveal_type(A.__hash__)  # N: Revealed type is "def (self: builtins.object) -> builtins.int"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testSubclassingHashability]
+from attrs import define
+
+@define(unsafe_hash=True)
+class A:
+    a: int
+
+@define
+class B(A):
+    pass
+
+reveal_type(B.__hash__)  # N: Revealed type is "None"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testManualOwnHashability]
+from attrs import define, frozen
+
+@define
+class A:
+    a: int
+    def __hash__(self) -> int:
+        ...
+
+reveal_type(A.__hash__)  # N: Revealed type is "def (self: __main__.A) -> builtins.int"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testSubclassDefaultLosesHashability]
+from attrs import define, frozen
+
+@define
+class A:
+    a: int
+    def __hash__(self) -> int:
+        ...
+
+@define
+class B(A):
+    pass
+
+reveal_type(B.__hash__)  # N: Revealed type is "None"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testSubclassEqFalseKeepsHashability]
+from attrs import define, frozen
+
+@define
+class A:
+    a: int
+    def __hash__(self) -> int:
+        ...
+
+@define(eq=False)
+class B(A):
+    pass
+
+reveal_type(B.__hash__)  # N: Revealed type is "def (self: __main__.A) -> builtins.int"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testSubclassingFrozenHashability]
+from attrs import define, frozen
+
+@define
+class A:
+    a: int
+
+@frozen
+class B(A):
+    pass
+
+reveal_type(B.__hash__)  # N: Revealed type is "def (self: builtins.object) -> builtins.int"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testSubclassingFrozenHashOffHashability]
+from attrs import define, frozen
+
+@define
+class A:
+    a: int
+    def __hash__(self) -> int:
+        ...
+
+@frozen(unsafe_hash=False)
+class B(A):
+    pass
+
+reveal_type(B.__hash__)  # N: Revealed type is "None"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testUnsafeHashPrecedence]
+from attrs import define, frozen
+
+@define(unsafe_hash=True, hash=False)
+class A:
+    pass
+reveal_type(A.__hash__)  # N: Revealed type is "def (self: builtins.object) -> builtins.int"
+
+@define(unsafe_hash=False, hash=True)
+class B:
+    pass
+reveal_type(B.__hash__)  # N: Revealed type is "None"
+
+[builtins fixtures/plugin_attrs.pyi]
+
+[case testAttrsStrictOptionalSetProperly]
+from typing import Generic, Optional, TypeVar
+
+import attr
+
+T = TypeVar("T")
+
+@attr.mutable()
+class Parent(Generic[T]):
+    run_type: Optional[int] = None
+
+@attr.mutable()
+class Child(Parent[float]):
+    pass
+
+Parent(run_type = None)
+c = Child(run_type = None)
+reveal_type(c.run_type)  # N: Revealed type is "Union[builtins.int, None]"
+[builtins fixtures/plugin_attrs.pyi]
diff --git a/test-data/unit/check-possibly-undefined.test b/test-data/unit/check-possibly-undefined.test
index ebceef88b537..ae277949c049 100644
--- a/test-data/unit/check-possibly-undefined.test
+++ b/test-data/unit/check-possibly-undefined.test
@@ -1026,3 +1026,20 @@ class B:
         else:
             # Same as above but in a loop.
             b = a  # E: Name "a" may be undefined
+
+[case testUnreachableCausingMissingTypeMap]
+# flags: --enable-error-code possibly-undefined --enable-error-code used-before-def --no-warn-unreachable
+# Regression test for https://github.com/python/mypy/issues/15958
+from typing import Union, NoReturn
+
+def assert_never(__x: NoReturn) -> NoReturn: ...
+
+def foo(x: Union[int, str]) -> None:
+    if isinstance(x, str):
+        f = "foo"
+    elif isinstance(x, int):
+        f = "bar"
+    else:
+        assert_never(x)
+    f  # OK
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-protocols.test b/test-data/unit/check-protocols.test
index 6976b8ee0a39..34e3f3e88080 100644
--- a/test-data/unit/check-protocols.test
+++ b/test-data/unit/check-protocols.test
@@ -319,10 +319,11 @@ 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
 from typing import Protocol
 
 class MyHashable(Protocol):
@@ -331,10 +332,9 @@ class MyHashable(Protocol):
 
 class C(MyHashable):
     __my_hash__ = None  # E: Incompatible types in assignment \
-(expression has type "None", base class "MyHashable" defined the type as "Callable[[MyHashable], int]")
+(expression has type "None", base class "MyHashable" defined the type as "Callable[[], int]")
 
 [case testProtocolsWithNoneAndStrictOptional]
-# flags: --strict-optional
 from typing import Protocol
 class P(Protocol):
     x = 0  # type: int
@@ -346,12 +346,12 @@ x: P = C() # Error!
 def f(x: P) -> None: pass
 f(C()) # Error!
 [out]
-main:9: error: Incompatible types in assignment (expression has type "C", variable has type "P")
-main:9: note: Following member(s) of "C" have conflicts:
-main:9: note:     x: expected "int", got "None"
-main:11: error: Argument 1 to "f" has incompatible type "C"; expected "P"
-main:11: note: Following member(s) of "C" have conflicts:
-main:11: note:     x: expected "int", got "None"
+main:8: error: Incompatible types in assignment (expression has type "C", variable has type "P")
+main:8: note: Following member(s) of "C" have conflicts:
+main:8: note:     x: expected "int", got "None"
+main:10: error: Argument 1 to "f" has incompatible type "C"; expected "P"
+main:10: note: Following member(s) of "C" have conflicts:
+main:10: note:     x: expected "int", got "None"
 
 -- Semanal errors in protocol types
 -- --------------------------------
@@ -667,7 +667,7 @@ def fun4(x: U, y: P[U, U]) -> U:
     pass
 reveal_type(fun4('a', C())) # N: Revealed type is "builtins.object"
 
-[case testUnrealtedGenericProtolsEquivalent]
+[case testUnrealtedGenericProtocolsEquivalent]
 from typing import TypeVar, Protocol
 T = TypeVar('T')
 
@@ -928,7 +928,7 @@ class L:
 
 def last(seq: Linked[T]) -> T:
     pass
-last(L()) # E: Argument 1 to "last" has incompatible type "L"; expected "Linked[<nothing>]"
+last(L()) # E: Argument 1 to "last" has incompatible type "L"; expected "Linked[Never]"
 
 [case testMutuallyRecursiveProtocols]
 from typing import Protocol, Sequence, List
@@ -1263,13 +1263,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 +1286,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 +1441,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 +1635,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):
@@ -1752,7 +1754,7 @@ if isinstance(c1i, P1):
 else:
     reveal_type(c1i) # Unreachable
 if isinstance(c1i, P):
-    reveal_type(c1i) # N: Revealed type is "__main__.<subclass of "C1" and "P">"
+    reveal_type(c1i) # N: Revealed type is "__main__.<subclass of "__main__.C1[builtins.int]" and "__main__.P">"
 else:
     reveal_type(c1i) # N: Revealed type is "__main__.C1[builtins.int]"
 
@@ -1764,7 +1766,7 @@ else:
 
 c2: C2
 if isinstance(c2, P):
-    reveal_type(c2) # N: Revealed type is "__main__.<subclass of "C2" and "P">"
+    reveal_type(c2) # N: Revealed type is "__main__.<subclass of "__main__.C2" and "__main__.P">"
 else:
     reveal_type(c2) # N: Revealed type is "__main__.C2"
 
@@ -2180,7 +2182,7 @@ main:11: note: Following member(s) of "B" have conflicts:
 main:11: note:     Expected:
 main:11: note:         def [T] f(self, x: T) -> None
 main:11: note:     Got:
-main:11: note:         def [S <: int, T] f(self, x: S, y: T) -> None
+main:11: note:         def [S: int, T] f(self, x: S, y: T) -> None
 
 [case testProtocolIncompatibilityWithGenericRestricted]
 from typing import Protocol, TypeVar
@@ -2200,7 +2202,7 @@ main:11: note: Following member(s) of "B" have conflicts:
 main:11: note:     Expected:
 main:11: note:         def [T] f(self, x: T) -> None
 main:11: note:     Got:
-main:11: note:         def [S in (int, str), T] f(self, x: S, y: T) -> None
+main:11: note:         def [S: (int, str), T] f(self, x: S, y: T) -> None
 
 [case testProtocolIncompatibilityWithManyOverloads]
 from typing import Protocol, overload
@@ -2337,8 +2339,7 @@ main:19: note: Protocol member AllSettable.b expected settable variable, got rea
 main:19: note:     <2 more conflict(s) not shown>
 
 [case testProtocolsMoreConflictsNotShown]
-from typing_extensions import Protocol
-from typing import Generic, TypeVar
+from typing import Generic, Protocol, TypeVar
 
 T = TypeVar('T')
 
@@ -2397,6 +2398,7 @@ x: P = None
 [out]
 
 [case testNoneSubtypeOfAllProtocolsWithoutStrictOptional]
+# flags: --no-strict-optional
 from typing import Protocol
 class P(Protocol):
     attr: int
@@ -2407,7 +2409,6 @@ x: P = None
 [out]
 
 [case testNoneSubtypeOfEmptyProtocolStrict]
-# flags: --strict-optional
 from typing import Protocol
 class P(Protocol):
     pass
@@ -2471,7 +2472,8 @@ def func(caller: Caller) -> None:
     pass
 
 func(call)
-func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[int, VarArg(str)], None]"; expected "Caller"
+func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[int, VarArg(str)], None]"; expected "Caller" \
+           # N: "Caller.__call__" has type "Callable[[Arg(str, 'x'), VarArg(int)], None]"
 [builtins fixtures/tuple.pyi]
 [out]
 
@@ -2508,7 +2510,8 @@ def func(caller: Caller) -> None:
     pass
 
 func(call)
-func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[int], int]"; expected "Caller"
+func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[int], int]"; expected "Caller" \
+           # N: "Caller.__call__" has type "Callable[[Arg(T, 'x')], T]"
 [builtins fixtures/tuple.pyi]
 [out]
 
@@ -2528,7 +2531,8 @@ def func(caller: Caller) -> None:
     pass
 
 func(call)
-func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[T], Tuple[T, T]]"; expected "Caller"
+func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[T], Tuple[T, T]]"; expected "Caller" \
+           # N: "Caller.__call__" has type "Callable[[Arg(int, 'x')], int]"
 [builtins fixtures/tuple.pyi]
 [out]
 
@@ -2555,7 +2559,8 @@ def func(caller: Caller) -> None:
     pass
 
 func(call)
-func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[Union[int, str]], Union[int, str]]"; expected "Caller"
+func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[Union[int, str]], Union[int, str]]"; expected "Caller" \
+           # N: "Caller.__call__" has type overloaded function
 [out]
 
 [case testCallableImplementsProtocolExtraNote]
@@ -2594,7 +2599,8 @@ def anon(caller: CallerAnon) -> None:
 
 
 func(call)
-func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[str], None]"; expected "Caller"
+func(bad)  # E: Argument 1 to "func" has incompatible type "Callable[[str], None]"; expected "Caller" \
+           # N: "Caller.__call__" has type "Callable[[Arg(str, 'x')], None]"
 anon(bad)
 [out]
 
@@ -2617,7 +2623,8 @@ a: Other
 b: Bad
 
 func(a)
-func(b)  # E: Argument 1 to "func" has incompatible type "Bad"; expected "One"
+func(b)  # E: Argument 1 to "func" has incompatible type "Bad"; expected "One" \
+         # N: "One.__call__" has type "Callable[[Arg(str, 'x')], None]"
 [out]
 
 [case testJoinProtocolCallback]
@@ -2759,8 +2766,7 @@ p: P = N(lambda a, b, c: 'foo')
 [builtins fixtures/property.pyi]
 
 [case testLiteralsAgainstProtocols]
-from typing import SupportsInt, SupportsAbs, TypeVar
-from typing_extensions import Literal, Final
+from typing import Final, Literal, SupportsInt, SupportsAbs, TypeVar
 
 T = TypeVar('T')
 def abs(x: SupportsAbs[T]) -> T: ...
@@ -2789,9 +2795,73 @@ 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 typing import Protocol
 
 class MyHashable(Protocol):
     def __hash__(self) -> int: ...
@@ -2834,6 +2904,7 @@ hs(None)
 
 
 [case testPartialTypeProtocol]
+# flags: --no-local-partial-types
 from typing import Protocol
 
 class Flapper(Protocol):
@@ -2872,7 +2943,7 @@ class DataArray(ObjectHashable):
 
 
 [case testPartialAttributeNoneType]
-# flags: --no-strict-optional
+# flags: --no-strict-optional --no-local-partial-types
 from typing import Optional, Protocol, runtime_checkable
 
 @runtime_checkable
@@ -2890,7 +2961,7 @@ class MyClass:
 
 
 [case testPartialAttributeNoneTypeStrictOptional]
-# flags: --strict-optional
+# flags: --no-local-partial-types
 from typing import Optional, Protocol, runtime_checkable
 
 @runtime_checkable
@@ -3011,7 +3082,6 @@ def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
 round(C(), 1)
 
 [case testEmptyBodyImplicitlyAbstractProtocol]
-# flags: --strict-optional
 from typing import Protocol, overload, Union
 
 class P1(Protocol):
@@ -3058,7 +3128,6 @@ C3()
 [builtins fixtures/classmethod.pyi]
 
 [case testEmptyBodyImplicitlyAbstractProtocolProperty]
-# flags: --strict-optional
 from typing import Protocol
 
 class P1(Protocol):
@@ -3153,7 +3222,6 @@ D() # E: Cannot instantiate abstract class "D" with abstract attribute "meth"
 [builtins fixtures/exception.pyi]
 
 [case testEmptyBodyNoneCompatibleProtocol]
-# flags: --strict-optional
 from abc import abstractmethod
 from typing import Any, Optional, Protocol, Union, overload
 from typing_extensions import TypeAlias
@@ -3527,7 +3595,8 @@ test(C)  # E: Argument 1 to "test" has incompatible type "Type[C]"; expected "P"
          # N:     Expected: \
          # N:         def __call__(x: int, y: int) -> Any \
          # N:     Got: \
-         # N:         def __init__(x: int, y: str) -> C
+         # N:         def __init__(x: int, y: str) -> C \
+         # N: "P.__call__" has type "Callable[[Arg(int, 'x'), Arg(int, 'y')], Any]"
 
 [case testProtocolClassObjectPureCallback]
 from typing import Any, ClassVar, Protocol
@@ -3548,7 +3617,8 @@ test(C)  # E: Argument 1 to "test" has incompatible type "Type[C]"; expected "P"
          # N:     Expected: \
          # N:         def __call__(x: int, y: int) -> Any \
          # N:     Got: \
-         # N:         def __init__(x: int, y: str) -> C
+         # N:         def __init__(x: int, y: str) -> C \
+         # N: "P.__call__" has type "Callable[[Arg(int, 'x'), Arg(int, 'y')], Any]"
 [builtins fixtures/type.pyi]
 
 [case testProtocolClassObjectCallableError]
@@ -3898,7 +3968,7 @@ func(some_module)  # E: Argument 1 to "func" has incompatible type Module; expec
                    # N: Protocol member My.a expected settable variable, got read-only attribute
 
 [file some_module.py]
-from typing_extensions import Final
+from typing import Final
 
 a: Final = 1
 [builtins fixtures/module.pyi]
@@ -4065,3 +4135,328 @@ class P(Protocol):
 
 class C(P): ...
 C(0)  # OK
+
+[case testTypeVarValueConstraintAgainstGenericProtocol]
+from typing import TypeVar, Generic, Protocol, overload
+
+T_contra = TypeVar("T_contra", contravariant=True)
+AnyStr = TypeVar("AnyStr", str, bytes)
+
+class SupportsWrite(Protocol[T_contra]):
+    def write(self, s: T_contra, /) -> None: ...
+
+class Buffer: ...
+
+class IO(Generic[AnyStr]):
+    @overload
+    def write(self: IO[bytes], s: Buffer, /) -> None: ...
+    @overload
+    def write(self, s: AnyStr, /) -> None: ...
+    def write(self, s): ...
+
+def foo(fdst: SupportsWrite[AnyStr]) -> None: ...
+
+x: IO[str]
+foo(x)
+
+[case testTypeVarValueConstraintAgainstGenericProtocol2]
+from typing import Generic, Protocol, TypeVar, overload
+
+AnyStr = TypeVar("AnyStr", str, bytes)
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
+
+class SupportsRead(Generic[T_co]):
+    def read(self) -> T_co: ...
+
+class SupportsWrite(Protocol[T_contra]):
+    def write(self, s: T_contra) -> object: ...
+
+def copyfileobj(fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr]) -> None: ...
+
+class WriteToMe(Generic[AnyStr]):
+    @overload
+    def write(self: WriteToMe[str], s: str) -> int: ...
+    @overload
+    def write(self: WriteToMe[bytes], s: bytes) -> int: ...
+    def write(self, s): ...
+
+class WriteToMeOrReadFromMe(WriteToMe[AnyStr], SupportsRead[AnyStr]): ...
+
+copyfileobj(WriteToMeOrReadFromMe[bytes](), WriteToMe[bytes]())
+
+[case testOverloadedMethodWithExplicitSelfTypes]
+from typing import Generic, overload, Protocol, TypeVar, Union
+
+AnyStr = TypeVar("AnyStr", str, bytes)
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
+
+class SupportsRead(Protocol[T_co]):
+    def read(self) -> T_co: ...
+
+class SupportsWrite(Protocol[T_contra]):
+    def write(self, s: T_contra) -> int: ...
+
+class Input(Generic[AnyStr]):
+    def read(self) -> AnyStr: ...
+
+class Output(Generic[AnyStr]):
+    @overload
+    def write(self: Output[str], s: str) -> int: ...
+    @overload
+    def write(self: Output[bytes], s: bytes) -> int: ...
+    def write(self, s: Union[str, bytes]) -> int: ...
+
+def f(src: SupportsRead[AnyStr], dst: SupportsWrite[AnyStr]) -> None: ...
+
+def g1(a: Input[bytes], b: Output[bytes]) -> None:
+    f(a, b)
+
+def g2(a: Input[bytes], b: Output[bytes]) -> None:
+    f(a, b)
+
+def g3(a: Input[str], b: Output[bytes]) -> None:
+    f(a, b)  # E: Cannot infer type argument 1 of "f"
+
+def g4(a: Input[bytes], b: Output[str]) -> None:
+    f(a, b)  # E: Cannot infer type argument 1 of "f"
+
+[builtins fixtures/tuple.pyi]
+
+[case testOverloadProtocolSubtyping]
+from typing import Protocol, Self, overload
+
+class NumpyFloat:
+    __add__: "FloatOP"
+
+class FloatOP(Protocol):
+    @overload
+    def __call__(self, other: float) -> NumpyFloat: ...
+    @overload
+    def __call__(self, other: NumpyFloat) -> NumpyFloat: ...
+
+class SupportsAdd(Protocol):
+    @overload
+    def __add__(self, other: float) -> Self: ...
+    @overload
+    def __add__(self, other: NumpyFloat) -> Self: ...
+
+x: SupportsAdd = NumpyFloat()
+[builtins fixtures/tuple.pyi]
+
+[case testSetterPropertyProtocolSubtypingBoth]
+from typing import Protocol
+
+class B1: ...
+class C1(B1): ...
+class B2: ...
+class C2(B2): ...
+
+class P1(Protocol):
+    @property
+    def foo(self) -> B1: ...
+    @foo.setter
+    def foo(self, x: C2) -> None: ...
+
+class P2(Protocol):
+    @property
+    def foo(self) -> B1: ...
+    @foo.setter
+    def foo(self, x: B2) -> None: ...
+
+class A1:
+    @property
+    def foo(self) -> B1: ...
+    @foo.setter
+    def foo(self, x: C2) -> None: ...
+
+class A2:
+    @property
+    def foo(self) -> C1: ...
+    @foo.setter
+    def foo(self, x: C2) -> None: ...
+
+class A3:
+    @property
+    def foo(self) -> C1: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+
+class A4:
+    @property
+    def foo(self) -> str: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+
+def f1(x: P1) -> None: ...
+def f2(x: P2) -> None: ...
+
+a1: A1
+a2: A2
+a3: A3
+a4: A4
+
+f1(a1)
+f1(a2)
+f1(a3)  # E: Argument 1 to "f1" has incompatible type "A3"; expected "P1" \
+        # N: Following member(s) of "A3" have conflicts: \
+        # N:     foo: expected setter type "C2", got "str"
+f1(a4)  # E: Argument 1 to "f1" has incompatible type "A4"; expected "P1" \
+        # N: Following member(s) of "A4" have conflicts: \
+        # N:     foo: expected "B1", got "str" \
+        # N:     foo: expected setter type "C2", got "str"
+
+f2(a1)  # E: Argument 1 to "f2" has incompatible type "A1"; expected "P2" \
+        # N: Following member(s) of "A1" have conflicts: \
+        # N:     foo: expected setter type "B2", got "C2" \
+        # N:     Setter types should behave contravariantly
+f2(a2)  # E: Argument 1 to "f2" has incompatible type "A2"; expected "P2" \
+        # N: Following member(s) of "A2" have conflicts: \
+        # N:     foo: expected setter type "B2", got "C2" \
+        # N:     Setter types should behave contravariantly
+f2(a3)  # E: Argument 1 to "f2" has incompatible type "A3"; expected "P2" \
+        # N: Following member(s) of "A3" have conflicts: \
+        # N:     foo: expected setter type "B2", got "str"
+f2(a4)  # E: Argument 1 to "f2" has incompatible type "A4"; expected "P2" \
+        # N: Following member(s) of "A4" have conflicts: \
+        # N:     foo: expected "B1", got "str" \
+        # N:     foo: expected setter type "B2", got "str"
+[builtins fixtures/property.pyi]
+
+[case testSetterPropertyProtocolSubtypingVarSuper]
+from typing import Protocol
+
+class B1: ...
+class C1(B1): ...
+
+class P1(Protocol):
+    foo: B1
+
+class P2(Protocol):
+    foo: C1
+
+class A1:
+    @property
+    def foo(self) -> B1: ...
+    @foo.setter
+    def foo(self, x: C1) -> None: ...
+
+class A2:
+    @property
+    def foo(self) -> C1: ...
+    @foo.setter
+    def foo(self, x: B1) -> None: ...
+
+class A3:
+    @property
+    def foo(self) -> C1: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+
+class A4:
+    @property
+    def foo(self) -> str: ...
+    @foo.setter
+    def foo(self, x: str) -> None: ...
+
+def f1(x: P1) -> None: ...
+def f2(x: P2) -> None: ...
+
+a1: A1
+a2: A2
+a3: A3
+a4: A4
+
+f1(a1)  # E: Argument 1 to "f1" has incompatible type "A1"; expected "P1" \
+        # N: Following member(s) of "A1" have conflicts: \
+        # N:     foo: expected setter type "B1", got "C1" \
+        # N:     Setter types should behave contravariantly
+f1(a2)
+f1(a3)  # E: Argument 1 to "f1" has incompatible type "A3"; expected "P1" \
+        # N: Following member(s) of "A3" have conflicts: \
+        # N:     foo: expected setter type "B1", got "str"
+f1(a4)  # E: Argument 1 to "f1" has incompatible type "A4"; expected "P1" \
+        # N: Following member(s) of "A4" have conflicts: \
+        # N:     foo: expected "B1", got "str"
+
+f2(a1)  # E: Argument 1 to "f2" has incompatible type "A1"; expected "P2" \
+        # N: Following member(s) of "A1" have conflicts: \
+        # N:     foo: expected "C1", got "B1"
+f2(a2)
+f2(a3)  # E: Argument 1 to "f2" has incompatible type "A3"; expected "P2" \
+        # N: Following member(s) of "A3" have conflicts: \
+        # N:     foo: expected setter type "C1", got "str"
+f2(a4)  # E: Argument 1 to "f2" has incompatible type "A4"; expected "P2" \
+        # N: Following member(s) of "A4" have conflicts: \
+        # N:     foo: expected "C1", got "str"
+[builtins fixtures/property.pyi]
+
+[case testSetterPropertyProtocolSubtypingVarSub]
+from typing import Protocol
+
+class B1: ...
+class C1(B1): ...
+class B2: ...
+class C2(B2): ...
+
+class P1(Protocol):
+    @property
+    def foo(self) -> B1: ...
+    @foo.setter
+    def foo(self, x: C2) -> None: ...
+
+class P2(Protocol):
+    @property
+    def foo(self) -> B1: ...
+    @foo.setter
+    def foo(self, x: C1) -> None: ...
+
+class A1:
+    foo: B1
+
+class A2:
+    foo: B2
+
+class A3:
+    foo: C2
+
+class A4:
+    foo: str
+
+def f1(x: P1) -> None: ...
+def f2(x: P2) -> None: ...
+
+a1: A1
+a2: A2
+a3: A3
+a4: A4
+
+f1(a1)  # E: Argument 1 to "f1" has incompatible type "A1"; expected "P1" \
+        # N: Following member(s) of "A1" have conflicts: \
+        # N:     foo: expected setter type "C2", got "B1"
+f1(a2)  # E: Argument 1 to "f1" has incompatible type "A2"; expected "P1" \
+        # N: Following member(s) of "A2" have conflicts: \
+        # N:     foo: expected "B1", got "B2"
+f1(a3)  # E: Argument 1 to "f1" has incompatible type "A3"; expected "P1" \
+        # N: Following member(s) of "A3" have conflicts: \
+        # N:     foo: expected "B1", got "C2"
+f1(a4)  # E: Argument 1 to "f1" has incompatible type "A4"; expected "P1" \
+        # N: Following member(s) of "A4" have conflicts: \
+        # N:     foo: expected "B1", got "str" \
+        # N:     foo: expected setter type "C2", got "str"
+
+f2(a1)
+f2(a2)  # E: Argument 1 to "f2" has incompatible type "A2"; expected "P2" \
+        # N: Following member(s) of "A2" have conflicts: \
+        # N:     foo: expected "B1", got "B2" \
+        # N:     foo: expected setter type "C1", got "B2"
+f2(a3)  # E: Argument 1 to "f2" has incompatible type "A3"; expected "P2" \
+        # N: Following member(s) of "A3" have conflicts: \
+        # N:     foo: expected "B1", got "C2" \
+        # N:     foo: expected setter type "C1", got "C2"
+f2(a4)  # E: Argument 1 to "f2" has incompatible type "A4"; expected "P2" \
+        # N: Following member(s) of "A4" have conflicts: \
+        # N:     foo: expected "B1", got "str" \
+        # N:     foo: expected setter type "C1", got "str"
+[builtins fixtures/property.pyi]
diff --git a/test-data/unit/check-python310.test b/test-data/unit/check-python310.test
index feedd02d82eb..af3982f6accd 100644
--- a/test-data/unit/check-python310.test
+++ b/test-data/unit/check-python310.test
@@ -64,7 +64,7 @@ m: A
 
 match m:
     case b.b:
-        reveal_type(m)  # N: Revealed type is "__main__.<subclass of "A" and "B">1"
+        reveal_type(m)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "b.B">"
 [file b.py]
 class B: ...
 b: B
@@ -332,6 +332,54 @@ match [SubClass("a"), SubClass("b")]:
         reveal_type(rest)  # N: Revealed type is "builtins.list[__main__.Example]"
 [builtins fixtures/tuple.pyi]
 
+# Narrowing union-based values via a literal pattern on an indexed/attribute subject
+# -------------------------------------------------------------------------------
+# Literal patterns against a union of types can be used to narrow the subject
+# itself, not just the expression being matched. Previously, the patterns below
+# failed to narrow the `d` variable, leading to errors for missing members; we
+# now propagate the type information up to the parent.
+
+[case testMatchNarrowingUnionTypedDictViaIndex]
+from typing import Literal, TypedDict
+
+class A(TypedDict):
+    tag: Literal["a"]
+    name: str
+
+class B(TypedDict):
+    tag: Literal["b"]
+    num: int
+
+d: A | B
+match d["tag"]:
+    case "a":
+        reveal_type(d)  # N: Revealed type is "TypedDict('__main__.A', {'tag': Literal['a'], 'name': builtins.str})"
+        reveal_type(d["name"])  # N: Revealed type is "builtins.str"
+    case "b":
+        reveal_type(d)  # N: Revealed type is "TypedDict('__main__.B', {'tag': Literal['b'], 'num': builtins.int})"
+        reveal_type(d["num"])  # N: Revealed type is "builtins.int"
+[typing fixtures/typing-typeddict.pyi]
+
+[case testMatchNarrowingUnionClassViaAttribute]
+from typing import Literal
+
+class A:
+    tag: Literal["a"]
+    name: str
+
+class B:
+    tag: Literal["b"]
+    num: int
+
+d: A | B
+match d.tag:
+    case "a":
+        reveal_type(d)  # N: Revealed type is "__main__.A"
+        reveal_type(d.name)  # N: Revealed type is "builtins.str"
+    case "b":
+        reveal_type(d)  # N: Revealed type is "__main__.B"
+        reveal_type(d.num)  # N: Revealed type is "builtins.int"
+
 [case testMatchSequenceUnion-skip]
 from typing import List, Union
 m: Union[List[List[str]], str]
@@ -341,6 +389,72 @@ match m:
         reveal_type(m)  # N: Revealed type is "builtins.list[builtins.list[builtins.str]]"
 [builtins fixtures/list.pyi]
 
+[case testMatchSequencePatternNarrowSubjectItems]
+m: int
+n: str
+o: bool
+
+match m, n, o:
+    case [3, "foo", True]:
+        reveal_type(m)  # N: Revealed type is "Literal[3]"
+        reveal_type(n)  # N: Revealed type is "Literal['foo']"
+        reveal_type(o)  # N: Revealed type is "Literal[True]"
+    case [a, b, c]:
+        reveal_type(m)  # N: Revealed type is "builtins.int"
+        reveal_type(n)  # N: Revealed type is "builtins.str"
+        reveal_type(o)  # N: Revealed type is "builtins.bool"
+
+reveal_type(m)  # N: Revealed type is "builtins.int"
+reveal_type(n)  # N: Revealed type is "builtins.str"
+reveal_type(o)  # N: Revealed type is "builtins.bool"
+[builtins fixtures/tuple.pyi]
+
+[case testMatchSequencePatternNarrowSubjectItemsRecursive]
+m: int
+n: int
+o: int
+p: int
+q: int
+r: int
+
+match m, (n, o), (p, (q, r)):
+    case [0, [1, 2], [3, [4, 5]]]:
+        reveal_type(m)  # N: Revealed type is "Literal[0]"
+        reveal_type(n)  # N: Revealed type is "Literal[1]"
+        reveal_type(o)  # N: Revealed type is "Literal[2]"
+        reveal_type(p)  # N: Revealed type is "Literal[3]"
+        reveal_type(q)  # N: Revealed type is "Literal[4]"
+        reveal_type(r)  # N: Revealed type is "Literal[5]"
+[builtins fixtures/tuple.pyi]
+
+[case testMatchSequencePatternSequencesLengthMismatchNoNarrowing]
+m: int
+n: str
+o: bool
+
+match m, n, o:
+    case [3, "foo"]:
+        pass
+    case [3, "foo", True, True]:
+        pass
+[builtins fixtures/tuple.pyi]
+
+[case testMatchSequencePatternSequencesLengthMismatchNoNarrowingRecursive]
+m: int
+n: int
+o: int
+
+match m, (n, o):
+    case [0]:
+        pass
+    case [0, 1, [2]]:
+        pass
+    case [0, [1]]:
+        pass
+    case [0, [1, 2, 3]]:
+        pass
+[builtins fixtures/tuple.pyi]
+
 -- Mapping Pattern --
 
 [case testMatchMappingPatternCaptures]
@@ -582,6 +696,25 @@ match m:
         reveal_type(m)  # N: Revealed type is "builtins.tuple[Any, ...]"
 [builtins fixtures/primitives.pyi]
 
+[case testMatchClassPatternCaptureSelfSubtype]
+class A(str):
+    pass
+
+class B(str):
+    __match_args__ = ("b",)
+    b: int
+
+def f1(x: A):
+    match x:
+        case A(a):
+            reveal_type(a)  # N: Revealed type is "__main__.A"
+
+def f2(x: B):
+    match x:
+        case B(b):
+            reveal_type(b)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
 [case testMatchInvalidClassPattern]
 m: object
 
@@ -685,6 +818,21 @@ match m:
         reveal_type(j)  # N: Revealed type is "builtins.int"
 [builtins fixtures/tuple.pyi]
 
+[case testMatchSequencePatternCaptureNamedTuple]
+from typing import NamedTuple
+
+class N(NamedTuple):
+    x: int
+    y: str
+
+a = N(1, "a")
+
+match a:
+    case [x, y]:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+        reveal_type(y)  # N: Revealed type is "builtins.str"
+[builtins fixtures/tuple.pyi]
+
 [case testMatchClassPatternCaptureGeneric]
 from typing import Generic, TypeVar
 
@@ -700,6 +848,21 @@ match m:
         reveal_type(m)  # N: Revealed type is "__main__.A[Any]"
         reveal_type(i)  # N: Revealed type is "Any"
 
+[case testMatchClassPatternCaptureVariadicGeneric]
+from typing import Generic, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple('Ts')
+class A(Generic[Unpack[Ts]]):
+    a: Tuple[Unpack[Ts]]
+
+m: object
+match m:
+    case A(a=i):
+        reveal_type(m)  # N: Revealed type is "__main__.A[Unpack[builtins.tuple[Any, ...]]]"
+        reveal_type(i)  # N: Revealed type is "builtins.tuple[Any, ...]"
+[builtins fixtures/tuple.pyi]
+
 [case testMatchClassPatternCaptureGenericAlreadyKnown]
 from typing import Generic, TypeVar
 
@@ -833,9 +996,9 @@ m: B
 
 match m:
     case A():
-        reveal_type(m)  # N: Revealed type is "__main__.<subclass of "B" and "A">2"
+        reveal_type(m)  # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
     case A(i, j):
-        reveal_type(m)  # N: Revealed type is "__main__.<subclass of "B" and "A">3"
+        reveal_type(m)  # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
 [builtins fixtures/tuple.pyi]
 
 [case testMatchClassPatternNonexistentKeyword]
@@ -896,6 +1059,16 @@ match m:
         reveal_type(i)
         reveal_type(j)
 
+[case testMatchClassPatternAny]
+from typing import Any
+
+Foo: Any
+m: object
+
+match m:
+    case Foo():
+        pass
+
 [case testMatchClassPatternNestedGenerics]
 # From cpython test_patma.py
 x = [[{0: 0}]]
@@ -906,7 +1079,7 @@ match x:
 reveal_type(x)  # N: Revealed type is "builtins.list[builtins.list[builtins.dict[builtins.int, builtins.int]]]"
 reveal_type(y)  # N: Revealed type is "builtins.int"
 reveal_type(z)  # N: Revealed type is "builtins.int"
-[builtins fixtures/dict.pyi]
+[builtins fixtures/dict-full.pyi]
 
 [case testMatchNonFinalMatchArgs]
 class A:
@@ -1114,6 +1287,36 @@ match m:
 
 reveal_type(a)  # N: Revealed type is "builtins.str"
 
+[case testMatchCapturePatternFromFunctionReturningUnion]
+def func1(arg: bool) -> str | int: ...
+def func2(arg: bool) -> bytes | int: ...
+
+def main() -> None:
+    match func1(True):
+        case str(a):
+            match func2(True):
+                case c:
+                    reveal_type(a)  # N: Revealed type is "builtins.str"
+                    reveal_type(c)  # N: Revealed type is "Union[builtins.bytes, builtins.int]"
+            reveal_type(a)  # N: Revealed type is "builtins.str"
+        case a:
+            reveal_type(a)  # N: Revealed type is "builtins.int"
+
+[case testMatchCapturePatternFromAsyncFunctionReturningUnion-xfail]
+async def func1(arg: bool) -> str | int: ...
+async def func2(arg: bool) -> bytes | int: ...
+
+async def main() -> None:
+    match await func1(True):
+        case str(a):
+            match await func2(True):
+                case c:
+                    reveal_type(a)  # N: Revealed type is "builtins.str"
+                    reveal_type(c)  # N: Revealed type is "Union[builtins.bytes, builtins.int]"
+            reveal_type(a)  # N: Revealed type is "builtins.str"
+        case a:
+            reveal_type(a)  # N: Revealed type is "builtins.int"
+
 -- Guards --
 
 [case testMatchSimplePatternGuard]
@@ -1140,12 +1343,11 @@ match m:
         reveal_type(a)
 
 [case testMatchRedefiningPatternGuard]
-# flags: --strict-optional
 m: str
 
 match m:
     case a if a := 1:  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-        reveal_type(a)  # N: Revealed type is "<nothing>"
+        reveal_type(a)  # N: Revealed type is "Literal[1]?"
 
 [case testMatchAssigningPatternGuard]
 m: str
@@ -1170,7 +1372,7 @@ m: A
 
 match m:
     case a if isinstance(a, B):
-        reveal_type(a)  # N: Revealed type is "__main__.<subclass of "A" and "B">"
+        reveal_type(a)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testMatchUnreachablePatternGuard]
@@ -1286,7 +1488,7 @@ def f(value: int) -> int:  # E: Missing return statement
         case 2:
             return 1
         case o:
-            assert_never(o)  # E: Argument 1 to "assert_never" has incompatible type "int"; expected "NoReturn"
+            assert_never(o)  # E: Argument 1 to "assert_never" has incompatible type "int"; expected "Never"
 
 [case testMatchExhaustiveNoError]
 from typing import NoReturn, Union, Literal
@@ -1303,7 +1505,7 @@ def f(value: Literal[1] | Literal[2]) -> int:
 [typing fixtures/typing-medium.pyi]
 
 [case testMatchSequencePatternNegativeNarrowing]
-from typing import Union, Sequence, Tuple
+from typing import Literal, Union, Sequence, Tuple
 
 m1: Sequence[int | str]
 
@@ -1328,8 +1530,56 @@ match m3:
         reveal_type(m3)  # N: Revealed type is "Tuple[Literal[1]]"
     case r2:
         reveal_type(m3)  # N: Revealed type is "Tuple[Union[builtins.int, builtins.str]]"
+
+m4: Tuple[Literal[1], int]
+
+match m4:
+    case (1, 5):
+        reveal_type(m4)  # N: Revealed type is "Tuple[Literal[1], Literal[5]]"
+    case (1, 6):
+        reveal_type(m4)  # N: Revealed type is "Tuple[Literal[1], Literal[6]]"
+    case _:
+        reveal_type(m4)  # N: Revealed type is "Tuple[Literal[1], builtins.int]"
+
+m5: Tuple[Literal[1, 2], Literal["a", "b"]]
+
+match m5:
+    case (1, str()):
+        reveal_type(m5)  # N: Revealed type is "Tuple[Literal[1], Union[Literal['a'], Literal['b']]]"
+    case _:
+        reveal_type(m5)  # N: Revealed type is "Tuple[Literal[2], Union[Literal['a'], Literal['b']]]"
+
+m6: Tuple[Literal[1, 2], Literal["a", "b"]]
+
+match m6:
+    case (1, "a"):
+        reveal_type(m6)  # N: Revealed type is "Tuple[Literal[1], Literal['a']]"
+    case _:
+        reveal_type(m6)  # N: Revealed type is "Tuple[Union[Literal[1], Literal[2]], Union[Literal['a'], Literal['b']]]"
+
 [builtins fixtures/tuple.pyi]
 
+[case testMatchEnumSingleChoice]
+from enum import Enum
+from typing import NoReturn
+
+def assert_never(x: NoReturn) -> None: ...
+
+class Medal(Enum):
+    gold = 1
+
+def f(m: Medal) -> None:
+    always_assigned: int | None = None
+    match m:
+        case Medal.gold:
+            always_assigned = 1
+            reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
+        case _:
+            assert_never(m)
+
+    reveal_type(always_assigned)  # N: Revealed type is "builtins.int"
+[builtins fixtures/bool.pyi]
+
 [case testMatchLiteralPatternEnumNegativeNarrowing]
 from enum import Enum
 class Medal(Enum):
@@ -1349,11 +1599,70 @@ def f(m: Medal) -> int:
 def g(m: Medal) -> int:
     match m:
         case Medal.gold:
+            reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
             return 0
         case Medal.silver:
+            reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.silver]"
             return 1
         case Medal.bronze:
+            reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.bronze]"
             return 2
+[builtins fixtures/enum.pyi]
+
+
+[case testMatchLiteralPatternEnumWithTypedAttribute]
+from enum import Enum
+from typing import NoReturn
+def assert_never(x: NoReturn) -> None: ...
+
+class int:
+    def __new__(cls, value: int): pass
+
+class Medal(int, Enum):
+    prize: str
+
+    def __new__(cls, value: int, prize: str) -> Medal:
+        enum = int.__new__(cls, value)
+        enum._value_ = value
+        enum.prize = prize
+        return enum
+
+    gold = (1, 'cash prize')
+    silver = (2, 'sponsorship')
+    bronze = (3, 'nothing')
+
+m: Medal
+
+match m:
+    case Medal.gold:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
+    case Medal.silver:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.silver]"
+    case Medal.bronze:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.bronze]"
+    case _ as unreachable:
+        assert_never(unreachable)
+
+[builtins fixtures/tuple.pyi]
+
+[case testMatchLiteralPatternFunctionalEnum]
+from enum import Enum
+from typing import NoReturn
+def assert_never(x: NoReturn) -> None: ...
+
+Medal = Enum('Medal', 'gold silver bronze')
+m: Medal
+
+match m:
+    case Medal.gold:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
+    case Medal.silver:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.silver]"
+    case Medal.bronze:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.bronze]"
+    case _ as unreachable:
+        assert_never(unreachable)
+[builtins fixtures/enum.pyi]
 
 [case testMatchLiteralPatternEnumCustomEquals-skip]
 from enum import Enum
@@ -1371,9 +1680,10 @@ match m:
         reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
     case _:
         reveal_type(m)  # N: Revealed type is "__main__.Medal"
+[builtins fixtures/enum.pyi]
 
 [case testMatchNarrowUsingPatternGuardSpecialCase]
-def f(x: int | str) -> int:  # E: Missing return statement
+def f(x: int | str) -> int:
     match x:
         case x if isinstance(x, str):
             return 0
@@ -1382,7 +1692,6 @@ def f(x: int | str) -> int:  # E: Missing return statement
 [builtins fixtures/isinstance.pyi]
 
 [case testMatchNarrowDownUnionPartially]
-# flags: --strict-optional
 
 def f(x: int | str) -> None:
     match x:
@@ -1449,6 +1758,7 @@ def union(x: str | bool) -> None:
         case True:
             return
     reveal_type(x)  # N: Revealed type is "Union[builtins.str, Literal[False]]"
+[builtins fixtures/tuple.pyi]
 
 [case testMatchAssertFalseToSilenceFalsePositives]
 class C:
@@ -1479,6 +1789,22 @@ def f(x: int | str) -> int:
         case str() as s:
             return 1
 
+[case testMatchOrPatternExhaustiveness]
+from typing import NoReturn, Literal
+def assert_never(x: NoReturn) -> None: ...
+
+Color = Literal["blue", "green", "red"]
+c: Color
+
+match c:
+    case "blue":
+        reveal_type(c) # N: Revealed type is "Literal['blue']"
+    case "green" | "notColor":
+        reveal_type(c) # N: Revealed type is "Literal['green']"
+    case _:
+        assert_never(c) # E: Argument 1 to "assert_never" has incompatible type "Literal['red']"; expected "Never"
+[typing fixtures/typing-typeddict.pyi]
+
 [case testMatchAsPatternIntersection-skip]
 class A: pass
 class B: pass
@@ -1487,13 +1813,12 @@ class C: pass
 def f(x: A) -> None:
     match x:
         case B() as y:
-            reveal_type(y)  # N: Revealed type is "__main__.<subclass of "A" and "B">"
+            reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
         case C() as y:
-            reveal_type(y)  # N: Revealed type is "__main__.<subclass of "A" and "C">"
-    reveal_type(y)  # N: Revealed type is "Union[__main__.<subclass of "A" and "B">, __main__.<subclass of "A" and "C">]"
+            reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.C">"
+    reveal_type(y)  # N: Revealed type is "Union[__main__.<subclass of "__main__.A" and "__main__.B">, __main__.<subclass of "__main__.A" and "__main__.C">]"
 
 [case testMatchWithBreakAndContinue]
-# flags: --strict-optional
 def f(x: int | str | None) -> None:
     i = int()
     while i:
@@ -1571,8 +1896,8 @@ class AnnAssign(stmt):
    value: str
    simple: int
 
-reveal_type(AST.__match_args__)  # N: Revealed type is "Tuple[]"
-reveal_type(stmt.__match_args__)  # N: Revealed type is "Tuple[]"
+reveal_type(AST.__match_args__)  # N: Revealed type is "Tuple[()]"
+reveal_type(stmt.__match_args__)  # N: Revealed type is "Tuple[()]"
 reveal_type(AnnAssign.__match_args__)  # N: Revealed type is "Tuple[Literal['target']?, Literal['annotation']?, Literal['value']?, Literal['simple']?]"
 
 AnnAssign.__match_args__ = ('a', 'b', 'c', 'd')  # E: Cannot assign to "__match_args__"
@@ -1626,7 +1951,6 @@ def func(e: Union[str, tuple[str]]) -> None:
 [builtins fixtures/tuple.pyi]
 
 [case testMatchTupleOptionalNoCrash]
-# flags: --strict-optional
 foo: tuple[int] | None
 match foo:
     case x,:
@@ -1645,8 +1969,7 @@ match var:
 [builtins fixtures/tuple.pyi]
 
 [case testMatchNamedAndKeywordsAreTheSame]
-from typing import Generic, TypeVar, Union
-from typing_extensions import Final
+from typing import Generic, Final, TypeVar, Union
 from dataclasses import dataclass
 
 T = TypeVar("T")
@@ -1655,7 +1978,7 @@ class Regular:
     x: str
     y: int
     __match_args__ = ("x",)
-class ReveresedOrder:
+class ReversedOrder:
     x: int
     y: str
     __match_args__ = ("y",)
@@ -1673,7 +1996,7 @@ class GenericDataclass(Generic[T]):
 
 input_arg: Union[
     Regular,
-    ReveresedOrder,
+    ReversedOrder,
     GenericRegular[str],
     GenericWithFinal[str],
     RegularSubtype,
@@ -1684,7 +2007,7 @@ input_arg: Union[
 match input_arg:
     case Regular(a):
         reveal_type(a)  # N: Revealed type is "builtins.str"
-    case ReveresedOrder(a):
+    case ReversedOrder(a):
         reveal_type(a)  # N: Revealed type is "builtins.str"
     case GenericWithFinal(a):
         reveal_type(a)  # N: Revealed type is "builtins.str"
@@ -1699,7 +2022,7 @@ match input_arg:
 match input_arg:
     case Regular(x=a):
         reveal_type(a)  # N: Revealed type is "builtins.str"
-    case ReveresedOrder(x=b):  # Order is different
+    case ReversedOrder(x=b):  # Order is different
         reveal_type(b)  # N: Revealed type is "builtins.int"
     case GenericWithFinal(x=a):
         reveal_type(a)  # N: Revealed type is "builtins.str"
@@ -1865,7 +2188,6 @@ def f() -> None:
             reveal_type(y.a)  # N: Revealed type is "builtins.int"
 
 [case testNarrowedVariableInNestedModifiedInMatch]
-# flags: --strict-optional
 from typing import Optional
 
 def match_stmt_error1(x: Optional[str]) -> None:
@@ -1958,3 +2280,382 @@ 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]
+
+[case testMatchGuardReachability]
+# flags: --warn-unreachable
+def f1(e: int) -> int:
+    match e:
+        case x if True:
+            return x
+        case _:
+            return 0  # E: Statement is unreachable
+    e = 0  # E: Statement is unreachable
+
+
+def f2(e: int) -> int:
+    match e:
+        case x if bool():
+            return x
+        case _:
+            return 0
+    e = 0  # E: Statement is unreachable
+
+def f3(e: int | str | bytes) -> int:
+    match e:
+        case x if isinstance(x, int):
+            return x
+        case [x]:
+            return 0  # E: Statement is unreachable
+        case str(x):
+            return 0
+    reveal_type(e)  # N: Revealed type is "builtins.bytes"
+    return 0
+
+def f4(e: int | str | bytes) -> int:
+    match e:
+        case int(x):
+            pass
+        case [x]:
+            return 0  # E: Statement is unreachable
+        case x if isinstance(x, str):
+            return 0
+    reveal_type(e)  # N: Revealed type is "Union[builtins.int, builtins.bytes]"
+    return 0
+
+[builtins fixtures/primitives.pyi]
+
+[case testMatchSequencePatternVariadicTupleNotTooShort]
+from typing import Tuple
+from typing_extensions import Unpack
+
+fm1: Tuple[int, int, Unpack[Tuple[str, ...]], int]
+match fm1:
+    case [fa1, fb1, fc1]:
+        reveal_type(fa1)  # N: Revealed type is "builtins.int"
+        reveal_type(fb1)  # N: Revealed type is "builtins.int"
+        reveal_type(fc1)  # N: Revealed type is "builtins.int"
+
+fm2: Tuple[int, int, Unpack[Tuple[str, ...]], int]
+match fm2:
+    case [fa2, fb2]:
+        reveal_type(fa2)
+        reveal_type(fb2)
+
+fm3: Tuple[int, int, Unpack[Tuple[str, ...]], int]
+match fm3:
+    case [fa3, fb3, fc3, fd3, fe3]:
+        reveal_type(fa3)  # N: Revealed type is "builtins.int"
+        reveal_type(fb3)  # N: Revealed type is "builtins.int"
+        reveal_type(fc3)  # N: Revealed type is "builtins.str"
+        reveal_type(fd3)  # N: Revealed type is "builtins.str"
+        reveal_type(fe3)  # N: Revealed type is "builtins.int"
+
+m1: Tuple[int, Unpack[Tuple[str, ...]], int]
+match m1:
+    case [a1, *b1, c1]:
+        reveal_type(a1)  # N: Revealed type is "builtins.int"
+        reveal_type(b1)  # N: Revealed type is "builtins.list[builtins.str]"
+        reveal_type(c1)  # N: Revealed type is "builtins.int"
+
+m2: Tuple[int, Unpack[Tuple[str, ...]], int]
+match m2:
+    case [a2, b2, *c2, d2, e2]:
+        reveal_type(a2)  # N: Revealed type is "builtins.int"
+        reveal_type(b2)  # N: Revealed type is "builtins.str"
+        reveal_type(c2)  # N: Revealed type is "builtins.list[builtins.str]"
+        reveal_type(d2)  # N: Revealed type is "builtins.str"
+        reveal_type(e2)  # N: Revealed type is "builtins.int"
+
+m3: Tuple[int, int, Unpack[Tuple[str, ...]], int, int]
+match m3:
+    case [a3, *b3, c3]:
+        reveal_type(a3)  # N: Revealed type is "builtins.int"
+        reveal_type(b3)  # N: Revealed type is "builtins.list[Union[builtins.int, builtins.str]]"
+        reveal_type(c3)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testMatchSequencePatternTypeVarTupleNotTooShort]
+from typing import Tuple
+from typing_extensions import Unpack, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+def test(xs: Tuple[Unpack[Ts]]) -> None:
+    fm1: Tuple[int, int, Unpack[Ts], int]
+    match fm1:
+        case [fa1, fb1, fc1]:
+            reveal_type(fa1)  # N: Revealed type is "builtins.int"
+            reveal_type(fb1)  # N: Revealed type is "builtins.int"
+            reveal_type(fc1)  # N: Revealed type is "builtins.int"
+
+    fm2: Tuple[int, int, Unpack[Ts], int]
+    match fm2:
+        case [fa2, fb2]:
+            reveal_type(fa2)
+            reveal_type(fb2)
+
+    fm3: Tuple[int, int, Unpack[Ts], int]
+    match fm3:
+        case [fa3, fb3, fc3, fd3, fe3]:
+            reveal_type(fa3)  # N: Revealed type is "builtins.int"
+            reveal_type(fb3)  # N: Revealed type is "builtins.int"
+            reveal_type(fc3)  # N: Revealed type is "builtins.object"
+            reveal_type(fd3)  # N: Revealed type is "builtins.object"
+            reveal_type(fe3)  # N: Revealed type is "builtins.int"
+
+    m1: Tuple[int, Unpack[Ts], int]
+    match m1:
+        case [a1, *b1, c1]:
+            reveal_type(a1)  # N: Revealed type is "builtins.int"
+            reveal_type(b1)  # N: Revealed type is "builtins.list[builtins.object]"
+            reveal_type(c1)  # N: Revealed type is "builtins.int"
+
+    m2: Tuple[int, Unpack[Ts], int]
+    match m2:
+        case [a2, b2, *c2, d2, e2]:
+            reveal_type(a2)  # N: Revealed type is "builtins.int"
+            reveal_type(b2)  # N: Revealed type is "builtins.object"
+            reveal_type(c2)  # N: Revealed type is "builtins.list[builtins.object]"
+            reveal_type(d2)  # N: Revealed type is "builtins.object"
+            reveal_type(e2)  # N: Revealed type is "builtins.int"
+
+    m3: Tuple[int, int, Unpack[Ts], int, int]
+    match m3:
+        case [a3, *b3, c3]:
+            reveal_type(a3)  # N: Revealed type is "builtins.int"
+            reveal_type(b3)  # N: Revealed type is "builtins.list[builtins.object]"
+            reveal_type(c3)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testMatchSequencePatternTypeVarBoundNoCrash]
+# This was crashing: https://github.com/python/mypy/issues/18089
+from typing import TypeVar, Sequence, Any
+
+T = TypeVar("T", bound=Sequence[Any])
+
+def f(x: T) -> None:
+    match x:
+        case [_]:
+            pass
+[builtins fixtures/tuple.pyi]
+
+[case testMatchSequencePatternTypeVarBoundNarrows]
+from typing import TypeVar, Sequence
+
+T = TypeVar("T", bound=Sequence[int | str])
+
+def accept_seq_int(x: Sequence[int]): ...
+
+def f(x: T) -> None:
+    match x:
+        case [1, 2]:
+            accept_seq_int(x)
+        case _:
+            accept_seq_int(x)  # E: Argument 1 to "accept_seq_int" has incompatible type "T"; expected "Sequence[int]"
+[builtins fixtures/tuple.pyi]
+
+[case testNarrowingTypeVarMatch]
+# flags: --warn-unreachable
+
+# https://github.com/python/mypy/issues/18126
+from typing import TypeVar
+
+T = TypeVar("T")
+
+def fn_case(arg: T) -> None:
+    match arg:
+        case None:
+            return None
+    return None
+[builtins fixtures/primitives.pyi]
+
+[case testNoneCheckDoesNotMakeTypeVarOptionalMatch]
+from typing import TypeVar
+
+T = TypeVar('T')
+
+def foo(x: T) -> T:
+    out = None
+    out = x
+    match out:
+        case None:
+            pass
+    return out
+
+[builtins fixtures/isinstance.pyi]
+
+[case testMatchSequenceReachableFromAny]
+# flags: --warn-unreachable
+from typing import Any
+
+def maybe_list(d: Any) -> int:
+    match d:
+        case []:
+            return 0
+        case [[_]]:
+            return 1
+        case [_]:
+            return 1
+        case _:
+            return 2
+
+def with_guard(d: Any) -> None:
+    match d:
+        case [s] if isinstance(s, str):
+            reveal_type(s)  # N: Revealed type is "builtins.str"
+    match d:
+        case (s,) if isinstance(s, str):
+            reveal_type(s)  # N: Revealed type is "builtins.str"
+
+def nested_in_dict(d: dict[str, Any]) -> int:
+    match d:
+        case {"src": ["src"]}:
+            return 1
+        case _:
+            return 0
+
+[builtins fixtures/dict.pyi]
+
+[case testMatchRebindsOuterFunctionName]
+# flags: --warn-unreachable
+from typing import Literal
+
+def x() -> tuple[Literal["test"]]: ...
+
+match x():
+    case (x,) if x == "test":  # E: Incompatible types in capture pattern (pattern captures type "Literal['test']", variable has type "Callable[[], Tuple[Literal['test']]]")
+        reveal_type(x)  # N: Revealed type is "def () -> Tuple[Literal['test']]"
+    case foo:
+        foo
+
+[builtins fixtures/dict.pyi]
+
+[case testMatchRebindsInnerFunctionName]
+# flags: --warn-unreachable
+class Some:
+    value: int | str
+    __match_args__ = ("value",)
+
+def fn1(x: Some | int | str) -> None:
+    match x:
+        case int():
+            def value():
+                return 1
+            reveal_type(value)  # N: Revealed type is "def () -> Any"
+        case str():
+            def value():
+                return 1
+            reveal_type(value)  # N: Revealed type is "def () -> Any"
+        case Some(value):  # E: Incompatible types in capture pattern (pattern captures type "Union[int, str]", variable has type "Callable[[], Any]")
+            pass
+
+def fn2(x: Some | int | str) -> None:
+    match x:
+        case int():
+            def value() -> str:
+                return ""
+            reveal_type(value)  # N: Revealed type is "def () -> builtins.str"
+        case str():
+            def value() -> int:  # E: All conditional function variants must have identical signatures \
+                                 # N: Original: \
+                                 # N:     def value() -> str \
+                                 # N: Redefinition: \
+                                 # N:     def value() -> int
+                return 1
+            reveal_type(value)  # N: Revealed type is "def () -> builtins.str"
+        case Some(value):  # E: Incompatible types in capture pattern (pattern captures type "Union[int, str]", variable has type "Callable[[], str]")
+            pass
+[builtins fixtures/dict.pyi]
+
+[case testMatchNamedTupleSequence]
+from typing import Any, NamedTuple
+
+class T(NamedTuple):
+    t: list[Any]
+
+class K(NamedTuple):
+    k: int
+
+def f(t: T) -> None:
+    match t:
+        case T([K() as k]):
+            reveal_type(k)  # N: Revealed type is "Tuple[builtins.int, fallback=__main__.K]"
+[builtins fixtures/tuple.pyi]
+
+[case testNewRedefineMatchBasics]
+# flags: --allow-redefinition-new --local-partial-types
+
+def f1(x: int | str | list[bytes]) -> None:
+    match x:
+        case int():
+            reveal_type(x) # N: Revealed type is "builtins.int"
+        case str(y):
+            reveal_type(y) # N: Revealed type is "builtins.str"
+        case [y]:
+            reveal_type(y) # N: Revealed type is "builtins.bytes"
+    reveal_type(y) # N: Revealed type is "Union[builtins.str, builtins.bytes]"
+
+[case testNewRedefineLoopWithMatch]
+# flags: --allow-redefinition-new --local-partial-types
+
+def f1() -> None:
+    while True:
+        x = object()
+        match x:
+            case str(y):
+                pass
+            case int():
+                pass
+        if int():
+            continue
+
+def f2() -> None:
+    for x in [""]:
+        match str():
+            case "a":
+                y = ""
+            case "b":
+                y = 1
+                return
+    reveal_type(y) # N: Revealed type is "builtins.str"
+[builtins fixtures/list.pyi]
+
+[case testEnumTypeObjectMember]
+import enum
+from typing import NoReturn
+
+def assert_never(x: NoReturn) -> None: ...
+
+class ValueType(enum.Enum):
+    INT = int
+    STR = str
+
+value_type: ValueType = ValueType.INT
+
+match value_type:
+    case ValueType.INT:
+        pass
+    case ValueType.STR:
+        pass
+    case _:
+        assert_never(value_type)
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-python311.test b/test-data/unit/check-python311.test
index 5870c7e17bcc..c6d42660403e 100644
--- a/test-data/unit/check-python311.test
+++ b/test-data/unit/check-python311.test
@@ -77,3 +77,247 @@ async def coro() -> Generator[List[Any], None, None]:
 reveal_type(coro)  # N: Revealed type is "def () -> typing.Coroutine[Any, Any, typing.Generator[builtins.list[Any], None, None]]"
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
+
+[case testTypeVarTupleNewSyntaxAnnotations]
+Ints = tuple[int, int, int]
+x: tuple[str, *Ints]
+reveal_type(x)  # N: Revealed type is "Tuple[builtins.str, builtins.int, builtins.int, builtins.int]"
+y: tuple[int, *tuple[int, ...]]
+reveal_type(y)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleNewSyntaxGenerics]
+from typing import Generic, TypeVar, TypeVarTuple
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+class C(Generic[T, *Ts]):
+    attr: tuple[int, *Ts, str]
+
+    def test(self) -> None:
+        reveal_type(self.attr)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`2], builtins.str]"
+        self.attr = ci  # E: Incompatible types in assignment (expression has type "C[*Tuple[int, ...]]", variable has type "Tuple[int, *Ts, str]")
+    def meth(self, *args: *Ts) -> T: ...
+
+ci: C[*tuple[int, ...]]
+reveal_type(ci)  # N: Revealed type is "__main__.C[Unpack[builtins.tuple[builtins.int, ...]]]"
+reveal_type(ci.meth)  # N: Revealed type is "def (*args: builtins.int) -> builtins.int"
+c3: C[str, str, str]
+reveal_type(c3)  # N: Revealed type is "__main__.C[builtins.str, builtins.str, builtins.str]"
+
+A = C[int, *Ts]
+B = tuple[str, *tuple[str, str], str]
+z: A[*B]
+reveal_type(z)  # N: Revealed type is "__main__.C[builtins.int, builtins.str, builtins.str, builtins.str, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleNewSyntaxCallables]
+from typing import Generic, overload, TypeVar
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+class MyClass(Generic[T1, T2]):
+    @overload
+    def __init__(self: MyClass[None, None]) -> None: ...
+
+    @overload
+    def __init__(self: MyClass[T1, None], *types: *tuple[type[T1]]) -> None: ...
+
+    @overload
+    def __init__(self: MyClass[T1, T2], *types: *tuple[type[T1], type[T2]]) -> None: ...
+
+    def __init__(self: MyClass[T1, T2], *types: *tuple[type, ...]) -> None:
+        pass
+
+myclass = MyClass()
+reveal_type(myclass)  # N: Revealed type is "__main__.MyClass[None, None]"
+myclass1 = MyClass(float)
+reveal_type(myclass1)  # N: Revealed type is "__main__.MyClass[builtins.float, None]"
+myclass2 = MyClass(float, float)
+reveal_type(myclass2)  # N: Revealed type is "__main__.MyClass[builtins.float, builtins.float]"
+myclass3 = MyClass(float, float, float)  # E: No overload variant of "MyClass" matches argument types "Type[float]", "Type[float]", "Type[float]" \
+                                         # N: Possible overload variants: \
+                                         # N:     def [T1, T2] __init__(self) -> MyClass[None, None] \
+                                         # N:     def [T1, T2] __init__(self, Type[T1], /) -> MyClass[T1, None] \
+                                         # N:     def [T1, T2] __init__(Type[T1], Type[T2], /) -> MyClass[T1, T2]
+reveal_type(myclass3)  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testUnpackNewSyntaxInvalidCallableAlias]
+from typing import Any, Callable, List, Tuple, TypeVar, Unpack
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")  # E: Name "TypeVarTuple" is not defined
+
+def good(*x: int) -> int: ...
+def bad(*x: int, y: int) -> int: ...
+
+Alias1 = Callable[[*Ts], int]  # E: Variable "__main__.Ts" is not valid as a type \
+                               # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
+x1: Alias1[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(x1)  # N: Revealed type is "def (*Any) -> builtins.int"
+x1 = good
+x1 = bad  # E: Incompatible types in assignment (expression has type "Callable[[VarArg(int), NamedArg(int, 'y')], int]", variable has type "Callable[[VarArg(Any)], int]")
+
+Alias2 = Callable[[*T], int]  # E: "T" cannot be unpacked (must be tuple or TypeVarTuple)
+x2: Alias2[int]
+reveal_type(x2)  # N: Revealed type is "def (*Any) -> builtins.int"
+
+Unknown = Any
+Alias3 = Callable[[*Unknown], int]
+x3: Alias3[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(x3)  # N: Revealed type is "def (*Any) -> builtins.int"
+
+IntList = List[int]
+Alias4 = Callable[[*IntList], int]  # E: "List[int]" cannot be unpacked (must be tuple or TypeVarTuple)
+x4: Alias4[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(x4)  # N: Revealed type is "def (*Any) -> builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testReturnInExceptStarBlock1]
+# flags: --python-version 3.11
+def foo() -> None:
+    try:
+        pass
+    except* Exception:
+        return   # E: "return" not allowed in except* block
+    finally:
+        return
+[builtins fixtures/exception.pyi]
+
+[case testReturnInExceptStarBlock2]
+# flags: --python-version 3.11
+def foo():
+    while True:
+        try:
+            pass
+        except* Exception:
+            while True:
+                return  # E: "return" not allowed in except* block
+[builtins fixtures/exception.pyi]
+
+[case testContinueInExceptBlockNestedInExceptStarBlock]
+# flags: --python-version 3.11
+while True:
+    try:
+        ...
+    except* Exception:
+        try:
+            ...
+        except Exception:
+            continue  # E: "continue" not allowed in except* block
+        continue  # E: "continue" not allowed in except* block
+[builtins fixtures/exception.pyi]
+
+[case testReturnInExceptBlockNestedInExceptStarBlock]
+# flags: --python-version 3.11
+def foo():
+    try:
+        ...
+    except* Exception:
+        try:
+            ...
+        except Exception:
+            return  # E: "return" not allowed in except* block
+        return  # E: "return" not allowed in except* block
+[builtins fixtures/exception.pyi]
+
+[case testBreakContinueReturnInExceptStarBlock1]
+# flags: --python-version 3.11
+from typing import Iterable
+def foo(x: Iterable[int]) -> None:
+    for _ in x:
+        try:
+            pass
+        except* Exception:
+            continue   # E: "continue" not allowed in except* block
+        except* Exception:
+            for _ in x:
+                continue
+            break  # E: "break" not allowed in except* block
+        except* Exception:
+            return  # E: "return" not allowed in except* block
+[builtins fixtures/exception.pyi]
+
+[case testBreakContinueReturnInExceptStarBlock2]
+# flags: --python-version 3.11
+def foo():
+    while True:
+        try:
+            pass
+        except* Exception:
+            def inner():
+                while True:
+                    if 1 < 1:
+                        continue
+                    else:
+                        break
+                return
+            if 1 < 2:
+                break  # E: "break" not allowed in except* block
+            if 1 < 2:
+                continue  # E: "continue" not allowed in except* block
+            return  # E: "return" not allowed in except* block
+[builtins fixtures/exception.pyi]
+
+[case testLambdaInExceptStarBlock]
+# flags: --python-version 3.11
+def foo():
+    try:
+        pass
+    except* Exception:
+        x = lambda: 0
+        return lambda: 0  # E: "return" not allowed in except* block
+
+def loop():
+    while True:
+        try:
+            pass
+        except* Exception:
+            x = lambda: 0
+            return lambda: 0  # E: "return" not allowed in except* block
+[builtins fixtures/exception.pyi]
+
+[case testRedefineLocalWithinExceptStarTryClauses]
+# flags: --allow-redefinition
+def fn_str(_: str) -> int: ...
+def fn_int(_: int) -> None: ...
+def fn_exc(_: Exception) -> str: ...
+
+def in_block() -> None:
+    try:
+        a = ""
+        a = fn_str(a)  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+        fn_int(a)  # E: Argument 1 to "fn_int" has incompatible type "str"; expected "int"
+    except* Exception:
+        b = ""
+        b = fn_str(b)
+        fn_int(b)
+    else:
+        c = ""
+        c = fn_str(c)
+        fn_int(c)
+    finally:
+        d = ""
+        d = fn_str(d)
+        fn_int(d)
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+    reveal_type(b)  # N: Revealed type is "builtins.int"
+    reveal_type(c)  # N: Revealed type is "builtins.int"
+    reveal_type(d)  # N: Revealed type is "builtins.int"
+
+def across_blocks() -> None:
+    try:
+        a = ""
+    except* Exception:
+        a = fn_str(a)  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+    else:
+        a = fn_str(a)  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+
+def exc_name() -> None:
+    try:
+        pass
+    except* RuntimeError as e:
+        e = fn_exc(e)
+[builtins fixtures/exception.pyi]
diff --git a/test-data/unit/check-python312.test b/test-data/unit/check-python312.test
new file mode 100644
index 000000000000..2244548ea969
--- /dev/null
+++ b/test-data/unit/check-python312.test
@@ -0,0 +1,2061 @@
+[case testPEP695TypeAliasBasic]
+type MyInt = int
+
+def f(x: MyInt) -> MyInt:
+    return reveal_type(x)  # N: Revealed type is "builtins.int"
+
+type MyList[T] = list[T]
+
+def g(x: MyList[int]) -> MyList[int]:
+    return reveal_type(x)  # N: Revealed type is "builtins.list[builtins.int]"
+
+type MyInt2 = int
+
+def h(x: MyInt2) -> MyInt2:
+    return reveal_type(x)  # N: Revealed type is "builtins.int"
+
+[case testPEP695Class]
+class MyGen[T]:
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+def f(x: MyGen[int]):
+    reveal_type(x.x)  # N: Revealed type is "builtins.int"
+
+[case testPEP695Function]
+def f[T](x: T) -> T:
+    return reveal_type(x)  # N: Revealed type is "T`-1"
+
+reveal_type(f(1))  # N: Revealed type is "builtins.int"
+
+async def g[T](x: T) -> T:
+    return reveal_type(x)  # N: Revealed type is "T`-1"
+
+reveal_type(g(1))  # E: Value of type "Coroutine[Any, Any, int]" must be used \
+                   # N: Are you missing an await? \
+                   # N: Revealed type is "typing.Coroutine[Any, Any, builtins.int]"
+
+[case testPEP695TypeVarBasic]
+from typing import Callable
+type Alias1[T: int] = list[T]
+type Alias2[**P] = Callable[P, int]
+type Alias3[*Ts] = tuple[*Ts]
+
+class Cls1[T: int]: ...
+class Cls2[**P]: ...
+class Cls3[*Ts]: ...
+
+def func1[T: int](x: T) -> T: ...
+def func2[**P](x: Callable[P, int]) -> Callable[P, str]: ...
+def func3[*Ts](x: tuple[*Ts]) -> tuple[int, *Ts]: ...
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeAliasType]
+from typing import Callable, TypeAliasType, TypeVar, TypeVarTuple
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+
+TestType = TypeAliasType("TestType", int | str)
+x: TestType = 42
+y: TestType = 'a'
+z: TestType = object()  # E: Incompatible types in assignment (expression has type "object", variable has type "Union[int, str]")
+
+BadAlias1 = TypeAliasType("BadAlias1", tuple[*Ts])  # E: TypeVarTuple "Ts" is not included in type_params
+ba1: BadAlias1[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(ba1)  # N: Revealed type is "builtins.tuple[Any, ...]"
+
+BadAlias2 = TypeAliasType("BadAlias2", Callable[[*Ts], str])  # E: TypeVarTuple "Ts" is not included in type_params
+ba2: BadAlias2[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(ba2)  # N: Revealed type is "def (*Any) -> builtins.str"
+
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695IncompleteFeatureIsAcceptedButHasNoEffect]
+# mypy: enable-incomplete-feature=NewGenericSyntax
+def f[T](x: T) -> T:
+    return x
+reveal_type(f(1))  # N: Revealed type is "builtins.int"
+
+[case testPEP695GenericFunctionSyntax]
+def ident[TV](x: TV) -> TV:
+    y: TV = x
+    y = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "TV")
+    return x
+
+reveal_type(ident(1))  # N: Revealed type is "builtins.int"
+reveal_type(ident('x'))  # N: Revealed type is "builtins.str"
+
+a: TV  # E: Name "TV" is not defined
+
+def tup[T, S](x: T, y: S) -> tuple[T, S]:
+    reveal_type((x, y))  # N: Revealed type is "Tuple[T`-1, S`-2]"
+    return (x, y)
+
+reveal_type(tup(1, 'x'))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695GenericClassSyntax]
+class C[T]:
+    x: T
+
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+    def ident(self, x: T) -> T:
+        y: T = x
+        if int():
+            return self.x
+        else:
+            return y
+
+reveal_type(C("x"))  # N: Revealed type is "__main__.C[builtins.str]"
+c: C[int] = C(1)
+reveal_type(c.x)  # N: Revealed type is "builtins.int"
+reveal_type(c.ident(1))  # N: Revealed type is "builtins.int"
+
+[case testPEP695GenericMethodInGenericClass]
+class C[T]:
+    def m[S](self, x: S) -> T | S: ...
+
+a: C[int] = C[object]()  # E: Incompatible types in assignment (expression has type "C[object]", variable has type "C[int]")
+b: C[object] = C[int]()
+
+reveal_type(C[str]().m(1))  # N: Revealed type is "Union[builtins.str, builtins.int]"
+
+[case testPEP695InferVarianceSimpleFromMethod]
+class Invariant[T]:
+    def f(self, x: T) -> None:
+        pass
+
+    def g(self) -> T | None:
+        return None
+
+a: Invariant[object]
+b: Invariant[int]
+if int():
+    a = b  # E: Incompatible types in assignment (expression has type "Invariant[int]", variable has type "Invariant[object]")
+if int():
+    b = a  # E: Incompatible types in assignment (expression has type "Invariant[object]", variable has type "Invariant[int]")
+
+class Covariant[T]:
+    def g(self) -> T | None:
+        return None
+
+c: Covariant[object]
+d: Covariant[int]
+if int():
+    c = d
+if int():
+    d = c  # E: Incompatible types in assignment (expression has type "Covariant[object]", variable has type "Covariant[int]")
+
+class Contravariant[T]:
+    def f(self, x: T) -> None:
+        pass
+
+e: Contravariant[object]
+f: Contravariant[int]
+if int():
+    e = f  # E: Incompatible types in assignment (expression has type "Contravariant[int]", variable has type "Contravariant[object]")
+if int():
+    f = e
+
+[case testPEP695InferVarianceSimpleFromAttribute]
+class Invariant1[T]:
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+a: Invariant1[object]
+b: Invariant1[int]
+if int():
+    a = b  # E: Incompatible types in assignment (expression has type "Invariant1[int]", variable has type "Invariant1[object]")
+if int():
+    b = a  # E: Incompatible types in assignment (expression has type "Invariant1[object]", variable has type "Invariant1[int]")
+
+class Invariant2[T]:
+    def __init__(self) -> None:
+        self.x: list[T] = []
+
+a2: Invariant2[object]
+b2: Invariant2[int]
+if int():
+    a2 = b2  # E: Incompatible types in assignment (expression has type "Invariant2[int]", variable has type "Invariant2[object]")
+if int():
+    b2 = a2  # E: Incompatible types in assignment (expression has type "Invariant2[object]", variable has type "Invariant2[int]")
+
+class Invariant3[T]:
+    def __init__(self) -> None:
+        self.x: T | None = None
+
+a3: Invariant3[object]
+b3: Invariant3[int]
+if int():
+    a3 = b3  # E: Incompatible types in assignment (expression has type "Invariant3[int]", variable has type "Invariant3[object]")
+if int():
+    b3 = a3  # E: Incompatible types in assignment (expression has type "Invariant3[object]", variable has type "Invariant3[int]")
+
+[case testPEP695InferVarianceRecursive]
+class Invariant[T]:
+    def f(self, x: Invariant[T]) -> Invariant[T]:
+        return x
+
+class Covariant[T]:
+    def f(self) -> Covariant[T]:
+        return self
+
+class Contravariant[T]:
+    def f(self, x: Contravariant[T]) -> None:
+        pass
+
+a: Invariant[object]
+b: Invariant[int]
+if int():
+    a = b  # E: Incompatible types in assignment (expression has type "Invariant[int]", variable has type "Invariant[object]")
+if int():
+    b = a
+
+c: Covariant[object]
+d: Covariant[int]
+if int():
+    c = d
+if int():
+    d = c  # E: Incompatible types in assignment (expression has type "Covariant[object]", variable has type "Covariant[int]")
+
+e: Contravariant[object]
+f: Contravariant[int]
+if int():
+    e = f  # E: Incompatible types in assignment (expression has type "Contravariant[int]", variable has type "Contravariant[object]")
+if int():
+    f = e
+
+[case testPEP695InferVarianceInFrozenDataclass]
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class Covariant[T]:
+    x: T
+
+cov1: Covariant[float] = Covariant[int](1)
+cov2: Covariant[int] = Covariant[float](1)  # E: Incompatible types in assignment (expression has type "Covariant[float]", variable has type "Covariant[int]")
+
+@dataclass(frozen=True)
+class Invariant[T]:
+    x: list[T]
+
+inv1: Invariant[float] = Invariant[int]([1])  # E: Incompatible types in assignment (expression has type "Invariant[int]", variable has type "Invariant[float]")
+inv2: Invariant[int] = Invariant[float]([1])  # E: Incompatible types in assignment (expression has type "Invariant[float]", variable has type "Invariant[int]")
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695InferVarianceCalculateOnDemand]
+class Covariant[T]:
+    def __init__(self) -> None:
+        self.x = [1]
+
+    def f(self) -> None:
+        c = Covariant[int]()
+        # We need to know that T is covariant here
+        self.g(c)
+        c2 = Covariant[object]()
+        self.h(c2)  # E: Argument 1 to "h" of "Covariant" has incompatible type "Covariant[object]"; expected "Covariant[int]"
+
+    def g(self, x: Covariant[object]) -> None: pass
+    def h(self, x: Covariant[int]) -> None: pass
+
+[case testPEP695InferVarianceNotReadyWhenNeeded]
+class Covariant[T]:
+    def f(self) -> None:
+        c = Covariant[int]()
+        # We need to know that T is covariant here
+        self.g(c)
+        c2 = Covariant[object]()
+        self.h(c2)  # E: Argument 1 to "h" of "Covariant" has incompatible type "Covariant[object]"; expected "Covariant[int]"
+
+    def g(self, x: Covariant[object]) -> None: pass
+    def h(self, x: Covariant[int]) -> None: pass
+
+    def __init__(self) -> None:
+        self.x = [1]
+
+class Invariant[T]:
+    def f(self) -> None:
+        c = Invariant(1)
+        # We need to know that T is invariant here, and for this we need the type
+        # of self.x, which won't be available on the first type checking pass,
+        # since __init__ is defined later in the file. In this case we fall back
+        # covariance.
+        self.g(c)
+        c2 = Invariant(object())
+        self.h(c2)  # E: Argument 1 to "h" of "Invariant" has incompatible type "Invariant[object]"; expected "Invariant[int]"
+
+    def g(self, x: Invariant[object]) -> None: pass
+    def h(self, x: Invariant[int]) -> None: pass
+
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+# Now we should have the variance correct.
+a: Invariant[object]
+b: Invariant[int]
+if int():
+    a = b  # E: Incompatible types in assignment (expression has type "Invariant[int]", variable has type "Invariant[object]")
+if int():
+    b = a  # E: Incompatible types in assignment (expression has type "Invariant[object]", variable has type "Invariant[int]")
+
+[case testPEP695InferVarianceNotReadyForJoin]
+class Invariant[T]:
+    def f(self) -> None:
+        # Assume covariance if variance us not ready
+        reveal_type([Invariant(1), Invariant(object())]) \
+            # N: Revealed type is "builtins.list[__main__.Invariant[builtins.object]]"
+
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+reveal_type([Invariant(1), Invariant(object())])   # N: Revealed type is "builtins.list[builtins.object]"
+
+[case testPEP695InferVarianceNotReadyForMeet]
+from typing import TypeVar, Callable
+
+S = TypeVar("S")
+def c(a: Callable[[S], None], b: Callable[[S], None]) -> S: ...
+
+def a1(x: Invariant[int]) -> None: pass
+def a2(x: Invariant[object]) -> None: pass
+
+class Invariant[T]:
+    def f(self) -> None:
+        reveal_type(c(a1, a2))  # N: Revealed type is "__main__.Invariant[builtins.int]"
+
+    def __init__(self, x: T) -> None:
+        self.x = x
+
+reveal_type(c(a1, a2))  # N: Revealed type is "Never"
+
+[case testPEP695InferVarianceUnderscorePrefix]
+class Covariant1[T]:
+    def __init__(self, x: T) -> None:
+        self._x = x
+
+    @property
+    def x(self) -> T:
+        return self._x
+
+co1_1: Covariant1[float] = Covariant1[int](1)
+co1_2: Covariant1[int] = Covariant1[float](1)  # E: Incompatible types in assignment (expression has type "Covariant1[float]", variable has type "Covariant1[int]")
+
+class Covariant2[T]:
+    def __init__(self, x: T) -> None:
+        self.__foo_bar = x
+
+    @property
+    def x(self) -> T:
+        return self.__foo_bar
+
+co2_1: Covariant2[float] = Covariant2[int](1)
+co2_2: Covariant2[int] = Covariant2[float](1)  # E: Incompatible types in assignment (expression has type "Covariant2[float]", variable has type "Covariant2[int]")
+
+class Invariant1[T]:
+    def __init__(self, x: T) -> None:
+        self._x = x
+
+    # Methods behave differently from attributes
+    def _f(self, x: T) -> None: ...
+
+    @property
+    def x(self) -> T:
+        return self._x
+
+inv1_1: Invariant1[float] = Invariant1[int](1)  # E: Incompatible types in assignment (expression has type "Invariant1[int]", variable has type "Invariant1[float]")
+inv1_2: Invariant1[int] = Invariant1[float](1)  # E: Incompatible types in assignment (expression has type "Invariant1[float]", variable has type "Invariant1[int]")
+
+class Invariant2[T]:
+    def __init__(self, x: T) -> None:
+        # Dunders are special
+        self.__x__ = x
+
+    @property
+    def x(self) -> T:
+        return self.__x__
+
+inv2_1: Invariant2[float] = Invariant2[int](1)  # E: Incompatible types in assignment (expression has type "Invariant2[int]", variable has type "Invariant2[float]")
+inv2_2: Invariant2[int] = Invariant2[float](1)  # E: Incompatible types in assignment (expression has type "Invariant2[float]", variable has type "Invariant2[int]")
+
+class Invariant3[T]:
+    def __init__(self, x: T) -> None:
+        self._x = Invariant1(x)
+
+    @property
+    def x(self) -> T:
+        return self._x._x
+
+inv3_1: Invariant3[float] = Invariant3[int](1)  # E: Incompatible types in assignment (expression has type "Invariant3[int]", variable has type "Invariant3[float]")
+inv3_2: Invariant3[int] = Invariant3[float](1)  # E: Incompatible types in assignment (expression has type "Invariant3[float]", variable has type "Invariant3[int]")
+[builtins fixtures/property.pyi]
+
+[case testPEP695InferVarianceWithInheritedSelf]
+from typing import overload, Self, TypeVar, Generic
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+class C(Generic[T]):
+    def f(self, x: T) -> Self: ...
+    def g(self) -> T: ...
+
+class D[T1, T2](C[T1]):
+    def m(self, x: T2) -> None: ...
+
+a1: D[int, int] = D[int, object]()
+a2: D[int, object] = D[int, int]()  # E: Incompatible types in assignment (expression has type "D[int, int]", variable has type "D[int, object]")
+a3: D[int, int] = D[object, object]()  # E: Incompatible types in assignment (expression has type "D[object, object]", variable has type "D[int, int]")
+a4: D[object, int] = D[int, object]()  # E: Incompatible types in assignment (expression has type "D[int, object]", variable has type "D[object, int]")
+
+[case testPEP695InferVarianceWithReturnSelf]
+from typing import Self, overload
+
+class Cov[T]:
+    def f(self) -> Self: ...
+
+a1: Cov[int] = Cov[float]()  # E: Incompatible types in assignment (expression has type "Cov[float]", variable has type "Cov[int]")
+a2: Cov[float] = Cov[int]()
+
+class Contra[T]:
+    def f(self) -> Self: ...
+    def g(self, x: T) -> None: ...
+
+b1: Contra[int] = Contra[float]()
+b2: Contra[float] = Contra[int]()  # E: Incompatible types in assignment (expression has type "Contra[int]", variable has type "Contra[float]")
+
+class Cov2[T]:
+    @overload
+    def f(self, x): ...
+    @overload
+    def f(self) -> Self: ...
+    def f(self, x=None): ...
+
+c1: Cov2[int] = Cov2[float]()  # E: Incompatible types in assignment (expression has type "Cov2[float]", variable has type "Cov2[int]")
+c2: Cov2[float] = Cov2[int]()
+
+class Contra2[T]:
+    @overload
+    def f(self, x): ...
+    @overload
+    def f(self) -> Self: ...
+    def f(self, x=None): ...
+
+    def g(self, x: T) -> None: ...
+
+d1: Contra2[int] = Contra2[float]()
+d2: Contra2[float] = Contra2[int]()  # E: Incompatible types in assignment (expression has type "Contra2[int]", variable has type "Contra2[float]")
+
+[case testPEP695InheritInvariant]
+class Invariant[T]:
+    x: T
+
+class Subclass[T](Invariant[T]):
+    pass
+
+x: Invariant[int]
+y: Invariant[object]
+if int():
+    x = y  # E: Incompatible types in assignment (expression has type "Invariant[object]", variable has type "Invariant[int]")
+if int():
+    y = x  # E: Incompatible types in assignment (expression has type "Invariant[int]", variable has type "Invariant[object]")
+
+a: Subclass[int]
+b: Subclass[object]
+if int():
+    a = b  # E: Incompatible types in assignment (expression has type "Subclass[object]", variable has type "Subclass[int]")
+if int():
+    b = a  # E: Incompatible types in assignment (expression has type "Subclass[int]", variable has type "Subclass[object]")
+
+[case testPEP695InheritanceMakesInvariant]
+class Covariant[T]:
+    def f(self) -> T:
+        ...
+
+class Subclass[T](Covariant[list[T]]):
+    pass
+
+x: Covariant[int] = Covariant[object]()  # E: Incompatible types in assignment (expression has type "Covariant[object]", variable has type "Covariant[int]")
+y: Covariant[object] = Covariant[int]()
+
+a: Subclass[int] = Subclass[object]()  # E: Incompatible types in assignment (expression has type "Subclass[object]", variable has type "Subclass[int]")
+b: Subclass[object] = Subclass[int]()  # E: Incompatible types in assignment (expression has type "Subclass[int]", variable has type "Subclass[object]")
+
+[case testPEP695InheritCoOrContravariant]
+class Contravariant[T]:
+    def f(self, x: T) -> None: pass
+
+class CovSubclass[T](Contravariant[T]):
+    pass
+
+a: CovSubclass[int] = CovSubclass[object]()
+b: CovSubclass[object] = CovSubclass[int]()  # E: Incompatible types in assignment (expression has type "CovSubclass[int]", variable has type "CovSubclass[object]")
+
+class Covariant[T]:
+    def f(self) -> T: ...
+
+class CoSubclass[T](Covariant[T]):
+    pass
+
+c: CoSubclass[int] = CoSubclass[object]()  # E: Incompatible types in assignment (expression has type "CoSubclass[object]", variable has type "CoSubclass[int]")
+d: CoSubclass[object] = CoSubclass[int]()
+
+class InvSubclass[T](Covariant[T]):
+    def g(self, x: T) -> None: pass
+
+e: InvSubclass[int] = InvSubclass[object]()  # E: Incompatible types in assignment (expression has type "InvSubclass[object]", variable has type "InvSubclass[int]")
+f: InvSubclass[object] = InvSubclass[int]()  # E: Incompatible types in assignment (expression has type "InvSubclass[int]", variable has type "InvSubclass[object]")
+
+[case testPEP695FinalAttribute]
+from typing import Final
+
+class C[T]:
+    def __init__(self, x: T) -> None:
+        self.x: Final = x
+
+a: C[int] = C[object](1)  # E: Incompatible types in assignment (expression has type "C[object]", variable has type "C[int]")
+b: C[object] = C[int](1)
+
+[case testPEP695TwoTypeVariables]
+class C[T, S]:
+    def f(self, x: T) -> None: ...
+    def g(self) -> S: ...
+
+a: C[int, int] = C[object, int]()
+b: C[object, int] = C[int, int]()  # E: Incompatible types in assignment (expression has type "C[int, int]", variable has type "C[object, int]")
+c: C[int, int] = C[int, object]()  # E: Incompatible types in assignment (expression has type "C[int, object]", variable has type "C[int, int]")
+d: C[int, object] = C[int, int]()
+
+[case testPEP695Properties]
+class R[T]:
+    @property
+    def p(self) -> T: ...
+
+class RW[T]:
+    @property
+    def p(self) -> T: ...
+    @p.setter
+    def p(self, x: T) -> None: ...
+
+a: R[int] = R[object]()  # E: Incompatible types in assignment (expression has type "R[object]", variable has type "R[int]")
+b: R[object] = R[int]()
+c: RW[int] = RW[object]()  # E: Incompatible types in assignment (expression has type "RW[object]", variable has type "RW[int]")
+d: RW[object] = RW[int]()  # E: Incompatible types in assignment (expression has type "RW[int]", variable has type "RW[object]")
+[builtins fixtures/property.pyi]
+
+[case testPEP695Protocol]
+from typing import Protocol
+
+class PContra[T](Protocol):
+    def f(self, x: T) -> None: ...
+
+PContra()  # E: Cannot instantiate protocol class "PContra"
+a: PContra[int]
+b: PContra[object]
+if int():
+    a = b
+if int():
+    b = a  # E: Incompatible types in assignment (expression has type "PContra[int]", variable has type "PContra[object]")
+
+class PCov[T](Protocol):
+    def f(self) -> T: ...
+
+PCov()  # E: Cannot instantiate protocol class "PCov"
+c: PCov[int]
+d: PCov[object]
+if int():
+    c = d  # E: Incompatible types in assignment (expression has type "PCov[object]", variable has type "PCov[int]")
+if int():
+    d = c
+
+class PInv[T](Protocol):
+    def f(self, x: T) -> T: ...
+
+PInv()  # E: Cannot instantiate protocol class "PInv"
+e: PInv[int]
+f: PInv[object]
+if int():
+    e = f  # E: Incompatible types in assignment (expression has type "PInv[object]", variable has type "PInv[int]")
+if int():
+    f = e  # E: Incompatible types in assignment (expression has type "PInv[int]", variable has type "PInv[object]")
+
+[case testPEP695TypeAlias]
+class C[T]: pass
+class D[T, S]: pass
+
+type A[S] = C[S]
+
+a: A[int]
+reveal_type(a)  # N: Revealed type is "__main__.C[builtins.int]"
+
+type A2[T] = C[C[T]]
+a2: A2[str]
+reveal_type(a2)  # N: Revealed type is "__main__.C[__main__.C[builtins.str]]"
+
+type A3[T, S] = D[S, C[T]]
+a3: A3[int, str]
+reveal_type(a3)  # N: Revealed type is "__main__.D[builtins.str, __main__.C[builtins.int]]"
+
+type A4 = int | str
+a4: A4
+reveal_type(a4)  # N: Revealed type is "Union[builtins.int, builtins.str]"
+[builtins fixtures/type.pyi]
+
+[case testPEP695TypeAliasNotValidAsBaseClass]
+from typing import TypeAlias
+
+import m
+
+type A1 = int
+class Bad1(A1):  # E: Type alias defined using "type" statement not valid as base class
+    pass
+
+type A2[T] = list[T]
+class Bad2(A2[int]):  # E: Type alias defined using "type" statement not valid as base class
+    pass
+
+class Bad3(m.A1):  # E: Type alias defined using "type" statement not valid as base class
+    pass
+
+class Bad4(m.A2[int]):  # E: Type alias defined using "type" statement not valid as base class
+    pass
+
+B1 = int
+B2 = list
+B3: TypeAlias = int
+class Good1(B1): pass
+class Good2(B2[int]): pass
+class Good3(list[A1]): pass
+class Good4(list[A2[int]]): pass
+class Good5(B3): pass
+
+[file m.py]
+type A1 = str
+type A2[T] = list[T]
+[typing fixtures/typing-medium.pyi]
+
+[case testPEP695TypeAliasWithUnusedTypeParams]
+type A[T] = int
+a: A[str]
+reveal_type(a)  # N: Revealed type is "builtins.int"
+
+[case testPEP695TypeAliasForwardReference1]
+type A[T] = C[T]
+
+a: A[int]
+reveal_type(a)  # N: Revealed type is "__main__.C[builtins.int]"
+
+class C[T]: pass
+
+[case testPEP695TypeAliasForwardReference2]
+type X = C
+type A = X
+
+a: A
+reveal_type(a)  # N: Revealed type is "__main__.C"
+
+class C: pass
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeAliasForwardReference3]
+type X = D
+type A = C[X]
+
+a: A
+reveal_type(a)  # N: Revealed type is "__main__.C[__main__.D]"
+
+class C[T]: pass
+class D: pass
+
+[case testPEP695TypeAliasForwardReference4]
+type A = C
+
+class D(A):  # E: Type alias defined using "type" statement not valid as base class
+    pass
+
+class C: pass
+
+x: C = D()
+y: D = C()  # E: Incompatible types in assignment (expression has type "C", variable has type "D")
+
+[case testPEP695TypeAliasForwardReference5]
+type A = str
+type B[T] = C[T]
+class C[T]: pass
+a: A
+b: B[int]
+c: C[str]
+reveal_type(a)  # N: Revealed type is "builtins.str"
+reveal_type(b)  # N: Revealed type is "__main__.C[builtins.int]"
+reveal_type(c)  # N: Revealed type is "__main__.C[builtins.str]"
+
+[case testPEP695TypeAliasWithUndefineName]
+type A[T] = XXX  # E: Name "XXX" is not defined
+a: A[int]
+reveal_type(a)  # N: Revealed type is "Any"
+
+[case testPEP695TypeAliasInvalidType]
+type A = int | 1  # E: Invalid type: try using Literal[1] instead?
+
+a: A
+reveal_type(a)  # N: Revealed type is "Union[builtins.int, Any]"
+type B = int + str  # E: Invalid type alias: expression is not a valid type
+b: B
+reveal_type(b)  # N: Revealed type is "Any"
+[builtins fixtures/type.pyi]
+
+[case testPEP695TypeAliasBoundForwardReference]
+type B[T: Foo] = list[T]
+class Foo: pass
+
+[case testPEP695UpperBound]
+class D:
+    x: int
+class E(D): pass
+
+class C[T: D]: pass
+
+a: C[D]
+b: C[E]
+reveal_type(a)  # N: Revealed type is "__main__.C[__main__.D]"
+reveal_type(b)  # N: Revealed type is "__main__.C[__main__.E]"
+
+c: C[int]  # E: Type argument "int" of "C" must be a subtype of "D"
+
+def f[T: D](a: T) -> T:
+    reveal_type(a.x)  # N: Revealed type is "builtins.int"
+    return a
+
+reveal_type(f(D()))  # N: Revealed type is "__main__.D"
+reveal_type(f(E()))  # N: Revealed type is "__main__.E"
+f(1)  # E: Value of type variable "T" of "f" cannot be "int"
+
+[case testPEP695UpperBoundForwardReference1]
+class C[T: D]: pass
+
+a: C[D]
+b: C[E]
+reveal_type(a)  # N: Revealed type is "__main__.C[__main__.D]"
+reveal_type(b)  # N: Revealed type is "__main__.C[__main__.E]"
+
+c: C[int]  # E: Type argument "int" of "C" must be a subtype of "D"
+
+class D: pass
+class E(D): pass
+
+[case testPEP695UpperBoundForwardReference2]
+type A = D
+class C[T: A]: pass
+
+class D: pass
+class E(D): pass
+
+a: C[D]
+b: C[E]
+reveal_type(a)  # N: Revealed type is "__main__.C[__main__.D]"
+reveal_type(b)  # N: Revealed type is "__main__.C[__main__.E]"
+
+c: C[int]  # E: Type argument "int" of "C" must be a subtype of "D"
+
+[case testPEP695UpperBoundForwardReference3]
+class D[T]: pass
+class E[T](D[T]): pass
+
+type A = D[X]
+
+class C[T: A]: pass
+
+class X: pass
+
+a: C[D[X]]
+b: C[E[X]]
+reveal_type(a)  # N: Revealed type is "__main__.C[__main__.D[__main__.X]]"
+reveal_type(b)  # N: Revealed type is "__main__.C[__main__.E[__main__.X]]"
+
+c: C[D[int]]  # E: Type argument "D[int]" of "C" must be a subtype of "D[X]"
+
+[case testPEP695UpperBoundForwardReference4]
+def f[T: D](a: T) -> T:
+    reveal_type(a.x)  # N: Revealed type is "builtins.int"
+    return a
+
+class D:
+    x: int
+class E(D): pass
+
+reveal_type(f(D()))  # N: Revealed type is "__main__.D"
+reveal_type(f(E()))  # N: Revealed type is "__main__.E"
+f(1)  # E: Value of type variable "T" of "f" cannot be "int"
+
+[case testPEP695UpperBoundUndefinedName]
+class C[T: XX]:  # E: Name "XX" is not defined
+    pass
+
+a: C[int]
+
+def f[T: YY](x: T) -> T:  # E: Name "YY" is not defined
+    return x
+reveal_type(f)  # N: Revealed type is "def [T <: Any] (x: T`-1) -> T`-1"
+
+[case testPEP695UpperBoundWithMultipleParams]
+class C[T, S: int]: pass
+class D[A: int, B]: pass
+
+def f[T: int, S: int | str](x: T, y: S) -> T | S:
+    return x
+
+C[str, int]()
+C[str, str]()  # E: Value of type variable "S" of "C" cannot be "str"
+D[int, str]()
+D[str, str]()  # E: Value of type variable "A" of "D" cannot be "str"
+f(1, 1)
+u: int | str
+f(1, u)
+f('x', None)  # E: Value of type variable "T" of "f" cannot be "str" \
+              # E: Value of type variable "S" of "f" cannot be "None"
+
+[case testPEP695InferVarianceOfTupleType]
+class Cov[T](tuple[int, str]):
+    def f(self) -> T: pass
+
+class Cov2[T](tuple[T, T]):
+    pass
+
+class Contra[T](tuple[int, str]):
+    def f(self, x: T) -> None: pass
+
+a: Cov[object] = Cov[int]()
+b: Cov[int] = Cov[object]()  # E: Incompatible types in assignment (expression has type "Cov[object]", variable has type "Cov[int]")
+
+c: Cov2[object] = Cov2[int]()
+d: Cov2[int] = Cov2[object]()  # E: Incompatible types in assignment (expression has type "Cov2[object]", variable has type "Cov2[int]")
+
+e: Contra[int] = Contra[object]()
+f: Contra[object] = Contra[int]()  # E: Incompatible types in assignment (expression has type "Contra[int]", variable has type "Contra[object]")
+[builtins fixtures/tuple-simple.pyi]
+
+[case testPEP695ValueRestriction]
+def f[T: (int, str)](x: T) -> T:
+    reveal_type(x)  # N: Revealed type is "builtins.int" \
+                    # N: Revealed type is "builtins.str"
+    return x
+
+reveal_type(f(1))  # N: Revealed type is "builtins.int"
+reveal_type(f('x'))  # N: Revealed type is "builtins.str"
+f(None)  # E: Value of type variable "T" of "f" cannot be "None"
+
+class C[T: (object, None)]: pass
+
+a: C[object]
+b: C[None]
+c: C[int]  # E: Value of type variable "T" of "C" cannot be "int"
+
+[case testPEP695ValueRestrictionForwardReference]
+class C[T: (int, D)]:
+    def __init__(self, x: T) -> None:
+        a = x
+        if int():
+            a = 'x'  # E: Incompatible types in assignment (expression has type "str", variable has type "int") \
+                     # E: Incompatible types in assignment (expression has type "str", variable has type "D")
+        self.x: T = x
+
+reveal_type(C(1).x)  # N: Revealed type is "builtins.int"
+C(None)  # E: Value of type variable "T" of "C" cannot be "None"
+
+class D: pass
+
+C(D())
+
+[case testPEP695ValueRestrictionUndefinedName]
+class C[T: (int, XX)]:  # E: Name "XX" is not defined
+    pass
+
+def f[S: (int, YY)](x: S) -> S:  # E: Name "YY" is not defined
+    return x
+
+[case testPEP695ParamSpec]
+from typing import Callable
+
+def g[**P](f: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None:
+    f(*args, **kwargs)
+    f(1, *args, **kwargs)  # E: Argument 1 has incompatible type "int"; expected "P.args"
+
+def h(x: int, y: str) -> None: pass
+
+g(h, 1, y='x')
+g(h, 1, x=1)  # E: "g" gets multiple values for keyword argument "x" \
+              # E: Missing positional argument "y" in call to "g"
+
+class C[**P, T]:
+    def m(self, *args: P.args, **kwargs: P.kwargs) -> T: ...
+
+a: C[[int, str], None]
+reveal_type(a)  # N: Revealed type is "__main__.C[[builtins.int, builtins.str], None]"
+reveal_type(a.m)  # N: Revealed type is "def (builtins.int, builtins.str)"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695ParamSpecTypeAlias]
+from typing import Callable
+
+type C[**P] = Callable[P, int]
+
+f: C[[str, int | None]]
+reveal_type(f)  # N: Revealed type is "def (builtins.str, Union[builtins.int, None]) -> builtins.int"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeVarTuple]
+def f[*Ts](t: tuple[*Ts]) -> tuple[*Ts]:
+    reveal_type(t)  # N: Revealed type is "Tuple[Unpack[Ts`-1]]"
+    return t
+
+reveal_type(f((1, 'x')))  # N: Revealed type is "Tuple[Literal[1]?, Literal['x']?]"
+a: tuple[int, ...]
+reveal_type(f(a))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+
+class C[T, *Ts]:
+    pass
+
+b: C[int, str, None]
+reveal_type(b)  # N: Revealed type is "__main__.C[builtins.int, builtins.str, None]"
+c: C[str]
+reveal_type(c)  # N: Revealed type is "__main__.C[builtins.str]"
+b = c  # E: Incompatible types in assignment (expression has type "C[str]", variable has type "C[int, str, None]")
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeVarTupleAlias]
+from typing import Callable
+
+type C[*Ts] = tuple[*Ts, int]
+
+a: C[str, None]
+reveal_type(a)  # N: Revealed type is "Tuple[builtins.str, None, builtins.int]"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695IncrementalFunction]
+import a
+
+[file a.py]
+import b
+
+[file a.py.2]
+import b
+reveal_type(b.f(1))
+reveal_type(b.g(1, 'x'))
+b.g('x', 'x')
+b.g(1, 2)
+
+[file b.py]
+def f[T](x: T) -> T:
+    return x
+
+def g[T: int, S: (str, None)](x: T, y: S) -> T | S:
+    return x
+
+[out2]
+tmp/a.py:2: note: Revealed type is "builtins.int"
+tmp/a.py:3: note: Revealed type is "Union[builtins.int, builtins.str]"
+tmp/a.py:4: error: Value of type variable "T" of "g" cannot be "str"
+tmp/a.py:5: error: Value of type variable "S" of "g" cannot be "int"
+
+[case testPEP695IncrementalClass]
+import a
+
+[file a.py]
+import b
+
+[file a.py.2]
+from b import C, D
+x: C[int]
+reveal_type(x)
+
+class N(int): pass
+class SS(str): pass
+
+y1: D[int, str]
+y2: D[N, str]
+y3: D[int, None]
+y4: D[int, None]
+y5: D[int, SS]  # Error
+y6: D[object, str]  # Error
+
+[file b.py]
+class C[T]: pass
+
+class D[T: int, S: (str, None)]:
+    pass
+
+[out2]
+tmp/a.py:3: note: Revealed type is "b.C[builtins.int]"
+tmp/a.py:12: error: Value of type variable "S" of "D" cannot be "SS"
+tmp/a.py:13: error: Type argument "object" of "D" must be a subtype of "int"
+
+[case testPEP695IncrementalParamSpecAndTypeVarTuple]
+import a
+
+[file a.py]
+import b
+
+[file a.py.2]
+from b import C, D
+x1: C[()]
+x2: C[int]
+x3: C[int, str]
+y: D[[int, str]]
+reveal_type(y.m)
+
+[file b.py]
+class C[*Ts]: pass
+class D[**P]:
+    def m(self, *args: P.args, **kwargs: P.kwargs) -> None: pass
+
+[builtins fixtures/tuple.pyi]
+[out2]
+tmp/a.py:6: note: Revealed type is "def (builtins.int, builtins.str)"
+
+[case testPEP695IncrementalTypeAlias]
+import a
+
+[file a.py]
+import b
+
+[file a.py.2]
+from b import A, B
+a: A
+reveal_type(a)
+b: B[int]
+reveal_type(b)
+
+[file b.py]
+type A = str
+class Foo[T]: pass
+type B[T] = Foo[T]
+
+[builtins fixtures/tuple.pyi]
+[out2]
+tmp/a.py:3: note: Revealed type is "builtins.str"
+tmp/a.py:5: note: Revealed type is "b.Foo[builtins.int]"
+
+[case testPEP695UndefinedNameInGenericFunction]
+def f[T](x: T) -> T:
+    return unknown()  # E: Name "unknown" is not defined
+
+class C:
+    def m[T](self, x: T) -> T:
+        return unknown()  # E: Name "unknown" is not defined
+
+[case testPEP695FunctionTypeVarAccessInFunction]
+from typing import cast
+
+class C:
+    def m[T](self, x: T) -> T:
+        y: T = x
+        reveal_type(y)  # N: Revealed type is "T`-1"
+        return cast(T, y)
+
+reveal_type(C().m(1))  # N: Revealed type is "builtins.int"
+
+[case testPEP695ScopingBasics]
+T = 1
+
+def f[T](x: T) -> T:
+    T = 'a'
+    reveal_type(T)  # N: Revealed type is "builtins.str"
+    return x
+
+reveal_type(T)  # N: Revealed type is "builtins.int"
+
+class C[T]:
+    T = 1.2
+    reveal_type(T)  # N: Revealed type is "builtins.float"
+
+reveal_type(T)  # N: Revealed type is "builtins.int"
+
+[case testPEP695ClassScoping]
+class C:
+    class D: pass
+
+    def m[T: D](self, x: T, y: D) -> T:
+        return x
+
+C().m(C.D(), C.D())
+C().m(1, C.D())  # E: Value of type variable "T" of "m" of "C" cannot be "int"
+
+[case testPEP695NestedGenericFunction]
+def f[T](x: T) -> T:
+    reveal_type(f(x))  # N: Revealed type is "T`-1"
+    reveal_type(f(1))  # N: Revealed type is "builtins.int"
+
+    def ff(x: T) -> T:
+        y: T = x
+        return y
+    reveal_type(ff(x))  # N: Revealed type is "T`-1"
+    ff(1)  # E: Argument 1 to "ff" has incompatible type "int"; expected "T"
+
+    def g[S](a: S) -> S:
+        ff(a)  # E: Argument 1 to "ff" has incompatible type "S"; expected "T"
+        return a
+    reveal_type(g(1))  # N: Revealed type is "builtins.int"
+    reveal_type(g(x))  # N: Revealed type is "T`-1"
+
+    def h[S](a: S) -> S:
+        return a
+    reveal_type(h(1))  # N: Revealed type is "builtins.int"
+    reveal_type(h(x))  # N: Revealed type is "T`-1"
+    return x
+
+[case testPEP695NonLocalAndGlobal]
+def f() -> None:
+    T = 1
+    def g[T](x: T) -> T:
+        nonlocal T  # E: nonlocal binding not allowed for type parameter "T"
+        T = 'x'  # E: "T" is a type variable and only valid in type context
+        return x
+    reveal_type(T)  # N: Revealed type is "builtins.int"
+
+def g() -> None:
+    a = 1
+    def g[T](x: T) -> T:
+        nonlocal a
+        a = 'x'  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+        return x
+
+x = 1
+
+def h[T](a: T) -> T:
+    global x
+    x = ''  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    return a
+
+class C[T]:
+    def m[S](self, a: S) -> S:
+        global x
+        x = ''  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+        return a
+
+[case testPEP695ArgumentDefault]
+from typing import cast
+
+def f[T](
+    x: T =
+        T  # E: Name "T" is not defined \
+           # E: Incompatible default for argument "x" (default has type "TypeVar", argument has type "T")
+) -> T:
+    return x
+
+def g[T](x: T = cast(T, None)) -> T:  # E: Name "T" is not defined
+    return x
+
+class C:
+    def m[T](self, x: T = cast(T, None)) -> T:  # E: Name "T" is not defined
+        return x
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695ListComprehension]
+from typing import cast
+
+def f[T](x: T) -> T:
+    b = [cast(T, a) for a in [1, 2]]
+    reveal_type(b)  # N: Revealed type is "builtins.list[T`-1]"
+    return x
+
+[case testPEP695ReuseNameInSameScope]
+class C[T]:
+    def m[S](self, x: S, y: T) -> S | T:
+        return x
+
+    def m2[S](self, x: S, y: T) -> S | T:
+        return x
+
+class D[T]:
+    pass
+
+def f[T](x: T) -> T:
+    return x
+
+def g[T](x: T) -> T:
+    def nested[S](y: S) -> S:
+        return y
+    def nested2[S](y: S) -> S:
+        return y
+    return x
+
+[case testPEP695NestedScopingSpecialCases]
+# This is adapted from PEP 695
+S = 0
+
+def outer1[S]() -> None:
+    S = 1
+    T = 1
+
+    def outer2[T]() -> None:
+        def inner1() -> None:
+            nonlocal S
+            nonlocal T  # E: nonlocal binding not allowed for type parameter "T"
+
+        def inner2() -> None:
+            global S
+
+[case testPEP695ScopingWithBaseClasses]
+# This is adapted from PEP 695
+class Outer:
+    class Private:
+        pass
+
+    # If the type parameter scope was like a traditional scope,
+    # the base class 'Private' would not be accessible here.
+    class Inner[T](Private, list[T]):
+        pass
+
+    # Likewise, 'Inner' would not be available in these type annotations.
+    def method1[T](self, a: Inner[T]) -> Inner[T]:
+        return a
+
+[case testPEP695RedefineTypeParameterInScope]
+class C[T]:
+    def m[T](self, x: T) -> T:  # E: "T" already defined as a type parameter
+        return x
+    def m2(self) -> None:
+        def nested[T](x: T) -> T:  # E: "T" already defined as a type parameter
+            return x
+
+def f[S, S](x: S) -> S:  # E: "S" already defined as a type parameter
+    return x
+
+[case testPEP695ClassDecorator]
+from typing import Any
+
+T = 0
+
+def decorator(x: str) -> Any: ...
+
+@decorator(T)  # E: Argument 1 to "decorator" has incompatible type "int"; expected "str"
+class C[T]:
+    pass
+
+[case testPEP695RecursiceTypeAlias]
+type A = str | list[A]
+a: A
+reveal_type(a)  # N: Revealed type is "Union[builtins.str, builtins.list[...]]"
+
+class C[T]: pass
+
+type B[T] = C[T] | list[B[T]]
+b: B[int]
+reveal_type(b)  # N: Revealed type is "Union[__main__.C[builtins.int], builtins.list[...]]"
+[builtins fixtures/type.pyi]
+
+[case testPEP695BadRecursiveTypeAlias]
+type A = A  # E: Cannot resolve name "A" (possible cyclic definition)
+type B = B | int  # E: Invalid recursive alias: a union item of itself
+a: A
+reveal_type(a)  # N: Revealed type is "Any"
+b: B
+reveal_type(b)  # N: Revealed type is "Any"
+[builtins fixtures/type.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695RecursiveTypeAliasForwardReference]
+def f(a: A) -> None:
+    if isinstance(a, str):
+        reveal_type(a)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(a)  # N: Revealed type is "__main__.C[Union[builtins.str, __main__.C[...]]]"
+
+type A = str | C[A]
+
+class C[T]: pass
+
+f('x')
+f(C[str]())
+f(C[C[str]]())
+f(1)  # E: Argument 1 to "f" has incompatible type "int"; expected "A"
+f(C[int]())  # E: Argument 1 to "f" has incompatible type "C[int]"; expected "A"
+[builtins fixtures/isinstance.pyi]
+
+[case testPEP695InvalidGenericOrProtocolBaseClass]
+from typing import Generic, Protocol, TypeVar
+
+S = TypeVar("S")
+
+class C[T](Generic[T]):  # E: Generic[...] base class is redundant
+    pass
+class C2[T](Generic[S]): # E: Generic[...] base class is redundant
+    pass
+
+a: C[int]
+b: C2[int, str]
+
+class P[T](Protocol[T]):  # E: No arguments expected for "Protocol" base class
+    pass
+class P2[T](Protocol[S]):  # E: No arguments expected for "Protocol" base class
+    pass
+
+[case testPEP695CannotUseTypeVarFromOuterClass]
+class ClassG[V]:
+    # This used to crash
+    class ClassD[T: dict[str, V]]:  # E: Name "V" is not defined
+        ...
+[builtins fixtures/dict.pyi]
+
+[case testPEP695MixNewAndOldStyleGenerics]
+from typing import TypeVar
+
+S = TypeVar("S")
+U = TypeVar("U")
+
+def f[T](x: T, y: S) -> T | S: ...  # E: All type parameters should be declared ("S" not declared)
+def g[T](x: S, y: U) -> T | S | U: ...  # E: All type parameters should be declared ("S", "U" not declared)
+
+def h[S: int](x: S) -> S:
+   a: int = x
+   return x
+
+class C[T]:
+    def m[X, S](self, x: S, y: U) -> X | S | U: ...  # E: All type parameters should be declared ("U" not declared)
+    def m2(self, x: T, y: S) -> T | S: ...
+
+class D[T](C[S]):  # E: All type parameters should be declared ("S" not declared)
+    pass
+
+[case testPEP695MixNewAndOldStyleTypeVarTupleAndParamSpec]
+from typing import TypeVarTuple, ParamSpec, Callable
+Ts = TypeVarTuple("Ts")
+P = ParamSpec("P")
+
+def f[T](x: T, f: Callable[P, None]  # E: All type parameters should be declared ("P" not declared)
+        ) -> Callable[P, T]: ...
+def g[T](x: T, f: tuple[*Ts]  # E: All type parameters should be declared ("Ts" not declared)
+        ) -> tuple[T, *Ts]: ...
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695MixNewAndOldStyleGenericsInTypeAlias]
+from typing import TypeVar, ParamSpec, TypeVarTuple, Callable
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+P = ParamSpec("P")
+
+type A = list[T]  # E: All type parameters should be declared ("T" not declared)
+a: A[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(a)   # N: Revealed type is "builtins.list[Any]"
+
+type B = tuple[*Ts]  # E: All type parameters should be declared ("Ts" not declared)
+type C = Callable[P, None]  # E: All type parameters should be declared ("P" not declared)
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695NonGenericAliasToGenericClass]
+class C[T]: pass
+type A = C
+x: C
+y: A
+reveal_type(x)  # N: Revealed type is "__main__.C[Any]"
+reveal_type(y)  # N: Revealed type is "__main__.C[Any]"
+z: A[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+
+[case testPEP695SelfType]
+from typing import Self
+
+class C:
+    @classmethod
+    def m[T](cls, x: T) -> tuple[Self, T]:
+        return cls(), x
+
+class D(C):
+    pass
+
+reveal_type(C.m(1))  # N: Revealed type is "Tuple[__main__.C, builtins.int]"
+reveal_type(D.m(1))  # N: Revealed type is "Tuple[__main__.D, builtins.int]"
+
+class E[T]:
+    def m(self) -> Self:
+        return self
+
+    def mm[S](self, x: S) -> tuple[Self, S]:
+        return self, x
+
+class F[T](E[T]):
+    pass
+
+reveal_type(E[int]().m())  # N: Revealed type is "__main__.E[builtins.int]"
+reveal_type(E[int]().mm(b'x'))  # N: Revealed type is "Tuple[__main__.E[builtins.int], builtins.bytes]"
+reveal_type(F[str]().m())  # N: Revealed type is "__main__.F[builtins.str]"
+reveal_type(F[str]().mm(b'x'))  # N: Revealed type is "Tuple[__main__.F[builtins.str], builtins.bytes]"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695CallAlias]
+class C:
+    def __init__(self, x: str) -> None: ...
+type A = C
+
+class D[T]: pass
+type B[T] = D[T]
+
+reveal_type(A)  # N: Revealed type is "typing.TypeAliasType"
+reveal_type(B)  # N: Revealed type is "typing.TypeAliasType"
+reveal_type(B[int])  # N: Revealed type is "typing.TypeAliasType"
+
+A(1)  # E: "TypeAliasType" not callable
+B[int]()  # E: "TypeAliasType" not callable
+
+A2 = C
+B2 = D
+A2(1)  # E: Argument 1 to "C" has incompatible type "int"; expected "str"
+B2[int]()
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695IncrementalTypeAliasKinds]
+import a
+
+[file a.py]
+from b import A
+
+[file a.py.2]
+from b import A, B, C
+A()
+B()
+C()
+
+[file b.py]
+from typing_extensions import TypeAlias
+type A = int
+B = int
+C: TypeAlias = int
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+[out2]
+tmp/a.py:2: error: "TypeAliasType" not callable
+
+[case testPEP695TypeAliasBoundAndValueChecking]
+from typing import Any, cast
+
+class C: pass
+class D(C): pass
+
+type A[T: C] = list[T]
+a1: A
+reveal_type(a1)  # N: Revealed type is "builtins.list[Any]"
+a2: A[Any]
+a3: A[C]
+a4: A[D]
+a5: A[object]  # E: Type argument "object" of "A" must be a subtype of "C"
+a6: A[int]  # E: Type argument "int" of "A" must be a subtype of "C"
+
+x1 = cast(A[C], a1)
+x2 = cast(A[None], a1)  # E: Type argument "None" of "A" must be a subtype of "C"
+
+type A2[T: (int, C)] = list[T]
+b1: A2
+reveal_type(b1)  # N: Revealed type is "builtins.list[Any]"
+b2: A2[Any]
+b3: A2[int]
+b4: A2[C]
+b5: A2[D]  # E: Value of type variable "T" of "A2" cannot be "D"
+b6: A2[object]  # E: Value of type variable "T" of "A2" cannot be "object"
+
+list[A2[int]]()
+list[A2[None]]()  # E: Invalid type argument value for "A2"
+
+class N(int): pass
+
+type A3[T: C, S: (int, str)] = T | S
+c1: A3[C, int]
+c2: A3[D, str]
+c3: A3[C, N]  # E: Value of type variable "S" of "A3" cannot be "N"
+c4: A3[int, str]  # E: Type argument "int" of "A3" must be a subtype of "C"
+[builtins fixtures/type.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeAliasInClassBodyOrFunction]
+class C:
+    type A = int
+    type B[T] = list[T] | None
+    a: A
+    b: B[str]
+
+    def method(self) -> None:
+        v: C.A
+        reveal_type(v)  # N: Revealed type is "builtins.int"
+
+reveal_type(C.a)  # N: Revealed type is "builtins.int"
+reveal_type(C.b)  # N: Revealed type is "Union[builtins.list[builtins.str], None]"
+
+C.A = str  # E: Incompatible types in assignment (expression has type "Type[str]", variable has type "TypeAliasType")
+
+x: C.A
+y: C.B[int]
+reveal_type(x)  # N: Revealed type is "builtins.int"
+reveal_type(y)  # N: Revealed type is "Union[builtins.list[builtins.int], None]"
+
+def f() -> None:
+    type A = int
+    type B[T] = list[T] | None
+    a: A
+    reveal_type(a)  # N: Revealed type is "builtins.int"
+
+    def g() -> None:
+        b: B[int]
+        reveal_type(b)  # N: Revealed type is "Union[builtins.list[builtins.int], None]"
+
+class D:
+    def __init__(self) -> None:
+        type A = int
+        self.a: A = 0
+        type B[T] = list[T]
+        self.b: B[int] = [1]
+
+reveal_type(D().a)  # N: Revealed type is "builtins.int"
+reveal_type(D().b)  # N: Revealed type is "builtins.list[builtins.int]"
+
+class E[T]:
+    type X = list[T]  # E: All type parameters should be declared ("T" not declared)
+
+    def __init__(self) -> None:
+        type A = list[T]  # E: All type parameters should be declared ("T" not declared)
+        self.a: A
+
+reveal_type(E[str]().a)  # N: Revealed type is "builtins.list[Any]"
+[builtins fixtures/type.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeAliasInvalidGenericConstraint]
+class A[T]:
+    class a[S: (int, list[T])]: pass                # E: Name "T" is not defined
+    type b[S: (int, list[T])] = S                   # E: TypeVar constraint type cannot be parametrized by type variables
+    def c[S: (int, list[T])](self) -> None: ...     # E: TypeVar constraint type cannot be parametrized by type variables
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeAliasUnboundTypeVarConstraint]
+from typing import TypeVar
+T = TypeVar("T")
+class a[S: (int, list[T])]: pass                # E: Type variable "__main__.T" is unbound \
+                                                # N: (Hint: Use "Generic[T]" or "Protocol[T]" base class to bind "T" inside a class) \
+                                                # N: (Hint: Use "T" in function signature to bind "T" inside a function)
+type b[S: (int, list[T])] = S                   # E: Type variable "__main__.T" is unbound \
+                                                # N: (Hint: Use "Generic[T]" or "Protocol[T]" base class to bind "T" inside a class) \
+                                                # N: (Hint: Use "T" in function signature to bind "T" inside a function)
+def c[S: (int, list[T])](self) -> None: ...     # E: Type variable "__main__.T" is unbound \
+                                                # N: (Hint: Use "Generic[T]" or "Protocol[T]" base class to bind "T" inside a class) \
+                                                # N: (Hint: Use "T" in function signature to bind "T" inside a function)
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695RedefineAsTypeAlias1]
+class C: pass
+type C = int  # E: Name "C" already defined on line 1
+
+A = 0
+type A = str  # E: Name "A" already defined on line 4
+reveal_type(A)  # N: Revealed type is "builtins.int"
+
+[case testPEP695RedefineAsTypeAlias2]
+from m import D
+type D = int  # E: Name "D" already defined (possibly by an import)
+a: D
+reveal_type(a)  # N: Revealed type is "m.D"
+[file m.py]
+class D: pass
+
+[case testPEP695RedefineAsTypeAlias3]
+D = list["Forward"]
+type D = int  # E: Name "D" already defined on line 1
+Forward = str
+x: D
+reveal_type(x)  # N: Revealed type is "builtins.list[builtins.str]"
+
+[case testPEP695MultiDefinitionsForTypeAlias]
+if int():
+    type A[T] = list[T]
+else:
+    type A[T] = str  # E: Name "A" already defined on line 2
+x: T  # E: Name "T" is not defined
+a: A[int]
+reveal_type(a)  # N: Revealed type is "builtins.list[builtins.int]"
+
+[case testPEP695UndefinedNameInAnnotation]
+def f[T](x: foobar, y: T) -> T: ...  # E: Name "foobar" is not defined
+reveal_type(f)  # N: Revealed type is "def [T] (x: Any, y: T`-1) -> T`-1"
+
+[case testPEP695WrongNumberOfConstrainedTypes]
+type A[T: ()] = list[T]  # E: Type variable must have at least two constrained types
+a: A[int]
+reveal_type(a)  # N: Revealed type is "builtins.list[builtins.int]"
+
+type B[T: (int,)] = list[T]  # E: Type variable must have at least two constrained types
+b: B[str]
+reveal_type(b)  # N: Revealed type is "builtins.list[builtins.str]"
+
+[case testPEP695UsingTypeVariableInOwnBoundOrConstraint]
+type A[T: list[T]] = str  # E: Name "T" is not defined
+type B[S: (list[S], str)] = str  # E: Name "S" is not defined
+type C[T, S: list[T]] = str  # E: Name "T" is not defined
+
+def f[T: T](x: T) -> T: ...  # E: Name "T" is not defined
+class D[T: T]:  # E: Name "T" is not defined
+    pass
+
+[case testPEP695InvalidType]
+def f[T: 1](x: T) -> T: ...  # E: Invalid type: try using Literal[1] instead?
+class C[T: (int, (1 + 2))]: pass  # E: Invalid type comment or annotation
+type A = list[1]  # E: Invalid type: try using Literal[1] instead?
+type B = (1 + 2)  # E: Invalid type alias: expression is not a valid type
+a: A
+reveal_type(a)  # N: Revealed type is "builtins.list[Any]"
+b: B
+reveal_type(b)  # N: Revealed type is "Any"
+
+[case testPEP695GenericNamedTuple]
+from typing import NamedTuple
+
+# Invariant because of the signature of the generated _replace method
+class N[T](NamedTuple):
+    x: T
+    y: int
+
+a: N[object]
+reveal_type(a.x)  # N: Revealed type is "builtins.object"
+b: N[int]
+reveal_type(b.x)  # N: Revealed type is "builtins.int"
+if int():
+    a = b  # E: Incompatible types in assignment (expression has type "N[int]", variable has type "N[object]")
+if int():
+    b = a  # E: Incompatible types in assignment (expression has type "N[object]", variable has type "N[int]")
+
+class M[T: (int, str)](NamedTuple):
+    x: T
+
+c: M[int]
+d: M[str]
+e: M[bool]  # E: Value of type variable "T" of "M" cannot be "bool"
+
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695GenericTypedDict]
+from typing import TypedDict
+
+class D[T](TypedDict):
+    x: T
+    y: int
+
+class E[T: str](TypedDict):
+    x: T
+    y: int
+
+a: D[object]
+reveal_type(a["x"])  # N: Revealed type is "builtins.object"
+b: D[int]
+reveal_type(b["x"])  # N: Revealed type is "builtins.int"
+c: E[str]
+d: E[int]  # E: Type argument "int" of "E" must be a subtype of "str"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testCurrentClassWorksAsBound]
+from typing import Protocol
+
+class Comparable[T: Comparable](Protocol):
+    def compare(self, other: T) -> bool: ...
+
+class Good:
+    def compare(self, other: Good) -> bool: ...
+
+x: Comparable[Good]
+y: Comparable[int]  # E: Type argument "int" of "Comparable" must be a subtype of "Comparable[Any]"
+
+[case testPEP695TypeAliasWithDifferentTargetTypes]
+import types  # We need GenericAlias from here, and test stubs don't bring in 'types'
+from typing import Any, Callable, List, Literal, TypedDict
+
+# Test that various type expressions don't generate false positives as type alias
+# values, as they are type checked as expressions. There is a similar test case in
+# pythoneval.test that uses typeshed stubs.
+
+class C[T]: pass
+
+class TD(TypedDict):
+    x: int
+
+type A1 = type[int]
+type A2 = type[int] | None
+type A3 = None | type[int]
+type A4 = type[Any]
+
+type B1[**P, R] = Callable[P, R] | None
+type B2[**P, R] = None | Callable[P, R]
+type B3 = Callable[[str], int]
+type B4 = Callable[..., int]
+
+type C1 = A1 | None
+type C2 = None | A1
+
+type D1 = Any | None
+type D2 = None | Any
+
+type E1 = List[int]
+type E2 = List[int] | None
+type E3 = None | List[int]
+
+type F1 = Literal[1]
+type F2 = Literal['x'] | None
+type F3 = None | Literal[True]
+
+type G1 = tuple[int, Any]
+type G2 = tuple[int, Any] | None
+type G3 = None | tuple[int, Any]
+
+type H1 = TD
+type H2 = TD | None
+type H3 = None | TD
+
+type I1 = C[int]
+type I2 = C[Any] | None
+type I3 = None | C[TD]
+[builtins fixtures/type.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypedDictInlineYesNewStyleAlias]
+# flags: --enable-incomplete-feature=InlineTypedDict
+type X[T] = {"item": T, "other": X[T] | None}
+x: X[str]
+reveal_type(x)  # N: Revealed type is "TypedDict({'item': builtins.str, 'other': Union[..., None]})"
+if x["other"] is not None:
+    reveal_type(x["other"]["item"])  # N: Revealed type is "builtins.str"
+
+type Y[T] = {"item": T, **Y[T]}  # E: Overwriting TypedDict field "item" while merging
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695UsingIncorrectExpressionsInTypeVariableBound]
+type X[T: (yield 1)] = Any  # E: Yield expression cannot be used as a type variable bound
+type Y[T: (yield from [])] = Any # E: Yield expression cannot be used as a type variable bound
+type Z[T: (a := 1)] = Any  # E: Named expression cannot be used as a type variable bound
+type K[T: (await 1)] = Any # E: Await expression cannot be used as a type variable bound
+
+type XNested[T: (1 + (yield 1))] = Any  # E: Yield expression cannot be used as a type variable bound
+type YNested[T: (1 + (yield from []))] = Any # E: Yield expression cannot be used as a type variable bound
+type ZNested[T: (1 + (a := 1))] = Any  # E: Named expression cannot be used as a type variable bound
+type KNested[T: (1 + (await 1))] = Any # E: Await expression cannot be used as a type variable bound
+
+class FooX[T: (yield 1)]: pass  # E: Yield expression cannot be used as a type variable bound
+class FooY[T: (yield from [])]: pass  # E: Yield expression cannot be used as a type variable bound
+class FooZ[T: (a := 1)]: pass  # E: Named expression cannot be used as a type variable bound
+class FooK[T: (await 1)]: pass  # E: Await expression cannot be used as a type variable bound
+
+class FooXNested[T: (1 + (yield 1))]: pass  # E: Yield expression cannot be used as a type variable bound
+class FooYNested[T: (1 + (yield from []))]: pass  # E: Yield expression cannot be used as a type variable bound
+class FooZNested[T: (1 + (a := 1))]: pass  # E: Named expression cannot be used as a type variable bound
+class FooKNested[T: (1 + (await 1))]: pass  # E: Await expression cannot be used as a type variable bound
+
+def foox[T: (yield 1)](): pass  # E: Yield expression cannot be used as a type variable bound
+def fooy[T: (yield from [])](): pass  # E: Yield expression cannot be used as a type variable bound
+def fooz[T: (a := 1)](): pass  # E: Named expression cannot be used as a type variable bound
+def fook[T: (await 1)](): pass  # E: Await expression cannot be used as a type variable bound
+
+def foox_nested[T: (1 + (yield 1))](): pass  # E: Yield expression cannot be used as a type variable bound
+def fooy_nested[T: (1 + (yield from []))](): pass  # E: Yield expression cannot be used as a type variable bound
+def fooz_nested[T: (1 + (a := 1))](): pass  # E: Named expression cannot be used as a type variable bound
+def fook_nested[T: (1 +(await 1))](): pass  # E: Await expression cannot be used as a type variable bound
+
+[case testPEP695UsingIncorrectExpressionsInTypeAlias]
+type X = (yield 1)  # E: Yield expression cannot be used within a type alias
+type Y = (yield from []) # E: Yield expression cannot be used within a type alias
+type Z = (a := 1)  # E: Named expression cannot be used within a type alias
+type K = (await 1)  # E: Await expression cannot be used within a type alias
+
+type XNested = (1 + (yield 1))  # E: Yield expression cannot be used within a type alias
+type YNested = (1 + (yield from [])) # E: Yield expression cannot be used within a type alias
+type ZNested = (1 + (a := 1))  # E: Named expression cannot be used within a type alias
+type KNested = (1 + (await 1))  # E: Await expression cannot be used within a type alias
+
+[case testPEP695TypeAliasAndAnnotated]
+from typing_extensions import Annotated, Annotated as _Annotated
+import typing_extensions as t
+
+def ann(*args): ...
+
+type A = Annotated[int, ann()]
+type B = Annotated[int | str, ann((1, 2))]
+type C = _Annotated[int, ann()]
+type D = t.Annotated[str, ann()]
+
+x: A
+y: B
+z: C
+zz: D
+reveal_type(x)  # N: Revealed type is "builtins.int"
+reveal_type(y)  # N: Revealed type is "Union[builtins.int, builtins.str]"
+reveal_type(z)  # N: Revealed type is "builtins.int"
+reveal_type(zz)  # N: Revealed type is "builtins.str"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695NestedGenericClass1]
+class C[T]:
+    def f(self) -> T: ...
+
+class A:
+    class B[Q]:
+        def __init__(self, a: Q) -> None:
+            self.a = a
+
+        def f(self) -> Q:
+            return self.a
+
+        def g(self, x: Q) -> None: ...
+
+    b: B[str]
+
+x: A.B[int]
+x.g("x")  # E: Argument 1 to "g" of "B" has incompatible type "str"; expected "int"
+reveal_type(x.a)  # N: Revealed type is "builtins.int"
+reveal_type(x)  # N: Revealed type is "__main__.A.B[builtins.int]"
+reveal_type(A.b)  # N: Revealed type is "__main__.A.B[builtins.str]"
+
+[case testPEP695NestedGenericClass2]
+class A:
+    def m(self) -> None:
+        class B[T]:
+            def f(self) -> T: ...
+        x: B[int]
+        reveal_type(x.f())  # N: Revealed type is "builtins.int"
+        self.a = B[str]()
+
+reveal_type(A().a)  # N: Revealed type is "__main__.B@3[builtins.str]"
+reveal_type(A().a.f())  # N: Revealed type is "builtins.str"
+
+[case testPEP695NestedGenericClass3]
+class C[T]:
+    def f(self) -> T: ...
+    class D[S]:
+        x: T  # E: Name "T" is not defined
+        def g(self) -> S: ...
+
+a: C[int]
+reveal_type(a.f())  # N: Revealed type is "builtins.int"
+b: C.D[str]
+reveal_type(b.g())  # N: Revealed type is "builtins.str"
+
+class E[T]:
+    class F[T]:  # E: "T" already defined as a type parameter
+        x: T
+
+c: E.F[int]
+
+[case testPEP695NestedGenericClass4]
+class A:
+    class B[T]:
+        def __get__(self, instance: A, owner: type[A]) -> T:
+            return None  # E: Incompatible return value type (got "None", expected "T")
+    f = B[int]()
+
+a = A()
+v = a.f
+
+[case testPEP695VarianceInheritedFromBaseWithExplicitVariance]
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+class ParentInvariant(Generic[T]):
+    pass
+
+class Invariant1[T](ParentInvariant[T]):
+    pass
+
+a1: Invariant1[int] = Invariant1[float]()  # E: Incompatible types in assignment (expression has type "Invariant1[float]", variable has type "Invariant1[int]")
+a2: Invariant1[float] = Invariant1[int]()  # E: Incompatible types in assignment (expression has type "Invariant1[int]", variable has type "Invariant1[float]")
+
+T_contra = TypeVar("T_contra", contravariant=True)
+
+class ParentContravariant(Generic[T_contra]):
+    pass
+
+class Contravariant[T](ParentContravariant[T]):
+    pass
+
+b1: Contravariant[int] = Contravariant[float]()
+b2: Contravariant[float] = Contravariant[int]()  # E: Incompatible types in assignment (expression has type "Contravariant[int]", variable has type "Contravariant[float]")
+
+class Invariant2[T](ParentContravariant[T]):
+    def f(self) -> T: ...
+
+c1: Invariant2[int] = Invariant2[float]()  # E: Incompatible types in assignment (expression has type "Invariant2[float]", variable has type "Invariant2[int]")
+c2: Invariant2[float] = Invariant2[int]()  # E: Incompatible types in assignment (expression has type "Invariant2[int]", variable has type "Invariant2[float]")
+
+class Multi[T, S](ParentInvariant[T], ParentContravariant[S]):
+    pass
+
+d1: Multi[int, str] = Multi[float, str]()  # E: Incompatible types in assignment (expression has type "Multi[float, str]", variable has type "Multi[int, str]")
+d2: Multi[float, str] = Multi[int, str]()  # E: Incompatible types in assignment (expression has type "Multi[int, str]", variable has type "Multi[float, str]")
+d3: Multi[str, int] = Multi[str, float]()
+d4: Multi[str, float] = Multi[str, int]()  # E: Incompatible types in assignment (expression has type "Multi[str, int]", variable has type "Multi[str, float]")
+
+[case testPEP695MultipleNestedGenericClass1]
+# flags: --enable-incomplete-feature=NewGenericSyntax
+class A:
+    class B:
+        class C:
+            class D[Q]:
+                def g(self, x: Q): ...
+            d: D[str]
+
+x: A.B.C.D[int]
+x.g('a') # E: Argument 1 to "g" of "D" has incompatible type "str"; expected "int"
+reveal_type(x)  # N: Revealed type is "__main__.A.B.C.D[builtins.int]"
+reveal_type(A.B.C.d)  # N: Revealed type is "__main__.A.B.C.D[builtins.str]"
+
+[case testPEP695MultipleNestedGenericClass2]
+# flags: --enable-incomplete-feature=NewGenericSyntax
+class A:
+    class B:
+        def m(self) -> None:
+            class C[T]:
+                def f(self) -> T: ...
+            x: C[int]
+            reveal_type(x.f())  # N: Revealed type is "builtins.int"
+            self.a = C[str]()
+
+reveal_type(A().B().a) # N: Revealed type is "__main__.C@5[builtins.str]"
+
+[case testPEP695MultipleNestedGenericClass3]
+# flags: --enable-incomplete-feature=NewGenericSyntax
+class A:
+    class C[T]:
+        def f(self) -> T: ...
+        class D[S]:
+            x: T  # E: Name "T" is not defined
+            def g(self) -> S: ...
+
+a: A.C[int]
+reveal_type(a.f())  # N: Revealed type is "builtins.int"
+b: A.C.D[str]
+reveal_type(b.g())  # N: Revealed type is "builtins.str"
+
+class B:
+    class E[T]:
+        class F[T]:  # E: "T" already defined as a type parameter
+            x: T
+
+c: B.E.F[int]
+
+[case testPEP695MultipleNestedGenericClass4]
+# flags: --enable-incomplete-feature=NewGenericSyntax
+class Z:
+    class A:
+        class B[T]:
+            def __get__(self, instance: Z.A, owner: type[Z.A]) -> T:
+                return None  # E: Incompatible return value type (got "None", expected "T")
+        f = B[int]()
+
+a = Z.A()
+v = a.f
+
+[case testPEP695MultipleNestedGenericClass5]
+# flags: --enable-incomplete-feature=NewGenericSyntax
+from a.b.c import d
+x: d.D.E.F.G[int]
+x.g('a') # E: Argument 1 to "g" of "G" has incompatible type "str"; expected "int"
+reveal_type(x)  # N: Revealed type is "a.b.c.d.D.E.F.G[builtins.int]"
+reveal_type(d.D.E.F.d)  # N: Revealed type is "a.b.c.d.D.E.F.G[builtins.str]"
+
+[file a/b/c/d.py]
+class D:
+    class E:
+        class F:
+            class G[Q]:
+                def g(self, x: Q): ...
+            d: G[str]
+
+[case testTypeAliasNormalization]
+from collections.abc import Callable
+from typing import Unpack
+from typing_extensions import TypeAlias
+
+type RK_function_args = tuple[float, int]
+type RK_functionBIS = Callable[[Unpack[RK_function_args], int], int]
+
+def ff(a: float, b: int, c: int) -> int:
+    return 2
+
+bis: RK_functionBIS = ff
+res: int = bis(1.0, 2, 3)
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeAliasNotReadyClass]
+class CustomizeResponse:
+    related_resources: "ResourceRule"
+
+class ResourceRule: pass
+
+class DecoratorController:
+    type CustomizeResponse = CustomizeResponse
+
+x: DecoratorController.CustomizeResponse
+reveal_type(x.related_resources)  # N: Revealed type is "__main__.ResourceRule"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeAliasRecursiveOuterClass]
+class A:
+    type X = X  # E: Cannot resolve name "X" (possible cyclic definition)
+class X: ...
+
+class AA:
+    XX = XX  # OK, we allow this as a special case.
+class XX: ...
+
+class Y: ...
+class B:
+    type Y = Y
+
+reveal_type(AA.XX)  # N: Revealed type is "def () -> __main__.XX"
+y: B.Y
+reveal_type(y)  # N: Revealed type is "__main__.Y"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeAliasRecursiveInvalid]
+type X = X  # E: Cannot resolve name "X" (possible cyclic definition)
+type Z = Z[int]  # E: Cannot resolve name "Z" (possible cyclic definition)
+def foo() -> None:
+    type X = X  # OK, refers to outer (invalid) X
+    x: X
+    reveal_type(x)  # N: Revealed type is "Any"
+    type Y = Y  # E: Cannot resolve name "Y" (possible cyclic definition) \
+                # N: Recursive types are not allowed at function scope
+class Z: ...  # E: Name "Z" already defined on line 2
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695MultipleUnpacksInBareApplicationNoCrash]
+# https://github.com/python/mypy/issues/18856
+class A[*Ts]: ...
+
+A[*tuple[int, ...], *tuple[int, ...]]  # E: More than one Unpack in a type is not allowed
+a: A[*tuple[int, ...], *tuple[int, ...]]  # E: More than one Unpack in a type is not allowed
+def foo(a: A[*tuple[int, ...], *tuple[int, ...]]): ...  # E: More than one Unpack in a type is not allowed
+
+tuple[*tuple[int, ...], *tuple[int, ...]]  # E: More than one Unpack in a type is not allowed
+b: tuple[*tuple[int, ...], *tuple[int, ...]]  # E: More than one Unpack in a type is not allowed
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testForwardNestedPrecedesForwardGlobal]
+from typing import NewType
+
+class W[T]: pass
+
+class R:
+    class M(W[Action.V], type):
+        FOO = R.Action.V(0)
+    class Action(metaclass=M):
+        V = NewType('V', int)
+
+class Action:
+    pass
diff --git a/test-data/unit/check-python313.test b/test-data/unit/check-python313.test
new file mode 100644
index 000000000000..f020b1602b99
--- /dev/null
+++ b/test-data/unit/check-python313.test
@@ -0,0 +1,276 @@
+[case testPEP695TypeParameterDefaultSupported]
+class C[T = None]: ...
+def f[T = list[int]]() -> None: ...
+def g[**P = [int, str]]() -> None: ...
+type A[T, S = int, U = str] = list[T]
+
+[case testPEP695TypeParameterDefaultBasic]
+from typing import Callable
+
+def f1[T1 = int](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[**P1 = [int, str]](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[*Ts1 = *tuple[int, str]](a: tuple[*Ts1]) -> tuple[*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[T1 = int]: ...
+class ClassA2[**P1 = [int, str]]: ...
+class ClassA3[*Ts1 = *tuple[int, str]]: ...
+
+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 testPEP695TypeParameterDefaultValid]
+from typing import Any
+
+class ClassT1[T = int]: ...
+class ClassT2[T: float = int]: ...
+class ClassT3[T: list[Any] = list[int]]: ...
+class ClassT4[T: (int, str) = int]: ...
+
+class ClassP1[**P = []]: ...
+class ClassP2[**P = ...]: ...
+class ClassP3[**P = [int, str]]: ...
+
+class ClassTs1[*Ts = *tuple[int]]: ...
+class ClassTs2[*Ts = *tuple[int, ...]]: ...
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeParameterDefaultInvalid]
+class ClassT1[T = 2]: ...  # E: TypeVar "default" must be a type
+class ClassT2[T = [int]]: ...  # E: Bracketed expression "[...]" is not valid as a type \
+                               # N: Did you mean "List[...]"? \
+                               # E: TypeVar "default" must be a type
+class ClassT3[T: str = int]: ...               # E: TypeVar default must be a subtype of the bound type
+class ClassT4[T: list[str] = list[int]]: ...   # E: TypeVar default must be a subtype of the bound type
+class ClassT5[T: (int, str) = bytes]: ...      # E: TypeVar default must be one of the constraint types
+class ClassT6[T: (int, str) = int | str]: ...  # E: TypeVar default must be one of the constraint types
+class ClassT7[T: (float, str) = int]: ...      # E: TypeVar default must be one of the constraint types
+
+class ClassP1[**P = int]: ...       # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+class ClassP2[**P = 2]: ...         # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+class ClassP3[**P = (2, int)]: ...  # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+class ClassP4[**P = [2, int]]: ...  # E: Argument 0 of ParamSpec default must be a type
+
+class ClassTs1[*Ts = 2]: ...           # E: The default argument to TypeVarTuple must be an Unpacked tuple
+class ClassTs2[*Ts = int]: ...         # E: The default argument to TypeVarTuple must be an Unpacked tuple
+class ClassTs3[*Ts = tuple[int]]: ...  # E: The default argument to TypeVarTuple must be an Unpacked tuple
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeParameterDefaultInvalid2]
+from typing import overload
+def f1[T = 2]() -> None: ...  # E: TypeVar "default" must be a type
+def f2[T = [int]]() -> None: ...  # E: Bracketed expression "[...]" is not valid as a type \
+                                  # N: Did you mean "List[...]"? \
+                                  # E: TypeVar "default" must be a type
+def f3[T: str = int](x: T) -> T: ...               # E: TypeVar default must be a subtype of the bound type
+def f4[T: list[str] = list[int]](x: T) -> T: ...   # E: TypeVar default must be a subtype of the bound type
+def f5[T: (int, str) = bytes](x: T) -> T: ...      # E: TypeVar default must be one of the constraint types
+def f6[T: (int, str) = int | str](x: T) -> T: ...  # E: TypeVar default must be one of the constraint types
+def f7[T: (float, str) = int](x: T) -> T: ...      # E: TypeVar default must be one of the constraint types
+def f8[T: str = int]() -> None: ...                # TODO check unused TypeVars
+@overload
+def f9[T: str = int](x: T) -> T: ...               # E: TypeVar default must be a subtype of the bound type
+@overload
+def f9[T: (int, str) = bytes](x: T) -> T: ...      # E: TypeVar default must be one of the constraint types
+def f9() -> None: ...  # type: ignore[misc]
+
+def g1[**P = int]() -> None: ...       # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+def g2[**P = 2]() -> None: ...         # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+def g3[**P = (2, int)]() -> None: ...  # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+def g4[**P = [2, int]]() -> None: ...  # E: Argument 0 of ParamSpec default must be a type
+
+def h1[*Ts = 2]() -> None: ...           # E: The default argument to TypeVarTuple must be an Unpacked tuple
+def h2[*Ts = int]() -> None: ...         # E: The default argument to TypeVarTuple must be an Unpacked tuple
+def h3[*Ts = tuple[int]]() -> None: ...  # E: The default argument to TypeVarTuple must be an Unpacked tuple
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeParameterDefaultInvalid3]
+from typing import Callable
+
+type TA1[T: str = 1] = list[T]  # E: TypeVar "default" must be a type
+type TA2[T: str = [int]] = list[T]  # E: Bracketed expression "[...]" is not valid as a type \
+                                    # N: Did you mean "List[...]"? \
+                                    # E: TypeVar "default" must be a type
+type TA3[T: str = int] = list[T]               # E: TypeVar default must be a subtype of the bound type
+type TA4[T: list[str] = list[int]] = list[T]   # E: TypeVar default must be a subtype of the bound type
+type TA5[T: (int, str) = bytes] = list[T]      # E: TypeVar default must be one of the constraint types
+type TA6[T: (int, str) = int | str] = list[T]  # E: TypeVar default must be one of the constraint types
+type TA7[T: (float, str) = int] = list[T]      # E: TypeVar default must be one of the constraint types
+
+type TB1[**P = int] = Callable[P, None]       # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+type TB2[**P = 2] = Callable[P, None]         # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+type TB3[**P = (2, int)] = Callable[P, None]  # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+type TB4[**P = [2, int]] = Callable[P, None]  # E: Argument 0 of ParamSpec default must be a type
+
+type TC1[*Ts = 2] = tuple[*Ts]           # E: The default argument to TypeVarTuple must be an Unpacked tuple
+type TC2[*Ts = int] = tuple[*Ts]         # E: The default argument to TypeVarTuple must be an Unpacked tuple
+type TC3[*Ts = tuple[int]] = tuple[*Ts]  # E: The default argument to TypeVarTuple must be an Unpacked tuple
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeParameterDefaultFunctions]
+from typing import Callable
+
+def callback1(x: str) -> None: ...
+
+def func_a1[T = str](x: int | T) -> T: ...
+reveal_type(func_a1(2))  # N: Revealed type is "builtins.str"
+reveal_type(func_a1(2.1))  # N: Revealed type is "builtins.float"
+
+def func_a2[T = str](x: int | T) -> list[T]: ...
+reveal_type(func_a2(2))  # N: Revealed type is "builtins.list[builtins.str]"
+reveal_type(func_a2(2.1))  # N: Revealed type is "builtins.list[builtins.float]"
+
+
+def func_a3[T: str = str](x: int | T) -> T: ...
+reveal_type(func_a3(2))  # N: Revealed type is "builtins.str"
+
+def func_a4[T: (bytes, str) = str](x: int | T) -> T: ...
+reveal_type(func_a4(2))  # N: Revealed type is "builtins.str"
+
+def func_b1[**P = [int, str]](x: int | Callable[P, None]) -> Callable[P, None]: ...
+reveal_type(func_b1(callback1))  # N: Revealed type is "def (x: builtins.str)"
+reveal_type(func_b1(2))  # N: Revealed type is "def (builtins.int, builtins.str)"
+
+def func_c1[*Ts = *tuple[int, str]](x: int | Callable[[*Ts], None]) -> tuple[*Ts]: ...
+# reveal_type(func_c1(callback1))  # Revealed type is "Tuple[str]"  # TODO
+reveal_type(func_c1(2))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeParameterDefaultClass1]
+# flags: --disallow-any-generics
+
+class ClassA1[T2 = int, T3 = str]: ...
+
+def func_a1(
+    a: ClassA1,
+    b: ClassA1[float],
+    c: ClassA1[float, float],
+    d: ClassA1[float, float, float],  # E: "ClassA1" expects between 0 and 2 type arguments, but 3 given
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassA1[builtins.int, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassA1[builtins.float, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassA1[builtins.float, builtins.float]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassA1[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeParameterDefaultClass2]
+# flags: --disallow-any-generics
+
+class ClassB1[**P2 = [int, str], **P3 = ...]: ...
+
+def func_b1(
+    a: ClassB1,
+    b: ClassB1[[float]],
+    c: ClassB1[[float], [float]],
+    d: ClassB1[[float], [float], [float]],  # E: "ClassB1" expects between 0 and 2 type arguments, but 3 given
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], ...]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassB1[[builtins.float], ...]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [builtins.float]]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], ...]"
+
+    k = ClassB1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], [*Any, **Any]]"
+    l = ClassB1[[float]]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [*Any, **Any]]"
+    m = ClassB1[[float], [float]]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [builtins.float]]"
+    n = ClassB1[[float], [float], [float]]()  # E: Type application has too many types (expected between 0 and 2)
+    reveal_type(n)  # N: Revealed type is "Any"
+
+[case testPEP695TypeParameterDefaultClass3]
+# flags: --disallow-any-generics
+
+class ClassC1[*Ts = *tuple[int, str]]: ...
+
+def func_c1(
+    a: ClassC1,
+    b: ClassC1[float],
+) -> None:
+    # reveal_type(a)  # Revealed type is "__main__.ClassC1[builtins.int, builtins.str]"  # TODO
+    reveal_type(b)  # N: Revealed type is "__main__.ClassC1[builtins.float]"
+
+    k = ClassC1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassC1[builtins.int, builtins.str]"
+    l = ClassC1[float]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassC1[builtins.float]"
+[builtins fixtures/tuple.pyi]
+
+[case testPEP695TypeParameterDefaultTypeAlias1]
+# flags: --disallow-any-generics
+
+type TA1[T2 = int, T3 = str] = dict[T2, T3]
+
+def func_a1(
+    a: TA1,
+    b: TA1[float],
+    c: TA1[float, float],
+    d: TA1[float, float, float],  # E: Bad number of arguments for type alias, expected between 0 and 2, given 3
+) -> None:
+    reveal_type(a)  # N: Revealed type is "builtins.dict[builtins.int, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "builtins.dict[builtins.float, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "builtins.dict[builtins.float, builtins.float]"
+    reveal_type(d)  # N: Revealed type is "builtins.dict[builtins.int, builtins.str]"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeParameterDefaultTypeAlias2]
+# flags: --disallow-any-generics
+
+class ClassB1[**P2, **P3]: ...
+type TB1[**P2 = [int, str], **P3 = ...] = ClassB1[P2, P3]
+
+def func_b1(
+    a: TB1,
+    b: TB1[[float]],
+    c: TB1[[float], [float]],
+    d: TB1[[float], [float], [float]],  # E: Bad number of arguments for type alias, expected between 0 and 2, given 3
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], [*Any, **Any]]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [*Any, **Any]]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [builtins.float]]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], [*Any, **Any]]"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeParameterDefaultTypeAlias3]
+# flags: --disallow-any-generics
+
+type TC1[*Ts = *tuple[int, str]] = tuple[*Ts]
+
+def func_c1(
+    a: TC1,
+    b: TC1[float],
+) -> None:
+    # reveal_type(a)  # Revealed type is "Tuple[builtins.int, builtins.str]"  # TODO
+    reveal_type(b)  # N: Revealed type is "Tuple[builtins.float]"
+
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testPEP695TypeParameterDefaultTypeAlias4]
+# flags: --disallow-any-generics
+class A[L = int, M = str]: ...
+TD1 = A[float]
+type TD2 = A[float]
+
+def func_d1(
+    a: TD1,
+    b: TD1[float],  # E: Bad number of arguments for type alias, expected 0, given 1
+    c: TD2,
+    d: TD2[float],  # E: Bad number of arguments for type alias, expected 0, given 1
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.A[builtins.float, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.A[builtins.float, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "__main__.A[builtins.float, builtins.str]"
+    reveal_type(d)  # N: Revealed type is "__main__.A[builtins.float, builtins.str]"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
diff --git a/test-data/unit/check-python38.test b/test-data/unit/check-python38.test
index 423daaf5ae8f..f90baed0eb16 100644
--- a/test-data/unit/check-python38.test
+++ b/test-data/unit/check-python38.test
@@ -17,8 +17,8 @@ def f(): ...  # E: Function is missing a return type annotation \
 # flags: --disallow-untyped-defs --warn-unused-ignores
 def d(f): ...  # type: ignore
 @d
-# type: ignore
-def f(): ...  # type: ignore  # E: Unused "type: ignore" comment
+# type: ignore  # E: Unused "type: ignore" comment
+def f(): ...  # type: ignore
 
 [case testIgnoreDecoratedFunction2]
 # flags: --disallow-untyped-defs
@@ -115,25 +115,21 @@ def g(x: int): ...
 )  # type: ignore  # E: Unused "type: ignore" comment
 
 [case testPEP570ArgTypesMissing]
-# flags: --python-version 3.8 --disallow-untyped-defs
+# flags: --disallow-untyped-defs
 def f(arg, /) -> None: ...  # E: Function is missing a type annotation for one or more arguments
 
 [case testPEP570ArgTypesBadDefault]
-# flags: --python-version 3.8
 def f(arg: int = "ERROR", /) -> None: ...  # E: Incompatible default for argument "arg" (default has type "str", argument has type "int")
 
 [case testPEP570ArgTypesDefault]
-# flags: --python-version 3.8
 def f(arg: int = 0, /) -> None:
     reveal_type(arg)  # N: Revealed type is "builtins.int"
 
 [case testPEP570ArgTypesRequired]
-# flags: --python-version 3.8
 def f(arg: int, /) -> None:
     reveal_type(arg)  # N: Revealed type is "builtins.int"
 
 [case testPEP570Required]
-# flags: --python-version 3.8
 def f(arg: int, /) -> None: ...  # N: "f" defined here
 f(1)
 f("ERROR")  # E: Argument 1 to "f" has incompatible type "str"; expected "int"
@@ -141,7 +137,6 @@ f(arg=1)  # E: Unexpected keyword argument "arg" for "f"
 f(arg="ERROR")  # E: Unexpected keyword argument "arg" for "f"
 
 [case testPEP570Default]
-# flags: --python-version 3.8
 def f(arg: int = 0, /) -> None: ...  # N: "f" defined here
 f()
 f(1)
@@ -150,7 +145,7 @@ f(arg=1)  # E: Unexpected keyword argument "arg" for "f"
 f(arg="ERROR")  # E: Unexpected keyword argument "arg" for "f"
 
 [case testPEP570Calls]
-# flags: --python-version 3.8 --no-strict-optional
+# flags: --no-strict-optional
 from typing import Any, Dict
 def f(p, /, p_or_kw, *, kw) -> None: ...  # N: "f" defined here
 d = None # type: Dict[Any, Any]
@@ -163,7 +158,6 @@ f(**d)  # E: Missing positional argument "p_or_kw" in call to "f"
 [builtins fixtures/dict.pyi]
 
 [case testPEP570Signatures1]
-# flags: --python-version 3.8
 def f(p1: bytes, p2: float, /, p_or_kw: int, *, kw: str) -> None:
     reveal_type(p1)  # N: Revealed type is "builtins.bytes"
     reveal_type(p2)  # N: Revealed type is "builtins.float"
@@ -171,7 +165,6 @@ def f(p1: bytes, p2: float, /, p_or_kw: int, *, kw: str) -> None:
     reveal_type(kw)  # N: Revealed type is "builtins.str"
 
 [case testPEP570Signatures2]
-# flags: --python-version 3.8
 def f(p1: bytes, p2: float = 0.0, /, p_or_kw: int = 0, *, kw: str) -> None:
     reveal_type(p1)  # N: Revealed type is "builtins.bytes"
     reveal_type(p2)  # N: Revealed type is "builtins.float"
@@ -179,33 +172,28 @@ def f(p1: bytes, p2: float = 0.0, /, p_or_kw: int = 0, *, kw: str) -> None:
     reveal_type(kw)  # N: Revealed type is "builtins.str"
 
 [case testPEP570Signatures3]
-# flags: --python-version 3.8
 def f(p1: bytes, p2: float = 0.0, /, *, kw: int) -> None:
     reveal_type(p1)  # N: Revealed type is "builtins.bytes"
     reveal_type(p2)  # N: Revealed type is "builtins.float"
     reveal_type(kw)  # N: Revealed type is "builtins.int"
 
 [case testPEP570Signatures4]
-# flags: --python-version 3.8
 def f(p1: bytes, p2: int = 0, /) -> None:
     reveal_type(p1)  # N: Revealed type is "builtins.bytes"
     reveal_type(p2)  # N: Revealed type is "builtins.int"
 
 [case testPEP570Signatures5]
-# flags: --python-version 3.8
 def f(p1: bytes, p2: float, /, p_or_kw: int) -> None:
     reveal_type(p1)  # N: Revealed type is "builtins.bytes"
     reveal_type(p2)  # N: Revealed type is "builtins.float"
     reveal_type(p_or_kw)  # N: Revealed type is "builtins.int"
 
 [case testPEP570Signatures6]
-# flags: --python-version 3.8
 def f(p1: bytes, p2: float, /) -> None:
     reveal_type(p1)  # N: Revealed type is "builtins.bytes"
     reveal_type(p2)  # N: Revealed type is "builtins.float"
 
 [case testPEP570Unannotated]
-# flags: --python-version 3.8
 def f(arg, /): ...  # N: "f" defined here
 g = lambda arg, /: arg
 def h(arg=0, /): ...  # N: "h" defined here
@@ -223,9 +211,7 @@ h(arg=0)  # E: Unexpected keyword argument "arg" for "h"
 i(arg=0)  # E: Unexpected keyword argument "arg"
 
 [case testWalrus]
-# flags: --strict-optional --python-version 3.8
-from typing import NamedTuple, Optional, List
-from typing_extensions import Final
+from typing import Final, NamedTuple, Optional, List
 
 if a := 2:
     reveal_type(a)  # N: Revealed type is "builtins.int"
@@ -310,8 +296,7 @@ def f(x: int = (c := 4)) -> int:
         z2: NT  # E: Variable "NT" is not valid as a type \
                 # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
 
-    if Alias := int:  # E: Function "Alias" could always be true in boolean context \
-                      # E: Function "int" could always be true in boolean context
+    if Alias := int:  # E: Function "Alias" could always be true in boolean context
         z3: Alias  # E: Variable "Alias" is not valid as a type \
                    # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
 
@@ -399,9 +384,7 @@ reveal_type(z2)  # E: Name "z2" is not defined  # N: Revealed type is "Any"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testWalrusConditionalTypeBinder]
-# flags: --python-version 3.8
-from typing import Tuple, Union
-from typing_extensions import Literal
+from typing import Literal, Tuple, Union
 
 class Good:
     @property
@@ -427,7 +410,6 @@ else:
 [builtins fixtures/list.pyi]
 
 [case testWalrusConditionalTypeCheck]
-# flags: --strict-optional --python-version 3.8
 from typing import Optional
 
 maybe_str: Optional[str]
@@ -443,7 +425,6 @@ reveal_type(maybe_str)  # N: Revealed type is "Union[builtins.str, None]"
 [builtins fixtures/bool.pyi]
 
 [case testWalrusConditionalTypeCheck2]
-# flags: --python-version 3.8
 from typing import Optional
 
 maybe_str: Optional[str]
@@ -459,7 +440,6 @@ reveal_type(maybe_str)  # N: Revealed type is "Union[builtins.str, None]"
 [builtins fixtures/bool.pyi]
 
 [case testWalrusPartialTypes]
-# flags: --python-version 3.8
 from typing import List
 
 def check_partial_list() -> None:
@@ -476,19 +456,18 @@ def check_partial_list() -> None:
 [builtins fixtures/list.pyi]
 
 [case testWalrusAssignmentAndConditionScopeForLiteral]
-# flags: --warn-unreachable --python-version 3.8
+# flags: --warn-unreachable
 
 if (x := 0):
     reveal_type(x)  # E: Statement is unreachable
 else:
-    reveal_type(x)  # N: Revealed type is "builtins.int"
+    reveal_type(x)  # N: Revealed type is "Literal[0]"
 
-reveal_type(x)  # N: Revealed type is "builtins.int"
+reveal_type(x)  # N: Revealed type is "Literal[0]"
 
 [case testWalrusAssignmentAndConditionScopeForProperty]
-# flags: --warn-unreachable --python-version 3.8
-
-from typing_extensions import Literal
+# flags: --warn-unreachable
+from typing import Literal
 
 class PropertyWrapper:
     @property
@@ -501,7 +480,7 @@ wrapper = PropertyWrapper()
 if x := wrapper.f:
     reveal_type(x)  # N: Revealed type is "builtins.str"
 else:
-    reveal_type(x)  # N: Revealed type is "builtins.str"
+    reveal_type(x)  # N: Revealed type is "Literal['']"
 
 reveal_type(x)  # N: Revealed type is "builtins.str"
 
@@ -514,16 +493,15 @@ reveal_type(y)  # N: Revealed type is "Literal[False]"
 [builtins fixtures/property.pyi]
 
 [case testWalrusAssignmentAndConditionScopeForFunction]
-# flags: --warn-unreachable --python-version 3.8
-
-from typing_extensions import Literal
+# flags: --warn-unreachable
+from typing import Literal
 
 def f() -> str: ...
 
 if x := f():
     reveal_type(x)  # N: Revealed type is "builtins.str"
 else:
-    reveal_type(x)  # N: Revealed type is "builtins.str"
+    reveal_type(x)  # N: Revealed type is "Literal['']"
 
 reveal_type(x)  # N: Revealed type is "builtins.str"
 
@@ -547,7 +525,6 @@ reveal_type(z)  # N: Revealed type is "Literal[False]"
 [builtins fixtures/tuple.pyi]
 
 [case testWalrusExpr]
-# flags: --python-version 3.8
 def func() -> None:
     foo = Foo()
     if x := foo.x:
@@ -558,7 +535,6 @@ class Foo:
         self.x = 123
 
 [case testWalrusTypeGuard]
-# flags: --python-version 3.8
 from typing_extensions import TypeGuard
 def is_float(a: object) -> TypeGuard[float]: pass
 def main(a: object) -> None:
@@ -568,14 +544,12 @@ def main(a: object) -> None:
 [builtins fixtures/tuple.pyi]
 
 [case testWalrusRedefined]
-# flags: --python-version 3.8
 def foo() -> None:
     x = 0
     [x := x + y for y in [1, 2, 3]]
 [builtins fixtures/dict.pyi]
 
 [case testWalrusUsedBeforeDef]
-# flags: --python-version 3.8
 class C:
     def f(self, c: 'C') -> None: pass
 
@@ -583,7 +557,6 @@ class C:
 (y := C()).f(y)
 
 [case testOverloadWithPositionalOnlySelf]
-# flags: --python-version 3.8
 from typing import overload, Optional
 
 class Foo:
@@ -608,7 +581,6 @@ class Bar:
 [builtins fixtures/bool.pyi]
 
 [case testOverloadPositionalOnlyErrorMessage]
-# flags: --python-version 3.8
 from typing import overload
 
 @overload
@@ -619,13 +591,12 @@ def foo(a): ...
 
 foo(a=1)
 [out]
-main:10: error: No overload variant of "foo" matches argument type "int"
-main:10: note: Possible overload variants:
-main:10: note:     def foo(int, /) -> Any
-main:10: note:     def foo(a: str) -> Any
+main:9: error: No overload variant of "foo" matches argument type "int"
+main:9: note: Possible overload variants:
+main:9: note:     def foo(int, /) -> Any
+main:9: note:     def foo(a: str) -> Any
 
 [case testOverloadPositionalOnlyErrorMessageAllTypes]
-# flags: --python-version 3.8
 from typing import overload
 
 @overload
@@ -636,13 +607,12 @@ def foo(a, b, *, c): ...
 
 foo(a=1)
 [out]
-main:10: error: No overload variant of "foo" matches argument type "int"
-main:10: note: Possible overload variants:
-main:10: note:     def foo(int, /, b: int, *, c: int) -> Any
-main:10: note:     def foo(a: str, b: int, *, c: int) -> Any
+main:9: error: No overload variant of "foo" matches argument type "int"
+main:9: note: Possible overload variants:
+main:9: note:     def foo(int, /, b: int, *, c: int) -> Any
+main:9: note:     def foo(a: str, b: int, *, c: int) -> Any
 
 [case testOverloadPositionalOnlyErrorMessageMultiplePosArgs]
-# flags: --python-version 3.8
 from typing import overload
 
 @overload
@@ -653,13 +623,12 @@ def foo(a, b, c, d): ...
 
 foo(a=1)
 [out]
-main:10: error: No overload variant of "foo" matches argument type "int"
-main:10: note: Possible overload variants:
-main:10: note:     def foo(int, int, int, /, d: str) -> Any
-main:10: note:     def foo(a: str, b: int, c: int, d: str) -> Any
+main:9: error: No overload variant of "foo" matches argument type "int"
+main:9: note: Possible overload variants:
+main:9: note:     def foo(int, int, int, /, d: str) -> Any
+main:9: note:     def foo(a: str, b: int, c: int, d: str) -> Any
 
 [case testOverloadPositionalOnlyErrorMessageMethod]
-# flags: --python-version 3.8
 from typing import overload
 
 class Some:
@@ -673,14 +642,13 @@ class Some:
 
 Some().foo(a=1)
 [out]
-main:13: error: No overload variant of "foo" of "Some" matches argument type "int"
-main:13: note: Possible overload variants:
-main:13: note:     def foo(self, int, /) -> Any
-main:13: note:     def foo(self, float, /) -> Any
-main:13: note:     def foo(self, a: str) -> Any
+main:12: error: No overload variant of "foo" of "Some" matches argument type "int"
+main:12: note: Possible overload variants:
+main:12: note:     def foo(self, int, /) -> Any
+main:12: note:     def foo(self, float, /) -> Any
+main:12: note:     def foo(self, a: str) -> Any
 
 [case testOverloadPositionalOnlyErrorMessageClassMethod]
-# flags: --python-version 3.8
 from typing import overload
 
 class Some:
@@ -699,15 +667,15 @@ class Some:
 Some.foo(a=1)
 [builtins fixtures/classmethod.pyi]
 [out]
-main:17: error: No overload variant of "foo" of "Some" matches argument type "int"
-main:17: note: Possible overload variants:
-main:17: note:     def foo(cls, int, /) -> Any
-main:17: note:     def foo(cls, float, /) -> Any
-main:17: note:     def foo(cls, a: str) -> Any
+main:16: error: No overload variant of "foo" of "Some" matches argument type "int"
+main:16: note: Possible overload variants:
+main:16: note:     def foo(cls, int, /) -> Any
+main:16: note:     def foo(cls, float, /) -> Any
+main:16: note:     def foo(cls, a: str) -> Any
 
 [case testUnpackWithDuplicateNamePositionalOnly]
-# flags: --python-version 3.8
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -715,9 +683,10 @@ class Person(TypedDict):
 def foo(name: str, /, **kwargs: Unpack[Person]) -> None:  # Allowed
     ...
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testPossiblyUndefinedWithAssignmentExpr]
-# flags: --python-version 3.8 --enable-error-code possibly-undefined
+# flags: --enable-error-code possibly-undefined
 def f1() -> None:
     d = {0: 1}
     if int():
@@ -729,7 +698,6 @@ def f1() -> None:
 [builtins fixtures/dict.pyi]
 
 [case testNarrowOnSelfInGeneric]
-# flags: --strict-optional
 from typing import Generic, TypeVar, Optional
 
 T = TypeVar("T", int, str)
@@ -741,11 +709,10 @@ class C(Generic[T]):
             reveal_type(y)
         return None
 [out]
-main:10: note: Revealed type is "builtins.int"
-main:10: note: Revealed type is "builtins.str"
+main:9: note: Revealed type is "builtins.int"
+main:9: note: Revealed type is "builtins.str"
 
 [case testTypeGuardWithPositionalOnlyArg]
-# flags: --python-version 3.8
 from typing_extensions import TypeGuard
 
 def typeguard(x: object, /) -> TypeGuard[int]:
@@ -756,10 +723,9 @@ if typeguard(n):
     reveal_type(n)
 [builtins fixtures/tuple.pyi]
 [out]
-main:9: note: Revealed type is "builtins.int"
+main:8: note: Revealed type is "builtins.int"
 
 [case testTypeGuardKeywordFollowingWalrus]
-# flags: --python-version 3.8
 from typing import cast
 from typing_extensions import TypeGuard
 
@@ -770,7 +736,7 @@ if typeguard(x=(n := cast(object, "hi"))):
     reveal_type(n)
 [builtins fixtures/tuple.pyi]
 [out]
-main:9: note: Revealed type is "builtins.int"
+main:8: note: Revealed type is "builtins.int"
 
 [case testNoCrashOnAssignmentExprClass]
 class C:
@@ -778,7 +744,6 @@ class C:
 [builtins fixtures/list.pyi]
 
 [case testNarrowedVariableInNestedModifiedInWalrus]
-# flags: --strict-optional
 from typing import Optional
 
 def walrus_with_nested_error(x: Optional[str]) -> None:
@@ -828,3 +793,11 @@ main:5: error: Dict entry 0 has incompatible type "str": "str"; expected "str":
 main:5: error: Unpacked dict entry 1 has incompatible type "Dict[str, str]"; expected "SupportsKeysAndGetItem[str, int]"
     dct: Dict[str, int] = {"a": "b", **other}
                                        ^~~~~
+
+[case testWalrusAssignmentEmptyCollection]
+from typing import List
+
+y: List[int]
+if (y := []):
+    reveal_type(y)  # N: Revealed type is "builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
diff --git a/test-data/unit/check-recursive-types.test b/test-data/unit/check-recursive-types.test
index 75f2433c6d8c..00d5489e515a 100644
--- a/test-data/unit/check-recursive-types.test
+++ b/test-data/unit/check-recursive-types.test
@@ -409,8 +409,9 @@ 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 "Type[...]"
+U = Type[Union[int, U]]  # E: Type[...] can't contain "Union[Type[...], Type[...]]" \
+                         # E: Type[...] can't contain "Type[...]"
 x: U
 reveal_type(x)  # N: Revealed type is "Type[Any]"
 
@@ -422,7 +423,6 @@ reveal_type(d)  # N: Revealed type is "Any"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testBasicRecursiveNamedTuple]
-# flags: --strict-optional
 from typing import NamedTuple, Optional
 
 NT = NamedTuple("NT", [("x", Optional[NT]), ("y", int)])
@@ -441,7 +441,7 @@ from typing import NamedTuple, TypeVar, Tuple
 NT = NamedTuple("NT", [("x", NT), ("y", int)])
 nt: NT
 reveal_type(nt)  # N: Revealed type is "Tuple[..., builtins.int, fallback=__main__.NT]"
-reveal_type(nt.x)  # N: Revealed type is "Tuple[Tuple[..., builtins.int, fallback=__main__.NT], builtins.int, fallback=__main__.NT]"
+reveal_type(nt.x)  # N: Revealed type is "Tuple[..., builtins.int, fallback=__main__.NT]"
 reveal_type(nt[0])  # N: Revealed type is "Tuple[Tuple[..., builtins.int, fallback=__main__.NT], builtins.int, fallback=__main__.NT]"
 y: str
 if nt.x is not None:
@@ -457,7 +457,6 @@ reveal_type(f(tnt, nt))  # N: Revealed type is "builtins.tuple[Any, ...]"
 [builtins fixtures/tuple.pyi]
 
 [case testBasicRecursiveNamedTupleClass]
-# flags: --strict-optional
 from typing import NamedTuple, Optional
 
 class NT(NamedTuple):
@@ -684,7 +683,6 @@ itd2 = TD(x=0, y=TD(x=0, y=TD(x=0, y=None)))
 [typing fixtures/typing-typeddict.pyi]
 
 [case testRecursiveTypedDictMethods]
-# flags: --strict-optional
 from typing import TypedDict
 
 class TD(TypedDict, total=False):
@@ -787,7 +785,6 @@ reveal_type(std)  # N: Revealed type is "TypedDict('__main__.STD', {'val': built
 [typing fixtures/typing-typeddict.pyi]
 
 [case testRecursiveClassLevelAlias]
-# flags: --strict-optional
 from typing import Union, Sequence
 
 class A:
@@ -882,13 +879,13 @@ def list_thing(transforming: InList[T]) -> T:
 reveal_type(list_thing([5]))  # N: Revealed type is "builtins.list[builtins.int]"
 
 [case testRecursiveTypedDictWithList]
-from typing import List
-from typing_extensions import TypedDict
+from typing import List, TypedDict
 
 Example = TypedDict("Example", {"rec": List["Example"]})
 e: Example
 reveal_type(e)  # N: Revealed type is "TypedDict('__main__.Example', {'rec': builtins.list[...]})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testRecursiveNamedTupleWithList]
 from typing import List, NamedTuple
@@ -937,3 +934,83 @@ 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 Literal, Tuple
+
+NotFilter = Tuple[Literal["not"], "NotFilter"]
+n: NotFilter
+reveal_type(n[1][1][0])  # N: Revealed type is "Literal['not']"
+[builtins fixtures/tuple.pyi]
+
+[case testNoCrashOnRecursiveAliasWithNone]
+# flags: --strict-optional
+from typing import Union, Generic, TypeVar, Optional
+
+T = TypeVar("T")
+class A(Generic[T]): ...
+class B(Generic[T]): ...
+
+Z = Union[A[Z], B[Optional[Z]]]
+X = Union[A[Optional[X]], B[Optional[X]]]
+
+z: Z
+x: X
+reveal_type(z)  # N: Revealed type is "Union[__main__.A[...], __main__.B[Union[..., None]]]"
+reveal_type(x)  # N: Revealed type is "Union[__main__.A[Union[..., None]], __main__.B[Union[..., None]]]"
+
+[case testRecursiveTupleFallback1]
+from typing import NewType, Tuple, Union
+
+T1 = NewType("T1", str)
+T2 = Tuple[T1, "T4", "T4"]
+T3 = Tuple[str, "T4", "T4"]
+T4 = Union[T2, T3]
+[builtins fixtures/tuple.pyi]
+
+[case testRecursiveTupleFallback2]
+from typing import NewType, Tuple, Union
+
+T1 = NewType("T1", str)
+class T2(Tuple[T1, "T4", "T4"]): ...
+T3 = Tuple[str, "T4", "T4"]
+T4 = Union[T2, T3]
+[builtins fixtures/tuple.pyi]
+
+[case testRecursiveTupleFallback3]
+from typing import NewType, Tuple, Union
+
+T1 = NewType("T1", str)
+T2 = Tuple[T1, "T4", "T4"]
+class T3(Tuple[str, "T4", "T4"]): ...
+T4 = Union[T2, T3]
+[builtins fixtures/tuple.pyi]
+
+[case testRecursiveTupleFallback4]
+from typing import NewType, Tuple, Union
+
+T1 = NewType("T1", str)
+class T2(Tuple[T1, "T4", "T4"]): ...
+class T3(Tuple[str, "T4", "T4"]): ...
+T4 = Union[T2, T3]
+[builtins fixtures/tuple.pyi]
+
+[case testRecursiveTupleFallback5]
+from typing import Protocol, Tuple, Union
+
+class Proto(Protocol):
+    def __len__(self) -> int: ...
+
+A = Union[Proto, Tuple[A]]
+ta: Tuple[A]
+p: Proto
+p = ta
+[builtins fixtures/tuple.pyi]
+
+[case testRecursiveAliasesWithAnyUnimported]
+# flags: --disallow-any-unimported
+from typing import Callable
+from bogus import Foo  # type: ignore
+
+A = Callable[[Foo, "B"], Foo]  # E: Type alias target becomes "Callable[[Any, B], Any]" due to an unfollowed import
+B = Callable[[Foo, A], Foo]  # E: Type alias target becomes "Callable[[Any, A], Any]" due to an unfollowed import
diff --git a/test-data/unit/check-redefine.test b/test-data/unit/check-redefine.test
index e3f1b976d4e9..aaec94b546f5 100644
--- a/test-data/unit/check-redefine.test
+++ b/test-data/unit/check-redefine.test
@@ -88,6 +88,7 @@ def h(a: Iterable[int]) -> None:
 
 [case testCannotRedefineLocalWithinTry]
 # flags: --allow-redefinition
+def g(): pass
 def f() -> None:
     try:
         x = 0
@@ -102,7 +103,67 @@ def f() -> None:
     y
     y = ''
 
-def g(): pass
+[case testRedefineLocalWithinTryClauses]
+# flags: --allow-redefinition
+def fn_str(_: str) -> int: ...
+def fn_int(_: int) -> None: ...
+
+def in_block() -> None:
+    try:
+        a = ""
+        a = fn_str(a)  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+        fn_int(a)  # E: Argument 1 to "fn_int" has incompatible type "str"; expected "int"
+    except:
+        b = ""
+        b = fn_str(b)
+        fn_int(b)
+    else:
+        c = ""
+        c = fn_str(c)
+        fn_int(c)
+    finally:
+        d = ""
+        d = fn_str(d)
+        fn_int(d)
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+    reveal_type(b)  # N: Revealed type is "builtins.int"
+    reveal_type(c)  # N: Revealed type is "builtins.int"
+    reveal_type(d)  # N: Revealed type is "builtins.int"
+
+def across_blocks() -> None:
+    try:
+        a = ""
+    except:
+        pass
+    else:
+        a = fn_str(a)  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+
+[case testRedefineLocalExceptVar]
+# flags: --allow-redefinition
+def fn_exc(_: Exception) -> str: ...
+
+def exc_name() -> None:
+    try:
+        pass
+    except RuntimeError as e:
+        e = fn_exc(e)
+[builtins fixtures/exception.pyi]
+
+[case testRedefineNestedInTry]
+# flags: --allow-redefinition
+
+def fn_int(_: int) -> None: ...
+
+try:
+    try:
+        ...
+    finally:
+        a = ""
+        a = 5  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+        fn_int(a)  # E: Argument 1 to "fn_int" has incompatible type "str"; expected "int"
+except:
+    pass
 
 [case testRedefineLocalWithinWith]
 # flags: --allow-redefinition
@@ -193,7 +254,8 @@ def f() -> None:
     _, _ = 1, ''
     if 1:
         _, _ = '', 1
-        reveal_type(_) # N: Revealed type is "Any"
+        # This is unintentional but probably fine. No one is going to read _ value.
+        reveal_type(_) # N: Revealed type is "builtins.int"
 
 [case testRedefineWithBreakAndContinue]
 # flags: --allow-redefinition
@@ -270,14 +332,16 @@ def f() -> None:
 from typing import TypeVar
 def f() -> None:
     x = TypeVar('x')
-    x = 1  # E: Invalid assignment target
-    reveal_type(x) # N: Revealed type is "builtins.int"
+    x = 1  # E: Invalid assignment target \
+           # E: Incompatible types in assignment (expression has type "int", variable has type "TypeVar")
+    reveal_type(x) # N: Revealed type is "typing.TypeVar"
     y = 1
-    # NOTE: '"int" not callable' is due to test stubs
     y = TypeVar('y')  # E: Cannot redefine "y" as a type variable \
-                      # E: "int" not callable
+                      # E: Incompatible types in assignment (expression has type "TypeVar", variable has type "int")
     def h(a: y) -> y: return a # E: Variable "y" is not valid as a type \
                                # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testCannotRedefineVarAsModule]
 # flags: --allow-redefinition
@@ -318,7 +382,7 @@ def f() -> None:
     x = 1
     if int():
         x = ''
-    reveal_type(x) # N: Revealed type is "builtins.object"
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, builtins.int]"
     x = ''
     reveal_type(x) # N: Revealed type is "builtins.str"
     if int():
diff --git a/test-data/unit/check-redefine2.test b/test-data/unit/check-redefine2.test
new file mode 100644
index 000000000000..238b64399ce4
--- /dev/null
+++ b/test-data/unit/check-redefine2.test
@@ -0,0 +1,1193 @@
+-- Test cases for the redefinition of variable with a different type (new version).
+
+[case testNewRedefineLocalWithDifferentType]
+# flags: --allow-redefinition-new --local-partial-types
+def f() -> None:
+    x = 0
+    reveal_type(x) # N: Revealed type is "builtins.int"
+    x = ''
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+[case testNewRedefineConditionalLocalWithDifferentType]
+# flags: --allow-redefinition-new --local-partial-types
+def f() -> None:
+    if int():
+        x = 0
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    else:
+        x = ''
+        reveal_type(x) # N: Revealed type is "builtins.str"
+
+[case testNewRedefineMergeConditionalLocal1]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    if int():
+        x = 0
+    else:
+        x = ''
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f2() -> None:
+    if int():
+        x = 0
+    else:
+        x = None
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
+
+[case testNewRedefineMergeConditionalLocal2]
+# flags: --allow-redefinition-new --local-partial-types
+def nested_ifs() -> None:
+    if int():
+        if int():
+            x = 0
+        else:
+            x = ''
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+    else:
+        if int():
+            x = None
+        else:
+            x = b""
+        reveal_type(x) # N: Revealed type is "Union[None, builtins.bytes]"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str, None, builtins.bytes]"
+
+[case testNewRedefineUninitializedCodePath1]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    if int():
+        x = 0
+        reveal_type(x) # N: Revealed type is "builtins.int"
+        x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+[case testNewRedefineUninitializedCodePath2]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Union
+
+def f1() -> None:
+    if int():
+        x: Union[int, str] = 0
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+        x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+[case testNewRedefineUninitializedCodePath3]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Union
+
+def f1() -> None:
+    if int():
+        x = 0
+    elif int():
+        x = ""
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineUninitializedCodePath4]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Union
+
+def f1() -> None:
+    if int():
+        x: Union[int, str] = 0
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineUninitializedCodePath5]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Union
+
+def f1() -> None:
+    x = 0
+    if int():
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+        x = None
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
+
+[case testNewRedefineUninitializedCodePath6]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Union
+
+x: Union[str, None]
+
+def f1() -> None:
+    if x is not None:
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, None]"
+
+[case testNewRedefineGlobalVariableSimple]
+# flags: --allow-redefinition-new --local-partial-types
+if int():
+    x = 0
+    reveal_type(x) # N: Revealed type is "builtins.int"
+else:
+    x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f1() -> None:
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f2() -> None:
+    global x
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+    x = 0
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineGlobalVariableNoneInit]
+# flags: --allow-redefinition-new --local-partial-types
+x = None
+
+def f() -> None:
+    global x
+    reveal_type(x) # N: Revealed type is "None"
+    x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "None")
+    reveal_type(x) # N: Revealed type is "None"
+
+reveal_type(x) # N: Revealed type is "None"
+
+[case testNewRedefineParameterTypes]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Optional
+
+def f1(x: Optional[str] = None) -> None:
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, None]"
+    if x is None:
+        x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f2(*args: str, **kwargs: int) -> None:
+     reveal_type(args) # N: Revealed type is "builtins.tuple[builtins.str, ...]"
+     reveal_type(kwargs) # N: Revealed type is "builtins.dict[builtins.str, builtins.int]"
+
+class C:
+    def m(self) -> None:
+        reveal_type(self) # N: Revealed type is "__main__.C"
+[builtins fixtures/dict.pyi]
+
+
+[case testNewRedefineClassBody]
+# flags: --allow-redefinition-new --local-partial-types
+class C:
+    if int():
+        x = 0
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    else:
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+reveal_type(C.x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineNestedFunctionBasics]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    if int():
+        x = 0
+    else:
+        x = ""
+
+    def nested() -> None:
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f2() -> None:
+    if int():
+        x = 0
+    else:
+        x = ""
+
+    def nested() -> None:
+        nonlocal x
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+        x = 0
+        reveal_type(x) # N: Revealed type is "builtins.int"
+
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineLambdaBasics]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    x = 0
+    if int():
+        x = None
+    f = lambda: reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
+    reveal_type(f) # N: Revealed type is "def () -> Union[builtins.int, None]"
+    if x is None:
+        x = ""
+    f = lambda: reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+    reveal_type(f) # N: Revealed type is "def () -> Union[builtins.int, builtins.str]"
+
+[case testNewRedefineAssignmentExpression]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    if x := int():
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    elif x := str():
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f2() -> None:
+    if x := int():
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    elif x := str():
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    else:
+        pass
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f3() -> None:
+    if (x := int()) or (x := str()):
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineOperatorAssignment]
+# flags: --allow-redefinition-new --local-partial-types
+class D: pass
+class C:
+    def __add__(self, x: C) -> D: ...
+
+c = C()
+if int():
+    c += C()
+    reveal_type(c) # N: Revealed type is "__main__.D"
+reveal_type(c) # N: Revealed type is "Union[__main__.C, __main__.D]"
+
+[case testNewRedefineImportFrom-xfail]
+# flags: --allow-redefinition-new --local-partial-types
+if int():
+    from m import x
+else:
+    # TODO: This could be useful to allow
+    from m import y as x # E: Incompatible import of "x" (imported name has type "str", local name has type "int")
+reveal_type(x) # N: Revealed type is "builtins.int"
+
+if int():
+    from m import y
+else:
+    y = 1
+reveal_type(y) # N: Revealed type is "Union[builtins.str, builtins.int]"
+
+[file m.py]
+x = 1
+y = ""
+
+[case testNewRedefineImport]
+# flags: --allow-redefinition-new --local-partial-types
+if int():
+    import m
+else:
+    import m2 as m # E: Name "m" already defined (by an import)
+m.x
+m.y # E: Module has no attribute "y"
+
+[file m.py]
+x = 1
+
+[file m2.py]
+y = ""
+[builtins fixtures/module.pyi]
+
+[case testNewRedefineOptionalTypesSimple]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    x = None
+    if int():
+        x = ""
+    reveal_type(x) # N: Revealed type is "Union[None, builtins.str]"
+
+def f2() -> None:
+    if int():
+        x = None
+    elif int():
+        x = ""
+    else:
+        x = 1
+    reveal_type(x) # N: Revealed type is "Union[None, builtins.str, builtins.int]"
+
+def f3() -> None:
+    if int():
+        x = None
+    else:
+        x = ""
+    reveal_type(x) # N: Revealed type is "Union[None, builtins.str]"
+
+def f4() -> None:
+    x = None
+    reveal_type(x) # N: Revealed type is "None"
+
+y = None
+if int():
+    y = 1
+reveal_type(y) # N: Revealed type is "Union[None, builtins.int]"
+
+if int():
+    z = None
+elif int():
+    z = 1
+else:
+    z = ""
+reveal_type(z) # N: Revealed type is "Union[None, builtins.int, builtins.str]"
+
+[case testNewRedefinePartialTypeForInstanceVariable]
+# flags: --allow-redefinition-new --local-partial-types
+class C1:
+    def __init__(self) -> None:
+        self.x = None
+        if int():
+            self.x = 1
+            reveal_type(self.x) # N: Revealed type is "builtins.int"
+        reveal_type(self.x) # N: Revealed type is "Union[builtins.int, None]"
+
+reveal_type(C1().x) # N: Revealed type is "Union[builtins.int, None]"
+
+class C2:
+    def __init__(self) -> None:
+        self.x = []
+        for i in [1, 2]:
+            self.x.append(i)
+        reveal_type(self.x) # N: Revealed type is "builtins.list[builtins.int]"
+
+reveal_type(C2().x) # N: Revealed type is "builtins.list[builtins.int]"
+
+class C3:
+    def __init__(self) -> None:
+        self.x = None
+        if int():
+            self.x = 1
+        else:
+            self.x = "" # E: Incompatible types in assignment (expression has type "str", variable has type "Optional[int]")
+        reveal_type(self.x) # N: Revealed type is "Union[builtins.int, None]"
+
+reveal_type(C3().x) # N: Revealed type is "Union[builtins.int, None]"
+
+class C4:
+    def __init__(self) -> None:
+        self.x = []
+        if int():
+            self.x = [""]
+        reveal_type(self.x) # N: Revealed type is "builtins.list[builtins.str]"
+
+reveal_type(C4().x) # N: Revealed type is "builtins.list[builtins.str]"
+[builtins fixtures/list.pyi]
+
+[case testNewRedefinePartialGenericTypes]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    a = []
+    a.append(1)
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+
+def f2() -> None:
+    a = []
+    a.append(1)
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+    a = [""]
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.str]"
+
+def f3() -> None:
+    a = []
+    a.append(1)
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+    a = []
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+
+def f4() -> None:
+    a = []
+    a.append(1)
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+    # Partial types are currently not supported on reassignment
+    a = []
+    a.append("x") # E: Argument 1 to "append" of "list" has incompatible type "str"; expected "int"
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+
+def f5() -> None:
+    if int():
+        a = []
+        a.append(1)
+        reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+    else:
+        b = [""]
+        a = b
+        reveal_type(a) # N: Revealed type is "builtins.list[builtins.str]"
+    reveal_type(a) # N: Revealed type is "Union[builtins.list[builtins.int], builtins.list[builtins.str]]"
+
+def f6() -> None:
+    a = []
+    a.append(1)
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.int]"
+    b = [""]
+    a = b
+    reveal_type(a) # N: Revealed type is "builtins.list[builtins.str]"
+[builtins fixtures/list.pyi]
+
+[case testNewRedefineFinalLiteral]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Final, Literal
+
+x: Final = "foo"
+reveal_type(x) # N: Revealed type is "Literal['foo']?"
+a: Literal["foo"] = x
+
+class B:
+    x: Final = "bar"
+    a: Literal["bar"] = x
+reveal_type(B.x) # N: Revealed type is "Literal['bar']?"
+[builtins fixtures/tuple.pyi]
+
+[case testNewRedefineAnnotatedVariable]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Optional
+
+def f1() -> None:
+    x: int = 0
+    if int():
+        x = "" # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f2(x: Optional[str]) -> None:
+    if x is not None:
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    else:
+        x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f3() -> None:
+    a: list[Optional[str]] = [""]
+    reveal_type(a) # N: Revealed type is "builtins.list[Union[builtins.str, None]]"
+    a = [""]
+    reveal_type(a) # N: Revealed type is "builtins.list[Union[builtins.str, None]]"
+
+class C:
+    x: Optional[str]
+
+    def f(self) -> None:
+        if self.x is not None:
+            reveal_type(self.x) # N: Revealed type is "builtins.str"
+        else:
+            self.x = ""
+        reveal_type(self.x) # N: Revealed type is "builtins.str"
+
+[case testNewRedefineAnyType1]
+# flags: --allow-redefinition-new --local-partial-types
+def a(): pass
+
+def f1() -> None:
+    if int():
+        x = ""
+    else:
+        x = a()
+        reveal_type(x) # N: Revealed type is "Any"
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, Any]"
+    x = 1
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f2() -> None:
+    if int():
+        x = a()
+    else:
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "Union[Any, builtins.str]"
+    x = 1
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f3() -> None:
+    x = 1
+    x = a()
+    reveal_type(x) # N: Revealed type is "Any"
+    x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f4() -> None:
+    x = a()
+    x = 1
+    reveal_type(x) # N: Revealed type is "builtins.int"
+    x = a()
+    reveal_type(x) # N: Revealed type is "Any"
+
+def f5() -> None:
+    x = a()
+    if int():
+        x = 1
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    elif int():
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "Union[Any, builtins.int, builtins.str]"
+
+def f6() -> None:
+    x = a()
+    if int():
+        x = 1
+    else:
+        x = ""
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f7() -> None:
+    x: int
+    x = a()
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+[case testNewRedefineAnyType2]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Any
+
+def f1() -> None:
+    x: Any
+    x = int()
+    reveal_type(x) # N: Revealed type is "Any"
+
+def f2() -> None:
+    x: Any
+    if int():
+        x = 0
+        reveal_type(x) # N: Revealed type is "Any"
+    else:
+        x = ""
+        reveal_type(x) # N: Revealed type is "Any"
+    reveal_type(x) # N: Revealed type is "Any"
+
+def f3(x) -> None:
+    if int():
+        x = 0
+        reveal_type(x) # N: Revealed type is "Any"
+    reveal_type(x) # N: Revealed type is "Any"
+
+[case tetNewRedefineDel]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+    del x
+    reveal_type(x) # N: Revealed type is "<Deleted 'x'>"
+    x = 0
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f2() -> None:
+    if int():
+        x = 0
+        del x
+    else:
+        x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f3() -> None:
+    if int():
+        x = 0
+    else:
+        x = ""
+        del x
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f4() -> None:
+    while int():
+        if int():
+            x: int = 0
+        else:
+            del x
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f5() -> None:
+    while int():
+        if int():
+            x = 0
+        else:
+            del x
+            continue
+        x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+[case testNewRedefineWhileLoopSimple]
+# flags: --allow-redefinition-new --local-partial-types
+def f() -> None:
+    while int():
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+        x = 0
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    reveal_type(x) # N: Revealed type is "builtins.int"
+    while int():
+        x = None
+        reveal_type(x) # N: Revealed type is "None"
+        x = b""
+        reveal_type(x) # N: Revealed type is "builtins.bytes"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.bytes]"
+    x = [1]
+    reveal_type(x) # N: Revealed type is "builtins.list[builtins.int]"
+
+[case testNewRedefineWhileLoopOptional]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    x = None
+    while int():
+        if int():
+            x = ""
+    reveal_type(x) # N: Revealed type is "Union[None, builtins.str]"
+
+def f2() -> None:
+    x = None
+    while int():
+        reveal_type(x) # N: Revealed type is "None" \
+                       # N: Revealed type is "Union[None, builtins.str]"
+        if int():
+            x = ""
+    reveal_type(x) # N: Revealed type is "Union[None, builtins.str]"
+
+[case testNewRedefineWhileLoopPartialType]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    x = []
+    while int():
+        x.append(1)
+    reveal_type(x) # N: Revealed type is "builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testNewRedefineWhileLoopComplex1]
+# flags: --allow-redefinition-new --local-partial-types
+
+def f1() -> None:
+    while True:
+        try:
+            pass
+        except Exception as e:
+            continue
+[builtins fixtures/exception.pyi]
+
+[case testNewRedefineWhileLoopComplex2]
+# flags: --allow-redefinition-new --local-partial-types
+
+class C:
+    def __enter__(self) -> str: ...
+    def __exit__(self, *args) -> str: ...
+
+def f1() -> None:
+    while True:
+        with C() as x:
+            continue
+
+def f2() -> None:
+    while True:
+        from m import y
+        if int():
+            continue
+
+[file m.py]
+y = ""
+[builtins fixtures/tuple.pyi]
+
+[case testNewRedefineReturn]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    if int():
+        x = 0
+        return
+    else:
+        x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f2() -> None:
+    if int():
+        x = ""
+    else:
+        x = 0
+        return
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+[case testNewRedefineBreakAndContinue]
+# flags: --allow-redefinition-new --local-partial-types
+def b() -> None:
+    while int():
+        x = ""
+        if int():
+            x = 1
+            break
+        reveal_type(x) # N: Revealed type is "builtins.str"
+        x = None
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
+
+def c() -> None:
+    x = 0
+    while int():
+        reveal_type(x) # N: Revealed type is "builtins.int" \
+                       # N: Revealed type is "Union[builtins.int, builtins.str, None]"
+        if int():
+            x = ""
+            continue
+        else:
+            x = None
+        reveal_type(x) # N: Revealed type is "None"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str, None]"
+
+[case testNewRedefineUnderscore]
+# flags: --allow-redefinition-new --local-partial-types
+def f() -> None:
+    if int():
+        _ = 0
+        reveal_type(_) # N: Revealed type is "builtins.int"
+    else:
+        _ = ""
+        reveal_type(_) # N: Revealed type is "builtins.str"
+    reveal_type(_) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineWithStatement]
+# flags: --allow-redefinition-new --local-partial-types
+class C:
+    def __enter__(self) -> int: ...
+    def __exit__(self, x, y, z): ...
+class D:
+    def __enter__(self) -> str: ...
+    def __exit__(self, x, y, z): ...
+
+def f1() -> None:
+    with C() as x:
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    with D() as x:
+        reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f2() -> None:
+    if int():
+        with C() as x:
+            reveal_type(x) # N: Revealed type is "builtins.int"
+    else:
+        with D() as x:
+            reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[case testNewRedefineTryStatement]
+# flags: --allow-redefinition-new --local-partial-types
+class E(Exception): pass
+
+def g(): ...
+
+def f1() -> None:
+    try:
+        x = 1
+        g()
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    except RuntimeError as e:
+        reveal_type(e) # N: Revealed type is "builtins.RuntimeError"
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+    except E as e:
+        reveal_type(e) # N: Revealed type is "__main__.E"
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+    reveal_type(e) # N: Revealed type is "<Deleted 'e'>"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f2() -> None:
+    try:
+        x = 1
+        if int():
+            x = ""
+            return
+    except Exception:
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+        return
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f3() -> None:
+    try:
+        x = 1
+        if int():
+            x = ""
+            return
+    finally:
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]" \
+            # N: Revealed type is "builtins.int"
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f4() -> None:
+    while int():
+        try:
+            x = 1
+            if int():
+                x = ""
+                break
+            if int():
+                while int():
+                    if int():
+                        x = None
+                        break
+        finally:
+            reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str, None]" \
+                # N: Revealed type is "Union[builtins.int, None]"
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
+[builtins fixtures/exception.pyi]
+
+[case testNewRedefineRaiseStatement]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    if int():
+        x = ""
+    elif int():
+        x = None
+        raise Exception()
+    else:
+        x = 1
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, builtins.int]"
+
+def f2() -> None:
+    try:
+        x = 1
+        if int():
+            x = ""
+            raise Exception()
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    except Exception:
+        reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+[builtins fixtures/exception.pyi]
+
+
+[case testNewRedefineMultipleAssignment]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    x, y = 1, ""
+    reveal_type(x) # N: Revealed type is "builtins.int"
+    reveal_type(y) # N: Revealed type is "builtins.str"
+    x, y = None, 2
+    reveal_type(x) # N: Revealed type is "None"
+    reveal_type(y) # N: Revealed type is "builtins.int"
+
+def f2() -> None:
+    if int():
+        x, y = 1, ""
+        reveal_type(x) # N: Revealed type is "builtins.int"
+        reveal_type(y) # N: Revealed type is "builtins.str"
+    else:
+        x, y = None, 2
+        reveal_type(x) # N: Revealed type is "None"
+        reveal_type(y) # N: Revealed type is "builtins.int"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
+    reveal_type(y) # N: Revealed type is "Union[builtins.str, builtins.int]"
+
+[case testNewRedefineForLoopBasics]
+# flags: --allow-redefinition-new --local-partial-types
+def f1() -> None:
+    for x in [1]:
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    for x in [""]:
+        reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f2() -> None:
+    if int():
+        for x, y in [(1, "x")]:
+            reveal_type(x) # N: Revealed type is "builtins.int"
+            reveal_type(y) # N: Revealed type is "builtins.str"
+    else:
+        for x, y in [(None, 1)]:
+            reveal_type(x) # N: Revealed type is "None"
+            reveal_type(y) # N: Revealed type is "builtins.int"
+
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, None]"
+    reveal_type(y) # N: Revealed type is "Union[builtins.str, builtins.int]"
+[builtins fixtures/for.pyi]
+
+[case testNewRedefineForLoop1]
+# flags: --allow-redefinition-new --local-partial-types
+def l() -> list[int]:
+    return []
+
+def f1() -> None:
+    x = ""
+    for x in l():
+        reveal_type(x) # N: Revealed type is "builtins.int"
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, builtins.int]"
+
+def f2() -> None:
+    for x in [1, 2]:
+        x = [x]
+    reveal_type(x) # N: Revealed type is "builtins.list[builtins.int]"
+
+def f3() -> None:
+    for x in [1, 2]:
+        if int():
+            x = "x"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+[builtins fixtures/for.pyi]
+
+[case testNewRedefineForLoop2]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Any
+
+def f(a: Any) -> None:
+    for d in a:
+        if isinstance(d["x"], str):
+            return
+[builtins fixtures/isinstance.pyi]
+
+[case testNewRedefineForStatementIndexNarrowing]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import TypedDict
+
+class X(TypedDict):
+    hourly: int
+    daily: int
+
+x: X
+for a in ("hourly", "daily"):
+    reveal_type(a)  # N: Revealed type is "Union[Literal['hourly']?, Literal['daily']?]"
+    reveal_type(x[a])  # N: Revealed type is "builtins.int"
+    reveal_type(a.upper())  # N: Revealed type is "builtins.str"
+    c = a
+    reveal_type(c)  # N: Revealed type is "builtins.str"
+    a = "monthly"
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+    a = "yearly"
+    reveal_type(a)  # N: Revealed type is "builtins.str"
+    a = 1
+    reveal_type(a)  # N: Revealed type is "builtins.int"
+reveal_type(a) # N: Revealed type is "builtins.int"
+
+b: str
+for b in ("hourly", "daily"):
+    reveal_type(b)  # N: Revealed type is "builtins.str"
+    reveal_type(b.upper())  # N: Revealed type is "builtins.str"
+[builtins fixtures/for.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testNewRedefineForLoopIndexWidening]
+# flags: --allow-redefinition-new --local-partial-types
+
+def f1() -> None:
+    for x in [1]:
+        reveal_type(x) # N: Revealed type is "builtins.int"
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+def f2() -> None:
+    for x in [1]:
+        reveal_type(x) # N: Revealed type is "builtins.int"
+        if int():
+            break
+        x = ""
+        reveal_type(x) # N: Revealed type is "builtins.str"
+    reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+def f3() -> None:
+    if int():
+        for x in [1]:
+            x = ""
+    reveal_type(x) # N: Revealed type is "builtins.str"
+
+[case testNewRedefineVariableAnnotatedInLoop]
+# flags: --allow-redefinition-new --local-partial-types --enable-error-code=redundant-expr
+from typing import Optional
+
+def f1() -> None:
+    e: Optional[str] = None
+    for x in ["a"]:
+        if e is None and int():
+            e = x
+            continue
+        elif e is not None and int():
+            break
+        reveal_type(e) # N: Revealed type is "Union[builtins.str, None]"
+    reveal_type(e) # N: Revealed type is "Union[builtins.str, None]"
+
+def f2(e: Optional[str]) -> None:
+    for x in ["a"]:
+        if e is None and int():
+            e = x
+            continue
+        elif e is not None and int():
+            break
+        reveal_type(e) # N: Revealed type is "Union[builtins.str, None]"
+    reveal_type(e) # N: Revealed type is "Union[builtins.str, None]"
+
+[case testNewRedefineLoopAndPartialTypesSpecialCase]
+# flags: --allow-redefinition-new --local-partial-types
+def f() -> list[str]:
+    a = []  # type: ignore
+    o = []
+    for line in ["x"]:
+        if int():
+            continue
+        if int():
+            a = []
+        if int():
+            a.append(line)
+        else:
+            o.append(line)
+    return o
+[builtins fixtures/list.pyi]
+
+[case testNewRedefineFinalVariable]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import Final
+
+x: Final = "foo"
+x = 1 # E: Cannot assign to final name "x" \
+      # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+class C:
+    y: Final = "foo"
+    y = 1 # E: Cannot assign to final name "y" \
+          # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+[case testNewRedefineEnableUsingComment]
+# flags: --local-partial-types
+import a
+import b
+
+[file a.py]
+# mypy: allow-redefinition-new
+if int():
+    x = 0
+else:
+    x = ""
+reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
+
+[file b.py]
+if int():
+    x = 0
+else:
+    x = "" # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+reveal_type(x) # N: Revealed type is "builtins.int"
+
+[case testNewRedefineWithoutLocalPartialTypes]
+import a
+import b
+
+[file a.py]
+# mypy: local-partial-types, allow-redefinition-new
+x = 0
+if int():
+    x = ""
+
+[file b.py]
+# mypy: allow-redefinition-new
+x = 0
+if int():
+    x = ""
+
+[out]
+tmp/b.py:1: error: --local-partial-types must be enabled if using --allow-redefinition-new
+
+[case testNewRedefineNestedLoopInfiniteExpansion]
+# flags: --allow-redefinition-new --local-partial-types
+def a(): ...
+
+def f() -> None:
+    while int():
+        x = a()
+
+        while int():
+            x = [x]
+
+    reveal_type(x) # N: Revealed type is "Union[Any, builtins.list[Any], builtins.list[Union[Any, builtins.list[Any]]], builtins.list[Union[Any, builtins.list[Any], builtins.list[Union[Any, builtins.list[Any]]]]], builtins.list[Union[Any, builtins.list[Any], builtins.list[Union[Any, builtins.list[Any]]], builtins.list[Union[Any, builtins.list[Any], builtins.list[Union[Any, builtins.list[Any]]]]]]]]"
+
+[case testNewRedefinePartialNoneEmptyList]
+# flags: --allow-redefinition-new --local-partial-types
+def func() -> None:
+    l = None
+
+    if int():
+        l = [] # E: Need type annotation for "l"
+        l.append(1)
+    reveal_type(l) # N: Revealed type is "Union[None, builtins.list[Any]]"
+[builtins fixtures/list.pyi]
+
+[case testNewRedefineNarrowingSpecialCase]
+# flags: --allow-redefinition-new --local-partial-types --warn-unreachable
+from typing import Any, Union
+
+def get() -> Union[tuple[Any, Any], tuple[None, None]]: ...
+
+def f() -> None:
+    x, _ = get()
+    reveal_type(x) # N: Revealed type is "Union[Any, None]"
+    if x and int():
+        reveal_type(x) # N: Revealed type is "Any"
+    reveal_type(x) # N: Revealed type is "Union[Any, None]"
+    if x and int():
+        reveal_type(x) # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testNewRedefinePartialTypeForUnderscore]
+# flags: --allow-redefinition-new --local-partial-types
+
+def t() -> tuple[int]:
+    return (42,)
+
+def f1() -> None:
+    # Underscore is slightly special to preserve backward compatibility
+    x, *_ = t()
+    reveal_type(x) # N: Revealed type is "builtins.int"
+
+def f2() -> None:
+    x, *y = t() # E: Need type annotation for "y" (hint: "y: List[<type>] = ...")
+
+def f3() -> None:
+    x, _ = 1, []
+
+def f4() -> None:
+    a, b = 1, [] # E: Need type annotation for "b" (hint: "b: List[<type>] = ...")
+[builtins fixtures/tuple.pyi]
+
+[case testNewRedefineUseInferredTypedDictTypeForContext]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import TypedDict
+
+class TD(TypedDict):
+    x: int
+
+def f() -> None:
+    td = TD(x=1)
+    if int():
+        td = {"x": 5}
+    reveal_type(td) # N: Revealed type is "TypedDict('__main__.TD', {'x': builtins.int})"
+[typing fixtures/typing-typeddict.pyi]
+
+[case testNewRedefineEmptyGeneratorUsingUnderscore]
+# flags: --allow-redefinition-new --local-partial-types
+def f() -> None:
+    gen = (_ for _ in ())
+    reveal_type(gen) # N: Revealed type is "typing.Generator[Any, None, None]"
+[builtins fixtures/tuple.pyi]
+
+[case testNewRedefineCannotWidenImportedVariable]
+# flags: --allow-redefinition-new --local-partial-types
+import a
+import b
+reveal_type(a.x) # N: Revealed type is "builtins.str"
+
+[file a.py]
+from b import x
+if int():
+    x = None  # E: Incompatible types in assignment (expression has type "None", variable has type "str")
+
+[file b.py]
+x = "a"
+
+[case testNewRedefineCannotWidenGlobalOrClassVariableWithMemberRef]
+# flags: --allow-redefinition-new --local-partial-types
+from typing import ClassVar
+import a
+
+a.x = None # E: Incompatible types in assignment (expression has type "None", variable has type "str")
+reveal_type(a.x) # N: Revealed type is "builtins.str"
+
+class C:
+    x = ""
+    y: ClassVar[str] = ""
+
+C.x = None # E: Incompatible types in assignment (expression has type "None", variable has type "str")
+reveal_type(C.x) # N: Revealed type is "builtins.str"
+C.y = None # E: Incompatible types in assignment (expression has type "None", variable has type "str")
+reveal_type(C.y) # N: Revealed type is "builtins.str"
+
+[file a.py]
+x = "a"
+
+[case testNewRedefineWidenGlobalInInitModule]
+# flags: --allow-redefinition-new --local-partial-types
+import pkg
+
+[file pkg/__init__.py]
+x = 0
+if int():
+    x = ""
+reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
diff --git a/test-data/unit/check-selftype.test b/test-data/unit/check-selftype.test
index 53c24584cb73..ffa1a369e883 100644
--- a/test-data/unit/check-selftype.test
+++ b/test-data/unit/check-selftype.test
@@ -160,12 +160,7 @@ class C(A[int]):
     def f(self) -> int: ...
 
 class D(A[str]):
-    def f(self) -> int: ...  # E: Signature of "f" incompatible with supertype "A" \
-                             # N:      Superclass:            \
-                             # N:          @overload          \
-                             # N:          def f(self) -> str \
-                             # N:      Subclass:              \
-                             # N:          def f(self) -> int
+    def f(self) -> int: ...  # E: Return type "int" of "f" incompatible with return type "str" in supertype "A"
 
 class E(A[T]):
     def f(self) -> int: ...  # E: Signature of "f" incompatible with supertype "A" \
@@ -201,7 +196,6 @@ class I(A[int]):
 class J(A[int]):
     def f(self, arg) -> int: ...  # E: Signature of "f" incompatible with supertype "A" \
                                   # N:      Superclass:            \
-                                  # N:          @overload          \
                                   # N:          def f(self) -> int \
                                   # N:      Subclass:              \
                                   # N:          def f(self, arg: Any) -> int
@@ -224,12 +218,10 @@ class B(A[int]):
     def f(self, s: int) -> int: ...
 
 class C(A[None]):
-    def f(self, s: int) -> int: ...  # E: Signature of "f" incompatible with supertype "A" \
-                                     # N:      Superclass:            \
-                                     # N:          @overload          \
-                                     # N:          def f(self, s: None) -> None \
-                                     # N:      Subclass:              \
-                                     # N:          def f(self, s: int) -> int
+    def f(self, s: int) -> int: ...  # E: Return type "int" of "f" incompatible with return type "None" in supertype "A" \
+                                     # E: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "None" \
+                                     # N: This violates the Liskov substitution principle \
+                                     # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
 [builtins fixtures/tuple.pyi]
 
 [case testSelfTypeOverrideCompatibilityTypeVar]
@@ -509,6 +501,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:
@@ -732,8 +776,7 @@ reveal_type(x)  # N: Revealed type is "__main__.SubP[Any]"
 y: SubP[str] = SubP(use_str=True)
 
 [file lib.pyi]
-from typing import TypeVar, Generic, overload, Tuple
-from typing_extensions import Literal
+from typing import Literal, TypeVar, Generic, overload, Tuple
 
 T = TypeVar('T')
 class P(Generic[T]):
@@ -757,8 +800,7 @@ xx = PFallBack(t)  # E: Need type annotation for "xx"
 yy = PFallBackAny(t)  # OK
 
 [file lib.pyi]
-from typing import TypeVar, Generic, overload, Tuple, Any
-from typing_extensions import Literal
+from typing import Literal, TypeVar, Generic, overload, Tuple, Any
 
 class PFallBack(Generic[T]):
     @overload
@@ -806,8 +848,7 @@ BadSub().get_item()  # E: Invalid self argument "BadSub" to attribute function "
 [builtins fixtures/list.pyi]
 
 [case testMixinAllowedWithProtocol]
-from typing import TypeVar
-from typing_extensions import Protocol
+from typing import Protocol, TypeVar
 
 class Resource(Protocol):
     def close(self) -> int: ...
@@ -845,7 +886,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: ...
@@ -857,8 +899,7 @@ class Bad:
 class CC(TweakFunc, Bad): pass  # E: Definition of "func" in base class "TweakFunc" is incompatible with definition in base class "Bad"
 
 [case testBadClassLevelDecoratorHack]
-from typing_extensions import Protocol
-from typing import TypeVar, Any
+from typing import Protocol, TypeVar, Any
 
 class FuncLike(Protocol):
     __call__: Any
@@ -1217,14 +1258,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]
 
@@ -1431,7 +1472,7 @@ class C:
             return self
 class D(C): ...
 
-reveal_type(C.meth)  # N: Revealed type is "def [Self <: __main__.C] (self: Self`0) -> builtins.list[Self`0]"
+reveal_type(C.meth)  # N: Revealed type is "def [Self <: __main__.C] (self: Self`1) -> builtins.list[Self`1]"
 C.attr  # E: Access to generic instance variables via class is ambiguous
 reveal_type(D().meth())  # N: Revealed type is "builtins.list[__main__.D]"
 reveal_type(D().attr)  # N: Revealed type is "builtins.list[__main__.D]"
@@ -1467,7 +1508,7 @@ from typing import Self, TypeVar, Tuple
 T = TypeVar("T")
 class C:
     def meth(self: T) -> Tuple[Self, T]: ...  # E: Method cannot have explicit self annotation and Self type
-reveal_type(C().meth())  # N: Revealed type is "Tuple[<nothing>, __main__.C]"
+reveal_type(C().meth())  # N: Revealed type is "Tuple[Never, __main__.C]"
 [builtins fixtures/property.pyi]
 
 [case testTypingSelfProperty]
@@ -1505,7 +1546,7 @@ class C:
 
 class D(C): ...
 reveal_type(D.meth())  # N: Revealed type is "__main__.D"
-reveal_type(D.bad())  # N: Revealed type is "<nothing>"
+reveal_type(D.bad())  # N: Revealed type is "Never"
 [builtins fixtures/classmethod.pyi]
 
 [case testTypingSelfOverload]
@@ -1665,6 +1706,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 +1741,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
 
@@ -1704,7 +1781,7 @@ class C:
     def bar(self) -> Self: ...
     def foo(self, x: S) -> Tuple[Self, S]: ...
 
-reveal_type(C.foo)  # N: Revealed type is "def [Self <: __main__.C, S] (self: Self`0, x: S`-1) -> Tuple[Self`0, S`-1]"
+reveal_type(C.foo)  # N: Revealed type is "def [Self <: __main__.C, S] (self: Self`1, x: S`2) -> Tuple[Self`1, S`2]"
 reveal_type(C().foo(42))  # N: Revealed type is "Tuple[__main__.C, builtins.int]"
 [builtins fixtures/tuple.pyi]
 
@@ -1718,7 +1795,7 @@ class C:
     def bar(self) -> Self: ...
     foo: Callable[[S, Self], Tuple[Self, S]]
 
-reveal_type(C().foo)  # N: Revealed type is "def [S] (S`1, __main__.C) -> Tuple[__main__.C, S`1]"
+reveal_type(C().foo)  # N: Revealed type is "def [S] (S`2, __main__.C) -> Tuple[__main__.C, S`2]"
 reveal_type(C().foo(42, C()))  # N: Revealed type is "Tuple[__main__.C, builtins.int]"
 class This: ...
 [builtins fixtures/tuple.pyi]
@@ -1814,7 +1891,7 @@ class C:
 
 class D(C): ...
 
-reveal_type(D.f)  # N: Revealed type is "def [T] (T`-1) -> T`-1"
+reveal_type(D.f)  # N: Revealed type is "def [T] (T`3) -> T`3"
 reveal_type(D().f)  # N: Revealed type is "def () -> __main__.D"
 
 [case testTypingSelfOnSuperTypeVarValues]
@@ -1867,3 +1944,280 @@ 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]
+
+[case testSelfTypesWithParamSpecExtract]
+from typing import Any, Callable, Generic, TypeVar
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+F = TypeVar("F", bound=Callable[..., Any])
+class Example(Generic[F]):
+    def __init__(self, fn: F) -> None:
+        ...
+    def __call__(self: Example[Callable[P, Any]], *args: P.args, **kwargs: P.kwargs) -> None:
+        ...
+
+def test_fn(a: int, b: str) -> None:
+    ...
+
+example = Example(test_fn)
+example()  # E: Missing positional arguments "a", "b" in call to "__call__" of "Example"
+example(1, "b")  # OK
+[builtins fixtures/list.pyi]
+
+[case testSelfTypesWithParamSpecInfer]
+from typing import TypeVar, Protocol, Type, Callable
+from typing_extensions import ParamSpec
+
+R = TypeVar("R", covariant=True)
+P = ParamSpec("P")
+class AsyncP(Protocol[P]):
+    def meth(self, *args: P.args, **kwargs: P.kwargs) -> None:
+        ...
+
+class Async:
+    @classmethod
+    def async_func(cls: Type[AsyncP[P]]) -> Callable[P, int]:
+        ...
+
+class Add(Async):
+    def meth(self, x: int, y: int) -> None: ...
+
+reveal_type(Add.async_func())  # N: Revealed type is "def (x: builtins.int, y: builtins.int) -> builtins.int"
+reveal_type(Add().async_func())  # N: Revealed type is "def (x: builtins.int, y: builtins.int) -> builtins.int"
+[builtins fixtures/classmethod.pyi]
+
+[case testSelfTypeMethodOnClassObject]
+from typing import Self
+
+class Object:  # Needed to mimic object in typeshed
+    ref: Self
+
+class Foo:
+    def foo(self) -> Self:
+        return self
+
+class Ben(Object):
+    MY_MAP = {
+        "foo": Foo.foo,
+    }
+    @classmethod
+    def doit(cls) -> Foo:
+        reveal_type(cls.MY_MAP)  # N: Revealed type is "builtins.dict[builtins.str, def [Self <: __main__.Foo] (self: Self`4) -> Self`4]"
+        foo_method = cls.MY_MAP["foo"]
+        return foo_method(Foo())
+[builtins fixtures/isinstancelist.pyi]
+
+[case testSelfTypeOnGenericClassObjectNewStyleBound]
+from typing import Generic, TypeVar, Self
+
+T = TypeVar("T")
+S = TypeVar("S")
+class B(Generic[T, S]):
+    def copy(self) -> Self: ...
+
+b: B[int, str]
+reveal_type(B.copy(b))  # N: Revealed type is "__main__.B[builtins.int, builtins.str]"
+
+class C(B[T, S]): ...
+
+c: C[int, str]
+reveal_type(C.copy(c))  # N: Revealed type is "__main__.C[builtins.int, builtins.str]"
+
+B.copy(42)  # E: Value of type variable "Self" of "copy" of "B" cannot be "int"
+C.copy(42)  # E: Value of type variable "Self" of "copy" of "B" cannot be "int"
+[builtins fixtures/tuple.pyi]
+
+[case testRecursiveSelfTypeCallMethodNoCrash]
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+class Partial:
+    def __call__(self: Callable[..., T]) -> T: ...
+
+class Partial2:
+    def __call__(self: Callable[..., T], x: T) -> T: ...
+
+p: Partial
+reveal_type(p())  # N: Revealed type is "Never"
+p2: Partial2
+reveal_type(p2(42))  # N: Revealed type is "builtins.int"
+
+[case testAccessingSelfClassVarInClassMethod]
+from typing import Self, ClassVar, Type, TypeVar
+
+T = TypeVar("T", bound="Foo")
+
+class Foo:
+    instance: ClassVar[Self]
+    @classmethod
+    def get_instance(cls) -> Self:
+        return reveal_type(cls.instance)  # N: Revealed type is "Self`0"
+    @classmethod
+    def get_instance_old(cls: Type[T]) -> T:
+        return reveal_type(cls.instance)  # N: Revealed type is "T`-1"
+
+class Bar(Foo):
+    extra: int
+
+    @classmethod
+    def get_instance(cls) -> Self:
+        reveal_type(cls.instance.extra)  # N: Revealed type is "builtins.int"
+        return cls.instance
+
+    @classmethod
+    def other(cls) -> None:
+        reveal_type(cls.instance)  # N: Revealed type is "Self`0"
+        reveal_type(cls.instance.extra)  # N: Revealed type is "builtins.int"
+
+reveal_type(Bar.instance)  # N: Revealed type is "__main__.Bar"
+[builtins fixtures/classmethod.pyi]
+
+[case testAccessingSelfClassVarInClassMethodTuple]
+from typing import Self, ClassVar, Tuple
+
+class C(Tuple[int, str]):
+    x: Self
+    y: ClassVar[Self]
+
+    @classmethod
+    def bar(cls) -> None:
+        reveal_type(cls.y)  # N: Revealed type is "Self`0"
+    @classmethod
+    def bar_self(self) -> Self:
+        return reveal_type(self.y)  # N: Revealed type is "Self`0"
+
+c: C
+reveal_type(c.x)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.C]"
+reveal_type(c.y)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.C]"
+reveal_type(C.y)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.C]"
+C.x  # E: Access to generic instance variables via class is ambiguous
+[builtins fixtures/classmethod.pyi]
+
+[case testAccessingTypingSelfUnion]
+from typing import Self, Union
+
+class C:
+    x: Self
+class D:
+    x: int
+x: Union[C, D]
+reveal_type(x.x)  # N: Revealed type is "Union[__main__.C, builtins.int]"
+
+[case testCallableProtocolTypingSelf]
+from typing import Protocol, Self
+
+class MyProtocol(Protocol):
+    __name__: str
+
+    def __call__(
+        self: Self,
+    ) -> None: ...
+
+def test() -> None: ...
+value: MyProtocol = test
+
+[case testCallableProtocolOldSelf]
+from typing import Protocol, TypeVar
+
+Self = TypeVar("Self", bound="MyProtocol")
+
+class MyProtocol(Protocol):
+    __name__: str
+
+    def __call__(
+        self: Self,
+    ) -> None: ...
+
+def test() -> None: ...
+value: MyProtocol = test
+
+[case testSelfTypeUnionIter]
+from typing import Self, Iterator, Generic, TypeVar, Union
+
+T = TypeVar("T")
+
+class range(Generic[T]):
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> T: ...
+
+class count:
+    def __iter__(self) -> Iterator[int]: ...
+
+def foo(x: Union[range[int], count]) -> None:
+    for item in x:
+        reveal_type(item)  # N: Revealed type is "builtins.int"
+
+[case testGenericDescriptorWithSelfTypeAnnotationsAndOverloads]
+from __future__ import annotations
+from typing import Any, overload, Callable, TypeVar, Generic, ParamSpec
+from typing_extensions import Concatenate
+
+C = TypeVar("C", bound=Callable[..., Any])
+S = TypeVar("S")
+P = ParamSpec("P")
+R = TypeVar("R")
+
+class Descriptor(Generic[C]):
+    def __init__(self, impl: C) -> None: ...
+
+    @overload
+    def __get__(
+        self: Descriptor[C], instance: None, owner: type | None
+    ) -> Descriptor[C]: ...
+
+    @overload
+    def __get__(
+        self: Descriptor[Callable[Concatenate[S, P], R]], instance: S, owner: type | None,
+    ) -> Callable[P, R]: ...
+
+    def __get__(self, *args, **kwargs): ...
+
+class Test:
+    @Descriptor
+    def method(self, foo: int, bar: str) -> bytes: ...
+
+reveal_type(Test().method) # N: Revealed type is "def (foo: builtins.int, bar: builtins.str) -> builtins.bytes"
+
+class Test2:
+    @Descriptor
+    def method(self, foo: int, *, bar: str) -> bytes: ...
+
+reveal_type(Test2().method) # N: Revealed type is "def (foo: builtins.int, *, bar: builtins.str) -> builtins.bytes"
+[builtins fixtures/tuple.pyi]
+
+[case testSelfInMultipleInheritance]
+from typing_extensions import Self
+
+class A:
+    foo: int
+    def method(self: Self, other: Self) -> None:
+        self.foo
+        other.foo
+
+class B:
+    bar: str
+    def method(self: Self, other: Self) -> None:
+        self.bar
+        other.bar
+
+class C(A, B):  # OK: both methods take Self
+    pass
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-semanal-error.test b/test-data/unit/check-semanal-error.test
index c6cf45d96691..52abbf09f1e5 100644
--- a/test-data/unit/check-semanal-error.test
+++ b/test-data/unit/check-semanal-error.test
@@ -137,8 +137,7 @@ def f() -> None: ...  # E: Name "f" already defined (possibly by an import)
 [out]
 
 [case testRuntimeProtoTwoBases]
-from typing_extensions import Protocol, runtime_checkable
-from typing import TypeVar, Generic
+from typing import TypeVar, Generic, Protocol, runtime_checkable
 
 T = TypeVar('T')
 
@@ -151,4 +150,34 @@ class C:
 
 x: P[int] = C()
 [builtins fixtures/tuple.pyi]
-[out]
+[typing fixtures/typing-full.pyi]
+
+[case testSemanalDoesNotLeakSyntheticTypes]
+# flags: --cache-fine-grained
+from typing import Generic, NamedTuple, TypedDict, TypeVar
+from dataclasses import dataclass
+
+T = TypeVar('T')
+class Wrap(Generic[T]): pass
+
+invalid_1: 1 + 2        # E: Invalid type comment or annotation
+invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+class A:
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+class B(NamedTuple):
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+class C(TypedDict):
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+
+@dataclass
+class D:
+    invalid_1: 1 + 2        # E: Invalid type comment or annotation
+    invalid_2: Wrap[1 + 2]  # E: Invalid type comment or annotation
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
diff --git a/test-data/unit/check-serialize.test b/test-data/unit/check-serialize.test
index 66d5d879ae68..042a962be9b3 100644
--- a/test-data/unit/check-serialize.test
+++ b/test-data/unit/check-serialize.test
@@ -740,7 +740,6 @@ main:4: note: Revealed type is "def (x: builtins.int) -> Tuple[builtins.int, fal
 --
 
 [case testSerializeOptionalType]
-# flags: --strict-optional
 import a
 [file a.py]
 import b
@@ -1055,7 +1054,7 @@ reveal_type(C().a)
 reveal_type(C().b)
 reveal_type(C().c)
 [file ntcrash.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class C:
     def __init__(self) -> None:
         A = TypedDict('A', {'x': int})
@@ -1063,6 +1062,7 @@ class C:
         self.b = A(x=0)  # type: A
         self.c = A
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out1]
 main:2: note: Revealed type is "TypedDict('ntcrash.C.A@4', {'x': builtins.int})"
 main:3: note: Revealed type is "TypedDict('ntcrash.C.A@4', {'x': builtins.int})"
@@ -1076,10 +1076,11 @@ main:4: note: Revealed type is "def (*, x: builtins.int) -> TypedDict('ntcrash.C
 from m import d
 reveal_type(d)
 [file m.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int, 'y': str}, total=False)
 d: D
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out1]
 main:2: note: Revealed type is "TypedDict('m.D', {'x'?: builtins.int, 'y'?: builtins.str})"
 [out2]
@@ -1275,6 +1276,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-singledispatch.test b/test-data/unit/check-singledispatch.test
index 1bc34c6fdaab..e63d4c073e86 100644
--- a/test-data/unit/check-singledispatch.test
+++ b/test-data/unit/check-singledispatch.test
@@ -80,20 +80,6 @@ def g(arg: int) -> None: # E: Argument to register "str" is incompatible with ty
 
 [builtins fixtures/args.pyi]
 
-[case testDispatchBasedOnTypeAnnotationsRequires37-xfail]
-# flags: --python-version 3.6
-# the docs for singledispatch say that register didn't accept type annotations until python 3.7
-from functools import singledispatch
-
-@singledispatch
-def f(arg) -> None:
-    pass
-@f.register
-def g(arg: int) -> None: # E: Singledispatch based on type annotations is only supported in Python 3.7 and greater
-    pass
-
-[builtins fixtures/args.pyi]
-
 [case testTypePassedAsArgumentToRegister]
 from functools import singledispatch
 
@@ -314,7 +300,7 @@ h('a', 1) # E: Argument 2 to "h" has incompatible type "int"; expected "str"
 
 [case testDontCrashWhenRegisteringAfterError]
 import functools
-a = functools.singledispatch('a') # E: Need type annotation for "a" # E: Argument 1 to "singledispatch" has incompatible type "str"; expected "Callable[..., <nothing>]"
+a = functools.singledispatch('a') # E: Need type annotation for "a" # E: Argument 1 to "singledispatch" has incompatible type "str"; expected "Callable[..., Never]"
 
 @a.register(int)
 def default(val) -> int:
diff --git a/test-data/unit/check-statements.test b/test-data/unit/check-statements.test
index 3cb8864f9207..9f77100863be 100644
--- a/test-data/unit/check-statements.test
+++ b/test-data/unit/check-statements.test
@@ -85,7 +85,7 @@ def f() -> Generator[int, None, None]:
 from typing import Iterator
 def f() -> Iterator[int]:
     yield 1
-    return "foo"
+    return "foo" # E: No return value expected
 [out]
 
 
@@ -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
@@ -405,11 +409,16 @@ main:5: error: Exception must be derived from BaseException
 class A: pass
 class MyError(BaseException): pass
 def f(): pass
-raise BaseException
-raise MyError
-raise A # E: Exception must be derived from BaseException
-raise object # E: Exception must be derived from BaseException
-raise f # E: Exception must be derived from BaseException
+if object():
+    raise BaseException
+if object():
+    raise MyError
+if object():
+    raise A # E: Exception must be derived from BaseException
+if object():
+    raise object # E: Exception must be derived from BaseException
+if object():
+    raise f # E: Exception must be derived from BaseException
 [builtins fixtures/exception.pyi]
 
 [case testRaiseClassObjectCustomInit]
@@ -425,23 +434,35 @@ class MyKwError(Exception):
 class MyErrorWithDefault(Exception):
     def __init__(self, optional=1) -> None:
         ...
-raise BaseException
-raise Exception
-raise BaseException(1)
-raise Exception(2)
-raise MyBaseError(4)
-raise MyError(5, 6)
-raise MyKwError(kwonly=7)
-raise MyErrorWithDefault(8)
-raise MyErrorWithDefault
-raise MyBaseError  # E: Too few arguments for "MyBaseError"
-raise MyError  # E: Too few arguments for "MyError"
-raise MyKwError  # E: Missing named argument "kwonly" for "MyKwError"
+if object():
+    raise BaseException
+if object():
+    raise Exception
+if object():
+    raise BaseException(1)
+if object():
+    raise Exception(2)
+if object():
+    raise MyBaseError(4)
+if object():
+    raise MyError(5, 6)
+if object():
+    raise MyKwError(kwonly=7)
+if object():
+    raise MyErrorWithDefault(8)
+if object():
+    raise MyErrorWithDefault
+if object():
+    raise MyBaseError  # E: Too few arguments for "MyBaseError"
+if object():
+    raise MyError  # E: Too few arguments for "MyError"
+if object():
+    raise MyKwError  # E: Missing named argument "kwonly" for "MyKwError"
 [builtins fixtures/exception.pyi]
 
 [case testRaiseExceptionType]
 import typing
-x = None # type: typing.Type[BaseException]
+x: typing.Type[BaseException]
 raise x
 [builtins fixtures/exception.pyi]
 
@@ -453,26 +474,30 @@ 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
-raise e from f
-raise e from x # E: Trying to read deleted variable "x"
+if object():
+    raise e from a # E: Exception must be derived from BaseException
+if object():
+    raise e from e
+if object():
+    raise e from f
+if object():
+    raise e from x # E: Trying to read deleted variable "x"
 class A: pass
 class MyError(BaseException): pass
 [builtins fixtures/exception.pyi]
@@ -482,13 +507,25 @@ import typing
 class A: pass
 class MyError(BaseException): pass
 def f(): pass
-raise BaseException from BaseException
-raise BaseException from MyError
-raise BaseException from A # E: Exception must be derived from BaseException
-raise BaseException from object # E: Exception must be derived from BaseException
-raise BaseException from f # E: Exception must be derived from BaseException
+if object():
+    raise BaseException from BaseException
+if object():
+    raise BaseException from MyError
+if object():
+    raise BaseException from A # E: Exception must be derived from BaseException
+if object():
+    raise BaseException from object # E: Exception must be derived from BaseException
+if object():
+    raise BaseException from f # E: Exception must be derived from BaseException
 [builtins fixtures/exception.pyi]
 
+[case testRaiseNotImplementedFails]
+if object():
+    raise NotImplemented    # E: Exception must be derived from BaseException; did you mean "NotImplementedError"?
+if object():
+    raise NotImplemented()  # E: NotImplemented? not callable
+[builtins fixtures/notimplemented.pyi]
+
 [case testTryFinallyStatement]
 import typing
 try:
@@ -505,27 +542,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 +1082,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__"
@@ -1305,7 +1346,7 @@ from typing import Generator
 def g() -> Generator[int, None, None]:
     yield from ()
     yield from (0, 1, 2)
-    yield from (0, "ERROR")  # E: Incompatible types in "yield from" (actual type "object", expected type "int")
+    yield from (0, "ERROR")  # E: Incompatible types in "yield from" (actual type "Union[int, str]", expected type "int")
     yield from ("ERROR",)  # E: Incompatible types in "yield from" (actual type "str", expected type "int")
 [builtins fixtures/tuple.pyi]
 
@@ -1486,13 +1527,13 @@ from typing import Optional
 
 class InvalidReturn1:
     def __exit__(self, x, y, z) -> bool:  # E: "bool" is invalid as return type for "__exit__" that always returns False \
-# N: Use "typing_extensions.Literal[False]" as the return type or change it to "None" \
+# N: Use "typing.Literal[False]" as the return type or change it to "None" \
 # N: If return type of "__exit__" implies that it may return True, the context manager may swallow exceptions
         return False
 
 class InvalidReturn2:
     def __exit__(self, x, y, z) -> Optional[bool]:  # E: "bool" is invalid as return type for "__exit__" that always returns False \
-# N: Use "typing_extensions.Literal[False]" as the return type or change it to "None" \
+# N: Use "typing.Literal[False]" as the return type or change it to "None" \
 # N: If return type of "__exit__" implies that it may return True, the context manager may swallow exceptions
         if int():
             return False
@@ -1501,7 +1542,7 @@ class InvalidReturn2:
 
 class InvalidReturn3:
     def __exit__(self, x, y, z) -> bool:  # E: "bool" is invalid as return type for "__exit__" that always returns False \
-# N: Use "typing_extensions.Literal[False]" as the return type or change it to "None" \
+# N: Use "typing.Literal[False]" as the return type or change it to "None" \
 # N: If return type of "__exit__" implies that it may return True, the context manager may swallow exceptions
         def nested() -> bool:
             return True
@@ -1509,7 +1550,7 @@ class InvalidReturn3:
 [builtins fixtures/bool.pyi]
 
 [case testWithStmtBoolExitReturnOkay]
-from typing_extensions import Literal
+from typing import Literal
 
 class GoodReturn1:
     def __exit__(self, x, y, z) -> bool:
@@ -1965,6 +2006,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 +2024,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():
@@ -2139,8 +2182,7 @@ class M(N): pass
 [out]
 
 [case testForwardRefsInWithStatementImplicit]
-from typing import ContextManager, Any
-from mypy_extensions import TypedDict
+from typing import ContextManager, Any, TypedDict
 cm: ContextManager[N]
 
 with cm as g:
@@ -2148,12 +2190,11 @@ with cm as g:
 
 N = TypedDict('N', {'x': int})
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-medium.pyi]
+[typing fixtures/typing-full.pyi]
 [out]
 
 [case testForwardRefsInWithStatement]
-from typing import ContextManager, Any
-from mypy_extensions import TypedDict
+from typing import ContextManager, Any, TypedDict
 cm: ContextManager[Any]
 
 with cm as g:  # type: N
@@ -2161,7 +2202,7 @@ with cm as g:  # type: N
 
 N = TypedDict('N', {'x': int})
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-medium.pyi]
+[typing fixtures/typing-full.pyi]
 [out]
 
 [case testGlobalWithoutInitialization]
@@ -2195,8 +2236,67 @@ class B: pass
 def foo(x: int) -> Union[Generator[A, None, None], Generator[B, None, None]]:
     yield x  # E: Incompatible types in "yield" (actual type "int", expected type "Union[A, B]")
 
+[case testYieldFromUnionOfGenerators]
+from typing import Generator, Union
+
+class T: pass
+
+def foo(arg: Union[Generator[int, None, T], Generator[str, None, T]]) -> Generator[Union[int, str], None, T]:
+    return (yield from arg)
+
+[case testYieldFromInvalidUnionReturn]
+from typing import Generator, Union
+
+class A: pass
+class B: pass
+
+def foo(arg: Union[A, B]) -> Generator[Union[int, str], None, A]:
+    return (yield from arg) # E: "yield from" can't be applied to "Union[A, B]"
+
+[case testYieldFromUnionOfGeneratorWithIterableStr]
+from typing import Generator, Union, Iterable, Optional
+
+def foo(arg: Union[Generator[int, None, bytes], Iterable[str]]) -> Generator[Union[int, str], None, Optional[bytes]]:
+    return (yield from arg)
+
+def bar(arg: Generator[str, None, str]) -> Generator[str, None, str]:
+    return foo(arg)  # E: Incompatible return value type (got "Generator[Union[int, str], None, Optional[bytes]]", expected "Generator[str, None, str]")
+
+def launder(arg: Iterable[str]) -> Generator[Union[int, str], None, Optional[bytes]]:
+    return foo(arg)
+
+def baz(arg: Generator[str, None, str]) -> Generator[Union[int, str], None, Optional[bytes]]:
+    # this is unsound, the Generator return type will actually be str
+    return launder(arg)
+[builtins fixtures/tuple.pyi]
+
+[case testYieldIteratorReturn]
+from typing import Iterator
+
+def get_strings(foo: bool) -> Iterator[str]:
+    if foo:
+        return ["foo1", "foo2"]  # E: No return value expected
+    else:
+        yield "bar1"
+        yield "bar2"
+[builtins fixtures/tuple.pyi]
+
+[case testYieldFromInvalidType]
+from collections.abc import Iterator
+
+class A:
+    def list(self) -> None: ...
+
+    def foo(self) -> list[int]:  # E: Function "__main__.A.list" is not valid as a type \
+                                 # N: Perhaps you need "Callable[...]" or a callback protocol?
+        return []
+
+def fn() -> Iterator[int]:
+    yield from A().foo()  # E: "list?[builtins.int]" has no attribute "__iter__" (not iterable)
+[builtins fixtures/tuple.pyi]
+
 [case testNoCrashOnStarRightHandSide]
-x = *(1, 2, 3)  # E: Can use starred expression only as assignment target
+x = *(1, 2, 3)  # E: can't use starred expression here
 [builtins fixtures/tuple.pyi]
 
 
@@ -2212,3 +2312,52 @@ 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]
+
+[case testCallableInstanceOverlapAllowed]
+# flags: --warn-unreachable
+from typing import Any, Callable, List
+
+class CAny:
+    def __call__(self) -> Any: ...
+class CNone:
+    def __call__(self) -> None: ...
+class CWrong:
+    def __call__(self, x: int) -> None: ...
+
+def describe(func: Callable[[], None]) -> str:
+    if isinstance(func, CAny):
+        return "CAny"
+    elif isinstance(func, CNone):
+        return "CNone"
+    elif isinstance(func, CWrong):
+        return "CWrong"  # E: Statement is unreachable
+    else:
+        return "other"
+
+class C(CAny):
+    def __call__(self) -> None: ...
+
+def f():
+    pass
+
+describe(CAny())
+describe(C())
+describe(CNone())
+describe(CWrong())  # E: Argument 1 to "describe" has incompatible type "CWrong"; expected "Callable[[], None]" \
+                    # N: "CWrong.__call__" has type "Callable[[Arg(int, 'x')], None]"
+describe(f)
+[builtins fixtures/isinstancelist.pyi]
diff --git a/test-data/unit/check-super.test b/test-data/unit/check-super.test
index b3379e505be7..8816322a270a 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')
@@ -277,8 +280,12 @@ class B(A):
 
 
 [case testSuperOutsideMethodNoCrash]
-class C:
-    a = super().whatever  # E: super() outside of a method is not supported
+class A:
+    x = 1
+class B(A): pass
+class C(B):
+    b = super(B, B).x
+    a = super().whatever  # E: "super()" outside of a method is not supported
 
 [case testSuperWithObjectClassAsFirstArgument]
 class A:
@@ -363,13 +370,22 @@ class C(B):
 [case testSuperInMethodWithNoArguments]
 class A:
     def f(self) -> None: pass
+    @staticmethod
+    def st() -> int:
+        return 1
 
 class B(A):
     def g() -> None: # E: Method must have at least one argument. Did you forget the "self" argument?
-        super().f() # E: super() requires one or more positional arguments in enclosing function
+        super().f() # E: "super()" requires one or two positional arguments in enclosing function
     def h(self) -> None:
         def a() -> None:
-            super().f() # E: super() requires one or more positional arguments in enclosing function
+            super().f() # E: "super()" requires one or two positional arguments in enclosing function
+    @staticmethod
+    def st() -> int:
+        reveal_type(super(B, B).st())  # N: Revealed type is "builtins.int"
+        super().st() # E: "super()" requires one or two positional arguments in enclosing function
+        return 2
+[builtins fixtures/staticmethod.pyi]
 
 [case testSuperWithUnsupportedTypeObject]
 from typing import Type
diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test
index e843532a2560..3424d053fe42 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]]")
@@ -106,20 +107,149 @@ class A: pass
 class B(A): pass
 [builtins fixtures/tuple.pyi]
 
-[case testSubtypingWithNamedTupleType]
-from typing import Tuple
-t1 = None # type: Tuple[A, A]
-t2 = None # type: tuple
-
-if int():
-    t1 = t2 # E: Incompatible types in assignment (expression has type "Tuple[Any, ...]", variable has type "Tuple[A, A]")
-if int():
-    t2 = t1
+[case testSubtypingWithTupleType]
+from __future__ import annotations
+from typing import Any, Tuple
+
+tuple_aa: tuple[A, A]
+Tuple_aa: Tuple[A, A]
+
+tuple_obj: tuple[object, ...]
+Tuple_obj: Tuple[object, ...]
+
+tuple_obj_one: tuple[object]
+Tuple_obj_one: Tuple[object]
+
+tuple_obj_two: tuple[object, object]
+Tuple_obj_two: Tuple[object, object]
+
+tuple_any_implicit: tuple
+Tuple_any_implicit: Tuple
+
+tuple_any: tuple[Any, ...]
+Tuple_any: Tuple[Any, ...]
+
+tuple_any_one: tuple[Any]
+Tuple_any_one: Tuple[Any]
+
+tuple_any_two: tuple[Any, Any]
+Tuple_any_two: Tuple[Any, Any]
+
+def takes_tuple_aa(t: tuple[A, A]): ...
+
+takes_tuple_aa(tuple_aa)
+takes_tuple_aa(Tuple_aa)
+takes_tuple_aa(tuple_obj)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[object, ...]"; expected "Tuple[A, A]"
+takes_tuple_aa(Tuple_obj)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[object, ...]"; expected "Tuple[A, A]"
+takes_tuple_aa(tuple_obj_one)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[object]"; expected "Tuple[A, A]"
+takes_tuple_aa(Tuple_obj_one)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[object]"; expected "Tuple[A, A]"
+takes_tuple_aa(tuple_obj_two)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[object, object]"; expected "Tuple[A, A]"
+takes_tuple_aa(Tuple_obj_two)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[object, object]"; expected "Tuple[A, A]"
+takes_tuple_aa(tuple_any_implicit)
+takes_tuple_aa(Tuple_any_implicit)
+takes_tuple_aa(tuple_any)
+takes_tuple_aa(Tuple_any)
+takes_tuple_aa(tuple_any_one)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[Any]"; expected "Tuple[A, A]"
+takes_tuple_aa(Tuple_any_one)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "Tuple[Any]"; expected "Tuple[A, A]"
+takes_tuple_aa(tuple_any_two)
+takes_tuple_aa(Tuple_any_two)
+
+def takes_tuple_any_implicit(t: tuple): ...
+
+takes_tuple_any_implicit(tuple_aa)
+takes_tuple_any_implicit(Tuple_aa)
+takes_tuple_any_implicit(tuple_obj)
+takes_tuple_any_implicit(Tuple_obj)
+takes_tuple_any_implicit(tuple_obj_one)
+takes_tuple_any_implicit(Tuple_obj_one)
+takes_tuple_any_implicit(tuple_obj_two)
+takes_tuple_any_implicit(Tuple_obj_two)
+takes_tuple_any_implicit(tuple_any_implicit)
+takes_tuple_any_implicit(Tuple_any_implicit)
+takes_tuple_any_implicit(tuple_any)
+takes_tuple_any_implicit(Tuple_any)
+takes_tuple_any_implicit(tuple_any_one)
+takes_tuple_any_implicit(Tuple_any_one)
+takes_tuple_any_implicit(tuple_any_two)
+takes_tuple_any_implicit(Tuple_any_two)
+
+def takes_tuple_any_one(t: tuple[Any]): ...
+
+takes_tuple_any_one(tuple_aa)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[A, A]"; expected "Tuple[Any]"
+takes_tuple_any_one(Tuple_aa)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[A, A]"; expected "Tuple[Any]"
+takes_tuple_any_one(tuple_obj)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[object, ...]"; expected "Tuple[Any]"
+takes_tuple_any_one(Tuple_obj)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[object, ...]"; expected "Tuple[Any]"
+takes_tuple_any_one(tuple_obj_one)
+takes_tuple_any_one(Tuple_obj_one)
+takes_tuple_any_one(tuple_obj_two)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[object, object]"; expected "Tuple[Any]"
+takes_tuple_any_one(Tuple_obj_two)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[object, object]"; expected "Tuple[Any]"
+takes_tuple_any_one(tuple_any_implicit)
+takes_tuple_any_one(Tuple_any_implicit)
+takes_tuple_any_one(tuple_any)
+takes_tuple_any_one(Tuple_any)
+takes_tuple_any_one(tuple_any_one)
+takes_tuple_any_one(Tuple_any_one)
+takes_tuple_any_one(tuple_any_two)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[Any, Any]"; expected "Tuple[Any]"
+takes_tuple_any_one(Tuple_any_two)  # E: Argument 1 to "takes_tuple_any_one" has incompatible type "Tuple[Any, Any]"; expected "Tuple[Any]"
 
 class A: pass
 [builtins fixtures/tuple.pyi]
 
+[case testSubtypingWithTupleTypeSubclass]
+from __future__ import annotations
+from typing import Any, Tuple
+
+class A: ...
+
+inst_tuple_aa: Tuple[A, A]
+
+class tuple_aa_subclass(Tuple[A, A]): ...
+inst_tuple_aa_subclass: tuple_aa_subclass
+
+class tuple_any_subclass(Tuple[Any, ...]): ...
+inst_tuple_any_subclass: tuple_any_subclass
+
+class tuple_any_one_subclass(Tuple[Any]): ...
+inst_tuple_any_one_subclass: tuple_any_one_subclass
+
+class tuple_any_two_subclass(Tuple[Any, Any]): ...
+inst_tuple_any_two_subclass: tuple_any_two_subclass
+
+class tuple_obj_subclass(Tuple[object, ...]): ...
+inst_tuple_obj_subclass: tuple_obj_subclass
+
+class tuple_obj_one_subclass(Tuple[object]): ...
+inst_tuple_obj_one_subclass: tuple_obj_one_subclass
+
+class tuple_obj_two_subclass(Tuple[object, object]): ...
+inst_tuple_obj_two_subclass: tuple_obj_two_subclass
+
+def takes_tuple_aa(t: Tuple[A, A]): ...
+
+takes_tuple_aa(inst_tuple_aa)
+takes_tuple_aa(inst_tuple_aa_subclass)
+takes_tuple_aa(inst_tuple_any_subclass)
+takes_tuple_aa(inst_tuple_any_one_subclass)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "tuple_any_one_subclass"; expected "Tuple[A, A]"
+takes_tuple_aa(inst_tuple_any_two_subclass)
+takes_tuple_aa(inst_tuple_obj_subclass)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "tuple_obj_subclass"; expected "Tuple[A, A]"
+takes_tuple_aa(inst_tuple_obj_one_subclass)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "tuple_obj_one_subclass"; expected "Tuple[A, A]"
+takes_tuple_aa(inst_tuple_obj_two_subclass)  # E: Argument 1 to "takes_tuple_aa" has incompatible type "tuple_obj_two_subclass"; expected "Tuple[A, A]"
+
+def takes_tuple_aa_subclass(t: tuple_aa_subclass): ...
+
+takes_tuple_aa_subclass(inst_tuple_aa)  # E: Argument 1 to "takes_tuple_aa_subclass" has incompatible type "Tuple[A, A]"; expected "tuple_aa_subclass"
+takes_tuple_aa_subclass(inst_tuple_aa_subclass)
+takes_tuple_aa_subclass(inst_tuple_any_subclass)  # E: Argument 1 to "takes_tuple_aa_subclass" has incompatible type "tuple_any_subclass"; expected "tuple_aa_subclass"
+takes_tuple_aa_subclass(inst_tuple_any_one_subclass)  # E: Argument 1 to "takes_tuple_aa_subclass" has incompatible type "tuple_any_one_subclass"; expected "tuple_aa_subclass"
+takes_tuple_aa_subclass(inst_tuple_any_two_subclass)  # E: Argument 1 to "takes_tuple_aa_subclass" has incompatible type "tuple_any_two_subclass"; expected "tuple_aa_subclass"
+takes_tuple_aa_subclass(inst_tuple_obj_subclass)  # E: Argument 1 to "takes_tuple_aa_subclass" has incompatible type "tuple_obj_subclass"; expected "tuple_aa_subclass"
+takes_tuple_aa_subclass(inst_tuple_obj_one_subclass)  # E: Argument 1 to "takes_tuple_aa_subclass" has incompatible type "tuple_obj_one_subclass"; expected "tuple_aa_subclass"
+takes_tuple_aa_subclass(inst_tuple_obj_two_subclass)  # E: Argument 1 to "takes_tuple_aa_subclass" has incompatible type "tuple_obj_two_subclass"; expected "tuple_aa_subclass"
+
+[builtins fixtures/tuple.pyi]
+
 [case testTupleInitializationWithNone]
+# flags: --no-strict-optional
 from typing import Tuple
 t = None # type: Tuple[A, A]
 t = None
@@ -132,6 +262,7 @@ class A: pass
 
 
 [case testTupleExpressions]
+# flags: --no-strict-optional
 from typing import Tuple
 t1 = None # type: tuple
 t2 = None # type: Tuple[A]
@@ -140,7 +271,7 @@ t3 = None # type: Tuple[A, B]
 a, b, c = None, None, None # type: (A, B, C)
 
 if int():
-    t2 = ()        # E: Incompatible types in assignment (expression has type "Tuple[]", variable has type "Tuple[A]")
+    t2 = ()        # E: Incompatible types in assignment (expression has type "Tuple[()]", variable has type "Tuple[A]")
 if int():
     t2 = (a, a)    # E: Incompatible types in assignment (expression has type "Tuple[A, A]", variable has type "Tuple[A]")
 if int():
@@ -166,8 +297,8 @@ class C(B): pass
 import typing
 def f() -> None: pass
 
-(None, f()) # E: "f" does not return a value
-(f(), None) # E: "f" does not return a value
+(None, f()) # E: "f" does not return a value (it only ever returns None)
+(f(), None) # E: "f" does not return a value (it only ever returns None)
 [builtins fixtures/tuple.pyi]
 
 
@@ -177,12 +308,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():
@@ -205,10 +337,12 @@ if int():
     b = t1[-1]
 if int():
     a = t1[(0)]
+if int():
+    b = t1[+1]
 if int():
     x = t3[0:3] # type (A, B, C)
 if int():
-    y = t3[0:5:2] # type (A, C, E)
+    y = t3[0:+5:2] # type (A, C, E)
 if int():
     x = t3[:-2] # type (A, B, C)
 
@@ -221,9 +355,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 +386,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 +400,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 +427,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 +459,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 +471,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 +491,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 +509,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 +525,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 +538,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 +559,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 +570,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 +598,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 +631,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 +643,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 +657,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 +683,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 +695,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 +715,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 +730,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 +742,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 +757,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 +798,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 +818,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 +862,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 +872,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 +888,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()
@@ -811,6 +959,12 @@ for x in B(), A():
 [builtins fixtures/for.pyi]
 
 [case testTupleIterable]
+from typing import Iterable, Optional, TypeVar
+
+T = TypeVar("T")
+
+def sum(iterable: Iterable[T], start: Optional[T] = None) -> T: pass
+
 y = 'a'
 x = sum((1,2))
 if int():
@@ -869,7 +1023,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 +1086,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]
@@ -957,6 +1111,13 @@ b = (0, *a)
 reveal_type(b)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 [builtins fixtures/tuple.pyi]
 
+[case testTupleWithStarExpr2Precise]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+a = [1]
+b = (0, *a)
+reveal_type(b)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]]]"
+[builtins fixtures/tuple.pyi]
+
 [case testTupleWithStarExpr3]
 a = ['']
 b = (0, *a)
@@ -965,6 +1126,15 @@ c = (*a, '')
 reveal_type(c)  # N: Revealed type is "builtins.tuple[builtins.str, ...]"
 [builtins fixtures/tuple.pyi]
 
+[case testTupleWithStarExpr3Precise]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+a = ['']
+b = (0, *a)
+reveal_type(b)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.str, ...]]]"
+c = (*a, '')
+reveal_type(c)  # N: Revealed type is "Tuple[Unpack[builtins.tuple[builtins.str, ...]], builtins.str]"
+[builtins fixtures/tuple.pyi]
+
 [case testTupleWithStarExpr4]
 a = (1, 1, 'x', 'x')
 b = (1, 'x')
@@ -972,7 +1142,7 @@ a = (0, *b, '')
 [builtins fixtures/tuple.pyi]
 
 [case testUnpackSyntaxError]
-*foo  # E: Can use starred expression only as assignment target
+*foo  # E: can't use starred expression here
 [builtins fixtures/tuple.pyi]
 
 [case testUnpackBases]
@@ -1046,8 +1216,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)
@@ -1058,68 +1228,76 @@ x, y = g(z) # E: Argument 1 to "g" has incompatible type "int"; expected "Tuple[
 [out]
 
 [case testFixedTupleJoinVarTuple]
-from typing import Tuple
+from typing import Tuple, TypeVar
 
 class A: pass
 class B(A): pass
 
-fixtup = None  # type: Tuple[B, B]
+fixtup: Tuple[B, B]
 
-vartup_b = None  # type: 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, ...]"
+T = TypeVar("T")
+def join(x: T, y: T) -> T: ...
 
-vartup_a = None  # type: 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, ...]"
+vartup_b: Tuple[B, ...]
+reveal_type(join(fixtup, vartup_b))  # N: Revealed type is "builtins.tuple[__main__.B, ...]"
+reveal_type(join(vartup_b, fixtup))  # N: Revealed type is "builtins.tuple[__main__.B, ...]"
 
+vartup_a: Tuple[A, ...]
+reveal_type(join(fixtup, vartup_a))  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
+reveal_type(join(vartup_a, fixtup))  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testFixedTupleJoinList]
-from typing import Tuple, List
+from typing import Tuple, List, TypeVar
 
 class A: pass
 class B(A): pass
 
-fixtup = None  # type: Tuple[B, B]
+fixtup: Tuple[B, B]
+
+T = TypeVar("T")
+def join(x: T, y: T) -> T: ...
 
-lst_b = None  # type: 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_b: List[B]
+reveal_type(join(fixtup, lst_b))  # N: Revealed type is "typing.Sequence[__main__.B]"
+reveal_type(join(lst_b, fixtup))  # N: Revealed type is "typing.Sequence[__main__.B]"
 
-lst_a = None  # type: 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]"
+lst_a: List[A]
+reveal_type(join(fixtup, lst_a))  # N: Revealed type is "typing.Sequence[__main__.A]"
+reveal_type(join(lst_a, fixtup))  # N: Revealed type is "typing.Sequence[__main__.A]"
 
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testEmptyTupleJoin]
-from typing import Tuple, List
+from typing import Tuple, List, TypeVar
 
 class A: pass
 
 empty = ()
 
-fixtup = None  # type: 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, ...]"
+T = TypeVar("T")
+def join(x: T, y: T) -> T: ...
 
-vartup = None  # type: 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, ...]"
+fixtup: Tuple[A]
+reveal_type(join(fixtup, empty))  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
+reveal_type(join(empty, fixtup))  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 
-lst = None  # type: 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]"
+vartup: Tuple[A, ...]
+reveal_type(join(vartup, empty))  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
+reveal_type(join(empty, vartup))  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
+
+lst: List[A]
+reveal_type(join(empty, lst))  # N: Revealed type is "typing.Sequence[__main__.A]"
+reveal_type(join(lst, empty))  # N: Revealed type is "typing.Sequence[__main__.A]"
 
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testTupleSubclassJoin]
-from typing import Tuple, NamedTuple
+from typing import Tuple, NamedTuple, TypeVar
 
 class NTup(NamedTuple):
     a: bool
@@ -1128,36 +1306,42 @@ 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
+
+T = TypeVar("T")
+def join(x: T, y: T) -> T: ...
 
-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, ...]"
+reveal_type(join(ntup, vartup))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join(subtup, vartup))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testTupleJoinIrregular]
-from typing import Tuple
+from typing import Tuple, TypeVar
 
-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, ...]"
+T = TypeVar("T")
+def join(x: T, y: T) -> T: ...
 
-reveal_type(tup1 if int() else ())  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
-reveal_type(() if int() else tup1)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join(tup1, tup2))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join(tup2, tup1))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 
-reveal_type(tup2 if int() else ())  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
-reveal_type(() if int() else tup2)  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
+reveal_type(join(tup1, ()))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join((), tup1))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+
+reveal_type(join(tup2, ()))  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
+reveal_type(join((), tup2))  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
 
 [builtins fixtures/tuple.pyi]
 [out]
 
 [case testTupleSubclassJoinIrregular]
-from typing import Tuple, NamedTuple
+from typing import Tuple, NamedTuple, TypeVar
 
 class NTup1(NamedTuple):
     a: bool
@@ -1168,18 +1352,21 @@ 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
+
+T = TypeVar("T")
+def join(x: T, y: T) -> T: ...
 
-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, ...]"
+reveal_type(join(tup1, tup2))  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
+reveal_type(join(tup2, tup1))  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
 
-reveal_type(tup1 if int() else subtup)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
-reveal_type(subtup if int() else tup1)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join(tup1, subtup))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join(subtup, tup1))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 
-reveal_type(tup2 if int() else subtup)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
-reveal_type(subtup if int() else tup2)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join(tup2, subtup))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(join(subtup, tup2))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 
 [builtins fixtures/tuple.pyi]
 [out]
@@ -1187,7 +1374,7 @@ reveal_type(subtup if int() else tup2)  # N: Revealed type is "builtins.tuple[bu
 [case testTupleWithUndersizedContext]
 a = ([1], 'x')
 if int():
-    a = ([], 'x', 1)  # E: Incompatible types in assignment (expression has type "Tuple[List[int], str, int]", variable has type "Tuple[List[int], str]")
+    a = ([], 'x', 1)  # E: Incompatible types in assignment (expression has type "Tuple[List[Never], str, int]", variable has type "Tuple[List[int], str]")
 [builtins fixtures/tuple.pyi]
 
 [case testTupleWithOversizedContext]
@@ -1226,9 +1413,9 @@ f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected "Tuple[Any, .
 from typing import Tuple
 def f(a: Tuple[()]) -> None: pass
 f(())
-f((1,))  # E: Argument 1 to "f" has incompatible type "Tuple[int]"; expected "Tuple[]"
-f(('', ''))  # E: Argument 1 to "f" has incompatible type "Tuple[str, str]"; expected "Tuple[]"
-f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected "Tuple[]"
+f((1,))  # E: Argument 1 to "f" has incompatible type "Tuple[int]"; expected "Tuple[()]"
+f(('', ''))  # E: Argument 1 to "f" has incompatible type "Tuple[str, str]"; expected "Tuple[()]"
+f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected "Tuple[()]"
 [builtins fixtures/tuple.pyi]
 
 [case testNonliteralTupleIndex]
@@ -1238,8 +1425,8 @@ y = ""
 reveal_type(t[x])  # N: Revealed type is "Union[builtins.int, builtins.str]"
 t[y]  # E: No overload variant of "__getitem__" of "tuple" matches argument type "str" \
       # N: Possible overload variants: \
-      # N:     def __getitem__(self, int, /) -> object \
-      # N:     def __getitem__(self, slice, /) -> Tuple[object, ...]
+      # N:     def __getitem__(self, int, /) -> Union[int, str] \
+      # N:     def __getitem__(self, slice, /) -> Tuple[Union[int, str], ...]
 
 [builtins fixtures/tuple.pyi]
 
@@ -1251,6 +1438,12 @@ reveal_type(t[x:])  # N: Revealed type is "builtins.tuple[Union[builtins.int, bu
 t[y:]  # E: Slice index must be an integer, SupportsIndex or None
 [builtins fixtures/tuple.pyi]
 
+[case testTupleSliceStepZeroNoCrash]
+# This was crashing: https://github.com/python/mypy/issues/18062
+# TODO: emit better error when 0 is used for step
+()[::0]  # E: Ambiguous slice of a variadic tuple
+[builtins fixtures/tuple.pyi]
+
 [case testInferTupleTypeFallbackAgainstInstance]
 from typing import TypeVar, Generic, Tuple
 T = TypeVar('T')
@@ -1288,7 +1481,21 @@ def foo(o: CallableTuple) -> int:
 class CallableTuple(Tuple[str, int]):
     def __call__(self, n: int, m: int) -> int:
         return n
+[builtins fixtures/tuple.pyi]
+
+[case testTypeTupleGenericCall]
+from typing import Generic, Tuple, TypeVar
+
+T = TypeVar('T')
+
+def foo(o: CallableTuple[int]) -> int:
+    reveal_type(o)  # N: Revealed type is "Tuple[builtins.str, builtins.int, fallback=__main__.CallableTuple[builtins.int]]"
+    reveal_type(o.count(3))  # N: Revealed type is "builtins.int"
+    return o(1, 2)
 
+class CallableTuple(Tuple[str, T]):
+    def __call__(self, n: int, m: int) -> int:
+        return n
 [builtins fixtures/tuple.pyi]
 
 [case testTupleCompatibleWithSequence]
@@ -1367,45 +1574,116 @@ 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]
 
+[case testPropertyLongTupleReturnTypeMismatchUnion]
+from typing import Tuple, Union
+class A:
+    a: str
+    b: str
+    c: str
+    d: str
+    e: str
+    f: str
+    g: Union[str, int]
+    h: Union[str, float]
+    i: Union[str, None]
+    j: Union[str, None]
+    k: Union[str, None]
+    l: Union[str, None]
+
+    @property
+    def x(self) -> Tuple[str, str, str, str, str, str, str, str, str, str, str, str]:
+        return (
+            self.a,
+            self.b,
+            self.c,
+            self.d,
+            self.e,
+            self.f,
+            self.g,
+            self.h,
+            self.i,
+            self.j,
+            self.k,
+            self.l,
+        )
+[out]
+main:18: error: Incompatible return value type (6 tuple items are incompatible; 3 items are omitted)
+main:18: note: Expression tuple item 6 has type "Union[str, int]"; "str" expected;
+main:18: note: Expression tuple item 7 has type "Union[str, float]"; "str" expected;
+main:18: note: Expression tuple item 8 has type "Optional[str]"; "str" expected;
+[builtins fixtures/property.pyi]
+
+[case testPropertyLongTupleReturnTypeMismatchUnionWiderExpected]
+from typing import Tuple, Union
+class A:
+    a: str
+    b: str
+    c: str
+    d: str
+    e: str
+    f: str
+    g: str
+    h: str
+    i: str
+    j: str
+    k: str
+    l: Union[float, int]
+
+    @property
+    def x(self) -> Tuple[Union[str, int], Union[str, float], int, Union[str, None], Union[str, None], Union[str, None], str, str, str, str, str, str]:
+        return (
+            self.a,
+            self.b,
+            self.c,
+            self.d,
+            self.e,
+            self.f,
+            self.g,
+            self.h,
+            self.i,
+            self.j,
+            self.k,
+            self.l,
+        )
+[out]
+main:18: error: Incompatible return value type (2 tuple items are incompatible)
+main:18: note: Expression tuple item 2 has type "str"; "int" expected;
+main:18: note: Expression tuple item 11 has type "Union[float, int]"; "str" expected;
+[builtins fixtures/property.pyi]
+
 [case testTupleWithStarExpr]
 from typing import Tuple, List
 points = (1, "test")  # type: Tuple[int, str]
@@ -1443,8 +1721,7 @@ x7, x8, y7, y8 = *points2, *points3 # E: Contiguous iterable with same type expe
 x9, y9, x10, y10, z5 = *points2, 1, *points2 # E: Contiguous iterable with same type expected
 [builtins fixtures/tuple.pyi]
 
-[case testAssignEmptyPy36]
-# flags: --python-version 3.6
+[case testAssignEmpty]
 () = []
 
 [case testAssignEmptyBogus]
@@ -1456,7 +1733,7 @@ from typing import Tuple
 t = ('',) * 2
 reveal_type(t)  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
 t2 = ('',) * -1
-reveal_type(t2)  # N: Revealed type is "Tuple[]"
+reveal_type(t2)  # N: Revealed type is "Tuple[()]"
 t3 = ('', 1) * 2
 reveal_type(t3)  # N: Revealed type is "Tuple[builtins.str, builtins.int, builtins.str, builtins.int]"
 def f() -> Tuple[str, ...]:
@@ -1464,12 +1741,21 @@ def f() -> Tuple[str, ...]:
 reveal_type(f() * 2)  # N: Revealed type is "builtins.tuple[builtins.str, ...]"
 [builtins fixtures/tuple.pyi]
 
+[case testEmptyTupleTypeRepr]
+from typing import Tuple
+
+def f() -> Tuple[()]: ...
+
+reveal_type(f)    # N: Revealed type is "def () -> Tuple[()]"
+reveal_type(f())  # N: Revealed type is "Tuple[()]"
+[builtins fixtures/tuple.pyi]
+
 [case testMultiplyTupleByIntegerLiteralReverse]
 from typing import Tuple
 t = 2 * ('',)
 reveal_type(t)  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
 t2 = -1 * ('',)
-reveal_type(t2)  # N: Revealed type is "Tuple[]"
+reveal_type(t2)  # N: Revealed type is "Tuple[()]"
 t3 = 2 * ('', 1)
 reveal_type(t3)  # N: Revealed type is "Tuple[builtins.str, builtins.int, builtins.str, builtins.int]"
 def f() -> Tuple[str, ...]:
@@ -1502,3 +1788,30 @@ class Bar(aaaaaaaaaa):  # E: Name "aaaaaaaaaa" is not defined
 class FooBarTuple(Tuple[Foo, Bar]):
     ...
 [builtins fixtures/tuple.pyi]
+
+
+[case testTupleOverloadZipAny]
+from typing import Any, Iterable, Iterator, Tuple, TypeVar, overload
+
+T = TypeVar("T")
+
+@overload
+def zip(__i: Iterable[T]) -> Iterator[Tuple[T]]: ...
+@overload
+def zip(*i: Iterable[Any]) -> Iterator[Tuple[Any, ...]]: ...
+def zip(i): ...
+
+def g(t: Tuple):
+    reveal_type(zip(*t))  # N: Revealed type is "typing.Iterator[builtins.tuple[Any, ...]]"
+    reveal_type(zip(t))  # N: Revealed type is "typing.Iterator[Tuple[Any]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTupleSubclassSlice]
+from typing import Tuple
+
+class A: ...
+
+class tuple_aa_subclass(Tuple[A, A]): ...
+
+inst_tuple_aa_subclass: tuple_aa_subclass = tuple_aa_subclass((A(), A()))[:]  # E: Incompatible types in assignment (expression has type "Tuple[A, A]", variable has type "tuple_aa_subclass")
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-type-aliases.test b/test-data/unit/check-type-aliases.test
index 05a03ecaf7b0..21832a0db079 100644
--- a/test-data/unit/check-type-aliases.test
+++ b/test-data/unit/check-type-aliases.test
@@ -12,7 +12,7 @@ U = Union[int, str]
 def f(x: U) -> None: pass
 f(1)
 f('')
-f(()) # E: Argument 1 to "f" has incompatible type "Tuple[]"; expected "Union[int, str]"
+f(()) # E: Argument 1 to "f" has incompatible type "Tuple[()]"; expected "Union[int, str]"
 [targets __main__, __main__.f]
 [builtins fixtures/tuple.pyi]
 
@@ -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__]
@@ -57,14 +57,14 @@ Never = NoReturn
 a: Never  # Used to be an error here
 
 def f(a: Never): ...
-f(5)  # E: Argument 1 to "f" has incompatible type "int"; expected "NoReturn"
+f(5)  # E: Argument 1 to "f" has incompatible type "int"; expected "Never"
 [case testImportUnionAlias]
 import typing
 from _m import U
 def f(x: U) -> None: pass
 f(1)
 f('x')
-f(()) # E: Argument 1 to "f" has incompatible type "Tuple[]"; expected "Union[int, str]"
+f(()) # E: Argument 1 to "f" has incompatible type "Tuple[()]"; expected "Union[int, str]"
 [file _m.py]
 from typing import Union
 U = Union[int, str]
@@ -93,11 +93,9 @@ T = TypeVar('T')
 
 A = Tuple[T, T]
 if int():
-    A = Union[T, int]  # E: Cannot assign multiple types to name "A" without an explicit "Type[...]" annotation \
-                   # E: Value of type "int" is not indexable
-                   # the second error is because of `Union = 0` in lib-stub/typing.pyi
+    A = Union[T, int]  # E: Cannot assign multiple types to name "A" without an explicit "Type[...]" annotation
 [builtins fixtures/tuple.pyi]
-[out]
+[typing fixtures/typing-full.pyi]
 
 [case testProhibitUsingVariablesAsTypesAndAllowAliasesAsTypes]
 
@@ -169,12 +167,12 @@ 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
-reveal_type(x)  # N: Revealed type is "Tuple[]"
+x: EmptyTuple
+reveal_type(x)  # N: Revealed type is "Tuple[()]"
 
 EmptyTupleCallable = Callable[[Tuple[()]], None]
-f = None # type: EmptyTupleCallable
-reveal_type(f)  # N: Revealed type is "def (Tuple[])"
+f: EmptyTupleCallable
+reveal_type(f)  # N: Revealed type is "def (Tuple[()])"
 [builtins fixtures/list.pyi]
 
 [case testForwardTypeAlias]
@@ -197,30 +195,35 @@ Alias = Tuple[int, T]
 [out]
 
 [case testRecursiveAliasesErrors1]
-# flags: --disable-recursive-aliases
-# Recursive aliases are not supported yet.
 from typing import Type, Callable, Union
 
-A = Union[A, int] # E: Cannot resolve name "A" (possible cyclic definition)
-B = Callable[[B], int] # E: Cannot resolve name "B" (possible cyclic definition)
-C = Type[C] # E: Cannot resolve name "C" (possible cyclic definition)
+def test() -> None:
+    A = Union[A, int]  # E: Cannot resolve name "A" (possible cyclic definition) \
+                       # N: Recursive types are not allowed at function scope
+    B = Callable[[B], int]  # E: Cannot resolve name "B" (possible cyclic definition) \
+                            # N: Recursive types are not allowed at function scope
+    C = Type[C]  # E: Cannot resolve name "C" (possible cyclic definition) \
+                 # N: Recursive types are not allowed at function scope
 
 [case testRecursiveAliasesErrors2]
-# flags: --disable-recursive-aliases --disable-error-code=used-before-def
-# Recursive aliases are not supported yet.
+# flags: --disable-error-code=used-before-def
 from typing import Type, Callable, Union
 
-A = Union[B, int]
-B = Callable[[C], int]
-C = Type[A]
-x: A
-reveal_type(x)
+def test() -> None:
+    A = Union[B, int]
+    B = Callable[[C], int]
+    C = Type[A]
+    x: A
+    reveal_type(x)
 [out]
 main:5: error: Cannot resolve name "A" (possible cyclic definition)
+main:5: note: Recursive types are not allowed at function scope
 main:5: error: Cannot resolve name "B" (possible cyclic definition)
 main:6: error: Cannot resolve name "B" (possible cyclic definition)
+main:6: note: Recursive types are not allowed at function scope
 main:6: error: Cannot resolve name "C" (possible cyclic definition)
 main:7: error: Cannot resolve name "C" (possible cyclic definition)
+main:7: note: Recursive types are not allowed at function scope
 main:9: note: Revealed type is "Union[Any, builtins.int]"
 
 [case testDoubleForwardAlias]
@@ -245,13 +248,16 @@ reveal_type(x[0].x) # N: Revealed type is "builtins.str"
 [out]
 
 [case testJSONAliasApproximation]
-# flags: --disable-recursive-aliases
 from typing import List, Union, Dict
-x: JSON # E: Cannot resolve name "JSON" (possible cyclic definition)
-JSON = Union[int, str, List[JSON], Dict[str, JSON]] # E: Cannot resolve name "JSON" (possible cyclic definition)
-reveal_type(x) # N: Revealed type is "Any"
-if isinstance(x, list):
-    reveal_type(x) # N: Revealed type is "builtins.list[Any]"
+
+def test() -> None:
+    x: JSON  # E: Cannot resolve name "JSON" (possible cyclic definition)  \
+             # N: Recursive types are not allowed at function scope
+    JSON = Union[int, str, List[JSON], Dict[str, JSON]]  # E: Cannot resolve name "JSON" (possible cyclic definition) \
+                                                         # N: Recursive types are not allowed at function scope
+    reveal_type(x) # N: Revealed type is "Any"
+    if isinstance(x, list):
+        reveal_type(x) # N: Revealed type is "builtins.list[Any]"
 [builtins fixtures/isinstancelist.pyi]
 [out]
 
@@ -305,7 +311,6 @@ reveal_type(y)  # N: Revealed type is "Union[builtins.int, None]"
 [builtins fixtures/bool.pyi]
 
 [case testNoneAliasStrict]
-# flags: --strict-optional
 from typing import Optional, Union
 void = type(None)
 x: int
@@ -323,10 +328,9 @@ c: C
 t: T
 reveal_type(c)  # N: Revealed type is "def (*Any, **Any) -> Any"
 reveal_type(t)  # N: Revealed type is "builtins.tuple[Any, ...]"
-bad: C[int]  # E: Bad number of arguments for type alias, expected: 0, given: 1
-also_bad: T[int]  # E: Bad number of arguments for type alias, expected: 0, given: 1
+bad: C[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+also_bad: T[int]  # E: Bad number of arguments for type alias, expected 0, given 1
 [builtins fixtures/tuple.pyi]
-[out]
 
 [case testAliasRefOnClass]
 from typing import Generic, TypeVar, Type
@@ -961,6 +965,7 @@ a: A
 b: B
 reveal_type(a)  # N: Revealed type is "Union[builtins.list[Any], builtins.int]"
 reveal_type(b)  # N: Revealed type is "Union[builtins.int, builtins.list[Any]]"
+[builtins fixtures/type.pyi]
 
 [case testValidTypeAliasValues]
 from typing import TypeVar, Generic, List
@@ -1045,8 +1050,8 @@ class C(Generic[T]):
 [builtins fixtures/classmethod.pyi]
 
 [case testRecursiveAliasTuple]
-from typing_extensions import Literal, TypeAlias
-from typing import Tuple, Union
+from typing_extensions import TypeAlias
+from typing import Literal, Tuple, Union
 
 Expr: TypeAlias = Union[
     Tuple[Literal[123], int],
@@ -1058,4 +1063,254 @@ def eval(e: Expr) -> int:
         return e[1]
     elif e[0] == 456:
         return -eval(e[1])
+[builtins fixtures/dict-full.pyi]
+
+[case testTypeAliasType]
+from typing import Union
+from typing_extensions import TypeAliasType
+
+TestType = TypeAliasType("TestType", Union[int, str])
+x: TestType = 42
+y: TestType = 'a'
+z: TestType = object()  # E: Incompatible types in assignment (expression has type "object", variable has type "Union[int, str]")
+
+reveal_type(TestType)  # N: Revealed type is "typing_extensions.TypeAliasType"
+TestType()  # E: "TypeAliasType" not callable
+
+class A:
+    ClassAlias = TypeAliasType("ClassAlias", int)
+xc: A.ClassAlias = 1
+yc: A.ClassAlias = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypeAliasTypePython311]
+# flags: --python-version 3.11
+# Pinning to 3.11, because 3.12 has `TypeAliasType`
+from typing_extensions import TypeAliasType
+
+TestType = TypeAliasType("TestType", int)
+x: TestType = 1
+[builtins fixtures/tuple.pyi]
+
+[case testTypeAliasTypeInvalid]
+from typing_extensions import TypeAliasType
+
+TestType = TypeAliasType("T", int)  # E: String argument 1 "T" to TypeAliasType(...) does not match variable name "TestType"
+
+T1 = T2 = TypeAliasType("T", int)
+t1: T1  # E: Variable "__main__.T1" is not valid as a type \
+        # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
+
+T3 = TypeAliasType("T3", -1)  # E: Invalid type: try using Literal[-1] instead?
+t3: T3
+reveal_type(t3)  # N: Revealed type is "Any"
+
+T4 = TypeAliasType("T4")  # E: Missing positional argument "value" in call to "TypeAliasType"
+T5 = TypeAliasType("T5", int, str)  # E: Too many positional arguments for "TypeAliasType" \
+                                    # E: Argument 3 to "TypeAliasType" has incompatible type "Type[str]"; expected "Tuple[Union[TypeVar?, ParamSpec?, TypeVarTuple?], ...]"
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypeAliasTypeGeneric]
+from typing import Callable, Dict, Generic, TypeVar, Tuple
+from typing_extensions import TypeAliasType, TypeVarTuple, ParamSpec, Unpack
+
+K = TypeVar('K')
+V = TypeVar('V')
+T = TypeVar('T')
+Ts = TypeVarTuple("Ts")
+Ts1 = TypeVarTuple("Ts1")
+P = ParamSpec("P")
+
+TestType = TypeAliasType("TestType", Dict[K, V], type_params=(K, V))
+x: TestType[int, str] = {1: 'a'}
+y: TestType[str, int] = {'a': 1}
+z: TestType[str, int] = {1: 'a'}  # E: Dict entry 0 has incompatible type "int": "str"; expected "str": "int"
+w: TestType[int]  # E: Bad number of arguments for type alias, expected 2, given 1
+
+InvertedDict = TypeAliasType("InvertedDict", Dict[K, V], type_params=(V, K))
+xi: InvertedDict[str, int] = {1: 'a'}
+yi: InvertedDict[str, int] = {'a': 1}  # E: Dict entry 0 has incompatible type "str": "int"; expected "int": "str"
+zi: InvertedDict[int, str] = {1: 'a'}  # E: Dict entry 0 has incompatible type "int": "str"; expected "str": "int"
+reveal_type(xi)  # N: Revealed type is "builtins.dict[builtins.int, builtins.str]"
+
+VariadicAlias1 = TypeAliasType("VariadicAlias1", Tuple[Unpack[Ts]], type_params=(Ts,))
+VariadicAlias2 = TypeAliasType("VariadicAlias2", Tuple[Unpack[Ts], K], type_params=(Ts, K))
+VariadicAlias3 = TypeAliasType("VariadicAlias3", Callable[[Unpack[Ts]], int], type_params=(Ts,))
+xv: VariadicAlias1[int, str] = (1, 'a')
+yv: VariadicAlias1[str, int] = (1, 'a')  # E: Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type "Tuple[str, int]")
+zv: VariadicAlias2[int, str] = (1, 'a')
+def int_in_int_out(x: int) -> int: return x
+wv: VariadicAlias3[int] = int_in_int_out
+reveal_type(wv)  # N: Revealed type is "def (builtins.int) -> builtins.int"
+
+ParamAlias = TypeAliasType("ParamAlias", Callable[P, int], type_params=(P,))
+def f(x: str, y: float) -> int: return 1
+def g(x: int, y: float) -> int: return 1
+xp1: ParamAlias[str, float] = f
+xp2: ParamAlias[str, float] = g  # E: Incompatible types in assignment (expression has type "Callable[[int, float], int]", variable has type "Callable[[str, float], int]")
+xp3: ParamAlias[str, float] = lambda x, y: 1
+
+class G(Generic[P, T]): ...
+ParamAlias2 = TypeAliasType("ParamAlias2", G[P, T], type_params=(P, T))
+xp: ParamAlias2[[int], str]
+reveal_type(xp)  # N: Revealed type is "__main__.G[[builtins.int], builtins.str]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypeAliasTypeInvalidGeneric]
+from typing_extensions import TypeAliasType, TypeVarTuple, ParamSpec
+from typing import Callable, Dict, Generic, TypeVar, Tuple, Unpack
+
+K = TypeVar('K')
+V = TypeVar('V')
+T = TypeVar('T')
+Ts = TypeVarTuple("Ts")
+Ts1 = TypeVarTuple("Ts1")
+P = ParamSpec("P")
+
+Ta0 = TypeAliasType("Ta0", int, type_params=(T, T))  # E: Duplicate type variable "T" in type_params argument to TypeAliasType
+
+Ta1 = TypeAliasType("Ta1", int, type_params=K)  # E: Tuple literal expected as the type_params argument to TypeAliasType
+
+Ta2 = TypeAliasType("Ta2", int, type_params=(None,))  # E: Free type variable expected in type_params argument to TypeAliasType
+
+Ta3 = TypeAliasType("Ta3", Dict[K, V], type_params=(V,))  # E: Type variable "K" is not included in type_params
+partially_generic1: Ta3[int] = {"a": 1}
+reveal_type(partially_generic1)  # N: Revealed type is "builtins.dict[Any, builtins.int]"
+partially_generic2: Ta3[int] = {1: "a"}  # E: Dict entry 0 has incompatible type "int": "str"; expected "Any": "int"
+
+Ta4 = TypeAliasType("Ta4", Tuple[Unpack[Ts]], type_params=(Ts, Ts1))  # E: Can only use one TypeVarTuple in type_params argument to TypeAliasType
+
+Ta5 = TypeAliasType("Ta5", Dict)  # Unlike old style aliases, this is not generic
+non_generic_dict: Ta5[int, str]  # E: Bad number of arguments for type alias, expected 0, given 2
+reveal_type(non_generic_dict)  # N: Revealed type is "builtins.dict[Any, Any]"
+
+Ta6 = TypeAliasType("Ta6", Tuple[Unpack[Ts]])  # E: TypeVarTuple "Ts" is not included in type_params
+unbound_tvt_alias: Ta6[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(unbound_tvt_alias)  # N: Revealed type is "builtins.tuple[Any, ...]"
+
+class G(Generic[P, T]): ...
+Ta7 = TypeAliasType("Ta7", G[P, T])  # E: ParamSpec "P" is not included in type_params \
+                                     # E: Type variable "T" is not included in type_params
+unbound_ps_alias: Ta7[[int], str]  # E: Bracketed expression "[...]" is not valid as a type \
+                                   # N: Did you mean "List[...]"? \
+                                   # E: Bad number of arguments for type alias, expected 0, given 2
+reveal_type(unbound_ps_alias)  # N: Revealed type is "__main__.G[Any, Any]"
+
+Ta8 = TypeAliasType("Ta8", Callable[P, int])  # E: ParamSpec "P" is not included in type_params
+unbound_ps_alias2: Ta8[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(unbound_ps_alias2)  # N: Revealed type is "def [P] (*Any, **Any) -> builtins.int"
+
+Ta9 = TypeAliasType("Ta9", Callable[P, T])  # E: ParamSpec "P" is not included in type_params \
+                                            # E: Type variable "T" is not included in type_params
+unbound_ps_alias3: Ta9[int, str]  # E: Bad number of arguments for type alias, expected 0, given 2
+reveal_type(unbound_ps_alias3)  # N: Revealed type is "def [P] (*Any, **Any) -> Any"
+
+Ta10 = TypeAliasType("Ta10", Callable[[Unpack[Ts]], str])  # E: TypeVarTuple "Ts" is not included in type_params
+unbound_tvt_alias2: Ta10[int]  # E: Bad number of arguments for type alias, expected 0, given 1
+reveal_type(unbound_tvt_alias2)  # N: Revealed type is "def (*Any) -> builtins.str"
+
+class A(Generic[T]):
+    Ta11 = TypeAliasType("Ta11", Dict[str, T], type_params=(T,))  # E: Can't use bound type variable "T" to define generic alias
+x: A.Ta11 = {"a": 1}
+reveal_type(x)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypeAliasTypeNoUnpackInTypeParams311]
+# flags: --python-version 3.11
+from typing_extensions import TypeAliasType, TypeVar, TypeVarTuple, Unpack
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+
+Ta1 = TypeAliasType("Ta1", None, type_params=(*Ts,))  # E: can't use starred expression here
+Ta2 = TypeAliasType("Ta2", None, type_params=(Unpack[Ts],))  # E: Free type variable expected in type_params argument to TypeAliasType \
+                                                             # N: Don't Unpack type variables in type_params
+
+[builtins fixtures/tuple.pyi]
+
+[case testAliasInstanceNameClash]
+from lib import func
+class A: ...
+func(A())  # E: Argument 1 to "func" has incompatible type "__main__.A"; expected "lib.A"
+[file lib.py]
+from typing import List, Union
+
+A = Union[int, List[A]]
+def func(x: A) -> int: ...
+[builtins fixtures/tuple.pyi]
+
+[case testAliasNonGeneric]
+from typing_extensions import TypeAlias
+class Foo: ...
+
+ImplicitFoo = Foo
+ExplicitFoo: TypeAlias = Foo
+
+x1: ImplicitFoo[str]  # E: "Foo" expects no type arguments, but 1 given
+x2: ExplicitFoo[str]  # E: "Foo" expects no type arguments, but 1 given
+
+def is_foo(x: object):
+    if isinstance(x, ImplicitFoo):
+        pass
+    if isinstance(x, ExplicitFoo):
+        pass
+
+[builtins fixtures/tuple.pyi]
+
+[case testAliasExplicitNoArgsTuple]
+from typing import Any, Tuple, assert_type
+from typing_extensions import TypeAlias
+
+Implicit = Tuple
+Explicit: TypeAlias = Tuple
+
+x1: Implicit[str]  # E: Bad number of arguments for type alias, expected 0, given 1
+x2: Explicit[str]  # E: Bad number of arguments for type alias, expected 0, given 1
+assert_type(x1, Tuple[Any, ...])
+assert_type(x2, Tuple[Any, ...])
+[builtins fixtures/tuple.pyi]
+
+[case testAliasExplicitNoArgsCallable]
+from typing import Any, Callable, assert_type
+from typing_extensions import TypeAlias
+
+Implicit = Callable
+Explicit: TypeAlias = Callable
+
+x1: Implicit[str]  # E: Bad number of arguments for type alias, expected 0, given 1
+x2: Explicit[str]  # E: Bad number of arguments for type alias, expected 0, given 1
+assert_type(x1, Callable[..., Any])
+assert_type(x2, Callable[..., Any])
+[builtins fixtures/tuple.pyi]
+
+[case testExplicitTypeAliasToSameNameOuterProhibited]
+from typing import TypeVar, Generic
+from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+class Foo(Generic[T]):
+    bar: Bar[T]
+
+class Bar(Generic[T]):
+    Foo: TypeAlias = Foo[T]  # E: Can't use bound type variable "T" to define generic alias
+[builtins fixtures/tuple.pyi]
+
+[case testExplicitTypeAliasToSameNameOuterAllowed]
+from typing import TypeVar, Generic
+from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+class Foo(Generic[T]):
+    bar: Bar[T]
+
+U = TypeVar("U")
+class Bar(Generic[T]):
+    Foo: TypeAlias = Foo[U]
+    var: Foo[T]
+x: Bar[int]
+reveal_type(x.var.bar)  # N: Revealed type is "__main__.Bar[builtins.int]"
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-type-checks.test b/test-data/unit/check-type-checks.test
index 106f2d680ba4..03c8de4177f3 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-type-object-type-inference.test b/test-data/unit/check-type-object-type-inference.test
new file mode 100644
index 000000000000..5a4afa0c9248
--- /dev/null
+++ b/test-data/unit/check-type-object-type-inference.test
@@ -0,0 +1,42 @@
+[case testInferTupleType]
+# flags: --python-version 3.9
+from typing import TypeVar, Generic, Type
+from abc import abstractmethod
+import types  # Explicitly bring in stubs for 'types'
+
+T = TypeVar('T')
+class E(Generic[T]):
+    @abstractmethod
+    def e(self, t: T) -> str:
+        ...
+
+class F:
+    @abstractmethod
+    def f(self, tp: Type[T]) -> E[T]:
+        ...
+
+def g(f: F):
+    f.f(int).e(7)
+    f.f(tuple[int,str])
+    f.f(tuple[int,str]).e('x')  # E: Argument 1 to "e" of "E" has incompatible type "str"; expected "Tuple[int, str]"
+    f.f(tuple[int,str]).e( (7,8) )  # E: Argument 1 to "e" of "E" has incompatible type "Tuple[int, int]"; expected "Tuple[int, str]"
+    f.f(tuple[int,str]).e( (7,'x') )  # OK
+    reveal_type(f.f(tuple[int,str]).e)  # N: Revealed type is "def (t: Tuple[builtins.int, builtins.str]) -> builtins.str"
+
+def h(f: F):
+    f.f(int).e(7)
+    f.f(tuple)
+    f.f(tuple).e('y') # E: Argument 1 to "e" of "E" has incompatible type "str"; expected "Tuple[Any, ...]"
+    f.f(tuple).e( (8,'y') )  # OK
+    reveal_type(f.f(tuple).e)  # N: Revealed type is "def (t: builtins.tuple[Any, ...]) -> builtins.str"
+
+def i(f: F):
+    f.f(tuple[int,tuple[int,str]])
+    f.f(tuple[int,tuple[int,str]]).e('z')  # E: Argument 1 to "e" of "E" has incompatible type "str"; expected "Tuple[int, Tuple[int, str]]"
+    f.f(tuple[int,tuple[int,str]]).e( (8,9) )  # E: Argument 1 to "e" of "E" has incompatible type "Tuple[int, int]"; expected "Tuple[int, Tuple[int, str]]"
+    f.f(tuple[int,tuple[int,str]]).e( (17, (28, 29)) )  # E: Argument 1 to "e" of "E" has incompatible type "Tuple[int, Tuple[int, int]]"; expected "Tuple[int, Tuple[int, str]]"
+    f.f(tuple[int,tuple[int,str]]).e( (27,(28,'z')) )  # OK
+    reveal_type(f.f(tuple[int,tuple[int,str]]).e)  # N: Revealed type is "def (t: Tuple[builtins.int, Tuple[builtins.int, builtins.str]]) -> builtins.str"
+
+x = tuple[int,str][str]  # False negative
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-type-promotion.test b/test-data/unit/check-type-promotion.test
index e66153726e7d..1b69174a4545 100644
--- a/test-data/unit/check-type-promotion.test
+++ b/test-data/unit/check-type-promotion.test
@@ -91,7 +91,7 @@ else:
     reveal_type(x)  # N: Revealed type is "builtins.complex"
 
 # Note we make type precise, since type promotions are involved
-reveal_type(x)  # N: Revealed type is "Union[builtins.complex, builtins.int, builtins.float]"
+reveal_type(x)  # N: Revealed type is "builtins.complex"
 [builtins fixtures/primitives.pyi]
 
 [case testIntersectionUsingPromotion3]
@@ -127,7 +127,7 @@ if isinstance(x, int):
     reveal_type(x)  # N: Revealed type is "builtins.int"
 else:
     reveal_type(x)  # N: Revealed type is "Union[builtins.float, builtins.complex]"
-reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.float, builtins.complex]"
+reveal_type(x)  # N: Revealed type is "Union[builtins.float, builtins.complex]"
 [builtins fixtures/primitives.pyi]
 
 [case testIntersectionUsingPromotion6]
@@ -139,7 +139,7 @@ if isinstance(x, int):
     reveal_type(x)  # N: Revealed type is "builtins.int"
 else:
     reveal_type(x)  # N: Revealed type is "Union[builtins.str, builtins.complex]"
-reveal_type(x)  # N: Revealed type is "Union[builtins.str, builtins.int, builtins.complex]"
+reveal_type(x)  # N: Revealed type is "Union[builtins.str, builtins.complex]"
 [builtins fixtures/primitives.pyi]
 
 [case testIntersectionUsingPromotion7]
@@ -187,3 +187,19 @@ if isinstance(x, (float, complex)):
 else:
     reveal_type(x)  # N: Revealed type is "builtins.int"
 [builtins fixtures/primitives.pyi]
+
+[case testRejectPromotionsForProtocols]
+from typing import Protocol
+
+class H(Protocol):
+    def hex(self, /) -> str: ...
+
+f: H = 1.0
+o: H = object()  # E: Incompatible types in assignment (expression has type "object", variable has type "H")
+c: H = 1j   # E: Incompatible types in assignment (expression has type "complex", variable has type "H")
+i: H = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "H")
+b: H = False  # E: Incompatible types in assignment (expression has type "bool", variable has type "H")
+
+class N(float): ...
+n: H = N()
+[builtins fixtures/primitives.pyi]
diff --git a/test-data/unit/check-typeddict.test b/test-data/unit/check-typeddict.test
index 970dc05b488d..47c8a71ba0e3 100644
--- a/test-data/unit/check-typeddict.test
+++ b/test-data/unit/check-typeddict.test
@@ -1,7 +1,7 @@
 -- Create Instance
 
 [case testCanCreateTypedDictInstanceWithKeywordArguments]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(x=42, y=1337)
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.int, 'y': builtins.int})"
@@ -12,7 +12,7 @@ reveal_type(p.values()) # N: Revealed type is "typing.Iterable[builtins.object]"
 [targets __main__]
 
 [case testCanCreateTypedDictInstanceWithDictCall]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337))
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.int, 'y': builtins.int})"
@@ -22,7 +22,7 @@ reveal_type(p.values()) # N: Revealed type is "typing.Iterable[builtins.object]"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictInstanceWithDictLiteral]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point({'x': 42, 'y': 1337})
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.int, 'y': builtins.int})"
@@ -32,8 +32,7 @@ reveal_type(p.values()) # N: Revealed type is "typing.Iterable[builtins.object]"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictInstanceWithNoArguments]
-from typing import TypeVar, Union
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar, Union
 EmptyDict = TypedDict('EmptyDict', {})
 p = EmptyDict()
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.EmptyDict', {})"
@@ -45,50 +44,55 @@ reveal_type(p.values()) # N: Revealed type is "typing.Iterable[builtins.object]"
 -- Create Instance (Errors)
 
 [case testCannotCreateTypedDictInstanceWithUnknownArgumentPattern]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(42, 1337)  # E: Expected keyword arguments, {...}, or dict(...) in TypedDict constructor
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictInstanceNonLiteralItemName]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 x = 'x'
 p = Point({x: 42, 'y': 1337})  # E: Expected TypedDict key to be string literal
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictInstanceWithExtraItems]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(x=42, y=1337, z=666)  # E: Extra key "z" for TypedDict "Point"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictInstanceWithMissingItems]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(x=42)  # E: Missing key "y" for TypedDict "Point"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictInstanceWithIncompatibleItemType]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(x='meaning_of_life', y=1337)  # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictInstanceWithInlineTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {
-    'x': TypedDict('E', {  # E: Inline TypedDict types not supported; use assignment to define TypedDict
+    'x': TypedDict('E', {  # E: Use dict literal for nested TypedDict
         'y': int
     })
 })
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 -- Define TypedDict (Class syntax)
 
 [case testCanCreateTypedDictWithClass]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Point(TypedDict):
     x: int
@@ -97,10 +101,10 @@ class Point(TypedDict):
 p = Point(x=42, y=1337)
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.int, 'y': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictWithSubclass]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Point1D(TypedDict):
     x: int
@@ -111,10 +115,10 @@ p: Point2D
 reveal_type(r)  # N: Revealed type is "TypedDict('__main__.Point1D', {'x': builtins.int})"
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point2D', {'x': builtins.int, 'y': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictWithSubclass2]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Point1D(TypedDict):
     x: int
@@ -124,10 +128,10 @@ class Point2D(TypedDict, Point1D): # We also allow to include TypedDict in bases
 p: Point2D
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point2D', {'x': builtins.int, 'y': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictClassEmpty]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class EmptyDict(TypedDict):
     pass
@@ -135,15 +139,12 @@ class EmptyDict(TypedDict):
 p = EmptyDict()
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.EmptyDict', {})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 [case testCanCreateTypedDictWithClassOldVersion]
-# flags: --python-version 3.5
-
-# Test that we can use class-syntax to merge TypedDicts even in
-# versions without type annotations
-
-from mypy_extensions import TypedDict
+# Test that we can use class-syntax to merge function-based TypedDicts
+from typing import TypedDict
 
 MovieBase1 = TypedDict(
     'MovieBase1', {'name': str, 'year': int})
@@ -159,14 +160,13 @@ def foo(x):
 
 foo({})  # E: Missing keys ("name", "year") for TypedDict "Movie"
 foo({'name': 'lol', 'year': 2009, 'based_on': 0})  # E: Incompatible types (expression has type "int", TypedDict item "based_on" has type "str")
-
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 -- Define TypedDict (Class syntax errors)
 
 [case testCannotCreateTypedDictWithClassOtherBases]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class A: pass
 
@@ -178,6 +178,7 @@ class Point2D(Point1D, A): # E: All bases of a new TypedDict must be TypedDict t
 p: Point2D
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point2D', {'x': builtins.int, 'y': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictWithDuplicateBases]
 # https://github.com/python/mypy/issues/3673
@@ -195,8 +196,7 @@ class C(TypedDict, TypedDict): # E: Duplicate base class "TypedDict"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictWithClassWithOtherStuff]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Point(TypedDict):
     x: int
@@ -207,6 +207,7 @@ class Point(TypedDict):
 p = Point(x=42, y=1337, z='whatever')
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.int, 'y': builtins.int, 'z': Any})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictWithClassWithFunctionUsedToCrash]
 # https://github.com/python/mypy/issues/11079
@@ -246,13 +247,13 @@ class Foo(TypedDict):
 [typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictTypeWithUnderscoreItemName]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int, '_fallback': object})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictWithClassUnderscores]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Point(TypedDict):
     x: int
@@ -261,10 +262,10 @@ class Point(TypedDict):
 p: Point
 reveal_type(p) # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.int, '_y': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictWithDuplicateKey1]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Bad(TypedDict):
     x: int
@@ -273,6 +274,7 @@ class Bad(TypedDict):
 b: Bad
 reveal_type(b) # N: Revealed type is "TypedDict('__main__.Bad', {'x': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictWithDuplicateKey2]
 from typing import TypedDict
@@ -291,8 +293,7 @@ reveal_type(d2) # N: Revealed type is "TypedDict('__main__.D2', {'x': builtins.s
 [typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictWithClassOverwriting]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Point1(TypedDict):
     x: int
@@ -304,10 +305,10 @@ class Bad(Point1, Point2): # E: Overwriting TypedDict field "x" while merging
 b: Bad
 reveal_type(b) # N: Revealed type is "TypedDict('__main__.Bad', {'x': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictWithClassOverwriting2]
-# flags: --python-version 3.6
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class Point1(TypedDict):
     x: int
@@ -317,104 +318,111 @@ class Point2(Point1):
 p2: Point2
 reveal_type(p2) # N: Revealed type is "TypedDict('__main__.Point2', {'x': builtins.float})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Subtyping
 
 [case testCanConvertTypedDictToItself]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 def identity(p: Point) -> Point:
     return p
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanConvertTypedDictToEquivalentTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 PointA = TypedDict('PointA', {'x': int, 'y': int})
 PointB = TypedDict('PointB', {'x': int, 'y': int})
 def identity(p: PointA) -> PointB:
     return p
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotConvertTypedDictToSimilarTypedDictWithNarrowerItemTypes]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 ObjectPoint = TypedDict('ObjectPoint', {'x': object, 'y': object})
 def convert(op: ObjectPoint) -> Point:
     return op  # E: Incompatible return value type (got "ObjectPoint", expected "Point")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotConvertTypedDictToSimilarTypedDictWithWiderItemTypes]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 ObjectPoint = TypedDict('ObjectPoint', {'x': object, 'y': object})
 def convert(p: Point) -> ObjectPoint:
     return p  # E: Incompatible return value type (got "Point", expected "ObjectPoint")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotConvertTypedDictToSimilarTypedDictWithIncompatibleItemTypes]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 Chameleon = TypedDict('Chameleon', {'x': str, 'y': str})
 def convert(p: Point) -> Chameleon:
     return p  # E: Incompatible return value type (got "Point", expected "Chameleon")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanConvertTypedDictToNarrowerTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 Point1D = TypedDict('Point1D', {'x': int})
 def narrow(p: Point) -> Point1D:
     return p
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotConvertTypedDictToWiderTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 Point3D = TypedDict('Point3D', {'x': int, 'y': int, 'z': int})
 def widen(p: Point) -> Point3D:
     return p  # E: Incompatible return value type (got "Point", expected "Point3D")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanConvertTypedDictToCompatibleMapping]
-from mypy_extensions import TypedDict
-from typing import Mapping
+from typing import Mapping, TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 def as_mapping(p: Point) -> Mapping[str, object]:
     return p
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotConvertTypedDictToIncompatibleMapping]
-from mypy_extensions import TypedDict
-from typing import Mapping
+from typing import Mapping, TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 def as_mapping(p: Point) -> Mapping[str, int]:
     return p  # E: Incompatible return value type (got "Point", expected "Mapping[str, int]")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictAcceptsIntForFloatDuckTypes]
-from mypy_extensions import TypedDict
-from typing import Any, Mapping
+from typing import Any, Mapping, TypedDict
 Point = TypedDict('Point', {'x': float, 'y': float})
 def create_point() -> Point:
     return Point(x=1, y=2)
 reveal_type(Point(x=1, y=2))  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.float, 'y': builtins.float})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictDoesNotAcceptsFloatForInt]
-from mypy_extensions import TypedDict
-from typing import Any, Mapping
+from typing import Any, Mapping, TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 def create_point() -> Point:
     return Point(x=1.2, y=2.5)
 [out]
-main:5: error: Incompatible types (expression has type "float", TypedDict item "x" has type "int")
-main:5: error: Incompatible types (expression has type "float", TypedDict item "y" has type "int")
+main:4: error: Incompatible types (expression has type "float", TypedDict item "x" has type "int")
+main:4: error: Incompatible types (expression has type "float", TypedDict item "y" has type "int")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictAcceptsAnyType]
-from mypy_extensions import TypedDict
-from typing import Any, Mapping
+from typing import Any, Mapping, TypedDict
 Point = TypedDict('Point', {'x': float, 'y': float})
 def create_point(something: Any) -> Point:
     return Point({
@@ -422,17 +430,17 @@ def create_point(something: Any) -> Point:
       'y': something.y
     })
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictValueTypeContext]
-from mypy_extensions import TypedDict
-from typing import List
+from typing import List, TypedDict
 D = TypedDict('D', {'x': List[int]})
 reveal_type(D(x=[]))  # N: Revealed type is "TypedDict('__main__.D', {'x': builtins.list[builtins.int]})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotConvertTypedDictToDictOrMutableMapping]
-from mypy_extensions import TypedDict
-from typing import Dict, MutableMapping
+from typing import Dict, MutableMapping, TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 def as_dict(p: Point) -> Dict[str, int]:
     return p  # E: Incompatible return value type (got "Point", expected "Dict[str, int]")
@@ -442,15 +450,15 @@ def as_mutable_mapping(p: Point) -> MutableMapping[str, object]:
 [typing fixtures/typing-full.pyi]
 
 [case testCanConvertTypedDictToAny]
-from mypy_extensions import TypedDict
-from typing import Any
+from typing import Any, TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 def unprotect(p: Point) -> Any:
     return p
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testAnonymousTypedDictInErrorMessages]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 A = TypedDict('A', {'x': int, 'y': str})
 B = TypedDict('B', {'x': int, 'z': str, 'a': int})
@@ -466,9 +474,10 @@ f(l) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x': int})]";
 ll = [b, c]
 f(ll) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x': int, 'z': str})]"; expected "A"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictWithSimpleProtocol]
-from typing_extensions import Protocol, TypedDict
+from typing import Protocol, TypedDict
 
 class StrObjectMap(Protocol):
     def __getitem__(self, key: str) -> object: ...
@@ -496,8 +505,7 @@ main:17: note:     Got:
 main:17: note:         def __getitem__(self, str, /) -> object
 
 [case testTypedDictWithSimpleProtocolInference]
-from typing_extensions import Protocol, TypedDict
-from typing import TypeVar
+from typing import Protocol, TypedDict, TypeVar
 
 T_co = TypeVar('T_co', covariant=True)
 T = TypeVar('T')
@@ -520,7 +528,7 @@ reveal_type(fun(b))  # N: Revealed type is "builtins.object"
 -- Join
 
 [case testJoinOfTypedDictHasOnlyCommonKeysAndNewFallback]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 Point3D = TypedDict('Point3D', {'x': int, 'y': int, 'z': int})
 p1 = TaggedPoint(type='2d', x=0, y=0)
@@ -533,7 +541,7 @@ reveal_type(joined_points)  # N: Revealed type is "TypedDict({'x': builtins.int,
 [typing fixtures/typing-typeddict.pyi]
 
 [case testJoinOfTypedDictRemovesNonequivalentKeys]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 CellWithInt = TypedDict('CellWithInt', {'value': object, 'meta': int})
 CellWithObject = TypedDict('CellWithObject', {'value': object, 'meta': object})
 c1 = CellWithInt(value=1, meta=42)
@@ -543,9 +551,10 @@ reveal_type(c1)             # N: Revealed type is "TypedDict('__main__.CellWithI
 reveal_type(c2)             # N: Revealed type is "TypedDict('__main__.CellWithObject', {'value': builtins.object, 'meta': builtins.object})"
 reveal_type(joined_cells)   # N: Revealed type is "builtins.list[TypedDict({'value': builtins.object})]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testJoinOfDisjointTypedDictsIsEmptyTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 Cell = TypedDict('Cell', {'value': object})
 d1 = Point(x=0, y=0)
@@ -555,10 +564,10 @@ reveal_type(d1)             # N: Revealed type is "TypedDict('__main__.Point', {
 reveal_type(d2)             # N: Revealed type is "TypedDict('__main__.Cell', {'value': builtins.object})"
 reveal_type(joined_dicts)   # N: Revealed type is "builtins.list[TypedDict({})]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testJoinOfTypedDictWithCompatibleMappingIsMapping]
-from mypy_extensions import TypedDict
-from typing import Mapping
+from typing import Mapping, TypedDict
 Cell = TypedDict('Cell', {'value': int})
 left = Cell(value=42)
 right = {'score': 999}  # type: Mapping[str, int]
@@ -567,10 +576,10 @@ joined2 = [right, left]
 reveal_type(joined1)  # N: Revealed type is "builtins.list[typing.Mapping[builtins.str, builtins.object]]"
 reveal_type(joined2)  # N: Revealed type is "builtins.list[typing.Mapping[builtins.str, builtins.object]]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testJoinOfTypedDictWithCompatibleMappingSupertypeIsSupertype]
-from mypy_extensions import TypedDict
-from typing import Sized
+from typing import Sized, TypedDict
 Cell = TypedDict('Cell', {'value': int})
 left = Cell(value=42)
 right = {'score': 999}  # type: Sized
@@ -582,8 +591,7 @@ reveal_type(joined2)  # N: Revealed type is "builtins.list[typing.Sized]"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testJoinOfTypedDictWithIncompatibleTypeIsObject]
-from mypy_extensions import TypedDict
-from typing import Mapping
+from typing import Mapping, TypedDict
 Cell = TypedDict('Cell', {'value': int})
 left = Cell(value=42)
 right = 42
@@ -592,13 +600,13 @@ joined2 = [right, left]
 reveal_type(joined1)  # N: Revealed type is "builtins.list[builtins.object]"
 reveal_type(joined2)  # N: Revealed type is "builtins.list[builtins.object]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Meet
 
 [case testMeetOfTypedDictsWithCompatibleCommonKeysHasAllKeysAndNewFallback]
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable
+from typing import TypedDict, TypeVar, Callable
 XY = TypedDict('XY', {'x': int, 'y': int})
 YZ = TypedDict('YZ', {'y': int, 'z': int})
 T = TypeVar('T')
@@ -606,22 +614,21 @@ def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: XY, y: YZ) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "TypedDict({'x': builtins.int, 'y': builtins.int, 'z': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testMeetOfTypedDictsWithIncompatibleCommonKeysIsUninhabited]
-# flags: --strict-optional
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable
+from typing import TypedDict, TypeVar, Callable
 XYa = TypedDict('XYa', {'x': int, 'y': int})
 YbZ = TypedDict('YbZ', {'y': object, 'z': int})
 T = TypeVar('T')
 def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: XYa, y: YbZ) -> None: pass
-reveal_type(f(g))  # N: Revealed type is "<nothing>"
+reveal_type(f(g))  # N: Revealed type is "Never"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testMeetOfTypedDictsWithNoCommonKeysHasAllKeysAndNewFallback]
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable
+from typing import TypedDict, TypeVar, Callable
 X = TypedDict('X', {'x': int})
 Z = TypedDict('Z', {'z': int})
 T = TypeVar('T')
@@ -629,36 +636,33 @@ def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: X, y: Z) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "TypedDict({'x': builtins.int, 'z': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 # TODO: It would be more accurate for the meet to be TypedDict instead.
 [case testMeetOfTypedDictWithCompatibleMappingIsUninhabitedForNow]
-# flags: --strict-optional
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable, Mapping
+from typing import TypedDict, TypeVar, Callable, Mapping
 X = TypedDict('X', {'x': int})
 M = Mapping[str, int]
 T = TypeVar('T')
 def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: X, y: M) -> None: pass
-reveal_type(f(g))  # N: Revealed type is "<nothing>"
+reveal_type(f(g))  # N: Revealed type is "Never"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testMeetOfTypedDictWithIncompatibleMappingIsUninhabited]
-# flags: --strict-optional
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable, Mapping
+from typing import TypedDict, TypeVar, Callable, Mapping
 X = TypedDict('X', {'x': int})
 M = Mapping[str, str]
 T = TypeVar('T')
 def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: X, y: M) -> None: pass
-reveal_type(f(g))  # N: Revealed type is "<nothing>"
+reveal_type(f(g))  # N: Revealed type is "Never"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testMeetOfTypedDictWithCompatibleMappingSuperclassIsUninhabitedForNow]
-# flags: --strict-optional
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable, Iterable
+from typing import TypedDict, TypeVar, Callable, Iterable
 X = TypedDict('X', {'x': int})
 I = Iterable[str]
 T = TypeVar('T')
@@ -666,10 +670,10 @@ def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: X, y: I) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "TypedDict('__main__.X', {'x': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testMeetOfTypedDictsWithNonTotal]
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable
+from typing import TypedDict, TypeVar, Callable
 XY = TypedDict('XY', {'x': int, 'y': int}, total=False)
 YZ = TypedDict('YZ', {'y': int, 'z': int}, total=False)
 T = TypeVar('T')
@@ -677,10 +681,10 @@ def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: XY, y: YZ) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "TypedDict({'x'?: builtins.int, 'y'?: builtins.int, 'z'?: builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testMeetOfTypedDictsWithNonTotalAndTotal]
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable
+from typing import TypedDict, TypeVar, Callable
 XY = TypedDict('XY', {'x': int}, total=False)
 YZ = TypedDict('YZ', {'y': int, 'z': int})
 T = TypeVar('T')
@@ -688,25 +692,24 @@ def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: XY, y: YZ) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "TypedDict({'x'?: builtins.int, 'y': builtins.int, 'z': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testMeetOfTypedDictsWithIncompatibleNonTotalAndTotal]
-# flags: --strict-optional
-from mypy_extensions import TypedDict
-from typing import TypeVar, Callable
+from typing import TypedDict, TypeVar, Callable
 XY = TypedDict('XY', {'x': int, 'y': int}, total=False)
 YZ = TypedDict('YZ', {'y': int, 'z': int})
 T = TypeVar('T')
 def f(x: Callable[[T, T], None]) -> T: pass
 def g(x: XY, y: YZ) -> None: pass
-reveal_type(f(g)) # N: Revealed type is "<nothing>"
+reveal_type(f(g)) # N: Revealed type is "Never"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Constraint Solver
 
 [case testTypedDictConstraintsAgainstIterable]
-from typing import TypeVar, Iterable
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar, Iterable
 T = TypeVar('T')
 def f(x: Iterable[T]) -> T: pass
 A = TypedDict('A', {'x': int})
@@ -721,25 +724,26 @@ reveal_type(f(a)) # N: Revealed type is "builtins.str"
 -- Special Method: __getitem__
 
 [case testCanGetItemOfTypedDictWithValidStringLiteralKey]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p = TaggedPoint(type='2d', x=42, y=1337)
 reveal_type(p['type'])  # N: Revealed type is "builtins.str"
 reveal_type(p['x'])     # N: Revealed type is "builtins.int"
 reveal_type(p['y'])     # N: Revealed type is "builtins.int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotGetItemOfTypedDictWithInvalidStringLiteralKey]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p: TaggedPoint
 p['typ']  # E: TypedDict "TaggedPoint" has no key "typ" \
           # N: Did you mean "type"?
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotGetItemOfAnonymousTypedDictWithInvalidStringLiteralKey]
-from typing import TypeVar
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar
 A = TypedDict('A', {'x': str, 'y': int, 'z': str})
 B = TypedDict('B', {'x': str, 'z': int})
 C = TypedDict('C', {'x': str, 'y': int, 'z': int})
@@ -750,68 +754,73 @@ ac = join(A(x='', y=1, z=''), C(x='', y=0, z=1))
 ab['y']  # E: "y" is not a valid TypedDict key; expected one of ("x")
 ac['a']  # E: "a" is not a valid TypedDict key; expected one of ("x", "y")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotGetItemOfTypedDictWithNonLiteralKey]
-from mypy_extensions import TypedDict
-from typing import Union
+from typing import TypedDict, Union
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p = TaggedPoint(type='2d', x=42, y=1337)
 def get_coordinate(p: TaggedPoint, key: str) -> Union[str, int]:
     return p[key]  # E: TypedDict key must be a string literal; expected one of ("type", "x", "y")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Special Method: __setitem__
 
 [case testCanSetItemOfTypedDictWithValidStringLiteralKeyAndCompatibleValueType]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p = TaggedPoint(type='2d', x=42, y=1337)
 p['type'] = 'two_d'
 p['x'] = 1
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotSetItemOfTypedDictWithIncompatibleValueType]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p = TaggedPoint(type='2d', x=42, y=1337)
 p['x'] = 'y'  # E: Value of "x" has incompatible type "str"; expected "int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotSetItemOfTypedDictWithInvalidStringLiteralKey]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p = TaggedPoint(type='2d', x=42, y=1337)
 p['z'] = 1  # E: TypedDict "TaggedPoint" has no key "z"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotSetItemOfTypedDictWithNonLiteralKey]
-from mypy_extensions import TypedDict
-from typing import Union
+from typing import TypedDict, Union
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p = TaggedPoint(type='2d', x=42, y=1337)
 def set_coordinate(p: TaggedPoint, key: str, value: int) -> None:
     p[key] = value  # E: TypedDict key must be a string literal; expected one of ("type", "x", "y")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- isinstance
 
 [case testTypedDictWithIsInstanceAndIsSubclass]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int})
 d: object
 if isinstance(d, D):   # E: Cannot use isinstance() with TypedDict type
     reveal_type(d)     # N: Revealed type is "TypedDict('__main__.D', {'x': builtins.int})"
 issubclass(object, D)  # E: Cannot use issubclass() with TypedDict type
 [builtins fixtures/isinstancelist.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Scoping
 
 [case testTypedDictInClassNamespace]
 # https://github.com/python/mypy/pull/2553#issuecomment-266474341
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class C:
     def f(self):
         A = TypedDict('A', {'x': int})
@@ -819,20 +828,21 @@ class C:
         A = TypedDict('A', {'y': int})
 C.A  # E: "Type[C]" has no attribute "A"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictInFunction]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 def f() -> None:
     A = TypedDict('A', {'x': int})
 A  # E: Name "A" is not defined
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Union simplification / proper subtype checks
 
 [case testTypedDictUnionSimplification]
-from typing import TypeVar, Union, Any, cast
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar, Union, Any, cast
 
 T = TypeVar('T')
 S = TypeVar('S')
@@ -860,10 +870,10 @@ reveal_type(u(f, c)) # N: Revealed type is "Union[TypedDict('__main__.C', {'a':
 reveal_type(u(c, g)) # N: Revealed type is "Union[TypedDict('__main__.G', {'a': Any}), TypedDict('__main__.C', {'a': builtins.int})]"
 reveal_type(u(g, c)) # N: Revealed type is "Union[TypedDict('__main__.C', {'a': builtins.int}), TypedDict('__main__.G', {'a': Any})]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictUnionSimplification2]
-from typing import TypeVar, Union, Mapping, Any
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar, Union, Mapping, Any
 
 T = TypeVar('T')
 S = TypeVar('S')
@@ -883,10 +893,10 @@ reveal_type(u(c, m_s_s)) # N: Revealed type is "Union[typing.Mapping[builtins.st
 reveal_type(u(c, m_i_i)) # N: Revealed type is "Union[typing.Mapping[builtins.int, builtins.int], TypedDict('__main__.C', {'a': builtins.int, 'b': builtins.int})]"
 reveal_type(u(c, m_s_a)) # N: Revealed type is "Union[typing.Mapping[builtins.str, Any], TypedDict('__main__.C', {'a': builtins.int, 'b': builtins.int})]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictUnionUnambiguousCase]
-from typing import Union, Mapping, Any, cast
-from typing_extensions import TypedDict, Literal
+from typing import Union, Literal, Mapping, TypedDict, Any, cast
 
 A = TypedDict('A', {'@type': Literal['a-type'], 'a': str})
 B = TypedDict('B', {'@type': Literal['b-type'], 'b': int})
@@ -894,20 +904,20 @@ B = TypedDict('B', {'@type': Literal['b-type'], 'b': int})
 c: Union[A, B] = {'@type': 'a-type', 'a': 'Test'}
 reveal_type(c) # N: Revealed type is "Union[TypedDict('__main__.A', {'@type': Literal['a-type'], 'a': builtins.str}), TypedDict('__main__.B', {'@type': Literal['b-type'], 'b': builtins.int})]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictUnionAmbiguousCaseBothMatch]
-from typing import Union, Mapping, Any, cast
-from typing_extensions import TypedDict, Literal
+from typing import Union, Literal, Mapping, TypedDict, Any, cast
 
 A = TypedDict('A', {'@type': Literal['a-type'], 'value': str})
 B = TypedDict('B', {'@type': Literal['b-type'], 'value': str})
 
 c: Union[A, B] = {'@type': 'a-type', 'value': 'Test'}
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictUnionAmbiguousCaseNoMatch]
-from typing import Union, Mapping, Any, cast
-from typing_extensions import TypedDict, Literal
+from typing import Union, Literal, Mapping, TypedDict, Any, cast
 
 A = TypedDict('A', {'@type': Literal['a-type'], 'value': int})
 B = TypedDict('B', {'@type': Literal['b-type'], 'value': int})
@@ -915,11 +925,12 @@ B = TypedDict('B', {'@type': Literal['b-type'], 'value': int})
 c: Union[A, B] = {'@type': 'a-type', 'value': 'Test'}  # E: Type of TypedDict is ambiguous, none of ("A", "B") matches cleanly \
                                                        # E: Incompatible types in assignment (expression has type "Dict[str, str]", variable has type "Union[A, B]")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 -- Use dict literals
 
 [case testTypedDictDictLiterals]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 Point = TypedDict('Point', {'x': int, 'y': int})
 
@@ -937,9 +948,10 @@ f(dict(x=1, y=3, z=4))  # E: Extra key "z" for TypedDict "Point"
 f(dict(x=1, y=3, z=4, a=5))  # E: Extra keys ("z", "a") for TypedDict "Point"
 
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictExplicitTypes]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 Point = TypedDict('Point', {'x': int, 'y': int})
 
@@ -956,10 +968,10 @@ if int():
 p4: Point = {'x': 1, 'y': 2}
 
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateAnonymousTypedDictInstanceUsingDictLiteralWithExtraItems]
-from mypy_extensions import TypedDict
-from typing import TypeVar
+from typing import TypedDict, TypeVar
 A = TypedDict('A', {'x': int, 'y': int})
 B = TypedDict('B', {'x': int, 'y': str})
 T = TypeVar('T')
@@ -968,10 +980,10 @@ ab = join(A(x=1, y=1), B(x=1, y=''))
 if int():
     ab = {'x': 1, 'z': 1} # E: Expected TypedDict key "x" but found keys ("x", "z")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateAnonymousTypedDictInstanceUsingDictLiteralWithMissingItems]
-from mypy_extensions import TypedDict
-from typing import TypeVar
+from typing import TypedDict, TypeVar
 A = TypedDict('A', {'x': int, 'y': int, 'z': int})
 B = TypedDict('B', {'x': int, 'y': int, 'z': str})
 T = TypeVar('T')
@@ -980,13 +992,13 @@ ab = join(A(x=1, y=1, z=1), B(x=1, y=1, z=''))
 if int():
     ab = {} # E: Expected TypedDict keys ("x", "y") but found no keys
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Other TypedDict methods
 
 [case testTypedDictGetMethod]
-# flags: --strict-optional
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class A: pass
 D = TypedDict('D', {'x': int, 'y': str})
 d: D
@@ -999,9 +1011,7 @@ reveal_type(d.get('y', None)) # N: Revealed type is "Union[builtins.str, None]"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictGetMethodTypeContext]
-# flags: --strict-optional
-from typing import List
-from mypy_extensions import TypedDict
+from typing import List, TypedDict
 class A: pass
 D = TypedDict('D', {'x': List[int], 'y': int})
 d: D
@@ -1013,7 +1023,7 @@ reveal_type(d.get('x', a)) # N: Revealed type is "Union[builtins.list[builtins.i
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictGetMethodInvalidArgs]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int, 'y': str})
 d: D
 d.get() # E: All overload variants of "get" of "Mapping" require at least one argument \
@@ -1033,14 +1043,15 @@ reveal_type(y) # N: Revealed type is "builtins.object"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictMissingMethod]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int, 'y': str})
 d: D
 d.bad(1) # E: "D" has no attribute "bad"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictChainedGetMethodWithDictFallback]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int, 'y': str})
 E = TypedDict('E', {'d': D})
 p = E(d=D(x=0, y=''))
@@ -1049,7 +1060,7 @@ reveal_type(p.get('d', {'x': 1, 'y': ''})) # N: Revealed type is "TypedDict('__m
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictGetDefaultParameterStillTypeChecked]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 TaggedPoint = TypedDict('TaggedPoint', {'type': str, 'x': int, 'y': int})
 p = TaggedPoint(type='2d', x=42, y=1337)
 p.get('x', 1 + 'y')     # E: Unsupported operand types for + ("int" and "str")
@@ -1057,8 +1068,7 @@ p.get('x', 1 + 'y')     # E: Unsupported operand types for + ("int" and "str")
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictChainedGetWithEmptyDictDefault]
-# flags: --strict-optional
-from mypy_extensions import TypedDict
+from typing import TypedDict
 C = TypedDict('C', {'a': int})
 D = TypedDict('D', {'x': C, 'y': str})
 d: D
@@ -1075,23 +1085,25 @@ reveal_type(d.get('x', {})['a']) # N: Revealed type is "builtins.int"
 -- Totality (the "total" keyword argument)
 
 [case testTypedDictWithTotalTrue]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int, 'y': str}, total=True)
 d: D
 reveal_type(d) \
     # N: Revealed type is "TypedDict('__main__.D', {'x': builtins.int, 'y': builtins.str})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictWithInvalidTotalArgument]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 A = TypedDict('A', {'x': int}, total=0) # E: "total" argument must be a True or False literal
 B = TypedDict('B', {'x': int}, total=bool) # E: "total" argument must be a True or False literal
 C = TypedDict('C', {'x': int}, x=False) # E: Unexpected keyword argument "x" for "TypedDict"
 D = TypedDict('D', {'x': int}, False) # E: Unexpected arguments to TypedDict()
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictWithTotalFalse]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int, 'y': str}, total=False)
 def f(d: D) -> None:
     reveal_type(d) # N: Revealed type is "TypedDict('__main__.D', {'x'?: builtins.int, 'y'?: builtins.str})"
@@ -1102,9 +1114,10 @@ f({'x': 1, 'y': ''})
 f({'x': 1, 'z': ''}) # E: Extra key "z" for TypedDict "D"
 f({'x': ''}) # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictConstructorWithTotalFalse]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 D = TypedDict('D', {'x': int, 'y': str}, total=False)
 def f(d: D) -> None: pass
 reveal_type(D()) # N: Revealed type is "TypedDict('__main__.D', {'x'?: builtins.int, 'y'?: builtins.str})"
@@ -1114,20 +1127,21 @@ f(D(x=1, y=''))
 f(D(x=1, z='')) # E: Extra key "z" for TypedDict "D"
 f(D(x='')) # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictIndexingWithNonRequiredKey]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 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]
 
 [case testTypedDictSubtypingWithTotalFalse]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 A = TypedDict('A', {'x': int})
 B = TypedDict('B', {'x': int}, total=False)
 C = TypedDict('C', {'x': int, 'y': str}, total=False)
@@ -1144,10 +1158,10 @@ fb(a) # E: Argument 1 to "fb" has incompatible type "A"; expected "B"
 fa(b) # E: Argument 1 to "fa" has incompatible type "B"; expected "A"
 fc(b) # E: Argument 1 to "fc" has incompatible type "B"; expected "C"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictJoinWithTotalFalse]
-from typing import TypeVar
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar
 A = TypedDict('A', {'x': int})
 B = TypedDict('B', {'x': int}, total=False)
 C = TypedDict('C', {'x': int, 'y': str}, total=False)
@@ -1167,18 +1181,20 @@ reveal_type(j(b, c)) \
 reveal_type(j(c, b)) \
     # N: Revealed type is "TypedDict({'x'?: builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictClassWithTotalArgument]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class D(TypedDict, total=False):
     x: int
     y: str
 d: D
 reveal_type(d) # N: Revealed type is "TypedDict('__main__.D', {'x'?: builtins.int, 'y'?: builtins.str})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictClassWithInvalidTotalArgument]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class D(TypedDict, total=1): # E: "total" argument must be a True or False literal
     x: int
 class E(TypedDict, total=bool): # E: "total" argument must be a True or False literal
@@ -1187,9 +1203,10 @@ class F(TypedDict, total=xyz): # E: Name "xyz" is not defined \
                                # E: "total" argument must be a True or False literal
     x: int
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictClassInheritanceWithTotalArgument]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class A(TypedDict):
     x: int
 class B(TypedDict, A, total=False):
@@ -1199,9 +1216,10 @@ class C(TypedDict, B, total=True):
 c: C
 reveal_type(c) # N: Revealed type is "TypedDict('__main__.C', {'x': builtins.int, 'y'?: builtins.int, 'z': builtins.str})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNonTotalTypedDictInErrorMessages]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 A = TypedDict('A', {'x': int, 'y': str}, total=False)
 B = TypedDict('B', {'x': int, 'z': str, 'a': int}, total=False)
@@ -1217,10 +1235,11 @@ f(l) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x'?: int})]"
 ll = [b, c]
 f(ll) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x'?: int, 'z'?: str})]"; expected "A"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testNonTotalTypedDictCanBeEmpty]
 # flags: --warn-unreachable
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 class A(TypedDict):
     ...
@@ -1237,70 +1256,80 @@ if not a:
 if not b:
     reveal_type(b) # N: Revealed type is "TypedDict('__main__.B', {'x'?: builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 -- Create Type (Errors)
 
 [case testCannotCreateTypedDictTypeWithTooFewArguments]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point')  # E: Too few arguments for TypedDict()
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithTooManyArguments]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int}, dict)  # E: Unexpected arguments to TypedDict()
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithInvalidName]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict(dict, {'x': int, 'y': int})  # E: TypedDict() expects a string literal as the first argument
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithInvalidItems]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x'})  # E: TypedDict() expects a dictionary literal as the second argument
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithKwargs]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 d = {'x': int, 'y': int}
 Point = TypedDict('Point', {**d})  # E: Invalid TypedDict() field name
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithBytes]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict(b'Point', {'x': int, 'y': int})  # E: TypedDict() expects a string literal as the first argument
 # This technically works at runtime but doesn't make sense.
 Point2 = TypedDict('Point2', {b'x': int})  # E: Invalid TypedDict() field name
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 -- NOTE: The following code works at runtime but is not yet supported by mypy.
 --       Keyword arguments may potentially be supported in the future.
 [case testCannotCreateTypedDictTypeWithNonpositionalArgs]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict(typename='Point', fields={'x': int, 'y': int})  # E: Unexpected arguments to TypedDict()
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithInvalidItemName]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {int: int, int: int})  # E: Invalid TypedDict() field name
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithInvalidItemType]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': 1, 'y': 1})  # E: Invalid type: try using Literal[1] instead?
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCannotCreateTypedDictTypeWithInvalidName2]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 X = TypedDict('Y', {'x': int})  # E: First argument "Y" to TypedDict() does not match variable name "X"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 
 -- Overloading
 
 [case testTypedDictOverloading]
-from typing import overload, Iterable
-from mypy_extensions import TypedDict
+from typing import overload, Iterable, TypedDict
 
 A = TypedDict('A', {'x': int})
 
@@ -1317,8 +1346,7 @@ reveal_type(f(1))  # N: Revealed type is "builtins.int"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictOverloading2]
-from typing import overload, Iterable
-from mypy_extensions import TypedDict
+from typing import overload, Iterable, TypedDict
 
 A = TypedDict('A', {'x': int})
 
@@ -1333,16 +1361,15 @@ f(a)
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 [out]
-main:13: error: Argument 1 to "f" has incompatible type "A"; expected "Iterable[int]"
-main:13: note: Following member(s) of "A" have conflicts:
-main:13: note:     Expected:
-main:13: note:         def __iter__(self) -> Iterator[int]
-main:13: note:     Got:
-main:13: note:         def __iter__(self) -> Iterator[str]
+main:12: error: Argument 1 to "f" has incompatible type "A"; expected "Iterable[int]"
+main:12: note: Following member(s) of "A" have conflicts:
+main:12: note:     Expected:
+main:12: note:         def __iter__(self) -> Iterator[int]
+main:12: note:     Got:
+main:12: note:         def __iter__(self) -> Iterator[str]
 
 [case testTypedDictOverloading3]
-from typing import overload
-from mypy_extensions import TypedDict
+from typing import TypedDict, overload
 
 A = TypedDict('A', {'x': int})
 
@@ -1361,8 +1388,7 @@ f(a)  # E: No overload variant of "f" matches argument type "A" \
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictOverloading4]
-from typing import overload
-from mypy_extensions import TypedDict
+from typing import TypedDict, overload
 
 A = TypedDict('A', {'x': int})
 B = TypedDict('B', {'x': str})
@@ -1382,8 +1408,7 @@ f(b) # E: Argument 1 to "f" has incompatible type "B"; expected "A"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictOverloading5]
-from typing import overload
-from mypy_extensions import TypedDict
+from typing import TypedDict, overload
 
 A = TypedDict('A', {'x': int})
 B = TypedDict('B', {'y': str})
@@ -1405,8 +1430,7 @@ f(c) # E: Argument 1 to "f" has incompatible type "C"; expected "A"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictOverloading6]
-from typing import overload
-from mypy_extensions import TypedDict
+from typing import TypedDict, overload
 
 A = TypedDict('A', {'x': int})
 B = TypedDict('B', {'y': str})
@@ -1428,8 +1452,7 @@ reveal_type(f(b)) # N: Revealed type is "builtins.str"
 -- Special cases
 
 [case testForwardReferenceInTypedDict]
-from typing import Mapping
-from mypy_extensions import TypedDict
+from typing import TypedDict, Mapping
 X = TypedDict('X', {'b': 'B', 'c': 'C'})
 class B: pass
 class C(B): pass
@@ -1438,10 +1461,10 @@ reveal_type(x) # N: Revealed type is "TypedDict('__main__.X', {'b': __main__.B,
 m1: Mapping[str, object] = x
 m2: Mapping[str, B] = x # E: Incompatible types in assignment (expression has type "X", variable has type "Mapping[str, B]")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testForwardReferenceInClassTypedDict]
-from typing import Mapping
-from mypy_extensions import TypedDict
+from typing import TypedDict, Mapping
 class X(TypedDict):
     b: 'B'
     c: 'C'
@@ -1452,52 +1475,53 @@ reveal_type(x) # N: Revealed type is "TypedDict('__main__.X', {'b': __main__.B,
 m1: Mapping[str, object] = x
 m2: Mapping[str, B] = x # E: Incompatible types in assignment (expression has type "X", variable has type "Mapping[str, B]")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testForwardReferenceToTypedDictInTypedDict]
-from typing import Mapping
-from mypy_extensions import TypedDict
+from typing import TypedDict, Mapping
 X = TypedDict('X', {'a': 'A'})
 A = TypedDict('A', {'b': int})
 x: X
 reveal_type(x) # N: Revealed type is "TypedDict('__main__.X', {'a': TypedDict('__main__.A', {'b': builtins.int})})"
 reveal_type(x['a']['b']) # N: Revealed type is "builtins.int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testSelfRecursiveTypedDictInheriting]
+from typing import TypedDict
 
-from mypy_extensions import TypedDict
-# flags: --disable-recursive-aliases
-class MovieBase(TypedDict):
-    name: str
-    year: int
-
-class Movie(MovieBase):
-    director: 'Movie' # E: Cannot resolve name "Movie" (possible cyclic definition)
+def test() -> None:
+    class MovieBase(TypedDict):
+        name: str
+        year: int
 
-m: Movie
-reveal_type(m['director']['name']) # N: Revealed type is "Any"
+    class Movie(MovieBase):
+        director: 'Movie' # E: Cannot resolve name "Movie" (possible cyclic definition) \
+                          # N: Recursive types are not allowed at function scope
+    m: Movie
+    reveal_type(m['director']['name']) # N: Revealed type is "Any"
 [builtins fixtures/dict.pyi]
-[out]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testSubclassOfRecursiveTypedDict]
-# flags: --disable-recursive-aliases
-from typing import List
-from mypy_extensions import TypedDict
+from typing import List, TypedDict
 
-class Command(TypedDict):
-    subcommands: List['Command']  # E: Cannot resolve name "Command" (possible cyclic definition)
+def test() -> None:
+    class Command(TypedDict):
+        subcommands: List['Command']  # E: Cannot resolve name "Command" (possible cyclic definition) \
+                                      # N: Recursive types are not allowed at function scope
 
-class HelpCommand(Command):
-    pass
+    class HelpCommand(Command):
+        pass
 
-hc = HelpCommand(subcommands=[])
-reveal_type(hc)  # N: Revealed type is "TypedDict('__main__.HelpCommand', {'subcommands': builtins.list[Any]})"
+    hc = HelpCommand(subcommands=[])
+    reveal_type(hc)  # N: Revealed type is "TypedDict('__main__.HelpCommand@7', {'subcommands': builtins.list[Any]})"
 [builtins fixtures/list.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testTypedDictForwardAsUpperBound]
-from typing import TypeVar, Generic
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar, Generic
 T = TypeVar('T', bound='M')
 class G(Generic[T]):
     x: T
@@ -1509,12 +1533,13 @@ z: int = G[M]().x['x']  # type: ignore[used-before-def]
 class M(TypedDict):
     x: int
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testTypedDictWithImportCycleForward]
 import a
 [file a.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 from b import f
 
 N = TypedDict('N', {'a': str})
@@ -1525,6 +1550,7 @@ def f(x: a.N) -> None:
     reveal_type(x)
     reveal_type(x['a'])
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 tmp/b.py:4: note: Revealed type is "TypedDict('a.N', {'a': builtins.str})"
 tmp/b.py:5: note: Revealed type is "builtins.str"
@@ -1545,14 +1571,15 @@ tp(x='no')  # E: Incompatible types (expression has type "str", TypedDict item "
 
 [file b.py]
 from a import C
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 tp = TypedDict('tp', {'x': int})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 
 [case testTypedDictAsStarStarArg]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 A = TypedDict('A', {'x': int, 'y': str})
 class B: pass
@@ -1572,11 +1599,11 @@ f4(**a) # E: Extra argument "y" from **args for "f4"
 f5(**a) # E: Missing positional arguments "y", "z" in call to "f5"
 f6(**a) # E: Extra argument "y" from **args for "f6"
 f1(1, **a) # E: "f1" gets multiple values for keyword argument "x"
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictAsStarStarArgConstraints]
-from typing import TypeVar, Union
-from mypy_extensions import TypedDict
+from typing import TypedDict, TypeVar, Union
 
 T = TypeVar('T')
 S = TypeVar('S')
@@ -1585,10 +1612,11 @@ def f1(x: T, y: S) -> Union[T, S]: ...
 A = TypedDict('A', {'y': int, 'x': str})
 a: A
 reveal_type(f1(**a)) # N: Revealed type is "Union[builtins.str, builtins.int]"
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictAsStarStarArgCalleeKwargs]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 A = TypedDict('A', {'x': int, 'y': str})
 B = TypedDict('B', {'x': str, 'y': str})
@@ -1606,9 +1634,10 @@ g(1, **a) # E: "g" gets multiple values for keyword argument "x"
 g(1, **b) # E: "g" gets multiple values for keyword argument "x" \
           # E: Argument "x" to "g" has incompatible type "str"; expected "int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictAsStarStarTwice]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 A = TypedDict('A', {'x': int, 'y': str})
 B = TypedDict('B', {'z': bytes})
@@ -1630,11 +1659,11 @@ f1(**a, **c) # E: "f1" gets multiple values for keyword argument "x" \
              # E: Argument "x" to "f1" has incompatible type "str"; expected "int"
 f1(**c, **a) # E: "f1" gets multiple values for keyword argument "x" \
              # E: Argument "x" to "f1" has incompatible type "str"; expected "int"
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictAsStarStarAndDictAsStarStar]
-from mypy_extensions import TypedDict
-from typing import Any, Dict
+from typing import Any, Dict, TypedDict
 
 TD = TypedDict('TD', {'x': int, 'y': str})
 
@@ -1642,17 +1671,17 @@ 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)
 f2(**td, **d)
 f2(**d, **td)
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictNonMappingMethods]
-from typing import List
-from mypy_extensions import TypedDict
+from typing import List, TypedDict
 
 A = TypedDict('A', {'x': int, 'y': List[int]})
 a: A
@@ -1669,7 +1698,7 @@ a.setdefault('y', '') # E: Argument 2 to "setdefault" of "TypedDict" has incompa
 x = ''
 a.setdefault(x, 1) # E: Expected TypedDict key to be string literal
 alias = a.setdefault
-alias(x, 1) # E: Argument 1 has incompatible type "str"; expected "NoReturn"
+alias(x, 1) # E: Argument 1 has incompatible type "str"; expected "Never"
 
 a.update({})
 a.update({'x': 1})
@@ -1682,10 +1711,10 @@ a.update({'z': 1, 'x': 1}) # E: Expected TypedDict key "x" but found keys ("z",
 d = {'x': 1}
 a.update(d) # E: Argument 1 to "update" of "TypedDict" has incompatible type "Dict[str, int]"; expected "TypedDict({'x'?: int, 'y'?: List[int]})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictPopMethod]
-from typing import List
-from mypy_extensions import TypedDict
+from typing import List, TypedDict
 
 A = TypedDict('A', {'x': int, 'y': List[int]}, total=False)
 B = TypedDict('B', {'x': int})
@@ -1701,13 +1730,13 @@ b.pop('x') # E: Key "x" of TypedDict "B" cannot be deleted
 x = ''
 b.pop(x) # E: Expected TypedDict key to be string literal
 pop = b.pop
-pop('x') # E: Argument 1 has incompatible type "str"; expected "NoReturn"
-pop('invalid') # E: Argument 1 has incompatible type "str"; expected "NoReturn"
+pop('x') # E: Argument 1 has incompatible type "str"; expected "Never"
+pop('invalid') # E: Argument 1 has incompatible type "str"; expected "Never"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictDel]
-from typing import List
-from mypy_extensions import TypedDict
+from typing import List, TypedDict
 
 A = TypedDict('A', {'x': int, 'y': List[int]}, total=False)
 B = TypedDict('B', {'x': int})
@@ -1724,10 +1753,10 @@ alias = b.__delitem__
 alias('x')
 alias(s)
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testPluginUnionsOfTypedDicts]
-from typing import Union
-from mypy_extensions import TypedDict
+from typing import TypedDict, Union
 
 class TDA(TypedDict):
     a: int
@@ -1740,8 +1769,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"
@@ -1752,8 +1781,7 @@ reveal_type(td['c'])  # N: Revealed type is "Union[Any, builtins.int]" \
 [typing fixtures/typing-typeddict.pyi]
 
 [case testPluginUnionsOfTypedDictsNonTotal]
-from typing import Union
-from mypy_extensions import TypedDict
+from typing import TypedDict, Union
 
 class TDA(TypedDict, total=False):
     a: int
@@ -1768,13 +1796,13 @@ td: Union[TDA, TDB]
 
 reveal_type(td.pop('a'))  # N: Revealed type is "builtins.int"
 reveal_type(td.pop('b'))  # N: Revealed type is "Union[builtins.str, builtins.int]"
-reveal_type(td.pop('c'))  # E: TypedDict "TDA" has no key "c" \
-                          # N: Revealed type is "Union[Any, builtins.int]"
+reveal_type(td.pop('c'))  # N: Revealed type is "Union[Any, builtins.int]" \
+                          # E: TypedDict "TDA" has no key "c"
+
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictWithTypingExtensions]
-# flags: --python-version 3.6
 from typing_extensions import TypedDict
 
 class Point(TypedDict):
@@ -1784,9 +1812,9 @@ class Point(TypedDict):
 p = Point(x=42, y=1337)
 reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtins.int, 'y': builtins.int})"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testCanCreateTypedDictWithTypingProper]
-# flags: --python-version 3.8
 from typing import TypedDict
 
 class Point(TypedDict):
@@ -1799,15 +1827,15 @@ reveal_type(p)  # N: Revealed type is "TypedDict('__main__.Point', {'x': builtin
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictOptionalUpdate]
-from typing import Union
-from mypy_extensions import TypedDict
+from typing import TypedDict, Union
 
 class A(TypedDict):
     x: int
 
-d: Union[A, None]
+d: A
 d.update({'x': 1})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictOverlapWithDict]
 # mypy: strict-equality
@@ -1878,7 +1906,7 @@ class Config(TypedDict):
     b: str
 
 x: Config
-x == {}  # E: Non-overlapping equality check (left operand type: "Config", right operand type: "Dict[<nothing>, <nothing>]")
+x == {}  # E: Non-overlapping equality check (left operand type: "Config", right operand type: "Dict[Never, Never]")
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
@@ -2038,8 +2066,7 @@ v = {bad2: 2}  # E: Missing key "num" for TypedDict "Value" \
 
 [case testOperatorContainsNarrowsTypedDicts_unionWithList]
 from __future__ import annotations
-from typing import assert_type, TypedDict, Union
-from typing_extensions import final
+from typing import assert_type, final, TypedDict, Union
 
 @final
 class D(TypedDict):
@@ -2056,12 +2083,11 @@ else:
     assert_type(d_or_list, list[str])
 
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-typeddict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testOperatorContainsNarrowsTypedDicts_total]
 from __future__ import annotations
-from typing import assert_type, Literal, TypedDict, TypeVar, Union
-from typing_extensions import final
+from typing import assert_type, final, Literal, TypedDict, TypeVar, Union
 
 @final
 class D1(TypedDict):
@@ -2107,13 +2133,12 @@ def f(arg: TD) -> None:
 
 
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-typeddict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testOperatorContainsNarrowsTypedDicts_final]
 # flags: --warn-unreachable
 from __future__ import annotations
-from typing import assert_type, TypedDict, Union
-from typing_extensions import final
+from typing import assert_type, final, TypedDict, Union
 
 @final
 class DFinal(TypedDict):
@@ -2151,12 +2176,11 @@ else:
     assert_type(d_union, DNotFinal)
 
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-typeddict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testOperatorContainsNarrowsTypedDicts_partialThroughTotalFalse]
 from __future__ import annotations
-from typing import assert_type, Literal, TypedDict, Union
-from typing_extensions import final
+from typing import assert_type, final, Literal, TypedDict, Union
 
 @final
 class DTotal(TypedDict):
@@ -2187,12 +2211,12 @@ else:
     assert_type(d, Union[DTotal, DNotTotal])
 
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-typeddict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testOperatorContainsNarrowsTypedDicts_partialThroughNotRequired]
 from __future__ import annotations
-from typing import assert_type, Required, NotRequired, TypedDict, Union
-from typing_extensions import final
+from typing import assert_type, final, TypedDict, Union
+from typing_extensions import Required, NotRequired
 
 @final
 class D1(TypedDict):
@@ -2219,11 +2243,10 @@ else:
     assert_type(d, Union[D1, D2])
 
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-typeddict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testCannotSubclassFinalTypedDict]
-from typing import TypedDict
-from typing_extensions import final
+from typing import TypedDict, final
 
 @final
 class DummyTypedDict(TypedDict):
@@ -2235,11 +2258,10 @@ class SubType(DummyTypedDict): # E: Cannot inherit from final class "DummyTypedD
     pass
 
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-typeddict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testCannotSubclassFinalTypedDictWithForwardDeclarations]
-from typing import TypedDict
-from typing_extensions import final
+from typing import TypedDict, final
 
 @final
 class DummyTypedDict(TypedDict):
@@ -2251,7 +2273,7 @@ class SubType(DummyTypedDict): # E: Cannot inherit from final class "DummyTypedD
 class ForwardDeclared: pass
 
 [builtins fixtures/dict.pyi]
-[typing fixtures/typing-typeddict.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testTypedDictTypeNarrowingWithFinalKey]
 from typing import Final, Optional, TypedDict
@@ -2271,8 +2293,7 @@ if foo[KEY_NAME] is not None:
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictDoubleForwardClass]
-from mypy_extensions import TypedDict
-from typing import Any, List
+from typing import Any, List, TypedDict
 
 class Foo(TypedDict):
     bar: Bar
@@ -2287,8 +2308,7 @@ reveal_type(foo['baz'])  # N: Revealed type is "builtins.list[Any]"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictDoubleForwardFunc]
-from mypy_extensions import TypedDict
-from typing import Any, List
+from typing import Any, List, TypedDict
 
 Foo = TypedDict('Foo', {'bar': 'Bar', 'baz': 'Bar'})
 
@@ -2301,8 +2321,7 @@ reveal_type(foo['baz'])  # N: Revealed type is "builtins.list[Any]"
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictDoubleForwardMixed]
-from mypy_extensions import TypedDict
-from typing import Any, List
+from typing import Any, List, TypedDict
 
 Bar = List[Any]
 
@@ -2379,11 +2398,42 @@ d[True] # E: TypedDict key must be a string literal; expected one of ("foo")
 [typing fixtures/typing-typeddict.pyi]
 
 [case testTypedDictUppercaseKey]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 
 Foo = TypedDict('Foo', {'camelCaseKey': str})
 value: Foo = {}  # E: Missing key "camelCaseKey" for TypedDict "Foo"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictWithDeferredFieldTypeEval]
+from typing import Generic, TypeVar, TypedDict, NotRequired
+
+class Foo(TypedDict):
+    y: NotRequired[int]
+    x: Outer[Inner[ForceDeferredEval]]
+
+var: Foo
+reveal_type(var)  # N: Revealed type is "TypedDict('__main__.Foo', {'y'?: builtins.int, 'x': __main__.Outer[__main__.Inner[__main__.ForceDeferredEval]]})"
+
+T1 = TypeVar("T1")
+class Outer(Generic[T1]): pass
+
+T2 = TypeVar("T2", bound="ForceDeferredEval")
+class Inner(Generic[T2]): pass
+
+class ForceDeferredEval: pass
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictRequiredUnimportedAny]
+# flags: --disallow-any-unimported
+from typing import NotRequired, TypedDict, ReadOnly
+from nonexistent import Foo  # type: ignore[import-not-found]
+class Bar(TypedDict):
+    foo: NotRequired[Foo]  # E: Type of variable becomes "Any" due to an unfollowed import
+    bar: ReadOnly[Foo]  # E: Type of variable becomes "Any" due to an unfollowed import
+    baz: NotRequired[ReadOnly[Foo]]  # E: Type of variable becomes "Any" due to an unfollowed import
+[typing fixtures/typing-typeddict.pyi]
 
 -- Required[]
 
@@ -2607,8 +2657,9 @@ def func(foo: Union[Foo1, Foo2]):
 
     del foo["missing"]  # E: TypedDict "Foo1" has no key "missing" \
                         # E: TypedDict "Foo2" has no key "missing"
-    del foo[1]  # E: Expected TypedDict key to be string literal \
-                # E: Argument 1 to "__delitem__" has incompatible type "int"; expected "str"
+    del foo[1]  # E: Argument 1 to "__delitem__" has incompatible type "int"; expected "str" \
+                # E: Expected TypedDict key to be string literal
+
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
@@ -2730,7 +2781,7 @@ class TD(TypedDict):
 reveal_type(TD.__iter__)  # N: Revealed type is "def (typing._TypedDict) -> typing.Iterator[builtins.str]"
 reveal_type(TD.__annotations__)  # N: Revealed type is "typing.Mapping[builtins.str, builtins.object]"
 reveal_type(TD.values)  # N: Revealed type is "def (self: typing.Mapping[T`1, T_co`2]) -> typing.Iterable[T_co`2]"
-[builtins fixtures/dict.pyi]
+[builtins fixtures/dict-full.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
 [case testGenericTypedDictAlias]
@@ -2873,3 +2924,1333 @@ 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 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]
+
+[case testTypedDictFlexibleUpdate]
+from typing 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 typing 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 TypedDict, Union
+
+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 TypedDict, Union
+
+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 TypedDict, Union, NotRequired
+
+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 overridden
+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 typing 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]
+
+[case testTypedDictUnpackError]
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+
+def foo(x: int) -> Foo: ...
+
+f: Foo = {**foo("no")}  # E: Argument 1 to "foo" has incompatible type "str"; expected "int"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+
+[case testTypedDictWith__or__method]
+from typing import Dict, TypedDict
+
+class Foo(TypedDict):
+    key: int
+
+foo1: Foo = {'key': 1}
+foo2: Foo = {'key': 2}
+
+reveal_type(foo1 | foo2)  # N: Revealed type is "TypedDict('__main__.Foo', {'key': builtins.int})"
+reveal_type(foo1 | {'key': 1})  # N: Revealed type is "TypedDict('__main__.Foo', {'key': builtins.int})"
+reveal_type(foo1 | {'key': 'a'})  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+reveal_type(foo1 | {})  # N: Revealed type is "TypedDict('__main__.Foo', {'key': builtins.int})"
+
+d1: Dict[str, int]
+d2: Dict[int, str]
+
+reveal_type(foo1 | d1)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+foo1 | d2  # E: Unsupported operand types for | ("Foo" and "Dict[int, str]")
+
+
+class Bar(TypedDict):
+    key: int
+    value: str
+
+bar: Bar
+reveal_type(bar | {})  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type(bar | {'key': 1, 'value': 'v'})  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type(bar | {'key': 1})  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type(bar | {'value': 'v'})  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type(bar | {'key': 'a'})  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+reveal_type(bar | {'value': 1})  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+reveal_type(bar | {'key': 'a', 'value': 1})  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+
+reveal_type(bar | foo1)  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type(bar | d1)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+bar | d2  # E: Unsupported operand types for | ("Bar" and "Dict[int, str]")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict-iror.pyi]
+
+[case testTypedDictWith__or__method_error]
+from typing import TypedDict
+
+class Foo(TypedDict):
+    key: int
+
+foo: Foo = {'key': 1}
+foo | 1
+
+class SubDict(dict): ...
+foo | SubDict()
+[out]
+main:7: error: No overload variant of "__or__" of "TypedDict" matches argument type "int"
+main:7: note: Possible overload variants:
+main:7: note:     def __or__(self, TypedDict({'key'?: int}), /) -> Foo
+main:7: note:     def __or__(self, Dict[str, Any], /) -> Dict[str, object]
+main:10: error: No overload variant of "__ror__" of "dict" matches argument type "Foo"
+main:10: note: Possible overload variants:
+main:10: note:     def __ror__(self, Dict[Any, Any], /) -> Dict[Any, Any]
+main:10: note:     def [T, T2] __ror__(self, Dict[T, T2], /) -> Dict[Union[Any, T], Union[Any, T2]]
+[builtins fixtures/dict-full.pyi]
+[typing fixtures/typing-typeddict-iror.pyi]
+
+[case testTypedDictWith__ror__method]
+from typing import Dict, TypedDict
+
+class Foo(TypedDict):
+    key: int
+
+foo: Foo = {'key': 1}
+
+reveal_type({'key': 1} | foo)  # N: Revealed type is "TypedDict('__main__.Foo', {'key': builtins.int})"
+reveal_type({'key': 'a'} | foo)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+reveal_type({} | foo)  # N: Revealed type is "TypedDict('__main__.Foo', {'key': builtins.int})"
+{1: 'a'} | foo  # E: Dict entry 0 has incompatible type "int": "str"; expected "str": "Any"
+
+d1: Dict[str, int]
+d2: Dict[int, str]
+
+reveal_type(d1 | foo)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+d2 | foo  # E: Unsupported operand types for | ("Dict[int, str]" and "Foo")
+1 | foo  # E: Unsupported left operand type for | ("int")
+
+
+class Bar(TypedDict):
+    key: int
+    value: str
+
+bar: Bar
+reveal_type({} | bar)  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type({'key': 1, 'value': 'v'} | bar)  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type({'key': 1} | bar)  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type({'value': 'v'} | bar)  # N: Revealed type is "TypedDict('__main__.Bar', {'key': builtins.int, 'value': builtins.str})"
+reveal_type({'key': 'a'} | bar)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+reveal_type({'value': 1} | bar)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+reveal_type({'key': 'a', 'value': 1} | bar)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+
+reveal_type(d1 | bar)  # N: Revealed type is "builtins.dict[builtins.str, builtins.object]"
+d2 | bar  # E: Unsupported operand types for | ("Dict[int, str]" and "Bar")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict-iror.pyi]
+
+[case testTypedDictWith__ior__method]
+from typing import Dict, TypedDict
+
+class Foo(TypedDict):
+    key: int
+
+foo: Foo = {'key': 1}
+foo |= {'key': 2}
+
+foo |= {}
+foo |= {'key': 'a', 'b': 'a'}  # E: Expected TypedDict key "key" but found keys ("key", "b")  \
+                               # E: Incompatible types (expression has type "str", TypedDict item "key" has type "int")
+foo |= {'b': 2}  # E: Unexpected TypedDict key "b"
+
+d1: Dict[str, int]
+d2: Dict[int, str]
+
+foo |= d1  # E: Argument 1 to "__ior__" of "TypedDict" has incompatible type "Dict[str, int]"; expected "TypedDict({'key'?: int})"
+foo |= d2  # E: Argument 1 to "__ior__" of "TypedDict" has incompatible type "Dict[int, str]"; expected "TypedDict({'key'?: int})"
+
+
+class Bar(TypedDict):
+    key: int
+    value: str
+
+bar: Bar
+bar |= {}
+bar |= {'key': 1, 'value': 'a'}
+bar |= {'key': 'a', 'value': 'a', 'b': 'a'}  # E: Expected TypedDict keys ("key", "value") but found keys ("key", "value", "b") \
+                                             # E: Incompatible types (expression has type "str", TypedDict item "key" has type "int")
+
+bar |= foo
+bar |= d1  # E: Argument 1 to "__ior__" of "TypedDict" has incompatible type "Dict[str, int]"; expected "TypedDict({'key'?: int, 'value'?: str})"
+bar |= d2  # E: Argument 1 to "__ior__" of "TypedDict" has incompatible type "Dict[int, str]"; expected "TypedDict({'key'?: int, 'value'?: str})"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict-iror.pyi]
+
+[case testGenericTypedDictStrictOptionalExtending]
+from typing import Generic, TypeVar, TypedDict, Optional
+
+T = TypeVar("T")
+class Foo(TypedDict, Generic[T], total=False):
+    a: Optional[str]
+    g: Optional[T]
+
+class Bar(Foo[T], total=False):
+    other: str
+
+b: Bar[int]
+reveal_type(b["a"])  # N: Revealed type is "Union[builtins.str, None]"
+reveal_type(b["g"])  # N: Revealed type is "Union[builtins.int, None]"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testNoCrashOnUnImportedAnyNotRequired]
+# flags: --disallow-any-unimported
+from typing import NotRequired, Required, TypedDict
+from thismoduledoesntexist import T  # type: ignore[import]
+
+B = TypedDict("B", {  # E: Type of a TypedDict key becomes "Any" due to an unfollowed import
+    "T1": NotRequired[T],
+    "T2": Required[T],
+})
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictWithClassLevelKeywords]
+from typing import TypedDict, Generic, TypeVar
+
+T = TypeVar('T')
+
+class Meta(type): ...
+
+class WithMetaKeyword(TypedDict, metaclass=Meta):  # E: Unexpected keyword argument "metaclass" for "__init_subclass__" of "TypedDict"
+    ...
+
+class GenericWithMetaKeyword(TypedDict, Generic[T], metaclass=Meta):  # E: Unexpected keyword argument "metaclass" for "__init_subclass__" of "TypedDict"
+    ...
+
+# We still don't allow this, because the implementation is much easier
+# and it does not make any practical sense to do it:
+class WithTypeMeta(TypedDict, metaclass=type):  # E: Unexpected keyword argument "metaclass" for "__init_subclass__" of "TypedDict"
+    ...
+
+class OtherKeywords(TypedDict, a=1, b=2, c=3, total=True):  # E: Unexpected keyword argument "a" for "__init_subclass__" of "TypedDict" \
+                                                            # E: Unexpected keyword argument "b" for "__init_subclass__" of "TypedDict" \
+                                                            # E: Unexpected keyword argument "c" for "__init_subclass__" of "TypedDict"
+    ...
+
+class TotalInTheMiddle(TypedDict, a=1, total=True, b=2, c=3):  # E: Unexpected keyword argument "a" for "__init_subclass__" of "TypedDict" \
+                                                            # E: Unexpected keyword argument "b" for "__init_subclass__" of "TypedDict" \
+                                                            # E: Unexpected keyword argument "c" for "__init_subclass__" of "TypedDict"
+    ...
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testCanCreateClassWithFunctionBasedTypedDictBase]
+from typing import TypedDict
+
+class Params(TypedDict("Params", {'x': int})):
+    pass
+
+p: Params = {'x': 2}
+reveal_type(p) # N: Revealed type is "TypedDict('__main__.Params', {'x': builtins.int})"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testInitTypedDictFromType]
+from typing import TypedDict, Type
+from typing_extensions import Required
+
+class Point(TypedDict, total=False):
+    x: Required[int]
+    y: int
+
+def func(cls: Type[Point]) -> None:
+    reveal_type(cls)  # N: Revealed type is "Type[TypedDict('__main__.Point', {'x': builtins.int, 'y'?: builtins.int})]"
+    cls(x=1, y=2)
+    cls(1, 2)  # E: Too many positional arguments
+    cls(x=1)
+    cls(y=2)  # E: Missing named argument "x"
+    cls(x=1, y=2, error="")  # E: Unexpected keyword argument "error"
+[typing fixtures/typing-full.pyi]
+[builtins fixtures/tuple.pyi]
+
+[case testInitTypedDictFromTypeGeneric]
+from typing import Generic, TypedDict, Type, TypeVar
+from typing_extensions import Required
+
+class Point(TypedDict, total=False):
+    x: Required[int]
+    y: int
+
+T = TypeVar("T", bound=Point)
+
+class A(Generic[T]):
+    def __init__(self, a: Type[T]) -> None:
+        self.a = a
+
+    def func(self) -> T:
+        reveal_type(self.a)  # N: Revealed type is "Type[T`1]"
+        self.a(x=1, y=2)
+        self.a(y=2)  # E: Missing named argument "x"
+        return self.a(x=1)
+[typing fixtures/typing-full.pyi]
+[builtins fixtures/tuple.pyi]
+
+[case testNameUndefinedErrorDoesNotLoseUnpackedKWArgsInformation]
+from typing import TypedDict, overload
+from typing_extensions import Unpack
+
+class TD(TypedDict, total=False):
+    x: int
+    y: str
+
+@overload
+def f(self, *, x: int) -> None: ...
+@overload
+def f(self, *, y: str) -> None: ...
+def f(self, **kwargs: Unpack[TD]) -> None:
+    z  # E: Name "z" is not defined
+
+@overload
+def g(self, *, x: float) -> None: ...
+@overload
+def g(self, *, y: str) -> None: ...
+def g(self, **kwargs: Unpack[TD]) -> None:  # E: Overloaded function implementation does not accept all possible arguments of signature 1
+    z  # E: Name "z" is not defined
+
+class A:
+    def f(self, *, x: int) -> None: ...
+    def g(self, *, x: float) -> None: ...
+class B(A):
+    def f(self, **kwargs: Unpack[TD]) -> None:
+        z  # E: Name "z" is not defined
+    def g(self, **kwargs: Unpack[TD]) -> None:  # E: Signature of "g" incompatible with supertype "A" \
+                                                # N:      Superclass: \
+                                                # N:          def g(self, *, x: float) -> None \
+                                                # N:      Subclass: \
+                                                # N:          def g(*, x: int = ..., y: str = ...) -> None
+        z  # E: Name "z" is not defined
+reveal_type(B.f)  # N: Revealed type is "def (self: __main__.B, **kwargs: Unpack[TypedDict('__main__.TD', {'x'?: builtins.int, 'y'?: builtins.str})])"
+B().f(x=1.0)  # E: Argument "x" to "f" of "B" has incompatible type "float"; expected "int"
+[builtins fixtures/primitives.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackWithParamSpecInference]
+from typing import TypedDict, TypeVar, ParamSpec, Callable
+from typing_extensions import Unpack
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+def run(func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R: ...
+
+class Params(TypedDict):
+    temperature: float
+
+def test(temperature: int) -> None: ...
+def test2(temperature: float, other: str) -> None: ...
+
+class Test:
+    def f(self, c: Callable[..., None], **params: Unpack[Params]) -> None:
+        run(c, **params)
+    def g(self, **params: Unpack[Params]) -> None:
+        run(test, **params)  # E: Argument "temperature" to "run" has incompatible type "float"; expected "int"
+    def h(self, **params: Unpack[Params]) -> None:
+        run(test2, other="yes", **params)
+        run(test2, other=0, **params)  # E: Argument "other" to "run" has incompatible type "int"; expected "str"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypedDictUnpackSingleWithSubtypingNoCrash]
+from typing import Callable, TypedDict
+from typing_extensions import Unpack
+
+class Kwargs(TypedDict):
+    name: str
+
+def f(**kwargs: Unpack[Kwargs]) -> None:
+    pass
+
+class C:
+    d: Callable[[Unpack[Kwargs]], None]
+
+# TODO: it is an old question whether we should allow this, for now simply don't crash.
+class D(C):
+    d = f
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictInlineNoOldStyleAlias]
+# flags: --enable-incomplete-feature=InlineTypedDict
+X = {"int": int, "str": str}
+reveal_type(X)  # N: Revealed type is "builtins.dict[builtins.str, def () -> builtins.object]"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictInlineYesMidStyleAlias]
+# flags: --enable-incomplete-feature=InlineTypedDict
+from typing_extensions import TypeAlias
+X: TypeAlias = {"int": int, "str": str}
+x: X
+reveal_type(x)  # N:  # N: Revealed type is "TypedDict({'int': builtins.int, 'str': builtins.str})"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictInlineNoEmpty]
+# flags: --enable-incomplete-feature=InlineTypedDict
+x: {}  # E: Invalid type comment or annotation
+reveal_type(x)  # N: Revealed type is "Any"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictInlineNotRequired]
+# flags: --enable-incomplete-feature=InlineTypedDict
+from typing import NotRequired
+
+x: {"one": int, "other": NotRequired[int]}
+x = {"one": 1}  # OK
+y: {"one": int, "other": int}
+y = {"one": 1}  # E: Expected TypedDict keys ("one", "other") but found only key "one"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictInlineReadOnly]
+# flags: --enable-incomplete-feature=InlineTypedDict
+from typing import ReadOnly
+
+x: {"one": int, "other": ReadOnly[int]}
+x["one"] = 1  # ok
+x["other"] = 1  # E: ReadOnly TypedDict key "other" TypedDict is mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictInlineNestedSchema]
+# flags: --enable-incomplete-feature=InlineTypedDict
+def nested() -> {"one": str, "other": {"a": int, "b": int}}:
+    if bool():
+        return {"one": "yes", "other": {"a": 1, "b": 2}}  # OK
+    else:
+        return {"one": "no", "other": {"a": 1, "b": "2"}}  # E: Incompatible types (expression has type "str", TypedDict item "b" has type "int")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictInlineMergeAnother]
+# flags: --enable-incomplete-feature=InlineTypedDict
+from typing import TypeVar
+from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+X: TypeAlias = {"item": T}
+x: {"a": int, **X[str], "b": int}
+reveal_type(x)  # N: Revealed type is "TypedDict({'a': builtins.int, 'b': builtins.int, 'item': builtins.str})"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-full.pyi]
+
+
+# ReadOnly
+# See: https://peps.python.org/pep-0705
+
+[case testTypedDictReadOnly]
+# flags: --show-error-codes
+from typing import ReadOnly, TypedDict
+
+class TP(TypedDict):
+    one: int
+    other: ReadOnly[str]
+
+x: TP
+reveal_type(x["one"])   # N: Revealed type is "builtins.int"
+reveal_type(x["other"]) # N: Revealed type is "builtins.str"
+x["one"] = 1  # ok
+x["other"] = "a"  # E: ReadOnly TypedDict key "other" TypedDict is mutated  [typeddict-readonly-mutated]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyCreation]
+from typing import ReadOnly, TypedDict
+
+class TD(TypedDict):
+    x: ReadOnly[int]
+    y: int
+
+# Ok:
+x = TD({"x": 1, "y": 2})
+y = TD(x=1, y=2)
+z: TD = {"x": 1, "y": 2}
+
+# Error:
+x2 = TD({"x": "a", "y": 2})  # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
+y2 = TD(x="a", y=2)          # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
+z2: TD = {"x": "a", "y": 2}  # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyDel]
+from typing import ReadOnly, TypedDict, NotRequired
+
+class TP(TypedDict):
+    required_key: ReadOnly[str]
+    optional_key: ReadOnly[NotRequired[str]]
+
+x: TP
+del x["required_key"]  # E: Key "required_key" of TypedDict "TP" cannot be deleted
+del x["optional_key"]  # E: Key "optional_key" of TypedDict "TP" cannot be deleted
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyMutateMethods]
+from typing import ReadOnly, TypedDict
+
+class TP(TypedDict):
+    key: ReadOnly[str]
+    other: ReadOnly[int]
+    mutable: bool
+
+x: TP
+reveal_type(x.pop("key"))  # N: Revealed type is "builtins.str" \
+                           # E: Key "key" of TypedDict "TP" cannot be deleted
+
+
+x.update({"key": "abc", "other": 1, "mutable": True})  # E: ReadOnly TypedDict keys ("key", "other") TypedDict are mutated
+x.setdefault("key", "abc")  # E: ReadOnly TypedDict key "key" TypedDict is mutated
+x.setdefault("other", 1)  # E: ReadOnly TypedDict key "other" TypedDict is mutated
+x.setdefault("mutable", False)  # ok
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictFromTypingExtensionsReadOnlyMutateMethods]
+from typing_extensions import ReadOnly, TypedDict
+
+class TP(TypedDict):
+    key: ReadOnly[str]
+
+x: TP
+x.update({"key": "abc"})  # E: ReadOnly TypedDict key "key" TypedDict is mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictFromMypyExtensionsReadOnlyMutateMethods]
+from mypy_extensions import TypedDict
+from typing_extensions import ReadOnly
+
+class TP(TypedDict):
+    key: ReadOnly[str]
+
+x: TP
+x.update({"key": "abc"})  # E: ReadOnly TypedDict key "key" TypedDict is mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyMutate__ior__Statements]
+from typing import TypedDict
+from typing_extensions import ReadOnly
+
+class TP(TypedDict):
+    key: ReadOnly[str]
+    other: ReadOnly[int]
+    mutable: bool
+
+x: TP
+x |= {"mutable": True}  # ok
+x |= {"key": "a"}  # E: ReadOnly TypedDict key "key" TypedDict is mutated
+x |= {"key": "a", "other": 1, "mutable": True}  # E: ReadOnly TypedDict keys ("key", "other") TypedDict are mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict-iror.pyi]
+
+[case testTypedDictReadOnlyMutate__or__Statements]
+from typing import TypedDict
+from typing_extensions import ReadOnly
+
+class TP(TypedDict):
+    key: ReadOnly[str]
+    other: ReadOnly[int]
+    mutable: bool
+
+x: TP
+# These are new objects, not mutation:
+x = x | {"mutable": True}
+x = x | {"key": "a"}
+x = x | {"key": "a", "other": 1, "mutable": True}
+y1 = x | {"mutable": True}
+y2 = x | {"key": "a"}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict-iror.pyi]
+
+[case testTypedDictReadOnlyMutateWithOtherDicts]
+from typing import ReadOnly, TypedDict, Dict
+
+class TP(TypedDict):
+    key: ReadOnly[str]
+    mutable: bool
+
+class Mutable(TypedDict):
+    mutable: bool
+
+class Regular(TypedDict):
+    key: str
+
+m: Mutable
+r: Regular
+d: Dict[str, object]
+
+# Creating new objects is ok:
+tp: TP = {**r, **m}
+tp1: TP = {**tp, **m}
+tp2: TP = {**r, **m}
+tp3: TP = {**tp, **r}
+tp4: TP = {**tp, **d}  # E: Unsupported type "Dict[str, object]" for ** expansion in TypedDict
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictGenericReadOnly]
+from typing import ReadOnly, TypedDict, TypeVar, Generic
+
+T = TypeVar('T')
+
+class TP(TypedDict, Generic[T]):
+    key: ReadOnly[T]
+
+x: TP[int]
+reveal_type(x["key"])   # N: Revealed type is "builtins.int"
+x["key"] = 1  # E: ReadOnly TypedDict key "key" TypedDict is mutated
+x["key"] = "a"  # E: ReadOnly TypedDict key "key" TypedDict is mutated \
+                # E: Value of "key" has incompatible type "str"; expected "int"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyOtherTypedDict]
+from typing import ReadOnly, TypedDict
+
+class First(TypedDict):
+    field: int
+
+class TP(TypedDict):
+    key: ReadOnly[First]
+
+x: TP
+reveal_type(x["key"]["field"])   # N: Revealed type is "builtins.int"
+x["key"]["field"] = 1  # ok
+x["key"] = {"field": 2}  # E: ReadOnly TypedDict key "key" TypedDict is mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyInheritance]
+from typing import ReadOnly, TypedDict
+
+class Base(TypedDict):
+    a: ReadOnly[str]
+
+class Child(Base):
+    b: ReadOnly[int]
+
+base: Base
+reveal_type(base["a"])   # N: Revealed type is "builtins.str"
+base["a"] = "x"  # E: ReadOnly TypedDict key "a" TypedDict is mutated
+base["b"]  # E: TypedDict "Base" has no key "b"
+
+child: Child
+reveal_type(child["a"])   # N: Revealed type is "builtins.str"
+reveal_type(child["b"])   # N: Revealed type is "builtins.int"
+child["a"] = "x"  # E: ReadOnly TypedDict key "a" TypedDict is mutated
+child["b"] = 1  # E: ReadOnly TypedDict key "b" TypedDict is mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlySubtyping]
+from typing import ReadOnly, TypedDict
+
+class A(TypedDict):
+    key: ReadOnly[str]
+
+class B(TypedDict):
+    key: str
+
+a: A
+b: B
+
+def accepts_A(d: A): ...
+def accepts_B(d: B): ...
+
+accepts_A(a)
+accepts_A(b)
+accepts_B(a)  # E: Argument 1 to "accepts_B" has incompatible type "A"; expected "B"
+accepts_B(b)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictRequiredConsistentWithNotRequiredReadOnly]
+from typing import NotRequired, ReadOnly, Required, TypedDict
+
+class A(TypedDict):
+    x: NotRequired[ReadOnly[str]]
+
+class B(TypedDict):
+    x: Required[str]
+
+def f(b: B):
+    a: A = b  # ok
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyCall]
+from typing import ReadOnly, TypedDict
+
+TP = TypedDict("TP", {"one": int, "other": ReadOnly[str]})
+
+x: TP
+reveal_type(x["one"])   # N: Revealed type is "builtins.int"
+reveal_type(x["other"]) # N: Revealed type is "builtins.str"
+x["one"] = 1  # ok
+x["other"] = "a"  # E: ReadOnly TypedDict key "other" TypedDict is mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyABCSubtypes]
+from typing import ReadOnly, TypedDict, Mapping, Dict, MutableMapping
+
+class TP(TypedDict):
+    one: int
+    other: ReadOnly[int]
+
+def accepts_mapping(m: Mapping[str, object]): ...
+def accepts_mutable_mapping(mm: MutableMapping[str, object]): ...
+def accepts_dict(d: Dict[str, object]): ...
+
+x: TP
+accepts_mapping(x)
+accepts_mutable_mapping(x)  # E: Argument 1 to "accepts_mutable_mapping" has incompatible type "TP"; expected "MutableMapping[str, object]"
+accepts_dict(x)  # E: Argument 1 to "accepts_dict" has incompatible type "TP"; expected "Dict[str, object]"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyAndNotRequired]
+from typing import ReadOnly, TypedDict, NotRequired
+
+class TP(TypedDict):
+    one: ReadOnly[NotRequired[int]]
+    two: NotRequired[ReadOnly[str]]
+
+x: TP
+reveal_type(x)  # N: Revealed type is "TypedDict('__main__.TP', {'one'?=: builtins.int, 'two'?=: builtins.str})"
+reveal_type(x.get("one"))  # N: Revealed type is "Union[builtins.int, None]"
+reveal_type(x.get("two"))  # N: Revealed type is "Union[builtins.str, None]"
+x["one"] = 1  # E: ReadOnly TypedDict key "one" TypedDict is mutated
+x["two"] = "a"  # E: ReadOnly TypedDict key "two" TypedDict is mutated
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testMeetOfTypedDictsWithReadOnly]
+from typing import TypeVar, Callable, TypedDict, ReadOnly
+XY = TypedDict('XY', {'x': ReadOnly[int], 'y': int})
+YZ = TypedDict('YZ', {'y': int, 'z': ReadOnly[int]})
+T = TypeVar('T')
+def f(x: Callable[[T, T], None]) -> T: pass
+def g(x: XY, y: YZ) -> None: pass
+reveal_type(f(g))  # N: Revealed type is "TypedDict({'x'=: builtins.int, 'y': builtins.int, 'z'=: builtins.int})"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyUnpack]
+from typing import TypedDict
+from typing_extensions import Unpack, ReadOnly
+
+class TD(TypedDict):
+    x: ReadOnly[int]
+    y: str
+
+def func(**kwargs: Unpack[TD]):
+    kwargs["x"] = 1  # E: ReadOnly TypedDict key "x" TypedDict is mutated
+    kwargs["y" ] = "a"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testIncorrectTypedDictSpecialFormsUsage]
+from typing import ReadOnly, TypedDict, NotRequired, Required
+
+x: ReadOnly[int]     # E: ReadOnly[] can be only used in a TypedDict definition
+y: Required[int]     # E: Required[] can be only used in a TypedDict definition
+z: NotRequired[int]  # E: NotRequired[] can be only used in a TypedDict definition
+
+class TP(TypedDict):
+    a: ReadOnly[ReadOnly[int]]              # E: "ReadOnly[]" type cannot be nested
+    b: ReadOnly[NotRequired[ReadOnly[str]]] # E: "ReadOnly[]" type cannot be nested
+    c: NotRequired[Required[int]]           # E: "Required[]" type cannot be nested
+    d: Required[NotRequired[int]]           # E: "NotRequired[]" type cannot be nested
+    e: Required[ReadOnly[NotRequired[int]]] # E: "NotRequired[]" type cannot be nested
+    f: ReadOnly[ReadOnly[ReadOnly[int]]]    # E: "ReadOnly[]" type cannot be nested
+    g: Required[Required[int]]              # E: "Required[]" type cannot be nested
+    h: NotRequired[NotRequired[int]]        # E: "NotRequired[]" type cannot be nested
+
+    j: NotRequired[ReadOnly[Required[ReadOnly[int]]]]  # E: "Required[]" type cannot be nested \
+                                                       # E: "ReadOnly[]" type cannot be nested
+
+    k: ReadOnly  # E: "ReadOnly[]" must have exactly one type argument
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictAnnotatedWithSpecialForms]
+from typing import NotRequired, ReadOnly, Required, TypedDict
+from typing_extensions import Annotated
+
+class A(TypedDict):
+    a: Annotated[NotRequired[ReadOnly[int]], ""]  # ok
+    b: NotRequired[ReadOnly[Annotated[int, ""]]]  # ok
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictReadOnlyCovariant]
+from typing import ReadOnly, TypedDict, Union
+
+class A(TypedDict):
+    a: ReadOnly[Union[int, str]]
+
+class A2(TypedDict):
+    a: ReadOnly[int]
+
+class B(TypedDict):
+    a: int
+
+class B2(TypedDict):
+    a: Union[int, str]
+
+class B3(TypedDict):
+    a: int
+
+def fa(a: A) -> None: ...
+def fa2(a: A2) -> None: ...
+
+b: B = {"a": 1}
+fa(b)
+fa2(b)
+b2: B2 = {"a": 1}
+fa(b2)
+fa2(b2)  # E: Argument 1 to "fa2" has incompatible type "B2"; expected "A2"
+
+class C(TypedDict):
+    a: ReadOnly[Union[int, str]]
+    b: Union[str, bytes]
+
+class D(TypedDict):
+    a: int
+    b: str
+
+d: D = {"a": 1, "b": "x"}
+c: C = d  # E: Incompatible types in assignment (expression has type "D", variable has type "C")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+
+[case testTypedDictFinalAndClassVar]
+from typing import TypedDict, Final, ClassVar
+
+class My(TypedDict):
+    a: Final      # E: Final[...] can't be used inside a TypedDict
+    b: Final[int] # E: Final[...] can't be used inside a TypedDict
+    c: ClassVar       # E: ClassVar[...] can't be used inside a TypedDict
+    d: ClassVar[int]  # E: ClassVar[...] can't be used inside a TypedDict
+
+Func = TypedDict('Func', {
+    'a': Final,         # E: Final[...] can't be used inside a TypedDict
+    'b': Final[int],    # E: Final[...] can't be used inside a TypedDict
+    'c': ClassVar,      # E: ClassVar[...] can't be used inside a TypedDict
+    'd': ClassVar[int], # E: ClassVar[...] can't be used inside a TypedDict
+})
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictNestedInClassAndInherited]
+from typing import TypedDict
+
+class Base:
+    class Params(TypedDict):
+        name: str
+
+class Derived(Base):
+    pass
+
+class DerivedOverride(Base):
+    class Params(Base.Params):
+        pass
+
+Base.Params(name="Robert")
+Derived.Params(name="Robert")
+DerivedOverride.Params(name="Robert")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testEnumAsClassMemberNoCrash]
+# https://github.com/python/mypy/issues/18736
+from typing import TypedDict
+
+class Base:
+    def __init__(self, namespace: dict[str, str]) -> None:
+        # Not a bug: trigger defer
+        names = {n: n for n in namespace if fail}  # E: Name "fail" is not defined
+        self.d = TypedDict("d", names)  # E: TypedDict type as attribute is not supported \
+                                        # E: TypedDict() expects a dictionary literal as the second argument
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictAlias]
+from typing import NotRequired, TypedDict
+from typing_extensions import TypeAlias
+
+class Base(TypedDict):
+    foo: int
+
+Base1 = Base
+class Child1(Base1):
+    bar: NotRequired[int]
+c11: Child1 = {"foo": 0}
+c12: Child1 = {"foo": 0, "bar": 1}
+c13: Child1 = {"foo": 0, "bar": 1, "baz": "error"}  # E: Extra key "baz" for TypedDict "Child1"
+
+Base2: TypeAlias = Base
+class Child2(Base2):
+    bar: NotRequired[int]
+c21: Child2 = {"foo": 0}
+c22: Child2 = {"foo": 0, "bar": 1}
+c23: Child2 = {"foo": 0, "bar": 1, "baz": "error"}  # E: Extra key "baz" for TypedDict "Child2"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictAliasInheritance]
+from typing import TypedDict
+from typing_extensions import TypeAlias
+
+class A(TypedDict):
+    x: str
+class B(TypedDict):
+    y: int
+
+B1 = B
+B2: TypeAlias = B
+
+class C(A, B1):
+    pass
+c1: C = {"y": 1}  # E: Missing key "x" for TypedDict "C"
+c2: C = {"x": "x", "y": 2}
+c3: C = {"x": 1, "y": 2}  # E: Incompatible types (expression has type "int", TypedDict item "x" has type "str")
+
+class D(A, B2):
+    pass
+d1: D = {"y": 1}  # E: Missing key "x" for TypedDict "D"
+d2: D = {"x": "x", "y": 2}
+d3: D = {"x": 1, "y": 2}  # E: Incompatible types (expression has type "int", TypedDict item "x" has type "str")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictAliasDuplicateBases]
+from typing import TypedDict
+from typing_extensions import TypeAlias
+
+class A(TypedDict):
+    x: str
+
+A1 = A
+A2 = A
+A3: TypeAlias = A
+
+class E(A1, A2): pass  # E: Duplicate base class "A"
+class F(A1, A3): pass # E: Duplicate base class "A"
+class G(A, A1): pass # E: Duplicate base class "A"
+
+class H(A, list): pass  # E: All bases of a new TypedDict must be TypedDict types
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictAliasGeneric]
+from typing import Generic, TypedDict, TypeVar
+from typing_extensions import TypeAlias
+
+_T = TypeVar("_T")
+
+class A(Generic[_T], TypedDict):
+    x: _T
+
+# This is by design - no_args aliases are only supported for instances
+A0 = A
+class B(A0[str]):  # E: Bad number of arguments for type alias, expected 0, given 1
+    y: int
+
+A1 = A[_T]
+A2: TypeAlias = A[_T]
+Aint = A[int]
+
+class C(A1[_T]):
+    y: str
+c1: C[int] = {"x": 0, "y": "a"}
+c2: C[int] = {"x": "no", "y": "a"}  # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
+
+class D(A2[_T]):
+    y: str
+d1: D[int] = {"x": 0, "y": "a"}
+d2: D[int] = {"x": "no", "y": "a"}  # E: Incompatible types (expression has type "str", TypedDict item "x" has type "int")
+
+class E(Aint):
+    y: str
+e1: E = {"x": 0, "y": "a"}
+e2: E = {"x": "no", "y": "a"}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
diff --git a/test-data/unit/check-typeguard.test b/test-data/unit/check-typeguard.test
index b4c007148903..94aa7ec6ffb8 100644
--- a/test-data/unit/check-typeguard.test
+++ b/test-data/unit/check-typeguard.test
@@ -54,6 +54,18 @@ def main(a: object, b: object) -> None:
         reveal_type(b)  # N: Revealed type is "builtins.object"
 [builtins fixtures/tuple.pyi]
 
+[case testTypeGuardTypeVarReturn]
+from typing import Callable, Optional, TypeVar
+from typing_extensions import TypeGuard
+T = TypeVar('T')
+def is_str(x: object) -> TypeGuard[str]: pass
+def main(x: object, type_check_func: Callable[[object], TypeGuard[T]]) -> T:
+    if not type_check_func(x):
+        raise Exception()
+    return x
+reveal_type(main("a", is_str))  # N: Revealed type is "builtins.str"
+[builtins fixtures/exception.pyi]
+
 [case testTypeGuardIsBool]
 from typing_extensions import TypeGuard
 def f(a: TypeGuard[int]) -> None: pass
@@ -75,6 +87,15 @@ def main(a: Tuple[T, ...]):
         reveal_type(a)  # N: Revealed type is "Tuple[T`-1, T`-1]"
 [builtins fixtures/tuple.pyi]
 
+[case testTypeGuardPassedAsTypeVarIsBool]
+from typing import Callable, TypeVar
+from typing_extensions import TypeGuard
+T = TypeVar('T')
+def is_str(x: object) -> TypeGuard[str]: ...
+def main(f: Callable[[object], T]) -> T: ...
+reveal_type(main(is_str))  # N: Revealed type is "builtins.bool"
+[builtins fixtures/tuple.pyi]
+
 [case testTypeGuardNonOverlapping]
 from typing import List
 from typing_extensions import TypeGuard
@@ -248,7 +269,6 @@ def main1(a: object) -> None:
 [builtins fixtures/tuple.pyi]
 
 [case testTypeGuardOverload]
-# flags: --strict-optional
 from typing import overload, Any, Callable, Iterable, Iterator, List, Optional, TypeVar
 from typing_extensions import TypeGuard
 
@@ -432,7 +452,7 @@ def g(x: object) -> None: ...
 def test(x: List[object]) -> None:
     if not(f(x) or isinstance(x, A)):
         return
-    g(reveal_type(x))  # N: Revealed type is "Union[builtins.list[builtins.str], __main__.<subclass of "list" and "A">]"
+    g(reveal_type(x))  # N: Revealed type is "Union[builtins.list[builtins.str], __main__.<subclass of "List[builtins.object]" and "__main__.A">]"
 [builtins fixtures/tuple.pyi]
 
 [case testTypeGuardMultipleCondition-xfail]
@@ -505,7 +525,7 @@ def with_bool(o: object) -> bool: pass
 
 accepts_typeguard(with_bool_typeguard)
 accepts_typeguard(with_str_typeguard)
-accepts_typeguard(with_bool)  # E: Argument 1 to "accepts_typeguard" has incompatible type "Callable[[object], bool]"; expected "Callable[[object], TypeGuard[bool]]"
+accepts_typeguard(with_bool)  # E: Argument 1 to "accepts_typeguard" has incompatible type "Callable[[object], bool]"; expected "Callable[[object], TypeGuard[Never]]"
 [builtins fixtures/tuple.pyi]
 
 [case testTypeGuardAsOverloadedFunctionArg]
@@ -620,10 +640,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
 
@@ -699,3 +715,65 @@ def foo(x: object) -> TypeGuard[List[str]]: ...
 def test(f: A[T]) -> T: ...
 reveal_type(test(foo))  # N: Revealed type is "builtins.str"
 [builtins fixtures/list.pyi]
+
+[case testNoCrashOnDunderCallTypeGuard]
+from typing_extensions import TypeGuard
+
+class A:
+    def __call__(self, x) -> TypeGuard[int]:
+        return True
+
+a: A
+assert a(x=1)
+
+x: object
+assert a(x=x)
+reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeGuardRestrictAwaySingleInvariant]
+from typing import List
+from typing_extensions import TypeGuard
+
+class B: ...
+class C(B): ...
+
+def is_c_list(x: list[B]) -> TypeGuard[list[C]]: ...
+
+def test() -> None:
+    x: List[B]
+    if not is_c_list(x):
+        reveal_type(x)  # N: Revealed type is "builtins.list[__main__.B]"
+        return
+    reveal_type(x)  # N: Revealed type is "builtins.list[__main__.C]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeGuardedTypeDoesNotLeak]
+# https://github.com/python/mypy/issues/18895
+from enum import Enum
+from typing import Literal, Union
+from typing_extensions import TypeGuard
+
+class Model(str, Enum):
+    A1 = 'model_a1'
+    A2 = 'model_a2'
+    B = 'model_b'
+
+MODEL_A = Literal[Model.A1, Model.A2]
+MODEL_B = Literal[Model.B]
+
+def is_model_a(model: str) -> TypeGuard[MODEL_A]:
+    return True
+
+def is_model_b(model: str) -> TypeGuard[MODEL_B]:
+    return True
+
+def process_model(model: Union[MODEL_A, MODEL_B]) -> int:
+    return 42
+
+def handle(model: Model) -> int:
+    if is_model_a(model) or is_model_b(model):
+        reveal_type(model)  # N: Revealed type is "__main__.Model"
+        return process_model(model)
+    return 0
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-typeis.test b/test-data/unit/check-typeis.test
new file mode 100644
index 000000000000..356b1abfdf63
--- /dev/null
+++ b/test-data/unit/check-typeis.test
@@ -0,0 +1,836 @@
+[case testTypeIsBasic]
+from typing_extensions import TypeIs
+class Point: pass
+def is_point(a: object) -> TypeIs[Point]: pass
+def main(a: object) -> None:
+    if is_point(a):
+        reveal_type(a)  # N: Revealed type is "__main__.Point"
+    else:
+        reveal_type(a)  # N: Revealed type is "builtins.object"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsElif]
+from typing_extensions import TypeIs
+from typing import Union
+class Point: pass
+def is_point(a: object) -> TypeIs[Point]: pass
+class Line: pass
+def is_line(a: object) -> TypeIs[Line]: pass
+def main(a: Union[Point, Line, int]) -> None:
+    if is_point(a):
+        reveal_type(a)  # N: Revealed type is "__main__.Point"
+    elif is_line(a):
+        reveal_type(a)  # N: Revealed type is "__main__.Line"
+    else:
+        reveal_type(a)  # N: Revealed type is "builtins.int"
+
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsTypeArgsNone]
+from typing_extensions import TypeIs
+def foo(a: object) -> TypeIs:  # E: TypeIs must have exactly one type argument
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsTypeArgsTooMany]
+from typing_extensions import TypeIs
+def foo(a: object) -> TypeIs[int, int]:  # E: TypeIs must have exactly one type argument
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsTypeArgType]
+from typing_extensions import TypeIs
+def foo(a: object) -> TypeIs[42]:  # E: Invalid type: try using Literal[42] instead?
+    pass
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsRepr]
+from typing_extensions import TypeIs
+def foo(a: object) -> TypeIs[int]:
+    pass
+reveal_type(foo)  # N: Revealed type is "def (a: builtins.object) -> TypeIs[builtins.int]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsCallArgsNone]
+from typing_extensions import TypeIs
+class Point: pass
+
+def is_point() -> TypeIs[Point]: pass  # E: "TypeIs" functions must have a positional argument
+def main(a: object) -> None:
+    if is_point():
+        reveal_type(a)  # N: Revealed type is "builtins.object"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsCallArgsMultiple]
+from typing_extensions import TypeIs
+class Point: pass
+def is_point(a: object, b: object) -> TypeIs[Point]: pass
+def main(a: object, b: object) -> None:
+    if is_point(a, b):
+        reveal_type(a)  # N: Revealed type is "__main__.Point"
+        reveal_type(b)  # N: Revealed type is "builtins.object"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsIsBool]
+from typing_extensions import TypeIs
+def f(a: TypeIs[int]) -> None: pass
+reveal_type(f)  # N: Revealed type is "def (a: builtins.bool)"
+a: TypeIs[int]
+reveal_type(a)  # N: Revealed type is "builtins.bool"
+class C:
+    a: TypeIs[int]
+reveal_type(C().a)  # N: Revealed type is "builtins.bool"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsWithTypeVar]
+from typing import TypeVar, Tuple, Type
+from typing_extensions import TypeIs
+T = TypeVar('T')
+def is_tuple_of_type(a: Tuple[object, ...], typ: Type[T]) -> TypeIs[Tuple[T, ...]]: pass
+def main(a: Tuple[object, ...]):
+    if is_tuple_of_type(a, int):
+        reveal_type(a)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsTypeVarReturn]
+from typing import Callable, Optional, TypeVar
+from typing_extensions import TypeIs
+T = TypeVar('T')
+def is_str(x: object) -> TypeIs[str]: pass
+def main(x: object, type_check_func: Callable[[object], TypeIs[T]]) -> T:
+    if not type_check_func(x):
+        raise Exception()
+    return x
+reveal_type(main("a", is_str))  # N: Revealed type is "builtins.str"
+[builtins fixtures/exception.pyi]
+
+[case testTypeIsPassedAsTypeVarIsBool]
+from typing import Callable, TypeVar
+from typing_extensions import TypeIs
+T = TypeVar('T')
+def is_str(x: object) -> TypeIs[str]: pass
+def main(f: Callable[[object], T]) -> T: pass
+reveal_type(main(is_str))  # N: Revealed type is "builtins.bool"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsUnionIn]
+from typing import Union
+from typing_extensions import TypeIs
+def is_foo(a: Union[int, str]) -> TypeIs[str]: pass
+def main(a: Union[str, int]) -> None:
+    if is_foo(a):
+        reveal_type(a)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(a)  # N: Revealed type is "builtins.int"
+    reveal_type(a)  # N: Revealed type is "Union[builtins.str, builtins.int]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsUnionOut]
+from typing import Union
+from typing_extensions import TypeIs
+def is_foo(a: object) -> TypeIs[Union[int, str]]: pass
+def main(a: object) -> None:
+    if is_foo(a):
+        reveal_type(a)  # N: Revealed type is "Union[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsNonzeroFloat]
+from typing_extensions import TypeIs
+def is_nonzero(a: object) -> TypeIs[float]: pass
+def main(a: int):
+    if is_nonzero(a):
+        reveal_type(a)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsHigherOrder]
+from typing import Callable, TypeVar, Iterable, List
+from typing_extensions import TypeIs
+T = TypeVar('T')
+R = TypeVar('R')
+def filter(f: Callable[[T], TypeIs[R]], it: Iterable[T]) -> Iterable[R]: pass
+def is_float(a: object) -> TypeIs[float]: pass
+a: List[object] = ["a", 0, 0.0]
+b = filter(is_float, a)
+reveal_type(b)  # N: Revealed type is "typing.Iterable[builtins.float]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsMethod]
+from typing_extensions import TypeIs
+class C:
+    def main(self, a: object) -> None:
+        if self.is_float(a):
+            reveal_type(self)  # N: Revealed type is "__main__.C"
+            reveal_type(a)  # N: Revealed type is "builtins.float"
+    def is_float(self, a: object) -> TypeIs[float]: pass
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsCrossModule]
+import guard
+from points import Point
+def main(a: object) -> None:
+    if guard.is_point(a):
+        reveal_type(a)  # N: Revealed type is "points.Point"
+[file guard.py]
+from typing_extensions import TypeIs
+import points
+def is_point(a: object) -> TypeIs[points.Point]: pass
+[file points.py]
+class Point: pass
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsBodyRequiresBool]
+from typing_extensions import TypeIs
+def is_float(a: object) -> TypeIs[float]:
+    return "not a bool"  # E: Incompatible return value type (got "str", expected "bool")
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsNarrowToTypedDict]
+from typing import Mapping, TypedDict
+from typing_extensions import TypeIs
+class User(TypedDict):
+    name: str
+    id: int
+def is_user(a: Mapping[str, object]) -> TypeIs[User]:
+    return isinstance(a.get("name"), str) and isinstance(a.get("id"), int)
+def main(a: Mapping[str, object]) -> None:
+    if is_user(a):
+        reveal_type(a)  # N: Revealed type is "TypedDict('__main__.User', {'name': builtins.str, 'id': builtins.int})"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypeIsInAssert]
+from typing_extensions import TypeIs
+def is_float(a: object) -> TypeIs[float]: pass
+def main(a: object) -> None:
+    assert is_float(a)
+    reveal_type(a)  # N: Revealed type is "builtins.float"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsFromAny]
+from typing import Any
+from typing_extensions import TypeIs
+def is_objfloat(a: object) -> TypeIs[float]: pass
+def is_anyfloat(a: Any) -> TypeIs[float]: pass
+def objmain(a: object) -> None:
+    if is_objfloat(a):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+    if is_anyfloat(a):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+def anymain(a: Any) -> None:
+    if is_objfloat(a):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+    if is_anyfloat(a):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsNegatedAndElse]
+from typing import Union
+from typing_extensions import TypeIs
+def is_int(a: object) -> TypeIs[int]: pass
+def is_str(a: object) -> TypeIs[str]: pass
+def intmain(a: Union[int, str]) -> None:
+    if not is_int(a):
+        reveal_type(a)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(a)  # N: Revealed type is "builtins.int"
+def strmain(a: Union[int, str]) -> None:
+    if is_str(a):
+        reveal_type(a)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(a)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsClassMethod]
+from typing_extensions import TypeIs
+class C:
+    @classmethod
+    def is_float(cls, a: object) -> TypeIs[float]: pass
+    def method(self, a: object) -> None:
+        if self.is_float(a):
+            reveal_type(a)  # N: Revealed type is "builtins.float"
+def main(a: object) -> None:
+    if C.is_float(a):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+[builtins fixtures/classmethod.pyi]
+
+[case testTypeIsRequiresPositionalArgs]
+from typing_extensions import TypeIs
+def is_float(a: object, b: object = 0) -> TypeIs[float]: pass
+def main1(a: object) -> None:
+    if is_float(a=a, b=1):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+
+    if is_float(b=1, a=a):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsOverload]
+from typing import overload, Any, Callable, Iterable, Iterator, List, Optional, TypeVar
+from typing_extensions import TypeIs
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+@overload
+def filter(f: Callable[[T], TypeIs[R]], it: Iterable[T]) -> Iterator[R]: ...
+@overload
+def filter(f: Callable[[T], bool], it: Iterable[T]) -> Iterator[T]: ...
+def filter(*args): pass
+
+def is_int_typeis(a: object) -> TypeIs[int]: pass
+def is_int_bool(a: object) -> bool: pass
+
+def main(a: List[Optional[int]]) -> None:
+    bb = filter(lambda x: x is not None, a)
+    reveal_type(bb)  # N: Revealed type is "typing.Iterator[Union[builtins.int, None]]"
+    # Also, if you replace 'bool' with 'Any' in the second overload, bb is Iterator[Any]
+    cc = filter(is_int_typeis, a)
+    reveal_type(cc)  # N: Revealed type is "typing.Iterator[builtins.int]"
+    dd = filter(is_int_bool, a)
+    reveal_type(dd)  # N: Revealed type is "typing.Iterator[Union[builtins.int, None]]"
+
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+[case testTypeIsDecorated]
+from typing import TypeVar
+from typing_extensions import TypeIs
+T = TypeVar("T")
+def decorator(f: T) -> T: pass
+@decorator
+def is_float(a: object) -> TypeIs[float]:
+    pass
+def main(a: object) -> None:
+    if is_float(a):
+        reveal_type(a)  # N: Revealed type is "builtins.float"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsMethodOverride]
+from typing_extensions import TypeIs
+class C:
+    def is_float(self, a: object) -> TypeIs[float]: pass
+class D(C):
+    def is_float(self, a: object) -> bool: pass  # Fail
+[builtins fixtures/tuple.pyi]
+[out]
+main:5: error: Signature of "is_float" incompatible with supertype "C"
+main:5: note:      Superclass:
+main:5: note:          def is_float(self, a: object) -> TypeIs[float]
+main:5: note:      Subclass:
+main:5: note:          def is_float(self, a: object) -> bool
+
+[case testTypeIsInAnd]
+from typing import Any
+from typing_extensions import TypeIs
+def isclass(a: object) -> bool:
+    pass
+def isfloat(a: object) -> TypeIs[float]:
+    pass
+def isstr(a: object) -> TypeIs[str]:
+    pass
+
+def coverage1(obj: Any) -> bool:
+    if isfloat(obj) and obj.__self__ is not None and isclass(obj.__self__):  # E: "float" has no attribute "__self__"
+        reveal_type(obj)  # N: Revealed type is "builtins.float"
+        return True
+    reveal_type(obj)  # N: Revealed type is "Any"
+    return False
+
+def coverage2(obj: Any) -> bool:
+    if not (isfloat(obj) or isstr(obj)):
+        reveal_type(obj)  # N: Revealed type is "Any"
+        return True
+    reveal_type(obj)  # N: Revealed type is "Union[builtins.float, builtins.str]"
+    return False
+[builtins fixtures/classmethod.pyi]
+
+[case testAssignToTypeIsedVariable1]
+from typing_extensions import TypeIs
+
+class A: pass
+class B(A): pass
+
+def guard(a: A) -> TypeIs[B]:
+    pass
+
+a = A()
+if not guard(a):
+    a = A()
+[builtins fixtures/tuple.pyi]
+
+[case testAssignToTypeIsedVariable2]
+from typing_extensions import TypeIs
+
+class A: pass
+class B: pass
+
+def guard(a: object) -> TypeIs[B]:
+    pass
+
+a = A()
+if not guard(a):
+    a = A()
+[builtins fixtures/tuple.pyi]
+
+[case testAssignToTypeIsedVariable3]
+from typing_extensions import TypeIs
+
+class A: pass
+class B: pass
+
+def guard(a: object) -> TypeIs[B]:
+    pass
+
+a = A()
+if guard(a):
+    reveal_type(a)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
+    a = B()  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
+    reveal_type(a)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
+    a = A()
+    reveal_type(a)  # N: Revealed type is "__main__.A"
+reveal_type(a)  # N: Revealed type is "__main__.A"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsNestedRestrictionAny]
+from typing_extensions import TypeIs
+from typing import Any
+
+class A: ...
+def f(x: object) -> TypeIs[A]: ...
+def g(x: object) -> None: ...
+
+def test(x: Any) -> None:
+    if not(f(x) or x):
+        return
+    g(reveal_type(x))  # N: Revealed type is "Union[__main__.A, Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsNestedRestrictionUnionOther]
+from typing_extensions import TypeIs
+from typing import Any
+
+class A: ...
+class B: ...
+def f(x: object) -> TypeIs[A]: ...
+def f2(x: object) -> TypeIs[B]: ...
+def g(x: object) -> None: ...
+
+def test(x: object) -> None:
+    if not(f(x) or f2(x)):
+        return
+    g(reveal_type(x))  # N: Revealed type is "Union[__main__.A, __main__.B]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsComprehensionSubtype]
+from typing import List
+from typing_extensions import TypeIs
+
+class Base: ...
+class Foo(Base): ...
+class Bar(Base): ...
+
+def is_foo(item: object) -> TypeIs[Foo]:
+    return isinstance(item, Foo)
+
+def is_bar(item: object) -> TypeIs[Bar]:
+    return isinstance(item, Bar)
+
+def foobar(items: List[object]):
+    a: List[Base] = [x for x in items if is_foo(x) or is_bar(x)]
+    b: List[Base] = [x for x in items if is_foo(x)]
+    c: List[Foo] = [x for x in items if is_foo(x)]
+    d: List[Bar] = [x for x in items if is_foo(x)]  # E: List comprehension has incompatible type List[Foo]; expected List[Bar]
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsNestedRestrictionUnionIsInstance]
+from typing_extensions import TypeIs
+from typing import Any, List
+
+class A: ...
+def f(x: List[Any]) -> TypeIs[List[str]]: ...
+def g(x: object) -> None: ...
+
+def test(x: List[Any]) -> None:
+    if not(f(x) or isinstance(x, A)):
+        return
+    g(reveal_type(x))  # N: Revealed type is "Union[builtins.list[builtins.str], __main__.<subclass of "List[Any]" and "__main__.A">]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsMultipleCondition]
+from typing_extensions import TypeIs
+from typing import Any, List
+
+class Foo: ...
+class Bar: ...
+
+def is_foo(item: object) -> TypeIs[Foo]:
+    return isinstance(item, Foo)
+
+def is_bar(item: object) -> TypeIs[Bar]:
+    return isinstance(item, Bar)
+
+def foobar(x: object):
+    if not isinstance(x, Foo) or not isinstance(x, Bar):
+        return
+    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.Foo" and "__main__.Bar">"
+
+def foobar_typeis(x: object):
+    if not is_foo(x) or not is_bar(x):
+        return
+    # Looks like a typo but this is what our unique name generation produces
+    reveal_type(x)  # N: Revealed type is "__main__.<subclass of "__main__.Foo" and "__main__.Bar">"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsAsFunctionArgAsBoolSubtype]
+from typing import Callable
+from typing_extensions import TypeIs
+
+def accepts_bool(f: Callable[[object], bool]): pass
+
+def with_bool_typeis(o: object) -> TypeIs[bool]: pass
+def with_str_typeis(o: object) -> TypeIs[str]: pass
+def with_bool(o: object) -> bool: pass
+
+accepts_bool(with_bool_typeis)
+accepts_bool(with_str_typeis)
+accepts_bool(with_bool)
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsAsFunctionArg]
+from typing import Callable
+from typing_extensions import TypeIs
+
+def accepts_typeis(f: Callable[[object], TypeIs[bool]]): pass
+def different_typeis(f: Callable[[object], TypeIs[str]]): pass
+
+def with_typeis(o: object) -> TypeIs[bool]: pass
+def with_bool(o: object) -> bool: pass
+
+accepts_typeis(with_typeis)
+accepts_typeis(with_bool)  # E: Argument 1 to "accepts_typeis" has incompatible type "Callable[[object], bool]"; expected "Callable[[object], TypeIs[bool]]"
+
+different_typeis(with_typeis)  # E: Argument 1 to "different_typeis" has incompatible type "Callable[[object], TypeIs[bool]]"; expected "Callable[[object], TypeIs[str]]"
+different_typeis(with_bool)  # E: Argument 1 to "different_typeis" has incompatible type "Callable[[object], bool]"; expected "Callable[[object], TypeIs[str]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsAsGenericFunctionArg]
+from typing import Callable, TypeVar
+from typing_extensions import TypeIs
+
+T = TypeVar('T')
+
+def accepts_typeis(f: Callable[[object], TypeIs[T]]): pass
+
+def with_bool_typeis(o: object) -> TypeIs[bool]: pass
+def with_str_typeis(o: object) -> TypeIs[str]: pass
+def with_bool(o: object) -> bool: pass
+
+accepts_typeis(with_bool_typeis)
+accepts_typeis(with_str_typeis)
+accepts_typeis(with_bool)  # E: Argument 1 to "accepts_typeis" has incompatible type "Callable[[object], bool]"; expected "Callable[[object], TypeIs[Never]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsAsOverloadedFunctionArg]
+# https://github.com/python/mypy/issues/11307
+from typing import Callable, TypeVar, Generic, Any, overload
+from typing_extensions import TypeIs
+
+_T = TypeVar('_T')
+
+class filter(Generic[_T]):
+    @overload
+    def __init__(self, function: Callable[[object], TypeIs[_T]]) -> None: pass
+    @overload
+    def __init__(self, function: Callable[[_T], Any]) -> None: pass
+    def __init__(self, function): pass
+
+def is_int_typeis(a: object) -> TypeIs[int]: pass
+def returns_bool(a: object) -> bool: pass
+
+reveal_type(filter(is_int_typeis))  # N: Revealed type is "__main__.filter[builtins.int]"
+reveal_type(filter(returns_bool))  # N: Revealed type is "__main__.filter[builtins.object]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsSubtypingVariance]
+from typing import Callable
+from typing_extensions import TypeIs
+
+class A: pass
+class B(A): pass
+class C(B): pass
+
+def accepts_typeis(f: Callable[[object], TypeIs[B]]): pass
+
+def with_typeis_a(o: object) -> TypeIs[A]: pass
+def with_typeis_b(o: object) -> TypeIs[B]: pass
+def with_typeis_c(o: object) -> TypeIs[C]: pass
+
+accepts_typeis(with_typeis_a)  # E: Argument 1 to "accepts_typeis" has incompatible type "Callable[[object], TypeIs[A]]"; expected "Callable[[object], TypeIs[B]]"
+accepts_typeis(with_typeis_b)
+accepts_typeis(with_typeis_c)  # E: Argument 1 to "accepts_typeis" has incompatible type "Callable[[object], TypeIs[C]]"; expected "Callable[[object], TypeIs[B]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsWithIdentityGeneric]
+from typing import TypeVar
+from typing_extensions import TypeIs
+
+_T = TypeVar("_T")
+
+def identity(val: _T) -> TypeIs[_T]:
+    pass
+
+def func1(name: _T):
+    reveal_type(name)  # N: Revealed type is "_T`-1"
+    if identity(name):
+        reveal_type(name)  # N: Revealed type is "_T`-1"
+
+def func2(name: str):
+    reveal_type(name)  # N: Revealed type is "builtins.str"
+    if identity(name):
+        reveal_type(name)  # N: Revealed type is "builtins.str"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsWithGenericOnSecondParam]
+from typing import TypeVar
+from typing_extensions import TypeIs
+
+_R = TypeVar("_R")
+
+def guard(val: object, param: _R) -> TypeIs[_R]:
+    pass
+
+def func1(name: object):
+    reveal_type(name)  # N: Revealed type is "builtins.object"
+    if guard(name, name):
+        reveal_type(name)  # N: Revealed type is "builtins.object"
+    if guard(name, 1):
+        reveal_type(name)  # N: Revealed type is "builtins.int"
+
+def func2(name: int):
+    reveal_type(name)  # N: Revealed type is "builtins.int"
+    if guard(name, True):
+        reveal_type(name)  # N: Revealed type is "builtins.bool"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsWithGenericInstance]
+from typing import TypeVar, List, Iterable
+from typing_extensions import TypeIs
+
+_T = TypeVar("_T")
+
+def is_list_of_str(val: Iterable[_T]) -> TypeIs[List[_T]]:
+    pass
+
+def func(name: Iterable[str]):
+    reveal_type(name)  # N: Revealed type is "typing.Iterable[builtins.str]"
+    if is_list_of_str(name):
+        reveal_type(name)  # N: Revealed type is "builtins.list[builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsWithTupleGeneric]
+from typing import TypeVar, Tuple
+from typing_extensions import TypeIs
+
+_T = TypeVar("_T")
+
+def is_two_element_tuple(val: Tuple[_T, ...]) -> TypeIs[Tuple[_T, _T]]:
+    pass
+
+def func(names: Tuple[str, ...]):
+    reveal_type(names)  # N: Revealed type is "builtins.tuple[builtins.str, ...]"
+    if is_two_element_tuple(names):
+        reveal_type(names)  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsErroneousDefinitionFails]
+from typing_extensions import TypeIs
+
+class Z:
+    def typeis1(self, *, x: object) -> TypeIs[int]:  # E: "TypeIs" functions must have a positional argument
+        ...
+
+    @staticmethod
+    def typeis2(x: object) -> TypeIs[int]:
+        ...
+
+    @staticmethod
+    def typeis3(*, x: object) -> TypeIs[int]:  # E: "TypeIs" functions must have a positional argument
+        ...
+
+def bad_typeis(*, x: object) -> TypeIs[int]:  # E: "TypeIs" functions must have a positional argument
+    ...
+
+[builtins fixtures/classmethod.pyi]
+
+[case testTypeIsWithKeywordArg]
+from typing_extensions import TypeIs
+
+class Z:
+    def typeis(self, x: object) -> TypeIs[int]:
+        ...
+
+def typeis(x: object) -> TypeIs[int]:
+    ...
+
+n: object
+if typeis(x=n):
+    reveal_type(n)  # N: Revealed type is "builtins.int"
+
+if Z().typeis(x=n):
+    reveal_type(n)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testStaticMethodTypeIs]
+from typing_extensions import TypeIs
+
+class Y:
+    @staticmethod
+    def typeis(h: object) -> TypeIs[int]:
+        ...
+
+x: object
+if Y().typeis(x):
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+if Y.typeis(x):
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/classmethod.pyi]
+
+[case testTypeIsKwargFollowingThroughOverloaded]
+from typing import overload, Union
+from typing_extensions import TypeIs
+
+@overload
+def typeis(x: object, y: str) -> TypeIs[str]:
+    ...
+
+@overload
+def typeis(x: object, y: int) -> TypeIs[int]:
+    ...
+
+def typeis(x: object, y: Union[int, str]) -> Union[TypeIs[int], TypeIs[str]]:
+    ...
+
+x: object
+if typeis(x=x, y=42):
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+
+if typeis(y=42, x=x):
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+
+if typeis(x=x, y="42"):
+    reveal_type(x)  # N: Revealed type is "builtins.str"
+
+if typeis(y="42", x=x):
+    reveal_type(x)  # N: Revealed type is "builtins.str"
+[builtins fixtures/tuple.pyi]
+
+[case testGenericAliasWithTypeIs]
+from typing import Callable, List, TypeVar
+from typing_extensions import TypeIs
+
+T = TypeVar('T')
+A = Callable[[object], TypeIs[List[T]]]
+def foo(x: object) -> TypeIs[List[str]]: ...
+
+def test(f: A[T]) -> T: ...
+reveal_type(test(foo))  # N: Revealed type is "builtins.str"
+[builtins fixtures/list.pyi]
+
+[case testNoCrashOnDunderCallTypeIs]
+from typing_extensions import TypeIs
+
+class A:
+    def __call__(self, x) -> TypeIs[int]:
+        return True
+
+a: A
+assert a(x=1)
+
+x: object
+assert a(x=x)
+reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsMustBeSubtypeFunctions]
+from typing_extensions import TypeIs
+from typing import List, Sequence, TypeVar
+
+def f(x: str) -> TypeIs[int]:  # E: Narrowed type "int" is not a subtype of input type "str"
+    pass
+
+T = TypeVar('T')
+
+def g(x: List[T]) -> TypeIs[Sequence[T]]:  # E: Narrowed type "Sequence[T]" is not a subtype of input type "List[T]"
+    pass
+
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsMustBeSubtypeMethods]
+from typing_extensions import TypeIs
+
+class NarrowHolder:
+    @classmethod
+    def cls_narrower_good(cls, x: object) -> TypeIs[int]:
+        pass
+
+    @classmethod
+    def cls_narrower_bad(cls, x: str) -> TypeIs[int]:  # E: Narrowed type "int" is not a subtype of input type "str"
+        pass
+
+    @staticmethod
+    def static_narrower_good(x: object) -> TypeIs[int]:
+        pass
+
+    @staticmethod
+    def static_narrower_bad(x: str) -> TypeIs[int]:  # E: Narrowed type "int" is not a subtype of input type "str"
+        pass
+
+    def inst_narrower_good(self, x: object) -> TypeIs[int]:
+        pass
+
+    def inst_narrower_bad(self, x: str) -> TypeIs[int]:  # E: Narrowed type "int" is not a subtype of input type "str"
+        pass
+
+
+[builtins fixtures/classmethod.pyi]
+
+[case testTypeIsTypeGuardNoSubtyping]
+from typing_extensions import TypeGuard, TypeIs
+from typing import Callable
+
+def accept_typeis(x: Callable[[object], TypeIs[str]]):
+    pass
+
+def accept_typeguard(x: Callable[[object], TypeGuard[str]]):
+    pass
+
+def typeis(x: object) -> TypeIs[str]:
+    pass
+
+def typeguard(x: object) -> TypeGuard[str]:
+    pass
+
+accept_typeis(typeis)
+accept_typeis(typeguard)  # E: Argument 1 to "accept_typeis" has incompatible type "Callable[[object], TypeGuard[str]]"; expected "Callable[[object], TypeIs[str]]"
+accept_typeguard(typeis)  # E: Argument 1 to "accept_typeguard" has incompatible type "Callable[[object], TypeIs[str]]"; expected "Callable[[object], TypeGuard[str]]"
+accept_typeguard(typeguard)
+
+[builtins fixtures/tuple.pyi]
+
+[case testTypeIsEnumOverlappingUnionExcludesIrrelevant]
+from enum import Enum
+from typing import Literal
+from typing_extensions import TypeIs
+
+class Model(str, Enum):
+    A = 'a'
+    B = 'a'
+
+def is_model_a(model: str) -> TypeIs[Literal[Model.A, "foo"]]:
+    return True
+
+def handle(model: Model) -> None:
+    if is_model_a(model):
+        reveal_type(model)  # N: Revealed type is "Literal[__main__.Model.A]"
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-typevar-defaults.test b/test-data/unit/check-typevar-defaults.test
index 7bc2d4089ecd..93d20eb26f6e 100644
--- a/test-data/unit/check-typevar-defaults.test
+++ b/test-data/unit/check-typevar-defaults.test
@@ -1,5 +1,4 @@
 [case testTypeVarDefaultsBasic]
-import builtins
 from typing import Generic, TypeVar, ParamSpec, Callable, Tuple, List
 from typing_extensions import TypeVarTuple, Unpack
 
@@ -10,7 +9,7 @@ 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]: ...
+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]]: ...
@@ -59,16 +58,694 @@ 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
+T2 = TypeVar("T2", default=[int])  # 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
+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]
+
+[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
+
+[case testTypeVarDefaultsInvalid3]
+from typing import Dict, Generic, TypeVar
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", default=T3)  # E: Name "T3" is used before definition
+T3 = TypeVar("T3", default=str)
+T4 = TypeVar("T4", default=T3)
+
+class ClassError1(Generic[T3, T1]): ...  # E: "T1" cannot appear after "T3" in type parameter list because it has no default type
+
+def func_error1(
+    a: ClassError1,
+    b: ClassError1[int],
+    c: ClassError1[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassError1[builtins.str, Any]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassError1[builtins.int, Any]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassError1[builtins.int, builtins.float]"
+
+    k = ClassError1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassError1[builtins.str, Any]"
+    l = ClassError1[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassError1[builtins.int, Any]"
+    m = ClassError1[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassError1[builtins.int, builtins.float]"
+
+class ClassError2(Generic[T4, T3]): ...  # E: Type parameter "T4" has a default type that refers to one or more type variables that are out of scope
+
+def func_error2(
+    a: ClassError2,
+    b: ClassError2[int],
+    c: ClassError2[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassError2[Any, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassError2[builtins.int, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassError2[builtins.int, builtins.float]"
+
+    k = ClassError2()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassError2[Any, builtins.str]"
+    l = ClassError2[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassError2[builtins.int, builtins.str]"
+    m = ClassError2[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassError2[builtins.int, builtins.float]"
+
+TERR1 = Dict[T3, T1]  # E: "T1" cannot appear after "T3" in type parameter list because it has no default type
+
+def func_error_alias1(
+    a: TERR1,
+    b: TERR1[int],
+    c: TERR1[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
+    reveal_type(b)  # N: Revealed type is "builtins.dict[builtins.int, Any]"
+    reveal_type(c)  # N: Revealed type is "builtins.dict[builtins.int, builtins.float]"
+
+TERR2 = Dict[T4, T3]  # TODO should be an error  \
+                      # Type parameter "T4" has a default type that refers to one or more type variables that are out of scope
+
+def func_error_alias2(
+    a: TERR2,
+    b: TERR2[int],
+    c: TERR2[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "builtins.dict[Any, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "builtins.dict[builtins.int, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "builtins.dict[builtins.int, builtins.float]"
+[builtins fixtures/dict.pyi]
+
+[case testTypeVarDefaultsFunctions]
+from typing import TypeVar, ParamSpec, List, Union, Callable, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+T1 = TypeVar("T1", default=str)
+T2 = TypeVar("T2", bound=str, default=str)
+T3 = TypeVar("T3", bytes, str, default=str)
+P1 = ParamSpec("P1", default=[int, str])
+Ts1 = TypeVarTuple("Ts1", default=Unpack[Tuple[int, str]])
+
+def callback1(x: str) -> None: ...
+
+def func_a1(x: Union[int, T1]) -> T1: ...
+reveal_type(func_a1(2))  # N: Revealed type is "builtins.str"
+reveal_type(func_a1(2.1))  # N: Revealed type is "builtins.float"
+
+def func_a2(x: Union[int, T1]) -> List[T1]: ...
+reveal_type(func_a2(2))  # N: Revealed type is "builtins.list[builtins.str]"
+reveal_type(func_a2(2.1))  # N: Revealed type is "builtins.list[builtins.float]"
+
+def func_a3(x: Union[int, T2]) -> T2: ...
+reveal_type(func_a3(2))  # N: Revealed type is "builtins.str"
+
+def func_a4(x: Union[int, T3]) -> T3: ...
+reveal_type(func_a4(2))  # N: Revealed type is "builtins.str"
+
+def func_b1(x: Union[int, Callable[P1, None]]) -> Callable[P1, None]: ...
+reveal_type(func_b1(callback1))  # N: Revealed type is "def (x: builtins.str)"
+reveal_type(func_b1(2))  # N: Revealed type is "def (builtins.int, builtins.str)"
+
+def func_c1(x: Union[int, Callable[[Unpack[Ts1]], None]]) -> Tuple[Unpack[Ts1]]: ...
+# reveal_type(func_c1(callback1))  # Revealed type is "Tuple[str]"  # TODO
+reveal_type(func_c1(2))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsClass1]
+# flags: --disallow-any-generics
+from typing import Generic, TypeVar, Union, overload
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", default=int)
+T3 = TypeVar("T3", default=str)
+T4 = TypeVar("T4", default=Union[int, None])
+
+class ClassA1(Generic[T2, T3]): ...
+
+def func_a1(
+    a: ClassA1,
+    b: ClassA1[float],
+    c: ClassA1[float, float],
+    d: ClassA1[float, float, float],  # E: "ClassA1" expects between 0 and 2 type arguments, but 3 given
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassA1[builtins.int, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassA1[builtins.float, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassA1[builtins.float, builtins.float]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassA1[builtins.int, builtins.str]"
+
+    k = ClassA1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassA1[builtins.int, builtins.str]"
+    l = ClassA1[float]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassA1[builtins.float, builtins.str]"
+    m = ClassA1[float, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassA1[builtins.float, builtins.float]"
+    n = ClassA1[float, float, float]()  # E: Type application has too many types (expected between 0 and 2)
+    reveal_type(n)  # N: Revealed type is "Any"
+
+class ClassA2(Generic[T1, T2, T3]): ...
+
+def func_a2(
+    a: ClassA2,  # E: Missing type parameters for generic type "ClassA2"
+    b: ClassA2[float],
+    c: ClassA2[float, float],
+    d: ClassA2[float, float, float],
+    e: ClassA2[float, float, float, float],  # E: "ClassA2" expects between 1 and 3 type arguments, but 4 given
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassA2[Any, builtins.int, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassA2[builtins.float, builtins.int, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassA2[builtins.float, builtins.float, builtins.str]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassA2[builtins.float, builtins.float, builtins.float]"
+    reveal_type(e)  # N: Revealed type is "__main__.ClassA2[Any, builtins.int, builtins.str]"
+
+    k = ClassA2()  # E: Need type annotation for "k"
+    reveal_type(k)  # N: Revealed type is "__main__.ClassA2[Any, builtins.int, builtins.str]"
+    l = ClassA2[float]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassA2[builtins.float, builtins.int, builtins.str]"
+    m = ClassA2[float, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassA2[builtins.float, builtins.float, builtins.str]"
+    n = ClassA2[float, float, float]()
+    reveal_type(n)  # N: Revealed type is "__main__.ClassA2[builtins.float, builtins.float, builtins.float]"
+    o = ClassA2[float, float, float, float]()  # E: Type application has too many types (expected between 1 and 3)
+    reveal_type(o)  # N: Revealed type is "Any"
+
+class ClassA3(Generic[T1, T2]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, var: int) -> None: ...
+    def __init__(self, var: Union[int, None] = None) -> None: ...
+
+def func_a3(
+    a: ClassA3,  # E: Missing type parameters for generic type "ClassA3"
+    b: ClassA3[float],
+    c: ClassA3[float, float],
+    d: ClassA3[float, float, float],  # E: "ClassA3" expects between 1 and 2 type arguments, but 3 given
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassA3[Any, builtins.int]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassA3[builtins.float, builtins.int]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassA3[builtins.float, builtins.float]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassA3[Any, builtins.int]"
+
+    k = ClassA3()  # E: Need type annotation for "k"
+    reveal_type(k)  # N: Revealed type is "__main__.ClassA3[Any, builtins.int]"
+    l = ClassA3[float]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassA3[builtins.float, builtins.int]"
+    m = ClassA3[float, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassA3[builtins.float, builtins.float]"
+    n = ClassA3[float, float, float]()  # E: Type application has too many types (expected between 1 and 2)
+    reveal_type(n)  # N: Revealed type is "Any"
+
+class ClassA4(Generic[T4]): ...
+
+def func_a4(
+    a: ClassA4,
+    b: ClassA4[float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassA4[Union[builtins.int, None]]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassA4[builtins.float]"
+
+    k = ClassA4()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassA4[Union[builtins.int, None]]"
+    l = ClassA4[float]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassA4[builtins.float]"
+
+[case testTypeVarDefaultsClass2]
+# flags: --disallow-any-generics
+from typing import Generic, ParamSpec
+
+P1 = ParamSpec("P1")
+P2 = ParamSpec("P2", default=[int, str])
+P3 = ParamSpec("P3", default=...)
+
+class ClassB1(Generic[P2, P3]): ...
+
+def func_b1(
+    a: ClassB1,
+    b: ClassB1[[float]],
+    c: ClassB1[[float], [float]],
+    d: ClassB1[[float], [float], [float]],  # E: "ClassB1" expects between 0 and 2 type arguments, but 3 given
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], ...]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassB1[[builtins.float], ...]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [builtins.float]]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], ...]"
+
+    k = ClassB1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], [*Any, **Any]]"
+    l = ClassB1[[float]]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [*Any, **Any]]"
+    m = ClassB1[[float], [float]]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [builtins.float]]"
+    n = ClassB1[[float], [float], [float]]()  # E: Type application has too many types (expected between 0 and 2)
+    reveal_type(n)  # N: Revealed type is "Any"
+
+class ClassB2(Generic[P1, P2]): ...
+
+def func_b2(
+    a: ClassB2,  # E: Missing type parameters for generic type "ClassB2"
+    b: ClassB2[[float]],
+    c: ClassB2[[float], [float]],
+    d: ClassB2[[float], [float], [float]],  # E: "ClassB2" expects between 1 and 2 type arguments, but 3 given
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassB2[Any, [builtins.int, builtins.str]]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassB2[[builtins.float], [builtins.int, builtins.str]]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassB2[[builtins.float], [builtins.float]]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassB2[Any, [builtins.int, builtins.str]]"
+
+    k = ClassB2()  # E: Need type annotation for "k"
+    reveal_type(k)  # N: Revealed type is "__main__.ClassB2[Any, [builtins.int, builtins.str]]"
+    l = ClassB2[[float]]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassB2[[builtins.float], [builtins.int, builtins.str]]"
+    m = ClassB2[[float], [float]]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassB2[[builtins.float], [builtins.float]]"
+    n = ClassB2[[float], [float], [float]]()  # E: Type application has too many types (expected between 1 and 2)
+    reveal_type(n)  # N: Revealed type is "Any"
+
+[case testTypeVarDefaultsClass3]
+# flags: --disallow-any-generics
+from typing import Generic, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+T1 = TypeVar("T1")
+T3 = TypeVar("T3", default=str)
+
+Ts1 = TypeVarTuple("Ts1")
+Ts2 = TypeVarTuple("Ts2", default=Unpack[Tuple[int, str]])
+Ts3 = TypeVarTuple("Ts3", default=Unpack[Tuple[float, ...]])
+Ts4 = TypeVarTuple("Ts4", default=Unpack[Tuple[()]])
+
+class ClassC1(Generic[Unpack[Ts2]]): ...
+
+def func_c1(
+    a: ClassC1,
+    b: ClassC1[float],
+) -> None:
+    # reveal_type(a)  # Revealed type is "__main__.ClassC1[builtins.int, builtins.str]"  # TODO
+    reveal_type(b)  # N: Revealed type is "__main__.ClassC1[builtins.float]"
+
+    k = ClassC1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassC1[builtins.int, builtins.str]"
+    l = ClassC1[float]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassC1[builtins.float]"
+
+class ClassC2(Generic[T3, Unpack[Ts3]]): ...
+
+def func_c2(
+    a: ClassC2,
+    b: ClassC2[int],
+    c: ClassC2[int, Unpack[Tuple[()]]],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassC2[builtins.str, Unpack[builtins.tuple[builtins.float, ...]]]"
+    # reveal_type(b)  # Revealed type is "__main__.ClassC2[builtins.int, Unpack[builtins.tuple[builtins.float, ...]]]"  # TODO
+    reveal_type(c)  # N: Revealed type is "__main__.ClassC2[builtins.int]"
+
+    k = ClassC2()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassC2[builtins.str, Unpack[builtins.tuple[builtins.float, ...]]]"
+    l = ClassC2[int]()
+    # reveal_type(l)  # Revealed type is "__main__.ClassC2[builtins.int, Unpack[builtins.tuple[builtins.float, ...]]]"  # TODO
+    m = ClassC2[int, Unpack[Tuple[()]]]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassC2[builtins.int]"
+
+class ClassC3(Generic[T3, Unpack[Ts4]]): ...
+
+def func_c3(
+    a: ClassC3,
+    b: ClassC3[int],
+    c: ClassC3[int, Unpack[Tuple[float]]]
+) -> None:
+    # reveal_type(a)  # Revealed type is "__main__.ClassC3[builtins.str]"  # TODO
+    reveal_type(b)  # N: Revealed type is "__main__.ClassC3[builtins.int]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassC3[builtins.int, builtins.float]"
+
+    k = ClassC3()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassC3[builtins.str]"
+    l = ClassC3[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassC3[builtins.int]"
+    m = ClassC3[int, Unpack[Tuple[float]]]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassC3[builtins.int, builtins.float]"
+
+class ClassC4(Generic[T1, Unpack[Ts1], T3]): ...
+
+def func_c4(
+    a: ClassC4,  # E: Missing type parameters for generic type "ClassC4"
+    b: ClassC4[int],
+    c: ClassC4[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassC4[Any, Unpack[builtins.tuple[Any, ...]], builtins.str]"
+    # reveal_type(b)  # Revealed type is "__main__.ClassC4[builtins.int, builtins.str]"  # TODO
+    reveal_type(c)  # N: Revealed type is "__main__.ClassC4[builtins.int, builtins.float]"
+
+    k = ClassC4()  # E: Need type annotation for "k"
+    reveal_type(k)  # N: Revealed type is "__main__.ClassC4[Any, Unpack[builtins.tuple[Any, ...]], builtins.str]"
+    l = ClassC4[int]()
+    # reveal_type(l)  # Revealed type is "__main__.ClassC4[builtins.int, builtins.str]"  # TODO
+    m = ClassC4[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassC4[builtins.int, builtins.float]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsClassRecursive1]
+# flags: --disallow-any-generics
+from typing import Generic, TypeVar, List
+
+T1 = TypeVar("T1", default=str)
+T2 = TypeVar("T2", default=T1)
+T3 = TypeVar("T3", default=T2)
+T4 = TypeVar("T4", default=List[T1])
+
+class ClassD1(Generic[T1, T2]): ...
+
+def func_d1(
+    a: ClassD1,
+    b: ClassD1[int],
+    c: ClassD1[int, float]
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassD1[builtins.str, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.int]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.float]"
+
+    k = ClassD1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassD1[builtins.str, builtins.str]"
+    l = ClassD1[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.int]"
+    m = ClassD1[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.float]"
+
+class ClassD2(Generic[T1, T2, T3]): ...
+
+def func_d2(
+    a: ClassD2,
+    b: ClassD2[int],
+    c: ClassD2[int, float],
+    d: ClassD2[int, float, str],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassD2[builtins.str, builtins.str, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.int, builtins.int]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.float]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.str]"
+
+    k = ClassD2()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassD2[builtins.str, builtins.str, builtins.str]"
+    l = ClassD2[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.int, builtins.int]"
+    m = ClassD2[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.float]"
+    n = ClassD2[int, float, str]()
+    reveal_type(n)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.str]"
+
+class ClassD3(Generic[T1, T4]): ...
+
+def func_d3(
+    a: ClassD3,
+    b: ClassD3[int],
+    c: ClassD3[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassD3[builtins.str, builtins.list[builtins.str]]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.list[builtins.int]]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.float]"
+
+    # k = ClassD3()
+    # reveal_type(k)  # Revealed type is "__main__.ClassD3[builtins.str, builtins.list[builtins.str]]"  # TODO
+    l = ClassD3[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.list[builtins.int]]"
+    m = ClassD3[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.float]"
+
+[case testTypeVarDefaultsClassRecursiveMultipleFiles]
+# flags: --disallow-any-generics
+from typing import Generic, TypeVar
+from file2 import T as T2
+
+T = TypeVar("T", default=T2)
+
+class ClassG1(Generic[T2, T]):
+    pass
+
+def func(
+    a: ClassG1,
+    b: ClassG1[str],
+    c: ClassG1[str, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassG1[builtins.int, builtins.int]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassG1[builtins.str, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassG1[builtins.str, builtins.float]"
+
+    k = ClassG1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassG1[builtins.int, builtins.int]"
+    l = ClassG1[str]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassG1[builtins.str, builtins.str]"
+    m = ClassG1[str, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassG1[builtins.str, builtins.float]"
+
+[file file2.py]
+from typing import TypeVar
+T = TypeVar('T', default=int)
+
+[case testTypeVarDefaultsTypeAlias1]
+# flags: --disallow-any-generics
+from typing import Any, Dict, List, Tuple, TypeVar, Union
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", default=int)
+T3 = TypeVar("T3", default=str)
+T4 = TypeVar("T4")
+
+TA1 = Dict[T2, T3]
+
+def func_a1(
+    a: TA1,
+    b: TA1[float],
+    c: TA1[float, float],
+    d: TA1[float, float, float],  # E: Bad number of arguments for type alias, expected between 0 and 2, given 3
+) -> None:
+    reveal_type(a)  # N: Revealed type is "builtins.dict[builtins.int, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "builtins.dict[builtins.float, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "builtins.dict[builtins.float, builtins.float]"
+    reveal_type(d)  # N: Revealed type is "builtins.dict[builtins.int, builtins.str]"
+
+TA2 = Tuple[T1, T2, T3]
+
+def func_a2(
+    a: TA2,  # E: Missing type parameters for generic type "TA2"
+    b: TA2[float],
+    c: TA2[float, float],
+    d: TA2[float, float, float],
+    e: TA2[float, float, float, float],  # E: Bad number of arguments for type alias, expected between 1 and 3, given 4
+) -> None:
+    reveal_type(a)  # N: Revealed type is "Tuple[Any, builtins.int, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "Tuple[builtins.float, builtins.int, builtins.str]"
+    reveal_type(c)  # N: Revealed type is "Tuple[builtins.float, builtins.float, builtins.str]"
+    reveal_type(d)  # N: Revealed type is "Tuple[builtins.float, builtins.float, builtins.float]"
+    reveal_type(e)  # N: Revealed type is "Tuple[Any, builtins.int, builtins.str]"
+
+TA3 = Union[Dict[T1, T2], List[T3]]
+
+def func_a3(
+    a: TA3,  # E: Missing type parameters for generic type "TA3"
+    b: TA3[float],
+    c: TA3[float, float],
+    d: TA3[float, float, float],
+    e: TA3[float, float, float, float],  # E: Bad number of arguments for type alias, expected between 1 and 3, given 4
+) -> None:
+    reveal_type(a)  # N: Revealed type is "Union[builtins.dict[Any, builtins.int], builtins.list[builtins.str]]"
+    reveal_type(b)  # N: Revealed type is "Union[builtins.dict[builtins.float, builtins.int], builtins.list[builtins.str]]"
+    reveal_type(c)  # N: Revealed type is "Union[builtins.dict[builtins.float, builtins.float], builtins.list[builtins.str]]"
+    reveal_type(d)  # N: Revealed type is "Union[builtins.dict[builtins.float, builtins.float], builtins.list[builtins.float]]"
+    reveal_type(e)  # N: Revealed type is "Union[builtins.dict[Any, builtins.int], builtins.list[builtins.str]]"
+
+TA4 = Tuple[T1, T4, T2]
+
+def func_a4(
+    a: TA4,  # E: Missing type parameters for generic type "TA4"
+    b: TA4[float],  # E: Bad number of arguments for type alias, expected between 2 and 3, given 1
+    c: TA4[float, float],
+    d: TA4[float, float, float],
+    e: TA4[float, float, float, float],  # E: Bad number of arguments for type alias, expected between 2 and 3, given 4
+) -> None:
+    reveal_type(a)  # N: Revealed type is "Tuple[Any, Any, builtins.int]"
+    reveal_type(b)  # N: Revealed type is "Tuple[Any, Any, builtins.int]"
+    reveal_type(c)  # N: Revealed type is "Tuple[builtins.float, builtins.float, builtins.int]"
+    reveal_type(d)  # N: Revealed type is "Tuple[builtins.float, builtins.float, builtins.float]"
+    reveal_type(e)  # N: Revealed type is "Tuple[Any, Any, builtins.int]"
+[builtins fixtures/dict.pyi]
+
+[case testTypeVarDefaultsTypeAlias2]
+# flags: --disallow-any-generics
+from typing import Any, Generic, ParamSpec
+
+P1 = ParamSpec("P1")
+P2 = ParamSpec("P2", default=[int, str])
+P3 = ParamSpec("P3", default=...)
+
+class ClassB1(Generic[P2, P3]): ...
+TB1 = ClassB1[P2, P3]
+
+def func_b1(
+    a: TB1,
+    b: TB1[[float]],
+    c: TB1[[float], [float]],
+    d: TB1[[float], [float], [float]],  # E: Bad number of arguments for type alias, expected between 0 and 2, given 3
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], [*Any, **Any]]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [*Any, **Any]]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassB1[[builtins.float], [builtins.float]]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassB1[[builtins.int, builtins.str], [*Any, **Any]]"
+
+class ClassB2(Generic[P1, P2]): ...
+TB2 = ClassB2[P1, P2]
+
+def func_b2(
+    a: TB2,  # E: Missing type parameters for generic type "TB2"
+    b: TB2[[float]],
+    c: TB2[[float], [float]],
+    d: TB2[[float], [float], [float]],  # E: Bad number of arguments for type alias, expected between 1 and 2, given 3
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassB2[Any, [builtins.int, builtins.str]]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassB2[[builtins.float], [builtins.int, builtins.str]]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassB2[[builtins.float], [builtins.float]]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassB2[Any, [builtins.int, builtins.str]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsTypeAlias3]
+# flags: --disallow-any-generics
+from typing import Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+T1 = TypeVar("T1")
+T3 = TypeVar("T3", default=str)
+
+Ts1 = TypeVarTuple("Ts1")
+Ts2 = TypeVarTuple("Ts2", default=Unpack[Tuple[int, str]])
+Ts3 = TypeVarTuple("Ts3", default=Unpack[Tuple[float, ...]])
+Ts4 = TypeVarTuple("Ts4", default=Unpack[Tuple[()]])
+
+TC1 = Tuple[Unpack[Ts2]]
+
+def func_c1(
+    a: TC1,
+    b: TC1[float],
+) -> None:
+    # reveal_type(a)  # Revealed type is "Tuple[builtins.int, builtins.str]"  # TODO
+    reveal_type(b)  # N: Revealed type is "Tuple[builtins.float]"
+
+TC2 = Tuple[T3, Unpack[Ts3]]
+
+def func_c2(
+    a: TC2,
+    b: TC2[int],
+    c: TC2[int, Unpack[Tuple[()]]],
+) -> None:
+    # reveal_type(a)  # Revealed type is "Tuple[builtins.str, Unpack[builtins.tuple[builtins.float, ...]]]"  # TODO
+    # reveal_type(b)  # Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]]]"  # TODO
+    reveal_type(c)  # N: Revealed type is "Tuple[builtins.int]"
+
+TC3 = Tuple[T3, Unpack[Ts4]]
+
+def func_c3(
+    a: TC3,
+    b: TC3[int],
+    c: TC3[int, Unpack[Tuple[float]]],
+) -> None:
+    # reveal_type(a)  # Revealed type is "Tuple[builtins.str]"  # TODO
+    reveal_type(b)  # N: Revealed type is "Tuple[builtins.int]"
+    reveal_type(c)  # N: Revealed type is "Tuple[builtins.int, builtins.float]"
+
+TC4 = Tuple[T1, Unpack[Ts1], T3]
+
+def func_c4(
+    a: TC4,  # E: Missing type parameters for generic type "TC4"
+    b: TC4[int],
+    c: TC4[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "Tuple[Any, Unpack[builtins.tuple[Any, ...]], builtins.str]"
+    # reveal_type(b)  # Revealed type is "Tuple[builtins.int, builtins.str]"  # TODO
+    reveal_type(c)  # N: Revealed type is "Tuple[builtins.int, builtins.float]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsTypeAliasRecursive1]
+# flags: --disallow-any-generics
+from typing import Dict, List, TypeVar
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", default=T1)
+
+TD1 = Dict[T1, T2]
+
+def func_d1(
+    a: TD1,  # E: Missing type parameters for generic type "TD1"
+    b: TD1[int],
+    c: TD1[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "builtins.dict[Any, Any]"
+    reveal_type(b)  # N: Revealed type is "builtins.dict[builtins.int, builtins.int]"
+    reveal_type(c)  # N: Revealed type is "builtins.dict[builtins.int, builtins.float]"
+[builtins fixtures/dict.pyi]
+
+[case testTypeVarDefaultsTypeAliasRecursive2]
+from typing import Any, Dict, Generic, TypeVar
+
+T1 = TypeVar("T1", default=str)
+T2 = TypeVar("T2", default=T1)
+Alias1 = Dict[T1, T2]
+T3 = TypeVar("T3")
+class A(Generic[T3]): ...
+
+T4 = TypeVar("T4", default=A[Alias1])
+class B(Generic[T4]): ...
+
+def func_d3(
+    a: B,
+    b: B[A[Alias1[int]]],
+    c: B[A[Alias1[int, float]]],
+    d: B[int],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.B[__main__.A[builtins.dict[builtins.str, builtins.str]]]"
+    reveal_type(b)  # N: Revealed type is "__main__.B[__main__.A[builtins.dict[builtins.int, builtins.int]]]"
+    reveal_type(c)  # N: Revealed type is "__main__.B[__main__.A[builtins.dict[builtins.int, builtins.float]]]"
+    reveal_type(d)  # N: Revealed type is "__main__.B[builtins.int]"
+[builtins fixtures/dict.pyi]
+
+[case testTypeVarDefaultsAndTypeObjectTypeInUnion]
+from __future__ import annotations
+from typing import Generic
+from typing_extensions import TypeVar
+
+_I = TypeVar("_I", default=int)
+
+class C(Generic[_I]): pass
+
+t: type[C] | int = C
+[builtins fixtures/tuple.pyi]
+
+
+
+[case testGenericTypeAliasWithDefaultTypeVarPreservesNoneInDefault]
+from typing_extensions import TypeVar
+from typing import Generic, Union
+
+T1 = TypeVar("T1", default=Union[int, None])
+T2 = TypeVar("T2", default=Union[int, None])
+
+
+class A(Generic[T1, T2]):
+    def __init__(self, a: T1, b: T2) -> None:
+        self.a = a
+        self.b = b
+
+
+MyA = A[T1, int]
+a: MyA = A(None, 10)
+reveal_type(a.a)  # N: Revealed type is "Union[builtins.int, None]"
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-typevar-tuple.test b/test-data/unit/check-typevar-tuple.test
index e1fae05eac63..d364439f22e9 100644
--- a/test-data/unit/check-typevar-tuple.test
+++ b/test-data/unit/check-typevar-tuple.test
@@ -17,15 +17,15 @@ reveal_type(f(args))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
 
 reveal_type(f(varargs))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 
-f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected <nothing>
+f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected "Tuple[Never, ...]"
 
 def g(a: Tuple[Unpack[Ts]], b: Tuple[Unpack[Ts]]) -> Tuple[Unpack[Ts]]:
     return a
 
 reveal_type(g(args, args))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
 reveal_type(g(args, args2))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
-reveal_type(g(args, args3))  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
-reveal_type(g(any, any))  # N: Revealed type is "Any"
+reveal_type(g(args, args3))  # N: Revealed type is "builtins.tuple[Union[builtins.int, builtins.str], ...]"
+reveal_type(g(any, any))  # N: Revealed type is "builtins.tuple[Any, ...]"
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTupleMixed]
@@ -57,11 +57,12 @@ f_args3: Tuple[int, str, bool]
 reveal_type(f(f_args))  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
 reveal_type(f(f_args2))  # N: Revealed type is "Tuple[builtins.str]"
 reveal_type(f(f_args3))  # N: Revealed type is "Tuple[builtins.str, builtins.str, builtins.bool]"
-f(empty)  # E: Argument 1 to "f" has incompatible type "Tuple[]"; expected "Tuple[int]"
+f(empty)  # E: Argument 1 to "f" has incompatible type "Tuple[()]"; expected "Tuple[int]"
 f(bad_args)  # E: Argument 1 to "f" has incompatible type "Tuple[str, str]"; expected "Tuple[int, str]"
-# TODO: This hits a crash where we assert len(templates.items) == 1. See visit_tuple_type
-# in mypy/constraints.py.
-#f(var_len_tuple)
+
+# The reason for error in subtle: actual can be empty, formal cannot.
+reveal_type(f(var_len_tuple))  # N: Revealed type is "Tuple[builtins.str, Unpack[builtins.tuple[builtins.int, ...]]]" \
+                               # E: Argument 1 to "f" has incompatible type "Tuple[int, ...]"; expected "Tuple[int, Unpack[Tuple[int, ...]]]"
 
 g_args: Tuple[str, int]
 reveal_type(g(g_args))  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
@@ -117,18 +118,18 @@ variadic_single: Variadic[int]
 reveal_type(variadic_single)  # N: Revealed type is "__main__.Variadic[builtins.int]"
 
 empty: Variadic[()]
-reveal_type(empty)  # N: Revealed type is "__main__.Variadic[Unpack[builtins.tuple[Any, ...]]]"
+reveal_type(empty)  # N: Revealed type is "__main__.Variadic[()]"
+
+omitted: Variadic
+reveal_type(omitted)  # N: Revealed type is "__main__.Variadic[Unpack[builtins.tuple[Any, ...]]]"
 
 bad: Variadic[Unpack[Tuple[int, ...]], str, Unpack[Tuple[bool, ...]]]  # E: More than one Unpack in a type is not allowed
 reveal_type(bad)  # N: Revealed type is "__main__.Variadic[Unpack[builtins.tuple[builtins.int, ...]], builtins.str]"
 
-# TODO: This is tricky to fix because we need typeanal to know whether the current
-# location is valid for an Unpack or not.
-# bad2: Unpack[Tuple[int, ...]]
+bad2: Unpack[Tuple[int, ...]]  # E: Unpack is only valid in a variadic position
 
 m1: Mixed1[int, str, bool]
 reveal_type(m1)  # N: Revealed type is "__main__.Mixed1[builtins.int, builtins.str, builtins.bool]"
-
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTupleGenericClassWithFunctions]
@@ -147,7 +148,6 @@ def foo(t: Variadic[int, Unpack[Ts], object]) -> Tuple[int, Unpack[Ts]]:
 
 v: Variadic[int, str, bool, object]
 reveal_type(foo(v))  # N: Revealed type is "Tuple[builtins.int, builtins.str, builtins.bool]"
-
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTupleGenericClassWithMethods]
@@ -167,7 +167,6 @@ class Variadic(Generic[T, Unpack[Ts], S]):
 
 v: Variadic[float, str, bool, object]
 reveal_type(v.foo(0))  # N: Revealed type is "Tuple[builtins.int, builtins.str, builtins.bool]"
-
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTupleIsNotValidAliasTarget]
@@ -210,8 +209,8 @@ shape = (Height(480), Width(640))
 x: Array[Height, Width] = Array(shape)
 reveal_type(abs(x))  # N: Revealed type is "__main__.Array[__main__.Height, __main__.Width]"
 reveal_type(x + x)  # N: Revealed type is "__main__.Array[__main__.Height, __main__.Width]"
-
 [builtins fixtures/tuple.pyi]
+
 [case testTypeVarTuplePep646ArrayExampleWithDType]
 from typing import Generic, Tuple, TypeVar, Protocol, NewType
 from typing_extensions import TypeVarTuple, Unpack
@@ -246,7 +245,6 @@ shape = (Height(480), Width(640))
 x: Array[float, Height, Width] = Array(shape)
 reveal_type(abs(x))  # N: Revealed type is "__main__.Array[builtins.float, __main__.Height, __main__.Width]"
 reveal_type(x + x)  # N: Revealed type is "__main__.Array[builtins.float, __main__.Height, __main__.Width]"
-
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTuplePep646ArrayExampleInfer]
@@ -292,8 +290,8 @@ c = del_batch_axis(b)
 reveal_type(c)  # N: Revealed type is "__main__.Array[__main__.Height, __main__.Width]"
 d = add_batch_channels(a)
 reveal_type(d)  # N: Revealed type is "__main__.Array[__main__.Batch, __main__.Height, __main__.Width, __main__.Channels]"
-
 [builtins fixtures/tuple.pyi]
+
 [case testTypeVarTuplePep646TypeVarConcatenation]
 from typing import Generic, TypeVar, NewType, Tuple
 from typing_extensions import TypeVarTuple, Unpack
@@ -310,6 +308,7 @@ def prefix_tuple(
 z = prefix_tuple(x=0, y=(True, 'a'))
 reveal_type(z)  # N: Revealed type is "Tuple[builtins.int, builtins.bool, builtins.str]"
 [builtins fixtures/tuple.pyi]
+
 [case testTypeVarTuplePep646TypeVarTupleUnpacking]
 from typing import Generic, TypeVar, NewType, Any, Tuple
 from typing_extensions import TypeVarTuple, Unpack
@@ -362,8 +361,6 @@ reveal_type(bad)  # N: Revealed type is "def [Ts, Ts2] (x: Tuple[builtins.int, U
 def bad2(x: Tuple[int, Unpack[Tuple[int, ...]], str, Unpack[Tuple[str, ...]]]) -> None:  # E: More than one Unpack in a type is not allowed
     ...
 reveal_type(bad2)  # N: Revealed type is "def (x: Tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]], builtins.str])"
-
-
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTuplePep646TypeVarStarArgsBasic]
@@ -372,23 +369,44 @@ from typing_extensions import TypeVarTuple, Unpack
 
 Ts = TypeVarTuple("Ts")
 
-# TODO: add less trivial tests with prefix/suffix etc.
-# TODO: add tests that call with a type var tuple instead of just args.
 def args_to_tuple(*args: Unpack[Ts]) -> Tuple[Unpack[Ts]]:
     reveal_type(args)  # N: Revealed type is "Tuple[Unpack[Ts`-1]]"
-    return args
+    reveal_type(args_to_tuple(1, *args))  # N: Revealed type is "Tuple[Literal[1]?, Unpack[Ts`-1]]"
+    reveal_type(args_to_tuple(*args, 'a'))  # N: Revealed type is "Tuple[Unpack[Ts`-1], Literal['a']?]"
+    reveal_type(args_to_tuple(1, *args, 'a'))  # N: Revealed type is "Tuple[Literal[1]?, Unpack[Ts`-1], Literal['a']?]"
+    args_to_tuple(*args, *args)  # E: Passing multiple variadic unpacks in a call is not supported
+    ok = (1, 'a')
+    reveal_type(args_to_tuple(*ok, *ok))  # N: Revealed type is "Tuple[builtins.int, builtins.str, builtins.int, builtins.str]"
+    if int():
+        return args
+    else:
+        return args_to_tuple(*args)
 
 reveal_type(args_to_tuple(1, 'a'))  # N: Revealed type is "Tuple[Literal[1]?, Literal['a']?]"
-
+vt: Tuple[int, ...]
+reveal_type(args_to_tuple(1, *vt))  # N: Revealed type is "Tuple[Literal[1]?, Unpack[builtins.tuple[builtins.int, ...]]]"
+reveal_type(args_to_tuple(*vt, 'a'))  # N: Revealed type is "Tuple[Unpack[builtins.tuple[builtins.int, ...]], Literal['a']?]"
+reveal_type(args_to_tuple(1, *vt, 'a'))  # N: Revealed type is "Tuple[Literal[1]?, Unpack[builtins.tuple[builtins.int, ...]], Literal['a']?]"
+args_to_tuple(*vt, *vt)  # E: Passing multiple variadic unpacks in a call is not supported
 [builtins fixtures/tuple.pyi]
+
 [case testTypeVarTuplePep646TypeVarStarArgs]
 from typing import Tuple
 from typing_extensions import TypeVarTuple, Unpack
 
 Ts = TypeVarTuple("Ts")
 
+def args_to_tuple(*args: Unpack[Ts]) -> Tuple[Unpack[Ts]]:
+    with_prefix_suffix(*args)  # E: Too few arguments for "with_prefix_suffix" \
+                               # E: Argument 1 to "with_prefix_suffix" has incompatible type "*Tuple[Unpack[Ts]]"; expected "bool"
+    new_args = (True, "foo", *args, 5)
+    with_prefix_suffix(*new_args)
+    return args
+
 def with_prefix_suffix(*args: Unpack[Tuple[bool, str, Unpack[Ts], int]]) -> Tuple[bool, str, Unpack[Ts], int]:
     reveal_type(args)  # N: Revealed type is "Tuple[builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int]"
+    reveal_type(args_to_tuple(*args))  # N: Revealed type is "Tuple[builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int]"
+    reveal_type(args_to_tuple(1, *args, 'a'))  # N: Revealed type is "Tuple[Literal[1]?, builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int, Literal['a']?]"
     return args
 
 reveal_type(with_prefix_suffix(True, "bar", "foo", 5))  # N: Revealed type is "Tuple[builtins.bool, builtins.str, Literal['foo']?, builtins.int]"
@@ -401,16 +419,13 @@ t = (True, "bar", "foo", 5)
 reveal_type(with_prefix_suffix(*t))  # N: Revealed type is "Tuple[builtins.bool, builtins.str, builtins.str, builtins.int]"
 reveal_type(with_prefix_suffix(True, *("bar", "foo"), 5))  # N: Revealed type is "Tuple[builtins.bool, builtins.str, Literal['foo']?, builtins.int]"
 
-# TODO: handle list case
-#reveal_type(with_prefix_suffix(True, "bar", *["foo1", "foo2"], 5))
+reveal_type(with_prefix_suffix(True, "bar", *["foo1", "foo2"], 5))  # N: Revealed type is "Tuple[builtins.bool, builtins.str, Unpack[builtins.tuple[builtins.str, ...]], builtins.int]"
 
 bad_t = (True, "bar")
 with_prefix_suffix(*bad_t)  # E: Too few arguments for "with_prefix_suffix"
 
 def foo(*args: Unpack[Ts]) -> None:
     reveal_type(with_prefix_suffix(True, "bar", *args, 5))  # N: Revealed type is "Tuple[builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int]"
-
-
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTuplePep646TypeVarStarArgsFixedLengthTuple]
@@ -421,40 +436,62 @@ def foo(*args: Unpack[Tuple[int, str]]) -> None:
     reveal_type(args)  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
 
 foo(0, "foo")
-foo(0, 1)  # E: Argument 2 to "foo" has incompatible type "int"; expected "Unpack[Tuple[int, str]]"
-foo("foo", "bar")  # E: Argument 1 to "foo" has incompatible type "str"; expected "Unpack[Tuple[int, str]]"
-foo(0, "foo", 1)  # E: Invalid number of arguments
-foo(0)  # E: Invalid number of arguments
-foo()  # E: Invalid number of arguments
+foo(0, 1)  # E: Argument 2 to "foo" has incompatible type "int"; expected "str"
+foo("foo", "bar")  # E: Argument 1 to "foo" has incompatible type "str"; expected "int"
+foo(0, "foo", 1)  # E: Too many arguments for "foo"
+foo(0)  # E: Too few arguments for "foo"
+foo()  # E: Too few arguments for "foo"
 foo(*(0, "foo"))
 
-# TODO: fix this case to do something sensible.
-#def foo2(*args: Unpack[Tuple[bool, Unpack[Tuple[int, str]], bool]]) -> None:
-#    reveal_type(args)
+def foo2(*args: Unpack[Tuple[bool, Unpack[Tuple[int, str]], bool]]) -> None:
+    reveal_type(args)  # N: Revealed type is "Tuple[builtins.bool, builtins.int, builtins.str, builtins.bool]"
+
+# It is hard to normalize callable types in definition, because there is deep relation between `FuncDef.type`
+# and `FuncDef.arguments`, therefore various typeops need to be sure to normalize Callable types before using them.
+reveal_type(foo2)  # N: Revealed type is "def (*args: Unpack[Tuple[builtins.bool, builtins.int, builtins.str, builtins.bool]])"
 
+class C:
+    def foo2(self, *args: Unpack[Tuple[bool, Unpack[Tuple[int, str]], bool]]) -> None: ...
+reveal_type(C().foo2)  # N: Revealed type is "def (*args: Unpack[Tuple[builtins.bool, builtins.int, builtins.str, builtins.bool]])"
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTuplePep646TypeVarStarArgsVariableLengthTuple]
 from typing import Tuple
-from typing_extensions import Unpack
+from typing_extensions import Unpack, TypeVarTuple
 
 def foo(*args: Unpack[Tuple[int, ...]]) -> None:
     reveal_type(args)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 
 foo(0, 1, 2)
-# TODO: this should say 'expected "int"' rather than the unpack
-foo(0, 1, "bar")  # E: Argument 3 to "foo" has incompatible type "str"; expected "Unpack[Tuple[int, ...]]"
-
+foo(0, 1, "bar")  # E: Argument 3 to "foo" has incompatible type "str"; expected "int"
 
 def foo2(*args: Unpack[Tuple[str, Unpack[Tuple[int, ...]], bool, bool]]) -> None:
     reveal_type(args)  # N: Revealed type is "Tuple[builtins.str, Unpack[builtins.tuple[builtins.int, ...]], builtins.bool, builtins.bool]"
-    # TODO: generate an error
-    # reveal_type(args[1])
+    reveal_type(args[1])  # N: Revealed type is "builtins.int"
+
+def foo3(*args: Unpack[Tuple[str, Unpack[Tuple[int, ...]], str, float]]) -> None:
+    reveal_type(args[0])  # N: Revealed type is "builtins.str"
+    reveal_type(args[1])  # N: Revealed type is "Union[builtins.int, builtins.str]"
+    reveal_type(args[2])  # N: Revealed type is "Union[builtins.int, builtins.str, builtins.float]"
+    args[3]  # E: Tuple index out of range \
+             # N: Variadic tuple can have length 3
+    reveal_type(args[-1])  # N: Revealed type is "builtins.float"
+    reveal_type(args[-2])  # N: Revealed type is "builtins.str"
+    reveal_type(args[-3])  # N: Revealed type is "Union[builtins.str, builtins.int]"
+    args[-4]  # E: Tuple index out of range \
+              # N: Variadic tuple can have length 3
+    reveal_type(args[::-1])  # N: Revealed type is "Tuple[builtins.float, builtins.str, Unpack[builtins.tuple[builtins.int, ...]], builtins.str]"
+    args[::2]  # E: Ambiguous slice of a variadic tuple
+    args[:2]  # E: Ambiguous slice of a variadic tuple
+
+Ts = TypeVarTuple("Ts")
+def foo4(*args: Unpack[Tuple[str, Unpack[Ts], bool, bool]]) -> None:
+    reveal_type(args[1])  # N: Revealed type is "builtins.object"
 
 foo2("bar", 1, 2, 3, False, True)
-foo2(0, 1, 2, 3, False, True)  # E: Argument 1 to "foo2" has incompatible type "int"; expected "Unpack[Tuple[str, Unpack[Tuple[int, ...]], bool, bool]]"
-foo2("bar", "bar", 2, 3, False, True)  # E: Argument 2 to "foo2" has incompatible type "str"; expected "Unpack[Tuple[str, Unpack[Tuple[int, ...]], bool, bool]]"
-foo2("bar", 1, 2, 3, 4, True)  # E: Argument 5 to "foo2" has incompatible type "int"; expected "Unpack[Tuple[str, Unpack[Tuple[int, ...]], bool, bool]]"
+foo2(0, 1, 2, 3, False, True)  # E: Argument 1 to "foo2" has incompatible type "int"; expected "str"
+foo2("bar", "bar", 2, 3, False, True)  # E: Argument 2 to "foo2" has incompatible type "str"; expected "Unpack[Tuple[Unpack[Tuple[int, ...]], bool, bool]]"
+foo2("bar", 1, 2, 3, 4, True)  # E: Argument 5 to "foo2" has incompatible type "int"; expected "Unpack[Tuple[Unpack[Tuple[int, ...]], bool, bool]]"
 foo2(*("bar", 1, 2, 3, False, True))
 [builtins fixtures/tuple.pyi]
 
@@ -478,18 +515,18 @@ vargs: Tuple[int, ...]
 vargs_str: Tuple[str, ...]
 
 call(target=func, args=(0, 'foo'))
-call(target=func, args=('bar', 'foo'))  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[object, str], None]"
-call(target=func, args=(True, 'foo', 0))  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[VarArg(object)], None]"
-call(target=func, args=(0, 0, 'foo'))  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[VarArg(object)], None]"
-call(target=func, args=vargs)  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[VarArg(object)], None]"
+call(target=func, args=('bar', 'foo'))  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[str, str], None]"
+call(target=func, args=(True, 'foo', 0))  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[bool, str, int], None]"
+call(target=func, args=(0, 0, 'foo'))  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int, int, str], None]"
+call(target=func, args=vargs)  # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[VarArg(int)], None]"
 
 # NOTE: This behavior may be a bit contentious, it is maybe inconsistent with our handling of
 # PEP646 but consistent with our handling of callable constraints.
 call(target=func2, args=vargs)  # E: Argument "target" to "call" has incompatible type "Callable[[int, int], None]"; expected "Callable[[VarArg(int)], None]"
 call(target=func3, args=vargs)
 call(target=func3, args=(0,1))
-call(target=func3, args=(0,'foo'))  # E: Argument "target" to "call" has incompatible type "Callable[[VarArg(int)], None]"; expected "Callable[[VarArg(object)], None]"
-call(target=func3, args=vargs_str)  # E: Argument "target" to "call" has incompatible type "Callable[[VarArg(int)], None]"; expected "Callable[[VarArg(object)], None]"
+call(target=func3, args=(0,'foo'))  # E: Argument "target" to "call" has incompatible type "Callable[[VarArg(int)], None]"; expected "Callable[[int, str], None]"
+call(target=func3, args=vargs_str)  # E: Argument "target" to "call" has incompatible type "Callable[[VarArg(int)], None]"; expected "Callable[[VarArg(str)], None]"
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTuplePep646CallableWithPrefixSuffix]
@@ -511,6 +548,50 @@ call_prefix(target=func_prefix, args=(0, 'foo'))
 call_prefix(target=func2_prefix, args=(0, 'foo'))  # E: Argument "target" to "call_prefix" has incompatible type "Callable[[str, int, str], None]"; expected "Callable[[bytes, int, str], None]"
 [builtins fixtures/tuple.pyi]
 
+[case testTypeVarTuplePep646CallableSuffixSyntax]
+from typing import Callable, Tuple, TypeVar
+from typing_extensions import Unpack, TypeVarTuple
+
+x: Callable[[str, Unpack[Tuple[int, ...]], bool], None]
+reveal_type(x)  # N: Revealed type is "def (builtins.str, *Unpack[Tuple[Unpack[builtins.tuple[builtins.int, ...]], builtins.bool]])"
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+A = Callable[[T, Unpack[Ts], S], int]
+y: A[int, str, bool]
+reveal_type(y)  # N: Revealed type is "def (builtins.int, builtins.str, builtins.bool) -> builtins.int"
+z: A[Unpack[Tuple[int, ...]]]
+reveal_type(z)  # N: Revealed type is "def (builtins.int, *Unpack[Tuple[Unpack[builtins.tuple[builtins.int, ...]], builtins.int]]) -> builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTuplePep646CallableInvalidSyntax]
+from typing import Callable, Tuple, TypeVar
+from typing_extensions import Unpack, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+Us = TypeVarTuple("Us")
+a: Callable[[Unpack[Ts], Unpack[Us]], int]  # E: More than one Unpack in a type is not allowed
+reveal_type(a)  # N: Revealed type is "def [Ts, Us] (*Unpack[Ts`-1]) -> builtins.int"
+b: Callable[[Unpack], int]  # E: Unpack[...] requires exactly one type argument
+reveal_type(b)  # N: Revealed type is "def (*Any) -> builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTuplePep646CallableNewSyntax]
+from typing import Callable, Generic, Tuple
+from typing_extensions import ParamSpec
+
+x: Callable[[str, *Tuple[int, ...]], None]
+reveal_type(x)  # N: Revealed type is "def (builtins.str, *builtins.int)"
+y: Callable[[str, *Tuple[int, ...], bool], None]
+reveal_type(y)  # N: Revealed type is "def (builtins.str, *Unpack[Tuple[Unpack[builtins.tuple[builtins.int, ...]], builtins.bool]])"
+
+P = ParamSpec("P")
+class C(Generic[P]): ...
+bad: C[[int, *Tuple[int, ...], int]]  # E: Unpack is only valid in a variadic position
+reveal_type(bad)  # N: Revealed type is "__main__.C[[builtins.int, *Any]]"
+[builtins fixtures/tuple.pyi]
+
 [case testTypeVarTuplePep646UnspecifiedParameters]
 from typing import Tuple, Generic, TypeVar
 from typing_extensions import Unpack, TypeVarTuple
@@ -549,8 +630,7 @@ def call(
     *args: Unpack[Ts],
 ) -> None:
     ...
-    # TODO: exposes unhandled case in checkexpr
-    # target(*args)
+    target(*args)
 
 class A:
     def func(self, arg1: int, arg2: str) -> None: ...
@@ -560,15 +640,14 @@ class A:
 vargs: Tuple[int, ...]
 vargs_str: Tuple[str, ...]
 
-call(A().func)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[VarArg(object)], None]"
+call(A().func)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[], None]"
 call(A().func, 0, 'foo')
-call(A().func, 0, 'foo', 0)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[VarArg(object)], None]"
-call(A().func, 0)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[VarArg(object)], None]"
-call(A().func, 0, 1)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int, object], None]"
+call(A().func, 0, 'foo', 0)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int, str, int], None]"
+call(A().func, 0)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int], None]"
+call(A().func, 0, 1)  # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int, int], None]"
 call(A().func2, 0, 0)
 call(A().func3, 0, 1, 2)
 call(A().func3)
-
 [builtins fixtures/tuple.pyi]
 
 [case testVariadicAliasBasicTuple]
@@ -579,8 +658,7 @@ T = TypeVar("T")
 Ts = TypeVarTuple("Ts")
 
 A = List[Tuple[T, Unpack[Ts], T]]
-B = A[Unpack[Ts]]
-x: B[int, str, str]
+x: A[int, str, str]
 reveal_type(x)  # N: Revealed type is "builtins.list[Tuple[builtins.int, builtins.str, builtins.str, builtins.int]]"
 [builtins fixtures/tuple.pyi]
 
@@ -639,19 +717,6 @@ x: A[str, str]
 reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.str, builtins.str]"
 [builtins fixtures/tuple.pyi]
 
-[case testVariadicAliasWrongCallable]
-from typing import TypeVar, Callable
-from typing_extensions import Unpack, TypeVarTuple
-
-T = TypeVar("T")
-S = TypeVar("S")
-Ts = TypeVarTuple("Ts")
-
-A = Callable[[T, Unpack[Ts], S], int]  # E: Required positional args may not appear after default, named or var args
-x: A[int, str, int, str]
-reveal_type(x)  # N: Revealed type is "def (builtins.int, builtins.str, builtins.int, builtins.str) -> builtins.int"
-[builtins fixtures/tuple.pyi]
-
 [case testVariadicAliasMultipleUnpacks]
 from typing import Tuple, Generic, Callable
 from typing_extensions import Unpack, TypeVarTuple
@@ -664,8 +729,7 @@ A = Tuple[Unpack[Ts], Unpack[Us]]  # E: More than one Unpack in a type is not al
 x: A[int, str]
 reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
 
-B = Callable[[Unpack[Ts], Unpack[Us]], int]  # E: Var args may not appear after named or var args \
-                                             # E: More than one Unpack in a type is not allowed
+B = Callable[[Unpack[Ts], Unpack[Us]], int]  # E: More than one Unpack in a type is not allowed
 y: B[int, str]
 reveal_type(y)  # N: Revealed type is "def (builtins.int, builtins.str) -> builtins.int"
 
@@ -688,7 +752,7 @@ reveal_type(x)  # N: Revealed type is "builtins.list[Tuple[Any, Unpack[builtins.
 
 B = Callable[[T, Unpack[Ts]], int]
 y: B
-reveal_type(y)  # N: Revealed type is "def (Any, *Unpack[builtins.tuple[Any, ...]]) -> builtins.int"
+reveal_type(y)  # N: Revealed type is "def (Any, *Any) -> builtins.int"
 
 C = G[T, Unpack[Ts], T]
 z: C
@@ -705,15 +769,15 @@ Ts = TypeVarTuple("Ts")
 class G(Generic[Unpack[Ts]]): ...
 
 A = List[Tuple[T, Unpack[Ts], S]]
-x: A[int]  # E: Bad number of arguments for type alias, expected: at least 2, given: 1
+x: A[int]  # E: Bad number of arguments for type alias, expected at least 2, given 1
 reveal_type(x)  # N: Revealed type is "builtins.list[Tuple[Any, Unpack[builtins.tuple[Any, ...]], Any]]"
 
 B = Callable[[T, S, Unpack[Ts]], int]
-y: B[int]  # E: Bad number of arguments for type alias, expected: at least 2, given: 1
-reveal_type(y)  # N: Revealed type is "def (Any, Any, *Unpack[builtins.tuple[Any, ...]]) -> builtins.int"
+y: B[int]  # E: Bad number of arguments for type alias, expected at least 2, given 1
+reveal_type(y)  # N: Revealed type is "def (Any, Any, *Any) -> builtins.int"
 
 C = G[T, Unpack[Ts], S]
-z: C[int]  # E: Bad number of arguments for type alias, expected: at least 2, given: 1
+z: C[int]  # E: Bad number of arguments for type alias, expected at least 2, given 1
 reveal_type(z)  # N: Revealed type is "__main__.G[Any, Unpack[builtins.tuple[Any, ...]], Any]"
 [builtins fixtures/tuple.pyi]
 
@@ -804,3 +868,1763 @@ reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple
 y: A[Unpack[Tuple[bool, ...]]]
 reveal_type(y)  # N: Revealed type is "Tuple[builtins.bool, Unpack[builtins.tuple[builtins.bool, ...]], builtins.bool, builtins.bool]"
 [builtins fixtures/tuple.pyi]
+
+[case testBanPathologicalRecursiveTuples]
+from typing import Tuple
+from typing_extensions import Unpack
+A = Tuple[int, Unpack[A]]  # E: Invalid recursive alias: a tuple item of itself
+B = Tuple[int, Unpack[C]]  # E: Invalid recursive alias: a tuple item of itself \
+                           # E: Name "C" is used before definition
+C = Tuple[int, Unpack[B]]
+x: A
+y: B
+z: C
+reveal_type(x)  # N: Revealed type is "Any"
+reveal_type(y)  # N: Revealed type is "Any"
+reveal_type(z)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[Any, ...]]]"
+
+[builtins fixtures/tuple.pyi]
+
+[case testInferenceAgainstGenericVariadicWithBadType]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, Generic
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+Us = TypeVarTuple("Us")
+
+class Foo(Generic[Unpack[Ts]]): ...
+
+def dec(f: Callable[[Unpack[Ts]], T]) -> Callable[[Unpack[Ts]], T]: ...
+def f(*args: Unpack[Us]) -> Foo[Us]: ...  # E: TypeVarTuple "Us" is only valid with an unpack
+dec(f)  # No crash
+[builtins fixtures/tuple.pyi]
+
+[case testHomogeneousGenericTupleUnpackInferenceNoCrash1]
+from typing import Any, TypeVar, Tuple, Type, Optional
+from typing_extensions import Unpack
+
+T = TypeVar("T")
+def convert(obj: Any, *to_classes: Unpack[Tuple[Type[T], ...]]) -> Optional[T]:
+    ...
+
+x = convert(1, int, float)
+reveal_type(x)  # N: Revealed type is "Union[builtins.float, None]"
+[builtins fixtures/tuple.pyi]
+
+[case testHomogeneousGenericTupleUnpackInferenceNoCrash2]
+from typing import TypeVar, Tuple, Callable, Iterable
+from typing_extensions import Unpack
+
+T = TypeVar("T")
+def combine(x: T, y: T) -> T: ...
+def reduce(fn: Callable[[T, T], T], xs: Iterable[T]) -> T: ...
+
+def pipeline(*xs: Unpack[Tuple[int, Unpack[Tuple[str, ...]], bool]]) -> None:
+    reduce(combine, xs)
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicStarArgsCallNoCrash]
+from typing import TypeVar, Callable, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+X = TypeVar("X")
+Y = TypeVar("Y")
+Xs = TypeVarTuple("Xs")
+Ys = TypeVarTuple("Ys")
+
+def nil() -> Tuple[()]:
+    return ()
+
+def cons(
+    f: Callable[[X], Y],
+    g: Callable[[Unpack[Xs]], Tuple[Unpack[Ys]]],
+) -> Callable[[X, Unpack[Xs]], Tuple[Y, Unpack[Ys]]]:
+    def wrapped(x: X, *xs: Unpack[Xs]) -> Tuple[Y, Unpack[Ys]]:
+        y, ys = f(x), g(*xs)
+        return y, *ys
+    return wrapped
+
+def star(f: Callable[[X], Y]) -> Callable[[Unpack[Tuple[X, ...]]], Tuple[Y, ...]]:
+    def wrapped(*xs: X) -> Tuple[Y, ...]:
+        if not xs:
+            return nil()
+        return cons(f, star(f))(*xs)
+    return wrapped
+[builtins fixtures/tuple.pyi]
+
+[case testInvalidTypeVarTupleUseNoCrash]
+from typing_extensions import TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+
+def f(x: Ts) -> Ts:  # E: TypeVarTuple "Ts" is only valid with an unpack
+    return x
+
+v = f(1, 2, "A")  # E: Too many arguments for "f"
+reveal_type(v)  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleSimpleDecoratorWorks]
+from typing import TypeVar, Callable
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+T = TypeVar("T")
+
+def decorator(f: Callable[[Unpack[Ts]], T]) -> Callable[[Unpack[Ts]], T]:
+    def wrapper(*args: Unpack[Ts]) -> T:
+        return f(*args)
+    return wrapper
+
+@decorator
+def f(a: int, b: int) -> int: ...
+reveal_type(f)  # N: Revealed type is "def (builtins.int, builtins.int) -> builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTupleWithUnpackIterator]
+from typing import Tuple
+from typing_extensions import Unpack
+
+def pipeline(*xs: Unpack[Tuple[int, Unpack[Tuple[float, ...]], bool]]) -> None:
+    for x in xs:
+        reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.float]"
+[builtins fixtures/tuple.pyi]
+
+[case testFixedUnpackItemInInstanceArguments]
+from typing import TypeVar, Callable, Tuple, Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+
+class C(Generic[T, Unpack[Ts], S]):
+    prefix: T
+    suffix: S
+    middle: Tuple[Unpack[Ts]]
+
+Ints = Tuple[int, int]
+c: C[Unpack[Ints]]
+reveal_type(c.prefix)  # N: Revealed type is "builtins.int"
+reveal_type(c.suffix)  # N: Revealed type is "builtins.int"
+reveal_type(c.middle)  # N: Revealed type is "Tuple[()]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicUnpackItemInInstanceArguments]
+from typing import TypeVar, Callable, Tuple, Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+
+class Other(Generic[Unpack[Ts]]): ...
+class C(Generic[T, Unpack[Ts], S]):
+    prefix: T
+    suffix: S
+    x: Tuple[Unpack[Ts]]
+    y: Callable[[Unpack[Ts]], None]
+    z: Other[Unpack[Ts]]
+
+Ints = Tuple[int, ...]
+c: C[Unpack[Ints]]
+reveal_type(c.prefix)  # N: Revealed type is "builtins.int"
+reveal_type(c.suffix)  # N: Revealed type is "builtins.int"
+reveal_type(c.x)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+reveal_type(c.y)  # N: Revealed type is "def (*builtins.int)"
+reveal_type(c.z)  # N: Revealed type is "__main__.Other[Unpack[builtins.tuple[builtins.int, ...]]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTooFewItemsInInstanceArguments]
+from typing import Generic, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+class C(Generic[T, Unpack[Ts], S]): ...
+
+c: C[int]  # E: Bad number of arguments, expected: at least 2, given: 1
+reveal_type(c)  # N: Revealed type is "__main__.C[Any, Unpack[builtins.tuple[Any, ...]], Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicClassUpperBoundCheck]
+from typing import Tuple, TypeVar, Generic
+from typing_extensions import Unpack, TypeVarTuple
+
+class A: ...
+class B: ...
+class C: ...
+class D: ...
+
+T = TypeVar("T", bound=int)
+S = TypeVar("S", bound=str)
+Ts = TypeVarTuple("Ts")
+
+class G(Generic[T, Unpack[Ts], S]): ...
+First = Tuple[A, B]
+Second = Tuple[C, D]
+x: G[Unpack[First], Unpack[Second]]  # E: Type argument "A" of "G" must be a subtype of "int" \
+                                     # E: Type argument "D" of "G" must be a subtype of "str"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleType]
+from typing import Tuple, Callable
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class A(Tuple[Unpack[Ts]]):
+    fn: Callable[[Unpack[Ts]], None]
+
+x: A[int]
+reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, fallback=__main__.A[builtins.int]]"
+reveal_type(x[0])  # N: Revealed type is "builtins.int"
+reveal_type(x.fn)  # N: Revealed type is "def (builtins.int)"
+
+y: A[int, str]
+reveal_type(y)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.A[builtins.int, builtins.str]]"
+reveal_type(y[0])  # N: Revealed type is "builtins.int"
+reveal_type(y.fn)  # N: Revealed type is "def (builtins.int, builtins.str)"
+
+z: A[Unpack[Tuple[int, ...]]]
+reveal_type(z)  # N: Revealed type is "__main__.A[Unpack[builtins.tuple[builtins.int, ...]]]"
+reveal_type(z[0])  # N: Revealed type is "builtins.int"
+reveal_type(z.fn)  # N: Revealed type is "def (*builtins.int)"
+
+t: A[int, Unpack[Tuple[int, str]], str]
+reveal_type(t)  # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.str, builtins.str, fallback=__main__.A[builtins.int, builtins.int, builtins.str, builtins.str]]"
+reveal_type(t[0])  # N: Revealed type is "builtins.int"
+reveal_type(t.fn)  # N: Revealed type is "def (builtins.int, builtins.int, builtins.str, builtins.str)"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicNamedTuple]
+from typing import Tuple, Callable, NamedTuple, Generic, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+class A(NamedTuple, Generic[Unpack[Ts], T]):
+    fn: Callable[[Unpack[Ts]], None]
+    val: T
+
+y: A[int, str]
+reveal_type(y)  # N: Revealed type is "Tuple[def (builtins.int), builtins.str, fallback=__main__.A[builtins.int, builtins.str]]"
+reveal_type(y[0])  # N: Revealed type is "def (builtins.int)"
+reveal_type(y.fn)  # N: Revealed type is "def (builtins.int)"
+
+z: A[Unpack[Tuple[int, ...]]]
+reveal_type(z)  # N: Revealed type is "Tuple[def (*builtins.int), builtins.int, fallback=__main__.A[Unpack[builtins.tuple[builtins.int, ...]], builtins.int]]"
+reveal_type(z.fn)  # N: Revealed type is "def (*builtins.int)"
+
+t: A[int, Unpack[Tuple[int, str]], str]
+reveal_type(t)  # N: Revealed type is "Tuple[def (builtins.int, builtins.int, builtins.str), builtins.str, fallback=__main__.A[builtins.int, builtins.int, builtins.str, builtins.str]]"
+
+def test(x: int, y: str) -> None: ...
+nt = A(fn=test, val=42)
+reveal_type(nt)  # N: Revealed type is "Tuple[def (builtins.int, builtins.str), builtins.int, fallback=__main__.A[builtins.int, builtins.str, builtins.int]]"
+
+def bad() -> int: ...
+nt2 = A(fn=bad, val=42)  # E: Argument "fn" to "A" has incompatible type "Callable[[], int]"; expected "Callable[[], None]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTypedDict]
+from typing import Tuple, Callable, Generic, TypedDict, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+class A(TypedDict, Generic[Unpack[Ts], T]):
+    fn: Callable[[Unpack[Ts]], None]
+    val: T
+
+y: A[int, str]
+reveal_type(y)  # N: Revealed type is "TypedDict('__main__.A', {'fn': def (builtins.int), 'val': builtins.str})"
+reveal_type(y["fn"])  # N: Revealed type is "def (builtins.int)"
+
+z: A[Unpack[Tuple[int, ...]]]
+reveal_type(z)  # N: Revealed type is "TypedDict('__main__.A', {'fn': def (*builtins.int), 'val': builtins.int})"
+reveal_type(z["fn"])  # N: Revealed type is "def (*builtins.int)"
+
+t: A[int, Unpack[Tuple[int, str]], str]
+reveal_type(t)  # N: Revealed type is "TypedDict('__main__.A', {'fn': def (builtins.int, builtins.int, builtins.str), 'val': builtins.str})"
+
+def test(x: int, y: str) -> None: ...
+td = A({"fn": test, "val": 42})
+reveal_type(td)  # N: Revealed type is "TypedDict('__main__.A', {'fn': def (builtins.int, builtins.str), 'val': builtins.int})"
+
+def bad() -> int: ...
+td2 = A({"fn": bad, "val": 42})  # E: Incompatible types (expression has type "Callable[[], int]", TypedDict item "fn" has type "Callable[[], None]")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testFixedUnpackWithRegularInstance]
+from typing import Tuple, Generic, TypeVar
+from typing_extensions import Unpack
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
+T4 = TypeVar("T4")
+
+class C(Generic[T1, T2, T3, T4]): ...
+x: C[int, Unpack[Alias], str]
+Alias = Tuple[int, str]
+reveal_type(x)  # N: Revealed type is "__main__.C[builtins.int, builtins.int, builtins.str, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicUnpackWithRegularInstance]
+from typing import Tuple, Generic, TypeVar
+from typing_extensions import Unpack
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
+T4 = TypeVar("T4")
+
+class C(Generic[T1, T2, T3, T4]): ...
+x: C[int, Unpack[Alias], str, str]  # E: Unpack is only valid in a variadic position
+Alias = Tuple[int, ...]
+reveal_type(x)  # N: Revealed type is "__main__.C[Any, Any, Any, Any]"
+y: C[int, Unpack[Undefined]]  # E: Name "Undefined" is not defined
+reveal_type(y)  # N: Revealed type is "__main__.C[Any, Any, Any, Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicAliasInvalidUnpackNoCrash]
+from typing import Tuple, Generic, Union, List
+from typing_extensions import Unpack, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+Alias = Tuple[int, Unpack[Ts], str]
+
+A = Union[int, str]
+x: List[Alias[int, Unpack[A], str]]  # E: "Union[int, str]" cannot be unpacked (must be tuple or TypeVarTuple)
+reveal_type(x)  # N: Revealed type is "builtins.list[Tuple[builtins.int, builtins.int, Unpack[builtins.tuple[Any, ...]], builtins.str, builtins.str]]"
+y: List[Alias[int, Unpack[Undefined], str]]  # E: Name "Undefined" is not defined
+reveal_type(y)  # N: Revealed type is "builtins.list[Tuple[builtins.int, Unpack[builtins.tuple[Any, ...]], builtins.str]]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicAliasForwardRefToFixedUnpack]
+from typing import Tuple, Generic, TypeVar
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+Alias = Tuple[T, Unpack[Ts], S]
+x: Alias[int, Unpack[Other]]
+Other = Tuple[int, str]
+reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicAliasForwardRefToVariadicUnpack]
+from typing import Tuple, Generic, TypeVar
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+Alias = Tuple[T, Unpack[Ts], S]
+x: Alias[int, Unpack[Other]]
+Other = Tuple[int, ...]
+reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]], builtins.int]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicInstanceStrictPrefixSuffixCheck]
+from typing import Tuple, Generic, TypeVar
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+class C(Generic[T, Unpack[Ts], S]): ...
+
+def foo(x: Tuple[Unpack[Ts]]) -> Tuple[Unpack[Ts]]:
+    y: C[int, Unpack[Ts]]  # E: TypeVarTuple cannot be split
+    z: C[Unpack[Ts], int]  # E: TypeVarTuple cannot be split
+    return x
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicAliasStrictPrefixSuffixCheck]
+from typing import Tuple, TypeVar
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+Alias = Tuple[T, Unpack[Ts], S]
+
+def foo(x: Tuple[Unpack[Ts]]) -> Tuple[Unpack[Ts]]:
+    y: Alias[int, Unpack[Ts]]  # E: TypeVarTuple cannot be split
+    z: Alias[Unpack[Ts], int]  # E: TypeVarTuple cannot be split
+    return x
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleWithIsInstance]
+# flags: --warn-unreachable
+from typing import Generic, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+TP = TypeVarTuple("TP")
+class A(Tuple[Unpack[TP]]): ...
+
+def test(d: A[int, str]) -> None:
+    if isinstance(d, A):
+        reveal_type(d)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.A[builtins.int, builtins.str]]"
+    else:
+        reveal_type(d)  # E: Statement is unreachable
+
+class B(Generic[Unpack[TP]]): ...
+
+def test2(d: B[int, str]) -> None:
+    if isinstance(d, B):
+        reveal_type(d)  # N: Revealed type is "__main__.B[builtins.int, builtins.str]"
+    else:
+        reveal_type(d)  # E: Statement is unreachable
+[builtins fixtures/isinstancelist.pyi]
+
+[case testVariadicTupleSubtyping]
+from typing import Tuple
+from typing_extensions import Unpack
+
+def f1(x: Tuple[float, ...]) -> None: ...
+def f2(x: Tuple[float, Unpack[Tuple[float, ...]]]) -> None: ...
+def f3(x: Tuple[Unpack[Tuple[float, ...]], float]) -> None: ...
+def f4(x: Tuple[float, Unpack[Tuple[float, ...]], float]) -> None: ...
+
+t1: Tuple[int, int]
+t2: Tuple[int, Unpack[Tuple[int, ...]]]
+t3: Tuple[Unpack[Tuple[int, ...]], int]
+t4: Tuple[int, Unpack[Tuple[int, ...]], int]
+t5: Tuple[int, ...]
+
+tl: Tuple[int, int, Unpack[Tuple[int, ...]]]
+tr: Tuple[Unpack[Tuple[int, ...]], int, int]
+
+f1(t1)
+f1(t2)
+f1(t3)
+f1(t4)
+f1(t5)
+
+f1(tl)
+f1(tr)
+
+f2(t1)
+f2(t2)
+f2(t3)
+f2(t4)
+f2(t5)  # E: Argument 1 to "f2" has incompatible type "Tuple[int, ...]"; expected "Tuple[float, Unpack[Tuple[float, ...]]]"
+
+f2(tl)
+f2(tr)
+
+f3(t1)
+f3(t2)
+f3(t3)
+f3(t4)
+f3(t5)  # E: Argument 1 to "f3" has incompatible type "Tuple[int, ...]"; expected "Tuple[Unpack[Tuple[float, ...]], float]"
+
+f3(tl)
+f3(tr)
+
+f4(t1)
+f4(t2)  # E: Argument 1 to "f4" has incompatible type "Tuple[int, Unpack[Tuple[int, ...]]]"; expected "Tuple[float, Unpack[Tuple[float, ...]], float]"
+f4(t3)  # E: Argument 1 to "f4" has incompatible type "Tuple[Unpack[Tuple[int, ...]], int]"; expected "Tuple[float, Unpack[Tuple[float, ...]], float]"
+f4(t4)
+f4(t5)  # E: Argument 1 to "f4" has incompatible type "Tuple[int, ...]"; expected "Tuple[float, Unpack[Tuple[float, ...]], float]"
+
+f4(tl)
+f4(tr)
+
+t5_verbose: Tuple[Unpack[Tuple[int, ...]]]
+t5 = t5_verbose  # OK
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleInference]
+from typing import List, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+def f(x: Tuple[int, Unpack[Tuple[T, ...]]]) -> T: ...
+
+vt0: Tuple[int, ...]
+f(vt0)  # E: Argument 1 to "f" has incompatible type "Tuple[int, ...]"; expected "Tuple[int, Unpack[Tuple[int, ...]]]"
+
+vt1: Tuple[Unpack[Tuple[int, ...]], int]
+reveal_type(f(vt1))  # N: Revealed type is "builtins.int"
+
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+def g(x: Tuple[T, Unpack[Ts], S]) -> Tuple[T, Unpack[Ts], S]: ...
+g(vt0)  # E: Argument 1 to "g" has incompatible type "Tuple[int, ...]"; expected "Tuple[int, Unpack[Tuple[int, ...]], int]"
+
+U = TypeVar("U")
+def h(x: List[Tuple[T, S, U]]) -> Tuple[T, S, U]: ...
+vt2: Tuple[Unpack[Tuple[int, ...]], int]
+vt2 = h(reveal_type([]))  # N: Revealed type is "builtins.list[Tuple[builtins.int, builtins.int, builtins.int]]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicSelfTypeErasure]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class Array(Generic[Unpack[Ts]]):
+    def _close(self) -> None: ...
+
+    def close(self) -> None:
+        self._close()
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicSubclassFixed]
+from typing import Generic, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]): ...
+class C(B[int, str]): ...
+class D(B[Unpack[Tuple[int, ...]]]): ...
+
+def fii(x: B[int, int]) -> None: ...
+def fis(x: B[int, str]) -> None: ...
+def fiv(x: B[Unpack[Tuple[int, ...]]]) -> None: ...
+
+fii(C())  # E: Argument 1 to "fii" has incompatible type "C"; expected "B[int, int]"
+fii(D())  # E: Argument 1 to "fii" has incompatible type "D"; expected "B[int, int]"
+fis(C())
+fis(D())  # E: Argument 1 to "fis" has incompatible type "D"; expected "B[int, str]"
+fiv(C())  # E: Argument 1 to "fiv" has incompatible type "C"; expected "B[Unpack[Tuple[int, ...]]]"
+fiv(D())
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicSubclassSame]
+from typing import Generic, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]): ...
+class C(B[Unpack[Ts]]): ...
+
+def fii(x: B[int, int]) -> None: ...
+def fis(x: B[int, str]) -> None: ...
+def fiv(x: B[Unpack[Tuple[int, ...]]]) -> None: ...
+
+cii: C[int, int]
+cis: C[int, str]
+civ: C[Unpack[Tuple[int, ...]]]
+
+fii(cii)
+fii(cis)  # E: Argument 1 to "fii" has incompatible type "C[int, str]"; expected "B[int, int]"
+fii(civ)  # E: Argument 1 to "fii" has incompatible type "C[Unpack[Tuple[int, ...]]]"; expected "B[int, int]"
+
+fis(cii)  # E: Argument 1 to "fis" has incompatible type "C[int, int]"; expected "B[int, str]"
+fis(cis)
+fis(civ)  # E: Argument 1 to "fis" has incompatible type "C[Unpack[Tuple[int, ...]]]"; expected "B[int, str]"
+
+fiv(cii)
+fiv(cis)  # E: Argument 1 to "fiv" has incompatible type "C[int, str]"; expected "B[Unpack[Tuple[int, ...]]]"
+fiv(civ)
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicSubclassExtra]
+from typing import Generic, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]): ...
+
+T = TypeVar("T")
+class C(B[int, Unpack[Ts], T]): ...
+
+def ff(x: B[int, int, int]) -> None: ...
+def fv(x: B[Unpack[Tuple[int, ...]]]) -> None: ...
+
+cii: C[int, int]
+cis: C[int, str]
+civ: C[Unpack[Tuple[int, ...]]]
+
+ff(cii)
+ff(cis)  # E: Argument 1 to "ff" has incompatible type "C[int, str]"; expected "B[int, int, int]"
+ff(civ)  # E: Argument 1 to "ff" has incompatible type "C[Unpack[Tuple[int, ...]]]"; expected "B[int, int, int]"
+
+fv(cii)
+fv(cis)  # E: Argument 1 to "fv" has incompatible type "C[int, str]"; expected "B[Unpack[Tuple[int, ...]]]"
+fv(civ)
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicSubclassVariadic]
+from typing import Generic, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]): ...
+T = TypeVar("T")
+class C(B[Unpack[Tuple[T, ...]]]): ...
+
+def ff(x: B[int, int]) -> None: ...
+def fv(x: B[Unpack[Tuple[int, ...]]]) -> None: ...
+
+ci: C[int]
+ff(ci)  # E: Argument 1 to "ff" has incompatible type "C[int]"; expected "B[int, int]"
+fv(ci)
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicSubclassMethodAccess]
+from typing import Generic, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]):
+    def meth(self) -> Tuple[Unpack[Ts]]: ...
+
+class C1(B[int, str]): ...
+class C2(B[Unpack[Ts]]): ...
+T = TypeVar("T")
+class C3(B[int, Unpack[Ts], T]): ...
+class C4(B[Unpack[Tuple[T, ...]]]): ...
+
+c1: C1
+reveal_type(c1.meth())  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+
+c2f: C2[int, str]
+c2v: C2[Unpack[Tuple[int, ...]]]
+reveal_type(c2f.meth())  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+reveal_type(c2v.meth())  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+
+c3f: C3[int, str]
+c3v: C3[Unpack[Tuple[int, ...]]]
+reveal_type(c3f.meth())  # N: Revealed type is "Tuple[builtins.int, builtins.int, builtins.str]"
+reveal_type(c3v.meth())  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]], builtins.int]"
+
+c4: C4[int]
+reveal_type(c4.meth())  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleAnySubtype]
+from typing import Any, Generic, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]): ...
+class C1(B[Unpack[Tuple[Any, ...]]]): ...
+c1 = C1()
+class C2(B): ...
+c2 = C2()
+x: B[int, str]
+x = c1
+x = c2
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleAnySubtypeTupleType]
+from typing import Any, Generic, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Tuple[Unpack[Ts]]): ...
+class C1(B[Unpack[Tuple[Any, ...]]]): ...
+c1 = C1()
+class C2(B): ...
+c2 = C2()
+x: B[int, str]
+x = c1
+x = c2
+[builtins fixtures/tuple.pyi]
+
+[case testUnpackingVariadicTuplesTypeVar]
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def foo(arg: Tuple[int, Unpack[Ts], str]) -> None:
+    x1, y1, z1 = arg  # E: Variadic tuple unpacking requires a star target
+    reveal_type(x1)  # N: Revealed type is "Any"
+    reveal_type(y1)  # N: Revealed type is "Any"
+    reveal_type(z1)  # N: Revealed type is "Any"
+    x2, *y2, z2 = arg
+    reveal_type(x2)  # N: Revealed type is "builtins.int"
+    reveal_type(y2)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z2)  # N: Revealed type is "builtins.str"
+    x3, *y3 = arg
+    reveal_type(x3)  # N: Revealed type is "builtins.int"
+    reveal_type(y3)  # N: Revealed type is "builtins.list[builtins.object]"
+    *y4, z4 = arg
+    reveal_type(y4)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z4)  # N: Revealed type is "builtins.str"
+    x5, xx5, *y5, z5, zz5 = arg  # E: Too many assignment targets for variadic unpack
+    reveal_type(x5)  # N: Revealed type is "Any"
+    reveal_type(xx5)  # N: Revealed type is "Any"
+    reveal_type(y5)  # N: Revealed type is "builtins.list[Any]"
+    reveal_type(z5)  # N: Revealed type is "Any"
+    reveal_type(zz5)  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testUnpackingVariadicTuplesHomogeneous]
+from typing import Tuple
+from typing_extensions import Unpack
+
+def bar(arg: Tuple[int, Unpack[Tuple[float, ...]], str]) -> None:
+    x1, y1, z1 = arg  # E: Variadic tuple unpacking requires a star target
+    reveal_type(x1)  # N: Revealed type is "Any"
+    reveal_type(y1)  # N: Revealed type is "Any"
+    reveal_type(z1)  # N: Revealed type is "Any"
+    x2, *y2, z2 = arg
+    reveal_type(x2)  # N: Revealed type is "builtins.int"
+    reveal_type(y2)  # N: Revealed type is "builtins.list[builtins.float]"
+    reveal_type(z2)  # N: Revealed type is "builtins.str"
+    x3, *y3 = arg
+    reveal_type(x3)  # N: Revealed type is "builtins.int"
+    reveal_type(y3)  # N: Revealed type is "builtins.list[builtins.object]"
+    *y4, z4 = arg
+    reveal_type(y4)  # N: Revealed type is "builtins.list[builtins.float]"
+    reveal_type(z4)  # N: Revealed type is "builtins.str"
+    x5, xx5, *y5, z5, zz5 = arg  # E: Too many assignment targets for variadic unpack
+    reveal_type(x5)  # N: Revealed type is "Any"
+    reveal_type(xx5)  # N: Revealed type is "Any"
+    reveal_type(y5)  # N: Revealed type is "builtins.list[Any]"
+    reveal_type(z5)  # N: Revealed type is "Any"
+    reveal_type(zz5)  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]
+
+[case testRepackingVariadicTuplesTypeVar]
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def foo(arg: Tuple[int, Unpack[Ts], str]) -> None:
+    x1, *y1, z1 = *arg,
+    reveal_type(x1)  # N: Revealed type is "builtins.int"
+    reveal_type(y1)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z1)  # N: Revealed type is "builtins.str"
+    x2, *y2, z2 = 1, *arg, 2
+    reveal_type(x2)  # N: Revealed type is "builtins.int"
+    reveal_type(y2)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z2)  # N: Revealed type is "builtins.int"
+    x3, *y3 = *arg, 42
+    reveal_type(x3)  # N: Revealed type is "builtins.int"
+    reveal_type(y3)  # N: Revealed type is "builtins.list[builtins.object]"
+    *y4, z4 = 42, *arg
+    reveal_type(y4)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z4)  # N: Revealed type is "builtins.str"
+    x5, xx5, *y5, z5, zz5 = 1, *arg, 2
+    reveal_type(x5)  # N: Revealed type is "builtins.int"
+    reveal_type(xx5)  # N: Revealed type is "builtins.int"
+    reveal_type(y5)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z5)  # N: Revealed type is "builtins.str"
+    reveal_type(zz5)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testRepackingVariadicTuplesHomogeneous]
+from typing import Tuple
+from typing_extensions import Unpack
+
+def foo(arg: Tuple[int, Unpack[Tuple[float, ...]], str]) -> None:
+    x1, *y1, z1 = *arg,
+    reveal_type(x1)  # N: Revealed type is "builtins.int"
+    reveal_type(y1)  # N: Revealed type is "builtins.list[builtins.float]"
+    reveal_type(z1)  # N: Revealed type is "builtins.str"
+    x2, *y2, z2 = 1, *arg, 2
+    reveal_type(x2)  # N: Revealed type is "builtins.int"
+    reveal_type(y2)  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type(z2)  # N: Revealed type is "builtins.int"
+    x3, *y3 = *arg, 42
+    reveal_type(x3)  # N: Revealed type is "builtins.int"
+    reveal_type(y3)  # N: Revealed type is "builtins.list[builtins.object]"
+    *y4, z4 = 42, *arg
+    reveal_type(y4)  # N: Revealed type is "builtins.list[builtins.float]"
+    reveal_type(z4)  # N: Revealed type is "builtins.str"
+    x5, xx5, *y5, z5, zz5 = 1, *arg, 2
+    reveal_type(x5)  # N: Revealed type is "builtins.int"
+    reveal_type(xx5)  # N: Revealed type is "builtins.int"
+    reveal_type(y5)  # N: Revealed type is "builtins.list[builtins.float]"
+    reveal_type(z5)  # N: Revealed type is "builtins.str"
+    reveal_type(zz5)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testPackingVariadicTuplesTypeVar]
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def foo(arg: Tuple[int, Unpack[Ts], str]) -> None:
+    x = *arg,
+    reveal_type(x)  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str]"
+    y = 1, *arg, 2
+    reveal_type(y)  # N: Revealed type is "Tuple[builtins.int, builtins.int, Unpack[Ts`-1], builtins.str, builtins.int]"
+    z = (*arg, *arg)
+    reveal_type(z)  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
+[builtins fixtures/tuple.pyi]
+
+[case testPackingVariadicTuplesHomogeneous]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple
+from typing_extensions import Unpack
+
+a: Tuple[float, ...]
+b: Tuple[int, Unpack[Tuple[float, ...]], str]
+
+x = *a,
+reveal_type(x)  # N: Revealed type is "builtins.tuple[builtins.float, ...]"
+y = 1, *a, 2
+reveal_type(y)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.int]"
+z = (*a, *a)
+reveal_type(z)  # N: Revealed type is "builtins.tuple[builtins.float, ...]"
+
+x2 = *b,
+reveal_type(x2)  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str]"
+y2 = 1, *b, 2
+reveal_type(y2)  # N: Revealed type is "Tuple[builtins.int, builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.str, builtins.int]"
+z2 = (*b, *b)
+reveal_type(z2)  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleInListSetExpr]
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+vt: Tuple[int, Unpack[Tuple[float, ...]], int]
+reveal_type([1, *vt])  # N: Revealed type is "builtins.list[builtins.float]"
+reveal_type({1, *vt})  # N: Revealed type is "builtins.set[builtins.float]"
+
+Ts = TypeVarTuple("Ts")
+def foo(arg: Tuple[int, Unpack[Ts], str]) -> None:
+    reveal_type([1, *arg])  # N: Revealed type is "builtins.list[builtins.object]"
+    reveal_type({1, *arg})  # N: Revealed type is "builtins.set[builtins.object]"
+[builtins fixtures/isinstancelist.pyi]
+
+[case testVariadicTupleInTupleContext]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple, Optional
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def test(x: Optional[Tuple[Unpack[Ts]]] = None) -> Tuple[Unpack[Ts]]: ...
+
+vt: Tuple[int, Unpack[Tuple[float, ...]], int]
+vt = 1, *test(), 2  # OK, type context is used
+vt2 = 1, *test(), 2  # E: Need type annotation for "vt2"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleConcatenation]
+# flags: --enable-incomplete-feature=PreciseTupleTypes
+from typing import Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+vtf: Tuple[float, ...]
+vt: Tuple[int, Unpack[Tuple[float, ...]], int]
+
+reveal_type(vt + (1, 2))  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.int, Literal[1]?, Literal[2]?]"
+reveal_type((1, 2) + vt)  # N: Revealed type is "Tuple[Literal[1]?, Literal[2]?, builtins.int, Unpack[builtins.tuple[builtins.float, ...]], builtins.int]"
+reveal_type(vt + vt)  # N: Revealed type is "builtins.tuple[Union[builtins.int, builtins.float], ...]"
+reveal_type(vtf + (1, 2))  # N: Revealed type is "Tuple[Unpack[builtins.tuple[builtins.float, ...]], Literal[1]?, Literal[2]?]"
+reveal_type((1, 2) + vtf)  # N: Revealed type is "Tuple[Literal[1]?, Literal[2]?, Unpack[builtins.tuple[builtins.float, ...]]]"
+
+Ts = TypeVarTuple("Ts")
+def foo(arg: Tuple[int, Unpack[Ts], str]) -> None:
+    reveal_type(arg + (1, 2))  # N: Revealed type is "Tuple[builtins.int, Unpack[Ts`-1], builtins.str, Literal[1]?, Literal[2]?]"
+    reveal_type((1, 2) + arg)  # N: Revealed type is "Tuple[Literal[1]?, Literal[2]?, builtins.int, Unpack[Ts`-1], builtins.str]"
+    reveal_type(arg + arg)  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleAnyOverload]
+from typing import Any, Generic, overload, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class Array(Generic[Unpack[Ts]]): ...
+
+class A:
+    @overload
+    def f(self, x: Tuple[Unpack[Ts]]) -> Array[Unpack[Ts]]: ...
+    @overload
+    def f(self, x: Any) -> Any: ...
+    def f(self, x: Any) -> Any:
+        ...
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleInferAgainstAny]
+from typing import Any, Tuple, TypeVar
+from typing_extensions import Unpack
+
+T = TypeVar("T")
+
+def test(x: int, t: Tuple[T, ...]) -> Tuple[int, Unpack[Tuple[T, ...]]]:
+    ...
+a: Any = test(42, ())
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleIndexTypeVar]
+from typing import Any, List, Sequence, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+def f(data: Sequence[Tuple[Unpack[Ts]]]) -> List[Any]:
+    return [d[0] for d in data]  # E: Tuple index out of range \
+                                 # N: Variadic tuple can have length 0
+
+T = TypeVar("T")
+def g(data: Sequence[Tuple[T, Unpack[Ts]]]) -> List[T]:
+    return [d[0] for d in data]  # OK
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleOverloadMatch]
+from typing import Any, Generic, overload, Tuple, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+_Ts = TypeVarTuple("_Ts")
+_T = TypeVar("_T")
+_T2 = TypeVar("_T2")
+
+class Container(Generic[_T]): ...
+class Array(Generic[Unpack[_Ts]]): ...
+
+@overload
+def build(entity: Container[_T], /) -> Array[_T]: ...
+@overload
+def build(entity: Container[_T], entity2: Container[_T2], /) -> Array[_T, _T2]: ...
+@overload
+def build(*entities: Container[Any]) -> Array[Unpack[Tuple[Any, ...]]]: ...
+def build(*entities: Container[Any]) -> Array[Unpack[Tuple[Any, ...]]]:
+    ...
+
+def test(a: Container[Any], b: Container[int], c: Container[str]):
+    reveal_type(build(a, b))  # N: Revealed type is "__main__.Array[Any, builtins.int]"
+    reveal_type(build(b, c))  # N: Revealed type is "__main__.Array[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleOverloadArbitraryLength]
+from typing import Any, Tuple, TypeVar, TypeVarTuple, Unpack, overload
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+@overload
+def add(self: Tuple[Unpack[Ts]], other: Tuple[T]) -> Tuple[Unpack[Ts], T]:
+    ...
+@overload
+def add(self: Tuple[T, ...], other: Tuple[T, ...]) -> Tuple[T, ...]:
+    ...
+def add(self: Any, other: Any) -> Any:
+    ...
+def test(a: Tuple[int, str], b: Tuple[bool], c: Tuple[bool, ...]):
+    reveal_type(add(a, b))  # N: Revealed type is "Tuple[builtins.int, builtins.str, builtins.bool]"
+    reveal_type(add(b, c))  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleOverloadOverlap]
+from typing import Union, overload, Tuple
+from typing_extensions import Unpack
+
+class Int(int): ...
+
+A = Tuple[int, Unpack[Tuple[int, ...]]]
+B = Tuple[int, Unpack[Tuple[str, ...]]]
+
+@overload
+def f(arg: A) -> int: ...
+@overload
+def f(arg: B) -> str: ...
+def f(arg: Union[A, B]) -> Union[int, str]:
+    ...
+
+A1 = Tuple[int, Unpack[Tuple[Int, ...]]]
+B1 = Tuple[Unpack[Tuple[Int, ...]], int]
+
+@overload
+def f1(arg: A1) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+@overload
+def f1(arg: B1) -> str: ...
+def f1(arg: Union[A1, B1]) -> Union[int, str]:
+    ...
+
+A2 = Tuple[int, int, int]
+B2 = Tuple[int, Unpack[Tuple[int, ...]]]
+
+@overload
+def f2(arg: A2) -> int: ...  # E: Overloaded function signatures 1 and 2 overlap with incompatible return types
+@overload
+def f2(arg: B2) -> str: ...
+def f2(arg: Union[A2, B2]) -> Union[int, str]:
+    ...
+
+A3 = Tuple[int, int, int]
+B3 = Tuple[int, Unpack[Tuple[str, ...]]]
+
+@overload
+def f3(arg: A3) -> int: ...
+@overload
+def f3(arg: B3) -> str: ...
+def f3(arg: Union[A3, B3]) -> Union[int, str]:
+    ...
+
+A4 = Tuple[int, int, Unpack[Tuple[int, ...]]]
+B4 = Tuple[int]
+
+@overload
+def f4(arg: A4) -> int: ...
+@overload
+def f4(arg: B4) -> str: ...
+def f4(arg: Union[A4, B4]) -> Union[int, str]:
+    ...
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleIndexOldStyleNonNormalizedAndNonLiteral]
+from typing import Any, Tuple
+from typing_extensions import Unpack
+
+t: Tuple[Unpack[Tuple[int, ...]]]
+reveal_type(t[42])  # N: Revealed type is "builtins.int"
+i: int
+reveal_type(t[i])  # N: Revealed type is "builtins.int"
+t1: Tuple[int, Unpack[Tuple[int, ...]]]
+reveal_type(t1[i])  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleNotConcreteCallable]
+from typing_extensions import Unpack, TypeVarTuple
+from typing import Callable, TypeVar, Tuple
+
+T = TypeVar("T")
+Args = TypeVarTuple("Args")
+Args2 = TypeVarTuple("Args2")
+
+def submit(fn: Callable[[Unpack[Args]], T], *args: Unpack[Args]) -> T:
+    ...
+
+def submit2(fn: Callable[[int, Unpack[Args]], T], *args: Unpack[Tuple[int, Unpack[Args]]]) -> T:
+    ...
+
+def foo(func: Callable[[Unpack[Args]], T], *args: Unpack[Args]) -> T:
+   return submit(func, *args)
+
+def foo2(func: Callable[[Unpack[Args2]], T], *args: Unpack[Args2]) -> T:
+   return submit(func, *args)
+
+def foo3(func: Callable[[int, Unpack[Args2]], T], *args: Unpack[Args2]) -> T:
+   return submit2(func, 1, *args)
+
+def foo_bad(func: Callable[[Unpack[Args2]], T], *args: Unpack[Args2]) -> T:
+   return submit2(func, 1, *args)  # E: Argument 1 to "submit2" has incompatible type "Callable[[VarArg(Unpack[Args2])], T]"; expected "Callable[[int, VarArg(Unpack[Args2])], T]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleParamSpecInteraction]
+from typing_extensions import Unpack, TypeVarTuple, ParamSpec
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+Args = TypeVarTuple("Args")
+Args2 = TypeVarTuple("Args2")
+P = ParamSpec("P")
+
+def submit(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    ...
+
+def foo(func: Callable[[Unpack[Args]], T], *args: Unpack[Args]) -> T:
+   return submit(func, *args)
+
+def foo2(func: Callable[[Unpack[Args]], T], *args: Unpack[Args2]) -> T:
+   return submit(func, *args)  # E: Argument 2 to "submit" has incompatible type "*Tuple[Unpack[Args2]]"; expected "Unpack[Args]"
+
+def foo3(func: Callable[[int, Unpack[Args2]], T], *args: Unpack[Args2]) -> T:
+   return submit(func, 1, *args)
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleEmptySpecialCase]
+from typing import Any, Callable, Generic
+from typing_extensions import Unpack, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+class MyClass(Generic[Unpack[Ts]]):
+    func: Callable[[Unpack[Ts]], object]
+
+    def __init__(self, func: Callable[[Unpack[Ts]], object]) -> None:
+        self.func = func
+
+explicit: MyClass[()]
+reveal_type(explicit)  # N: Revealed type is "__main__.MyClass[()]"
+reveal_type(explicit.func)  # N: Revealed type is "def () -> builtins.object"
+
+a: Any
+explicit_2 = MyClass[()](a)
+reveal_type(explicit_2)  # N: Revealed type is "__main__.MyClass[()]"
+reveal_type(explicit_2.func)  # N: Revealed type is "def () -> builtins.object"
+
+Alias = MyClass[()]
+explicit_3: Alias
+reveal_type(explicit_3)  # N: Revealed type is "__main__.MyClass[()]"
+reveal_type(explicit_3.func)  # N: Revealed type is "def () -> builtins.object"
+
+explicit_4 = Alias(a)
+reveal_type(explicit_4)  # N: Revealed type is "__main__.MyClass[()]"
+reveal_type(explicit_4.func)  # N: Revealed type is "def () -> builtins.object"
+
+def no_args() -> None: ...
+implicit = MyClass(no_args)
+reveal_type(implicit)  # N: Revealed type is "__main__.MyClass[()]"
+reveal_type(implicit.func)  # N: Revealed type is "def () -> builtins.object"
+
+def one_arg(__a: int) -> None: ...
+x = MyClass(one_arg)
+x = explicit  # E: Incompatible types in assignment (expression has type "MyClass[()]", variable has type "MyClass[int]")
+
+# Consistently handle special case for no argument aliases
+Direct = MyClass
+y = Direct(one_arg)
+reveal_type(y)  # N: Revealed type is "__main__.MyClass[builtins.int]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleRuntimeTypeApplication]
+from typing import Generic, TypeVar, Tuple
+from typing_extensions import Unpack, TypeVarTuple
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+class C(Generic[T, Unpack[Ts], S]): ...
+
+Ints = Tuple[int, int]
+x = C[Unpack[Ints]]()
+reveal_type(x)  # N: Revealed type is "__main__.C[builtins.int, builtins.int]"
+
+y = C[Unpack[Tuple[int, ...]]]()
+reveal_type(y)  # N: Revealed type is "__main__.C[builtins.int, Unpack[builtins.tuple[builtins.int, ...]], builtins.int]"
+
+z = C[int]()  # E: Bad number of arguments, expected: at least 2, given: 1
+reveal_type(z)  # N: Revealed type is "__main__.C[Any, Unpack[builtins.tuple[Any, ...]], Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleTupleSubclassPrefixSuffix]
+from typing import Tuple
+from typing_extensions import Unpack
+
+i: int
+
+class A(Tuple[int, Unpack[Tuple[int, ...]]]): ...
+a: A
+reveal_type(a[i])  # N: Revealed type is "builtins.int"
+
+class B(Tuple[Unpack[Tuple[int, ...]], int]): ...
+b: B
+reveal_type(b[i])  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicClassSubclassInit]
+from typing import Tuple, Generic, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]):
+    def __init__(self, x: Tuple[Unpack[Ts]], *args: Unpack[Ts]) -> None: ...
+reveal_type(B)  # N: Revealed type is "def [Ts] (x: Tuple[Unpack[Ts`1]], *args: Unpack[Ts`1]) -> __main__.B[Unpack[Ts`1]]"
+
+T = TypeVar("T")
+S = TypeVar("S")
+class C(B[T, S]): ...
+reveal_type(C)  # N: Revealed type is "def [T, S] (x: Tuple[T`1, S`2], T`1, S`2) -> __main__.C[T`1, S`2]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicClassGenericSelf]
+from typing import Tuple, Generic, TypeVar
+from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+S = TypeVar("S")
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]):
+    def copy(self: T) -> T: ...
+    def on_pair(self: B[T, S]) -> Tuple[T, S]: ...
+
+b1: B[int]
+reveal_type(b1.on_pair())  # E: Invalid self argument "B[int]" to attribute function "on_pair" with type "Callable[[B[T, S]], Tuple[T, S]]" \
+                           # N: Revealed type is "Tuple[Never, Never]"
+b2: B[int, str]
+reveal_type(b2.on_pair())  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+b3: B[int, str, int]
+reveal_type(b3.on_pair())  # E: Invalid self argument "B[int, str, int]" to attribute function "on_pair" with type "Callable[[B[T, S]], Tuple[T, S]]" \
+                           # N: Revealed type is "Tuple[Never, Never]"
+
+class C(B[T, S]): ...
+c: C[int, str]
+reveal_type(c.copy())  # N: Revealed type is "__main__.C[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicClassNewStyleSelf]
+from typing import Generic, TypeVar, Self
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class B(Generic[Unpack[Ts]]):
+    next: Self
+    def copy(self) -> Self:
+        return self.next
+
+b: B[int, str, int]
+reveal_type(b.next)  # N: Revealed type is "__main__.B[builtins.int, builtins.str, builtins.int]"
+reveal_type(b.copy())  # N: Revealed type is "__main__.B[builtins.int, builtins.str, builtins.int]"
+reveal_type(B.copy(b))  # N: Revealed type is "__main__.B[builtins.int, builtins.str, builtins.int]"
+
+T = TypeVar("T")
+S = TypeVar("S")
+class C(B[T, S]): ...
+c: C[int, str]
+
+reveal_type(c.next)  # N: Revealed type is "__main__.C[builtins.int, builtins.str]"
+reveal_type(c.copy())  # N: Revealed type is "__main__.C[builtins.int, builtins.str]"
+reveal_type(C.copy(c))  # N: Revealed type is "__main__.C[builtins.int, builtins.str]"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleDataclass]
+from dataclasses import dataclass
+from typing import Generic, TypeVar, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+
+@dataclass
+class B(Generic[Unpack[Ts]]):
+    items: Tuple[Unpack[Ts]]
+
+reveal_type(B)  # N: Revealed type is "def [Ts] (items: Tuple[Unpack[Ts`1]]) -> __main__.B[Unpack[Ts`1]]"
+b = B((1, "yes"))
+reveal_type(b.items)  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+@dataclass
+class C(B[T, S]):
+    first: T
+    second: S
+
+reveal_type(C)  # N: Revealed type is "def [T, S] (items: Tuple[T`1, S`2], first: T`1, second: S`2) -> __main__.C[T`1, S`2]"
+c = C((1, "yes"), 2, "no")
+reveal_type(c.items)  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+reveal_type(c.first)  # N: Revealed type is "builtins.int"
+reveal_type(c.second)  # N: Revealed type is "builtins.str"
+[builtins fixtures/dataclasses.pyi]
+[typing fixtures/typing-medium.pyi]
+
+[case testVariadicTupleInProtocol]
+from typing import Protocol, Tuple, List
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class P(Protocol[Unpack[Ts]]):
+    def items(self) -> Tuple[Unpack[Ts]]: ...
+
+class PC(Protocol[Unpack[Ts]]):
+    def meth(self, *args: Unpack[Ts]) -> None: ...
+
+def get_items(x: P[Unpack[Ts]]) -> Tuple[Unpack[Ts]]: ...
+def match(x: PC[Unpack[Ts]]) -> Tuple[Unpack[Ts]]: ...
+
+class Bad:
+    def items(self) -> List[int]: ...
+    def meth(self, *, named: int) -> None: ...
+
+class Good:
+    def items(self) -> Tuple[int, str]: ...
+    def meth(self, __x: int, y: str) -> None: ...
+
+g: Good
+reveal_type(get_items(g))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+reveal_type(match(g))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+
+b: Bad
+get_items(b)  # E: Argument 1 to "get_items" has incompatible type "Bad"; expected "P[Unpack[Tuple[Never, ...]]]" \
+              # N: Following member(s) of "Bad" have conflicts: \
+              # N:     Expected: \
+              # N:         def items(self) -> Tuple[Never, ...] \
+              # N:     Got: \
+              # N:         def items(self) -> List[int]
+match(b)  # E: Argument 1 to "match" has incompatible type "Bad"; expected "PC[Unpack[Tuple[Never, ...]]]" \
+          # N: Following member(s) of "Bad" have conflicts: \
+          # N:     Expected: \
+          # N:         def meth(self, *args: Never) -> None \
+          # N:     Got: \
+          # N:         def meth(self, *, named: int) -> None
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleCollectionCheck]
+from typing import Tuple, Optional
+from typing_extensions import Unpack
+
+allowed: Tuple[int, Unpack[Tuple[int, ...]]]
+
+x: Optional[int]
+if x in allowed:
+    reveal_type(x)  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testJoinOfVariadicTupleCallablesNoCrash]
+from typing import Callable, Tuple
+
+f: Callable[[int, *Tuple[str, ...], int], None]
+g: Callable[[int, *Tuple[str, ...], int], None]
+reveal_type([f, g])  # N: Revealed type is "builtins.list[def (builtins.int, *Unpack[Tuple[Unpack[builtins.tuple[builtins.str, ...]], builtins.int]])]"
+
+h: Callable[[int, *Tuple[str, ...], str], None]
+reveal_type([f, h])  # N: Revealed type is "builtins.list[def (builtins.int, *Unpack[Tuple[Unpack[builtins.tuple[builtins.str, ...]], Never]])]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleBothUnpacksSimple]
+from typing import Tuple, TypedDict
+from typing_extensions import Unpack, TypeVarTuple
+
+class Keywords(TypedDict):
+    a: str
+    b: str
+
+Ints = Tuple[int, ...]
+
+def f(*args: Unpack[Ints], other: str = "no", **kwargs: Unpack[Keywords]) -> None: ...
+reveal_type(f)  # N: Revealed type is "def (*args: builtins.int, other: builtins.str =, **kwargs: Unpack[TypedDict('__main__.Keywords', {'a': builtins.str, 'b': builtins.str})])"
+f(1, 2, a="a", b="b")  # OK
+f(1, 2, 3)  # E: Missing named argument "a" for "f" \
+            # E: Missing named argument "b" for "f"
+
+Ts = TypeVarTuple("Ts")
+def g(*args: Unpack[Ts], other: str = "no", **kwargs: Unpack[Keywords]) -> None: ...
+reveal_type(g)  # N: Revealed type is "def [Ts] (*args: Unpack[Ts`-1], other: builtins.str =, **kwargs: Unpack[TypedDict('__main__.Keywords', {'a': builtins.str, 'b': builtins.str})])"
+g(1, 2, a="a", b="b")  # OK
+g(1, 2, 3)  # E: Missing named argument "a" for "g" \
+            # E: Missing named argument "b" for "g"
+
+def bad(
+    *args: Unpack[Keywords],  # E: "Keywords" cannot be unpacked (must be tuple or TypeVarTuple)
+    **kwargs: Unpack[Ints],  # E: Unpack item in ** argument must be a TypedDict
+) -> None: ...
+reveal_type(bad)  # N: Revealed type is "def (*args: Any, **kwargs: Any)"
+
+def bad2(
+    one: int,
+    *args: Unpack[Keywords],  # E: "Keywords" cannot be unpacked (must be tuple or TypeVarTuple)
+    other: str = "no",
+     **kwargs: Unpack[Ints],  # E: Unpack item in ** argument must be a TypedDict
+) -> None: ...
+reveal_type(bad2)  # N: Revealed type is "def (one: builtins.int, *args: Any, other: builtins.str =, **kwargs: Any)"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypeVarTupleBothUnpacksCallable]
+from typing import Callable, Tuple, TypedDict
+from typing_extensions import Unpack
+
+class Keywords(TypedDict):
+    a: str
+    b: str
+Ints = Tuple[int, ...]
+
+cb: Callable[[Unpack[Ints], Unpack[Keywords]], None]
+reveal_type(cb)  # N: Revealed type is "def (*builtins.int, **Unpack[TypedDict('__main__.Keywords', {'a': builtins.str, 'b': builtins.str})])"
+
+cb2: Callable[[int, Unpack[Ints], int, Unpack[Keywords]], None]
+reveal_type(cb2)  # N: Revealed type is "def (builtins.int, *Unpack[Tuple[Unpack[builtins.tuple[builtins.int, ...]], builtins.int]], **Unpack[TypedDict('__main__.Keywords', {'a': builtins.str, 'b': builtins.str})])"
+cb2(1, 2, 3, a="a", b="b")
+cb2(1, a="a", b="b")  # E: Too few arguments
+cb2(1, 2, 3, a="a")  # E: Missing named argument "b"
+
+bad1: Callable[[Unpack[Ints], Unpack[Ints]], None]  # E: More than one Unpack in a type is not allowed
+reveal_type(bad1)  # N: Revealed type is "def (*builtins.int)"
+bad2: Callable[[Unpack[Keywords], Unpack[Keywords]], None]  # E: "Keywords" cannot be unpacked (must be tuple or TypeVarTuple)
+reveal_type(bad2)  # N: Revealed type is "def (*Any, **Unpack[TypedDict('__main__.Keywords', {'a': builtins.str, 'b': builtins.str})])"
+bad3: Callable[[Unpack[Keywords], Unpack[Ints]], None]  # E: "Keywords" cannot be unpacked (must be tuple or TypeVarTuple) \
+                                                        # E: More than one Unpack in a type is not allowed
+reveal_type(bad3)  # N: Revealed type is "def (*Any)"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypeVarTupleBothUnpacksApplication]
+from typing import Callable, TypedDict, TypeVar, Optional
+from typing_extensions import Unpack, TypeVarTuple
+
+class Keywords(TypedDict):
+    a: str
+    b: str
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+def test(
+    x: int,
+    func: Callable[[Unpack[Ts]], T],
+    *args: Unpack[Ts],
+    other: Optional[str] = None,
+    **kwargs: Unpack[Keywords],
+) -> T:
+    if bool():
+        func(*args, **kwargs)  # E: Extra argument "a" from **args
+    return func(*args)
+def test2(
+    x: int,
+    func: Callable[[Unpack[Ts], Unpack[Keywords]], T],
+    *args: Unpack[Ts],
+    other: Optional[str] = None,
+    **kwargs: Unpack[Keywords],
+) -> T:
+    if bool():
+        func(*args)  # E: Missing named argument "a" \
+                     # E: Missing named argument "b"
+    return func(*args, **kwargs)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testUnpackTupleSpecialCaseNoCrash]
+from typing import Tuple, TypeVar
+from typing_extensions import Unpack
+
+T = TypeVar("T")
+
+def foo(*x: object) -> None: ...
+def bar(*x: int) -> None: ...
+def baz(*x: T) -> T: ...
+
+keys: Tuple[Unpack[Tuple[int, ...]]]
+
+foo(keys, 1)
+foo(*keys, 1)
+
+bar(keys, 1)  # E: Argument 1 to "bar" has incompatible type "Tuple[Unpack[Tuple[int, ...]]]"; expected "int"
+bar(*keys, 1)  # OK
+
+reveal_type(baz(keys, 1))  # N: Revealed type is "builtins.object"
+reveal_type(baz(*keys, 1))  # N: Revealed type is "builtins.int"
+[builtins fixtures/tuple.pyi]
+
+[case testVariadicTupleContextNoCrash]
+from typing import Tuple, Unpack
+
+x: Tuple[int, Unpack[Tuple[int, ...]]] = ()  # E: Incompatible types in assignment (expression has type "Tuple[()]", variable has type "Tuple[int, Unpack[Tuple[int, ...]]]")
+y: Tuple[int, Unpack[Tuple[int, ...]]] = (1, 2)
+z: Tuple[int, Unpack[Tuple[int, ...]]] = (1,)
+w: Tuple[int, Unpack[Tuple[int, ...]]] = (1, *[2, 3, 4])
+t: Tuple[int, Unpack[Tuple[int, ...]]] = (1, *(2, 3, 4))
+[builtins fixtures/tuple.pyi]
+
+[case testAliasToCallableWithUnpack]
+from typing import Any, Callable, Tuple, Unpack
+
+_CallableValue = Callable[[Unpack[Tuple[Any, ...]]], Any]
+def higher_order(f: _CallableValue) -> None: ...
+
+def good1(*args: int) -> None: ...
+def good2(*args: str) -> int: ...
+
+# These are special-cased for *args: Any (as opposite to *args: object)
+def ok1(a: str, b: int, /) -> None: ...
+def ok2(c: bytes, *args: int) -> str: ...
+
+def bad1(*, d: str) -> int: ...
+def bad2(**kwargs: None) -> None: ...
+
+higher_order(good1)
+higher_order(good2)
+
+higher_order(ok1)
+higher_order(ok2)
+
+higher_order(bad1)  # E: Argument 1 to "higher_order" has incompatible type "Callable[[NamedArg(str, 'd')], int]"; expected "Callable[[VarArg(Any)], Any]"
+higher_order(bad2)  # E: Argument 1 to "higher_order" has incompatible type "Callable[[KwArg(None)], None]"; expected "Callable[[VarArg(Any)], Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testAliasToCallableWithUnpack2]
+from typing import Any, Callable, Tuple, Unpack
+
+_CallableValue = Callable[[int, str, Unpack[Tuple[Any, ...]], int], Any]
+def higher_order(f: _CallableValue) -> None: ...
+
+def good(a: int, b: str, *args: Unpack[Tuple[Unpack[Tuple[Any, ...]], int]]) -> int: ...
+def bad1(a: str, b: int, /) -> None: ...
+def bad2(c: bytes, *args: int) -> str: ...
+def bad3(*, d: str) -> int: ...
+def bad4(**kwargs: None) -> None: ...
+
+higher_order(good)
+higher_order(bad1)  # E: Argument 1 to "higher_order" has incompatible type "Callable[[str, int], None]"; expected "Callable[[int, str, VarArg(Unpack[Tuple[Unpack[Tuple[Any, ...]], int]])], Any]"
+higher_order(bad2)  # E: Argument 1 to "higher_order" has incompatible type "Callable[[bytes, VarArg(int)], str]"; expected "Callable[[int, str, VarArg(Unpack[Tuple[Unpack[Tuple[Any, ...]], int]])], Any]"
+higher_order(bad3)  # E: Argument 1 to "higher_order" has incompatible type "Callable[[NamedArg(str, 'd')], int]"; expected "Callable[[int, str, VarArg(Unpack[Tuple[Unpack[Tuple[Any, ...]], int]])], Any]"
+higher_order(bad4)  # E: Argument 1 to "higher_order" has incompatible type "Callable[[KwArg(None)], None]"; expected "Callable[[int, str, VarArg(Unpack[Tuple[Unpack[Tuple[Any, ...]], int]])], Any]"
+[builtins fixtures/tuple.pyi]
+
+[case testAliasToCallableWithUnpackInvalid]
+from typing import Any, Callable, List, Tuple, TypeVar, Unpack
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")  # E: Name "TypeVarTuple" is not defined
+
+def good(*x: int) -> int: ...
+def bad(*x: int, y: int) -> int: ...
+
+Alias = Callable[[Unpack[T]], int]  # E: "T" cannot be unpacked (must be tuple or TypeVarTuple)
+x: Alias[int]
+reveal_type(x)  # N: Revealed type is "def (*Any) -> builtins.int"
+x = good
+x = bad  # E: Incompatible types in assignment (expression has type "Callable[[VarArg(int), NamedArg(int, 'y')], int]", variable has type "Callable[[VarArg(Any)], int]")
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleInvariant]
+from typing import Generic, Tuple
+from typing_extensions import Unpack, TypeVarTuple
+Ts = TypeVarTuple("Ts")
+
+class Array(Generic[Unpack[Ts]]): ...
+
+def pointwise_multiply(x: Array[Unpack[Ts]], y: Array[Unpack[Ts]]) -> Array[Unpack[Ts]]: ...
+
+def a1(x: Array[int], y: Array[str], z: Array[int, str]) -> None:
+    reveal_type(pointwise_multiply(x, x))  # N: Revealed type is "__main__.Array[builtins.int]"
+    reveal_type(pointwise_multiply(x, y))  # E: Cannot infer type argument 1 of "pointwise_multiply" \
+                                           # N: Revealed type is "__main__.Array[Unpack[builtins.tuple[Any, ...]]]"
+    reveal_type(pointwise_multiply(x, z))  # E: Cannot infer type argument 1 of "pointwise_multiply" \
+                                           # N: Revealed type is "__main__.Array[Unpack[builtins.tuple[Any, ...]]]"
+
+def func(x: Array[Unpack[Ts]], *args: Unpack[Ts]) -> Tuple[Unpack[Ts]]:
+    ...
+
+def a2(x: Array[int, str]) -> None:
+    reveal_type(func(x, 2, "Hello"))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+    reveal_type(func(x, 2))           # E: Cannot infer type argument 1 of "func" \
+                                      # N: Revealed type is "builtins.tuple[Any, ...]"
+    reveal_type(func(x, 2, "Hello", True))   # E: Cannot infer type argument 1 of "func" \
+                                             # N: Revealed type is "builtins.tuple[Any, ...]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleTypeApplicationOverload]
+from typing import Generic, TypeVar, TypeVarTuple, Unpack, overload, Callable
+
+T = TypeVar("T")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+T3 = TypeVar("T3")
+Ts = TypeVarTuple("Ts")
+
+class C(Generic[T, Unpack[Ts]]):
+    @overload
+    def __init__(self, f: Callable[[Unpack[Ts]], T]) -> None: ...
+    @overload
+    def __init__(self, f: Callable[[T1, T2, T3, Unpack[Ts]], T], a: T1, b: T2, c: T3) -> None: ...
+    def __init__(self, f, *args, **kwargs) -> None:
+        ...
+
+reveal_type(C[int, str])  # N: Revealed type is "Overload(def (f: def (builtins.str) -> builtins.int) -> __main__.C[builtins.int, builtins.str], def [T1, T2, T3] (f: def (T1`-1, T2`-2, T3`-3, builtins.str) -> builtins.int, a: T1`-1, b: T2`-2, c: T3`-3) -> __main__.C[builtins.int, builtins.str])"
+Alias = C[int, str]
+
+def f(x: int, y: int, z: int, t: int) -> str: ...
+x = C(f, 0, 0, "hm")  # E: Argument 1 to "C" has incompatible type "Callable[[int, int, int, int], str]"; expected "Callable[[int, int, str, int], str]"
+reveal_type(x)  # N: Revealed type is "__main__.C[builtins.str, builtins.int]"
+reveal_type(C(f))  # N: Revealed type is "__main__.C[builtins.str, builtins.int, builtins.int, builtins.int, builtins.int]"
+C[()]  # E: At least 1 type argument(s) expected, none given
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleAgainstParamSpecActualSuccess]
+from typing import Generic, TypeVar, TypeVarTuple, Unpack, Callable, Tuple, List
+from typing_extensions import ParamSpec
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+class CM(Generic[R]): ...
+def cm(fn: Callable[P, R]) -> Callable[P, CM[R]]: ...
+
+Ts = TypeVarTuple("Ts")
+@cm
+def test(*args: Unpack[Ts]) -> Tuple[Unpack[Ts]]: ...
+
+reveal_type(test)  # N: Revealed type is "def [Ts] (*args: Unpack[Ts`-1]) -> __main__.CM[Tuple[Unpack[Ts`-1]]]"
+reveal_type(test(1, 2, 3))  # N: Revealed type is "__main__.CM[Tuple[Literal[1]?, Literal[2]?, Literal[3]?]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleAgainstParamSpecActualFailedNoCrash]
+from typing import Generic, TypeVar, TypeVarTuple, Unpack, Callable, Tuple, List
+from typing_extensions import ParamSpec
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+class CM(Generic[R]): ...
+def cm(fn: Callable[P, List[R]]) -> Callable[P, CM[R]]: ...
+
+Ts = TypeVarTuple("Ts")
+@cm  # E: Argument 1 to "cm" has incompatible type "Callable[[VarArg(Unpack[Ts])], Tuple[Unpack[Ts]]]"; expected "Callable[[VarArg(Never)], List[Never]]"
+def test(*args: Unpack[Ts]) -> Tuple[Unpack[Ts]]: ...
+
+reveal_type(test)  # N: Revealed type is "def (*args: Never) -> __main__.CM[Never]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleAgainstParamSpecActualPrefix]
+from typing import Generic, TypeVar, TypeVarTuple, Unpack, Callable, Tuple, List
+from typing_extensions import ParamSpec, Concatenate
+
+R = TypeVar("R")
+P = ParamSpec("P")
+T = TypeVar("T")
+
+class CM(Generic[R]): ...
+def cm(fn: Callable[Concatenate[T, P], R]) -> Callable[Concatenate[List[T], P], CM[R]]: ...
+
+Ts = TypeVarTuple("Ts")
+@cm
+def test(x: T, *args: Unpack[Ts]) -> Tuple[T, Unpack[Ts]]: ...
+
+reveal_type(test)  # N: Revealed type is "def [T, Ts] (builtins.list[T`2], *args: Unpack[Ts`-2]) -> __main__.CM[Tuple[T`2, Unpack[Ts`-2]]]"
+[builtins fixtures/tuple.pyi]
+
+[case testMixingTypeVarTupleAndParamSpec]
+from typing import Generic, ParamSpec, TypeVarTuple, Unpack, Callable, TypeVar
+
+P = ParamSpec("P")
+Ts = TypeVarTuple("Ts")
+
+class A(Generic[P, Unpack[Ts]]): ...
+class B(Generic[Unpack[Ts], P]): ...
+
+a: A[[int, str], int, str]
+reveal_type(a)  # N: Revealed type is "__main__.A[[builtins.int, builtins.str], builtins.int, builtins.str]"
+b: B[int, str, [int, str]]
+reveal_type(b)  # N: Revealed type is "__main__.B[builtins.int, builtins.str, [builtins.int, builtins.str]]"
+
+x: A[int, str, [int, str]]  # E: Can only replace ParamSpec with a parameter types list or another ParamSpec, got "int"
+reveal_type(x)  # N: Revealed type is "__main__.A[Any, Unpack[builtins.tuple[Any, ...]]]"
+y: B[[int, str], int, str]  # E: Can only replace ParamSpec with a parameter types list or another ParamSpec, got "str"
+reveal_type(y)  # N: Revealed type is "__main__.B[Unpack[builtins.tuple[Any, ...]], Any]"
+
+R = TypeVar("R")
+class C(Generic[P, R]):
+    fn: Callable[P, None]
+
+c: C[int, str]  # E: Can only replace ParamSpec with a parameter types list or another ParamSpec, got "int"
+reveal_type(c.fn)  # N: Revealed type is "def (*Any, **Any)"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleInstanceOverlap]
+# flags: --strict-equality
+from typing import TypeVarTuple, Unpack, Generic
+
+Ts = TypeVarTuple("Ts")
+
+class Foo(Generic[Unpack[Ts]]):
+    pass
+
+x1: Foo[Unpack[tuple[int, ...]]]
+y1: Foo[Unpack[tuple[str, ...]]]
+x1 is y1  # E: Non-overlapping identity check (left operand type: "Foo[Unpack[Tuple[int, ...]]]", right operand type: "Foo[Unpack[Tuple[str, ...]]]")
+
+x2: Foo[Unpack[tuple[int, ...]]]
+y2: Foo[Unpack[tuple[int, ...]]]
+x2 is y2
+
+x3: Foo[Unpack[tuple[int, ...]]]
+y3: Foo[Unpack[tuple[int, int]]]
+x3 is y3
+
+x4: Foo[Unpack[tuple[str, ...]]]
+y4: Foo[Unpack[tuple[int, int]]]
+x4 is y4  # E: Non-overlapping identity check (left operand type: "Foo[Unpack[Tuple[str, ...]]]", right operand type: "Foo[int, int]")
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleErasureNormalized]
+from typing import TypeVarTuple, Unpack, Generic, Union
+from collections.abc import Callable
+
+Args = TypeVarTuple("Args")
+
+class Built(Generic[Unpack[Args]]):
+    pass
+
+def example(
+    fn: Union[Built[Unpack[Args]], Callable[[Unpack[Args]], None]]
+) -> Built[Unpack[Args]]: ...
+
+@example
+def command() -> None:
+    return
+reveal_type(command)  # N: Revealed type is "__main__.Built[()]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleSelfMappedPrefix]
+from typing import TypeVarTuple, Generic, Unpack
+
+Ts = TypeVarTuple("Ts")
+class Base(Generic[Unpack[Ts]]):
+    attr: tuple[Unpack[Ts]]
+
+    @property
+    def prop(self) -> tuple[Unpack[Ts]]:
+        return self.attr
+
+    def meth(self) -> tuple[Unpack[Ts]]:
+        return self.attr
+
+Ss = TypeVarTuple("Ss")
+class Derived(Base[str, Unpack[Ss]]):
+    def test(self) -> None:
+        reveal_type(self.attr)  # N: Revealed type is "Tuple[builtins.str, Unpack[Ss`1]]"
+        reveal_type(self.prop)  # N: Revealed type is "Tuple[builtins.str, Unpack[Ss`1]]"
+        reveal_type(self.meth())  # N: Revealed type is "Tuple[builtins.str, Unpack[Ss`1]]"
+[builtins fixtures/property.pyi]
+
+[case testTypeVarTupleProtocolPrefix]
+from typing import Protocol, Unpack, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+class A(Protocol[Unpack[Ts]]):
+    def f(self, z: str, *args: Unpack[Ts]) -> None: ...
+
+class C:
+    def f(self, z: str, x: int) -> None: ...
+
+def f(x: A[Unpack[Ts]]) -> tuple[Unpack[Ts]]: ...
+
+reveal_type(f(C()))  # N: Revealed type is "Tuple[builtins.int]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleHomogeneousCallableNormalized]
+from typing import Generic, Unpack, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]):
+    def foo(self, *args: Unpack[Ts]) -> None: ...
+
+c: C[Unpack[tuple[int, ...]]]
+reveal_type(c.foo)  # N: Revealed type is "def (*args: builtins.int)"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleJoinInstanceTypeVar]
+from typing import Any, Unpack, TypeVarTuple, TypeVar
+
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+
+def join(x: T, y: T) -> T: ...
+def test(xs: tuple[Unpack[Ts]], xsi: tuple[int, Unpack[Ts]]) -> None:
+    a: tuple[Any, ...]
+    reveal_type(join(xs, a))  # N: Revealed type is "builtins.tuple[Any, ...]"
+    reveal_type(join(a, xs))  # N: Revealed type is "builtins.tuple[Any, ...]"
+    aa: tuple[Unpack[tuple[Any, ...]]]
+    reveal_type(join(xs, aa))  # N: Revealed type is "builtins.tuple[Any, ...]"
+    reveal_type(join(aa, xs))  # N: Revealed type is "builtins.tuple[Any, ...]"
+    ai: tuple[int, Unpack[tuple[Any, ...]]]
+    reveal_type(join(xsi, ai))  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[Any, ...]]]"
+    reveal_type(join(ai, xsi))  # N: Revealed type is "Tuple[builtins.int, Unpack[builtins.tuple[Any, ...]]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTupleInferAgainstAnyCallableSuffix]
+from typing import Any, Callable, TypeVar, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+R = TypeVar("R")
+def deco(func: Callable[[*Ts, int], R]) -> Callable[[*Ts], R]:
+    ...
+
+untyped: Any
+reveal_type(deco(untyped))  # N: Revealed type is "def (*Any) -> Any"
+[builtins fixtures/tuple.pyi]
+
+[case testNoCrashOnNonNormalUnpackInCallable]
+from typing import Callable, Unpack, TypeVar
+
+T = TypeVar("T")
+def fn(f: Callable[[*tuple[T]], int]) -> Callable[[*tuple[T]], int]: ...
+
+def test(*args: Unpack[tuple[T]]) -> int: ...
+reveal_type(fn(test))  # N: Revealed type is "def [T] (T`1) -> builtins.int"
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-typevar-unbound.test b/test-data/unit/check-typevar-unbound.test
index d3e54c75e373..587ae6577328 100644
--- a/test-data/unit/check-typevar-unbound.test
+++ b/test-data/unit/check-typevar-unbound.test
@@ -15,8 +15,7 @@ def g() -> U: # E: A function returning TypeVar should receive at least one argu
 
 V = TypeVar('V', int, str)
 
-# TODO: this should also give an error
-def h() -> V:
+def h() -> V:  # E: A function returning TypeVar should receive at least one argument containing the same TypeVar
     ...
 
 [case testInnerFunctionTypeVar]
@@ -70,3 +69,50 @@ from typing import TypeVar
 T = TypeVar("T")
 def f(t: T) -> None:
     a, *b = t  # E: "object" object is not iterable
+
+[case testTypeVarType]
+from typing import Mapping, Type, TypeVar, Union
+T = TypeVar("T")
+
+class A: ...
+class B: ...
+
+lookup_table: Mapping[str, Type[Union[A,B]]]
+def load(lookup_table: Mapping[str, Type[T]], lookup_key: str) -> T:
+    ...
+reveal_type(load(lookup_table, "a"))  # N: Revealed type is "Union[__main__.A, __main__.B]"
+
+lookup_table_a: Mapping[str, Type[A]]
+def load2(lookup_table: Mapping[str, Type[Union[T, int]]], lookup_key: str) -> T:
+    ...
+reveal_type(load2(lookup_table_a, "a"))  # N: Revealed type is "__main__.A"
+
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarTypeAssignment]
+# Adapted from https://github.com/python/mypy/issues/12115
+from typing import TypeVar, Type, Callable, Union, Any
+
+t1: Type[bool] = bool
+t2: Union[Type[bool], Type[str]] = bool
+
+T1 = TypeVar("T1", bound=Union[bool, str])
+def foo1(t: Type[T1]) -> None: ...
+foo1(t1)
+foo1(t2)
+
+T2 = TypeVar("T2", bool, str)
+def foo2(t: Type[T2]) -> None: ...
+foo2(t1)
+# Rejected correctly: T2 cannot be Union[bool, str]
+foo2(t2)  # E: Value of type variable "T2" of "foo2" cannot be "Union[bool, str]"
+
+T3 = TypeVar("T3")
+def foo3(t: Type[T3]) -> None: ...
+foo3(t1)
+foo3(t2)
+
+def foo4(t: Type[Union[bool, str]]) -> None: ...
+foo4(t1)
+foo4(t2)
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-typevar-values.test b/test-data/unit/check-typevar-values.test
index 83340c52b63b..36ab3af6d3e9 100644
--- a/test-data/unit/check-typevar-values.test
+++ b/test-data/unit/check-typevar-values.test
@@ -21,7 +21,7 @@ if int():
     s = f('')
     o = f(1) \
       # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[object]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+      # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
       # N: Consider using "Sequence" instead, which is covariant
 [builtins fixtures/list.pyi]
 
@@ -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 *
@@ -633,8 +633,7 @@ def f(x: S) -> None:
     h(x)
 
 [case testTypeVarWithTypedDictBoundInIndexExpression]
-from typing import TypeVar
-from typing_extensions import TypedDict
+from typing import TypedDict, TypeVar
 
 class Data(TypedDict):
     x: int
@@ -645,11 +644,11 @@ T = TypeVar("T", bound=Data)
 
 def f(data: T) -> None:
     reveal_type(data["x"]) # N: Revealed type is "builtins.int"
-[builtins fixtures/tuple.pyi]
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypeVarWithUnionTypedDictBoundInIndexExpression]
-from typing import TypeVar, Union, Dict
-from typing_extensions import TypedDict
+from typing import TypedDict, TypeVar, Union, Dict
 
 class Data(TypedDict):
     x: int
@@ -661,10 +660,10 @@ T = TypeVar("T", bound=Union[Data, Dict[str, str]])
 def f(data: T) -> None:
     reveal_type(data["x"]) # N: Revealed type is "Union[builtins.int, builtins.str]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testTypeVarWithTypedDictValueInIndexExpression]
-from typing import TypeVar, Union, Dict
-from typing_extensions import TypedDict
+from typing import TypedDict, TypeVar, Union, Dict
 
 class Data(TypedDict):
     x: int
@@ -676,10 +675,10 @@ T = TypeVar("T", Data, Dict[str, str])
 def f(data: T) -> None:
     _: Union[str, int] = data["x"]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testSelfTypeVarIndexExpr]
-from typing import TypeVar, Union, Type
-from typing_extensions import TypedDict
+from typing import TypedDict, TypeVar, Union, Type
 
 T = TypeVar("T", bound="Indexable")
 
@@ -697,6 +696,7 @@ class Indexable:
     def m(self: T) -> T:
         return self["foo"]
 [builtins fixtures/classmethod.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testTypeVarWithValueDeferral]
 from typing import TypeVar, Callable
@@ -706,3 +706,42 @@ Func = Callable[[], T]
 
 class A: ...
 class B: ...
+
+[case testTypeCommentInGenericTypeWithConstrainedTypeVar]
+from typing import Generic, TypeVar
+
+NT = TypeVar("NT", int, float)
+
+class Foo1(Generic[NT]):
+    p = 1  # type: int
+
+class Foo2(Generic[NT]):
+    p, q = 1, 2.0  # type: (int, float)
+
+class Foo3(Generic[NT]):
+    def bar(self) -> None:
+        p = 1  # type: int
+
+class Foo4(Generic[NT]):
+    def bar(self) -> None:
+        p, q = 1, 2.0  # type: (int, float)
+
+def foo3(x: NT) -> None:
+    p = 1  # type: int
+
+def foo4(x: NT) -> None:
+    p, q = 1, 2.0  # type: (int, float)
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarValuesNarrowing]
+from typing import TypeVar
+
+W = TypeVar("W", int, str)
+
+def fn(w: W) -> W:
+    if type(w) is str:
+        reveal_type(w)  # N: Revealed type is "builtins.str"
+    elif type(w) is int:
+        reveal_type(w)  # N: Revealed type is "builtins.int"
+    return w
+[builtins fixtures/isinstance.pyi]
diff --git a/test-data/unit/check-underscores.test b/test-data/unit/check-underscores.test
index ac9fad2ca792..2a789b3314f3 100644
--- a/test-data/unit/check-underscores.test
+++ b/test-data/unit/check-underscores.test
@@ -1,10 +1,4 @@
-[case testUnderscoresRequire36]
-# flags: --python-version 3.5
-x = 1000_000  # E: Underscores in numeric literals are only supported in Python 3.6 and greater
-[out]
-
 [case testUnderscoresBasics]
-# flags: --python-version 3.6
 x: int
 x = 1000_000
 x = 0x_FF_FF_FF_FF
diff --git a/test-data/unit/check-union-error-syntax.test b/test-data/unit/check-union-error-syntax.test
index 2928cc312709..3c541173a891 100644
--- a/test-data/unit/check-union-error-syntax.test
+++ b/test-data/unit/check-union-error-syntax.test
@@ -30,32 +30,28 @@ x = 3 # E: Incompatible types in assignment (expression has type "int", variable
 
 [case testLiteralOrErrorSyntax]
 # flags: --python-version 3.10 --no-force-union-syntax
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 x : Union[Literal[1], Literal[2], str]
 x = 3 # E: Incompatible types in assignment (expression has type "Literal[3]", variable has type "Literal[1, 2] | str")
 [builtins fixtures/tuple.pyi]
 
 [case testLiteralUnionErrorSyntax]
 # flags: --python-version 3.10 --force-union-syntax
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 x : Union[Literal[1], Literal[2], str]
 x = 3 # E: Incompatible types in assignment (expression has type "Literal[3]", variable has type "Union[str, Literal[1, 2]]")
 [builtins fixtures/tuple.pyi]
 
 [case testLiteralOrNoneErrorSyntax]
 # flags: --python-version 3.10 --no-force-union-syntax
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 x : Union[Literal[1], None]
 x = 3 # E: Incompatible types in assignment (expression has type "Literal[3]", variable has type "Literal[1] | None")
 [builtins fixtures/tuple.pyi]
 
 [case testLiteralOptionalErrorSyntax]
 # flags: --python-version 3.10 --force-union-syntax
-from typing import Union
-from typing_extensions import Literal
+from typing import Literal, Union
 x : Union[Literal[1], None]
 x = 3 # E: Incompatible types in assignment (expression has type "Literal[3]", variable has type "Optional[Literal[1]]")
 [builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/check-union-or-syntax.test b/test-data/unit/check-union-or-syntax.test
index 58526cfd0623..6250374ccbea 100644
--- a/test-data/unit/check-union-or-syntax.test
+++ b/test-data/unit/check-union-or-syntax.test
@@ -45,9 +45,10 @@ reveal_type(f)  # N: Revealed type is "def (x: Union[__main__.A, __main__.B, __m
 
 [case testUnionOrSyntaxWithLiteral]
 # flags: --python-version 3.10
-from typing_extensions import Literal
+from typing import Literal
 reveal_type(Literal[4] | str)  # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
 
 [case testUnionOrSyntaxWithBadOperator]
 # flags: --python-version 3.10
@@ -66,8 +67,8 @@ x: List[int | str]
 reveal_type(x)  # N: Revealed type is "builtins.list[Union[builtins.int, builtins.str]]"
 [builtins fixtures/list.pyi]
 
-[case testUnionOrSyntaxWithQuotedFunctionTypes]
-# flags: --python-version 3.4
+[case testUnionOrSyntaxWithQuotedFunctionTypesPre310]
+# flags: --python-version 3.9
 from typing import Union
 def f(x: 'Union[int, str, None]') -> 'Union[int, None]':
     reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str, None]"
@@ -79,8 +80,8 @@ def g(x: "int | str | None") -> "int | None":
     return 42
 reveal_type(g)  # N: Revealed type is "def (x: Union[builtins.int, builtins.str, None]) -> Union[builtins.int, None]"
 
-[case testUnionOrSyntaxWithQuotedVariableTypes]
-# flags: --python-version 3.6
+[case testUnionOrSyntaxWithQuotedVariableTypesPre310]
+# flags: --python-version 3.9
 y: "int | str" = 42
 reveal_type(y)  # N: Revealed type is "Union[builtins.int, builtins.str]"
 
@@ -124,11 +125,9 @@ cast(str | int, 'x')  # E: Cast target is not a type
 [typing fixtures/typing-full.pyi]
 
 [case testUnionOrSyntaxInComment]
-# flags: --python-version 3.6
 x = 1  # type: int | str
 
 [case testUnionOrSyntaxFutureImport]
-# flags: --python-version 3.7
 from __future__ import annotations
 x: int | None
 [builtins fixtures/tuple.pyi]
@@ -138,7 +137,7 @@ x: int | None
 x: int | None  # E: X | Y syntax for unions requires Python 3.10
 
 [case testUnionOrSyntaxInStubFile]
-# flags: --python-version 3.6
+# flags: --python-version 3.9
 from lib import x
 [file lib.pyi]
 x: int | None
@@ -191,7 +190,7 @@ def g(x: int | str | tuple[int, str] | C) -> None:
 # flags: --python-version 3.9
 from typing import Union
 def f(x: Union[int, str, None]) -> None:
-    if isinstance(x, int | str): # E: Unsupported left operand type for | ("Type[int]")
+    if isinstance(x, int | str):
         reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str]"
     else:
         reveal_type(x)  # N: Revealed type is "None"
@@ -209,6 +208,36 @@ foo: ReadableBuffer
 [file was_mmap.pyi]
 from was_builtins import *
 class mmap: ...
+[builtins fixtures/type.pyi]
+
+[case testTypeAliasWithNewUnionIsInstance]
+# flags: --python-version 3.10
+SimpleAlias = int | str
+
+def foo(x: int | str | tuple):
+    if isinstance(x, SimpleAlias):
+        reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str]"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.tuple[Any, ...]"
+
+ParameterizedAlias = str | list[str]
+
+# these are false negatives:
+isinstance(5, str | list[str])
+isinstance(5, ParameterizedAlias)
+[builtins fixtures/type.pyi]
+
+[case testIsInstanceUnionNone]
+# flags: --python-version 3.10
+def foo(value: str | bool | None):
+    assert not isinstance(value, str | None)
+    reveal_type(value)  # N: Revealed type is "builtins.bool"
+
+def bar(value: object):
+    assert isinstance(value, str | None)
+    reveal_type(value)  # N: Revealed type is "Union[builtins.str, None]"
+[builtins fixtures/type.pyi]
+
 
 # TODO: Get this test to pass
 [case testImplicit604TypeAliasWithCyclicImportNotInStub-xfail]
diff --git a/test-data/unit/check-unions.test b/test-data/unit/check-unions.test
index 65d5c1abc7e8..8e92b6a91e8a 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"
@@ -525,7 +528,6 @@ x: Union[int, str]
 a: Any
 if bool():
     x = a
-    # TODO: Maybe we should infer Any as the type instead.
     reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str]"
 reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str]"
 [builtins fixtures/bool.pyi]
@@ -926,7 +928,6 @@ reveal_type(z) # N: Revealed type is "Union[builtins.int, __main__.A, builtins.s
 [out]
 
 [case testUnpackUnionNoCrashOnPartialNone]
-# flags: --strict-optional
 from typing import Dict, Tuple, List, Any
 
 a: Any
@@ -941,7 +942,6 @@ if x:
 [out]
 
 [case testUnpackUnionNoCrashOnPartialNone2]
-# flags: --strict-optional
 from typing import Dict, Tuple, List, Any
 
 a: Any
@@ -957,7 +957,6 @@ if x:
 [out]
 
 [case testUnpackUnionNoCrashOnPartialNoneBinder]
-# flags: --strict-optional
 from typing import Dict, Tuple, List, Any
 
 x: object
@@ -972,7 +971,6 @@ if x:
 [out]
 
 [case testUnpackUnionNoCrashOnPartialList]
-# flags: --strict-optional
 from typing import Dict, Tuple, List, Any
 
 a: Any
@@ -1004,12 +1002,15 @@ def takes_int(arg: int) -> None: pass
 takes_int(x)  # E: Argument 1 to "takes_int" has incompatible type "Union[ExtremelyLongTypeNameWhichIsGenericSoWeCanUseItMultipleTimes[int], ExtremelyLongTypeNameWhichIsGenericSoWeCanUseItMultipleTimes[object], ExtremelyLongTypeNameWhichIsGenericSoWeCanUseItMultipleTimes[float], ExtremelyLongTypeNameWhichIsGenericSoWeCanUseItMultipleTimes[str], ExtremelyLongTypeNameWhichIsGenericSoWeCanUseItMultipleTimes[Any], ExtremelyLongTypeNameWhichIsGenericSoWeCanUseItMultipleTimes[bytes]]"; expected "int"
 
 [case testRecursiveForwardReferenceInUnion]
-# flags: --disable-recursive-aliases
 from typing import List, Union
-MYTYPE = List[Union[str, "MYTYPE"]] # E: Cannot resolve name "MYTYPE" (possible cyclic definition)
+
+def test() -> None:
+    MYTYPE = List[Union[str, "MYTYPE"]]  # E: Cannot resolve name "MYTYPE" (possible cyclic definition) \
+                                         # N: Recursive types are not allowed at function scope
 [builtins fixtures/list.pyi]
 
 [case testNonStrictOptional]
+# flags: --no-strict-optional
 from typing import Optional, List
 
 def union_test1(x):
@@ -1048,7 +1049,7 @@ def do_thing_with_enums(enums: Union[List[Enum], Enum]) -> None: ...
 
 boop: List[Boop] = []
 do_thing_with_enums(boop)  # E: Argument 1 to "do_thing_with_enums" has incompatible type "List[Boop]"; expected "Union[List[Enum], Enum]" \
-                           # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+                           # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
                            # N: Consider using "Sequence" instead, which is covariant
 [builtins fixtures/isinstancelist.pyi]
 
@@ -1077,7 +1078,6 @@ def bar(a: T4, b: T4) -> T4:  # test multi-level alias
 [builtins fixtures/ops.pyi]
 
 [case testJoinUnionWithUnionAndAny]
-# flags: --strict-optional
 from typing import TypeVar, Union, Any
 T = TypeVar("T")
 def f(x: T, y: T) -> T:
@@ -1219,3 +1219,129 @@ nc: Union[Container[str], int]
 'x' in nc  # E: Unsupported right operand type for in ("Union[Container[str], int]")
 [builtins fixtures/tuple.pyi]
 [typing fixtures/typing-full.pyi]
+
+[case testDescriptorAccessForUnionOfTypes]
+from typing import overload, Generic, Any, TypeVar, List, Optional, Union, Type
+
+_T_co = TypeVar("_T_co", bound=Any, covariant=True)
+
+class Mapped(Generic[_T_co]):
+    def __init__(self, value: _T_co):
+        self.value = value
+
+    @overload
+    def __get__(
+        self, instance: None, owner: Any
+    ) -> List[_T_co]:
+        ...
+
+    @overload
+    def __get__(self, instance: object, owner: Any) -> _T_co:
+        ...
+
+    def __get__(
+        self, instance: Optional[object], owner: Any
+    ) -> Union[List[_T_co], _T_co]:
+        return self.value
+
+class A:
+    field_1: Mapped[int] = Mapped(1)
+    field_2: Mapped[str] = Mapped('1')
+
+class B:
+    field_1: Mapped[int] = Mapped(2)
+    field_2: Mapped[str] = Mapped('2')
+
+mix: Union[Type[A], Type[B]] = A
+reveal_type(mix)  # N: Revealed type is "Union[Type[__main__.A], Type[__main__.B]]"
+reveal_type(mix.field_1)  # N: Revealed type is "builtins.list[builtins.int]"
+reveal_type(mix().field_1)  # N: Revealed type is "builtins.int"
+[builtins fixtures/list.pyi]
+
+
+[case testDescriptorAccessForUnionOfTypesWithNoStrictOptional]
+# mypy: no-strict-optional
+from typing import overload, Generic, Any, TypeVar, List, Optional, Union, Type
+
+class Descriptor:
+    @overload
+    def __get__(
+        self, instance: None, owner: type
+    ) -> str:
+        ...
+
+    @overload
+    def __get__(self, instance: object, owner: type) -> int:
+        ...
+
+    def __get__(
+        self, instance: Optional[object], owner: type
+    ) -> Union[str, int]:
+        ...
+
+class A:
+    field = Descriptor()
+
+a_class_or_none: Optional[Type[A]]
+x: str = a_class_or_none.field
+
+a_or_none: Optional[A]
+y: int = a_or_none.field
+[builtins fixtures/list.pyi]
+
+[case testLargeUnionsShort]
+from typing import Union
+
+class C1: ...
+class C2: ...
+class C3: ...
+class C4: ...
+class C5: ...
+class C6: ...
+class C7: ...
+class C8: ...
+class C9: ...
+class C10: ...
+class C11: ...
+
+u: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11]
+x: int = u  # E: Incompatible types in assignment (expression has type "Union[C1, C2, C3, C4, C5, <6 more items>]", variable has type "int")
+
+[case testLargeUnionsLongIfNeeded]
+from typing import Union
+
+class C1: ...
+class C2: ...
+class C3: ...
+class C4: ...
+class C5: ...
+class C6: ...
+class C7: ...
+class C8: ...
+class C9: ...
+class C10: ...
+
+x: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, int]
+y: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, str]
+x = y  # E: Incompatible types in assignment (expression has type "Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, str]", variable has type "Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, int]") \
+       # N: Item in the first union not in the second: "str"
+
+[case testLargeUnionsNoneShown]
+from typing import Union
+
+class C1: ...
+class C2: ...
+class C3: ...
+class C4: ...
+class C5: ...
+class C6: ...
+class C7: ...
+class C8: ...
+class C9: ...
+class C10: ...
+class C11: ...
+
+x: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11]
+y: Union[C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, None]
+x = y  # E: Incompatible types in assignment (expression has type "Union[C1, C2, C3, C4, C5, <6 more items>, None]", variable has type "Union[C1, C2, C3, C4, C5, <6 more items>]") \
+       # N: Item in the first union not in the second: "None"
diff --git a/test-data/unit/check-unreachable-code.test b/test-data/unit/check-unreachable-code.test
index b2fd44043435..a40aa21ff26a 100644
--- a/test-data/unit/check-unreachable-code.test
+++ b/test-data/unit/check-unreachable-code.test
@@ -422,9 +422,9 @@ x = 1
 [out]
 
 [case testCustomSysVersionInfo]
-# flags: --python-version 3.5
+# flags: --python-version 3.11
 import sys
-if sys.version_info == (3, 5):
+if sys.version_info == (3, 11):
     x = "foo"
 else:
     x = 3
@@ -433,7 +433,7 @@ reveal_type(x)  # N: Revealed type is "builtins.str"
 [out]
 
 [case testCustomSysVersionInfo2]
-# flags: --python-version 3.5
+# flags: --python-version 3.11
 import sys
 if sys.version_info == (3, 6):
     x = "foo"
@@ -615,7 +615,6 @@ reveal_type(x)  # N: Revealed type is "__main__.B"
 [typing fixtures/typing-medium.pyi]
 
 [case testUnreachableWhenSuperclassIsAny]
-# flags: --strict-optional
 from typing import Any
 
 # This can happen if we're importing a class from a missing module
@@ -799,7 +798,7 @@ def baz(x: int) -> int:
 [builtins fixtures/exception.pyi]
 
 [case testUnreachableFlagIgnoresSemanticAnalysisUnreachable]
-# flags: --warn-unreachable --python-version 3.7 --platform win32 --always-false FOOBAR
+# flags: --warn-unreachable --python-version 3.8 --platform win32 --always-false FOOBAR
 import sys
 from typing import TYPE_CHECKING
 
@@ -829,7 +828,7 @@ if sys.version_info == (2, 7):
 else:
     reveal_type(x)  # N: Revealed type is "builtins.int"
 
-if sys.version_info == (3, 7):
+if sys.version_info == (3, 8):
     reveal_type(x)  # N: Revealed type is "builtins.int"
 else:
     reveal_type(x)
@@ -873,15 +872,15 @@ def expect_str(x: str) -> str: pass
 x: int
 if False:
     assert False
-    reveal_type(x)
+    reveal_type(x)  # E: Statement is unreachable
 
 if False:
     raise Exception()
-    reveal_type(x)
+    reveal_type(x)  # E: Statement is unreachable
 
 if False:
     assert_never(x)
-    reveal_type(x)
+    reveal_type(x)  # E: Statement is unreachable
 
 if False:
     nonthrowing_assert_never(x)  # E: Statement is unreachable
@@ -890,7 +889,7 @@ if False:
 if False:
     # Ignore obvious type errors
     assert_never(expect_str(x))
-    reveal_type(x)
+    reveal_type(x)  # E: Statement is unreachable
 [builtins fixtures/exception.pyi]
 
 [case testNeverVariants]
@@ -901,15 +900,15 @@ from typing_extensions import NoReturn as TENoReturn
 from mypy_extensions import NoReturn as MENoReturn
 
 bottom1: Never
-reveal_type(bottom1)  # N: Revealed type is "<nothing>"
+reveal_type(bottom1)  # N: Revealed type is "Never"
 bottom2: TENever
-reveal_type(bottom2)  # N: Revealed type is "<nothing>"
+reveal_type(bottom2)  # N: Revealed type is "Never"
 bottom3: NoReturn
-reveal_type(bottom3)  # N: Revealed type is "<nothing>"
+reveal_type(bottom3)  # N: Revealed type is "Never"
 bottom4: TENoReturn
-reveal_type(bottom4)  # N: Revealed type is "<nothing>"
+reveal_type(bottom4)  # N: Revealed type is "Never"
 bottom5: MENoReturn
-reveal_type(bottom5)  # N: Revealed type is "<nothing>"
+reveal_type(bottom5)  # N: Revealed type is "Never"
 
 [builtins fixtures/tuple.pyi]
 
@@ -1001,11 +1000,20 @@ class Test4(Generic[T3]):
 
 [builtins fixtures/isinstancelist.pyi]
 
+[case testUnreachableBlockStaysUnreachableWithTypeVarConstraints]
+# flags: --always-false COMPILE_TIME_FALSE
+from typing import TypeVar
+COMPILE_TIME_FALSE = False
+T = TypeVar("T", int, str)
+def foo(x: T) -> T:
+    if COMPILE_TIME_FALSE:
+        return "bad"
+    return x
+
 [case testUnreachableFlagContextManagersNoSuppress]
 # flags: --warn-unreachable
 from contextlib import contextmanager
-from typing import Optional, Iterator, Any
-from typing_extensions import Literal
+from typing import Literal, Optional, Iterator, Any
 class DoesNotSuppress1:
     def __enter__(self) -> int: ...
     def __exit__(self, exctype: object, excvalue: object, traceback: object) -> Optional[bool]: ...
@@ -1069,8 +1077,7 @@ def f_no_suppress_5() -> int:
 [case testUnreachableFlagContextManagersSuppressed]
 # flags: --warn-unreachable
 from contextlib import contextmanager
-from typing import Optional, Iterator, Any
-from typing_extensions import Literal
+from typing import Optional, Iterator, Literal, Any
 
 class DoesNotSuppress:
     def __enter__(self) -> int: ...
@@ -1116,8 +1123,7 @@ def f_mix() -> int:         # E: Missing return statement
 [case testUnreachableFlagContextManagersSuppressedNoStrictOptional]
 # flags: --warn-unreachable --no-strict-optional
 from contextlib import contextmanager
-from typing import Optional, Iterator, Any
-from typing_extensions import Literal
+from typing import Optional, Iterator, Literal, Any
 
 class DoesNotSuppress1:
     def __enter__(self) -> int: ...
@@ -1156,10 +1162,9 @@ def f_suppress() -> int:  # E: Missing return statement
 [builtins fixtures/tuple.pyi]
 
 [case testUnreachableFlagContextAsyncManagersNoSuppress]
-# flags: --warn-unreachable --python-version 3.7
+# flags: --warn-unreachable
 from contextlib import asynccontextmanager
-from typing import Optional, AsyncIterator, Any
-from typing_extensions import Literal
+from typing import Optional, AsyncIterator, Literal, Any
 
 class DoesNotSuppress1:
     async def __aenter__(self) -> int: ...
@@ -1222,10 +1227,9 @@ async def f_no_suppress_5() -> int:
 [builtins fixtures/tuple.pyi]
 
 [case testUnreachableFlagContextAsyncManagersSuppressed]
-# flags: --warn-unreachable --python-version 3.7
+# flags: --warn-unreachable
 from contextlib import asynccontextmanager
-from typing import Optional, AsyncIterator, Any
-from typing_extensions import Literal
+from typing import Optional, AsyncIterator, Literal, Any
 
 class DoesNotSuppress:
     async def __aenter__(self) -> int: ...
@@ -1269,10 +1273,9 @@ async def f_mix() -> int:         # E: Missing return statement
 [builtins fixtures/tuple.pyi]
 
 [case testUnreachableFlagContextAsyncManagersAbnormal]
-# flags: --warn-unreachable --python-version 3.7
+# flags: --warn-unreachable
 from contextlib import asynccontextmanager
-from typing import Optional, AsyncIterator, Any
-from typing_extensions import Literal
+from typing import Optional, AsyncIterator, Literal, Any
 
 class RegularManager:
     def __enter__(self) -> int: ...
@@ -1371,7 +1374,7 @@ def f(t: T) -> None:
 
 [case testUnreachableLiteral]
 # flags: --warn-unreachable
-from typing_extensions import Literal
+from typing import Literal
 
 def nope() -> Literal[False]: ...
 
@@ -1380,6 +1383,38 @@ def f() -> None:
         x = 1  # E: Statement is unreachable
 [builtins fixtures/dict.pyi]
 
+[case testUnreachableLiteralFrom__bool__]
+# flags: --warn-unreachable
+from typing import Literal
+
+class Truth:
+    def __bool__(self) -> Literal[True]: ...
+
+class Lie:
+    def __bool__(self) -> Literal[False]: ...
+
+class Maybe:
+    def __bool__(self) -> Literal[True | False]: ...
+
+t = Truth()
+if t:
+    x = 1
+else:
+    x = 2  # E: Statement is unreachable
+
+if Lie():
+    x = 3  # E: Statement is unreachable
+
+if Maybe():
+    x = 4
+
+
+def foo() -> bool: ...
+
+y = Truth() or foo()  # E: Right operand of "or" is never evaluated
+z = Lie() and foo()  # E: Right operand of "and" is never evaluated
+[builtins fixtures/dict.pyi]
+
 [case testUnreachableModuleBody1]
 # flags: --warn-unreachable
 from typing import NoReturn
@@ -1447,3 +1482,32 @@ def f() -> None:
     Foo()['a'] = 'a'
     x = 0 # This should not be reported as unreachable
 [builtins fixtures/exception.pyi]
+
+[case testIntentionallyEmptyGeneratorFunction]
+# flags: --warn-unreachable
+from typing import Generator
+
+def f() -> Generator[None, None, None]:
+    return
+    yield
+
+[case testIntentionallyEmptyGeneratorFunction_None]
+# flags: --warn-unreachable
+from typing import Generator
+
+def f() -> Generator[None, None, None]:
+    return None
+    yield None
+
+[case testLambdaNoReturn]
+# flags: --warn-unreachable
+from typing import Callable, NoReturn
+
+def foo() -> NoReturn:
+    raise
+
+f1 = lambda: foo()
+x = 0  # not unreachable
+
+f2: Callable[[], NoReturn] = lambda: foo()
+x = 0  # not unreachable
diff --git a/test-data/unit/check-varargs.test b/test-data/unit/check-varargs.test
index 92b9f7f04f26..c59f07e92a4e 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,14 +46,14 @@ 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"
-f(g())     # E: "g" does not return a value
-f(a, g())  # E: "g" does not return a value
+f(g())     # E: "g" does not return a value (it only ever returns None)
+f(a, g())  # E: "g" does not return a value (it only ever returns None)
 f()
 f(a)
 f(b)
@@ -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)
@@ -145,6 +145,14 @@ f(*it1, 1, *it2, 2)  # E: Argument 3 to "f" has incompatible type "*Tuple[str]";
 f(*it1, '') # E: Argument 2 to "f" has incompatible type "str"; expected "int"
 [builtins fixtures/for.pyi]
 
+[case testCallVarArgsWithMatchingNamedArgument]
+def foo(*args: int) -> None: ...  # N: "foo" defined here
+foo(args=1)  # E: Unexpected keyword argument "args" for "foo"
+
+def bar(*args: int, **kwargs: str) -> None: ...
+bar(args=1)  # E: Argument "args" to "bar" has incompatible type "int"; expected "str"
+[builtins fixtures/for.pyi]
+
 
 -- Calling varargs function + type inference
 -- -----------------------------------------
@@ -161,10 +169,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 +196,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 +238,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 +257,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,17 +276,19 @@ f(a, *(b, cc))
 [builtins fixtures/tuple.pyi]
 
 [case testInvalidVarArg]
-
 def f(a: 'A') -> None:
     pass
 
 class A: pass
 
-a = None # type: A
+a = A()
 
-f(*None)
-f(*a)    # E: List or tuple expected as variadic arguments
+f(*None)  # E: Expected iterable as variadic argument
+f(*a)    # E: Expected iterable as variadic argument
 f(*(a,))
+
+f(*4)  # E: Expected iterable as variadic argument
+f(a, *4)  # E: Expected iterable as variadic argument
 [builtins fixtures/tuple.pyi]
 
 
@@ -293,7 +304,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 +329,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 +359,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 +369,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 +381,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 +468,7 @@ foo(*())
 
 
 [case testIntersectionTypesAndVarArgs]
+# flags: --no-strict-optional
 from foo import *
 [file foo.pyi]
 from typing import overload
@@ -518,7 +538,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"
@@ -531,9 +553,9 @@ if int():
 if int():
     b, b = f(b, b, *aa) # E: Argument 3 to "f" has incompatible type "*List[A]"; expected "B"
 if int():
-    a, b = f(a, *a)  # E: List or tuple expected as variadic arguments
+    a, b = f(a, *a)  # E: Expected iterable as variadic argument
 if int():
-    a, b = f(*a)     # E: List or tuple expected as variadic arguments
+    a, b = f(*a)     # E: Expected iterable as variadic argument
 
 if int():
     a, a = f(*aa)
@@ -553,7 +575,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 +598,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]]:
@@ -588,35 +612,18 @@ class A: pass
 class B: pass
 
 if int():
-    a, aa = G().f(*[a]) \
-      # E: Incompatible types in assignment (expression has type "List[A]", variable has type "A") \
-      # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[A]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
-      # N: Consider using "Sequence" instead, which is covariant
-
+    a, aa = G().f(*[a]) # E: Incompatible types in assignment (expression has type "List[A]", variable has type "A")
 if int():
-    aa, a = G().f(*[a]) # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "A")
+    aa, a = G().f(*[a]) # E: Incompatible types in assignment (expression has type "List[Never]", variable has type "A")
 if int():
-    ab, aa = G().f(*[a]) \
-      # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[A]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
-      # N: Consider using "Sequence" instead, which is covariant \
-      # E: Argument 1 to "f" of "G" has incompatible type "*List[A]"; expected "B"
-
+    ab, aa = G().f(*[a]) # E: Argument 1 to "f" of "G" has incompatible type "*List[A]"; expected "B"
 if int():
-    ao, ao = G().f(*[a]) \
-      # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[object]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
-      # N: Consider using "Sequence" instead, which is covariant
+    ao, ao = G().f(*[a])
 if int():
-    aa, aa = G().f(*[a]) \
-      # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[A]") \
-      # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
-      # N: Consider using "Sequence" instead, which is covariant
+    aa, aa = G().f(*[a])
 [builtins fixtures/list.pyi]
 
 [case testCallerTupleVarArgsAndGenericCalleeVarArg]
-# flags: --strict-optional
 from typing import TypeVar
 
 T = TypeVar('T')
@@ -649,7 +656,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
@@ -680,12 +687,12 @@ b = {'b': ['c', 'd']}
 c = {'c': 1.0}
 d = {'d': 1}
 f(a) # E: Argument 1 to "f" has incompatible type "Dict[str, List[int]]"; expected "Dict[str, Sequence[int]]" \
-     # N: "Dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+     # N: "dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
      # N: Consider using "Mapping" instead, which is covariant in the value type
 f(b) # E: Argument 1 to "f" has incompatible type "Dict[str, List[str]]"; expected "Dict[str, Sequence[int]]"
 g(c)
 g(d) # E: Argument 1 to "g" has incompatible type "Dict[str, int]"; expected "Dict[str, float]" \
-     # N: "Dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+     # N: "dict" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
      # N: Consider using "Mapping" instead, which is covariant in the value type
 h(c) # E: Argument 1 to "h" has incompatible type "Dict[str, float]"; expected "Dict[str, int]"
 h(d)
@@ -697,7 +704,7 @@ from typing import List, Union
 def f(numbers: List[Union[int, float]]) -> None: pass
 a = [1, 2]
 f(a) # E: Argument 1 to "f" has incompatible type "List[int]"; expected "List[Union[int, float]]" \
-     # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
+     # N: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \
      # N: Consider using "Sequence" instead, which is covariant
 x = [1]
 y = ['a']
@@ -740,13 +747,14 @@ bar(*good1)
 bar(*good2)
 bar(*good3)
 bar(*bad1)  # E: Argument 1 to "bar" has incompatible type "*I[str]"; expected "float"
-bar(*bad2)  # E: List or tuple expected as variadic arguments
+bar(*bad2)  # E: Expected iterable as variadic argument
 [builtins fixtures/dict.pyi]
 
 -- Keyword arguments unpacking
 
 [case testUnpackKwargsReveal]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -755,20 +763,23 @@ def foo(arg: bool, **kwargs: Unpack[Person]) -> None: ...
 
 reveal_type(foo)  # N: Revealed type is "def (arg: builtins.bool, **kwargs: Unpack[TypedDict('__main__.Person', {'name': builtins.str, 'age': builtins.int})])"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackOutsideOfKwargs]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 class Person(TypedDict):
     name: str
     age: int
 
-def foo(x: Unpack[Person]) -> None:  # E: "Person" cannot be unpacked (must be tuple or TypeVarTuple)
+def foo(x: Unpack[Person]) -> None:  # E: Unpack is only valid in a variadic position
     ...
 def bar(x: int, *args: Unpack[Person]) -> None:  # E: "Person" cannot be unpacked (must be tuple or TypeVarTuple)
     ...
 def baz(**kwargs: Unpack[Person]) -> None:  # OK
     ...
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackWithoutTypedDict]
 from typing_extensions import Unpack
@@ -778,7 +789,8 @@ def foo(**kwargs: Unpack[dict]) -> None:  # E: Unpack item in ** argument must b
 [builtins fixtures/dict.pyi]
 
 [case testUnpackWithDuplicateKeywords]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -786,10 +798,11 @@ class Person(TypedDict):
 def foo(name: str, **kwargs: Unpack[Person]) -> None:  # E: Overlap between argument names and ** TypedDict items: "name"
     ...
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackWithDuplicateKeywordKwargs]
-from typing_extensions import Unpack, TypedDict
-from typing import Dict, List
+from typing_extensions import Unpack
+from typing import Dict, List, TypedDict
 
 class Spec(TypedDict):
     args: List[int]
@@ -798,9 +811,11 @@ def foo(**kwargs: Unpack[Spec]) -> None:  # Allowed
     ...
 foo(args=[1], kwargs={"2": 3})  # E: Dict entry 0 has incompatible type "str": "int"; expected "int": "int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsNonIdentifier]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 Weird = TypedDict("Weird", {"@": int})
 
@@ -809,9 +824,11 @@ def foo(**kwargs: Unpack[Weird]) -> None:
 foo(**{"@": 42})
 foo(**{"no": "way"})  # E: Argument 1 to "foo" has incompatible type "**Dict[str, str]"; expected "int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsEmpty]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 Empty = TypedDict("Empty", {})
 
@@ -820,9 +837,11 @@ def foo(**kwargs: Unpack[Empty]) -> None:  # N: "foo" defined here
 foo()
 foo(x=1)  # E: Unexpected keyword argument "x" for "foo"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackTypedDictTotality]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Circle(TypedDict, total=True):
     radius: int
@@ -842,9 +861,11 @@ def bar(**kwargs: Unpack[Square]):
     ...
 bar(side=12)
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackUnexpectedKeyword]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict, total=False):
     name: str
@@ -855,9 +876,11 @@ def foo(**kwargs: Unpack[Person]) -> None:  # N: "foo" defined here
 foo(name='John', age=42, department='Sales')  # E: Unexpected keyword argument "department" for "foo"
 foo(name='Jennifer', age=38)
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKeywordTypes]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -868,9 +891,11 @@ def foo(**kwargs: Unpack[Person]):
 foo(name='John', age='42')  # E: Argument "age" to "foo" has incompatible type "str"; expected "int"
 foo(name='Jennifer', age=38)
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKeywordTypesTypedDict]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -885,9 +910,11 @@ def foo(**kwargs: Unpack[Person]) -> None:
 lp = LegacyPerson(name="test", age="42")
 foo(**lp)  # E: Argument "age" to "foo" has incompatible type "str"; expected "int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testFunctionBodyWithUnpackedKwargs]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -899,9 +926,11 @@ def foo(**kwargs: Unpack[Person]) -> int:
     department: str = kwargs['department']  # E: TypedDict "Person" has no key "department"
     return kwargs['age']
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsOverrides]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -916,9 +945,11 @@ class SubBad(Base):
     # N: This violates the Liskov substitution principle \
     # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsOverridesTypedDict]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -941,10 +972,11 @@ class SubBad(Base):
     # N:      Subclass: \
     # N:          def foo(self, *, baz: int) -> None
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsGeneric]
-from typing import Generic, TypeVar
-from typing_extensions import Unpack, TypedDict
+from typing import Generic, TypedDict, TypeVar
+from typing_extensions import Unpack
 
 T = TypeVar("T")
 class Person(TypedDict, Generic[T]):
@@ -954,10 +986,11 @@ class Person(TypedDict, Generic[T]):
 def foo(**kwargs: Unpack[Person[T]]) -> T: ...
 reveal_type(foo(name="test", value=42))  # N: Revealed type is "builtins.int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsInference]
-from typing import Generic, TypeVar, Protocol
-from typing_extensions import Unpack, TypedDict
+from typing import Generic, TypedDict, TypeVar, Protocol
+from typing_extensions import Unpack
 
 T_contra = TypeVar("T_contra", contravariant=True)
 class CBPerson(Protocol[T_contra]):
@@ -973,10 +1006,11 @@ def test(cb: CBPerson[T]) -> T: ...
 def foo(*, name: str, value: int) -> None: ...
 reveal_type(test(foo))  # N: Revealed type is "builtins.int"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsOverload]
-from typing import Any, overload
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict, Any, overload
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -995,9 +1029,11 @@ def foo(**kwargs: Any) -> Any:
 
 reveal_type(foo(sort="test", taste=999))  # N: Revealed type is "builtins.str"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsJoin]
-from typing_extensions import Unpack, TypedDict
+from typing import TypedDict
+from typing_extensions import Unpack
 
 class Person(TypedDict):
     name: str
@@ -1009,10 +1045,11 @@ def bar(**kwargs: Unpack[Person]) -> None: ...
 reveal_type([foo, bar])  # N: Revealed type is "builtins.list[def (*, name: builtins.str, age: builtins.int)]"
 reveal_type([bar, foo])  # N: Revealed type is "builtins.list[def (*, name: builtins.str, age: builtins.int)]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackKwargsParamSpec]
-from typing import Callable, Any, TypeVar, List
-from typing_extensions import ParamSpec, Unpack, TypedDict
+from typing import Callable, Any, TypedDict, TypeVar, List
+from typing_extensions import ParamSpec, Unpack
 
 class Person(TypedDict):
     name: str
@@ -1028,10 +1065,11 @@ def g(**kwargs: Unpack[Person]) -> int: ...
 
 reveal_type(g)  # N: Revealed type is "def (*, name: builtins.str, age: builtins.int) -> builtins.list[builtins.int]"
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackGenericTypedDictImplicitAnyEnabled]
-from typing import Generic, TypeVar
-from typing_extensions import Unpack, TypedDict
+from typing import Generic, TypedDict, TypeVar
+from typing_extensions import Unpack
 
 T = TypeVar("T")
 class TD(TypedDict, Generic[T]):
@@ -1042,11 +1080,12 @@ def foo(**kwds: Unpack[TD]) -> None: ...  # Same as `TD[Any]`
 foo(key="yes", value=42)
 foo(key="yes", value="ok")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackGenericTypedDictImplicitAnyDisabled]
 # flags: --disallow-any-generics
-from typing import Generic, TypeVar
-from typing_extensions import Unpack, TypedDict
+from typing import Generic, TypedDict, TypeVar
+from typing_extensions import Unpack
 
 T = TypeVar("T")
 class TD(TypedDict, Generic[T]):
@@ -1057,6 +1096,7 @@ def foo(**kwds: Unpack[TD]) -> None: ...  # E: Missing type parameters for gener
 foo(key="yes", value=42)
 foo(key="yes", value="ok")
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [case testUnpackNoCrashOnEmpty]
 from typing_extensions import Unpack
@@ -1066,3 +1106,19 @@ class C:
 class D:
     def __init__(self, **kwds: Unpack[int, str]) -> None: ...  # E: Unpack[...] requires exactly one type argument
 [builtins fixtures/dict.pyi]
+
+[case testUnpackInCallableType]
+from typing import Callable, TypedDict
+from typing_extensions import Unpack
+
+class TD(TypedDict):
+    key: str
+    value: str
+
+foo: Callable[[Unpack[TD]], None]
+foo(key="yes", value=42)  # E: Argument "value" has incompatible type "int"; expected "str"
+foo(key="yes", value="ok")
+
+bad: Callable[[*TD], None]  # E: "TD" cannot be unpacked (must be tuple or TypeVarTuple)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
diff --git a/test-data/unit/check-warnings.test b/test-data/unit/check-warnings.test
index 10c7968be475..895b16e5e3c3 100644
--- a/test-data/unit/check-warnings.test
+++ b/test-data/unit/check-warnings.test
@@ -42,6 +42,32 @@ a: Any
 b = cast(Any, a)
 [builtins fixtures/list.pyi]
 
+[case testCastToObjectNotRedunant]
+# flags: --warn-redundant-casts
+from typing import cast
+
+a = 1
+b = cast(object, 1)
+
+[case testCastFromLiteralRedundant]
+# flags: --warn-redundant-casts
+from typing import cast
+
+cast(int, 1)
+[out]
+main:4: error: Redundant cast to "int"
+
+[case testCastFromUnionOfAnyOk]
+# flags: --warn-redundant-casts
+from typing import Any, cast, Union
+
+x = Any
+y = Any
+z = Any
+
+def f(q: Union[x, y, z]) -> None:
+    cast(Union[x, y], q)
+
 -- Unused 'type: ignore' comments
 -- ------------------------------
 
@@ -207,7 +233,7 @@ def f() -> Any: return g()
 [out]
 
 [case testOKReturnAnyIfProperSubtype]
-# flags: --warn-return-any --strict-optional
+# flags: --warn-return-any
 from typing import Any, Optional
 
 class Test(object):
diff --git a/test-data/unit/cmdline.pyproject.test b/test-data/unit/cmdline.pyproject.test
index 831bce2eb63d..f9691ba245f9 100644
--- a/test-data/unit/cmdline.pyproject.test
+++ b/test-data/unit/cmdline.pyproject.test
@@ -92,7 +92,7 @@ exclude = '''(?x)(
 [file x/__init__.py]
 i: int = 0
 [file x/_skipme_please.py]
-This isn't even syntatically valid!
+This isn't even syntactically valid!
 [file x/please_skipme_.py]
 Neither is this!
 
@@ -107,7 +107,7 @@ exclude = """(?x)(
 [file x/__init__.py]
 i: int = 0
 [file x/_skipme_please.py]
-This isn't even syntatically valid!
+This isn't even syntactically valid!
 [file x/please_skipme_.py]
 Neither is this!
 
@@ -122,7 +122,7 @@ exclude = [
 [file x/__init__.py]
 i: int = 0
 [file x/_skipme_please.py]
-This isn't even syntatically valid!
+This isn't even syntactically valid!
 [file x/please_skipme_.py]
 Neither is this!
 
@@ -133,3 +133,96 @@ Neither is this!
 description = "Factory ⸻ A code generator 🏭"
 \[tool.mypy]
 [file x.py]
+
+[case testPyprojectFilesTrailingComma]
+# cmd: mypy
+[file pyproject.toml]
+\[tool.mypy]
+# We combine multiple tests in a single one here, because these tests are slow.
+files = """
+  a.py,
+  b.py,
+"""
+always_true = """
+  FLAG_A1,
+  FLAG_B1,
+"""
+always_false = """
+  FLAG_A2,
+  FLAG_B2,
+"""
+[file a.py]
+x: str = 'x'  # ok'
+
+# --always-true
+FLAG_A1 = False
+FLAG_B1 = False
+if not FLAG_A1:  # unreachable
+    x: int = 'x'
+if not FLAG_B1:  # unreachable
+    y: int = 'y'
+
+# --always-false
+FLAG_A2 = True
+FLAG_B2 = True
+if FLAG_A2:  # unreachable
+    x: int = 'x'
+if FLAG_B2:  # unreachable
+    y: int = 'y'
+[file b.py]
+y: int = 'y'  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[file c.py]
+# This should not trigger any errors, because it is not included:
+z: int = 'z'
+[out]
+
+[case testPyprojectModulesTrailingComma]
+# cmd: mypy
+[file pyproject.toml]
+\[tool.mypy]
+# We combine multiple tests in a single one here, because these tests are slow.
+modules = """
+  a,
+  b,
+"""
+disable_error_code = """
+  operator,
+  import,
+"""
+enable_error_code = """
+  redundant-expr,
+  ignore-without-code,
+"""
+[file a.py]
+x: str = 'x'  # ok
+
+# --enable-error-code
+a: int = 'a'  # type: ignore
+
+# --disable-error-code
+'a' + 1
+[file b.py]
+y: int = 'y'
+[file c.py]
+# This should not trigger any errors, because it is not included:
+z: int = 'z'
+[out]
+b.py:1: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+a.py:4: error: "type: ignore" comment without error code (consider "type: ignore[assignment]" instead)
+
+[case testPyprojectPackagesTrailingComma]
+# cmd: mypy
+[file pyproject.toml]
+\[tool.mypy]
+packages = """
+  a,
+  b,
+"""
+[file a/__init__.py]
+x: str = 'x'  # ok
+[file b/__init__.py]
+y: int = 'y'  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[file c/__init__.py]
+# This should not trigger any errors, because it is not included:
+z: int = 'z'
+[out]
diff --git a/test-data/unit/cmdline.test b/test-data/unit/cmdline.test
index c2e98cdb74f9..748a655d5a10 100644
--- a/test-data/unit/cmdline.test
+++ b/test-data/unit/cmdline.test
@@ -153,18 +153,6 @@ FLAG = False
 if not FLAG:
     x = "unreachable"
 
-[case testErrorContextConfig]
-# cmd: mypy main.py
-[file mypy.ini]
-\[mypy]
-show_error_context=True
-[file main.py]
-def f() -> None:
-  0 + ""
-[out]
-main.py: note: In function "f":
-main.py:2: error: Unsupported operand types for + ("int" and "str")
-
 [case testAltConfigFile]
 # cmd: mypy --config-file config.ini main.py
 [file config.ini]
@@ -176,43 +164,6 @@ FLAG = False
 if not FLAG:
     x = "unreachable"
 
-[case testNoConfigFile]
-# cmd: mypy main.py --config-file=
-[file mypy.ini]
-\[mypy]
-warn_unused_ignores = True
-[file main.py]
-# type: ignore
-
-[case testPerFileConfigSection]
-# cmd: mypy x.py y.py z.py
-[file mypy.ini]
-\[mypy]
-disallow_untyped_defs = True
-\[mypy-y]
-disallow_untyped_defs = False
-\[mypy-z]
-disallow_untyped_calls = True
-[file x.py]
-def f(a):
-    pass
-def g(a: int) -> int:
-    return f(a)
-[file y.py]
-def f(a):
-    pass
-def g(a: int) -> int:
-    return f(a)
-[file z.py]
-def f(a):
-    pass
-def g(a: int) -> int:
-    return f(a)
-[out]
-z.py:1: error: Function is missing a type annotation
-z.py:4: error: Call to untyped function "f" in typed context
-x.py:1: error: Function is missing a type annotation
-
 [case testPerFileConfigSectionMultipleMatchesDisallowed]
 # cmd: mypy xx.py xy.py yx.py yy.py
 [file mypy.ini]
@@ -296,7 +247,7 @@ mypy.ini: [mypy]: ignore_missing_imports: Not a boolean: nah
 [file mypy.ini]
 \[mypy]
 \[mypy-*]
-python_version = 3.4
+python_version = 3.11
 [out]
 mypy.ini: [mypy-*]: Per-module sections should only specify per-module flags (python_version)
 == Return code: 0
@@ -326,43 +277,6 @@ file.py:1: error: Cannot find implementation or library stub for module named "n
 file.py:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
 file.py:6: error: Argument 1 to "foo" has incompatible type "str"; expected "int"
 
-[case testIgnoreErrorsConfig]
-# cmd: mypy x.py y.py
-[file mypy.ini]
-\[mypy]
-\[mypy-x]
-ignore_errors = True
-[file x.py]
-x: str = 5
-[file y.py]
-x: str = 5
-[out]
-y.py:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-[case testConfigFollowImportsNormal]
-# cmd: mypy main.py
-[file main.py]
-from a import x
-x + 0
-x + ''  # E
-import a
-a.x + 0
-a.x + ''  # E
-a.y  # E
-a + 0  # E
-[file mypy.ini]
-\[mypy]
-follow_imports = normal
-[file a.py]
-x = 0
-x += ''  # Error reported here
-[out]
-a.py:2: error: Unsupported operand types for + ("int" and "str")
-main.py:3: error: Unsupported operand types for + ("int" and "str")
-main.py:6: error: Unsupported operand types for + ("int" and "str")
-main.py:7: error: Module has no attribute "y"
-main.py:8: error: Unsupported operand types for + (Module and "int")
-
 [case testConfigFollowImportsSysPath]
 # cmd: mypy main.py
 [file main.py]
@@ -389,102 +303,6 @@ main.py:6: error: Unsupported operand types for + ("int" and "str")
 main.py:7: error: Module has no attribute "y"
 main.py:8: error: Unsupported operand types for + (Module and "int")
 
-[case testConfigFollowImportsSilent]
-# cmd: mypy main.py
-[file main.py]
-from a import x
-x + ''
-import a
-a.x + ''
-a.y
-a + 0
-[file mypy.ini]
-\[mypy]
-follow_imports = silent
-[file a.py]
-x = 0
-x += ''  # No error reported
-[out]
-main.py:2: error: Unsupported operand types for + ("int" and "str")
-main.py:4: error: Unsupported operand types for + ("int" and "str")
-main.py:5: error: Module has no attribute "y"
-main.py:6: error: Unsupported operand types for + (Module and "int")
-
-[case testConfigFollowImportsSkip]
-# cmd: mypy main.py
-[file main.py]
-from a import x
-reveal_type(x)  # Expect Any
-import a
-reveal_type(a.x)  # Expect Any
-[file mypy.ini]
-\[mypy]
-follow_imports = skip
-[file a.py]
-/  # No error reported
-[out]
-main.py:2: note: Revealed type is "Any"
-main.py:4: note: Revealed type is "Any"
-== Return code: 0
-
-[case testConfigFollowImportsError]
-# cmd: mypy main.py
-[file main.py]
-from a import x  # Error reported here
-reveal_type(x)  # Expect Any
-import a
-reveal_type(a.x)  # Expect Any
-[file mypy.ini]
-\[mypy]
-follow_imports = error
-[file a.py]
-/  # No error reported
-[out]
-main.py:1: error: Import of "a" ignored
-main.py:1: note: (Using --follow-imports=error, module not passed on command line)
-main.py:2: note: Revealed type is "Any"
-main.py:4: note: Revealed type is "Any"
-
-[case testConfigFollowImportsSelective]
-# cmd: mypy main.py
-[file mypy.ini]
-\[mypy]
-\[mypy-normal]
-follow_imports = normal
-\[mypy-silent]
-follow_imports = silent
-\[mypy-skip]
-follow_imports = skip
-\[mypy-error]
-follow_imports = error
-[file main.py]
-import normal
-import silent
-import skip
-import error
-reveal_type(normal.x)
-reveal_type(silent.x)
-reveal_type(skip)
-reveal_type(error)
-[file normal.py]
-x = 0
-x += ''
-[file silent.py]
-x = 0
-x += ''
-[file skip.py]
-bla bla
-[file error.py]
-bla bla
-[out]
-normal.py:2: error: Unsupported operand types for + ("int" and "str")
-main.py:4: error: Import of "error" ignored
-main.py:4: note: (Using --follow-imports=error, module not passed on command line)
-main.py:5: note: Revealed type is "builtins.int"
-main.py:6: note: Revealed type is "builtins.int"
-main.py:7: note: Revealed type is "Any"
-main.py:8: note: Revealed type is "Any"
-
 [case testConfigFollowImportsInvalid]
 # cmd: mypy main.py
 [file mypy.ini]
@@ -495,31 +313,6 @@ follow_imports =True
 mypy.ini: [mypy]: follow_imports: invalid choice 'True' (choose from 'normal', 'silent', 'skip', 'error')
 == Return code: 0
 
-[case testConfigSilentMissingImportsOff]
-# cmd: mypy main.py
-[file main.py]
-import missing  # Expect error here
-reveal_type(missing.x)  # Expect Any
-[file mypy.ini]
-\[mypy]
-ignore_missing_imports = False
-[out]
-main.py:1: error: Cannot find implementation or library stub for module named "missing"
-main.py:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
-main.py:2: note: Revealed type is "Any"
-
-[case testConfigSilentMissingImportsOn]
-# cmd: mypy main.py
-[file main.py]
-import missing  # No error here
-reveal_type(missing.x)  # Expect Any
-[file mypy.ini]
-\[mypy]
-ignore_missing_imports = True
-[out]
-main.py:2: note: Revealed type is "Any"
-== Return code: 0
-
 [case testFailedImportOnWrongCWD]
 # cmd: mypy main.py
 # cwd: main/subdir1/subdir2
@@ -592,7 +385,7 @@ main.py:1: error: Cannot find implementation or library stub for module named "a
 \[tool.mypy]
 python_version = 3.10
 [out]
-pyproject.toml: [mypy]: python_version: Python 3.1 is not supported (must be 3.4 or higher). You may need to put quotes around your Python version
+pyproject.toml: [mypy]: python_version: Python 3.1 is not supported (must be 3.8 or higher). You may need to put quotes around your Python version
 == Return code: 0
 
 [case testPythonVersionTooOld10]
@@ -604,13 +397,13 @@ python_version = 1.0
 mypy.ini: [mypy]: python_version: Python major version '1' out of range (must be 3)
 == Return code: 0
 
-[case testPythonVersionTooOld33]
+[case testPythonVersionTooOld37]
 # cmd: mypy -c pass
 [file mypy.ini]
 \[mypy]
-python_version = 3.3
+python_version = 3.7
 [out]
-mypy.ini: [mypy]: python_version: Python 3.3 is not supported (must be 3.4 or higher)
+mypy.ini: [mypy]: python_version: Python 3.7 is not supported (must be 3.8 or higher)
 == Return code: 0
 
 [case testPythonVersionTooNew40]
@@ -633,18 +426,18 @@ usage: mypy [-h] [-v] [-V] [more options; see below]
 mypy: error: Mypy no longer supports checking Python 2 code. Consider pinning to mypy<0.980 if you need to check Python 2 code.
 == Return code: 2
 
-[case testPythonVersionAccepted34]
+[case testPythonVersionAccepted38]
 # cmd: mypy -c pass
 [file mypy.ini]
 \[mypy]
-python_version = 3.4
+python_version = 3.8
 [out]
 
-[case testPythonVersionAccepted36]
+[case testPythonVersionAccepted311]
 # cmd: mypy -c pass
 [file mypy.ini]
 \[mypy]
-python_version = 3.6
+python_version = 3.11
 [out]
 
 -- This should be a dumping ground for tests of plugins that are sensitive to
@@ -676,28 +469,17 @@ int_pow.py:10: note: Revealed type is "builtins.int"
 int_pow.py:11: note: Revealed type is "Any"
 == Return code: 0
 
-[case testDisallowAnyGenericsBuiltinCollections]
+[case testDisallowAnyGenericsBuiltinCollectionsPre39]
 # cmd: mypy m.py
 [file mypy.ini]
 \[mypy]
-python_version=3.6
+python_version = 3.8
 \[mypy-m]
 disallow_any_generics = True
-
 [file m.py]
-s = tuple([1, 2, 3])  # no error
-
-def f(t: tuple) -> None: pass
-def g() -> list: pass
-def h(s: dict) -> None: pass
-def i(s: set) -> None: pass
 def j(s: frozenset) -> None: pass
 [out]
-m.py:3: error: Implicit generic "Any". Use "typing.Tuple" and specify generic parameters
-m.py:4: error: Implicit generic "Any". Use "typing.List" and specify generic parameters
-m.py:5: error: Implicit generic "Any". Use "typing.Dict" and specify generic parameters
-m.py:6: error: Implicit generic "Any". Use "typing.Set" and specify generic parameters
-m.py:7: error: Implicit generic "Any". Use "typing.FrozenSet" and specify generic parameters
+m.py:1: error: Implicit generic "Any". Use "typing.FrozenSet" and specify generic parameters
 
 [case testDisallowAnyGenericsTypingCollections]
 # cmd: mypy m.py
@@ -705,21 +487,11 @@ m.py:7: error: Implicit generic "Any". Use "typing.FrozenSet" and specify generi
 \[mypy]
 \[mypy-m]
 disallow_any_generics = True
-
 [file m.py]
-from typing import Tuple, List, Dict, Set, FrozenSet
-
-def f(t: Tuple) -> None: pass
-def g() -> List: pass
-def h(s: Dict) -> None: pass
-def i(s: Set) -> None: pass
+from typing import FrozenSet
 def j(s: FrozenSet) -> None: pass
 [out]
-m.py:3: error: Missing type parameters for generic type "Tuple"
-m.py:4: error: Missing type parameters for generic type "List"
-m.py:5: error: Missing type parameters for generic type "Dict"
-m.py:6: error: Missing type parameters for generic type "Set"
-m.py:7: error: Missing type parameters for generic type "FrozenSet"
+m.py:2: error: Missing type parameters for generic type "FrozenSet"
 
 [case testSectionInheritance]
 # cmd: mypy a
@@ -756,18 +528,6 @@ ignore_errors = False
 a/b/c/d/e/__init__.py:2: error: Missing type parameters for generic type "List"
 a/b/c/d/e/__init__.py:3: error: Argument 1 to "g" has incompatible type "None"; expected "List[Any]"
 
-[case testDisallowUntypedDefsAndGenerics]
-# cmd: mypy a.py
-[file mypy.ini]
-\[mypy]
-disallow_untyped_defs = True
-disallow_any_generics = True
-[file a.py]
-def get_tasks(self):
-    return 'whatever'
-[out]
-a.py:1: error: Function is missing a return type annotation
-
 [case testMissingFile]
 # cmd: mypy nope.py
 [out]
@@ -775,26 +535,6 @@ mypy: can't read file 'nope.py': No such file or directory
 == Return code: 2
 --'
 
-[case testParseError]
-# cmd: mypy a.py
-[file a.py]
-def foo(
-[out]
-a.py:1: error: unexpected EOF while parsing
-== Return code: 2
-[out version>=3.10]
-a.py:1: error: '(' was never closed
-== Return code: 2
-
-[case testParseErrorAnnots]
-# cmd: mypy a.py
-[file a.py]
-def foo(x):
-    # type: (str, int) -> None
-    return
-[out]
-a.py:1: error: Type signature has too many arguments
-
 [case testModulesAndPackages]
 # cmd: mypy --package p.a --package p.b --module c
 [file p/__init__.py]
@@ -914,6 +654,23 @@ s4.py:2: error: Incompatible return value type (got "int", expected "str")
 s3.py:2: error: Incompatible return value type (got "List[int]", expected "int")
 s1.py:2: error: Incompatible return value type (got "int", expected "str")
 
+[case testShadowFileWithPretty]
+# cmd: mypy a.py --pretty --shadow-file a.py b.py
+[file a.py]
+b: bytes
+[file b.py]
+a: int = ""
+b: bytes = 1
+[out]
+a.py:1: error: Incompatible types in assignment (expression has type "str",
+variable has type "int")
+    a: int = ""
+             ^~
+a.py:2: error: Incompatible types in assignment (expression has type "int",
+variable has type "bytes")
+    b: bytes = 1
+               ^
+
 [case testConfigWarnUnusedSection1]
 # cmd: mypy foo.py quux.py spam/eggs.py
 [file mypy.ini]
@@ -1075,7 +832,7 @@ y = []  # type: List[int]
 x = y
 [out]
 bad.py:4: error: Incompatible types in assignment (expression has type "List[int]", variable has type "List[float]")
-bad.py:4: note: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
+bad.py:4: note: "list" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance
 bad.py:4: note: Consider using "Sequence" instead, which is covariant
 Found 1 error in 1 file (checked 1 source file)
 
@@ -1122,19 +879,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 +909,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
                    ^~~~
@@ -1399,6 +1135,21 @@ b/bpkg.py:1: error: "int" not callable
 [out]
 c/cpkg.py:1: error: "int" not callable
 
+[case testCmdlineExcludeGitignore]
+# cmd: mypy --exclude-gitignore .
+[file .gitignore]
+abc
+[file abc/apkg.py]
+1()
+[file b/.gitignore]
+bpkg.*
+[file b/bpkg.py]
+1()
+[file c/cpkg.py]
+1()
+[out]
+c/cpkg.py:1: error: "int" not callable
+
 [case testCmdlineCfgExclude]
 # cmd: mypy .
 [file mypy.ini]
@@ -1442,14 +1193,6 @@ b \d+
 b\.c \d+
 .*
 
-[case testCmdlineEnableIncompleteFeatures]
-# cmd: mypy --enable-incomplete-features a.py
-[file a.py]
-pass
-[out]
-Warning: --enable-incomplete-features is deprecated, use --enable-incomplete-feature=FEATURE instead
-== Return code: 0
-
 [case testShadowTypingModuleEarlyLoad]
 # cmd: mypy dir
 [file dir/__init__.py]
@@ -1484,26 +1227,21 @@ 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?
 == Return code: 2
 
-[case testRecursiveAliasesFlagDeprecated]
-# cmd: mypy --enable-recursive-aliases a.py
+[case testNewTypeInferenceFlagDeprecated]
+# cmd: mypy --new-type-inference a.py
 [file a.py]
 pass
 [out]
-Warning: --enable-recursive-aliases is deprecated; recursive types are enabled by default
-== Return code: 0
-
-[case testNotesOnlyResultInExitSuccess]
-# cmd: mypy a.py
-[file a.py]
-def f():
-    x: int = "no"
-[out]
-a.py:2: note: By default the bodies of untyped functions are not checked, consider using --check-untyped-defs
+Warning: --new-type-inference flag is deprecated; new type inference algorithm is already enabled by default
 == Return code: 0
 
 [case testCustomTypeshedDirFilePassedExplicitly]
@@ -1523,6 +1261,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]
@@ -1573,6 +1315,22 @@ foo.py:1: error: "int" not callable
 [out]
 foo/m.py:1: error: "int" not callable
 
+[case testCmdlineCfgFilesTrailingComma]
+# cmd: mypy
+[file mypy.ini]
+\[mypy]
+files =
+  a.py,
+  b.py,
+[file a.py]
+x: str = 'x'  # ok
+[file b.py]
+y: int = 'y'  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[file c.py]
+# This should not trigger any errors, because it is not included:
+z: int = 'z'
+[out]
+
 [case testCmdlineCfgEnableErrorCodeTrailingComma]
 # cmd: mypy .
 [file mypy.ini]
@@ -1598,3 +1356,45 @@ disable_error_code =
 always_true =
   MY_VAR,
 [out]
+
+[case testCmdlineCfgModulesTrailingComma]
+# cmd: mypy
+[file mypy.ini]
+\[mypy]
+modules =
+  a,
+  b,
+[file a.py]
+x: str = 'x'  # ok
+[file b.py]
+y: int = 'y'  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[file c.py]
+# This should not trigger any errors, because it is not included:
+z: int = 'z'
+[out]
+
+[case testCmdlineCfgPackagesTrailingComma]
+# cmd: mypy
+[file mypy.ini]
+\[mypy]
+packages =
+  a,
+  b,
+[file a/__init__.py]
+x: str = 'x'  # ok
+[file b/__init__.py]
+y: int = 'y'  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[file c/__init__.py]
+# This should not trigger any errors, because it is not included:
+z: int = 'z'
+[out]
+
+[case testTypeVarTupleUnpackEnabled]
+# cmd: mypy --enable-incomplete-feature=TypeVarTuple --enable-incomplete-feature=Unpack a.py
+[file a.py]
+from typing_extensions import TypeVarTuple
+Ts = TypeVarTuple("Ts")
+[out]
+Warning: TypeVarTuple is already enabled by default
+Warning: Unpack is already enabled by default
+== Return code: 0
diff --git a/test-data/unit/daemon.test b/test-data/unit/daemon.test
index c60068a44bec..19ffce0927ab 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
@@ -35,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
@@ -110,18 +159,18 @@ def plugin(version): return Dummy
 [case testDaemonRunRestartGlobs]
 -- Ensure dmypy is not restarted if the configuration doesn't change and it contains globs
 -- Note: Backslash path separator in output is replaced with forward slash so the same test succeeds on Windows as well
-$ dmypy run -- foo --follow-imports=error --python-version=3.6
+$ dmypy run -- foo --follow-imports=error
 Daemon started
 foo/lol.py:1: error: Name "fail" is not defined
 Found 1 error in 1 file (checked 3 source files)
 == Return code: 1
-$ dmypy run -- foo --follow-imports=error --python-version=3.6
+$ dmypy run -- foo --follow-imports=error
 foo/lol.py:1: error: Name "fail" is not defined
 Found 1 error in 1 file (checked 3 source files)
 == Return code: 1
 $ {python} -c "print('[mypy]')" >mypy.ini
 $ {python} -c "print('ignore_errors=True')" >>mypy.ini
-$ dmypy run -- foo --follow-imports=error --python-version=3.6
+$ dmypy run -- foo --follow-imports=error
 Restarting: configuration changed
 Daemon stopped
 Daemon started
@@ -214,8 +263,40 @@ mypy-daemon: error: Missing target module, package, files, or command.
 $ dmypy stop
 Daemon stopped
 
+[case testDaemonRunTwoFilesFullTypeshed]
+$ dmypy run x.py
+Daemon started
+Success: no issues found in 1 source file
+$ dmypy run y.py
+Success: no issues found in 1 source file
+$ dmypy run x.py
+Success: no issues found in 1 source file
+[file x.py]
+[file y.py]
+
+[case testDaemonCheckTwoFilesFullTypeshed]
+$ dmypy start
+Daemon started
+$ dmypy check foo.py
+foo.py:3: error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+$ dmypy check bar.py
+Success: no issues found in 1 source file
+$ dmypy check foo.py
+foo.py:3: error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+[file foo.py]
+from bar import add
+x: str = add("a", "b")
+x_error: int = add("a", "b")
+[file bar.py]
+def add(a, b) -> str:
+    return a + b
+
 [case testDaemonWarningSuccessExitCode-posix]
-$ dmypy run -- foo.py --follow-imports=error
+$ dmypy run -- foo.py --follow-imports=error --python-version=3.11
 Daemon started
 foo.py:2: note: By default the bodies of untyped functions are not checked, consider using --check-untyped-defs
 Success: no issues found in 1 source file
@@ -233,13 +314,13 @@ def foo():
 [case testDaemonQuickstart]
 $ {python} -c "print('x=1')" >foo.py
 $ {python} -c "print('x=1')" >bar.py
-$ mypy --local-partial-types --cache-fine-grained --follow-imports=error --no-sqlite-cache --python-version=3.6 -- foo.py bar.py
+$ mypy --local-partial-types --cache-fine-grained --follow-imports=error --no-sqlite-cache --python-version=3.11 -- foo.py bar.py
 Success: no issues found in 2 source files
-$ {python} -c "import shutil; shutil.copy('.mypy_cache/3.6/bar.meta.json', 'asdf.json')"
+$ {python} -c "import shutil; shutil.copy('.mypy_cache/3.11/bar.meta.json', 'asdf.json')"
 -- update bar's timestamp but don't change the file
 $ {python} -c "import time;time.sleep(1)"
 $ {python} -c "print('x=1')" >bar.py
-$ dmypy run -- foo.py bar.py --follow-imports=error --use-fine-grained-cache --no-sqlite-cache --python-version=3.6
+$ dmypy run -- foo.py bar.py --follow-imports=error --use-fine-grained-cache --no-sqlite-cache --python-version=3.11
 Daemon started
 Success: no issues found in 2 source files
 $ dmypy status --fswatcher-dump-file test.json
@@ -247,11 +328,11 @@ Daemon is up and running
 $ dmypy stop
 Daemon stopped
 -- copy the original bar cache file back so that the mtime mismatches
-$ {python} -c "import shutil; shutil.copy('asdf.json', '.mypy_cache/3.6/bar.meta.json')"
+$ {python} -c "import shutil; shutil.copy('asdf.json', '.mypy_cache/3.11/bar.meta.json')"
 -- sleep guarantees timestamp changes
 $ {python} -c "import time;time.sleep(1)"
 $ {python} -c "print('lol')" >foo.py
-$ dmypy run --log-file=log -- foo.py bar.py --follow-imports=error --use-fine-grained-cache --no-sqlite-cache --python-version=3.6 --quickstart-file test.json
+$ dmypy run --log-file=log -- foo.py bar.py --follow-imports=error --use-fine-grained-cache --no-sqlite-cache --python-version=3.11 --quickstart-file test.json
 Daemon started
 foo.py:1: error: Name "lol" is not defined
 Found 1 error in 1 file (checked 2 source files)
@@ -260,7 +341,7 @@ Found 1 error in 1 file (checked 2 source files)
 $ {python} -c "import sys; sys.stdout.write(open('log').read())"
 -- make sure the meta file didn't get updated. we use this as an imperfect proxy for
 -- whether the source file got rehashed, which we don't want it to have been.
-$ {python} -c "x = open('.mypy_cache/3.6/bar.meta.json').read(); y = open('asdf.json').read(); assert x == y"
+$ {python} -c "x = open('.mypy_cache/3.11/bar.meta.json').read(); y = open('asdf.json').read(); assert x == y"
 
 [case testDaemonSuggest]
 $ dmypy start --log-file log.txt -- --follow-imports=error --no-error-summary
@@ -311,7 +392,34 @@ def bar() -> None:
     x = foo('abc')  # type: str
     foo(arg='xyz')
 
-[case testDaemonGetType_python38]
+[case testDaemonInspectCheck]
+$ dmypy start
+Daemon started
+$ dmypy check foo.py
+Success: no issues found in 1 source file
+$ dmypy check foo.py --export-types
+Success: no issues found in 1 source file
+$ dmypy inspect foo.py:1:1
+"int"
+[file foo.py]
+x = 1
+
+[case testDaemonInspectRun]
+$ dmypy run test1.py
+Daemon started
+Success: no issues found in 1 source file
+$ dmypy run test2.py
+Success: no issues found in 1 source file
+$ dmypy run test1.py --export-types
+Success: no issues found in 1 source file
+$ dmypy inspect test1.py:1:1
+"int"
+[file test1.py]
+a: int
+[file test2.py]
+a: str
+
+[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
@@ -323,6 +431,9 @@ foo.py:3: error: Incompatible types in assignment (expression has type "str", va
 $ dmypy inspect foo:1
 Format should be file:line:column[:end_line:end_column]
 == Return code: 2
+$ dmypy inspect foo:1:2:3
+Source file is not a Python file
+== Return code: 2
 $ dmypy inspect foo.py:1:2:a:b
 invalid literal for int() with base 10: 'a'
 == Return code: 2
@@ -330,7 +441,7 @@ $ dmypy inspect foo.pyc:1:1:2:2
 Source file is not a Python file
 == Return code: 2
 $ dmypy inspect bar/baz.py:1:1:2:2
-Unknown module: baz
+Unknown module: bar/baz.py
 == Return code: 1
 $ dmypy inspect foo.py:3:1:1:1
 "end_line" must not be before "line"
@@ -374,7 +485,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
@@ -385,7 +496,7 @@ $ dmypy inspect foo.pyc:1:2
 Source file is not a Python file
 == Return code: 2
 $ dmypy inspect bar/baz.py:1:2
-Unknown module: baz
+Unknown module: bar/baz.py
 == Return code: 1
 $ dmypy inspect foo.py:7:5 --include-span
 7:5:7:5 -> "int"
@@ -429,7 +540,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
@@ -471,7 +582,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
@@ -522,3 +633,35 @@ class A:
     x: int
 class B:
     x: int
+
+[case testDaemonInspectSelectCorrectFile]
+$ dmypy run test.py --export-types
+Daemon started
+Success: no issues found in 1 source file
+$ dmypy inspect demo/test.py:1:1
+"int"
+$ dmypy inspect test.py:1:1
+"str"
+[file test.py]
+b: str
+from demo.test import a
+[file demo/test.py]
+a: int
+
+[case testDaemonImportAncestors]
+$ dmypy run test.py
+Daemon started
+test.py:2: error: Unsupported operand types for + ("int" and "str")  [operator]
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+$ dmypy run test.py
+test.py:2: error: Unsupported operand types for + ("int" and "str")  [operator]
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+$ dmypy run test.py
+test.py:2: error: Unsupported operand types for + ("int" and "str")  [operator]
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+[file test.py]
+from xml.etree.ElementTree import Element
+1 + 'a'
diff --git a/test-data/unit/deps-classes.test b/test-data/unit/deps-classes.test
index ebe2e9caed02..a8fc5d629491 100644
--- a/test-data/unit/deps-classes.test
+++ b/test-data/unit/deps-classes.test
@@ -178,6 +178,7 @@ def g() -> None:
     A.X
 [file m.py]
 class B: pass
+[builtins fixtures/enum.pyi]
 [out]
 <m.A.X> -> m.g
 <m.A> -> <m.f>, m.A, m.f, m.g
diff --git a/test-data/unit/deps-expressions.test b/test-data/unit/deps-expressions.test
index ff8c875b66f0..fd5a4fe0ff9f 100644
--- a/test-data/unit/deps-expressions.test
+++ b/test-data/unit/deps-expressions.test
@@ -420,7 +420,7 @@ def g() -> None:
 <m.f2> -> m.g
 
 [case testLiteralDepsExpr]
-from typing_extensions import Literal
+from typing import Literal
 
 Alias = Literal[1]
 
diff --git a/test-data/unit/deps-generics.test b/test-data/unit/deps-generics.test
index c78f3fad90c0..6baa57266d2f 100644
--- a/test-data/unit/deps-generics.test
+++ b/test-data/unit/deps-generics.test
@@ -159,7 +159,7 @@ class D: pass
 T = TypeVar('T', A, B)
 S = TypeVar('S', C, D)
 
-def f(x: T) -> S:
+def f(x: T, y: S) -> S:
     pass
 [out]
 <m.A> -> <m.T>, <m.f>, m, m.A, m.f
diff --git a/test-data/unit/deps-types.test b/test-data/unit/deps-types.test
index def117fe04df..7642e6d7a14c 100644
--- a/test-data/unit/deps-types.test
+++ b/test-data/unit/deps-types.test
@@ -818,7 +818,7 @@ class I: pass
 <mod> -> a
 
 [case testAliasDepsTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 from mod import I
 A = I
 class P(TypedDict):
@@ -826,6 +826,7 @@ class P(TypedDict):
 [file mod.py]
 class I: pass
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 <m.A> -> m
 <m.P> -> m.P
@@ -836,7 +837,7 @@ class I: pass
 
 [case testAliasDepsTypedDictFunctional]
 # __dump_all__
-from mypy_extensions import TypedDict
+from typing import TypedDict
 import a
 P = TypedDict('P', {'x': a.A})
 [file a.py]
@@ -845,6 +846,7 @@ A = I
 [file mod.py]
 class I: pass
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 <a.A> -> m
 <a> -> m
@@ -905,6 +907,7 @@ def g() -> None:
     A.X
 [file mod.py]
 class B: pass
+[builtins fixtures/tuple.pyi]
 [out]
 <m.A.X> -> m.g
 <m.A> -> <m.f>, m.f, m.g
diff --git a/test-data/unit/deps.test b/test-data/unit/deps.test
index 28d51f1a4c30..2c231c9afff6 100644
--- a/test-data/unit/deps.test
+++ b/test-data/unit/deps.test
@@ -432,7 +432,7 @@ def f(x: A) -> None:
         x.y
 [builtins fixtures/isinstancelist.pyi]
 [out]
-<m.<subclass of "A" and "B">.y> -> m.f
+<m.<subclass of "m.A" and "m.B">.y> -> m.f
 <m.A> -> <m.f>, m.A, m.f
 <m.B> -> m.B, m.f
 
@@ -597,6 +597,7 @@ class C:
 <m.f> -> m.C.__init__
 
 [case testPartialNoneTypeAttributeCrash1]
+# flags: --no-local-partial-types
 class C: pass
 
 class A:
@@ -612,7 +613,7 @@ class A:
 <m.C> -> <m.A.x>, m.A.f, m.C
 
 [case testPartialNoneTypeAttributeCrash2]
-# flags: --strict-optional
+# flags: --no-local-partial-types
 class C: pass
 
 class A:
@@ -643,12 +644,13 @@ x = 1
 <pkg> -> m, pkg, pkg.mod
 
 [case testTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337))
 def foo(x: Point) -> int:
     return x['x'] + x['y']
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 <m.Point.__init__> -> m
 <m.Point.__new__> -> m
@@ -656,13 +658,14 @@ def foo(x: Point) -> int:
 <m.p> -> m
 
 [case testTypedDict2]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class A: pass
 Point = TypedDict('Point', {'x': int, 'y': A})
 p = Point(dict(x=42, y=A()))
 def foo(x: Point) -> int:
     return x['x']
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 <m.A.__init__> -> m
 <m.A.__new__> -> m
@@ -673,7 +676,7 @@ def foo(x: Point) -> int:
 <m.p> -> m
 
 [case testTypedDict3]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class A: pass
 class Point(TypedDict):
     x: int
@@ -682,6 +685,7 @@ p = Point(dict(x=42, y=A()))
 def foo(x: Point) -> int:
     return x['x']
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 <m.A.__init__> -> m
 <m.A.__new__> -> m
@@ -750,7 +754,7 @@ class C:
 <mod.decb> -> m.outer
 <mod> -> m, m.outer
 
-[case testDecoratorDepsDeeepNested]
+[case testDecoratorDepsDeepNested]
 import mod
 
 def outer() -> None:
@@ -1370,7 +1374,6 @@ def h() -> None:
 <m.D> -> m.D, m.h
 
 [case testDataclassDepsOldVersion]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 
 Z = int
@@ -1388,11 +1391,13 @@ 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, m.B.__mypy-replace
 <m.A.__new__> -> <m.B.__new__>
 <m.A.x> -> <m.B.x>
 <m.A.y> -> <m.B.y>
 <m.A> -> m, m.A, m.B
 <m.A[wildcard]> -> m
+<m.B.__mypy-replace> -> m
 <m.B.y> -> m
 <m.B> -> m.B
 <m.Z> -> m
@@ -1419,13 +1424,37 @@ 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, m.B.__mypy-replace
 <m.A.__new__> -> <m.B.__new__>
 <m.A.x> -> <m.B.x>
 <m.A.y> -> <m.B.y>
 <m.A> -> m, m.A, m.B
 <m.A[wildcard]> -> m
+<m.B.__mypy-replace> -> m
 <m.B.y> -> m
 <m.B> -> m.B
 <m.Z> -> m
 <dataclasses.dataclass> -> m
 <dataclasses> -> m
+
+[case testPEP695TypeAliasDeps]
+# flags: --python-version=3.12
+from a import C, E
+type A = C
+type A2 = A
+type A3 = E
+[file a.py]
+class C: pass
+class D: pass
+type E = D
+[out]
+<m.A2> -> m
+<m.A3> -> m
+<m.A> -> m
+<a.C.__init__> -> m
+<a.C.__new__> -> m
+<a.C> -> m
+<a.E> -> m
+<a> -> m
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
diff --git a/test-data/unit/diff.test b/test-data/unit/diff.test
index 66adfaecd909..1f1987183fe4 100644
--- a/test-data/unit/diff.test
+++ b/test-data/unit/diff.test
@@ -566,6 +566,7 @@ A = Enum('A', 'x')
 B = Enum('B', 'y')
 C = IntEnum('C', 'x')
 D = IntEnum('D', 'x y')
+[builtins fixtures/enum.pyi]
 [out]
 __main__.B.x
 __main__.B.y
@@ -605,6 +606,7 @@ class D(Enum):
     Y = 'b'
 class F(Enum):
     X = 0
+[builtins fixtures/enum.pyi]
 [out]
 __main__.B.Y
 __main__.B.Z
@@ -615,57 +617,61 @@ __main__.E
 __main__.F
 
 [case testTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337))
 [file next.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': str})
 p = Point(dict(x=42, y='lurr'))
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 __main__.Point
 __main__.p
 
 [case testTypedDict2]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class Point(TypedDict):
     x: int
     y: int
 p = Point(dict(x=42, y=1337))
 [file next.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class Point(TypedDict):
     x: int
     y: str
 p = Point(dict(x=42, y='lurr'))
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 __main__.Point
 __main__.p
 
 [case testTypedDict3]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337))
 [file next.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int})
 p = Point(dict(x=42))
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 __main__.Point
 __main__.p
 
 [case testTypedDict4]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337))
 [file next.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int}, total=False)
 p = Point(dict(x=42, y=1337))
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 __main__.Point
 __main__.p
@@ -1147,7 +1153,7 @@ __main__.Diff
 __main__.Diff.x
 
 [case testLiteralTriggersVar]
-from typing_extensions import Literal
+from typing import Literal
 
 x: Literal[1] = 1
 y = 1
@@ -1165,7 +1171,7 @@ class C:
         self.same_instance: Literal[1] = 1
 
 [file next.py]
-from typing_extensions import Literal
+from typing import Literal
 
 x = 1
 y: Literal[1] = 1
@@ -1194,7 +1200,7 @@ __main__.y
 __main__.z
 
 [case testLiteralTriggersFunctions]
-from typing_extensions import Literal
+from typing import Literal
 
 def function_1() -> int: pass
 def function_2() -> Literal[1]: pass
@@ -1258,7 +1264,7 @@ class C:
     def staticmethod_same_2(x: Literal[1]) -> None: pass
 
 [file next.py]
-from typing_extensions import Literal
+from typing import Literal
 
 def function_1() -> Literal[1]: pass
 def function_2() -> int: pass
@@ -1348,7 +1354,7 @@ __main__.function_5
 __main__.function_6
 
 [case testLiteralTriggersProperty]
-from typing_extensions import Literal
+from typing import Literal
 
 class C:
     @property
@@ -1361,7 +1367,7 @@ class C:
     def same(self) -> Literal[1]: pass
 
 [file next.py]
-from typing_extensions import Literal
+from typing import Literal
 
 class C:
     @property
@@ -1378,8 +1384,7 @@ __main__.C.p1
 __main__.C.p2
 
 [case testLiteralsTriggersOverload]
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 @overload
 def func(x: str) -> str: ...
@@ -1411,8 +1416,7 @@ class C:
         pass
 
 [file next.py]
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 
 @overload
 def func(x: str) -> str: ...
@@ -1448,10 +1452,10 @@ __main__.C.method
 __main__.func
 
 [case testUnionOfLiterals]
-from typing_extensions import Literal
+from typing import Literal
 x: Literal[1, '2']
 [file next.py]
-from typing_extensions import Literal
+from typing import Literal
 x: Literal[1, 2]
 [builtins fixtures/tuple.pyi]
 [out]
@@ -1497,3 +1501,135 @@ class C:
     def meth(self) -> int: return 0
 [out]
 __main__.C.meth
+
+[case testGenericFunctionWithOptionalReturnType]
+from typing import Type, TypeVar
+
+T = TypeVar("T")
+
+class C:
+    @classmethod
+    def get_by_team_and_id(
+        cls: Type[T],
+        raw_member_id: int,
+        include_removed: bool = False,
+    ) -> T:
+        pass
+
+[file next.py]
+from typing import Type, TypeVar, Optional
+
+T = TypeVar("T")
+
+class C:
+    @classmethod
+    def get_by_team_and_id(
+        cls: Type[T],
+        raw_member_id: int,
+        include_removed: bool = False,
+    ) -> Optional[T]:
+        pass
+
+[builtins fixtures/classmethod.pyi]
+[out]
+__main__.C.get_by_team_and_id
+__main__.Optional
+
+[case testPEP695TypeAlias]
+# flags: --python-version=3.12
+from typing_extensions import TypeAlias, TypeAliasType
+type A = int
+type B = str
+type C = int
+D = int
+E: TypeAlias = int
+F = TypeAliasType("F", int)
+G = TypeAliasType("G", int)
+type H = int
+
+[file next.py]
+# flags: --python-version=3.12
+from typing_extensions import TypeAlias, TypeAliasType
+type A = str
+type B = str
+type C[T] = int
+type D = int
+type E = int
+type F = int
+type G = str
+type H[T] = int
+
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+[out]
+__main__.A
+__main__.C
+__main__.D
+__main__.E
+__main__.G
+__main__.H
+
+[case testPEP695TypeAlias2]
+# flags: --python-version=3.12
+type A[T: int] = list[T]
+type B[T: int] = list[T]
+type C[T: (int, str)] = list[T]
+type D[T: (int, str)] = list[T]
+type E[T: int] = list[T]
+type F[T: (int, str)] = list[T]
+
+[file next.py]
+# flags: --python-version=3.12
+type A[T] = list[T]
+type B[T: str] = list[T]
+type C[T: (int, None)] = list[T]
+type D[T] = list[T]
+type E[T: int] = list[T]
+type F[T: (int, str)] = list[T]
+
+[out]
+__main__.A
+__main__.B
+__main__.C
+__main__.D
+
+[case testPEP695GenericFunction]
+# flags: --python-version=3.12
+def f[T](x: T) -> T:
+    return x
+def g[T](x: T, y: T) -> T:
+    return x
+[file next.py]
+# flags: --python-version=3.12
+def f[T](x: T) -> T:
+    return x
+def g[T, S](x: T, y: S) -> S:
+    return y
+[out]
+__main__.g
+
+[case testPEP695GenericClass]
+# flags: --python-version=3.12
+class C[T]:
+    pass
+class D[T]:
+    pass
+class E[T]:
+    pass
+class F[T]:
+    def f(self, x: object) -> T: ...
+[file next.py]
+# flags: --python-version=3.12
+class C[T]:
+    pass
+class D[T: int]:
+    pass
+class E:
+    pass
+class F[T]:
+    def f(self, x: T) -> T: ...
+[out]
+__main__.D
+__main__.E
+__main__.F
+__main__.F.f
diff --git a/test-data/unit/fine-grained-blockers.test b/test-data/unit/fine-grained-blockers.test
index a134fb1d4301..33dedd887114 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 50f93dd35af3..f622cefc5b8e 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.9/@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.9/b.meta.json.2]
+[delete ../.mypy_cache/3.9/p/c.meta.json.2]
 
 [out]
 ==
diff --git a/test-data/unit/fine-grained-dataclass-transform.test b/test-data/unit/fine-grained-dataclass-transform.test
index cc297bc344aa..89628256fda5 100644
--- a/test-data/unit/fine-grained-dataclass-transform.test
+++ b/test-data/unit/fine-grained-dataclass-transform.test
@@ -86,9 +86,9 @@ class A(Dataclass):
 
 [out]
 main:7: error: Unexpected keyword argument "x" for "B"
-builtins.pyi:13: note: "B" defined here
+builtins.pyi:14: note: "B" defined here
 main:7: error: Unexpected keyword argument "y" for "B"
-builtins.pyi:13: note: "B" defined here
+builtins.pyi:14: note: "B" defined here
 ==
 
 [case frozenInheritanceViaDefault]
diff --git a/test-data/unit/fine-grained-dataclass.test b/test-data/unit/fine-grained-dataclass.test
new file mode 100644
index 000000000000..036d858ddf69
--- /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/fine-grained-follow-imports.test b/test-data/unit/fine-grained-follow-imports.test
index 22f2a7895cf9..d716a57123dc 100644
--- a/test-data/unit/fine-grained-follow-imports.test
+++ b/test-data/unit/fine-grained-follow-imports.test
@@ -831,8 +831,7 @@ class A: ...
 import trio
 
 [file trio/__init__.py.2]
-from typing import TypeVar
-from typing_extensions import TypedDict
+from typing import TypedDict, TypeVar
 import trio
 from . import abc as abc
 
@@ -844,5 +843,6 @@ class C(TypedDict):
 import trio
 class A: ...
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 ==
diff --git a/test-data/unit/fine-grained-inspect.test b/test-data/unit/fine-grained-inspect.test
index 2c575ec365b1..0e05769370a2 100644
--- a/test-data/unit/fine-grained-inspect.test
+++ b/test-data/unit/fine-grained-inspect.test
@@ -1,8 +1,8 @@
 [case testInspectTypeBasic]
-# inspect2: --include-kind foo.py:10:13
-# inspect2: --show=type --include-kind foo.py:10:13
-# inspect2: --include-span -vv foo.py:12:5
-# inspect2: --include-span --include-kind foo.py:12:5:12:9
+# inspect2: --include-kind tmp/foo.py:10:13
+# inspect2: --show=type --include-kind tmp/foo.py:10:13
+# inspect2: --include-span -vv tmp/foo.py:12:5
+# inspect2: --include-span --include-kind tmp/foo.py:12:5:12:9
 import foo
 [file foo.py]
 from typing import TypeVar, Generic
@@ -23,16 +23,16 @@ NameExpr -> "C[T]"
 MemberExpr -> "T"
 NameExpr -> "C[T]"
 MemberExpr -> "T"
-12:5:12:5 -> "Type[foo.C[Any]]"
+12:5:12:5 -> "Type[foo.C[builtins.int]]"
 12:5:12:9 -> "foo.C[builtins.int]"
 12:1:12:10 -> "builtins.int"
 CallExpr:12:5:12:9 -> "C[int]"
 
 [case testInspectAttrsBasic]
-# inspect2: --show=attrs foo.py:6:1
-# inspect2: --show=attrs foo.py:7:1
-# inspect2: --show=attrs foo.py:10:1
-# inspect2: --show=attrs --include-object-attrs  foo.py:10:1
+# inspect2: --show=attrs tmp/foo.py:6:1
+# inspect2: --show=attrs tmp/foo.py:7:1
+# inspect2: --show=attrs tmp/foo.py:10:1
+# inspect2: --show=attrs --include-object-attrs  tmp/foo.py:10:1
 import foo
 [file foo.py]
 from bar import Meta
@@ -56,12 +56,12 @@ class Meta(type):
 {"function": ["__name__"], "object": ["__init__"]}
 
 [case testInspectDefBasic]
-# inspect2: --show=definition foo.py:5:5
-# inspect2: --show=definition --include-kind foo.py:6:3
-# inspect2: --show=definition --include-span foo.py:7:5
-# inspect2: --show=definition foo.py:8:1:8:4
-# inspect2: --show=definition foo.py:8:6:8:8
-# inspect2: --show=definition foo.py:9:3
+# inspect2: --show=definition tmp/foo.py:5:5
+# inspect2: --show=definition --include-kind tmp/foo.py:6:3
+# inspect2: --show=definition --include-span tmp/foo.py:7:5
+# inspect2: --show=definition tmp/foo.py:8:1:8:4
+# inspect2: --show=definition tmp/foo.py:8:6:8:8
+# inspect2: --show=definition tmp/foo.py:9:3
 import foo
 [file foo.py]
 from bar import var, test, A
@@ -95,18 +95,18 @@ def foo(x: Union[int, str]) -> None:
 [builtins fixtures/classmethod.pyi]
 [out]
 ==
-bar.py:4:0:meth
+tmp/bar.py:4:0:meth
 MemberExpr -> tmp/bar.py:2:5:x
 7:1:7:5 -> tmp/bar.py:6:9:y
-bar.py:9:1:test
-bar.py:8:1:var
-baz.py:3:2:foo
+tmp/bar.py:9:1:test
+tmp/bar.py:8:1:var
+tmp/baz.py:3:2:foo
 
 [case testInspectFallbackAttributes]
-# inspect2: --show=attrs --include-object-attrs foo.py:5:1
-# inspect2: --show=attrs foo.py:8:1
-# inspect2: --show=attrs --include-kind foo.py:10:1
-# inspect2: --show=attrs --include-kind --include-object-attrs foo.py:10:1
+# inspect2: --show=attrs --include-object-attrs tmp/foo.py:5:1
+# inspect2: --show=attrs tmp/foo.py:8:1
+# inspect2: --show=attrs --include-kind tmp/foo.py:10:1
+# inspect2: --show=attrs --include-kind --include-object-attrs tmp/foo.py:10:1
 import foo
 [file foo.py]
 class B: ...
@@ -128,7 +128,7 @@ NameExpr -> {}
 NameExpr -> {"object": ["__eq__", "__init__", "__ne__"]}
 
 [case testInspectTypeVarBoundAttrs]
-# inspect2: --show=attrs foo.py:8:13
+# inspect2: --show=attrs tmp/foo.py:8:13
 import foo
 [file foo.py]
 from typing import TypeVar
@@ -144,10 +144,10 @@ def foo(arg: T) -> T:
 {"C": ["x"]}
 
 [case testInspectTypeVarValuesAttrs]
-# inspect2: --show=attrs --force-reload foo.py:13:13
-# inspect2: --show=attrs --force-reload --union-attrs foo.py:13:13
-# inspect2: --show=attrs foo.py:16:5
-# inspect2: --show=attrs --union-attrs foo.py:16:5
+# inspect2: --show=attrs --force-reload tmp/foo.py:13:13
+# inspect2: --show=attrs --force-reload --union-attrs tmp/foo.py:13:13
+# inspect2: --show=attrs tmp/foo.py:16:5
+# inspect2: --show=attrs --union-attrs tmp/foo.py:16:5
 import foo
 [file foo.py]
 from typing import TypeVar, Generic
@@ -174,8 +174,8 @@ class C(Generic[T]):
 {"A": ["x", "z"], "B": ["y", "z"]}
 
 [case testInspectTypeVarBoundDef]
-# inspect2: --show=definition foo.py:9:13
-# inspect2: --show=definition foo.py:8:9
+# inspect2: --show=definition tmp/foo.py:9:13
+# inspect2: --show=definition tmp/foo.py:8:9
 import foo
 [file foo.py]
 from typing import TypeVar
@@ -189,13 +189,13 @@ def foo(arg: T) -> T:
     return arg
 [out]
 ==
-foo.py:7:9:arg
-foo.py:4:5:x
+tmp/foo.py:7:9:arg
+tmp/foo.py:4:5:x
 
 [case testInspectTypeVarValuesDef]
-# inspect2: --show=definition --force-reload foo.py:13:9
-# inspect2: --show=definition --force-reload foo.py:14:13
-# inspect2: --show=definition foo.py:18:7
+# inspect2: --show=definition --force-reload tmp/foo.py:13:9
+# inspect2: --show=definition --force-reload tmp/foo.py:14:13
+# inspect2: --show=definition tmp/foo.py:18:7
 import foo
 [file foo.py]
 from typing import TypeVar, Generic
@@ -218,12 +218,12 @@ class C(Generic[T]):
     x.z
 [out]
 ==
-foo.py:5:5:z, tmp/foo.py:9:5:z
-foo.py:12:9:arg
-foo.py:5:5:z, tmp/foo.py:9:5:z
+tmp/foo.py:5:5:z, tmp/foo.py:9:5:z
+tmp/foo.py:12:9:arg
+tmp/foo.py:5:5:z, tmp/foo.py:9:5:z
 
 [case testInspectModuleAttrs]
-# inspect2: --show=attrs foo.py:2:1
+# inspect2: --show=attrs tmp/foo.py:2:1
 import foo
 [file foo.py]
 from pack import bar
@@ -236,10 +236,10 @@ class C: ...
 [builtins fixtures/module.pyi]
 [out]
 ==
-{"<pack.bar>": ["C", "__annotations__", "__doc__", "__file__", "__name__", "__package__", "bar", "x"], "ModuleType": ["__file__", "__getattr__"]}
+{"<pack.bar>": ["C", "__annotations__", "__doc__", "__file__", "__name__", "__package__", "__spec__", "bar", "x"], "ModuleType": ["__file__", "__getattr__"]}
 
 [case testInspectModuleDef]
-# inspect2: --show=definition --include-kind foo.py:2:1
+# inspect2: --show=definition --include-kind tmp/foo.py:2:1
 import foo
 [file foo.py]
 from pack import bar
@@ -255,7 +255,7 @@ NameExpr -> tmp/pack/bar.py:1:1:bar
 MemberExpr -> tmp/pack/bar.py:3:5:x
 
 [case testInspectFunctionArgDef]
-# inspect2: --show=definition --include-span foo.py:4:13
+# inspect2: --show=definition --include-span tmp/foo.py:4:13
 # TODO: for now all arguments have line/column set to function definition.
 import foo
 [file foo.py]
diff --git a/test-data/unit/fine-grained-modules.test b/test-data/unit/fine-grained-modules.test
index 163e859276cb..f28dbaa1113b 100644
--- a/test-data/unit/fine-grained-modules.test
+++ b/test-data/unit/fine-grained-modules.test
@@ -837,15 +837,13 @@ p.a.f(1)
 [file p/__init__.py]
 [file p/a.py]
 def f(x: str) -> None: pass
-[delete p/__init__.py.2]
-[delete p/a.py.2]
-def f(x: str) -> None: pass
+[delete p.2]
 [out]
 main:2: error: Argument 1 to "f" has incompatible type "int"; expected "str"
 ==
 main:1: error: Cannot find implementation or library stub for module named "p.a"
 main:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
-main:2: error: "object" has no attribute "a"
+main:1: error: Cannot find implementation or library stub for module named "p"
 
 [case testDeletePackage2]
 import p
diff --git a/test-data/unit/fine-grained-python312.test b/test-data/unit/fine-grained-python312.test
new file mode 100644
index 000000000000..2cb2148a66fe
--- /dev/null
+++ b/test-data/unit/fine-grained-python312.test
@@ -0,0 +1,117 @@
+[case testPEP695TypeAliasDep]
+import m
+def g() -> m.C:
+    return m.f()
+[file m.py]
+type C = int
+
+def f() -> int:
+    pass
+[file m.py.2]
+type C = str
+
+def f() -> int:
+    pass
+[out]
+==
+main:3: error: Incompatible return value type (got "int", expected "str")
+
+[case testPEP695ChangeOldStyleToNewStyleTypeAlias]
+from m import A
+A()
+
+[file m.py]
+A = int
+
+[file m.py.2]
+type A = int
+[typing fixtures/typing-full.pyi]
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: "TypeAliasType" not callable
+
+[case testPEP695VarianceChangesDueToDependency]
+from a import C
+
+x: C[object] = C[int]()
+
+[file a.py]
+from b import A
+
+class C[T]:
+    def f(self) -> A[T]: ...
+
+[file b.py]
+class A[T]:
+    def f(self) -> T: ...
+
+[file b.py.2]
+class A[T]:
+    def f(self) -> list[T]: ...
+
+[out]
+==
+main:3: error: Incompatible types in assignment (expression has type "C[int]", variable has type "C[object]")
+
+[case testPEP695TypeAliasChangesDueToDependency]
+from a import A
+x: A
+x = 0
+x = ''
+
+[file a.py]
+from b import B
+type A = B[int, str]
+
+[file b.py]
+from typing import Union as B
+
+[file b.py.2]
+from builtins import tuple as B
+
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+[out]
+==
+main:3: error: Incompatible types in assignment (expression has type "int", variable has type "Tuple[int, str]")
+main:4: error: Incompatible types in assignment (expression has type "str", variable has type "Tuple[int, str]")
+
+[case testPEP695NestedGenericClassMethodUpdated]
+from a import f
+
+class C:
+    class D[T]:
+        x: T
+        def m(self) -> T:
+            f()
+            return self.x
+
+[file a.py]
+def f() -> None: pass
+
+[file a.py.2]
+def f(x: int) -> None: pass
+[out]
+==
+main:7: error: Missing positional argument "x" in call to "f"
+
+[case testPEP695MultipleNestedGenericClassMethodUpdated]
+from a import f
+
+class A:
+    class C:
+        class D[T]:
+            x: T
+            def m(self) -> T:
+                f()
+                return self.x
+
+[file a.py]
+def f() -> None: pass
+
+[file a.py.2]
+def f(x: int) -> None: pass
+[out]
+==
+main:8: error: Missing positional argument "x" in call to "f"
diff --git a/test-data/unit/fine-grained-suggest.test b/test-data/unit/fine-grained-suggest.test
index a28e3204b93f..2539886229cf 100644
--- a/test-data/unit/fine-grained-suggest.test
+++ b/test-data/unit/fine-grained-suggest.test
@@ -62,7 +62,6 @@ foo('3', '4')
 ==
 
 [case testSuggestInferFunc1]
-# flags: --strict-optional
 # suggest: foo.foo
 [file foo.py]
 def foo(arg, lol=None):
@@ -85,7 +84,6 @@ def untyped(x) -> None:
 ==
 
 [case testSuggestInferFunc2]
-# flags: --strict-optional
 # suggest: foo.foo
 [file foo.py]
 def foo(arg):
@@ -161,13 +159,14 @@ def foo():
 [case testSuggestInferTypedDict]
 # suggest: foo.foo
 [file foo.py]
-from typing_extensions import TypedDict
+from typing import TypedDict
 TD = TypedDict('TD', {'x': int})
 def foo():
     return bar()
 
 def bar() -> TD: ...
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 () -> foo.TD
 ==
@@ -222,7 +221,6 @@ Foo('lol')
 ==
 
 [case testSuggestInferMethod1]
-# flags: --strict-optional
 # suggest: --no-any foo.Foo.foo
 [file foo.py]
 class Foo:
@@ -248,7 +246,6 @@ def bar() -> None:
 ==
 
 [case testSuggestInferMethod2]
-# flags: --strict-optional
 # suggest: foo.Foo.foo
 [file foo.py]
 class Foo:
@@ -275,7 +272,6 @@ def bar() -> None:
 ==
 
 [case testSuggestInferMethod3]
-# flags: --strict-optional
 # suggest2: foo.Foo.foo
 [file foo.py]
 class Foo:
@@ -372,7 +368,6 @@ def has_nested(x):
 ==
 
 [case testSuggestInferFunctionUnreachable]
-# flags: --strict-optional
 # suggest: foo.foo
 [file foo.py]
 import sys
@@ -390,7 +385,6 @@ foo('test')
 ==
 
 [case testSuggestInferMethodStep2]
-# flags: --strict-optional
 # suggest2: foo.Foo.foo
 [file foo.py]
 class Foo:
@@ -417,7 +411,6 @@ def bar() -> None:
 (Union[str, int, None], Optional[int]) -> Union[int, str]
 
 [case testSuggestInferNestedMethod]
-# flags: --strict-optional
 # suggest: foo.Foo.Bar.baz
 [file foo.py]
 class Foo:
@@ -435,7 +428,6 @@ def bar() -> None:
 ==
 
 [case testSuggestCallable]
-# flags: --strict-optional
 # suggest: foo.foo
 # suggest: foo.bar
 # suggest: --flex-any=0.9 foo.bar
@@ -483,7 +475,6 @@ No guesses that match criteria!
 ==
 
 [case testSuggestNewSemanal]
-# flags: --strict-optional
 # suggest: foo.Foo.foo
 # suggest: foo.foo
 [file foo.py]
@@ -521,7 +512,6 @@ def baz() -> None:
 ==
 
 [case testSuggestInferFuncDecorator1]
-# flags: --strict-optional
 # suggest: foo.foo
 [file foo.py]
 from typing import TypeVar
@@ -543,7 +533,6 @@ def bar() -> None:
 ==
 
 [case testSuggestInferFuncDecorator2]
-# flags: --strict-optional
 # suggest: foo.foo
 [file foo.py]
 from typing import TypeVar, Callable, Any
@@ -565,7 +554,6 @@ def bar() -> None:
 ==
 
 [case testSuggestInferFuncDecorator3]
-# flags: --strict-optional
 # suggest: foo.foo
 [file foo.py]
 from typing import TypeVar, Callable, Any
@@ -589,7 +577,6 @@ def bar() -> None:
 ==
 
 [case testSuggestInferFuncDecorator4]
-# flags: --strict-optional
 # suggest: foo.foo
 [file dec.py]
 from typing import TypeVar, Callable, Any
@@ -615,8 +602,56 @@ def bar() -> None:
 (str) -> str
 ==
 
+[case testSuggestInferFuncDecorator5]
+# suggest: foo.foo1
+# suggest: foo.foo2
+# suggest: foo.foo3
+[file foo.py]
+from __future__ import annotations
+
+from typing import TypeVar, Generator, Callable
+
+F = TypeVar('F')
+
+# simplified `@contextmanager
+class _impl:
+    def __call__(self, f: F) -> F: return f
+def contextmanager(gen: Callable[[], Generator[None, None, None]]) -> Callable[[], _impl]: return _impl
+
+@contextmanager
+def gen() -> Generator[None, None, None]:
+    yield
+
+@gen()
+def foo1(x):
+    return x
+
+foo1('hi')
+
+inst = gen()
+
+@inst
+def foo2(x):
+    return x
+
+foo2('hello')
+
+ref = gen
+
+@ref()
+def foo3(x):
+    return x
+
+foo3('hello hello')
+
+[builtins fixtures/isinstancelist.pyi]
+[out]
+(str) -> str
+(str) -> str
+(str) -> str
+==
+
 [case testSuggestFlexAny1]
-# flags: --strict-optional
 # suggest: --flex-any=0.4 m.foo
 # suggest: --flex-any=0.7 m.foo
 # suggest: --flex-any=0.4 m.bar
@@ -661,7 +696,6 @@ No guesses that match criteria!
 
 
 [case testSuggestFlexAny2]
-# flags: --strict-optional
 # suggest: --flex-any=0.5 m.baz
 # suggest: --flex-any=0.0 m.baz
 # suggest: --flex-any=0.5 m.F.foo
@@ -693,7 +727,6 @@ No guesses that match criteria!
 ==
 
 [case testSuggestClassMethod]
-# flags: --strict-optional
 # suggest: foo.F.bar
 # suggest: foo.F.baz
 # suggest: foo.F.eggs
@@ -1090,7 +1123,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 88a11be31f34..df244b3135e9 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
             ^~~~~
@@ -196,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]
@@ -657,7 +652,6 @@ class M(type):
 a.py:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 [case testDataclassUpdate1]
-# flags: --python-version 3.7
 [file a.py]
 from dataclasses import dataclass
 
@@ -696,7 +690,6 @@ b.py:8: error: Argument 1 to "B" has incompatible type "int"; expected "str"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassUpdate2]
-# flags: --python-version 3.7
 [file c.py]
 Foo = int
 
@@ -727,7 +720,6 @@ b.py:8: error: Argument 1 to "B" has incompatible type "int"; expected "str"
 [builtins fixtures/dataclasses.pyi]
 
 [case testDataclassUpdate3]
-# flags: --python-version 3.7
 from b import B
 B(1, 2)
 [file b.py]
@@ -751,10 +743,9 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 [out]
 ==
-main:3: error: Missing positional argument "b" in call to "B"
+main:2: error: Missing positional argument "b" in call to "B"
 
 [case testDataclassUpdate4]
-# flags: --python-version 3.7
 from b import B
 B(1, 2)
 [file b.py]
@@ -778,10 +769,9 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 [out]
 ==
-main:3: error: Missing positional argument "b" in call to "B"
+main:2: error: Missing positional argument "b" in call to "B"
 
 [case testDataclassUpdate5]
-# flags: --python-version 3.7
 from b import B
 B(1, 2)
 [file b.py]
@@ -812,11 +802,10 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 [out]
 ==
-main:3: error: Missing positional argument "b" in call to "B"
+main:2: error: Missing positional argument "b" in call to "B"
 ==
 
 [case testDataclassUpdate6]
-# flags: --python-version 3.7
 from b import B
 B(1, 2) < B(1, 2)
 [file b.py]
@@ -839,10 +828,9 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 [out]
 ==
-main:3: error: Unsupported left operand type for < ("B")
+main:2: error: Unsupported left operand type for < ("B")
 
 [case testDataclassUpdate8]
-# flags: --python-version 3.7
 from c import C
 C(1, 2, 3)
 [file c.py]
@@ -872,10 +860,9 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 [out]
 ==
-main:3: error: Missing positional argument "c" in call to "C"
+main:2: error: Missing positional argument "c" in call to "C"
 
 [case testDataclassUpdate9]
-# flags: --python-version 3.7
 from c import C
 C(1, 2, 3)
 [file c.py]
@@ -912,7 +899,7 @@ class A:
 [builtins fixtures/dataclasses.pyi]
 [out]
 ==
-main:3: error: Missing positional argument "c" in call to "C"
+main:2: error: Missing positional argument "c" in call to "C"
 ==
 
 [case testAttrsUpdate1]
@@ -1729,15 +1716,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]
@@ -2088,7 +2075,6 @@ a.py:5: error: "list" expects 1 type argument, but 2 given
 ==
 
 [case testPreviousErrorInOverloadedFunction]
-# flags: --strict-optional
 import a
 [file a.py]
 from typing import overload
@@ -2383,7 +2369,7 @@ a.py:7: error: "B" has no attribute "x"
 ==
 a.py:5: error: Missing positional argument "x" in call to "C"
 
-[case testDecoratorUpdateDeeepNested]
+[case testDecoratorUpdateDeepNested]
 import a
 [file a.py]
 import mod
@@ -3499,7 +3485,6 @@ def foo() -> None:
 b.py:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 [case testNamedTupleUpdateNonRecursiveToRecursiveFine]
-# flags: --strict-optional
 import c
 [file a.py]
 from b import M
@@ -3542,7 +3527,6 @@ c.py:5: error: Incompatible types in assignment (expression has type "Optional[N
 c.py:7: note: Revealed type is "Tuple[Union[Tuple[Union[..., None], builtins.int, fallback=b.M], None], builtins.int, fallback=a.N]"
 
 [case testTupleTypeUpdateNonRecursiveToRecursiveFine]
-# flags: --strict-optional
 import c
 [file a.py]
 from b import M
@@ -3575,7 +3559,6 @@ c.py:4: note: Revealed type is "Tuple[Union[Tuple[Union[..., None], builtins.int
 c.py:5: error: Incompatible types in assignment (expression has type "Optional[N]", variable has type "int")
 
 [case testTypeAliasUpdateNonRecursiveToRecursiveFine]
-# flags: --strict-optional
 import c
 [file a.py]
 from b import M
@@ -3608,27 +3591,28 @@ c.py:4: note: Revealed type is "Tuple[Union[Tuple[Union[..., None], builtins.int
 c.py:5: error: Incompatible types in assignment (expression has type "Optional[N]", variable has type "int")
 
 [case testTypedDictRefresh]
-[builtins fixtures/dict.pyi]
 import a
 [file a.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337))
 [file a.py.2]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337)) # dummy change
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 ==
 
 [case testTypedDictUpdate]
 import b
 [file a.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 p = Point(dict(x=42, y=1337))
 [file a.py.2]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': str})
 p = Point(dict(x=42, y='lurr'))
 [file b.py]
@@ -3636,6 +3620,7 @@ from a import Point
 def foo(x: Point) -> int:
     return x['x'] + x['y']
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 ==
 b.py:3: error: Unsupported operand types for + ("int" and "str")
@@ -3643,13 +3628,13 @@ b.py:3: error: Unsupported operand types for + ("int" and "str")
 [case testTypedDictUpdate2]
 import b
 [file a.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class Point(TypedDict):
     x: int
     y: int
 p = Point(dict(x=42, y=1337))
 [file a.py.2]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class Point(TypedDict):
     x: int
     y: str
@@ -3659,6 +3644,7 @@ from a import Point
 def foo(x: Point) -> int:
     return x['x'] + x['y']
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 ==
 b.py:3: error: Unsupported operand types for + ("int" and "str")
@@ -3666,16 +3652,14 @@ b.py:3: error: Unsupported operand types for + ("int" and "str")
 [case testTypedDictUpdate3]
 import b
 [file a.py]
-from mypy_extensions import TypedDict
-from typing import Optional
+from typing import Optional, TypedDict
 class Point(TypedDict):
     x: Optional[Point]
     y: int
     z: int
 p = Point(dict(x=None, y=1337, z=0))
 [file a.py.2]
-from mypy_extensions import TypedDict
-from typing import Optional
+from typing import Optional, TypedDict
 class Point(TypedDict):
     x: Optional[Point]
     y: str
@@ -3687,6 +3671,7 @@ def foo(x: Point) -> int:
     assert x['x'] is not None
     return x['x']['z'] + x['x']['y']
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 ==
 b.py:4: error: Unsupported operand types for + ("int" and "str")
@@ -3694,13 +3679,12 @@ b.py:4: error: Unsupported operand types for + ("int" and "str")
 [case testTypedDictUpdateGeneric]
 import b
 [file a.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class Point(TypedDict):
     x: int
     y: int
 [file a.py.2]
-from mypy_extensions import TypedDict
-from typing import Generic, TypeVar
+from typing import Generic, TypedDict, TypeVar
 
 T = TypeVar("T")
 class Point(TypedDict, Generic[T]):
@@ -3717,11 +3701,44 @@ def foo() -> None:
     p = Point(x=0, y="no")
     i: int = p["y"]
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 ==
 ==
 b.py:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
 
+[case testTypedDictUpdateReadOnly]
+import b
+[file a.py]
+from typing import TypedDict
+from typing_extensions import ReadOnly
+Point = TypedDict('Point', {'x': int, 'y': int})
+p = Point(x=1, y=2)
+[file a.py.2]
+from typing import TypedDict
+from typing_extensions import ReadOnly
+class Point(TypedDict):
+    x: int
+    y: ReadOnly[int]
+p = Point(x=1, y=2)
+[file a.py.3]
+from typing import TypedDict
+from typing_extensions import ReadOnly
+Point = TypedDict('Point', {'x': ReadOnly[int], 'y': int})
+p = Point(x=1, y=2)
+[file b.py]
+from a import Point
+def foo(x: Point) -> None:
+    x['x'] = 1
+    x['y'] = 2
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+[out]
+==
+b.py:4: error: ReadOnly TypedDict key "y" TypedDict is mutated
+==
+b.py:3: error: ReadOnly TypedDict key "x" TypedDict is mutated
+
 [case testBasicAliasUpdate]
 import b
 [file a.py]
@@ -4041,7 +4058,7 @@ def f(x: a.A[str]):
 [builtins fixtures/dict.pyi]
 [out]
 ==
-b.py:2: error: Bad number of arguments for type alias, expected: 2, given: 1
+b.py:2: error: Bad number of arguments for type alias, expected 2, given 1
 
 [case testAliasFineAdded]
 import b
@@ -4503,9 +4520,9 @@ x = 0
 x = ''
 [builtins fixtures/tuple.pyi]
 [out]
-b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[int, ...], object], int]")
+b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[object], int]")
 ==
-b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[int, ...], object], int]")
+b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[object], int]")
 
 [case testReprocessEllipses1]
 import a
@@ -4631,6 +4648,7 @@ class User:
 ==
 
 [case testNoStrictOptionalModule]
+# flags: --no-strict-optional
 import a
 a.y = a.x
 [file a.py]
@@ -4648,9 +4666,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:
@@ -4671,9 +4690,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:
@@ -4698,10 +4718,9 @@ 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
 import a
 a.y = a.x
 [file a.py]
@@ -4714,10 +4733,9 @@ x: Optional[int]
 y: int
 [out]
 ==
-main:3: error: Incompatible types in assignment (expression has type "Optional[int]", variable has type "int")
+main:2: error: Incompatible types in assignment (expression has type "Optional[int]", variable has type "int")
 
 [case testStrictOptionalFunction]
-# flags: --strict-optional
 import a
 from typing import Optional
 def f() -> None:
@@ -4733,10 +4751,9 @@ def g(x: int) -> None:
     pass
 [out]
 ==
-main:6: error: Argument 1 to "g" has incompatible type "Optional[int]"; expected "int"
+main:5: error: Argument 1 to "g" has incompatible type "Optional[int]"; expected "int"
 
 [case testStrictOptionalMethod]
-# flags: --strict-optional
 import a
 from typing import Optional
 class C:
@@ -4755,7 +4772,7 @@ class B:
         pass
 [out]
 ==
-main:7: error: Argument 1 to "g" of "B" has incompatible type "Optional[int]"; expected "int"
+main:6: error: Argument 1 to "g" of "B" has incompatible type "Optional[int]"; expected "int"
 
 [case testPerFileStrictOptionalModule]
 import a
@@ -5281,10 +5298,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):
@@ -5306,10 +5324,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):
@@ -5342,6 +5361,7 @@ c: C
 c = C.X
 if int():
     c = 1
+[builtins fixtures/enum.pyi]
 [out]
 ==
 ==
@@ -5373,6 +5393,7 @@ if int():
     n = C.X
     if int():
         n = c
+[builtins fixtures/enum.pyi]
 [out]
 ==
 ==
@@ -5397,6 +5418,7 @@ from enum import Enum
 
 class C(Enum):
     X = 0
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
 [out]
 ==
@@ -5419,6 +5441,7 @@ from enum import Enum
 class C(Enum):
     X = 0
     Y = 1
+[builtins fixtures/enum.pyi]
 [out]
 ==
 a.py:4: error: Argument 1 to "f" has incompatible type "C"; expected "int"
@@ -5443,6 +5466,7 @@ c: C
 c = C.X
 if int():
    c = 1
+[builtins fixtures/tuple.pyi]
 [out]
 ==
 ==
@@ -5472,6 +5496,7 @@ if int():
     n: int
     n = C.X
 n = c
+[builtins fixtures/enum.pyi]
 [out]
 ==
 ==
@@ -5493,6 +5518,7 @@ C = Enum('C', 'X Y')
 from enum import Enum
 
 C = Enum('C', 'X')
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
 [out]
 ==
@@ -5513,6 +5539,7 @@ class C:
 [file b.py.2]
 from enum import Enum
 C = Enum('C', [('X', 0), ('Y', 1)])
+[builtins fixtures/tuple.pyi]
 [out]
 ==
 a.py:4: error: Argument 1 to "f" has incompatible type "C"; expected "int"
@@ -5549,7 +5576,7 @@ main:9: error: Function "a.T" is not valid as a type
 main:9: note: Perhaps you need "Callable[...]" or a callback protocol?
 main:12: error: Function "a.T" is not valid as a type
 main:12: note: Perhaps you need "Callable[...]" or a callback protocol?
-main:12: error: Bad number of arguments for type alias, expected: 0, given: 1
+main:12: error: Bad number of arguments for type alias, expected 0, given 1
 
 [case testChangeTypeVarToModule]
 
@@ -5583,7 +5610,7 @@ main:9: error: Module "T" is not valid as a type
 main:9: note: Perhaps you meant to use a protocol matching the module structure?
 main:12: error: Module "T" is not valid as a type
 main:12: note: Perhaps you meant to use a protocol matching the module structure?
-main:12: error: Bad number of arguments for type alias, expected: 0, given: 1
+main:12: error: Bad number of arguments for type alias, expected 0, given 1
 
 [case testChangeClassToModule]
 
@@ -5635,7 +5662,7 @@ T = int
 ==
 main:5: error: Free type variable expected in Generic[...]
 main:9: error: "C" expects no type arguments, but 1 given
-main:12: error: Bad number of arguments for type alias, expected: 0, given: 1
+main:12: error: Bad number of arguments for type alias, expected 0, given 1
 
 [case testChangeTypeAliasToModule]
 
@@ -6945,7 +6972,7 @@ class A:
 ==
 main:3: error: "A" has no attribute "__iter__" (not iterable)
 
-[case testWeAreCarefullWithBuiltinProtocolsBase]
+[case testWeAreCarefulWithBuiltinProtocolsBase]
 import a
 x: a.A
 for i in x:
@@ -7098,7 +7125,7 @@ class AS:
 ==
 main:9: error: Incompatible types in assignment (expression has type "int", variable has type "str")
 
-[case testOverloadsUpdatedTypeRechekConsistency]
+[case testOverloadsUpdatedTypeRecheckConsistency]
 from typing import overload
 import mod
 class Outer:
@@ -7153,7 +7180,7 @@ T = TypeVar('T', bound=str)
 a.py:2: error: No overload variant of "f" matches argument type "int"
 a.py:2: note: Possible overload variants:
 a.py:2: note:     def f(x: C) -> None
-a.py:2: note:     def [c.T <: str] f(x: c.T) -> c.T
+a.py:2: note:     def [c.T: str] f(x: c.T) -> c.T
 
 [case testOverloadsGenericToNonGeneric]
 import a
@@ -7774,7 +7801,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:
@@ -7786,7 +7814,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
@@ -7952,7 +7980,7 @@ class Foo(a.I):
 ==
 
 [case testImplicitOptionalRefresh1]
-# flags: --strict-optional --implicit-optional
+# flags: --implicit-optional
 from x import f
 def foo(x: int = None) -> None:
     f()
@@ -8032,7 +8060,7 @@ A = NamedTuple('A', F)  # type: ignore
 [builtins fixtures/list.pyi]
 [out]
 ==
-b.py:3: note: Revealed type is "Tuple[, fallback=a.A]"
+b.py:3: note: Revealed type is "Tuple[(), fallback=a.A]"
 
 [case testImportOnTopOfAlias1]
 from a import A
@@ -8691,10 +8719,10 @@ reveal_type(mod.x)
 [file mod.py]
 x = 1
 [file mod.py.2]
-from typing_extensions import Literal
+from typing import Literal
 x: Literal[1] = 1
 [file mod.py.3]
-from typing_extensions import Literal
+from typing import Literal
 x: Literal[1] = 2
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8711,10 +8739,10 @@ foo(3)
 [file mod.py]
 def foo(x: int) -> None: pass
 [file mod.py.2]
-from typing_extensions import Literal
+from typing import Literal
 def foo(x: Literal[3]) -> None: pass
 [file mod.py.3]
-from typing_extensions import Literal
+from typing import Literal
 def foo(x: Literal[4]) -> None: pass
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8728,10 +8756,10 @@ a: Alias = 1
 [file mod.py]
 Alias = int
 [file mod.py.2]
-from typing_extensions import Literal
+from typing import Literal
 Alias = Literal[1]
 [file mod.py.3]
-from typing_extensions import Literal
+from typing import Literal
 Alias = Literal[2]
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8743,16 +8771,14 @@ main:2: error: Incompatible types in assignment (expression has type "Literal[1]
 from mod import foo
 reveal_type(foo(4))
 [file mod.py]
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 @overload
 def foo(x: int) -> str: ...
 @overload
 def foo(x: Literal['bar']) -> int: ...
 def foo(x): pass
 [file mod.py.2]
-from typing import overload
-from typing_extensions import Literal
+from typing import Literal, overload
 @overload
 def foo(x: Literal[4]) -> Literal['foo']: ...
 @overload
@@ -8768,7 +8794,7 @@ main:2: note: Revealed type is "Literal['foo']"
 
 [case testLiteralFineGrainedChainedDefinitions]
 from mod1 import foo
-from typing_extensions import Literal
+from typing import Literal
 def expect_3(x: Literal[3]) -> None: pass
 expect_3(foo)
 [file mod1.py]
@@ -8777,10 +8803,10 @@ foo = bar
 [file mod2.py]
 from mod3 import qux as bar
 [file mod3.py]
-from typing_extensions import Literal
+from typing import Literal
 qux: Literal[3]
 [file mod3.py.2]
-from typing_extensions import Literal
+from typing import Literal
 qux: Literal[4]
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8789,7 +8815,7 @@ main:4: error: Argument 1 to "expect_3" has incompatible type "Literal[4]"; expe
 
 [case testLiteralFineGrainedChainedAliases]
 from mod1 import Alias1
-from typing_extensions import Literal
+from typing import Literal
 x: Alias1
 def expect_3(x: Literal[3]) -> None: pass
 expect_3(x)
@@ -8800,10 +8826,10 @@ Alias1 = Alias2
 from mod3 import Alias3
 Alias2 = Alias3
 [file mod3.py]
-from typing_extensions import Literal
+from typing import Literal
 Alias3 = Literal[3]
 [file mod3.py.2]
-from typing_extensions import Literal
+from typing import Literal
 Alias3 = Literal[4]
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8812,7 +8838,7 @@ main:5: error: Argument 1 to "expect_3" has incompatible type "Literal[4]"; expe
 
 [case testLiteralFineGrainedChainedFunctionDefinitions]
 from mod1 import func1
-from typing_extensions import Literal
+from typing import Literal
 def expect_3(x: Literal[3]) -> None: pass
 expect_3(func1())
 [file mod1.py]
@@ -8821,10 +8847,10 @@ from mod2 import func2 as func1
 from mod3 import func3
 func2 = func3
 [file mod3.py]
-from typing_extensions import Literal
+from typing import Literal
 def func3() -> Literal[3]: pass
 [file mod3.py.2]
-from typing_extensions import Literal
+from typing import Literal
 def func3() -> Literal[4]: pass
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8843,7 +8869,7 @@ foo = func(bar)
 [file mod2.py]
 bar = 3
 [file mod2.py.2]
-from typing_extensions import Literal
+from typing import Literal
 bar: Literal[3] = 3
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8853,23 +8879,23 @@ main:2: note: Revealed type is "Literal[3]"
 
 [case testLiteralFineGrainedChainedViaFinal]
 from mod1 import foo
-from typing_extensions import Literal
+from typing import Literal
 def expect_3(x: Literal[3]) -> None: pass
 expect_3(foo)
 [file mod1.py]
-from typing_extensions import Final
+from typing import Final
 from mod2 import bar
 foo: Final = bar
 [file mod2.py]
 from mod3 import qux as bar
 [file mod3.py]
-from typing_extensions import Final
+from typing import Final
 qux: Final = 3
 [file mod3.py.2]
-from typing_extensions import Final
+from typing import Final
 qux: Final = 4
 [file mod3.py.3]
-from typing_extensions import Final
+from typing import Final
 qux: Final[int] = 4
 [builtins fixtures/tuple.pyi]
 [out]
@@ -8885,13 +8911,13 @@ reveal_type(foo)
 from mod2 import bar
 foo = bar()
 [file mod2.py]
-from typing_extensions import Literal
+from typing import Literal
 def bar() -> Literal["foo"]: pass
 [file mod2.py.2]
-from typing_extensions import Literal
+from typing import Literal
 def bar() -> Literal[u"foo"]: pass
 [file mod2.py.3]
-from typing_extensions import Literal
+from typing import Literal
 def bar() -> Literal[b"foo"]: pass
 [builtins fixtures/tuple.pyi]
 [out]
@@ -9114,27 +9140,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]
 ==
@@ -9569,7 +9595,7 @@ reveal_type(Foo().x)
 [builtins fixtures/isinstance.pyi]
 [out]
 ==
-b.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+b.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 
 [case testIsInstanceAdHocIntersectionFineGrainedIncrementalIsInstanceChange]
 import c
@@ -9603,9 +9629,9 @@ from b import y
 reveal_type(y)
 [builtins fixtures/isinstance.pyi]
 [out]
-c.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 ==
-c.py:2: note: Revealed type is "a.<subclass of "A" and "C">"
+c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.C">"
 
 [case testIsInstanceAdHocIntersectionFineGrainedIncrementalUnderlyingObjChang]
 import c
@@ -9631,9 +9657,9 @@ from b import y
 reveal_type(y)
 [builtins fixtures/isinstance.pyi]
 [out]
-c.py:2: note: Revealed type is "b.<subclass of "A" and "B">"
+c.py:2: note: Revealed type is "b.<subclass of "a.A" and "a.B">"
 ==
-c.py:2: note: Revealed type is "b.<subclass of "A" and "C">"
+c.py:2: note: Revealed type is "b.<subclass of "a.A" and "a.C">"
 
 [case testIsInstanceAdHocIntersectionFineGrainedIncrementalIntersectionToUnreachable]
 import c
@@ -9664,9 +9690,10 @@ from b import z
 reveal_type(z)
 [builtins fixtures/isinstance.pyi]
 [out]
-c.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 ==
-c.py:2: note: Revealed type is "a.A"
+c.py:2: note: Revealed type is "Any"
+b.py:2: error: Cannot determine type of "y"
 
 [case testIsInstanceAdHocIntersectionFineGrainedIncrementalUnreachaableToIntersection]
 import c
@@ -9697,9 +9724,10 @@ from b import z
 reveal_type(z)
 [builtins fixtures/isinstance.pyi]
 [out]
-c.py:2: note: Revealed type is "a.A"
+b.py:2: error: Cannot determine type of "y"
+c.py:2: note: Revealed type is "Any"
 ==
-c.py:2: note: Revealed type is "a.<subclass of "A" and "B">"
+c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 
 [case testStubFixupIssues]
 [file a.py]
@@ -9790,7 +9818,6 @@ class ExampleClass(Generic[T]):
 [out]
 ==
 [case testStrictNoneAttribute]
-# flags: --strict-optional
 from typing import Generic, TypeVar
 
 T = TypeVar('T', int, str)
@@ -9804,7 +9831,6 @@ class ExampleClass(Generic[T]):
 ==
 
 [case testDataclassCheckTypeVarBoundsInReprocess]
-# flags: --python-version 3.7
 from dataclasses import dataclass
 from typing import ClassVar, Protocol, Dict, TypeVar, Generic
 from m import x
@@ -9872,7 +9898,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
@@ -9913,17 +9939,139 @@ x = 0  # Arbitrary change to trigger reprocessing
 ==
 a.py:3: note: Revealed type is "Tuple[Literal[1]?, Literal['x']?]"
 
+[case testVariadicClassFineUpdateRegularToVariadic]
+from typing import Any
+from lib import C
+
+x: C[int, str]
+
+[file lib.py]
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+S = TypeVar("S")
+class C(Generic[T, S]): ...
+
+[file lib.py.2]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]): ...
+[builtins fixtures/tuple.pyi]
+[out]
+==
+
+[case testVariadicClassFineUpdateVariadicToRegular]
+from typing import Any
+from lib import C
+
+x: C[int, str, int]
+
+[file lib.py]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]): ...
+[file lib.py.2]
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+S = TypeVar("S")
+class C(Generic[T, S]): ...
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:4: error: "C" expects 2 type arguments, but 3 given
+
+-- Order of error messages is different, so we repeat the test twice.
+[case testVariadicClassFineUpdateValidToInvalidCached-only_when_cache]
+from typing import Any
+from lib import C
+
+x: C[int, str]
+
+[file lib.py]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]): ...
+
+[file lib.py.2]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Ts]): ...
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:4: error: "C" expects no type arguments, but 2 given
+lib.py:5: error: Free type variable expected in Generic[...]
+
+[case testVariadicClassFineUpdateValidToInvalid-only_when_nocache]
+from typing import Any
+from lib import C
+
+x: C[int, str]
+
+[file lib.py]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]): ...
+
+[file lib.py.2]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Ts]): ...
+[builtins fixtures/tuple.pyi]
+[out]
+==
+lib.py:5: error: Free type variable expected in Generic[...]
+main:4: error: "C" expects no type arguments, but 2 given
+
+[case testVariadicClassFineUpdateInvalidToValid]
+from typing import Any
+from lib import C
+
+x: C[int, str]
+
+[file lib.py]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Ts]): ...
+
+[file lib.py.2]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts")
+class C(Generic[Unpack[Ts]]): ...
+[builtins fixtures/tuple.pyi]
+[out]
+lib.py:5: error: Free type variable expected in Generic[...]
+main:4: error: "C" expects no type arguments, but 2 given
+==
+
 [case testUnpackKwargsUpdateFine]
 import m
 [file shared.py]
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 class Person(TypedDict):
     name: str
     age: int
 
 [file shared.py.2]
-from typing_extensions import TypedDict
+from typing import TypedDict
 
 class Person(TypedDict):
     name: str
@@ -9940,6 +10088,7 @@ from lib import foo
 foo(name='Jennifer', age=38)
 
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 ==
 m.py:2: error: Argument "age" to "foo" has incompatible type "int"; expected "str"
@@ -10043,7 +10192,6 @@ class C(B): ...
 main.py:4: note: Revealed type is "def () -> builtins.str"
 
 [case testAbstractBodyTurnsEmpty]
-# flags: --strict-optional
 from b import Base
 
 class Sub(Base):
@@ -10063,10 +10211,9 @@ class Base:
     def meth(self) -> int: ...
 [out]
 ==
-main:6: error: Call to abstract method "meth" of "Base" with trivial body via super() is unsafe
+main:5: error: Call to abstract method "meth" of "Base" with trivial body via super() is unsafe
 
 [case testAbstractBodyTurnsEmptyProtocol]
-# flags: --strict-optional
 from b import Base
 
 class Sub(Base):
@@ -10083,10 +10230,10 @@ class Base(Protocol):
     def meth(self) -> int: ...
 [out]
 ==
-main:6: error: Call to abstract method "meth" of "Base" with trivial body via super() is unsafe
+main:5: error: Call to abstract method "meth" of "Base" with trivial body via super() is unsafe
 
 [case testPrettyMessageSorting]
-# flags: --pretty
+# flags: --python-version 3.8 --pretty
 import a
 
 [file a.py]
@@ -10101,23 +10248,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
     ^~~~~~~~~~
@@ -10264,7 +10394,7 @@ import n
 import m
 x: m.TD
 [file m.py]
-from typing_extensions import TypedDict
+from typing import TypedDict
 from f import A
 
 class TD(TypedDict):
@@ -10277,6 +10407,7 @@ A = int
 [file f.py.2]
 A = str
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 m.py:5: error: Invalid statement in TypedDict definition; expected "field_name: field_type"
 ==
@@ -10291,6 +10422,7 @@ from b import C, D
 A = C | D
 a: A
 reveal_type(a)
+[builtins fixtures/type.pyi]
 
 [file b.py]
 C = int
@@ -10340,3 +10472,748 @@ 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
+
+[case testModuleLevelGetAttrInStub]
+import stub
+import a
+import b
+
+[file stub/__init__.pyi]
+s: str
+def __getattr__(self): pass
+
+[file a.py]
+
+[file a.py.2]
+from stub import x
+from stub.pkg import y
+from stub.pkg.sub import z
+
+[file b.py]
+
+[file b.py.3]
+from stub import s
+reveal_type(s)
+
+[out]
+==
+==
+b.py:2: note: Revealed type is "builtins.str"
+
+[case testRenameSubModule]
+import a
+
+[file a.py]
+import pkg.sub
+
+[file pkg/__init__.py]
+[file pkg/sub/__init__.py]
+from pkg.sub import mod
+[file pkg/sub/mod.py]
+
+[file pkg/sub/__init__.py.2]
+from pkg.sub import modb
+[delete pkg/sub/mod.py.2]
+[file pkg/sub/modb.py.2]
+
+[out]
+==
+
+[case testFineGrainedFunctoolsPartial]
+import m
+
+[file m.py]
+from typing import Callable
+from partial import p1
+
+reveal_type(p1)
+p1("a")
+p1("a", 3)
+p1("a", c=3)
+p1(1, 3)
+p1(1, "a", 3)
+p1(a=1, b="a", c=3)
+[builtins fixtures/dict.pyi]
+
+[file partial.py]
+from typing import Callable
+import functools
+
+def foo(a: int, b: str, c: int = 5) -> int: ...
+p1 = foo
+
+[file partial.py.2]
+from typing import Callable
+import functools
+
+def foo(a: int, b: str, c: int = 5) -> int: ...
+p1 = functools.partial(foo, 1)
+
+[out]
+m.py:4: note: Revealed type is "def (a: builtins.int, b: builtins.str, c: builtins.int =) -> builtins.int"
+m.py:5: error: Too few arguments
+m.py:5: error: Argument 1 has incompatible type "str"; expected "int"
+m.py:6: error: Argument 1 has incompatible type "str"; expected "int"
+m.py:6: error: Argument 2 has incompatible type "int"; expected "str"
+m.py:7: error: Too few arguments
+m.py:7: error: Argument 1 has incompatible type "str"; expected "int"
+m.py:8: error: Argument 2 has incompatible type "int"; expected "str"
+==
+m.py:4: note: Revealed type is "functools.partial[builtins.int]"
+m.py:8: error: Argument 1 to "foo" has incompatible type "int"; expected "str"
+m.py:9: error: Too many arguments for "foo"
+m.py:9: error: Argument 1 to "foo" has incompatible type "int"; expected "str"
+m.py:9: error: Argument 2 to "foo" has incompatible type "str"; expected "int"
+m.py:10: error: Unexpected keyword argument "a" for "foo"
+partial.py:4: note: "foo" defined here
+
+[case testReplaceFunctionWithDecoratedFunctionIndirect]
+from b import f
+x: int = f()
+import b
+y: int = b.f()
+
+[file b.py]
+from a import f
+
+[file a.py]
+def f() -> int: ...
+
+[file a.py.2]
+from typing import Callable
+def d(t: Callable[[], str]) -> Callable[[], str]: ...
+
+@d
+def f() -> str: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+main:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[case testReplaceFunctionWithDecoratedFunctionIndirect2]
+from c import f
+x: int = f()
+import c
+y: int = c.f()
+
+[file c.py]
+from b import f
+
+[file b.py]
+from a import f
+
+[file a.py]
+def f() -> int: ...
+
+[file a.py.2]
+from typing import Callable
+def d(t: Callable[[], str]) -> Callable[[], str]: ...
+
+@d
+def f() -> str: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+main:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[case testReplaceFunctionWithClassIndirect]
+from b import f
+x: int = f()
+import b
+y: int = b.f()
+
+[file b.py]
+from a import f
+
+[file a.py]
+def f() -> int: ...
+
+[file a.py.2]
+class f: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: Incompatible types in assignment (expression has type "f", variable has type "int")
+main:4: error: Incompatible types in assignment (expression has type "f", variable has type "int")
+
+[case testReplaceFunctionWithClassIndirect2]
+from c import f
+x: int = f()
+import c
+y: int = c.f()
+
+[file c.py]
+from b import f
+
+[file b.py]
+from a import f
+
+[file a.py]
+def f() -> int: ...
+
+[file a.py.2]
+class f: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: Incompatible types in assignment (expression has type "f", variable has type "int")
+main:4: error: Incompatible types in assignment (expression has type "f", variable has type "int")
+
+
+[case testDeprecatedAddKeepChangeAndRemoveFunctionDeprecation]
+# flags: --enable-error-code=deprecated
+
+from a import f
+f()
+import a
+a.f()
+
+[file a.py]
+def f() -> None: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+[file a.py.3]
+from typing_extensions import deprecated
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+[file a.py.4]
+from typing_extensions import deprecated
+@deprecated("use f3 instead")
+def f() -> None: ...
+
+[file a.py.5]
+def f() -> None: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:3: error: function a.f is deprecated: use f2 instead
+main:6: error: function a.f is deprecated: use f2 instead
+==
+main:3: error: function a.f is deprecated: use f2 instead
+main:6: error: function a.f is deprecated: use f2 instead
+==
+main:3: error: function a.f is deprecated: use f3 instead
+main:6: error: function a.f is deprecated: use f3 instead
+==
+
+
+[case testDeprecatedRemoveFunctionDeprecation]
+# flags: --enable-error-code=deprecated
+from a import f
+f()
+import a
+a.f()
+
+[file a.py]
+from typing_extensions import deprecated
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+[file a.py.2]
+def f() -> None: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+main:2: error: function a.f is deprecated: use f2 instead
+main:5: error: function a.f is deprecated: use f2 instead
+==
+
+[case testDeprecatedKeepFunctionDeprecation]
+# flags: --enable-error-code=deprecated
+from a import f
+f()
+import a
+a.f()
+
+[file a.py]
+from typing_extensions import deprecated
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+@deprecated("use f2 instead")
+def f() -> None: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+main:2: error: function a.f is deprecated: use f2 instead
+main:5: error: function a.f is deprecated: use f2 instead
+==
+main:2: error: function a.f is deprecated: use f2 instead
+main:5: error: function a.f is deprecated: use f2 instead
+
+
+[case testDeprecatedAddFunctionDeprecationIndirectImport]
+# flags: --enable-error-code=deprecated
+from b import f
+f()
+import b
+b.f()
+
+[file b.py]
+from a import f
+
+[file a.py]
+def f() -> int: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+@deprecated("use f2 instead")
+def f() -> int: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+b.py:1: error: function a.f is deprecated: use f2 instead
+main:2: error: function a.f is deprecated: use f2 instead
+main:5: error: function a.f is deprecated: use f2 instead
+
+
+[case testDeprecatedChangeFunctionDeprecationIndirectImport]
+# flags: --enable-error-code=deprecated
+from b import f
+f()
+import b
+b.f()
+
+[file b.py]
+from a import f
+
+[file a.py]
+from typing_extensions import deprecated
+@deprecated("use f1 instead")
+def f() -> int: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+@deprecated("use f2 instead")
+def f() -> int: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+b.py:1: error: function a.f is deprecated: use f1 instead
+main:2: error: function a.f is deprecated: use f1 instead
+main:5: error: function a.f is deprecated: use f1 instead
+==
+b.py:1: error: function a.f is deprecated: use f2 instead
+main:2: error: function a.f is deprecated: use f2 instead
+main:5: error: function a.f is deprecated: use f2 instead
+
+[case testDeprecatedRemoveFunctionDeprecationIndirectImport]
+# flags: --enable-error-code=deprecated
+from b import f
+f()
+import b
+b.f()
+
+[file b.py]
+from a import f
+
+[file a.py]
+from typing_extensions import deprecated
+@deprecated("use f1 instead")
+def f() -> int: ...
+
+[file a.py.2]
+def f() -> int: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+b.py:1: error: function a.f is deprecated: use f1 instead
+main:2: error: function a.f is deprecated: use f1 instead
+main:5: error: function a.f is deprecated: use f1 instead
+==
+
+
+[case testDeprecatedFunctionAlreadyDecorated1-only_when_cache]
+# flags: --enable-error-code=deprecated
+from b import f
+x: str = f()
+import b
+y: str = b.f()
+
+[file b.py]
+from a import f
+
+[file a.py]
+from typing import Callable
+
+def d(t: Callable[[], str]) -> Callable[[], str]: ...
+
+@d
+def f() -> str: ...
+
+[file a.py.2]
+from typing import Callable
+from typing_extensions import deprecated
+
+def d(t: Callable[[], str]) -> Callable[[], str]: ...
+
+@deprecated("deprecated decorated function")
+@d
+def f() -> str: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+b.py:1: error: function a.f is deprecated: deprecated decorated function
+main:2: error: function a.f is deprecated: deprecated decorated function
+main:5: error: function a.f is deprecated: deprecated decorated function
+
+
+[case testDeprecatedFunctionAlreadyDecorated2-only_when_nocache]
+# flags: --enable-error-code=deprecated
+from b import f
+x: str = f()
+import b
+y: str = b.f()
+
+[file b.py]
+from a import f
+
+[file a.py]
+from typing import Callable
+
+def d(t: Callable[[], str]) -> Callable[[], str]: ...
+
+@d
+def f() -> str: ...
+
+[file a.py.2]
+from typing import Callable
+from typing_extensions import deprecated
+
+def d(t: Callable[[], str]) -> Callable[[], str]: ...
+
+@deprecated("deprecated decorated function")
+@d
+def f() -> str: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: function a.f is deprecated: deprecated decorated function
+main:5: error: function a.f is deprecated: deprecated decorated function
+b.py:1: error: function a.f is deprecated: deprecated decorated function
+
+
+[case testDeprecatedAddClassDeprecationIndirectImport1-only_when_cache]
+# flags: --enable-error-code=deprecated
+from b import C
+x: C
+C()
+import b
+y: b.D
+b.D()
+
+[file b.py]
+from a import C
+from a import D
+
+[file a.py]
+class C: ...
+class D: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C: ...
+
+@deprecated("use D2 instead")
+class D: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+b.py:1: error: class a.C is deprecated: use C2 instead
+b.py:2: error: class a.D is deprecated: use D2 instead
+main:2: error: class a.C is deprecated: use C2 instead
+main:6: error: class a.D is deprecated: use D2 instead
+main:7: error: class a.D is deprecated: use D2 instead
+
+
+[case testDeprecatedAddClassDeprecationIndirectImport2-only_when_nocache]
+# flags: --enable-error-code=deprecated
+from b import C
+x: C
+C()
+import b
+y: b.D
+b.D()
+
+[file b.py]
+from a import C
+from a import D
+
+[file a.py]
+class C: ...
+class D: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C: ...
+
+@deprecated("use D2 instead")
+class D: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: class a.C is deprecated: use C2 instead
+main:6: error: class a.D is deprecated: use D2 instead
+main:7: error: class a.D is deprecated: use D2 instead
+b.py:1: error: class a.C is deprecated: use C2 instead
+b.py:2: error: class a.D is deprecated: use D2 instead
+
+
+[case testDeprecatedChangeClassDeprecationIndirectImport]
+# flags: --enable-error-code=deprecated
+from b import C
+x: C
+C()
+import b
+y: b.D
+b.D()
+
+[file b.py]
+from a import C
+from a import D
+
+[file a.py]
+from typing_extensions import deprecated
+
+@deprecated("use C1 instead")
+class C: ...
+@deprecated("use D1 instead")
+class D: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C: ...
+
+@deprecated("use D2 instead")
+class D: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+b.py:1: error: class a.C is deprecated: use C1 instead
+b.py:2: error: class a.D is deprecated: use D1 instead
+main:2: error: class a.C is deprecated: use C1 instead
+main:6: error: class a.D is deprecated: use D1 instead
+main:7: error: class a.D is deprecated: use D1 instead
+==
+b.py:1: error: class a.C is deprecated: use C2 instead
+b.py:2: error: class a.D is deprecated: use D2 instead
+main:2: error: class a.C is deprecated: use C2 instead
+main:6: error: class a.D is deprecated: use D2 instead
+main:7: error: class a.D is deprecated: use D2 instead
+
+
+[case testDeprecatedRemoveClassDeprecationIndirectImport]
+# flags: --enable-error-code=deprecated
+from b import C
+x: C
+C()
+import b
+y: b.D
+b.D()
+
+[file b.py]
+from a import C
+from a import D
+
+[file a.py]
+from typing_extensions import deprecated
+
+@deprecated("use C1 instead")
+class C: ...
+@deprecated("use D1 instead")
+class D: ...
+
+[file a.py.2]
+class C: ...
+class D: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+b.py:1: error: class a.C is deprecated: use C1 instead
+b.py:2: error: class a.D is deprecated: use D1 instead
+main:2: error: class a.C is deprecated: use C1 instead
+main:6: error: class a.D is deprecated: use D1 instead
+main:7: error: class a.D is deprecated: use D1 instead
+==
+
+
+[case testDeprecatedAddClassDeprecationIndirectImportAlreadyDecorated1-only_when_cache]
+# flags: --enable-error-code=deprecated
+from b import C
+x: C
+C()
+import b
+y: b.D
+b.D()
+
+[file b.py]
+from a import C
+from a import D
+
+[file a.py]
+from typing import TypeVar
+
+T = TypeVar("T")
+def dec(x: T) -> T: ...
+
+@dec
+class C: ...
+@dec
+class D: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C: ...
+
+@deprecated("use D2 instead")
+class D: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+b.py:1: error: class a.C is deprecated: use C2 instead
+b.py:2: error: class a.D is deprecated: use D2 instead
+main:2: error: class a.C is deprecated: use C2 instead
+main:6: error: class a.D is deprecated: use D2 instead
+main:7: error: class a.D is deprecated: use D2 instead
+
+
+[case testDeprecatedAddClassDeprecationIndirectImportAlreadyDecorated2-only_when_nocache]
+# flags: --enable-error-code=deprecated
+from b import C
+x: C
+C()
+import b
+y: b.D
+b.D()
+
+[file b.py]
+from a import C
+from a import D
+
+[file a.py]
+from typing import TypeVar
+
+T = TypeVar("T")
+def dec(x: T) -> T: ...
+
+@dec
+class C: ...
+@dec
+class D: ...
+
+[file a.py.2]
+from typing_extensions import deprecated
+
+@deprecated("use C2 instead")
+class C: ...
+
+@deprecated("use D2 instead")
+class D: ...
+
+[builtins fixtures/tuple.pyi]
+[out]
+==
+main:2: error: class a.C is deprecated: use C2 instead
+main:6: error: class a.D is deprecated: use D2 instead
+main:7: error: class a.D is deprecated: use D2 instead
+b.py:1: error: class a.C is deprecated: use C2 instead
+b.py:2: error: class a.D is deprecated: use D2 instead
+
+[case testPropertySetterTypeFineGrained]
+from a import A
+a = A()
+a.f = ''
+[file a.py]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: str) -> None:
+        pass
+[file a.py.2]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: int) -> None:
+        pass
+[builtins fixtures/property.pyi]
+[out]
+==
+main:3: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[case testPropertyDeleteSetterFineGrained]
+from a import A
+a = A()
+a.f = 1
+[file a.py]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: int) -> None:
+        pass
+[file a.py.2]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.deleter
+    def f(self) -> None:
+        pass
+[builtins fixtures/property.pyi]
+[out]
+==
+main:3: error: Property "f" defined in "A" is read-only
diff --git a/test-data/unit/fixtures/dataclasses.pyi b/test-data/unit/fixtures/dataclasses.pyi
index 710b8659d265..29f87ae97e62 100644
--- a/test-data/unit/fixtures/dataclasses.pyi
+++ b/test-data/unit/fixtures/dataclasses.pyi
@@ -3,6 +3,7 @@ from typing import (
     Generic, Iterator, Iterable, Mapping, Optional, Sequence, Tuple,
     TypeVar, Union, overload,
 )
+from typing_extensions import override
 
 _T = TypeVar('_T')
 _U = TypeVar('_U')
@@ -29,8 +30,10 @@ class dict(Mapping[KT, VT]):
     def __init__(self, **kwargs: VT) -> None: pass
     @overload
     def __init__(self, arg: Iterable[Tuple[KT, VT]], **kwargs: VT) -> None: pass
+    @override
     def __getitem__(self, key: KT) -> VT: pass
     def __setitem__(self, k: KT, v: VT) -> None: pass
+    @override
     def __iter__(self) -> Iterator[KT]: pass
     def __contains__(self, item: object) -> int: pass
     def update(self, a: Mapping[KT, VT]) -> None: pass
@@ -42,9 +45,12 @@ class dict(Mapping[KT, VT]):
 
 class list(Generic[_T], Sequence[_T]):
     def __contains__(self, item: object) -> int: pass
+    @override
     def __getitem__(self, key: int) -> _T: pass
+    @override
     def __iter__(self) -> Iterator[_T]: pass
 
 class function: pass
 class classmethod: pass
+class staticmethod: pass
 property = object()
diff --git a/test-data/unit/fixtures/dict-full.pyi b/test-data/unit/fixtures/dict-full.pyi
new file mode 100644
index 000000000000..f20369ce9332
--- /dev/null
+++ b/test-data/unit/fixtures/dict-full.pyi
@@ -0,0 +1,83 @@
+# Builtins stub used in dictionary-related test cases (more complete).
+
+from _typeshed import SupportsKeysAndGetItem
+import _typeshed
+from typing import (
+    TypeVar, Generic, Iterable, Iterator, Mapping, Tuple, overload, Optional, Union, Sequence,
+    Self,
+)
+
+T = TypeVar('T')
+T2 = TypeVar('T2')
+KT = TypeVar('KT')
+VT = TypeVar('VT')
+
+class object:
+    def __init__(self) -> None: pass
+    def __init_subclass__(cls) -> None: pass
+    def __eq__(self, other: object) -> bool: pass
+
+class type:
+    __annotations__: Mapping[str, object]
+
+class dict(Mapping[KT, VT]):
+    @overload
+    def __init__(self, **kwargs: VT) -> None: pass
+    @overload
+    def __init__(self, arg: Iterable[Tuple[KT, VT]], **kwargs: VT) -> None: pass
+    def __getitem__(self, key: KT) -> VT: pass
+    def __setitem__(self, k: KT, v: VT) -> None: pass
+    def __iter__(self) -> Iterator[KT]: pass
+    def __contains__(self, item: object) -> int: pass
+    def update(self, a: SupportsKeysAndGetItem[KT, VT]) -> None: pass
+    @overload
+    def get(self, k: KT) -> Optional[VT]: pass
+    @overload
+    def get(self, k: KT, default: Union[VT, T]) -> Union[VT, T]: pass
+    def __len__(self) -> int: ...
+
+    # This was actually added in 3.9:
+    @overload
+    def __or__(self, __value: dict[KT, VT]) -> dict[KT, VT]: ...
+    @overload
+    def __or__(self, __value: dict[T, T2]) -> dict[Union[KT, T], Union[VT, T2]]: ...
+    @overload
+    def __ror__(self, __value: dict[KT, VT]) -> dict[KT, VT]: ...
+    @overload
+    def __ror__(self, __value: dict[T, T2]) -> dict[Union[KT, T], Union[VT, T2]]: ...
+    # dict.__ior__ should be kept roughly in line with MutableMapping.update()
+    @overload  # type: ignore[misc]
+    def __ior__(self, __value: _typeshed.SupportsKeysAndGetItem[KT, VT]) -> Self: ...
+    @overload
+    def __ior__(self, __value: Iterable[Tuple[KT, VT]]) -> Self: ...
+
+class int: # for convenience
+    def __add__(self, x: Union[int, complex]) -> int: pass
+    def __radd__(self, x: int) -> int: pass
+    def __sub__(self, x: Union[int, complex]) -> int: pass
+    def __neg__(self) -> int: pass
+    real: int
+    imag: int
+
+class str: pass # for keyword argument key type
+class bytes: pass
+
+class list(Sequence[T]): # needed by some test cases
+    def __getitem__(self, x: int) -> T: pass
+    def __iter__(self) -> Iterator[T]: pass
+    def __mul__(self, x: int) -> list[T]: pass
+    def __contains__(self, item: object) -> bool: pass
+    def append(self, item: T) -> None: pass
+
+class tuple(Generic[T]): pass
+class function: pass
+class float: pass
+class complex: pass
+class bool(int): pass
+
+class ellipsis:
+    __class__: object
+def isinstance(x: object, t: Union[type, Tuple[type, ...]]) -> bool: pass
+class BaseException: pass
+
+def iter(__iterable: Iterable[T]) -> Iterator[T]: pass
diff --git a/test-data/unit/fixtures/dict.pyi b/test-data/unit/fixtures/dict.pyi
index 19d175ff79ab..ed2287511161 100644
--- a/test-data/unit/fixtures/dict.pyi
+++ b/test-data/unit/fixtures/dict.pyi
@@ -1,22 +1,25 @@
-# Builtins stub used in dictionary-related test cases.
+# Builtins stub used in dictionary-related test cases (stripped down).
+#
+# NOTE: Use dict-full.pyi if you need more builtins instead of adding here,
+#       if feasible.
 
 from _typeshed import SupportsKeysAndGetItem
 import _typeshed
 from typing import (
-    TypeVar, Generic, Iterable, Iterator, Mapping, Tuple, overload, Optional, Union, Sequence
+    TypeVar, Generic, Iterable, Iterator, Mapping, Tuple, overload, Optional, Union, Sequence,
+    Self,
 )
 
 T = TypeVar('T')
+T2 = TypeVar('T2')
 KT = TypeVar('KT')
 VT = TypeVar('VT')
 
 class object:
     def __init__(self) -> None: pass
-    def __init_subclass__(cls) -> None: pass
     def __eq__(self, other: object) -> bool: pass
 
-class type:
-    __annotations__: Mapping[str, object]
+class type: pass
 
 class dict(Mapping[KT, VT]):
     @overload
@@ -38,9 +41,6 @@ class int: # for convenience
     def __add__(self, x: Union[int, complex]) -> int: pass
     def __radd__(self, x: int) -> int: pass
     def __sub__(self, x: Union[int, complex]) -> int: pass
-    def __neg__(self) -> int: pass
-    real: int
-    imag: int
 
 class str: pass # for keyword argument key type
 class bytes: pass
@@ -57,10 +57,8 @@ class function: pass
 class float: pass
 class complex: pass
 class bool(int): pass
-
-class ellipsis:
-    __class__: object
-def isinstance(x: object, t: Union[type, Tuple[type, ...]]) -> bool: pass
+class ellipsis: pass
 class BaseException: pass
 
+def isinstance(x: object, t: Union[type, Tuple[type, ...]]) -> bool: pass
 def iter(__iterable: Iterable[T]) -> Iterator[T]: pass
diff --git a/test-data/unit/fixtures/enum.pyi b/test-data/unit/fixtures/enum.pyi
new file mode 100644
index 000000000000..22e7193da041
--- /dev/null
+++ b/test-data/unit/fixtures/enum.pyi
@@ -0,0 +1,25 @@
+# Minimal set of builtins required to work with Enums
+from typing import TypeVar, Generic, Iterator, Sequence, overload, Iterable
+
+T = TypeVar('T')
+
+class object:
+    def __init__(self): pass
+
+class type: pass
+class tuple(Generic[T]):
+    def __getitem__(self, x: int) -> T: pass
+
+class int: pass
+class str:
+    def __len__(self) -> int: pass
+    def __iter__(self) -> Iterator[str]: pass
+
+class dict: pass
+class ellipsis: pass
+
+class list(Sequence[T]):
+    @overload
+    def __init__(self) -> None: pass
+    @overload
+    def __init__(self, x: Iterable[T]) -> None: pass
diff --git a/test-data/unit/fixtures/float.pyi b/test-data/unit/fixtures/float.pyi
index 5db4525849c0..9e2d20f04edf 100644
--- a/test-data/unit/fixtures/float.pyi
+++ b/test-data/unit/fixtures/float.pyi
@@ -1,8 +1,6 @@
-from typing import Generic, TypeVar
+from typing import Generic, TypeVar, Any
 T = TypeVar('T')
 
-Any = 0
-
 class object:
     def __init__(self) -> None: pass
 
diff --git a/test-data/unit/fixtures/floatdict.pyi b/test-data/unit/fixtures/floatdict.pyi
index 7baa7ca9206f..10586218b551 100644
--- a/test-data/unit/fixtures/floatdict.pyi
+++ b/test-data/unit/fixtures/floatdict.pyi
@@ -1,11 +1,9 @@
-from typing import TypeVar, Generic, Iterable, Iterator, Mapping, Tuple, overload, Optional, Union
+from typing import TypeVar, Generic, Iterable, Iterator, Mapping, Tuple, overload, Optional, Union, Any
 
 T = TypeVar('T')
 KT = TypeVar('KT')
 VT = TypeVar('VT')
 
-Any = 0
-
 class object:
     def __init__(self) -> None: pass
 
diff --git a/test-data/unit/fixtures/for.pyi b/test-data/unit/fixtures/for.pyi
index 694f83e940b2..80c8242c2a5e 100644
--- a/test-data/unit/fixtures/for.pyi
+++ b/test-data/unit/fixtures/for.pyi
@@ -12,9 +12,12 @@ class type: pass
 class tuple(Generic[t]):
     def __iter__(self) -> Iterator[t]: pass
 class function: pass
+class ellipsis: pass
 class bool: pass
 class int: pass # for convenience
-class str: pass # for convenience
+class float: pass  # for convenience
+class str:  # for convenience
+    def upper(self) -> str: ...
 
 class list(Iterable[t], Generic[t]):
     def __iter__(self) -> Iterator[t]: pass
diff --git a/test-data/unit/fixtures/isinstance.pyi b/test-data/unit/fixtures/isinstance.pyi
index c1125c24b941..12cef2035c2b 100644
--- a/test-data/unit/fixtures/isinstance.pyi
+++ b/test-data/unit/fixtures/isinstance.pyi
@@ -7,6 +7,7 @@ class object:
 
 class type:
     def __init__(self, x) -> None: pass
+    def __or__(self, other: type) -> type: pass
 
 class tuple(Generic[T]): pass
 
diff --git a/test-data/unit/fixtures/isinstance_python3_10.pyi b/test-data/unit/fixtures/isinstance_python3_10.pyi
index 7c919a216bfb..0918d10ab1ef 100644
--- a/test-data/unit/fixtures/isinstance_python3_10.pyi
+++ b/test-data/unit/fixtures/isinstance_python3_10.pyi
@@ -7,15 +7,15 @@ T = TypeVar('T')
 class object:
     def __init__(self) -> None: pass
 
-class type(Generic[T]):
+class type:
     def __init__(self, x) -> None: pass
-    def __or__(self, x) -> types.Union: pass
+    def __or__(self, x) -> types.UnionType: pass
 
 class tuple(Generic[T]): pass
 
 class function: pass
 
-def isinstance(x: object, t: Union[Type[object], Tuple[Type[object], ...], types.Union]) -> bool: pass
+def isinstance(x: object, t: Union[Type[object], Tuple[Type[object], ...], types.UnionType]) -> bool: pass
 def issubclass(x: object, t: Union[Type[object], Tuple[Type[object], ...]]) -> bool: pass
 
 class int:
diff --git a/test-data/unit/fixtures/len.pyi b/test-data/unit/fixtures/len.pyi
new file mode 100644
index 000000000000..ee39d952701f
--- /dev/null
+++ b/test-data/unit/fixtures/len.pyi
@@ -0,0 +1,39 @@
+from typing import Tuple, TypeVar, Generic, Union, Type, Sequence, Mapping
+from typing_extensions import Protocol
+
+T = TypeVar("T")
+V = TypeVar("V")
+
+class object:
+    def __init__(self) -> None: pass
+
+class type:
+    def __init__(self, x) -> None: pass
+
+class tuple(Sequence[T]):
+    def __len__(self) -> int: pass
+
+class list(Sequence[T]): pass
+class dict(Mapping[T, V]): pass
+
+class function: pass
+
+class Sized(Protocol):
+    def __len__(self) -> int: pass
+
+def len(__obj: Sized) -> int: ...
+def isinstance(x: object, t: Union[Type[object], Tuple[Type[object], ...]]) -> bool: pass
+
+class int:
+    def __add__(self, other: int) -> int: pass
+    def __eq__(self, other: int) -> bool: pass
+    def __ne__(self, other: int) -> bool: pass
+    def __lt__(self, n: int) -> bool: pass
+    def __gt__(self, n: int) -> bool: pass
+    def __le__(self, n: int) -> bool: pass
+    def __ge__(self, n: int) -> bool: pass
+    def __neg__(self) -> int: pass
+class float: pass
+class bool(int): pass
+class str(Sequence[str]): pass
+class ellipsis: pass
diff --git a/test-data/unit/fixtures/list.pyi b/test-data/unit/fixtures/list.pyi
index 90fbabe8bc92..3dcdf18b2faa 100644
--- a/test-data/unit/fixtures/list.pyi
+++ b/test-data/unit/fixtures/list.pyi
@@ -6,6 +6,7 @@ T = TypeVar('T')
 
 class object:
     def __init__(self) -> None: pass
+    def __eq__(self, other: object) -> bool: pass
 
 class type: pass
 class ellipsis: pass
diff --git a/test-data/unit/fixtures/module.pyi b/test-data/unit/fixtures/module.pyi
index 47408befd5ce..92f78a42f92f 100644
--- a/test-data/unit/fixtures/module.pyi
+++ b/test-data/unit/fixtures/module.pyi
@@ -4,13 +4,14 @@ from types import ModuleType
 T = TypeVar('T')
 S = TypeVar('S')
 
-class list(Generic[T], Sequence[T]): pass
+class list(Generic[T], Sequence[T]): pass  # type: ignore
 
 class object:
     def __init__(self) -> None: pass
 class type: pass
 class function: pass
 class int: pass
+class float: pass
 class str: pass
 class bool: pass
 class tuple(Generic[T]): pass
diff --git a/test-data/unit/fixtures/notimplemented.pyi b/test-data/unit/fixtures/notimplemented.pyi
index 2ca376ea0760..92edf84a7fd1 100644
--- a/test-data/unit/fixtures/notimplemented.pyi
+++ b/test-data/unit/fixtures/notimplemented.pyi
@@ -1,6 +1,5 @@
 # builtins stub used in NotImplemented related cases.
-from typing import Any, cast
-
+from typing import Any
 
 class object:
     def __init__(self) -> None: pass
@@ -10,5 +9,10 @@ class function: pass
 class bool: pass
 class int: pass
 class str: pass
-NotImplemented = cast(Any, None)
 class dict: pass
+
+class _NotImplementedType(Any):
+    __call__: NotImplemented  # type: ignore
+NotImplemented: _NotImplementedType
+
+class BaseException: pass
diff --git a/test-data/unit/fixtures/ops.pyi b/test-data/unit/fixtures/ops.pyi
index 9cc4d22eb0a7..df3b163166ad 100644
--- a/test-data/unit/fixtures/ops.pyi
+++ b/test-data/unit/fixtures/ops.pyi
@@ -24,8 +24,6 @@ class tuple(Sequence[Tco]):
 
 class function: pass
 
-class bool: pass
-
 class str:
     def __init__(self, x: 'int') -> None: pass
     def __add__(self, x: 'str') -> 'str': pass
@@ -54,6 +52,8 @@ class int:
     def __gt__(self, x: 'int') -> bool: pass
     def __ge__(self, x: 'int') -> bool: pass
 
+class bool(int): pass
+
 class float:
     def __add__(self, x: 'float') -> 'float': pass
     def __radd__(self, x: 'float') -> 'float': pass
diff --git a/test-data/unit/fixtures/paramspec.pyi b/test-data/unit/fixtures/paramspec.pyi
index 5e4b8564e238..dfb5e126f242 100644
--- a/test-data/unit/fixtures/paramspec.pyi
+++ b/test-data/unit/fixtures/paramspec.pyi
@@ -16,6 +16,7 @@ class object:
 
 class function: ...
 class ellipsis: ...
+class classmethod: ...
 
 class type:
     def __init__(self, *a: object) -> None: ...
@@ -30,7 +31,8 @@ class list(Sequence[T], Generic[T]):
     def __iter__(self) -> Iterator[T]: ...
 
 class int:
-    def __neg__(self) -> 'int': ...
+    def __neg__(self) -> int: ...
+    def __add__(self, other: int) -> int: ...
 
 class bool(int): ...
 class float: ...
diff --git a/test-data/unit/fixtures/plugin_attrs.pyi b/test-data/unit/fixtures/plugin_attrs.pyi
index f62104809e74..7fd641727253 100644
--- a/test-data/unit/fixtures/plugin_attrs.pyi
+++ b/test-data/unit/fixtures/plugin_attrs.pyi
@@ -1,10 +1,11 @@
 # Builtins stub used to support attrs plugin tests.
-from typing import Union, overload
+from typing import Union, overload, Generic, Sequence, TypeVar, Type, Iterable, Iterator
 
 class object:
     def __init__(self) -> None: pass
     def __eq__(self, o: object) -> bool: pass
     def __ne__(self, o: object) -> bool: pass
+    def __hash__(self) -> int: ...
 
 class type: pass
 class bytes: pass
@@ -24,6 +25,15 @@ class complex:
 
 class str: pass
 class ellipsis: pass
-class tuple: pass
 class list: pass
 class dict: pass
+
+T = TypeVar("T")
+Tco = TypeVar('Tco', covariant=True)
+class tuple(Sequence[Tco], Generic[Tco]):
+    def __new__(cls: Type[T], iterable: Iterable[Tco] = ...) -> T: ...
+    def __iter__(self) -> Iterator[Tco]: pass
+    def __contains__(self, item: object) -> bool: pass
+    def __getitem__(self, x: int) -> Tco: pass
+
+property = object()  # Dummy definition
diff --git a/test-data/unit/fixtures/primitives.pyi b/test-data/unit/fixtures/primitives.pyi
index b74252857d6f..2f8623c79b9f 100644
--- a/test-data/unit/fixtures/primitives.pyi
+++ b/test-data/unit/fixtures/primitives.pyi
@@ -12,16 +12,18 @@ class object:
     def __ne__(self, other: object) -> bool: pass
 
 class type:
-    def __init__(self, x) -> None: pass
+    def __init__(self, x: object) -> None: pass
 
 class int:
     # Note: this is a simplification of the actual signature
     def __init__(self, x: object = ..., base: int = ...) -> None: pass
     def __add__(self, i: int) -> int: pass
     def __rmul__(self, x: int) -> int: pass
+    def __bool__(self) -> bool: pass
 class float:
     def __float__(self) -> float: pass
     def __add__(self, x: float) -> float: pass
+    def hex(self) -> str: pass
 class complex:
     def __add__(self, x: complex) -> complex: pass
 class bool(int): pass
@@ -30,7 +32,7 @@ class str(Sequence[str]):
     def __iter__(self) -> Iterator[str]: pass
     def __contains__(self, other: object) -> bool: pass
     def __getitem__(self, item: int) -> str: pass
-    def format(self, *args, **kwargs) -> str: pass
+    def format(self, *args: object, **kwargs: object) -> str: pass
 class bytes(Sequence[int]):
     def __iter__(self) -> Iterator[int]: pass
     def __contains__(self, other: object) -> bool: pass
@@ -45,8 +47,10 @@ class memoryview(Sequence[int]):
     def __iter__(self) -> Iterator[int]: pass
     def __contains__(self, other: object) -> bool: pass
     def __getitem__(self, item: int) -> int: pass
-class tuple(Generic[T]): pass
+class tuple(Generic[T]):
+    def __contains__(self, other: object) -> bool: pass
 class list(Sequence[T]):
+    def append(self, v: T) -> None: pass
     def __iter__(self) -> Iterator[T]: pass
     def __contains__(self, other: object) -> bool: pass
     def __getitem__(self, item: int) -> T: pass
diff --git a/test-data/unit/fixtures/property.pyi b/test-data/unit/fixtures/property.pyi
index 667bdc02d0f5..933868ac9907 100644
--- a/test-data/unit/fixtures/property.pyi
+++ b/test-data/unit/fixtures/property.pyi
@@ -13,7 +13,7 @@ class function: pass
 property = object()  # Dummy definition
 class classmethod: pass
 
-class list: pass
+class list(typing.Generic[_T]): pass
 class dict: pass
 class int: pass
 class float: pass
diff --git a/test-data/unit/fixtures/set.pyi b/test-data/unit/fixtures/set.pyi
index 71d3bd2eee18..f757679a95f4 100644
--- a/test-data/unit/fixtures/set.pyi
+++ b/test-data/unit/fixtures/set.pyi
@@ -13,6 +13,7 @@ class tuple(Generic[T]): pass
 class function: pass
 
 class int: pass
+class float: pass
 class str: pass
 class bool: pass
 class ellipsis: pass
diff --git a/test-data/unit/fixtures/staticmethod.pyi b/test-data/unit/fixtures/staticmethod.pyi
index 8a87121b2a71..a0ca831c7527 100644
--- a/test-data/unit/fixtures/staticmethod.pyi
+++ b/test-data/unit/fixtures/staticmethod.pyi
@@ -19,3 +19,4 @@ class str: pass
 class bytes: pass
 class ellipsis: pass
 class dict: pass
+class tuple: pass
diff --git a/test-data/unit/fixtures/tuple-simple.pyi b/test-data/unit/fixtures/tuple-simple.pyi
index 6c816c1c5b7a..07f9edf63cdd 100644
--- a/test-data/unit/fixtures/tuple-simple.pyi
+++ b/test-data/unit/fixtures/tuple-simple.pyi
@@ -5,7 +5,7 @@
 
 from typing import Iterable, TypeVar, Generic
 
-T = TypeVar('T')
+T = TypeVar('T', covariant=True)
 
 class object:
     def __init__(self): pass
diff --git a/test-data/unit/fixtures/tuple.pyi b/test-data/unit/fixtures/tuple.pyi
index e270f3d79d3e..d01cd0034d26 100644
--- a/test-data/unit/fixtures/tuple.pyi
+++ b/test-data/unit/fixtures/tuple.pyi
@@ -1,28 +1,29 @@
 # Builtins stub used in tuple-related test cases.
 
 import _typeshed
-from typing import Iterable, Iterator, TypeVar, Generic, Sequence, Optional, overload, Tuple, Type
+from typing import Iterable, Iterator, TypeVar, Generic, Sequence, Optional, overload, Tuple, Type, Self
 
-T = TypeVar("T")
-Tco = TypeVar('Tco', covariant=True)
+_T = TypeVar("_T")
+_Tco = TypeVar('_Tco', covariant=True)
 
 class object:
     def __init__(self) -> None: pass
+    def __new__(cls) -> Self: ...
 
 class type:
     def __init__(self, *a: object) -> None: pass
     def __call__(self, *a: object) -> object: pass
-class tuple(Sequence[Tco], Generic[Tco]):
-    def __new__(cls: Type[T], iterable: Iterable[Tco] = ...) -> T: ...
-    def __iter__(self) -> Iterator[Tco]: pass
+class tuple(Sequence[_Tco], Generic[_Tco]):
+    def __new__(cls: Type[_T], iterable: Iterable[_Tco] = ...) -> _T: ...
+    def __iter__(self) -> Iterator[_Tco]: pass
     def __contains__(self, item: object) -> bool: pass
     @overload
-    def __getitem__(self, x: int) -> Tco: pass
+    def __getitem__(self, x: int) -> _Tco: pass
     @overload
-    def __getitem__(self, x: slice) -> Tuple[Tco, ...]: ...
-    def __mul__(self, n: int) -> Tuple[Tco, ...]: pass
-    def __rmul__(self, n: int) -> Tuple[Tco, ...]: pass
-    def __add__(self, x: Tuple[Tco, ...]) -> Tuple[Tco, ...]: pass
+    def __getitem__(self, x: slice) -> Tuple[_Tco, ...]: ...
+    def __mul__(self, n: int) -> Tuple[_Tco, ...]: pass
+    def __rmul__(self, n: int) -> Tuple[_Tco, ...]: pass
+    def __add__(self, x: Tuple[_Tco, ...]) -> Tuple[_Tco, ...]: pass
     def count(self, obj: object) -> int: pass
 class function:
     __name__: str
@@ -32,6 +33,7 @@ class classmethod: pass
 # We need int and slice for indexing tuples.
 class int:
     def __neg__(self) -> 'int': pass
+    def __pos__(self) -> 'int': pass
 class float: pass
 class slice: pass
 class bool(int): pass
@@ -39,18 +41,16 @@ class str: pass # For convenience
 class bytes: pass
 class bytearray: pass
 
-class list(Sequence[T], Generic[T]):
+class list(Sequence[_T], Generic[_T]):
     @overload
-    def __getitem__(self, i: int) -> T: ...
+    def __getitem__(self, i: int) -> _T: ...
     @overload
-    def __getitem__(self, s: slice) -> list[T]: ...
+    def __getitem__(self, s: slice) -> list[_T]: ...
     def __contains__(self, item: object) -> bool: ...
-    def __iter__(self) -> Iterator[T]: ...
+    def __iter__(self) -> Iterator[_T]: ...
 
 def isinstance(x: object, t: type) -> bool: pass
 
-def sum(iterable: Iterable[T], start: Optional[T] = None) -> T: pass
-
 class BaseException: pass
 
 class dict: pass
diff --git a/test-data/unit/fixtures/type.pyi b/test-data/unit/fixtures/type.pyi
index 39357a693638..0d93b2e1fcd6 100644
--- a/test-data/unit/fixtures/type.pyi
+++ b/test-data/unit/fixtures/type.pyi
@@ -1,6 +1,8 @@
 # builtins stub used in type-related test cases.
 
 from typing import Any, Generic, TypeVar, List, Union
+import sys
+import types
 
 T = TypeVar("T")
 S = TypeVar("S")
@@ -11,7 +13,7 @@ class object:
 
 class list(Generic[T]): pass
 
-class type(Generic[T]):
+class type:
     __name__: str
     def __call__(self, *args: Any, **kwargs: Any) -> Any: pass
     def __or__(self, other: Union[type, None]) -> type: pass
@@ -25,3 +27,9 @@ class bool: pass
 class int: pass
 class str: pass
 class ellipsis: pass
+class float: pass
+
+if sys.version_info >= (3, 10):  # type: ignore
+    def isinstance(obj: object, class_or_tuple: type | types.UnionType, /) -> bool: ...
+else:
+    def isinstance(obj: object, class_or_tuple: type, /) -> bool: ...
diff --git a/test-data/unit/fixtures/typing-async.pyi b/test-data/unit/fixtures/typing-async.pyi
index b207dd599c33..03728f822316 100644
--- a/test-data/unit/fixtures/typing-async.pyi
+++ b/test-data/unit/fixtures/typing-async.pyi
@@ -10,7 +10,7 @@ from abc import abstractmethod, ABCMeta
 
 cast = 0
 overload = 0
-Any = 0
+Any = object()
 Union = 0
 Optional = 0
 TypeVar = 0
@@ -24,6 +24,7 @@ ClassVar = 0
 Final = 0
 Literal = 0
 NoReturn = 0
+Self = 0
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
@@ -124,3 +125,5 @@ class AsyncContextManager(Generic[T]):
     def __aenter__(self) -> Awaitable[T]: pass
     # Use Any because not all the precise types are in the fixtures.
     def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Awaitable[Any]: pass
+
+class _SpecialForm: pass
diff --git a/test-data/unit/fixtures/typing-full.pyi b/test-data/unit/fixtures/typing-full.pyi
index 417ae6baf491..8e0116aab1c2 100644
--- a/test-data/unit/fixtures/typing-full.pyi
+++ b/test-data/unit/fixtures/typing-full.pyi
@@ -10,26 +10,37 @@ from abc import abstractmethod, ABCMeta
 
 class GenericMeta(type): pass
 
+class _SpecialForm:
+    def __getitem__(self, index: Any) -> Any: ...
+    def __or__(self, other): ...
+    def __ror__(self, other): ...
+class TypeVar:
+    def __init__(self, name, *args, bound=None): ...
+    def __or__(self, other): ...
+class ParamSpec: ...
+class TypeVarTuple: ...
+
 def cast(t, o): ...
 def assert_type(o, t): ...
 overload = 0
-Any = 0
-Union = 0
+Any = object()
 Optional = 0
-TypeVar = 0
 Generic = 0
 Protocol = 0
 Tuple = 0
-Callable = 0
 _promote = 0
 Type = 0
 no_type_check = 0
 ClassVar = 0
 Final = 0
-Literal = 0
 TypedDict = 0
 NoReturn = 0
 NewType = 0
+Self = 0
+Unpack = 0
+Callable: _SpecialForm
+Union: _SpecialForm
+Literal: _SpecialForm
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
@@ -38,6 +49,8 @@ U = TypeVar('U')
 V = TypeVar('V')
 S = TypeVar('S')
 
+def final(x: T) -> T: ...
+
 class NamedTuple(tuple[Any, ...]): ...
 
 # Note: definitions below are different from typeshed, variances are declared
@@ -181,8 +194,6 @@ class _TypedDict(Mapping[str, object]):
     def update(self: T, __m: T) -> None: ...
     def __delitem__(self, k: NoReturn) -> None: ...
 
-class _SpecialForm: pass
-
 def dataclass_transform(
     *,
     eq_default: bool = ...,
@@ -192,3 +203,19 @@ def dataclass_transform(
     **kwargs: Any,
 ) -> Callable[[T], T]: ...
 def override(__arg: T) -> T: ...
+
+# Was added in 3.11
+def reveal_type(__obj: T) -> T: ...
+
+# Only exists in type checking time:
+def type_check_only(__func_or_class: T) -> T: ...
+
+# Was added in 3.12
+@final
+class TypeAliasType:
+    def __init__(
+        self, name: str, value: Any, *, type_params: Tuple[Union[TypeVar, ParamSpec, TypeVarTuple], ...] = ()
+    ) -> None: ...
+
+    def __or__(self, other: Any) -> Any: ...
+    def __ror__(self, other: Any) -> Any: ...
diff --git a/test-data/unit/fixtures/typing-medium.pyi b/test-data/unit/fixtures/typing-medium.pyi
index 03be1d0a664d..c722a9ddb12c 100644
--- a/test-data/unit/fixtures/typing-medium.pyi
+++ b/test-data/unit/fixtures/typing-medium.pyi
@@ -8,7 +8,7 @@
 
 cast = 0
 overload = 0
-Any = 0
+Any = object()
 Union = 0
 Optional = 0
 TypeVar = 0
@@ -28,6 +28,7 @@ NoReturn = 0
 NewType = 0
 TypeAlias = 0
 LiteralString = 0
+Self = 0
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
diff --git a/test-data/unit/fixtures/typing-namedtuple.pyi b/test-data/unit/fixtures/typing-namedtuple.pyi
index c8658a815a13..fbb4e43b62e6 100644
--- a/test-data/unit/fixtures/typing-namedtuple.pyi
+++ b/test-data/unit/fixtures/typing-namedtuple.pyi
@@ -1,11 +1,14 @@
 TypeVar = 0
 Generic = 0
-Any = 0
+Any = object()
 overload = 0
 Type = 0
 Literal = 0
 Optional = 0
 Self = 0
+Tuple = 0
+ClassVar = 0
+Final = 0
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
@@ -18,6 +21,11 @@ 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: ...
+
+class _SpecialForm: pass
diff --git a/test-data/unit/fixtures/typing-override.pyi b/test-data/unit/fixtures/typing-override.pyi
new file mode 100644
index 000000000000..e9d2dfcf55c4
--- /dev/null
+++ b/test-data/unit/fixtures/typing-override.pyi
@@ -0,0 +1,26 @@
+TypeVar = 0
+Generic = 0
+Any = object()
+overload = 0
+Type = 0
+Literal = 0
+Optional = 0
+Self = 0
+Tuple = 0
+ClassVar = 0
+Callable = 0
+
+T = TypeVar('T')
+T_co = TypeVar('T_co', covariant=True)
+KT = TypeVar('KT')
+
+class Iterable(Generic[T_co]): pass
+class Iterator(Iterable[T_co]): pass
+class Sequence(Iterable[T_co]): pass
+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
+
+def override(__arg: T) -> T: ...
+
+class _SpecialForm: pass
diff --git a/test-data/unit/fixtures/typing-typeddict-iror.pyi b/test-data/unit/fixtures/typing-typeddict-iror.pyi
new file mode 100644
index 000000000000..845ac6cf208f
--- /dev/null
+++ b/test-data/unit/fixtures/typing-typeddict-iror.pyi
@@ -0,0 +1,68 @@
+# Test stub for typing module that includes TypedDict `|` operator.
+# It only covers `__or__`, `__ror__`, and `__ior__`.
+#
+# We cannot define these methods in `typing-typeddict.pyi`,
+# because they need `dict` with two type args,
+# and not all tests using `[typing typing-typeddict.pyi]` have the proper
+# `dict` stub.
+#
+# Keep in sync with `typeshed`'s definition.
+from abc import ABCMeta
+
+cast = 0
+assert_type = 0
+overload = 0
+Any = object()
+Union = 0
+Optional = 0
+TypeVar = 0
+Generic = 0
+Protocol = 0
+Tuple = 0
+Callable = 0
+NamedTuple = 0
+Final = 0
+Literal = 0
+TypedDict = 0
+NoReturn = 0
+Required = 0
+NotRequired = 0
+Self = 0
+
+T = TypeVar('T')
+T_co = TypeVar('T_co', covariant=True)
+V = TypeVar('V')
+
+# Note: definitions below are different from typeshed, variances are declared
+# to silence the protocol variance checks. Maybe it is better to use type: ignore?
+
+class Sized(Protocol):
+    def __len__(self) -> int: pass
+
+class Iterable(Protocol[T_co]):
+    def __iter__(self) -> 'Iterator[T_co]': pass
+
+class Iterator(Iterable[T_co], Protocol):
+    def __next__(self) -> T_co: pass
+
+class Sequence(Iterable[T_co]):
+    # misc is for explicit Any.
+    def __getitem__(self, n: Any) -> T_co: pass # type: ignore[misc]
+
+class Mapping(Iterable[T], Generic[T, T_co], metaclass=ABCMeta):
+    pass
+
+# Fallback type for all typed dicts (does not exist at runtime).
+class _TypedDict(Mapping[str, object]):
+    @overload
+    def __or__(self, __value: Self) -> Self: ...
+    @overload
+    def __or__(self, __value: dict[str, Any]) -> dict[str, object]: ...
+    @overload
+    def __ror__(self, __value: Self) -> Self: ...
+    @overload
+    def __ror__(self, __value: dict[str, Any]) -> dict[str, object]: ...
+    # supposedly incompatible definitions of __or__ and __ior__
+    def __ior__(self, __value: Self) -> Self: ...  # type: ignore[misc]
+
+class _SpecialForm: pass
diff --git a/test-data/unit/fixtures/typing-typeddict.pyi b/test-data/unit/fixtures/typing-typeddict.pyi
index 24a2f1328981..f841a9aae6e7 100644
--- a/test-data/unit/fixtures/typing-typeddict.pyi
+++ b/test-data/unit/fixtures/typing-typeddict.pyi
@@ -11,7 +11,7 @@ from abc import ABCMeta
 cast = 0
 assert_type = 0
 overload = 0
-Any = 0
+Any = object()
 Union = 0
 Optional = 0
 TypeVar = 0
@@ -24,9 +24,12 @@ Final = 0
 Literal = 0
 TypedDict = 0
 NoReturn = 0
+NewType = 0
 Required = 0
 NotRequired = 0
+ReadOnly = 0
 Self = 0
+ClassVar = 0
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
@@ -45,8 +48,7 @@ class Iterator(Iterable[T_co], Protocol):
     def __next__(self) -> T_co: pass
 
 class Sequence(Iterable[T_co]):
-    # misc is for explicit Any.
-    def __getitem__(self, n: Any) -> T_co: pass # type: ignore[misc]
+    def __getitem__(self, n: Any) -> T_co: pass # type: ignore[explicit-any]
 
 class Mapping(Iterable[T], Generic[T, T_co], metaclass=ABCMeta):
     def keys(self) -> Iterable[T]: pass  # Approximate return type
@@ -59,6 +61,10 @@ class Mapping(Iterable[T], Generic[T, T_co], metaclass=ABCMeta):
     def __len__(self) -> int: ...
     def __contains__(self, arg: object) -> int: pass
 
+class MutableMapping(Mapping[T, T_co], Generic[T, T_co], metaclass=ABCMeta):
+    # Other methods are not used in tests.
+    def clear(self) -> None: ...
+
 # Fallback type for all typed dicts (does not exist at runtime).
 class _TypedDict(Mapping[str, object]):
     # Needed to make this class non-abstract. It is explicitly declared abstract in
@@ -71,3 +77,5 @@ class _TypedDict(Mapping[str, object]):
     def pop(self, k: NoReturn, default: T = ...) -> object: ...
     def update(self: T, __m: T) -> None: ...
     def __delitem__(self, k: NoReturn) -> None: ...
+
+class _SpecialForm: pass
diff --git a/test-data/unit/hacks.txt b/test-data/unit/hacks.txt
index 43114a8af004..15b1065cb7a9 100644
--- a/test-data/unit/hacks.txt
+++ b/test-data/unit/hacks.txt
@@ -5,17 +5,6 @@ Due to historical reasons, test cases contain things that may appear
 baffling without extra context. This file attempts to describe most of
 them.
 
-Strict optional is disabled be default
---------------------------------------
-
-Strict optional checking is enabled in mypy by default, but test cases
-must enable it explicitly, either through `# flags: --strict-optional`
-or by including `optional` as a substring in your test file name.
-
-The reason for this is that many test cases written before strict
-optional was implemented use the idiom `x = None # type: t`, and
-updating all of these test cases would take a lot of work.
-
 Dummy if statements to prevent redefinition
 -------------------------------------------
 
diff --git a/test-data/unit/lib-stub/attr/__init__.pyi b/test-data/unit/lib-stub/attr/__init__.pyi
index 24ffc0f3f275..466c6913062d 100644
--- a/test-data/unit/lib-stub/attr/__init__.pyi
+++ b/test-data/unit/lib-stub/attr/__init__.pyi
@@ -131,6 +131,7 @@ def define(
     *,
     these: Optional[Mapping[str, Any]] = ...,
     repr: bool = ...,
+    unsafe_hash: Optional[bool]=None,
     hash: Optional[bool] = ...,
     init: bool = ...,
     slots: bool = ...,
@@ -153,6 +154,7 @@ def define(
     *,
     these: Optional[Mapping[str, Any]] = ...,
     repr: bool = ...,
+    unsafe_hash: Optional[bool]=None,
     hash: Optional[bool] = ...,
     init: bool = ...,
     slots: bool = ...,
diff --git a/test-data/unit/lib-stub/attrs/__init__.pyi b/test-data/unit/lib-stub/attrs/__init__.pyi
index a575f97da9bc..d0a65c84d9d8 100644
--- a/test-data/unit/lib-stub/attrs/__init__.pyi
+++ b/test-data/unit/lib-stub/attrs/__init__.pyi
@@ -1,7 +1,14 @@
-from typing import TypeVar, overload, Callable, Any, Optional, Union, Sequence, Mapping, Generic
+from typing import TypeVar, overload, Callable, Any, Optional, Union, Sequence, Mapping, \
+    Protocol, ClassVar, Type
+from typing_extensions import TypeGuard
 
 from attr import Attribute as Attribute
 
+
+class AttrsInstance(Protocol):
+    __attrs_attrs__: ClassVar[Any]
+
+
 _T = TypeVar('_T')
 _C = TypeVar('_C', bound=type)
 
@@ -15,6 +22,7 @@ def define(
     *,
     these: Optional[Mapping[str, Any]] = ...,
     repr: bool = ...,
+    unsafe_hash: Optional[bool]=None,
     hash: Optional[bool] = ...,
     init: bool = ...,
     slots: bool = ...,
@@ -37,6 +45,7 @@ def define(
     *,
     these: Optional[Mapping[str, Any]] = ...,
     repr: bool = ...,
+    unsafe_hash: Optional[bool]=None,
     hash: Optional[bool] = ...,
     init: bool = ...,
     slots: bool = ...,
@@ -72,6 +81,7 @@ def field(
     eq: Optional[bool] = ...,
     order: Optional[bool] = ...,
     on_setattr: Optional[_OnSetAttrArgType] = ...,
+    alias: Optional[str] = ...,
 ) -> Any: ...
 
 # This form catches an explicit None or no default and infers the type from the
@@ -91,6 +101,7 @@ def field(
     eq: Optional[bool] = ...,
     order: Optional[bool] = ...,
     on_setattr: Optional[object] = ...,
+    alias: Optional[str] = ...,
 ) -> _T: ...
 
 # This form catches an explicit default argument.
@@ -109,6 +120,7 @@ def field(
     eq: Optional[bool] = ...,
     order: Optional[bool] = ...,
     on_setattr: Optional[object] = ...,
+    alias: Optional[str] = ...,
 ) -> _T: ...
 
 # This form covers type=non-Type: e.g. forward references (str), Any
@@ -127,9 +139,10 @@ def field(
     eq: Optional[bool] = ...,
     order: Optional[bool] = ...,
     on_setattr: Optional[object] = ...,
+    alias: Optional[str] = ...,
 ) -> Any: ...
 
 def evolve(inst: _T, **changes: Any) -> _T: ...
 def assoc(inst: _T, **changes: Any) -> _T: ...
-
-def fields(cls: type) -> Any: ...
+def has(cls: type) -> TypeGuard[Type[AttrsInstance]]: ...
+def fields(cls: Type[AttrsInstance]) -> Any: ...
diff --git a/test-data/unit/lib-stub/dataclasses.pyi b/test-data/unit/lib-stub/dataclasses.pyi
index bd33b459266c..cf43747757bd 100644
--- a/test-data/unit/lib-stub/dataclasses.pyi
+++ b/test-data/unit/lib-stub/dataclasses.pyi
@@ -1,6 +1,14 @@
-from typing import Any, Callable, Generic, Mapping, Optional, TypeVar, overload, Type
+from typing import Any, Callable, Generic, Literal, Mapping, Optional, TypeVar, overload, Type, \
+    Protocol, ClassVar
+from typing_extensions import TypeGuard
+
+# DataclassInstance is in _typeshed.pyi normally, but alas we can't do the same for lib-stub
+# due to test-data/unit/lib-stub/builtins.pyi not having 'tuple'.
+class DataclassInstance(Protocol):
+    __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
 
 _T = TypeVar('_T')
+_DataclassT = TypeVar("_DataclassT", bound=DataclassInstance)
 
 class InitVar(Generic[_T]):
     ...
@@ -32,3 +40,13 @@ def field(*,
 
 
 class Field(Generic[_T]): pass
+
+@overload
+def is_dataclass(obj: DataclassInstance) -> Literal[True]: ...
+@overload
+def is_dataclass(obj: type) -> TypeGuard[type[DataclassInstance]]: ...
+@overload
+def is_dataclass(obj: object) -> TypeGuard[DataclassInstance | type[DataclassInstance]]: ...
+
+
+def replace(__obj: _DataclassT, **changes: Any) -> _DataclassT: ...
diff --git a/test-data/unit/lib-stub/enum.pyi b/test-data/unit/lib-stub/enum.pyi
index 11adfc597955..ccb3818b9d25 100644
--- a/test-data/unit/lib-stub/enum.pyi
+++ b/test-data/unit/lib-stub/enum.pyi
@@ -1,4 +1,5 @@
 from typing import Any, TypeVar, Union, Type, Sized, Iterator
+from typing_extensions import Literal
 
 _T = TypeVar('_T')
 
@@ -7,6 +8,7 @@ class EnumMeta(type, Sized):
     def __iter__(self: Type[_T]) -> Iterator[_T]: pass
     def __reversed__(self: Type[_T]) -> Iterator[_T]: pass
     def __getitem__(self: Type[_T], name: str) -> _T: pass
+    def __bool__(self) -> Literal[True]: pass
 
 class Enum(metaclass=EnumMeta):
     def __new__(cls: Type[_T], value: object) -> _T: pass
@@ -48,3 +50,13 @@ class auto(IntFlag):
 # It is python-3.11+ only:
 class StrEnum(str, Enum):
     def __new__(cls: Type[_T], value: str | _T) -> _T: ...
+
+# It is python-3.11+ only:
+class nonmember(Generic[_T]):
+    value: _T
+    def __init__(self, value: _T) -> None: ...
+
+# It is python-3.11+ only:
+class member(Generic[_T]):
+    value: _T
+    def __init__(self, value: _T) -> None: ...
diff --git a/test-data/unit/lib-stub/functools.pyi b/test-data/unit/lib-stub/functools.pyi
index 9e62a14c2f34..b8d47e1da2b5 100644
--- a/test-data/unit/lib-stub/functools.pyi
+++ b/test-data/unit/lib-stub/functools.pyi
@@ -1,4 +1,4 @@
-from typing import Generic, TypeVar, Callable, Any, Mapping
+from typing import Generic, TypeVar, Callable, Any, Mapping, Self, overload
 
 _T = TypeVar("_T")
 
@@ -33,3 +33,7 @@ class cached_property(Generic[_T]):
     def __get__(self, instance: object, owner: type[Any] | None = ...) -> _T: ...
     def __set_name__(self, owner: type[Any], name: str) -> None: ...
     def __class_getitem__(cls, item: Any) -> Any: ...
+
+class partial(Generic[_T]):
+    def __new__(cls, __func: Callable[..., _T], *args: Any, **kwargs: Any) -> Self: ...
+    def __call__(__self, *args: Any, **kwargs: Any) -> _T: ...
diff --git a/test-data/unit/lib-stub/mypy_extensions.pyi b/test-data/unit/lib-stub/mypy_extensions.pyi
index 56fac31e7219..4295c33f81ad 100644
--- a/test-data/unit/lib-stub/mypy_extensions.pyi
+++ b/test-data/unit/lib-stub/mypy_extensions.pyi
@@ -50,7 +50,67 @@ class FlexibleAlias(Generic[_T, _U]): ...
 class __SupportsInt(Protocol[T_co]):
     def __int__(self) -> int: pass
 
-_Int = Union[int, 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: ...
+    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: ...
diff --git a/test-data/unit/lib-stub/types.pyi b/test-data/unit/lib-stub/types.pyi
index 012fd8503377..3f713c31e417 100644
--- a/test-data/unit/lib-stub/types.pyi
+++ b/test-data/unit/lib-stub/types.pyi
@@ -9,9 +9,13 @@ class ModuleType:
     __file__: str
     def __getattr__(self, name: str) -> Any: pass
 
-if sys.version_info >= (3, 10):
-    class Union:
-        def __or__(self, x) -> Union: ...
+class GenericAlias:
+    def __or__(self, o): ...
+    def __ror__(self, o): ...
 
+if sys.version_info >= (3, 10):
     class NoneType:
         ...
+
+    class UnionType:
+        def __or__(self, x) -> UnionType: ...
diff --git a/test-data/unit/lib-stub/typing.pyi b/test-data/unit/lib-stub/typing.pyi
index b35b64a383c9..86d542a918ee 100644
--- a/test-data/unit/lib-stub/typing.pyi
+++ b/test-data/unit/lib-stub/typing.pyi
@@ -11,7 +11,7 @@
 cast = 0
 assert_type = 0
 overload = 0
-Any = 0
+Any = object()
 Union = 0
 Optional = 0
 TypeVar = 0
@@ -23,6 +23,7 @@ NamedTuple = 0
 Type = 0
 ClassVar = 0
 Final = 0
+Literal = 0
 NoReturn = 0
 Never = 0
 NewType = 0
@@ -48,6 +49,7 @@ class Generator(Iterator[T], Generic[T, U, V]):
 
 class Sequence(Iterable[T_co]):
     def __getitem__(self, n: Any) -> T_co: pass
+    def __len__(self) -> int: pass
 
 # Mapping type is oversimplified intentionally.
 class Mapping(Iterable[T], Generic[T, T_co]):
@@ -62,3 +64,5 @@ class Coroutine(Awaitable[V], Generic[T, U, V]): pass
 def final(meth: T) -> T: pass
 
 def reveal_type(__obj: T) -> T: pass
+
+class _SpecialForm: pass
diff --git a/test-data/unit/lib-stub/typing_extensions.pyi b/test-data/unit/lib-stub/typing_extensions.pyi
index 216005e3cf83..cb054b0e6b4f 100644
--- a/test-data/unit/lib-stub/typing_extensions.pyi
+++ b/test-data/unit/lib-stub/typing_extensions.pyi
@@ -1,5 +1,5 @@
 import typing
-from typing import Any, Mapping, Iterable, Iterator, NoReturn as NoReturn, Dict, Tuple, Type
+from typing import Any, Callable, Mapping, Iterable, Iterator, NoReturn as NoReturn, Dict, Tuple, Type, Union
 from typing import TYPE_CHECKING as TYPE_CHECKING
 from typing import NewType as NewType, overload as overload
 
@@ -34,10 +34,22 @@ Concatenate: _SpecialForm
 TypeAlias: _SpecialForm
 
 TypeGuard: _SpecialForm
+TypeIs: _SpecialForm
 Never: _SpecialForm
 
 TypeVarTuple: _SpecialForm
 Unpack: _SpecialForm
+Required: _SpecialForm
+NotRequired: _SpecialForm
+ReadOnly: _SpecialForm
+
+Self: _SpecialForm
+
+@final
+class TypeAliasType:
+    def __init__(
+        self, name: str, value: Any, *, type_params: Tuple[Union[TypeVar, ParamSpec, TypeVarTuple], ...] = ()
+    ) -> None: ...
 
 # Fallback type for all typed dicts (does not exist at runtime).
 class _TypedDict(Mapping[str, object]):
@@ -59,11 +71,16 @@ class _TypedDict(Mapping[str, object]):
     # Stubtest's tests need the following items:
     __required_keys__: frozenset[str]
     __optional_keys__: frozenset[str]
+    __readonly_keys__: frozenset[str]
+    __mutable_keys__: frozenset[str]
+    __closed__: bool
+    __extra_items__: Any
     __total__: bool
 
 def TypedDict(typename: str, fields: Dict[str, Type[_T]], *, total: Any = ...) -> Type[dict]: ...
 
-def reveal_type(__obj: T) -> T: pass
+def reveal_type(__obj: _T) -> _T: pass
+def assert_type(__val: _T, __typ: Any) -> _T: pass
 
 def dataclass_transform(
     *,
@@ -72,8 +89,9 @@ def dataclass_transform(
     kw_only_default: bool = ...,
     field_specifiers: tuple[type[Any] | Callable[..., Any], ...] = ...,
     **kwargs: Any,
-) -> Callable[[T], T]: ...
+) -> Callable[[_T], _T]: ...
 
 def override(__arg: _T) -> _T: ...
+def deprecated(__msg: str) -> Callable[[_T], _T]: ...
 
 _FutureFeatureFixture = 0
diff --git a/test-data/unit/merge.test b/test-data/unit/merge.test
index 19b1839f86c0..8c806623403b 100644
--- a/test-data/unit/merge.test
+++ b/test-data/unit/merge.test
@@ -1332,23 +1332,25 @@ MypyFile:1<1>(
 [case testMergeTypedDict_symtable]
 import target
 [file target.py]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class A: pass
 D = TypedDict('D', {'a': A})
 d: D
 [file target.py.next]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class A: pass
 D = TypedDict('D', {'a': A, 'b': int})
 d: D
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
 [out]
 __main__:
     target: MypyFile<0>
 target:
     A: TypeInfo<1>
     D: TypeInfo<2>
-    TypedDict: FuncDef<3>
+    TypedDict: Var<3>
     d: Var<4>(TypedDict('target.D', {'a': target.A<1>}))
 ==>
 __main__:
@@ -1356,7 +1358,7 @@ __main__:
 target:
     A: TypeInfo<1>
     D: TypeInfo<2>
-    TypedDict: FuncDef<3>
+    TypedDict: Var<3>
     d: Var<4>(TypedDict('target.D', {'a': target.A<1>, 'b': builtins.int<5>}))
 
 [case testNewType_symtable]
@@ -1490,6 +1492,7 @@ from enum import Enum
 class A(Enum):
     X = 0
     Y = 1
+[builtins fixtures/enum.pyi]
 [out]
 TypeInfo<0>(
   Name(target.A)
@@ -1511,11 +1514,11 @@ TypeInfo<0>(
 [case testLiteralMerge]
 import target
 [file target.py]
-from typing_extensions import Literal
+from typing import Literal
 def foo(x: Literal[3]) -> Literal['a']: pass
 bar: Literal[4] = 4
 [file target.py.next]
-from typing_extensions import Literal
+from typing import Literal
 def foo(x: Literal['3']) -> Literal['b']: pass
 bar: Literal[5] = 5
 [builtins fixtures/tuple.pyi]
@@ -1525,7 +1528,7 @@ MypyFile:1<0>(
   Import:1(target))
 MypyFile:1<1>(
   tmp/target.py
-  ImportFrom:1(typing_extensions, [Literal])
+  ImportFrom:1(typing, [Literal])
   FuncDef:2<2>(
     foo
     Args(
@@ -1543,7 +1546,7 @@ MypyFile:1<0>(
   Import:1(target))
 MypyFile:1<1>(
   tmp/target.py
-  ImportFrom:1(typing_extensions, [Literal])
+  ImportFrom:1(typing, [Literal])
   FuncDef:2<2>(
     foo
     Args(
diff --git a/test-data/unit/outputjson.test b/test-data/unit/outputjson.test
new file mode 100644
index 000000000000..43649b7b781d
--- /dev/null
+++ b/test-data/unit/outputjson.test
@@ -0,0 +1,44 @@
+-- Test cases for `--output=json`.
+-- These cannot be run by the usual unit test runner because of the backslashes
+-- in the output, which get normalized to forward slashes by the test suite on
+-- Windows.
+
+[case testOutputJsonNoIssues]
+# flags: --output=json
+def foo() -> None:
+    pass
+
+foo()
+[out]
+
+[case testOutputJsonSimple]
+# flags: --output=json
+def foo() -> None:
+    pass
+
+foo(1)
+[out]
+{"file": "main", "line": 5, "column": 0, "message": "Too many arguments for \"foo\"", "hint": null, "code": "call-arg", "severity": "error"}
+
+[case testOutputJsonWithHint]
+# flags: --output=json
+from typing import Optional, overload
+
+@overload
+def foo() -> None: ...
+@overload
+def foo(x: int) -> None: ...
+
+def foo(x: Optional[int] = None) -> None:
+    ...
+
+reveal_type(foo)
+
+foo('42')
+
+def bar() -> None: ...
+bar('42')
+[out]
+{"file": "main", "line": 12, "column": 12, "message": "Revealed type is \"Overload(def (), def (x: builtins.int))\"", "hint": null, "code": "misc", "severity": "note"}
+{"file": "main", "line": 14, "column": 0, "message": "No overload variant of \"foo\" matches argument type \"str\"", "hint": "Possible overload variants:\n    def foo() -> None\n    def foo(x: int) -> None", "code": "call-overload", "severity": "error"}
+{"file": "main", "line": 17, "column": 0, "message": "Too many arguments for \"bar\"", "hint": null, "code": "call-arg", "severity": "error"}
diff --git a/test-data/unit/parse-errors.test b/test-data/unit/parse-errors.test
index 33cf9b4f91b4..33c2a6ddf5c0 100644
--- a/test-data/unit/parse-errors.test
+++ b/test-data/unit/parse-errors.test
@@ -55,7 +55,7 @@ file:1: error: invalid syntax
 [case testUnexpectedEof]
 if 1:
 [out]
-file:1: error: unexpected EOF while parsing
+file:1: error: expected an indented block
 
 [case testInvalidKeywordArguments1]
 f(x=y, z)
@@ -151,6 +151,13 @@ x = 0 # type: A B #comment #7
 [out]
 file:2: error: Syntax error in type comment "A B"
 
+[case testMissingBracket]
+def foo(
+[out]
+file:1: error: unexpected EOF while parsing
+[out version>=3.10]
+file:1: error: '(' was never closed
+
 [case testInvalidSignatureInComment1]
 def f(): # type: x
   pass
@@ -273,17 +280,10 @@ file:3: error: Syntax error in type comment
 file:3: error: Inconsistent use of "*" in function signature
 file:3: error: Inconsistent use of "**" in function signature
 
-[case testPrintStatementInPython35]
-# flags: --python-version 3.5
-print 1
-[out]
-file:2: error: Missing parentheses in call to 'print'
-
-[case testPrintStatementInPython37]
-# flags: --python-version 3.7
+[case testPrintStatementInPython3]
 print 1
 [out]
-file:2: error: Missing parentheses in call to 'print'. Did you mean print(1)?
+file:1: error: Missing parentheses in call to 'print'. Did you mean print(1)?
 
 [case testInvalidConditionInConditionalExpression]
 1 if 2, 3 else 4
@@ -434,7 +434,7 @@ file:1: error: invalid syntax
 [case testSmartQuotes]
 foo = ‘bar’
 [out]
-file:1: error: invalid character in identifier
+file:1: error: invalid character '‘' (U+2018)
 
 [case testExceptCommaInPython3]
 try:
diff --git a/test-data/unit/parse-python312.test b/test-data/unit/parse-python312.test
new file mode 100644
index 000000000000..2b1f9b42e0f7
--- /dev/null
+++ b/test-data/unit/parse-python312.test
@@ -0,0 +1,90 @@
+[case testPEP695TypeAlias]
+# comment
+type A[T] = C[T]
+[out]
+MypyFile:1(
+  TypeAliasStmt:2(
+    NameExpr(A)
+    TypeParam(
+      T)
+    LambdaExpr:2(
+      Block:-1(
+        ReturnStmt:2(
+          IndexExpr:2(
+            NameExpr(C)
+            NameExpr(T)))))))
+
+[case testPEP695GenericFunction]
+# comment
+
+def f[T](): pass
+def g[T: str](): pass
+def h[T: (int, str)](): pass
+[out]
+MypyFile:1(
+  FuncDef:3(
+    f
+    TypeParam(
+      T)
+    Block:3(
+      PassStmt:3()))
+  FuncDef:4(
+    g
+    TypeParam(
+      T
+      str?)
+    Block:4(
+      PassStmt:4()))
+  FuncDef:5(
+    h
+    TypeParam(
+      T
+      Values(
+        int?
+        str?))
+    Block:5(
+      PassStmt:5())))
+
+[case testPEP695ParamSpec]
+# comment
+
+def f[**P](): pass
+class C[T: int, **P]: pass
+[out]
+MypyFile:1(
+  FuncDef:3(
+    f
+    TypeParam(
+      **P)
+    Block:3(
+      PassStmt:3()))
+  ClassDef:4(
+    C
+    TypeParam(
+      T
+      int?)
+    TypeParam(
+      **P)
+    PassStmt:4()))
+
+[case testPEP695TypeVarTuple]
+# comment
+
+def f[*Ts](): pass
+class C[T: int, *Ts]: pass
+[out]
+MypyFile:1(
+  FuncDef:3(
+    f
+    TypeParam(
+      *Ts)
+    Block:3(
+      PassStmt:3()))
+  ClassDef:4(
+    C
+    TypeParam(
+      T
+      int?)
+    TypeParam(
+      *Ts)
+    PassStmt:4()))
diff --git a/test-data/unit/parse-python313.test b/test-data/unit/parse-python313.test
new file mode 100644
index 000000000000..efbafb0766f5
--- /dev/null
+++ b/test-data/unit/parse-python313.test
@@ -0,0 +1,80 @@
+[case testPEP696TypeAlias]
+type A[T = int] = C[T]
+[out]
+MypyFile:1(
+  TypeAliasStmt:1(
+    NameExpr(A)
+    TypeParam(
+      T
+      Default(
+        int?))
+    LambdaExpr:1(
+      Block:-1(
+        ReturnStmt:1(
+          IndexExpr:1(
+            NameExpr(C)
+            NameExpr(T)))))))
+
+[case testPEP696GenericFunction]
+def f[T = int](): pass
+class C[T = int]: pass
+[out]
+MypyFile:1(
+  FuncDef:1(
+    f
+    TypeParam(
+      T
+      Default(
+        int?))
+    Block:1(
+      PassStmt:1()))
+  ClassDef:2(
+    C
+    TypeParam(
+      T
+      Default(
+        int?))
+    PassStmt:2()))
+
+[case testPEP696ParamSpec]
+def f[**P = [int, str]](): pass
+class C[**P = [int, str]]: pass
+[out]
+[out]
+MypyFile:1(
+  FuncDef:1(
+    f
+    TypeParam(
+      **P
+      Default(
+        <TypeList int?, str?>))
+    Block:1(
+      PassStmt:1()))
+  ClassDef:2(
+    C
+    TypeParam(
+      **P
+      Default(
+        <TypeList int?, str?>))
+    PassStmt:2()))
+
+[case testPEP696TypeVarTuple]
+def f[*Ts = *tuple[str, int]](): pass
+class C[*Ts = *tuple[str, int]]: pass
+[out]
+MypyFile:1(
+  FuncDef:1(
+    f
+    TypeParam(
+      *Ts
+      Default(
+        Unpack[tuple?[str?, int?]]))
+    Block:1(
+      PassStmt:1()))
+  ClassDef:2(
+    C
+    TypeParam(
+      *Ts
+      Default(
+        Unpack[tuple?[str?, int?]]))
+    PassStmt:2()))
diff --git a/test-data/unit/parse.test b/test-data/unit/parse.test
index 10ceaa947fd4..943ca49081f1 100644
--- a/test-data/unit/parse.test
+++ b/test-data/unit/parse.test
@@ -3171,10 +3171,10 @@ MypyFile:1(
     IndexExpr:1(
       NameExpr(a)
       TupleExpr:1(
-        SliceExpr:-1(
+        SliceExpr:1(
           <empty>
           <empty>)
-        SliceExpr:-1(
+        SliceExpr:1(
           <empty>
           <empty>)))))
 
@@ -3186,10 +3186,10 @@ MypyFile:1(
     IndexExpr:1(
       NameExpr(a)
       TupleExpr:1(
-        SliceExpr:-1(
+        SliceExpr:1(
           IntExpr(1)
           IntExpr(2))
-        SliceExpr:-1(
+        SliceExpr:1(
           <empty>
           <empty>)))))
 
@@ -3201,13 +3201,29 @@ MypyFile:1(
     IndexExpr:1(
       NameExpr(a)
       TupleExpr:1(
-        SliceExpr:-1(
+        SliceExpr:1(
           IntExpr(1)
           IntExpr(2)
           IntExpr(3))
         Ellipsis
         IntExpr(1)))))
 
+[case testParseExtendedSlicing4]
+m[*index, :]
+[out]
+main:1: error: invalid syntax
+[out version>=3.11]
+MypyFile:1(
+  ExpressionStmt:1(
+    IndexExpr:1(
+      NameExpr(m)
+      TupleExpr:1(
+        StarExpr:1(
+          NameExpr(index))
+        SliceExpr:1(
+          <empty>
+          <empty>)))))
+
 [case testParseIfExprInDictExpr]
 test =  { 'spam': 'eggs' if True else 'bacon' }
 [out]
diff --git a/test-data/unit/pep561.test b/test-data/unit/pep561.test
index 8c401cfc3c51..314befa11b94 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
@@ -185,6 +167,7 @@ a.bf(False)
 b.bf(False)
 a.bf(1)
 b.bf(1)
+import typedpkg_ns.whatever as c  # type: ignore[import-untyped]
 [out]
 testNamespacePkgWStubs.py:4: error: Skipping analyzing "typedpkg_ns.b.bbb": module is installed, but missing library stubs or py.typed marker
 testNamespacePkgWStubs.py:4: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
@@ -204,6 +187,13 @@ b.bf(1)
 testNamespacePkgWStubsWithNamespacePackagesFlag.py:7: error: Argument 1 to "bf" has incompatible type "int"; expected "bool"
 testNamespacePkgWStubsWithNamespacePackagesFlag.py:8: error: Argument 1 to "bf" has incompatible type "int"; expected "bool"
 
+[case testMissingPytypedFlag]
+# pkgs: typedpkg_ns_b
+# flags: --namespace-packages --follow-untyped-imports
+import typedpkg_ns.b.bbb as b
+b.bf("foo", "bar")
+[out]
+testMissingPytypedFlag.py:4: error: Too many arguments for "bf"
 
 [case testTypedPkgNamespaceRegFromImportTwiceMissing]
 # pkgs: typedpkg_ns_a
@@ -223,3 +213,23 @@ from typedpkg_ns.a.bbb import bf
 [file dummy.py.2]
 [out]
 [out2]
+
+[case testTypedNamespaceSubpackage]
+# pkgs: typedpkg_ns_nested
+import our
+[file our/__init__.py]
+import our.bar
+import our.foo
+[file our/bar.py]
+from typedpkg_ns.b import Something
+[file our/foo.py]
+import typedpkg_ns.a
+
+[file dummy.py.2]
+
+[out]
+our/bar.py:1: error: Skipping analyzing "typedpkg_ns.b": module is installed, but missing library stubs or py.typed marker
+our/bar.py:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
+[out2]
+our/bar.py:1: error: Skipping analyzing "typedpkg_ns.b": module is installed, but missing library stubs or py.typed marker
+our/bar.py:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
diff --git a/test-data/unit/plugins/add_classmethod.py b/test-data/unit/plugins/add_classmethod.py
index 5aacc69a8f01..9bc2c4e079dd 100644
--- a/test-data/unit/plugins/add_classmethod.py
+++ b/test-data/unit/plugins/add_classmethod.py
@@ -1,4 +1,6 @@
-from typing import Callable, Optional
+from __future__ import annotations
+
+from typing import Callable
 
 from mypy.nodes import ARG_POS, Argument, Var
 from mypy.plugin import ClassDefContext, Plugin
@@ -7,7 +9,7 @@
 
 
 class ClassMethodPlugin(Plugin):
-    def get_base_class_hook(self, fullname: str) -> Optional[Callable[[ClassDefContext], None]]:
+    def get_base_class_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None:
         if "BaseAddMethod" in fullname:
             return add_extra_methods_hook
         return None
@@ -24,5 +26,5 @@ def add_extra_methods_hook(ctx: ClassDefContext) -> None:
     )
 
 
-def plugin(version):
+def plugin(version: str) -> type[ClassMethodPlugin]:
     return ClassMethodPlugin
diff --git a/test-data/unit/plugins/add_method.py b/test-data/unit/plugins/add_method.py
new file mode 100644
index 000000000000..f3a7ebdb95ed
--- /dev/null
+++ b/test-data/unit/plugins/add_method.py
@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import ClassDefContext, Plugin
+from mypy.plugins.common import add_method
+from mypy.types import NoneType
+
+
+class AddOverrideMethodPlugin(Plugin):
+    def get_class_decorator_hook_2(self, fullname: str) -> Callable[[ClassDefContext], bool] | None:
+        if fullname == "__main__.inject_foo":
+            return add_extra_methods_hook
+        return None
+
+
+def add_extra_methods_hook(ctx: ClassDefContext) -> bool:
+    add_method(ctx, "foo_implicit", [], NoneType())
+    return True
+
+
+def plugin(version: str) -> type[AddOverrideMethodPlugin]:
+    return AddOverrideMethodPlugin
diff --git a/test-data/unit/plugins/add_overloaded_method.py b/test-data/unit/plugins/add_overloaded_method.py
new file mode 100644
index 000000000000..efda848f790c
--- /dev/null
+++ b/test-data/unit/plugins/add_overloaded_method.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.nodes import ARG_POS, Argument, Var
+from mypy.plugin import ClassDefContext, Plugin
+from mypy.plugins.common import MethodSpec, add_overloaded_method_to_class
+
+
+class OverloadedMethodPlugin(Plugin):
+    def get_base_class_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None:
+        if "AddOverloadedMethod" in fullname:
+            return add_overloaded_method_hook
+        return None
+
+
+def add_overloaded_method_hook(ctx: ClassDefContext) -> None:
+    add_overloaded_method_to_class(ctx.api, ctx.cls, "method", _generate_method_specs(ctx))
+    add_overloaded_method_to_class(
+        ctx.api, ctx.cls, "clsmethod", _generate_method_specs(ctx), is_classmethod=True
+    )
+    add_overloaded_method_to_class(
+        ctx.api, ctx.cls, "stmethod", _generate_method_specs(ctx), is_staticmethod=True
+    )
+
+
+def _generate_method_specs(ctx: ClassDefContext) -> list[MethodSpec]:
+    return [
+        MethodSpec(
+            args=[Argument(Var("arg"), ctx.api.named_type("builtins.int"), None, ARG_POS)],
+            return_type=ctx.api.named_type("builtins.str"),
+        ),
+        MethodSpec(
+            args=[Argument(Var("arg"), ctx.api.named_type("builtins.str"), None, ARG_POS)],
+            return_type=ctx.api.named_type("builtins.int"),
+        ),
+    ]
+
+
+def plugin(version: str) -> type[OverloadedMethodPlugin]:
+    return OverloadedMethodPlugin
diff --git a/test-data/unit/plugins/arg_kinds.py b/test-data/unit/plugins/arg_kinds.py
index 5392e64c4f11..388a3c738b62 100644
--- a/test-data/unit/plugins/arg_kinds.py
+++ b/test-data/unit/plugins/arg_kinds.py
@@ -1,18 +1,19 @@
-from typing import Optional, Callable
-from mypy.plugin import Plugin, MethodContext, FunctionContext
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import FunctionContext, MethodContext, Plugin
 from mypy.types import Type
 
 
 class ArgKindsPlugin(Plugin):
-    def get_function_hook(self, fullname: str
-                          ) -> Optional[Callable[[FunctionContext], Type]]:
-        if 'func' in fullname:
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
+        if "func" in fullname:
             return extract_arg_kinds_from_function
         return None
 
-    def get_method_hook(self, fullname: str
-                        ) -> Optional[Callable[[MethodContext], Type]]:
-        if 'Class.method' in fullname:
+    def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None:
+        if "Class.method" in fullname:
             return extract_arg_kinds_from_method
         return None
 
@@ -27,5 +28,5 @@ def extract_arg_kinds_from_method(ctx: MethodContext) -> Type:
     return ctx.default_return_type
 
 
-def plugin(version):
+def plugin(version: str) -> type[ArgKindsPlugin]:
     return ArgKindsPlugin
diff --git a/test-data/unit/plugins/arg_names.py b/test-data/unit/plugins/arg_names.py
index 6c1cbb9415cc..981c1a2eb12d 100644
--- a/test-data/unit/plugins/arg_names.py
+++ b/test-data/unit/plugins/arg_names.py
@@ -1,35 +1,51 @@
-from typing import Optional, Callable
+from __future__ import annotations
 
-from mypy.plugin import Plugin, MethodContext, FunctionContext
+from typing import Callable
+
+from mypy.nodes import StrExpr
+from mypy.plugin import FunctionContext, MethodContext, Plugin
 from mypy.types import Type
 
 
 class ArgNamesPlugin(Plugin):
-    def get_function_hook(self, fullname: str
-                          ) -> Optional[Callable[[FunctionContext], Type]]:
-        if fullname in {'mod.func', 'mod.func_unfilled', 'mod.func_star_expr',
-                        'mod.ClassInit', 'mod.Outer.NestedClassInit'}:
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
+        if fullname in {
+            "mod.func",
+            "mod.func_unfilled",
+            "mod.func_star_expr",
+            "mod.ClassInit",
+            "mod.Outer.NestedClassInit",
+        }:
             return extract_classname_and_set_as_return_type_function
         return None
 
-    def get_method_hook(self, fullname: str
-                        ) -> Optional[Callable[[MethodContext], Type]]:
-        if fullname in {'mod.Class.method', 'mod.Class.myclassmethod', 'mod.Class.mystaticmethod',
-                        'mod.ClassUnfilled.method', 'mod.ClassStarExpr.method',
-                        'mod.ClassChild.method', 'mod.ClassChild.myclassmethod'}:
+    def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None:
+        if fullname in {
+            "mod.Class.method",
+            "mod.Class.myclassmethod",
+            "mod.Class.mystaticmethod",
+            "mod.ClassUnfilled.method",
+            "mod.ClassStarExpr.method",
+            "mod.ClassChild.method",
+            "mod.ClassChild.myclassmethod",
+        }:
             return extract_classname_and_set_as_return_type_method
         return None
 
 
 def extract_classname_and_set_as_return_type_function(ctx: FunctionContext) -> Type:
-    classname = ctx.args[ctx.callee_arg_names.index('classname')][0].value
-    return ctx.api.named_generic_type(classname, [])
+    arg = ctx.args[ctx.callee_arg_names.index("classname")][0]
+    if not isinstance(arg, StrExpr):
+        return ctx.default_return_type
+    return ctx.api.named_generic_type(arg.value, [])
 
 
 def extract_classname_and_set_as_return_type_method(ctx: MethodContext) -> Type:
-    classname = ctx.args[ctx.callee_arg_names.index('classname')][0].value
-    return ctx.api.named_generic_type(classname, [])
+    arg = ctx.args[ctx.callee_arg_names.index("classname")][0]
+    if not isinstance(arg, StrExpr):
+        return ctx.default_return_type
+    return ctx.api.named_generic_type(arg.value, [])
 
 
-def plugin(version):
+def plugin(version: str) -> type[ArgNamesPlugin]:
     return ArgNamesPlugin
diff --git a/test-data/unit/plugins/attrhook.py b/test-data/unit/plugins/attrhook.py
index c177072aa47f..9500734daa6c 100644
--- a/test-data/unit/plugins/attrhook.py
+++ b/test-data/unit/plugins/attrhook.py
@@ -1,12 +1,14 @@
-from typing import Optional, Callable
+from __future__ import annotations
 
-from mypy.plugin import Plugin, AttributeContext
-from mypy.types import Type, Instance
+from typing import Callable
+
+from mypy.plugin import AttributeContext, Plugin
+from mypy.types import Instance, Type
 
 
 class AttrPlugin(Plugin):
-    def get_attribute_hook(self, fullname: str) -> Optional[Callable[[AttributeContext], Type]]:
-        if fullname == 'm.Signal.__call__':
+    def get_attribute_hook(self, fullname: str) -> Callable[[AttributeContext], Type] | None:
+        if fullname == "m.Signal.__call__":
             return signal_call_callback
         return None
 
@@ -17,5 +19,5 @@ def signal_call_callback(ctx: AttributeContext) -> Type:
     return ctx.default_attr_type
 
 
-def plugin(version):
+def plugin(version: str) -> type[AttrPlugin]:
     return AttrPlugin
diff --git a/test-data/unit/plugins/attrhook2.py b/test-data/unit/plugins/attrhook2.py
index cc14341a6f97..1ce318d2057b 100644
--- a/test-data/unit/plugins/attrhook2.py
+++ b/test-data/unit/plugins/attrhook2.py
@@ -1,15 +1,19 @@
-from typing import Optional, Callable
+from __future__ import annotations
 
-from mypy.plugin import Plugin, AttributeContext
-from mypy.types import Type, AnyType, TypeOfAny
+from typing import Callable
+
+from mypy.plugin import AttributeContext, Plugin
+from mypy.types import AnyType, Type, TypeOfAny
 
 
 class AttrPlugin(Plugin):
-    def get_attribute_hook(self, fullname: str) -> Optional[Callable[[AttributeContext], Type]]:
-        if fullname == 'm.Magic.magic_field':
+    def get_attribute_hook(self, fullname: str) -> Callable[[AttributeContext], Type] | None:
+        if fullname == "m.Magic.magic_field":
             return magic_field_callback
-        if fullname == 'm.Magic.nonexistent_field':
+        if fullname == "m.Magic.nonexistent_field":
             return nonexistent_field_callback
+        if fullname == "m.Magic.no_assignment_field":
+            return no_assignment_field_callback
         return None
 
 
@@ -22,5 +26,12 @@ def nonexistent_field_callback(ctx: AttributeContext) -> Type:
     return AnyType(TypeOfAny.from_error)
 
 
-def plugin(version):
+def no_assignment_field_callback(ctx: AttributeContext) -> Type:
+    if ctx.is_lvalue:
+        ctx.api.fail(f"Cannot assign to field", ctx.context)
+        return AnyType(TypeOfAny.from_error)
+    return ctx.default_attr_type
+
+
+def plugin(version: str) -> type[AttrPlugin]:
     return AttrPlugin
diff --git a/test-data/unit/plugins/badreturn.py b/test-data/unit/plugins/badreturn.py
index fd7430606dd6..9dce3b3e99c2 100644
--- a/test-data/unit/plugins/badreturn.py
+++ b/test-data/unit/plugins/badreturn.py
@@ -1,2 +1,2 @@
-def plugin(version):
+def plugin(version: str) -> None:
     pass
diff --git a/test-data/unit/plugins/badreturn2.py b/test-data/unit/plugins/badreturn2.py
index c7e0447841c1..1ae551ecbf20 100644
--- a/test-data/unit/plugins/badreturn2.py
+++ b/test-data/unit/plugins/badreturn2.py
@@ -1,5 +1,9 @@
+from __future__ import annotations
+
+
 class MyPlugin:
     pass
 
-def plugin(version):
+
+def plugin(version: str) -> type[MyPlugin]:
     return MyPlugin
diff --git a/test-data/unit/plugins/callable_instance.py b/test-data/unit/plugins/callable_instance.py
index 40e7df418539..a9f562effb34 100644
--- a/test-data/unit/plugins/callable_instance.py
+++ b/test-data/unit/plugins/callable_instance.py
@@ -1,23 +1,30 @@
+from __future__ import annotations
+
+from typing import Callable
+
 from mypy.plugin import MethodContext, Plugin
 from mypy.types import Instance, Type
 
+
 class CallableInstancePlugin(Plugin):
-    def get_function_hook(self, fullname):
-        assert not fullname.endswith(' of Foo')
+    def get_function_hook(self, fullname: str) -> None:
+        assert not fullname.endswith(" of Foo")
 
-    def get_method_hook(self, fullname):
+    def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None:
         # Ensure that all names are fully qualified
-        assert not fullname.endswith(' of Foo')
+        assert not fullname.endswith(" of Foo")
 
-        if fullname == '__main__.Class.__call__':
+        if fullname == "__main__.Class.__call__":
             return my_hook
 
         return None
 
+
 def my_hook(ctx: MethodContext) -> Type:
     if isinstance(ctx.type, Instance) and len(ctx.type.args) == 1:
         return ctx.type.args[0]
     return ctx.default_return_type
 
-def plugin(version):
+
+def plugin(version: str) -> type[CallableInstancePlugin]:
     return CallableInstancePlugin
diff --git a/test-data/unit/plugins/class_attr_hook.py b/test-data/unit/plugins/class_attr_hook.py
index 348e5df0ee03..5d6a87df48bb 100644
--- a/test-data/unit/plugins/class_attr_hook.py
+++ b/test-data/unit/plugins/class_attr_hook.py
@@ -1,20 +1,23 @@
-from typing import Callable, Optional
+from __future__ import annotations
+
+from typing import Callable
 
 from mypy.plugin import AttributeContext, Plugin
 from mypy.types import Type as MypyType
 
 
 class ClassAttrPlugin(Plugin):
-    def get_class_attribute_hook(self, fullname: str
-                                 ) -> Optional[Callable[[AttributeContext], MypyType]]:
-        if fullname == '__main__.Cls.attr':
+    def get_class_attribute_hook(
+        self, fullname: str
+    ) -> Callable[[AttributeContext], MypyType] | None:
+        if fullname == "__main__.Cls.attr":
             return my_hook
         return None
 
 
 def my_hook(ctx: AttributeContext) -> MypyType:
-    return ctx.api.named_generic_type('builtins.int', [])
+    return ctx.api.named_generic_type("builtins.int", [])
 
 
-def plugin(_version: str):
+def plugin(_version: str) -> type[ClassAttrPlugin]:
     return ClassAttrPlugin
diff --git a/test-data/unit/plugins/class_callable.py b/test-data/unit/plugins/class_callable.py
index 07f75ec80ac1..9fab30e60458 100644
--- a/test-data/unit/plugins/class_callable.py
+++ b/test-data/unit/plugins/class_callable.py
@@ -1,32 +1,43 @@
-from mypy.plugin import Plugin
+from __future__ import annotations
+
+from typing import Callable
+
 from mypy.nodes import NameExpr
-from mypy.types import UnionType, NoneType, Instance
+from mypy.plugin import FunctionContext, Plugin
+from mypy.types import Instance, NoneType, Type, UnionType, get_proper_type
+
 
 class AttrPlugin(Plugin):
-    def get_function_hook(self, fullname):
-        if fullname.startswith('mod.Attr'):
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
+        if fullname.startswith("mod.Attr"):
             return attr_hook
         return None
 
-def attr_hook(ctx):
-    assert isinstance(ctx.default_return_type, Instance)
-    if ctx.default_return_type.type.fullname == 'mod.Attr':
-        attr_base = ctx.default_return_type
+
+def attr_hook(ctx: FunctionContext) -> Type:
+    default = get_proper_type(ctx.default_return_type)
+    assert isinstance(default, Instance)
+    if default.type.fullname == "mod.Attr":
+        attr_base = default
     else:
         attr_base = None
-    for base in ctx.default_return_type.type.bases:
-        if base.type.fullname == 'mod.Attr':
+    for base in default.type.bases:
+        if base.type.fullname == "mod.Attr":
             attr_base = base
             break
     assert attr_base is not None
     last_arg_exprs = ctx.args[-1]
-    if any(isinstance(expr, NameExpr) and expr.name == 'True' for expr in last_arg_exprs):
+    if any(isinstance(expr, NameExpr) and expr.name == "True" for expr in last_arg_exprs):
         return attr_base
     assert len(attr_base.args) == 1
     arg_type = attr_base.args[0]
-    return Instance(attr_base.type, [UnionType([arg_type, NoneType()])],
-                    line=ctx.default_return_type.line,
-                    column=ctx.default_return_type.column)
+    return Instance(
+        attr_base.type,
+        [UnionType([arg_type, NoneType()])],
+        line=default.line,
+        column=default.column,
+    )
+
 
-def plugin(version):
+def plugin(version: str) -> type[AttrPlugin]:
     return AttrPlugin
diff --git a/test-data/unit/plugins/common_api_incremental.py b/test-data/unit/plugins/common_api_incremental.py
index 2dcd559777ec..b14b2f92073e 100644
--- a/test-data/unit/plugins/common_api_incremental.py
+++ b/test-data/unit/plugins/common_api_incremental.py
@@ -1,44 +1,48 @@
-from mypy.plugin import Plugin
-from mypy.nodes import (
-    ClassDef, Block, TypeInfo, SymbolTable, SymbolTableNode, MDEF, GDEF, Var
-)
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.nodes import GDEF, MDEF, Block, ClassDef, SymbolTable, SymbolTableNode, TypeInfo, Var
+from mypy.plugin import ClassDefContext, DynamicClassDefContext, Plugin
 
 
 class DynPlugin(Plugin):
-    def get_dynamic_class_hook(self, fullname):
-        if fullname == 'lib.declarative_base':
+    def get_dynamic_class_hook(
+        self, fullname: str
+    ) -> Callable[[DynamicClassDefContext], None] | None:
+        if fullname == "lib.declarative_base":
             return add_info_hook
         return None
 
-    def get_base_class_hook(self, fullname: str):
+    def get_base_class_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None:
         sym = self.lookup_fully_qualified(fullname)
         if sym and isinstance(sym.node, TypeInfo):
-            if sym.node.metadata.get('magic'):
+            if sym.node.metadata.get("magic"):
                 return add_magic_hook
         return None
 
 
-def add_info_hook(ctx) -> None:
+def add_info_hook(ctx: DynamicClassDefContext) -> None:
     class_def = ClassDef(ctx.name, Block([]))
     class_def.fullname = ctx.api.qualified_name(ctx.name)
 
     info = TypeInfo(SymbolTable(), class_def, ctx.api.cur_mod_id)
     class_def.info = info
-    obj = ctx.api.named_type('builtins.object')
+    obj = ctx.api.named_type("builtins.object", [])
     info.mro = [info, obj.type]
     info.bases = [obj]
     ctx.api.add_symbol_table_node(ctx.name, SymbolTableNode(GDEF, info))
-    info.metadata['magic'] = True
+    info.metadata["magic"] = {"value": True}
 
 
-def add_magic_hook(ctx) -> None:
+def add_magic_hook(ctx: ClassDefContext) -> None:
     info = ctx.cls.info
-    str_type = ctx.api.named_type_or_none('builtins.str', [])
+    str_type = ctx.api.named_type_or_none("builtins.str", [])
     assert str_type is not None
-    var = Var('__magic__', str_type)
+    var = Var("__magic__", str_type)
     var.info = info
-    info.names['__magic__'] = SymbolTableNode(MDEF, var)
+    info.names["__magic__"] = SymbolTableNode(MDEF, var)
 
 
-def plugin(version):
+def plugin(version: str) -> type[DynPlugin]:
     return DynPlugin
diff --git a/test-data/unit/plugins/config_data.py b/test-data/unit/plugins/config_data.py
index 059e036d5e32..9b828bc9ac0a 100644
--- a/test-data/unit/plugins/config_data.py
+++ b/test-data/unit/plugins/config_data.py
@@ -1,6 +1,7 @@
-import os
-import json
+from __future__ import annotations
 
+import json
+import os
 from typing import Any
 
 from mypy.plugin import Plugin, ReportConfigContext
@@ -8,11 +9,11 @@
 
 class ConfigDataPlugin(Plugin):
     def report_config_data(self, ctx: ReportConfigContext) -> Any:
-        path = os.path.join('tmp/test.json')
+        path = os.path.join("tmp/test.json")
         with open(path) as f:
             data = json.load(f)
         return data.get(ctx.id)
 
 
-def plugin(version):
+def plugin(version: str) -> type[ConfigDataPlugin]:
     return ConfigDataPlugin
diff --git a/test-data/unit/plugins/custom_errorcode.py b/test-data/unit/plugins/custom_errorcode.py
index 0e2209a32eca..0af87658e59f 100644
--- a/test-data/unit/plugins/custom_errorcode.py
+++ b/test-data/unit/plugins/custom_errorcode.py
@@ -1,20 +1,24 @@
+from __future__ import annotations
+
+from typing import Callable
+
 from mypy.errorcodes import ErrorCode
-from mypy.plugin import Plugin
-from mypy.types import AnyType, TypeOfAny
+from mypy.plugin import FunctionContext, Plugin
+from mypy.types import AnyType, Type, TypeOfAny
 
 CUSTOM_ERROR = ErrorCode(code="custom", description="", category="Custom")
 
 
 class CustomErrorCodePlugin(Plugin):
-    def get_function_hook(self, fullname):
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
         if fullname.endswith(".main"):
             return self.emit_error
         return None
 
-    def emit_error(self, ctx):
+    def emit_error(self, ctx: FunctionContext) -> Type:
         ctx.api.fail("Custom error", ctx.context, code=CUSTOM_ERROR)
         return AnyType(TypeOfAny.from_error)
 
 
-def plugin(version):
+def plugin(version: str) -> type[CustomErrorCodePlugin]:
     return CustomErrorCodePlugin
diff --git a/test-data/unit/plugins/customentry.py b/test-data/unit/plugins/customentry.py
index b3dacfd4cf44..1a7ed3348e12 100644
--- a/test-data/unit/plugins/customentry.py
+++ b/test-data/unit/plugins/customentry.py
@@ -1,14 +1,22 @@
-from mypy.plugin import Plugin
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import FunctionContext, Plugin
+from mypy.types import Type
+
 
 class MyPlugin(Plugin):
-    def get_function_hook(self, fullname):
-        if fullname == '__main__.f':
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
+        if fullname == "__main__.f":
             return my_hook
         assert fullname
         return None
 
-def my_hook(ctx):
-    return ctx.api.named_generic_type('builtins.int', [])
 
-def register(version):
+def my_hook(ctx: FunctionContext) -> Type:
+    return ctx.api.named_generic_type("builtins.int", [])
+
+
+def register(version: str) -> type[MyPlugin]:
     return MyPlugin
diff --git a/test-data/unit/plugins/customize_mro.py b/test-data/unit/plugins/customize_mro.py
index 0f2396d98965..3b13b2e9d998 100644
--- a/test-data/unit/plugins/customize_mro.py
+++ b/test-data/unit/plugins/customize_mro.py
@@ -1,10 +1,17 @@
-from mypy.plugin import Plugin
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import ClassDefContext, Plugin
+
 
 class DummyPlugin(Plugin):
-    def get_customize_class_mro_hook(self, fullname):
-        def analyze(classdef_ctx):
+    def get_customize_class_mro_hook(self, fullname: str) -> Callable[[ClassDefContext], None]:
+        def analyze(classdef_ctx: ClassDefContext) -> None:
             pass
+
         return analyze
 
-def plugin(version):
+
+def plugin(version: str) -> type[DummyPlugin]:
     return DummyPlugin
diff --git a/test-data/unit/plugins/decimal_to_int.py b/test-data/unit/plugins/decimal_to_int.py
index 94aa33ef6df1..2318b2367d33 100644
--- a/test-data/unit/plugins/decimal_to_int.py
+++ b/test-data/unit/plugins/decimal_to_int.py
@@ -1,14 +1,21 @@
-from mypy.plugin import Plugin
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import AnalyzeTypeContext, Plugin
+from mypy.types import Type
 
 
 class MyPlugin(Plugin):
-    def get_type_analyze_hook(self, fullname):
+    def get_type_analyze_hook(self, fullname: str) -> Callable[[AnalyzeTypeContext], Type] | None:
         if fullname in ("decimal.Decimal", "_decimal.Decimal"):
             return decimal_to_int_hook
         return None
 
-def plugin(version):
-    return MyPlugin
 
-def decimal_to_int_hook(ctx):
-    return ctx.api.named_type('builtins.int', [])
+def decimal_to_int_hook(ctx: AnalyzeTypeContext) -> Type:
+    return ctx.api.named_type("builtins.int", [])
+
+
+def plugin(version: str) -> type[MyPlugin]:
+    return MyPlugin
diff --git a/test-data/unit/plugins/depshook.py b/test-data/unit/plugins/depshook.py
index 76277f3cb82b..bb2460de1196 100644
--- a/test-data/unit/plugins/depshook.py
+++ b/test-data/unit/plugins/depshook.py
@@ -1,15 +1,15 @@
-from typing import List, Tuple
+from __future__ import annotations
 
-from mypy.plugin import Plugin
 from mypy.nodes import MypyFile
+from mypy.plugin import Plugin
 
 
 class DepsPlugin(Plugin):
-    def get_additional_deps(self, file: MypyFile) -> List[Tuple[int, str, int]]:
-        if file.fullname == '__main__':
-            return [(10, 'err', -1)]
+    def get_additional_deps(self, file: MypyFile) -> list[tuple[int, str, int]]:
+        if file.fullname == "__main__":
+            return [(10, "err", -1)]
         return []
 
 
-def plugin(version):
+def plugin(version: str) -> type[DepsPlugin]:
     return DepsPlugin
diff --git a/test-data/unit/plugins/descriptor.py b/test-data/unit/plugins/descriptor.py
index afbadcdfb671..d38853367906 100644
--- a/test-data/unit/plugins/descriptor.py
+++ b/test-data/unit/plugins/descriptor.py
@@ -1,28 +1,38 @@
-from mypy.plugin import Plugin
-from mypy.types import NoneType, CallableType
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import MethodContext, MethodSigContext, Plugin
+from mypy.types import CallableType, NoneType, Type, get_proper_type
 
 
 class DescriptorPlugin(Plugin):
-    def get_method_hook(self, fullname):
+    def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None:
         if fullname == "__main__.Desc.__get__":
             return get_hook
         return None
 
-    def get_method_signature_hook(self, fullname):
+    def get_method_signature_hook(
+        self, fullname: str
+    ) -> Callable[[MethodSigContext], CallableType] | None:
         if fullname == "__main__.Desc.__set__":
             return set_hook
         return None
 
 
-def get_hook(ctx):
-    if isinstance(ctx.arg_types[0][0], NoneType):
-        return ctx.api.named_type("builtins.str")
-    return ctx.api.named_type("builtins.int")
+def get_hook(ctx: MethodContext) -> Type:
+    arg = get_proper_type(ctx.arg_types[0][0])
+    if isinstance(arg, NoneType):
+        return ctx.api.named_generic_type("builtins.str", [])
+    return ctx.api.named_generic_type("builtins.int", [])
 
 
-def set_hook(ctx):
+def set_hook(ctx: MethodSigContext) -> CallableType:
     return CallableType(
-        [ctx.api.named_type("__main__.Cls"), ctx.api.named_type("builtins.int")],
+        [
+            ctx.api.named_generic_type("__main__.Cls", []),
+            ctx.api.named_generic_type("builtins.int", []),
+        ],
         ctx.default_signature.arg_kinds,
         ctx.default_signature.arg_names,
         ctx.default_signature.ret_type,
@@ -30,5 +40,5 @@ def set_hook(ctx):
     )
 
 
-def plugin(version):
+def plugin(version: str) -> type[DescriptorPlugin]:
     return DescriptorPlugin
diff --git a/test-data/unit/plugins/dyn_class.py b/test-data/unit/plugins/dyn_class.py
index 54bf377aa8ef..1471267b24ee 100644
--- a/test-data/unit/plugins/dyn_class.py
+++ b/test-data/unit/plugins/dyn_class.py
@@ -1,47 +1,57 @@
-from mypy.plugin import Plugin
-from mypy.nodes import (
-    ClassDef, Block, TypeInfo, SymbolTable, SymbolTableNode, GDEF, Var
-)
-from mypy.types import Instance
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.nodes import GDEF, Block, ClassDef, SymbolTable, SymbolTableNode, TypeInfo, Var
+from mypy.plugin import ClassDefContext, DynamicClassDefContext, Plugin
+from mypy.types import Instance, get_proper_type
+
+DECL_BASES: set[str] = set()
 
-DECL_BASES = set()
 
 class DynPlugin(Plugin):
-    def get_dynamic_class_hook(self, fullname):
-        if fullname == 'mod.declarative_base':
+    def get_dynamic_class_hook(
+        self, fullname: str
+    ) -> Callable[[DynamicClassDefContext], None] | None:
+        if fullname == "mod.declarative_base":
             return add_info_hook
         return None
 
-    def get_base_class_hook(self, fullname: str):
+    def get_base_class_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None:
         if fullname in DECL_BASES:
             return replace_col_hook
         return None
 
-def add_info_hook(ctx):
+
+def add_info_hook(ctx: DynamicClassDefContext) -> None:
     class_def = ClassDef(ctx.name, Block([]))
     class_def.fullname = ctx.api.qualified_name(ctx.name)
 
     info = TypeInfo(SymbolTable(), class_def, ctx.api.cur_mod_id)
     class_def.info = info
-    obj = ctx.api.named_type('builtins.object')
+    obj = ctx.api.named_type("builtins.object")
     info.mro = [info, obj.type]
     info.bases = [obj]
     ctx.api.add_symbol_table_node(ctx.name, SymbolTableNode(GDEF, info))
     DECL_BASES.add(class_def.fullname)
 
-def replace_col_hook(ctx):
+
+def replace_col_hook(ctx: ClassDefContext) -> None:
     info = ctx.cls.info
     for sym in info.names.values():
         node = sym.node
-        if isinstance(node, Var) and isinstance(node.type, Instance):
-            if node.type.type.fullname == 'mod.Column':
-                new_sym = ctx.api.lookup_fully_qualified_or_none('mod.Instr')
+        if isinstance(node, Var) and isinstance(
+            (node_type := get_proper_type(node.type)), Instance
+        ):
+            if node_type.type.fullname == "mod.Column":
+                new_sym = ctx.api.lookup_fully_qualified_or_none("mod.Instr")
                 if new_sym:
                     new_info = new_sym.node
                     assert isinstance(new_info, TypeInfo)
-                    node.type = Instance(new_info, node.type.args,
-                                         node.type.line,
-                                         node.type.column)
+                    node.type = Instance(
+                        new_info, node_type.args, node_type.line, node_type.column
+                    )
+
 
-def plugin(version):
+def plugin(version: str) -> type[DynPlugin]:
     return DynPlugin
diff --git a/test-data/unit/plugins/dyn_class_from_method.py b/test-data/unit/plugins/dyn_class_from_method.py
index 4c3904907750..2630b16be66e 100644
--- a/test-data/unit/plugins/dyn_class_from_method.py
+++ b/test-data/unit/plugins/dyn_class_from_method.py
@@ -1,28 +1,76 @@
-from mypy.nodes import (Block, ClassDef, GDEF, SymbolTable, SymbolTableNode, TypeInfo)
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.nodes import (
+    GDEF,
+    Block,
+    ClassDef,
+    IndexExpr,
+    MemberExpr,
+    NameExpr,
+    RefExpr,
+    SymbolTable,
+    SymbolTableNode,
+    TypeApplication,
+    TypeInfo,
+)
 from mypy.plugin import DynamicClassDefContext, Plugin
 from mypy.types import Instance
 
 
 class DynPlugin(Plugin):
-    def get_dynamic_class_hook(self, fullname):
-        if 'from_queryset' in fullname:
+    def get_dynamic_class_hook(
+        self, fullname: str
+    ) -> Callable[[DynamicClassDefContext], None] | None:
+        if "from_queryset" in fullname:
             return add_info_hook
+        if "as_manager" in fullname:
+            return as_manager_hook
         return None
 
 
-def add_info_hook(ctx: DynamicClassDefContext):
+def add_info_hook(ctx: DynamicClassDefContext) -> None:
     class_def = ClassDef(ctx.name, Block([]))
     class_def.fullname = ctx.api.qualified_name(ctx.name)
 
     info = TypeInfo(SymbolTable(), class_def, ctx.api.cur_mod_id)
     class_def.info = info
+    assert isinstance(ctx.call.args[0], RefExpr)
     queryset_type_fullname = ctx.call.args[0].fullname
-    queryset_info = ctx.api.lookup_fully_qualified_or_none(queryset_type_fullname).node  # type: TypeInfo
-    obj = ctx.api.named_type('builtins.object')
+    queryset_node = ctx.api.lookup_fully_qualified_or_none(queryset_type_fullname)
+    assert queryset_node is not None
+    queryset_info = queryset_node.node
+    assert isinstance(queryset_info, TypeInfo)
+    obj = ctx.api.named_type("builtins.object")
     info.mro = [info, queryset_info, obj.type]
     info.bases = [Instance(queryset_info, [])]
     ctx.api.add_symbol_table_node(ctx.name, SymbolTableNode(GDEF, info))
 
 
-def plugin(version):
+def as_manager_hook(ctx: DynamicClassDefContext) -> None:
+    class_def = ClassDef(ctx.name, Block([]))
+    class_def.fullname = ctx.api.qualified_name(ctx.name)
+
+    info = TypeInfo(SymbolTable(), class_def, ctx.api.cur_mod_id)
+    class_def.info = info
+    assert isinstance(ctx.call.callee, MemberExpr)
+    assert isinstance(ctx.call.callee.expr, IndexExpr)
+    assert isinstance(ctx.call.callee.expr.analyzed, TypeApplication)
+    assert isinstance(ctx.call.callee.expr.analyzed.expr, NameExpr)
+
+    queryset_type_fullname = ctx.call.callee.expr.analyzed.expr.fullname
+    queryset_node = ctx.api.lookup_fully_qualified_or_none(queryset_type_fullname)
+    assert queryset_node is not None
+    queryset_info = queryset_node.node
+    assert isinstance(queryset_info, TypeInfo)
+    parameter_type = ctx.call.callee.expr.analyzed.types[0]
+
+    obj = ctx.api.named_type("builtins.object")
+    info.mro = [info, queryset_info, obj.type]
+    info.bases = [Instance(queryset_info, [parameter_type])]
+    ctx.api.add_symbol_table_node(ctx.name, SymbolTableNode(GDEF, info))
+
+
+def plugin(version: str) -> type[DynPlugin]:
     return DynPlugin
diff --git a/test-data/unit/plugins/fnplugin.py b/test-data/unit/plugins/fnplugin.py
index 684d6343458e..a5a7e57101c2 100644
--- a/test-data/unit/plugins/fnplugin.py
+++ b/test-data/unit/plugins/fnplugin.py
@@ -1,14 +1,22 @@
-from mypy.plugin import Plugin
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import FunctionContext, Plugin
+from mypy.types import Type
+
 
 class MyPlugin(Plugin):
-    def get_function_hook(self, fullname):
-        if fullname == '__main__.f':
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
+        if fullname == "__main__.f":
             return my_hook
         assert fullname is not None
         return None
 
-def my_hook(ctx):
-    return ctx.api.named_generic_type('builtins.int', [])
 
-def plugin(version):
+def my_hook(ctx: FunctionContext) -> Type:
+    return ctx.api.named_generic_type("builtins.int", [])
+
+
+def plugin(version: str) -> type[MyPlugin]:
     return MyPlugin
diff --git a/test-data/unit/plugins/fully_qualified_test_hook.py b/test-data/unit/plugins/fully_qualified_test_hook.py
index 529cf25a1215..9230091bba1a 100644
--- a/test-data/unit/plugins/fully_qualified_test_hook.py
+++ b/test-data/unit/plugins/fully_qualified_test_hook.py
@@ -1,16 +1,28 @@
-from mypy.plugin import CallableType, MethodSigContext, Plugin
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import MethodSigContext, Plugin
+from mypy.types import CallableType
+
 
 class FullyQualifiedTestPlugin(Plugin):
-    def get_method_signature_hook(self, fullname):
+    def get_method_signature_hook(
+        self, fullname: str
+    ) -> Callable[[MethodSigContext], CallableType] | None:
         # Ensure that all names are fully qualified
-        if 'FullyQualifiedTest' in fullname:
-            assert fullname.startswith('__main__.') and not ' of ' in fullname, fullname
+        if "FullyQualifiedTest" in fullname:
+            assert fullname.startswith("__main__.") and " of " not in fullname, fullname
             return my_hook
 
         return None
 
+
 def my_hook(ctx: MethodSigContext) -> CallableType:
-    return ctx.default_signature.copy_modified(ret_type=ctx.api.named_generic_type('builtins.int', []))
+    return ctx.default_signature.copy_modified(
+        ret_type=ctx.api.named_generic_type("builtins.int", [])
+    )
+
 
-def plugin(version):
+def plugin(version: str) -> type[FullyQualifiedTestPlugin]:
     return FullyQualifiedTestPlugin
diff --git a/test-data/unit/plugins/function_sig_hook.py b/test-data/unit/plugins/function_sig_hook.py
index d83c7df26209..a8d3cf058062 100644
--- a/test-data/unit/plugins/function_sig_hook.py
+++ b/test-data/unit/plugins/function_sig_hook.py
@@ -1,26 +1,27 @@
-from mypy.plugin import CallableType, CheckerPluginInterface, FunctionSigContext, Plugin
-from mypy.types import Instance, Type
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import FunctionSigContext, Plugin
+from mypy.types import CallableType
+
 
 class FunctionSigPlugin(Plugin):
-    def get_function_signature_hook(self, fullname):
-        if fullname == '__main__.dynamic_signature':
+    def get_function_signature_hook(
+        self, fullname: str
+    ) -> Callable[[FunctionSigContext], CallableType] | None:
+        if fullname == "__main__.dynamic_signature":
             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:
-    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),
-    )
+    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=[arg1_type], ret_type=arg1_type)
+
 
-def plugin(version):
+def plugin(version: str) -> type[FunctionSigPlugin]:
     return FunctionSigPlugin
diff --git a/test-data/unit/plugins/magic_method.py b/test-data/unit/plugins/magic_method.py
new file mode 100644
index 000000000000..fc220ab44748
--- /dev/null
+++ b/test-data/unit/plugins/magic_method.py
@@ -0,0 +1,24 @@
+from mypy.types import LiteralType, AnyType, TypeOfAny, Type
+from mypy.plugin import Plugin, MethodContext
+from typing import Callable, Optional
+
+# If radd exists, there shouldn't be an error. If it doesn't exist, then there will be an error
+def type_add(ctx: MethodContext) -> Type:
+    ctx.api.fail("fail", ctx.context)
+    return AnyType(TypeOfAny.from_error)
+
+def type_radd(ctx: MethodContext) -> Type:
+    return LiteralType(7, fallback=ctx.api.named_generic_type('builtins.int', []))
+
+
+class TestPlugin(Plugin):
+
+    def get_method_hook(self, fullname: str) -> Optional[Callable[[MethodContext], Type]]:
+        if fullname == 'builtins.int.__add__':
+            return type_add
+        if fullname == 'builtins.int.__radd__':
+            return type_radd
+        return None
+
+def plugin(version: str) -> type[TestPlugin]:
+    return TestPlugin
diff --git a/test-data/unit/plugins/method_in_decorator.py b/test-data/unit/plugins/method_in_decorator.py
index 99774dfcc7ef..3fba7692266c 100644
--- a/test-data/unit/plugins/method_in_decorator.py
+++ b/test-data/unit/plugins/method_in_decorator.py
@@ -1,19 +1,25 @@
-from mypy.types import CallableType, Type
-from typing import Callable, Optional
+from __future__ import annotations
+
+from typing import Callable
+
 from mypy.plugin import MethodContext, Plugin
+from mypy.types import CallableType, Type, get_proper_type
 
 
 class MethodDecoratorPlugin(Plugin):
-    def get_method_hook(self, fullname: str) -> Optional[Callable[[MethodContext], Type]]:
-        if 'Foo.a' in fullname:
+    def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None:
+        if "Foo.a" in fullname:
             return method_decorator_callback
         return None
 
+
 def method_decorator_callback(ctx: MethodContext) -> Type:
-    if isinstance(ctx.default_return_type, CallableType):
-        str_type = ctx.api.named_generic_type('builtins.str', [])
-        return ctx.default_return_type.copy_modified(ret_type=str_type)
+    default = get_proper_type(ctx.default_return_type)
+    if isinstance(default, CallableType):
+        str_type = ctx.api.named_generic_type("builtins.str", [])
+        return default.copy_modified(ret_type=str_type)
     return ctx.default_return_type
 
-def plugin(version):
+
+def plugin(version: str) -> type[MethodDecoratorPlugin]:
     return MethodDecoratorPlugin
diff --git a/test-data/unit/plugins/method_sig_hook.py b/test-data/unit/plugins/method_sig_hook.py
index 25c2842e6620..b78831cc45d5 100644
--- a/test-data/unit/plugins/method_sig_hook.py
+++ b/test-data/unit/plugins/method_sig_hook.py
@@ -1,30 +1,41 @@
-from mypy.plugin import CallableType, CheckerPluginInterface, MethodSigContext, Plugin
-from mypy.types import Instance, Type
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import CheckerPluginInterface, MethodSigContext, Plugin
+from mypy.types import CallableType, Instance, Type, get_proper_type
+
 
 class MethodSigPlugin(Plugin):
-    def get_method_signature_hook(self, fullname):
+    def get_method_signature_hook(
+        self, fullname: str
+    ) -> Callable[[MethodSigContext], CallableType] | None:
         # Ensure that all names are fully qualified
-        assert not fullname.endswith(' of Foo')
+        assert not fullname.endswith(" of Foo")
 
-        if fullname.startswith('__main__.Foo.'):
+        if fullname.startswith("__main__.Foo."):
             return my_hook
 
         return None
 
+
 def _str_to_int(api: CheckerPluginInterface, typ: Type) -> Type:
+    typ = get_proper_type(typ)
     if isinstance(typ, Instance):
-        if typ.type.fullname == 'builtins.str':
-            return api.named_generic_type('builtins.int', [])
+        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: MethodSigContext) -> CallableType:
     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),
     )
 
-def plugin(version):
+
+def plugin(version: str) -> type[MethodSigPlugin]:
     return MethodSigPlugin
diff --git a/test-data/unit/plugins/named_callable.py b/test-data/unit/plugins/named_callable.py
index e40d181d2bad..c37e11c32125 100644
--- a/test-data/unit/plugins/named_callable.py
+++ b/test-data/unit/plugins/named_callable.py
@@ -1,28 +1,33 @@
-from mypy.plugin import Plugin
-from mypy.types import CallableType
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import FunctionContext, Plugin
+from mypy.types import CallableType, Type, get_proper_type
 
 
 class MyPlugin(Plugin):
-    def get_function_hook(self, fullname):
-        if fullname == 'm.decorator1':
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
+        if fullname == "m.decorator1":
             return decorator_call_hook
-        if fullname == 'm._decorated':  # This is a dummy name generated by the plugin
+        if fullname == "m._decorated":  # This is a dummy name generated by the plugin
             return decorate_hook
         return None
 
 
-def decorator_call_hook(ctx):
-    if isinstance(ctx.default_return_type, CallableType):
-        return ctx.default_return_type.copy_modified(name='m._decorated')
+def decorator_call_hook(ctx: FunctionContext) -> Type:
+    default = get_proper_type(ctx.default_return_type)
+    if isinstance(default, CallableType):
+        return default.copy_modified(name="m._decorated")
     return ctx.default_return_type
 
 
-def decorate_hook(ctx):
-    if isinstance(ctx.default_return_type, CallableType):
-        return ctx.default_return_type.copy_modified(
-            ret_type=ctx.api.named_generic_type('builtins.str', []))
+def decorate_hook(ctx: FunctionContext) -> Type:
+    default = get_proper_type(ctx.default_return_type)
+    if isinstance(default, CallableType):
+        return default.copy_modified(ret_type=ctx.api.named_generic_type("builtins.str", []))
     return ctx.default_return_type
 
 
-def plugin(version):
+def plugin(version: str) -> type[MyPlugin]:
     return MyPlugin
diff --git a/test-data/unit/plugins/plugin2.py b/test-data/unit/plugins/plugin2.py
index b530a62d23aa..e486d96ea8bf 100644
--- a/test-data/unit/plugins/plugin2.py
+++ b/test-data/unit/plugins/plugin2.py
@@ -1,13 +1,21 @@
-from mypy.plugin import Plugin
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import FunctionContext, Plugin
+from mypy.types import Type
+
 
 class Plugin2(Plugin):
-    def get_function_hook(self, fullname):
-        if fullname in ('__main__.f', '__main__.g'):
+    def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
+        if fullname in ("__main__.f", "__main__.g"):
             return str_hook
         return None
 
-def str_hook(ctx):
-    return ctx.api.named_generic_type('builtins.str', [])
 
-def plugin(version):
+def str_hook(ctx: FunctionContext) -> Type:
+    return ctx.api.named_generic_type("builtins.str", [])
+
+
+def plugin(version: str) -> type[Plugin2]:
     return Plugin2
diff --git a/test-data/unit/plugins/type_anal_hook.py b/test-data/unit/plugins/type_anal_hook.py
index 86d18d8c8611..c380bbe873fe 100644
--- a/test-data/unit/plugins/type_anal_hook.py
+++ b/test-data/unit/plugins/type_anal_hook.py
@@ -1,22 +1,23 @@
-from typing import Optional, Callable
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import AnalyzeTypeContext, Plugin
 
-from mypy.plugin import Plugin, AnalyzeTypeContext
-from mypy.types import Type, TypeList, AnyType, CallableType, TypeOfAny
 # The official name changed to NoneType but we have an alias for plugin compat reasons
 # so we'll keep testing that here.
-from mypy.types import NoneTyp
+from mypy.types import AnyType, CallableType, NoneTyp, Type, TypeList, TypeOfAny
+
 
 class TypeAnalyzePlugin(Plugin):
-    def get_type_analyze_hook(self, fullname: str
-                              ) -> Optional[Callable[[AnalyzeTypeContext], Type]]:
-        if fullname == 'm.Signal':
+    def get_type_analyze_hook(self, fullname: str) -> Callable[[AnalyzeTypeContext], Type] | None:
+        if fullname == "m.Signal":
             return signal_type_analyze_callback
         return None
 
 
 def signal_type_analyze_callback(ctx: AnalyzeTypeContext) -> Type:
-    if (len(ctx.type.args) != 1
-            or not isinstance(ctx.type.args[0], TypeList)):
+    if len(ctx.type.args) != 1 or not isinstance(ctx.type.args[0], TypeList):
         ctx.api.fail('Invalid "Signal" type (expected "Signal[[t, ...]]")', ctx.context)
         return AnyType(TypeOfAny.from_error)
 
@@ -27,13 +28,11 @@ def signal_type_analyze_callback(ctx: AnalyzeTypeContext) -> Type:
         return AnyType(TypeOfAny.from_error)  # Error generated elsewhere
     arg_types, arg_kinds, arg_names = analyzed
     arg_types = [ctx.api.analyze_type(arg) for arg in arg_types]
-    type_arg = CallableType(arg_types,
-                            arg_kinds,
-                            arg_names,
-                            NoneTyp(),
-                            ctx.api.named_type('builtins.function', []))
-    return ctx.api.named_type('m.Signal', [type_arg])
+    type_arg = CallableType(
+        arg_types, arg_kinds, arg_names, NoneTyp(), ctx.api.named_type("builtins.function", [])
+    )
+    return ctx.api.named_type("m.Signal", [type_arg])
 
 
-def plugin(version):
+def plugin(version: str) -> type[TypeAnalyzePlugin]:
     return TypeAnalyzePlugin
diff --git a/test-data/unit/plugins/union_method.py b/test-data/unit/plugins/union_method.py
index a7621553f6ad..7c62ffb8c0cc 100644
--- a/test-data/unit/plugins/union_method.py
+++ b/test-data/unit/plugins/union_method.py
@@ -1,34 +1,40 @@
-from mypy.plugin import (
-    CallableType, CheckerPluginInterface, MethodSigContext, MethodContext, Plugin
-)
-from mypy.types import Instance, Type
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import CheckerPluginInterface, MethodContext, MethodSigContext, Plugin
+from mypy.types import CallableType, Instance, Type, get_proper_type
 
 
 class MethodPlugin(Plugin):
-    def get_method_signature_hook(self, fullname):
-        if fullname.startswith('__main__.Foo.'):
+    def get_method_signature_hook(
+        self, fullname: str
+    ) -> Callable[[MethodSigContext], CallableType] | None:
+        if fullname.startswith("__main__.Foo."):
             return my_meth_sig_hook
         return None
 
-    def get_method_hook(self, fullname):
-        if fullname.startswith('__main__.Bar.'):
+    def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | None:
+        if fullname.startswith("__main__.Bar."):
             return my_meth_hook
         return None
 
 
 def _str_to_int(api: CheckerPluginInterface, typ: Type) -> Type:
+    typ = get_proper_type(typ)
     if isinstance(typ, Instance):
-        if typ.type.fullname == 'builtins.str':
-            return api.named_generic_type('builtins.int', [])
+        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 _float_to_int(api: CheckerPluginInterface, typ: Type) -> Type:
+    typ = get_proper_type(typ)
     if isinstance(typ, Instance):
-        if typ.type.fullname == 'builtins.float':
-            return api.named_generic_type('builtins.int', [])
+        if typ.type.fullname == "builtins.float":
+            return api.named_generic_type("builtins.int", [])
         elif typ.args:
             return typ.copy_modified(args=[_float_to_int(api, t) for t in typ.args])
     return typ
@@ -45,5 +51,5 @@ def my_meth_hook(ctx: MethodContext) -> Type:
     return _float_to_int(ctx.api, ctx.default_return_type)
 
 
-def plugin(version):
+def plugin(version: str) -> type[MethodPlugin]:
     return MethodPlugin
diff --git a/test-data/unit/pythoneval-asyncio.test b/test-data/unit/pythoneval-asyncio.test
index 556414cf3252..e1f0f861eef3 100644
--- a/test-data/unit/pythoneval-asyncio.test
+++ b/test-data/unit/pythoneval-asyncio.test
@@ -25,11 +25,7 @@ async def greet_every_two_seconds() -> None:
         print('After', n)
         n += 1
 
-loop = asyncio.get_event_loop()
-try:
-    loop.run_until_complete(greet_every_two_seconds())
-finally:
-    loop.close()
+asyncio.run(greet_every_two_seconds())
 [out]
 Prev 0
 After 0
@@ -56,9 +52,7 @@ async def print_sum(x: int, y: int) -> None:
     result = await compute(x, y)  # The type of result will be int (is extracted from Future[int]
     print("%s + %s = %s" % (x, y, result))
 
-loop = asyncio.get_event_loop()
-loop.run_until_complete(print_sum(1, 2))
-loop.close()
+asyncio.run(print_sum(1, 2))
 [out]
 Compute 1 + 2 ...
 1 + 2 = 3
@@ -72,12 +66,13 @@ async def slow_operation(future: 'Future[str]') -> None:
     await asyncio.sleep(0.01)
     future.set_result('Future is done!')
 
-loop = asyncio.get_event_loop()
-future = asyncio.Future()  # type: Future[str]
-asyncio.Task(slow_operation(future))
-loop.run_until_complete(future)
-print(future.result())
-loop.close()
+async def main() -> None:
+    future = asyncio.Future()  # type: Future[str]
+    asyncio.Task(slow_operation(future))
+    await future
+    print(future.result())
+
+asyncio.run(main())
 [out]
 Future is done!
 
@@ -95,10 +90,13 @@ def got_result(future: 'Future[str]') -> None:
     print(future.result())
     loop.stop()
 
-loop = asyncio.get_event_loop() # type: AbstractEventLoop
-future = asyncio.Future()  # type: Future[str]
-asyncio.Task(slow_operation(future))  # Here create a task with the function. (The Task need a Future[T] as first argument)
-future.add_done_callback(got_result)  # and assign the callback to the future
+async def main() -> None:
+    future = asyncio.Future()  # type: Future[str]
+    asyncio.Task(slow_operation(future))  # Here create a task with the function. (The Task need a Future[T] as first argument)
+    future.add_done_callback(got_result)  # and assign the callback to the future
+
+loop = asyncio.new_event_loop()  # type: AbstractEventLoop
+loop.run_until_complete(main())
 try:
     loop.run_forever()
 finally:
@@ -119,13 +117,14 @@ async def factorial(name, number) -> None:
         f *= i
     print("Task %s: factorial(%s) = %s" % (name, number, f))
 
-loop = asyncio.get_event_loop()
-tasks = [
-    asyncio.Task(factorial("A", 2)),
-    asyncio.Task(factorial("B", 3)),
-    asyncio.Task(factorial("C", 4))]
-loop.run_until_complete(asyncio.wait(tasks))
-loop.close()
+async def main() -> None:
+    tasks = [
+        asyncio.Task(factorial("A", 2)),
+        asyncio.Task(factorial("B", 3)),
+        asyncio.Task(factorial("C", 4))]
+    await asyncio.wait(tasks)
+
+asyncio.run(main())
 [out]
 Task A: Compute factorial(2)...
 Task B: Compute factorial(2)...
@@ -144,6 +143,8 @@ from typing import Any
 import asyncio
 from asyncio import Future
 
+future: Future[int]
+
 async def h4() -> int:
     x = await future
     return x
@@ -162,12 +163,14 @@ async def h() -> None:
     x = await h2()
     print("h: %s" % x)
 
-loop = asyncio.get_event_loop()
-future = asyncio.Future()  # type: Future[int]
-future.set_result(42)
-loop.run_until_complete(h())
-print("Outside %s" % future.result())
-loop.close()
+async def main() -> None:
+    global future
+    future = asyncio.Future()
+    future.set_result(42)
+    await h()
+    print("Outside %s" % future.result())
+
+asyncio.run(main())
 [out]
 h3: 42
 h2: 42
@@ -182,13 +185,13 @@ from asyncio import Future
 
 async def h4() -> "Future[int]":
     await asyncio.sleep(0.01)
-    f = asyncio.Future() #type: Future[int]
+    f = asyncio.Future()  # type: Future[int]
     return f
 
 async def h3() -> "Future[Future[int]]":
     x = await h4()
     x.set_result(42)
-    f = asyncio.Future() #type: Future[Future[int]]
+    f = asyncio.Future()  # type: Future[Future[int]]
     f.set_result(x)
     return f
 
@@ -205,9 +208,7 @@ async def h() -> None:
     print(normalize(y))
     print(normalize(x))
 
-loop = asyncio.get_event_loop()
-loop.run_until_complete(h())
-loop.close()
+asyncio.run(h())
 [out]
 Before
 42
@@ -221,6 +222,8 @@ from typing import Any
 import asyncio
 from asyncio import Future
 
+future: Future["A"]
+
 class A:
     def __init__(self, x: int) -> None:
         self.x = x
@@ -229,12 +232,14 @@ async def h() -> None:
     x = await future
     print("h: %s" % x.x)
 
-loop = asyncio.get_event_loop()
-future = asyncio.Future()  # type: Future[A]
-future.set_result(A(42))
-loop.run_until_complete(h())
-print("Outside %s" % future.result().x)
-loop.close()
+async def main() -> None:
+    global future
+    future = asyncio.Future()
+    future.set_result(A(42))
+    await h()
+    print("Outside %s" % future.result().x)
+
+asyncio.run(main())
 [out]
 h: 42
 Outside 42
@@ -255,13 +260,9 @@ async def test() -> None:
     await greet()
     x = await greet()  # Error
 
-loop = asyncio.get_event_loop()
-try:
-    loop.run_until_complete(test())
-finally:
-    loop.close()
+asyncio.run(test())
 [out]
-_program.py:11: error: Function does not return a value
+_program.py:11: error: Function does not return a value (it only ever returns None)
 
 [case testErrorReturnIsNotTheSameType]
 from typing import Any
@@ -277,10 +278,7 @@ async def print_sum(x: int, y: int) -> None:
     result = await compute(x, y)
     print("%s + %s = %s" % (x, y, result))
 
-loop = asyncio.get_event_loop()
-loop.run_until_complete(print_sum(1, 2))
-loop.close()
-
+asyncio.run(print_sum(1, 2))
 [out]
 _program.py:8: error: Incompatible return value type (got "str", expected "int")
 
@@ -293,12 +291,13 @@ async def slow_operation(future: 'Future[str]') -> None:
     await asyncio.sleep(1)
     future.set_result(42)  # Error
 
-loop = asyncio.get_event_loop()
-future = asyncio.Future()  # type: Future[str]
-asyncio.Task(slow_operation(future))
-loop.run_until_complete(future)
-print(future.result())
-loop.close()
+async def main() -> None:
+    future = asyncio.Future()  # type: Future[str]
+    asyncio.Task(slow_operation(future))
+    await future
+    print(future.result())
+
+asyncio.run(main())
 [out]
 _program.py:7: error: Argument 1 to "set_result" of "Future" has incompatible type "int"; expected "str"
 
@@ -312,12 +311,13 @@ async def slow_operation(future: 'Future[int]') -> None:
     await asyncio.sleep(1)
     future.set_result(42)
 
-loop = asyncio.get_event_loop()
-future = asyncio.Future()  # type: Future[str]
-asyncio.Task(slow_operation(future))  # Error
-loop.run_until_complete(future)
-print(future.result())
-loop.close()
+async def main() -> None:
+    future = asyncio.Future()  # type: Future[str]
+    asyncio.Task(slow_operation(future))  # Error
+    await future
+    print(future.result())
+
+asyncio.run(main())
 [out]
 _program.py:11: error: Argument 1 to "slow_operation" has incompatible type "Future[str]"; expected "Future[int]"
 
@@ -328,14 +328,15 @@ from asyncio import Future
 
 async def slow_operation(future: 'Future[int]') -> None:
     await asyncio.sleep(1)
-    future.set_result('42')  #Try to set an str as result to a Future[int]
-
-loop = asyncio.get_event_loop()
-future = asyncio.Future()  # type: Future[str]
-asyncio.Task(slow_operation(future))  # Error
-loop.run_until_complete(future)
-print(future.result())
-loop.close()
+    future.set_result('42')  # Try to set an str as result to a Future[int]
+
+async def main() -> None:
+    future = asyncio.Future()  # type: Future[str]
+    asyncio.Task(slow_operation(future))  # Error
+    await future
+    print(future.result())
+
+asyncio.run(main())
 [out]
 _program.py:7: error: Argument 1 to "set_result" of "Future" has incompatible type "str"; expected "int"
 _program.py:11: error: Argument 1 to "slow_operation" has incompatible type "Future[str]"; expected "Future[int]"
@@ -354,11 +355,13 @@ def got_result(future: 'Future[int]') -> None:
     print(future.result())
     loop.stop()
 
-loop = asyncio.get_event_loop() # type: AbstractEventLoop
-future = asyncio.Future()  # type: Future[str]
-asyncio.Task(slow_operation(future))
-future.add_done_callback(got_result)  # Error
+async def main() -> None:
+    future = asyncio.Future()  # type: Future[str]
+    asyncio.Task(slow_operation(future))
+    future.add_done_callback(got_result)  # Error
 
+loop = asyncio.new_event_loop()
+loop.run_until_complete(main())
 try:
     loop.run_forever()
 finally:
@@ -374,13 +377,13 @@ from asyncio import Future
 
 async def h4() -> Future[int]:
     await asyncio.sleep(1)
-    f = asyncio.Future() #type: Future[int]
+    f = asyncio.Future()  # type: Future[int]
     return f
 
 async def h3() -> Future[Future[Future[int]]]:
     x = await h4()
     x.set_result(42)
-    f = asyncio.Future() #type: Future[Future[int]]
+    f = asyncio.Future()  # type: Future[Future[int]]
     f.set_result(x)
     return f
 
@@ -393,9 +396,7 @@ async def h() -> None:
     print(y)
     print(x)
 
-loop = asyncio.get_event_loop()
-loop.run_until_complete(h())
-loop.close()
+asyncio.run(h())
 [out]
 _program.py:16: error: Incompatible return value type (got "Future[Future[int]]", expected "Future[Future[Future[int]]]")
 
@@ -407,13 +408,13 @@ from asyncio import Future
 
 async def h4() -> Future[int]:
     await asyncio.sleep(1)
-    f = asyncio.Future() #type: Future[int]
+    f = asyncio.Future()  # type: Future[int]
     return f
 
 async def h3() -> Future[int]:
     x = await h4()
     x.set_result(42)
-    f = asyncio.Future() #type: Future[Future[int]]
+    f = asyncio.Future()  # type: Future[Future[int]]
     f.set_result(x)
     return f
 
@@ -424,9 +425,7 @@ async def h() -> None:
     print(y)
     print(x)
 
-loop = asyncio.get_event_loop()
-loop.run_until_complete(h())
-loop.close()
+asyncio.run(h())
 [out]
 _program.py:16: error: Incompatible return value type (got "Future[Future[int]]", expected "Future[int]")
 _program.py:16: note: Maybe you forgot to use "await"?
@@ -437,6 +436,8 @@ from typing import Any
 import asyncio
 from asyncio import Future
 
+future: Future["A"]
+
 class A:
     def __init__(self, x: int) -> None:
         self.x = x
@@ -446,16 +447,18 @@ class B:
         self.x = x
 
 async def h() -> None:
-    x = await future # type: B # Error
+    x = await future  # type: B  # Error
     print("h: %s" % x.x)
 
-loop = asyncio.get_event_loop()
-future = asyncio.Future()  # type: Future[A]
-future.set_result(A(42))
-loop.run_until_complete(h())
-loop.close()
+async def main() -> None:
+    global future
+    future = asyncio.Future()
+    future.set_result(A(42))
+    await h()
+
+asyncio.run(main())
 [out]
-_program.py:15: error: Incompatible types in assignment (expression has type "A", variable has type "B")
+_program.py:17: error: Incompatible types in assignment (expression has type "A", variable has type "B")
 
 [case testForwardRefToBadAsyncShouldNotCrash_newsemanal]
 from typing import TypeVar
@@ -472,7 +475,7 @@ async def bad(arg: P) -> T:
     pass
 [out]
 _program.py:8: note: Revealed type is "def [T] (arg: P?) -> typing.Coroutine[Any, Any, T`-1]"
-_program.py:9: error: Value of type "Coroutine[Any, Any, <nothing>]" must be used
+_program.py:9: error: Value of type "Coroutine[Any, Any, Never]" must be used
 _program.py:9: note: Are you missing an await?
 _program.py:11: error: Variable "_testForwardRefToBadAsyncShouldNotCrash_newsemanal.P" is not valid as a type
 _program.py:11: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index 7108734102d1..0e0e2b1f344d 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -11,132 +11,97 @@ print('hello, world')
 [out]
 hello, world
 
-[case testReversed]
+[case testMiscStdlibFeatures]
+# Various legacy tests merged together to speed up test runtimes.
+
+def f(x: object) -> None: pass
+
+# testReversed
 from typing import Reversible
-class A(Reversible):
+class R(Reversible):
     def __iter__(self): return iter('oof')
     def __reversed__(self): return iter('foo')
-print(list(reversed(range(5))))
-print(list(reversed([1,2,3])))
-print(list(reversed('abc')))
-print(list(reversed(A())))
-[out]
--- Escape bracket at line beginning
-\[4, 3, 2, 1, 0]
-\[3, 2, 1]
-\['c', 'b', 'a']
-\['f', 'o', 'o']
-
-[case testIntAndFloatConversion]
+f(list(reversed(range(5))))
+f(list(reversed([1,2,3])))
+f(list(reversed('abc')))
+f(list(reversed(R())))
+
+# testIntAndFloatConversion
 from typing import SupportsInt, SupportsFloat
 class A(SupportsInt):
     def __int__(self): return 5
 class B(SupportsFloat):
     def __float__(self): return 1.2
-print(int(1))
-print(int(6.2))
-print(int('3'))
-print(int(b'4'))
-print(int(A()))
-print(float(-9))
-print(float(B()))
-[out]
-1
-6
-3
-4
-5
--9.0
-1.2
-
-[case testAbs]
+f(int(1))
+f(int(6.2))
+f(int('3'))
+f(int(b'4'))
+f(int(A()))
+f(float(-9))
+f(float(B()))
+
+# testAbs
 from typing import SupportsAbs
-class A(SupportsAbs[float]):
+class Ab(SupportsAbs[float]):
     def __abs__(self) -> float: return 5.5
 
-print(abs(-1))
-print(abs(-1.2))
-print(abs(A()))
-[out]
-1
-1.2
-5.5
-
-[case testAbs2]
-n = None  # type: int
-f = None  # type: float
-n = abs(1)
-abs(1) + 'x'  # Error
-f = abs(1.1)
-abs(1.1) + 'x'  # Error
-[out]
-_program.py:4: error: Unsupported operand types for + ("int" and "str")
-_program.py:6: error: Unsupported operand types for + ("float" and "str")
+f(abs(-1))
+f(abs(-1.2))
+f(abs(Ab()))
 
-[case testRound]
+# testRound
 from typing import SupportsRound
-class A(SupportsRound):
+class Ro(SupportsRound):
     def __round__(self, ndigits=0): return 'x%d' % ndigits
-print(round(1.6))
-print(round(A()))
-print(round(A(), 2))
-[out]
-2
-x0
-x2
+f(round(1.6))
+f(round(Ro()))
+f(round(Ro(), 2))
 
-[case testCallMethodViaTypeObject]
-import typing
-print(list.__add__([1, 2], [3, 4]))
-[out]
-\[1, 2, 3, 4]
+# testCallMethodViaTypeObject
+list.__add__([1, 2], [3, 4])
 
-[case testInheritedClassAttribute]
+# testInheritedClassAttribute
 import typing
-class A:
+class AA:
     x = 1
-    def f(self) -> None: print('f')
-class B(A):
+    def f(self: typing.Optional["AA"]) -> None: pass
+class BB(AA):
     pass
-B.f(None)
-print(B.x)
-[out]
-f
-1
-
-[case testModuleAttributes]
-import math
-import typing
-print(math.__name__)
-print(type(math.__dict__))
-print(type(math.__doc__ or ''))
-print(math.__class__)
-[out]
-math
-<class 'dict'>
-<class 'str'>
-<class 'module'>
+BB.f(None)
+f(BB.x)
 
-[case testSpecialAttributes]
-import typing
-class A:
+# testSpecialAttributes
+class Doc:
     """A docstring!"""
-print(A().__doc__)
-print(A().__class__)
-[out]
-A docstring!
-<class '__main__.A'>
+f(Doc().__doc__)
+f(Doc().__class__)
 
-[case testFunctionAttributes]
-import typing
-ord.__class__
-print(type(ord.__doc__ + ''))
-print(ord.__name__)
-print(ord.__module__)
+# testFunctionAttributes
+f(ord.__class__)
+f(type(ord.__doc__ or '' + ''))
+f(ord.__name__)
+f(ord.__module__)
+
+# testModuleAttributes
+import math
+f(type(__spec__))
+f(math.__name__)
+f(math.__spec__.name)
+f(type(math.__dict__))
+f(type(math.__doc__ or ''))
+f(type(math.__spec__).__name__)
+f(math.__class__)
+
+[case testAbs2]
+n: int
+f: float
+n = abs(1)
+abs(1) + 'x'  # Error
+f = abs(1.1)
+abs(1.1) + 'x'  # Error
 [out]
-<class 'str'>
-ord
-builtins
+_program.py:4: error: Unsupported operand types for + ("int" and "str")
+_program.py:6: error: Unsupported operand types for + ("float" and "str")
 
 [case testTypeAttributes]
 import typing
@@ -268,10 +233,8 @@ def bin(f: IO[bytes]) -> None:
 txt(sys.stdout)
 bin(sys.stdout)
 [out]
-_program.py:5: error: No overload variant of "write" of "IO" matches argument type "bytes"
-_program.py:5: note: Possible overload variants:
-_program.py:5: note:     def write(self, str, /) -> int
-_program.py:10: error: Argument 1 to "bin" has incompatible type "TextIO"; expected "IO[bytes]"
+_program.py:5: error: Argument 1 to "write" of "IO" has incompatible type "bytes"; expected "str"
+_program.py:10: error: Argument 1 to "bin" has incompatible type "Union[TextIO, Any]"; expected "IO[bytes]"
 
 [case testBuiltinOpen]
 f = open('x')
@@ -279,8 +242,8 @@ f.write('x')
 f.write(b'x')
 f.foobar()
 [out]
-_program.py:3: error: Argument 1 to "write" of "TextIOBase" has incompatible type "bytes"; expected "str"
-_program.py:4: error: "TextIOWrapper" has no attribute "foobar"
+_program.py:3: error: Argument 1 to "write" of "_TextIOBase" has incompatible type "bytes"; expected "str"
+_program.py:4: error: "TextIOWrapper[_WrappedBuffer]" has no attribute "foobar"
 
 [case testOpenReturnTypeInference]
 reveal_type(open('x'))
@@ -289,9 +252,9 @@ reveal_type(open('x', 'rb'))
 mode = 'rb'
 reveal_type(open('x', mode))
 [out]
-_program.py:1: note: Revealed type is "io.TextIOWrapper"
-_program.py:2: note: Revealed type is "io.TextIOWrapper"
-_program.py:3: note: Revealed type is "io.BufferedReader"
+_program.py:1: note: Revealed type is "_io.TextIOWrapper[_io._WrappedBuffer]"
+_program.py:2: note: Revealed type is "_io.TextIOWrapper[_io._WrappedBuffer]"
+_program.py:3: note: Revealed type is "_io.BufferedReader"
 _program.py:5: note: Revealed type is "typing.IO[Any]"
 
 [case testOpenReturnTypeInferenceSpecialCases]
@@ -300,8 +263,8 @@ reveal_type(open(file='x', mode='rb'))
 mode = 'rb'
 reveal_type(open(mode=mode, file='r'))
 [out]
-_testOpenReturnTypeInferenceSpecialCases.py:1: note: Revealed type is "io.BufferedReader"
-_testOpenReturnTypeInferenceSpecialCases.py:2: note: Revealed type is "io.BufferedReader"
+_testOpenReturnTypeInferenceSpecialCases.py:1: note: Revealed type is "_io.BufferedReader"
+_testOpenReturnTypeInferenceSpecialCases.py:2: note: Revealed type is "_io.BufferedReader"
 _testOpenReturnTypeInferenceSpecialCases.py:4: note: Revealed type is "typing.IO[Any]"
 
 [case testPathOpenReturnTypeInference]
@@ -313,9 +276,9 @@ reveal_type(p.open('rb'))
 mode = 'rb'
 reveal_type(p.open(mode))
 [out]
-_program.py:3: note: Revealed type is "io.TextIOWrapper"
-_program.py:4: note: Revealed type is "io.TextIOWrapper"
-_program.py:5: note: Revealed type is "io.BufferedReader"
+_program.py:3: note: Revealed type is "_io.TextIOWrapper[_io._WrappedBuffer]"
+_program.py:4: note: Revealed type is "_io.TextIOWrapper[_io._WrappedBuffer]"
+_program.py:5: note: Revealed type is "_io.BufferedReader"
 _program.py:7: note: Revealed type is "typing.IO[Any]"
 
 [case testPathOpenReturnTypeInferenceSpecialCases]
@@ -326,32 +289,35 @@ reveal_type(p.open(errors='replace', mode='r'))
 mode = 'r'
 reveal_type(p.open(mode=mode, errors='replace'))
 [out]
-_program.py:3: note: Revealed type is "io.TextIOWrapper"
-_program.py:4: note: Revealed type is "io.TextIOWrapper"
+_program.py:3: note: Revealed type is "_io.TextIOWrapper[_io._WrappedBuffer]"
+_program.py:4: note: Revealed type is "_io.TextIOWrapper[_io._WrappedBuffer]"
 _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 +340,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,21 +399,20 @@ True
 False
 
 [case testOverlappingOperatorMethods]
-
 class X: pass
 class A:
-    def __add__(self, x) -> int:
+    def __add__(self, x: object) -> int:
         if isinstance(x, X):
             return 1
         return NotImplemented
 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
@@ -833,6 +797,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,35 +823,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"
-
-[case testNoSubcriptionOfStdlibCollections]
-# flags: --python-version 3.6
-import collections
-from collections import Counter
-from typing import TypeVar
-
-collections.defaultdict[int, str]()
-Counter[int]()
-
-T = TypeVar('T')
-DDint = collections.defaultdict[T, int]
-
-d = DDint[str]()
-d[0] = 1
-
-def f(d: collections.defaultdict[int, str]) -> None:
-    ...
-[out]
-_program.py:6: error: "defaultdict" is not subscriptable
-_program.py:7: error: "Counter" is not subscriptable
-_program.py:10: error: "defaultdict" is not subscriptable
-_program.py:13: error: Invalid index type "int" for "defaultdict[str, int]"; expected type "str"
-_program.py:15: error: "defaultdict" is not subscriptable, use "typing.DefaultDict" instead
+_program.py:7: error: Argument 1 to "defaultdict" has incompatible type "Type[List[_T]]"; 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[Never]]"; expected "defaultdict[int, List[Never]]"
+_program.py:24: error: Invalid index type "str" for "MyDDict[Dict[Never, Never]]"; expected type "int"
 
 [case testCollectionsAliases]
 import typing as t
@@ -965,14 +906,14 @@ 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]
-from abc import abstractproperty, ABCMeta
+from abc import abstractproperty, ABCMeta  # type: ignore[deprecated]
 class A(metaclass=ABCMeta):
     @abstractproperty
     def x(self) -> int: pass
@@ -1001,9 +942,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:
@@ -1016,11 +961,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
@@ -1028,9 +973,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:
@@ -1043,11 +992,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
@@ -1077,15 +1026,14 @@ reveal_type(g)
 with f('') as s:
     reveal_type(s)
 [out]
-_program.py:13: note: Revealed type is "def (x: builtins.int) -> contextlib._GeneratorContextManager[builtins.str]"
-_program.py:14: note: Revealed type is "def (*x: builtins.str) -> contextlib._GeneratorContextManager[builtins.int]"
+_program.py:13: note: Revealed type is "def (x: builtins.int) -> contextlib._GeneratorContextManager[builtins.str, None, None]"
+_program.py:14: note: Revealed type is "def (*x: builtins.str) -> contextlib._GeneratorContextManager[builtins.int, None, None]"
 _program.py:16: error: Argument 1 to "f" has incompatible type "str"; expected "int"
 _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
+from typing import TypedDict
 class A: pass
 D = TypedDict('D', {'x': int, 'y': str})
 d: D
@@ -1096,17 +1044,17 @@ 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
+from typing import TypedDict
 Cell = TypedDict('Cell', {'value': int})
 c = Cell(value=42)
 for x in c:
@@ -1142,16 +1090,15 @@ _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]
 
 [case testCanConvertTypedDictToAnySuperclassOfMapping]
-from mypy_extensions import TypedDict
-from typing import Sized, Iterable, Container
+from typing import Sized, TypedDict, Iterable, Container
 
 Point = TypedDict('Point', {'x': int, 'y': int})
 
@@ -1162,12 +1109,12 @@ c: Container[str] = p
 o: object = p
 it2: Iterable[int] = p
 [out]
-_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: error: Incompatible types in assignment (expression has type "Point", variable has type "Iterable[int]")
-_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: note: Following member(s) of "Point" have conflicts:
-_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: note:     Expected:
-_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: note:         def __iter__(self) -> Iterator[int]
-_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: note:     Got:
-_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: note:         def __iter__(self) -> Iterator[str]
+_testCanConvertTypedDictToAnySuperclassOfMapping.py:10: error: Incompatible types in assignment (expression has type "Point", variable has type "Iterable[int]")
+_testCanConvertTypedDictToAnySuperclassOfMapping.py:10: note: Following member(s) of "Point" have conflicts:
+_testCanConvertTypedDictToAnySuperclassOfMapping.py:10: note:     Expected:
+_testCanConvertTypedDictToAnySuperclassOfMapping.py:10: note:         def __iter__(self) -> Iterator[int]
+_testCanConvertTypedDictToAnySuperclassOfMapping.py:10: note:     Got:
+_testCanConvertTypedDictToAnySuperclassOfMapping.py:10: note:         def __iter__(self) -> Iterator[str]
 
 [case testAsyncioGatherPreciseType-xfail]
 # Mysteriously regressed in #11905
@@ -1373,7 +1320,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)
@@ -1432,7 +1379,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"
@@ -1473,14 +1420,12 @@ frozenset({1}) == [1]  # Error
 {1: 2}.keys() == frozenset({1})
 {1: 2}.items() == {(1, 2)}
 
-{1: 2}.keys() == {'no'}  # Error
+{1: 2}.keys() == {'no'}  # OK
 {1: 2}.values() == {2}  # Error
-{1: 2}.keys() == [1]  # Error
+{1: 2}.keys() == [1]  # OK
 [out]
 _testStrictEqualityAllowlist.py:5: error: Non-overlapping equality check (left operand type: "FrozenSet[int]", right operand type: "List[int]")
-_testStrictEqualityAllowlist.py:11: error: Non-overlapping equality check (left operand type: "dict_keys[int, int]", right operand type: "Set[str]")
 _testStrictEqualityAllowlist.py:12: error: Non-overlapping equality check (left operand type: "dict_values[int, int]", right operand type: "Set[int]")
-_testStrictEqualityAllowlist.py:13: error: Non-overlapping equality check (left operand type: "dict_keys[int, int]", right operand type: "List[int]")
 
 [case testUnreachableWithStdlibContextManagers]
 # mypy: warn-unreachable, strict-optional
@@ -1561,34 +1506,33 @@ note: A user-defined top-level module with name "typing" is not supported
 # flags: --ignore-missing-imports
 import scribe  # No Python 3 stubs available for scribe
 from scribe import x
-import maxminddb  # Python 3 stubs available for maxminddb
+import pytz  # Python 3 stubs available for pytz
 import foobar_asdf
 import jack  # This has a stubs package but was never bundled with mypy, so ignoring works
 [out]
-_testIgnoreImportIfNoPython3StubAvailable.py:4: error: Library stubs not installed for "maxminddb"
-_testIgnoreImportIfNoPython3StubAvailable.py:4: note: Hint: "python3 -m pip install types-maxminddb"
+_testIgnoreImportIfNoPython3StubAvailable.py:4: error: Library stubs not installed for "pytz"
+_testIgnoreImportIfNoPython3StubAvailable.py:4: note: Hint: "python3 -m pip install types-pytz"
 _testIgnoreImportIfNoPython3StubAvailable.py:4: note: (or run "mypy --install-types" to install all missing stub packages)
 _testIgnoreImportIfNoPython3StubAvailable.py:4: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
 
 [case testNoPython3StubAvailable]
 import scribe
 from scribe import x
-import maxminddb
+import pytz
 [out]
 _testNoPython3StubAvailable.py:1: error: Cannot find implementation or library stub for module named "scribe"
 _testNoPython3StubAvailable.py:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
-_testNoPython3StubAvailable.py:3: error: Library stubs not installed for "maxminddb"
-_testNoPython3StubAvailable.py:3: note: Hint: "python3 -m pip install types-maxminddb"
+_testNoPython3StubAvailable.py:3: error: Library stubs not installed for "pytz"
+_testNoPython3StubAvailable.py:3: note: Hint: "python3 -m pip install types-pytz"
 _testNoPython3StubAvailable.py:3: note: (or run "mypy --install-types" to install all missing stub packages)
 
 
 [case testTypingOrderedDictAlias]
-# flags: --python-version 3.7
 from typing import OrderedDict
 x: OrderedDict[str, int] = OrderedDict({})
 reveal_type(x)
 [out]
-_testTypingOrderedDictAlias.py:4: note: Revealed type is "collections.OrderedDict[builtins.str, builtins.int]"
+_testTypingOrderedDictAlias.py:3: note: Revealed type is "collections.OrderedDict[builtins.str, builtins.int]"
 
 [case testTypingExtensionsOrderedDictAlias]
 from typing_extensions import OrderedDict
@@ -1610,18 +1554,6 @@ if isinstance(obj, Awaitable):
 _testSpecialTypingProtocols.py:6: note: Revealed type is "Tuple[builtins.int]"
 _testSpecialTypingProtocols.py:8: error: Statement is unreachable
 
-[case testEnumValueWithPlaceholderNodeType]
-# https://github.com/python/mypy/issues/11971
-from enum import Enum
-from typing import Callable, Dict
-class Foo(Enum):
-    Bar: Foo = Callable[[str], None]
-    Baz: Foo = Callable[[Dict[str, "Missing"]], None]
-[out]
-_testEnumValueWithPlaceholderNodeType.py:5: error: Incompatible types in assignment (expression has type "object", variable has type "Foo")
-_testEnumValueWithPlaceholderNodeType.py:6: error: Incompatible types in assignment (expression has type "object", variable has type "Foo")
-_testEnumValueWithPlaceholderNodeType.py:6: error: Name "Missing" is not defined
-
 [case testTypeshedRecursiveTypesExample]
 from typing import List, Union
 
@@ -1640,7 +1572,6 @@ foo(list((list(""), "")))
 [out]
 
 [case testNarrowTypeForDictKeys]
-# flags: --strict-optional
 from typing import Dict, KeysView, Optional
 
 d: Dict[str, int]
@@ -1658,10 +1589,10 @@ else:
     reveal_type(k)
 
 [out]
-_testNarrowTypeForDictKeys.py:7: note: Revealed type is "builtins.str"
-_testNarrowTypeForDictKeys.py:9: note: Revealed type is "Union[builtins.str, None]"
-_testNarrowTypeForDictKeys.py:14: note: Revealed type is "builtins.str"
-_testNarrowTypeForDictKeys.py:16: note: Revealed type is "Union[builtins.str, None]"
+_testNarrowTypeForDictKeys.py:6: note: Revealed type is "builtins.str"
+_testNarrowTypeForDictKeys.py:8: note: Revealed type is "Union[builtins.str, None]"
+_testNarrowTypeForDictKeys.py:13: note: Revealed type is "builtins.str"
+_testNarrowTypeForDictKeys.py:15: note: Revealed type is "Union[builtins.str, None]"
 
 [case testTypeAliasWithNewStyleUnion]
 # flags: --python-version 3.10
@@ -1705,7 +1636,6 @@ _testTypeAliasWithNewStyleUnion.py:25: note: Revealed type is "Union[Type[builti
 _testTypeAliasWithNewStyleUnion.py:28: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
 
 [case testTypeAliasWithNewStyleUnionInStub]
-# flags: --python-version 3.7
 import m
 a: m.A
 reveal_type(a)
@@ -1721,8 +1651,8 @@ f: m.F
 reveal_type(f)
 
 [file m.pyi]
-from typing import Type, Callable
-from typing_extensions import Literal, TypeAlias
+from typing import Type, Callable, Literal
+from typing_extensions import TypeAlias
 
 Foo = Literal[1, 2]
 reveal_type(Foo)
@@ -1756,12 +1686,12 @@ CU4: TypeAlias = int | Callable[[str | bool], str]
 [out]
 m.pyi:5: note: Revealed type is "typing._SpecialForm"
 m.pyi:22: note: Revealed type is "typing._SpecialForm"
-_testTypeAliasWithNewStyleUnionInStub.py:4: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
-_testTypeAliasWithNewStyleUnionInStub.py:6: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
-_testTypeAliasWithNewStyleUnionInStub.py:8: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
-_testTypeAliasWithNewStyleUnionInStub.py:10: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
-_testTypeAliasWithNewStyleUnionInStub.py:12: note: Revealed type is "Union[builtins.str, Type[builtins.int]]"
-_testTypeAliasWithNewStyleUnionInStub.py:14: note: Revealed type is "Union[builtins.str, Type[builtins.int]]"
+_testTypeAliasWithNewStyleUnionInStub.py:3: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
+_testTypeAliasWithNewStyleUnionInStub.py:5: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
+_testTypeAliasWithNewStyleUnionInStub.py:7: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
+_testTypeAliasWithNewStyleUnionInStub.py:9: note: Revealed type is "Union[Type[builtins.int], builtins.str]"
+_testTypeAliasWithNewStyleUnionInStub.py:11: note: Revealed type is "Union[builtins.str, Type[builtins.int]]"
+_testTypeAliasWithNewStyleUnionInStub.py:13: note: Revealed type is "Union[builtins.str, Type[builtins.int]]"
 
 [case testEnumNameWorkCorrectlyOn311]
 # flags: --python-version 3.11
@@ -1795,9 +1725,9 @@ C = str | int
 D: TypeAlias = str | int
 [out]
 _testTypeAliasNotSupportedWithNewStyleUnion.py:3: error: Invalid type alias: expression is not a valid type
-_testTypeAliasNotSupportedWithNewStyleUnion.py:3: error: Value of type "Type[type]" is not indexable
+_testTypeAliasNotSupportedWithNewStyleUnion.py:3: error: Unsupported left operand type for | ("GenericAlias")
 _testTypeAliasNotSupportedWithNewStyleUnion.py:4: error: Invalid type alias: expression is not a valid type
-_testTypeAliasNotSupportedWithNewStyleUnion.py:4: error: Value of type "Type[type]" is not indexable
+_testTypeAliasNotSupportedWithNewStyleUnion.py:4: error: Unsupported left operand type for | ("Type[str]")
 _testTypeAliasNotSupportedWithNewStyleUnion.py:5: error: Invalid type alias: expression is not a valid type
 _testTypeAliasNotSupportedWithNewStyleUnion.py:5: error: Unsupported left operand type for | ("Type[str]")
 _testTypeAliasNotSupportedWithNewStyleUnion.py:6: error: Invalid type alias: expression is not a valid type
@@ -1848,7 +1778,6 @@ RHSAlias3: type = tuple[int, ...]
 WrongTypeElement = str | tuple[float, 1]  # Error
 WrongEllipsis = tuple[float, float, ...] | str  # Error
 
-# TODO: This should produce a fixed-length tuple
 reveal_type(tuple[int, str]((1, "x")))
 [out]
 _testTupleWithDifferentArgsPy310.py:15: note: Revealed type is "Union[builtins.str, Tuple[builtins.float, builtins.float, builtins.str]]"
@@ -1859,7 +1788,7 @@ _testTupleWithDifferentArgsPy310.py:19: note: Revealed type is "builtins.tuple[b
 _testTupleWithDifferentArgsPy310.py:20: note: Revealed type is "builtins.list[Tuple[builtins.int, builtins.str]]"
 _testTupleWithDifferentArgsPy310.py:26: error: Invalid type: try using Literal[1] instead?
 _testTupleWithDifferentArgsPy310.py:27: error: Unexpected "..."
-_testTupleWithDifferentArgsPy310.py:30: note: Revealed type is "builtins.tuple[builtins.object, ...]"
+_testTupleWithDifferentArgsPy310.py:29: note: Revealed type is "Tuple[builtins.int, builtins.str]"
 
 [case testEnumIterMetaInference]
 import socket
@@ -1957,13 +1886,13 @@ class Bar(Generic[P]): ...
 def bad(foo: Foo[[int]], bar: Bar[[int]]) -> bool:
     return foo == bar
 
-def good1(foo1: Foo[[int]], foo2: Foo[[str]]) -> bool:
+def bad1(foo1: Foo[[int]], foo2: Foo[[str]]) -> bool:
     return foo1 == foo2
 
-def good2(foo1: Foo[[int, str]], foo2: Foo[[int, bytes]]) -> bool:
+def bad2(foo1: Foo[[int, str]], foo2: Foo[[int, bytes]]) -> bool:
     return foo1 == foo2
 
-def good3(foo1: Foo[[int]], foo2: Foo[[int, int]]) -> bool:
+def bad3(foo1: Foo[[int]], foo2: Foo[[int, int]]) -> bool:
     return foo1 == foo2
 
 def good4(foo1: Foo[[int]], foo2: Foo[[int]]) -> bool:
@@ -1986,9 +1915,25 @@ 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]]")
+_testStrictEqualitywithParamSpec.py:14: error: Non-overlapping equality check (left operand type: "Foo[[int]]", right operand type: "Foo[[str]]")
+_testStrictEqualitywithParamSpec.py:17: error: Non-overlapping equality check (left operand type: "Foo[[int, str]]", right operand type: "Foo[[int, bytes]]")
+_testStrictEqualitywithParamSpec.py:20: error: Non-overlapping equality check (left operand type: "Foo[[int]]", right operand type: "Foo[[int, 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[Never, Never]", variable has type "MappingProxyType[str, Any]")
 
 [case testTypeVarTuple]
-# flags: --enable-incomplete-feature=TypeVarTuple --enable-incomplete-feature=Unpack --python-version=3.11
+# flags: --python-version=3.11
 from typing import Any, Callable, Unpack, TypeVarTuple
 
 Ts = TypeVarTuple("Ts")
@@ -2000,7 +1945,6 @@ def call(callback: Callable[[Unpack[Ts]], Any], *args: Unpack[Ts]) -> Any:
     ...
 
 [case testTypeVarTupleTypingExtensions]
-# flags: --enable-incomplete-feature=TypeVarTuple --enable-incomplete-feature=Unpack
 from typing_extensions import Unpack, TypeVarTuple
 from typing import Any, Callable
 
@@ -2011,3 +1955,238 @@ 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: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]
+
+[case testDataclassReplaceOptional]
+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: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]"
+
+[case testPEP695VarianceInference]
+# flags: --python-version=3.12
+from typing import Callable, Final
+
+class Job[_R_co]:
+    def __init__(self, target: Callable[[], _R_co]) -> None:
+        self.target: Final = target
+
+def func(
+    action: Job[int | None],
+    a1: Job[int | None],
+    a2: Job[int],
+    a3: Job[None],
+) -> None:
+    action = a1
+    action = a2
+    action = a3
+    a2 = action  # Error
+[out]
+_testPEP695VarianceInference.py:17: error: Incompatible types in assignment (expression has type "Job[None]", variable has type "Job[int]")
+
+[case testPEP695TypeAliasWithDifferentTargetTypes]
+# flags: --python-version=3.12
+from typing import Any, Callable, List, Literal, TypedDict, overload, TypeAlias, TypeVar, Never
+
+class C[T]: pass
+
+class O[T]:
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: int) -> None: ...
+    def __init__(self, x: int = 0) -> None:
+        pass
+
+class TD(TypedDict):
+    x: int
+
+S = TypeVar("S")
+A = list[S]
+B: TypeAlias = list[S]
+
+type A1 = type[int]
+type A2 = type[int] | None
+type A3 = None | type[int]
+type A4 = type[Any]
+type A5 = type[C] | None
+type A6 = None | type[C]
+type A7 = type[O] | None
+type A8 = None | type[O]
+
+type B1[**P, R] = Callable[P, R] | None
+type B2[**P, R] = None | Callable[P, R]
+type B3 = Callable[[str], int]
+type B4 = Callable[..., int]
+
+type C1 = A1 | None
+type C2 = None | A1
+
+type D1 = Any | None
+type D2 = None | Any
+
+type E1 = List[int]
+type E2 = List[int] | None
+type E3 = None | List[int]
+
+type F1 = Literal[1]
+type F2 = Literal['x'] | None
+type F3 = None | Literal[True]
+
+type G1 = tuple[int, Any]
+type G2 = tuple[int, Any] | None
+type G3 = None | tuple[int, Any]
+
+type H1 = TD
+type H2 = TD | None
+type H3 = None | TD
+
+type I1 = C[int]
+type I2 = C[Any] | None
+type I3 = None | C[TD]
+type I4 = O[int] | None
+type I5 = None | O[int]
+
+type J1[T] = T | None
+type J2[T] = None | T
+type J3[*Ts] = tuple[*Ts]
+type J4[T] = J1[T] | None
+type J5[T] = None | J1[T]
+type J6[*Ts] = J3[*Ts] | None
+
+type K1 = A[int] | None
+type K2 = None | A[int]
+type K3 = B[int] | None
+type K4 = None | B[int]
+
+type L1 = Never
+type L2 = list[Never]
+
+[case testPEP695VarianceInferenceSpecialCaseWithTypeshed]
+# flags: --python-version=3.12
+class C1[T1, T2](list[T1]):
+    def m(self, a: T2) -> None: ...
+
+def func1(p: C1[int, object]):
+    x: C1[int, int] = p
+
+class C2[T1, T2, T3](dict[T2, T3]):
+    def m(self, a: T1) -> None: ...
+
+def func2(p: C2[object, int, int]):
+    x: C2[int, int, int] = p
+
+class C3[T1, T2](tuple[T1, ...]):
+    def m(self, a: T2) -> None: ...
+
+def func3(p: C3[int, object]):
+    x: C3[int, int] = p
+
+
+[case testDynamicClassAttribute]
+# Some things that can break if DynamicClassAttribute isn't handled properly
+from types import DynamicClassAttribute
+from enum import Enum
+
+class TestClass:
+    @DynamicClassAttribute
+    def name(self) -> str: ...
+
+class TestClass2(TestClass, Enum): ...
+
+class Status(Enum):
+    ABORTED = -1
+
+def imperfect(status: Status) -> str:
+    return status.name.lower()
+
+[case testUnpackIteratorBuiltins]
+# Regression test for https://github.com/python/mypy/issues/18320
+# Caused by https://github.com/python/typeshed/pull/12851
+x = [1, 2]
+reveal_type([*reversed(x)])
+reveal_type([*map(str, x)])
+[out]
+_testUnpackIteratorBuiltins.py:4: note: Revealed type is "builtins.list[builtins.int]"
+_testUnpackIteratorBuiltins.py:5: note: Revealed type is "builtins.list[builtins.str]"
diff --git a/test-data/unit/reports.test b/test-data/unit/reports.test
index 50dabb1fdea9..82c3869bb855 100644
--- a/test-data/unit/reports.test
+++ b/test-data/unit/reports.test
@@ -27,7 +27,7 @@ def bar() -> str:
 def untyped_function():
   return 42
 [outfile build/cobertura.xml]
-<coverage timestamp="$TIMESTAMP" version="$VERSION" line-rate="0.7500" branch-rate="0">
+<coverage timestamp="$TIMESTAMP" version="$VERSION" line-rate="0.7500" branch-rate="0" lines-covered="6" lines-valid="8">
   <sources>
     <source>$PWD</source>
   </sources>
@@ -69,6 +69,40 @@ def untyped_function():
   </packages>
 </coverage>
 
+[case testCoberturaStarUnpacking]
+# cmd: mypy --cobertura-xml-report build a.py
+[file a.py]
+from typing import TypedDict
+
+class MyDict(TypedDict):
+    a: int
+
+def foo(a: int) -> MyDict:
+    return {"a": a}
+md: MyDict = MyDict(**foo(42))
+[outfile build/cobertura.xml]
+<coverage timestamp="$TIMESTAMP" version="$VERSION" line-rate="1.0000" branch-rate="0" lines-covered="6" lines-valid="6">
+  <sources>
+    <source>$PWD</source>
+  </sources>
+  <packages>
+    <package complexity="1.0" name="a" branch-rate="0" line-rate="1.0000">
+      <classes>
+        <class complexity="1.0" filename="a.py" name="a.py" branch-rate="0" line-rate="1.0000">
+          <methods/>
+          <lines>
+            <line branch="false" hits="1" number="1" precision="precise"/>
+            <line branch="false" hits="1" number="3" precision="precise"/>
+            <line branch="false" hits="1" number="4" precision="precise"/>
+            <line branch="false" hits="1" number="6" precision="precise"/>
+            <line branch="false" hits="1" number="7" precision="precise"/>
+            <line branch="false" hits="1" number="8" precision="precise"/>
+          </lines>
+        </class>
+      </classes>
+    </package>
+  </packages>
+</coverage>
 
 [case testAnyExprReportDivisionByZero]
 # cmd: mypy --any-exprs-report=out -c 'pass'
@@ -121,9 +155,9 @@ z: NestedGen[Any]
 [outfile report/types-of-anys.txt]
  Name   Unannotated   Explicit   Unimported   Omitted Generics   Error   Special Form   Implementation Artifact
 -----------------------------------------------------------------------------------------------------------------
-    n             0          4            0                  8       0              0                         0
+    n             0          2            0                  8       0              0                         0
 -----------------------------------------------------------------------------------------------------------------
-Total             0          4            0                  8       0              0                         0
+Total             0          2            0                  8       0              0                         0
 
 [case testTypeVarTreatedAsEmptyLine]
 # cmd: mypy --html-report report n.py
@@ -272,10 +306,7 @@ Total      1      11     90.91%
 
 [file i.py]
 from enum import Enum
-from mypy_extensions import TypedDict
-from typing import NewType, NamedTuple, TypeVar
-
-from typing import TypeVar
+from typing import NewType, NamedTuple, TypedDict, TypeVar
 
 T = TypeVar('T')  # no error
 
@@ -311,7 +342,7 @@ Total      0      14    100.00%
 
 
 [case testAnyExpressionsReportTypesOfAny]
-# cmd: mypy --python-version=3.6 --any-exprs-report report n.py
+# cmd: mypy --any-exprs-report report n.py
 
 [file n.py]
 from typing import Any, List
@@ -337,9 +368,9 @@ z = g.does_not_exist()  # type: ignore  # Error
 [outfile report/types-of-anys.txt]
  Name   Unannotated   Explicit   Unimported   Omitted Generics   Error   Special Form   Implementation Artifact
 -----------------------------------------------------------------------------------------------------------------
-    n             2          4            2                  1       3              0                         0
+    n             2          3            1                  1       3              0                         0
 -----------------------------------------------------------------------------------------------------------------
-Total             2          4            2                  1       3              0                         0
+Total             2          3            1                  1       3              0                         0
 
 [case testAnyExpressionsReportUnqualifiedError]
 # cmd: mypy --any-exprs-report report n.py
diff --git a/test-data/unit/semanal-basic.test b/test-data/unit/semanal-basic.test
index 169769f06a00..1f03ed22648d 100644
--- a/test-data/unit/semanal-basic.test
+++ b/test-data/unit/semanal-basic.test
@@ -316,7 +316,7 @@ MypyFile:1(
         NameExpr(x* [l])
         NameExpr(None [builtins.None])))))
 
-[case testGlobaWithinMethod]
+[case testGlobalWithinMethod]
 x = None
 class A:
   def f(self):
diff --git a/test-data/unit/semanal-classes.test b/test-data/unit/semanal-classes.test
index 951791e23490..b14358509f85 100644
--- a/test-data/unit/semanal-classes.test
+++ b/test-data/unit/semanal-classes.test
@@ -585,7 +585,7 @@ MypyFile:1(
     TupleType(
       Tuple[builtins.int, builtins.str])
     BaseType(
-      builtins.tuple[builtins.object, ...])
+      builtins.tuple[Union[builtins.int, builtins.str], ...])
     PassStmt:2()))
 
 [case testBaseClassFromIgnoredModule]
diff --git a/test-data/unit/semanal-errors.test b/test-data/unit/semanal-errors.test
index 0c3de312cdfa..52c658c97c3b 100644
--- a/test-data/unit/semanal-errors.test
+++ b/test-data/unit/semanal-errors.test
@@ -361,84 +361,84 @@ main:2: error: "yield" outside function
 [case testInvalidLvalues1]
 1 = 1
 [out]
-main:1: error: can't assign to literal
+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
+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
+main:1: error: cannot assign to literal
 
 [case testInvalidLvalues4]
 [1, 1] = 1
 [out]
-main:1: error: can't assign to literal
+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
+main:2: error: cannot assign to literal
 
 [case testInvalidLvalues7]
 x, [y, 1] = 1
 [out]
-main:1: error: can't assign to literal
+main:1: error: cannot assign to literal
 
 [case testInvalidLvalues8]
 x, [y, [z, 1]] = 1
 [out]
-main:1: error: can't assign to literal
+main:1: error: cannot assign to literal
 
 [case testInvalidLvalues9]
 x, (y) = 1 # ok
 x, (y, (z, z)) = 1 # ok
 x, (y, (z, 1)) = 1
 [out]
-main:3: error: can't assign to literal
+main:3: error: cannot assign to literal
 
 [case testInvalidLvalues10]
 x + x = 1
 [out]
-main:1: error: can't assign to operator
+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
+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
+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
+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
+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
@@ -480,18 +480,19 @@ c = 1
 d = 1
 a = *b
 [out]
-main:4: error: Can use starred expression only as assignment target
+main:4: error: can't use starred expression here
 
 [case testStarExpressionInExp]
 a = 1
 *a + 1
 [out]
-main:2: error: Can use starred expression only as assignment target
+main:2: error: can't use starred expression here
 
 [case testInvalidDel1]
 x = 1
-del x(1)  # E: can't delete function call
+del x(1)
 [out]
+main:2: error: cannot delete function call
 
 [case testInvalidDel2]
 x = 1
@@ -503,7 +504,6 @@ main:2: error: cannot delete expression
 
 [case testInvalidDel3]
 del z     # E: Name "z" is not defined
-[out]
 
 [case testFunctionTvarScope]
 
@@ -810,8 +810,8 @@ class C(Generic[t]): pass
 cast(str + str, None)    # E: Cast target is not a type
 cast(C[str][str], None)  # E: Cast target is not a type
 cast(C[str + str], None) # E: Cast target is not a type
-cast([int, str], None)   # E: Bracketed expression "[...]" is not valid as a type \
-                         # N: Did you mean "List[...]"?
+cast([int], None)   # E: Bracketed expression "[...]" is not valid as a type \
+                    # N: Did you mean "List[...]"?
 [out]
 
 [case testInvalidCastTargetType]
@@ -859,8 +859,8 @@ Any(arg=str)  # E: Any(...) is no longer supported. Use cast(Any, ...) instead
 
 [case testTypeListAsType]
 
-def f(x:[int, str]) -> None: # E: Bracketed expression "[...]" is not valid as a type \
-                             # N: Did you mean "List[...]"?
+def f(x: [int]) -> None: # E: Bracketed expression "[...]" is not valid as a type \
+                         # N: Did you mean "List[...]"?
     pass
 [out]
 
@@ -897,9 +897,9 @@ import typing
 def f(): pass
 f() = 1 # type: int
 [out]
-main:3: error: can't assign to function call
+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
@@ -1046,7 +1046,7 @@ T = TypeVar(b'T')      # E: TypeVar() expects a string literal as first argument
 d = TypeVar('D')    # E: String argument 1 "D" to TypeVar(...) does not match variable name "d"
 e = TypeVar('e', int, str, x=1)   # E: Unexpected argument to "TypeVar()": "x"
 f = TypeVar('f', (int, str), int) # E: Type expected
-g = TypeVar('g', int)             # E: TypeVar cannot have only a single constraint
+g = TypeVar('g', int)             # E: Type variable must have at least two constrained types
 h = TypeVar('h', x=(int, str))    # E: Unexpected argument to "TypeVar()": "x"
 i = TypeVar('i', bound=1)         # E: TypeVar "bound" must be a type
 j = TypeVar('j', covariant=None)  # E: TypeVar "covariant" may only be a literal bool
@@ -1060,6 +1060,22 @@ S = TypeVar('S', covariant=True, contravariant=True) \
     # E: TypeVar cannot be both covariant and contravariant
 [builtins fixtures/bool.pyi]
 
+[case testInvalidTypevarArgumentsGenericConstraint]
+from typing import Generic, List, TypeVar
+from typing_extensions import Self
+
+T = TypeVar("T")
+
+def f(x: T) -> None:
+    Bad = TypeVar("Bad", int, List[T])    # E: TypeVar constraint type cannot be parametrized by type variables
+class C(Generic[T]):
+    Bad = TypeVar("Bad", int, List[T])    # E: TypeVar constraint type cannot be parametrized by type variables
+class D:
+    Bad = TypeVar("Bad", int, List[Self]) # E: TypeVar constraint type cannot be parametrized by type variables
+S = TypeVar("S", int, List[T])            # E: Type variable "__main__.T" is unbound \
+                                          # N: (Hint: Use "Generic[T]" or "Protocol[T]" base class to bind "T" inside a class) \
+                                          # N: (Hint: Use "T" in function signature to bind "T" inside a function)
+
 [case testInvalidTypevarValues]
 from typing import TypeVar
 b = TypeVar('b', *[int]) # E: Unexpected argument to "TypeVar()"
@@ -1241,6 +1257,12 @@ class A:
     @property  # OK
     @dec
     def g(self) -> int: pass
+    @dec  # type: ignore[misc]
+    @property
+    def h(self) -> int: pass
+    @dec  # type: ignore[prop-decorator]
+    @property
+    def i(self) -> int: pass
 [builtins fixtures/property.pyi]
 [out]
 
@@ -1275,8 +1297,9 @@ 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: cannot assign to literal
 
 [case testInvalidTypeAnnotation]
 import typing
@@ -1290,9 +1313,9 @@ import typing
 def f() -> None:
     f() = 1  # type: int
 [out]
-main:3: error: can't assign to function call
+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:
@@ -1388,12 +1411,13 @@ class N:  # E: Name "N" already defined on line 2
 [out]
 
 [case testDuplicateDefTypedDict]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 
 class Point:  # E: Name "Point" already defined on line 2
     pass
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 
 [out]
 
@@ -1452,11 +1476,11 @@ from typing_extensions import Unpack
 from typing import Tuple
 
 heterogenous_tuple: Tuple[Unpack[Tuple[int, str]]]
-homogenous_tuple: Tuple[Unpack[Tuple[int, ...]]]
+homogeneous_tuple: Tuple[Unpack[Tuple[int, ...]]]
 bad: Tuple[Unpack[int]]  # E: "int" cannot be unpacked (must be tuple or TypeVarTuple)
 [builtins fixtures/tuple.pyi]
 
-[case testTypeVarTuple]
+[case testTypeVarTupleErrors]
 from typing import Generic
 from typing_extensions import TypeVarTuple, Unpack
 
@@ -1470,15 +1494,14 @@ TP5 = TypeVarTuple(t='TP5')  # E: TypeVarTuple() expects a string literal as fir
 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
+y: Unpack[TVariadic]  # E: Unpack is only valid in a variadic position
 
 
 class Variadic(Generic[Unpack[TVariadic], Unpack[TVariadic2]]):  # E: Can only use one type var tuple in a class def
     pass
 
-# TODO: this should generate an error
-#def bad_args(*args: TVariadic):
-#    pass
+def bad_args(*args: TVariadic):  # E: TypeVarTuple "TVariadic" is only valid with an unpack
+    pass
 
 def bad_kwargs(**kwargs: Unpack[TVariadic]):  # E: Unpack item in ** argument must be a TypedDict
     pass
diff --git a/test-data/unit/semanal-literal.test b/test-data/unit/semanal-literal.test
index 4c100add6ec0..53191f692c8c 100644
--- a/test-data/unit/semanal-literal.test
+++ b/test-data/unit/semanal-literal.test
@@ -1,9 +1,9 @@
 [case testLiteralSemanalBasicAssignment]
-from typing_extensions import Literal
+from typing import Literal
 foo: Literal[3]
 [out]
 MypyFile:1(
-  ImportFrom:1(typing_extensions, [Literal])
+  ImportFrom:1(typing, [Literal])
   AssignmentStmt:2(
     NameExpr(foo [__main__.foo])
     TempNode:2(
@@ -11,12 +11,12 @@ MypyFile:1(
     Literal[3]))
 
 [case testLiteralSemanalInFunction]
-from typing_extensions import Literal
+from typing import Literal
 def foo(a: Literal[1], b: Literal["  foo  "]) -> Literal[True]: pass
 [builtins fixtures/bool.pyi]
 [out]
 MypyFile:1(
-  ImportFrom:1(typing_extensions, [Literal])
+  ImportFrom:1(typing, [Literal])
   FuncDef:2(
     foo
     Args(
diff --git a/test-data/unit/semanal-namedtuple.test b/test-data/unit/semanal-namedtuple.test
index df1d5679c892..16944391da86 100644
--- a/test-data/unit/semanal-namedtuple.test
+++ b/test-data/unit/semanal-namedtuple.test
@@ -165,7 +165,7 @@ N = namedtuple('N', ['x', 1]) # E: String literal expected as "namedtuple()" ite
 
 [case testNamedTupleWithUnderscoreItemName]
 from collections import namedtuple
-N = namedtuple('N', ['_fallback']) # E: "namedtuple()" field names cannot start with an underscore: _fallback
+N = namedtuple('N', ['_fallback']) # E: "namedtuple()" field name "_fallback" starts with an underscore
 [builtins fixtures/tuple.pyi]
 
 -- NOTE: The following code works at runtime but is not yet supported by mypy.
@@ -197,7 +197,7 @@ N = NamedTuple('N', 1) # E: List or tuple literal expected as the second argumen
 
 [case testTypingNamedTupleWithUnderscoreItemName]
 from typing import NamedTuple
-N = NamedTuple('N', [('_fallback', int)]) # E: "NamedTuple()" field names cannot start with an underscore: _fallback
+N = NamedTuple('N', [('_fallback', int)]) # E: "NamedTuple()" field name "_fallback" starts with an underscore
 [builtins fixtures/tuple.pyi]
 
 [case testTypingNamedTupleWithUnexpectedNames]
@@ -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()))
diff --git a/test-data/unit/semanal-statements.test b/test-data/unit/semanal-statements.test
index f602c236c949..f828e2a3263f 100644
--- a/test-data/unit/semanal-statements.test
+++ b/test-data/unit/semanal-statements.test
@@ -557,9 +557,9 @@ MypyFile:1(
 def f(x, y) -> None:
     del x, y + 1
 [out]
-main:2: error: can't delete operator
+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
@@ -1127,7 +1127,7 @@ MypyFile:1(
         IntExpr(1)))))
 
 [case testConstantFold1]
-from typing_extensions import Final
+from typing import Final
 add: Final = 15 + 47
 add_mul: Final = (2 + 3) * 5
 sub: Final = 7 - 11
@@ -1140,7 +1140,7 @@ lshift0: Final = 5 << 0
 rshift0: Final = 13 >> 0
 [out]
 MypyFile:1(
-  ImportFrom:1(typing_extensions, [Final])
+  ImportFrom:1(typing, [Final])
   AssignmentStmt:2(
     NameExpr(add [__main__.add] = 62)
     OpExpr:2(
@@ -1216,7 +1216,7 @@ MypyFile:1(
     Literal[13]?))
 
 [case testConstantFold2]
-from typing_extensions import Final
+from typing import Final
 neg1: Final = -5
 neg2: Final = --1
 neg3: Final = -0
@@ -1231,7 +1231,7 @@ p3: Final = 0**0
 s: Final = 'x' + 'y'
 [out]
 MypyFile:1(
-  ImportFrom:1(typing_extensions, [Final])
+  ImportFrom:1(typing, [Final])
   AssignmentStmt:2(
     NameExpr(neg1 [__main__.neg1] = -5)
     UnaryExpr:2(
diff --git a/test-data/unit/semanal-typeddict.test b/test-data/unit/semanal-typeddict.test
index b9eb6e0c2b13..936ed1aed3ee 100644
--- a/test-data/unit/semanal-typeddict.test
+++ b/test-data/unit/semanal-typeddict.test
@@ -2,44 +2,47 @@
 
 -- TODO: Implement support for this syntax.
 --[case testCanCreateTypedDictTypeWithDictCall]
---from mypy_extensions import TypedDict
+--from typing import TypedDict
 --Point = TypedDict('Point', dict(x=int, y=int))
 --[builtins fixtures/dict.pyi]
+--[typing fixtures/typing-typeddict.pyi]
 --[out]
 --MypyFile:1(
---  ImportFrom:1(mypy_extensions, [TypedDict])
+--  ImportFrom:1(typing, [TypedDict])
 --  AssignmentStmt:2(
 --    NameExpr(Point* [__main__.Point])
 --    TypedDictExpr:2(Point)))
 
 [case testCanCreateTypedDictTypeWithDictLiteral]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 Point = TypedDict('Point', {'x': int, 'y': int})
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 MypyFile:1(
-  ImportFrom:1(mypy_extensions, [TypedDict])
+  ImportFrom:1(typing, [TypedDict])
   AssignmentStmt:2(
     NameExpr(Point* [__main__.Point])
     TypedDictExpr:2(Point)))
 
 [case testTypedDictWithDocString]
-from mypy_extensions import TypedDict
+from typing import TypedDict
 class A(TypedDict):
     """foo"""
     x: str
 [builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
 [out]
 MypyFile:1(
-  ImportFrom:1(mypy_extensions, [TypedDict])
+  ImportFrom:1(typing, [TypedDict])
   ClassDef:2(
     A
     BaseType(
-      mypy_extensions._TypedDict)
+      typing._TypedDict)
     ExpressionStmt:3(
       StrExpr(foo))
     AssignmentStmt:4(
       NameExpr(x)
       TempNode:4(
         Any)
-      str?)))
+      builtins.str)))
diff --git a/test-data/unit/semanal-types.test b/test-data/unit/semanal-types.test
index 71a5c6dd87b5..83c44738f055 100644
--- a/test-data/unit/semanal-types.test
+++ b/test-data/unit/semanal-types.test
@@ -1043,7 +1043,7 @@ MypyFile:1(
       default(
         Var(y)
         StrExpr()))
-    def (*x: builtins.int, *, y: builtins.str =) -> Any
+    def (*x: builtins.int, y: builtins.str =) -> Any
     VarArg(
       Var(x))
     Block:1(
@@ -1559,8 +1559,8 @@ MypyFile:1(
   ImportFrom:1(typing_extensions, [TypeVarTuple])
   AssignmentStmt:2(
     NameExpr(TV* [__main__.TV])
-    TypeVarTupleExpr:2()))
-
+    TypeVarTupleExpr:2(
+      UpperBound(builtins.tuple[builtins.object, ...]))))
 [builtins fixtures/tuple.pyi]
 
 [case testTypeVarTupleCallable]
@@ -1576,7 +1576,8 @@ MypyFile:1(
   ImportFrom:2(typing, [Callable])
   AssignmentStmt:3(
     NameExpr(Ts* [__main__.Ts])
-    TypeVarTupleExpr:3())
+    TypeVarTupleExpr:3(
+      UpperBound(builtins.tuple[builtins.object, ...])))
   FuncDef:5(
     foo
     Args(
diff --git a/test-data/unit/stubgen.test b/test-data/unit/stubgen.test
index e1818dc4c4bc..86d33e3af51d 100644
--- a/test-data/unit/stubgen.test
+++ b/test-data/unit/stubgen.test
@@ -11,6 +11,11 @@ def f() -> None: ...
 
 [case testTwoFunctions]
 def f(a, b):
+    """
+    this is a docstring
+
+    more.
+    """
     x = 1
 def g(arg):
     pass
@@ -22,35 +27,47 @@ def g(arg) -> None: ...
 def f(a, b=2): ...
 def g(b=-1, c=0): ...
 [out]
-def f(a, b: int = ...) -> None: ...
-def g(b: int = ..., c: int = ...) -> None: ...
+def f(a, b: int = 2) -> None: ...
+def g(b: int = -1, c: int = 0) -> None: ...
 
 [case testDefaultArgNone]
 def f(x=None): ...
 [out]
 from _typeshed import Incomplete
 
-def f(x: Incomplete | None = ...) -> None: ...
+def f(x: Incomplete | None = None) -> None: ...
 
 [case testDefaultArgBool]
 def f(x=True, y=False): ...
 [out]
-def f(x: bool = ..., y: bool = ...) -> None: ...
+def f(x: bool = True, y: bool = False) -> None: ...
+
+[case testDefaultArgBool_inspect]
+def f(x=True, y=False): ...
+[out]
+def f(x: bool = ..., y: bool = ...): ...
 
 [case testDefaultArgStr]
+def f(x='foo',y="how's quotes"): ...
+[out]
+def f(x: str = 'foo', y: str = "how's quotes") -> None: ...
+
+[case testDefaultArgStr_inspect]
 def f(x='foo'): ...
 [out]
-def f(x: str = ...) -> None: ...
+def f(x: str = ...): ...
 
 [case testDefaultArgBytes]
-def f(x=b'foo'): ...
+def f(x=b'foo',y=b"what's up",z=b'\xc3\xa0 la une'): ...
 [out]
-def f(x: bytes = ...) -> None: ...
+def f(x: bytes = b'foo', y: bytes = b"what's up", z: bytes = b'\xc3\xa0 la une') -> None: ...
 
 [case testDefaultArgFloat]
-def f(x=1.2): ...
+def f(x=1.2,y=1e-6,z=0.0,w=-0.0,v=+1.0): ...
+def g(x=float("nan"), y=float("inf"), z=float("-inf")): ...
 [out]
-def f(x: float = ...) -> None: ...
+def f(x: float = 1.2, y: float = 1e-06, z: float = 0.0, w: float = -0.0, v: float = +1.0) -> None: ...
+def g(x=..., y=..., z=...) -> None: ...
 
 [case testDefaultArgOther]
 def f(x=ord): ...
@@ -111,10 +128,10 @@ def i(a, *, b=1): ...
 def j(a, *, b=1, **c): ...
 [out]
 def f(a, *b, **c) -> None: ...
-def g(a, *b, c: int = ...) -> None: ...
-def h(a, *b, c: int = ..., **d) -> None: ...
-def i(a, *, b: int = ...) -> None: ...
-def j(a, *, b: int = ..., **c) -> None: ...
+def g(a, *b, c: int = 1) -> None: ...
+def h(a, *b, c: int = 1, **d) -> None: ...
+def i(a, *, b: int = 1) -> None: ...
+def j(a, *, b: int = 1, **c) -> None: ...
 
 [case testClass]
 class A:
@@ -127,10 +144,52 @@ class A:
 
 def g() -> None: ...
 
-[case testVariable]
-x = 1
+[case testVariables]
+i = 1
+s = 'a'
+f = 1.5
+c1 = 1j
+c2 = 0j + 1
+bl1 = True
+bl2 = False
+bts = b''
+[out]
+i: int
+s: str
+f: float
+c1: complex
+c2: complex
+bl1: bool
+bl2: bool
+bts: bytes
+
+[case testVariablesWithUnary]
+i = +-1
+f = -1.5
+c1 = -1j
+c2 = -1j + 1
+bl1 = not True
+bl2 = not not False
+[out]
+i: int
+f: float
+c1: complex
+c2: complex
+bl1: bool
+bl2: bool
+
+[case testVariablesWithUnaryWrong]
+i = not +1
+bl1 = -True
+bl2 = not -False
+bl3 = -(not False)
 [out]
-x: int
+from _typeshed import Incomplete
+
+i: Incomplete
+bl1: Incomplete
+bl2: Incomplete
+bl3: Incomplete
 
 [case testAnnotatedVariable]
 x: int = 1
@@ -179,13 +238,24 @@ class C:
     def __init__(self, x: str) -> None: ...
 
 [case testSelfAssignment]
+from mod import A
+from typing import Any, Dict, Union
 class C:
     def __init__(self):
+        self.a: A = A()
         self.x = 1
         x.y = 2
+        self.y: Dict[str, Any] = {}
+        self.z: Union[int, str, bool, None] = None
 [out]
+from mod import A
+from typing import Any
+
 class C:
+    a: A
     x: int
+    y: dict[str, Any]
+    z: int | str | bool | None
     def __init__(self) -> None: ...
 
 [case testSelfAndClassBodyAssignment]
@@ -258,6 +328,7 @@ __all__ = []
 __author__ = ''
 __version__ = ''
 [out]
+__version__: str
 
 [case testBaseClass]
 class A: ...
@@ -267,10 +338,24 @@ class A: ...
 class B(A): ...
 
 [case testDecoratedFunction]
+import x
+
 @decorator
 def foo(x): ...
+
+@x.decorator
+def bar(x): ...
+
+@decorator(x=1, y={"a": 1})
+def foo_bar(x): ...
 [out]
+import x
+
+@decorator
 def foo(x) -> None: ...
+@x.decorator
+def bar(x) -> None: ...
+def foo_bar(x) -> None: ...
 
 [case testMultipleAssignment]
 x, y = 1, 2
@@ -298,8 +383,17 @@ y: Incomplete
 def f(x, *, y=1): ...
 def g(x, *, y=1, z=2): ...
 [out]
-def f(x, *, y: int = ...) -> None: ...
-def g(x, *, y: int = ..., z: int = ...) -> None: ...
+def f(x, *, y: int = 1) -> None: ...
+def g(x, *, y: int = 1, z: int = 2) -> None: ...
+
+[case testKeywordOnlyArg_inspect]
+def f(x, *, y=1): ...
+def g(x, *, y=1, z=2): ...
+def h(x, *, y, z=2): ...
+[out]
+def f(x, *, y: int = ...): ...
+def g(x, *, y: int = ..., z: int = ...): ...
+def h(x, *, y, z: int = ...): ...
 
 [case testProperty]
 class A:
@@ -308,6 +402,30 @@ class A:
         return 1
     @f.setter
     def f(self, x): ...
+    @f.deleter
+    def f(self): ...
+
+    def h(self):
+        self.f = 1
+[out]
+class A:
+    @property
+    def f(self): ...
+    @f.setter
+    def f(self, x) -> None: ...
+    @f.deleter
+    def f(self) -> None: ...
+    def h(self) -> None: ...
+
+[case testProperty_semanal]
+class A:
+    @property
+    def f(self):
+        return 1
+    @f.setter
+    def f(self, x): ...
+    @f.deleter
+    def f(self): ...
 
     def h(self):
         self.f = 1
@@ -317,8 +435,28 @@ class A:
     def f(self): ...
     @f.setter
     def f(self, x) -> None: ...
+    @f.deleter
+    def f(self) -> None: ...
     def h(self) -> None: ...
 
+-- a read/write property is treated the same as an attribute
+[case testProperty_inspect]
+class A:
+    @property
+    def f(self):
+        return 1
+    @f.setter
+    def f(self, x): ...
+
+    def h(self):
+        self.f = 1
+[out]
+from _typeshed import Incomplete
+
+class A:
+    f: Incomplete
+    def h(self): ...
+
 [case testFunctoolsCachedProperty]
 import functools
 
@@ -393,6 +531,15 @@ class A:
     @classmethod
     def f(cls) -> None: ...
 
+[case testClassMethod_inspect]
+class A:
+    @classmethod
+    def f(cls): ...
+[out]
+class A:
+    @classmethod
+    def f(cls): ...
+
 [case testIfMainCheck]
 def a(): ...
 if __name__ == '__main__':
@@ -430,6 +577,23 @@ class B: ...
 class C:
     def f(self) -> None: ...
 
+[case testNoSpacesBetweenEmptyClasses_inspect]
+class X:
+    def g(self): ...
+class A: ...
+class B: ...
+class C:
+    def f(self): ...
+[out]
+class X:
+    def g(self): ...
+
+class A: ...
+class B: ...
+
+class C:
+    def f(self): ...
+
 [case testExceptionBaseClasses]
 class A(Exception): ...
 class B(ValueError): ...
@@ -448,6 +612,17 @@ class A:
 class A:
     def __eq__(self): ...
 
+[case testOmitSomeSpecialMethods_inspect]
+class A:
+    def __str__(self): ...
+    def __repr__(self): ...
+    def __eq__(self): ...
+    def __getstate__(self): ...
+    def __setstate__(self, state): ...
+[out]
+class A:
+    def __eq__(self) -> bool: ...
+
 -- Tests that will perform runtime imports of modules.
 -- Don't use `_import` suffix if there are unquoted forward references.
 
@@ -456,6 +631,8 @@ __all__ = [] + ['f']
 def f(): ...
 def g(): ...
 [out]
+__all__ = ['f']
+
 def f() -> None: ...
 
 [case testOmitDefsNotInAll_semanal]
@@ -463,8 +640,19 @@ __all__ = ['f']
 def f(): ...
 def g(): ...
 [out]
+__all__ = ['f']
+
 def f() -> None: ...
 
+[case testOmitDefsNotInAll_inspect]
+__all__ = [] + ['f']
+def f(): ...
+def g(): ...
+[out]
+__all__ = ['f']
+
+def f(): ...
+
 [case testVarDefsNotInAll_import]
 __all__ = [] + ['f', 'g']
 def f(): ...
@@ -472,24 +660,53 @@ x = 1
 y = 1
 def g(): ...
 [out]
+__all__ = ['f', 'g']
+
 def f() -> None: ...
 def g() -> None: ...
 
+[case testVarDefsNotInAll_inspect]
+__all__ = [] + ['f', 'g']
+def f(): ...
+x = 1
+y = 1
+def g(): ...
+[out]
+__all__ = ['f', 'g']
+
+def f(): ...
+def g(): ...
+
 [case testIncludeClassNotInAll_import]
 __all__ = [] + ['f']
 def f(): ...
 class A: ...
 [out]
+__all__ = ['f']
+
 def f() -> None: ...
 
 class A: ...
 
+[case testIncludeClassNotInAll_inspect]
+__all__ = [] + ['f']
+def f(): ...
+class A: ...
+[out]
+__all__ = ['f']
+
+def f(): ...
+
+class A: ...
+
 [case testAllAndClass_import]
 __all__ = ['A']
 class A:
     x = 1
     def f(self): ...
 [out]
+__all__ = ['A']
+
 class A:
     x: int
     def f(self) -> None: ...
@@ -527,6 +744,8 @@ x = 1
 [out]
 from re import match as match, sub as sub
 
+__all__ = ['match', 'sub', 'x']
+
 x: int
 
 [case testExportModule_import]
@@ -537,6 +756,8 @@ y = 2
 [out]
 import re as re
 
+__all__ = ['re', 'x']
+
 x: int
 
 [case testExportModule2_import]
@@ -547,6 +768,8 @@ y = 2
 [out]
 import re as re
 
+__all__ = ['re', 'x']
+
 x: int
 
 [case testExportModuleAs_import]
@@ -557,6 +780,8 @@ y = 2
 [out]
 import re as rex
 
+__all__ = ['rex', 'x']
+
 x: int
 
 [case testExportModuleInPackage_import]
@@ -565,6 +790,8 @@ __all__ = ['p']
 [out]
 import urllib.parse as p
 
+__all__ = ['p']
+
 [case testExportPackageOfAModule_import]
 import urllib.parse
 __all__ = ['urllib']
@@ -572,6 +799,8 @@ __all__ = ['urllib']
 [out]
 import urllib as urllib
 
+__all__ = ['urllib']
+
 [case testRelativeImportAll]
 from .x import *
 [out]
@@ -584,6 +813,8 @@ x = 1
 class C:
     def g(self): ...
 [out]
+__all__ = ['f', 'x', 'C', 'g']
+
 def f() -> None: ...
 
 x: int
@@ -594,6 +825,25 @@ class C:
 # Names in __all__ with no definition:
 #   g
 
+[case testCommentForUndefinedName_inspect]
+__all__ = ['f', 'x', 'C', 'g']
+def f(): ...
+x = 1
+class C:
+    def g(self): ...
+[out]
+__all__ = ['f', 'x', 'C', 'g']
+
+def f(): ...
+
+x: int
+
+class C:
+    def g(self): ...
+
+# Names in __all__ with no definition:
+#   g
+
 [case testIgnoreSlots]
 class A:
     __slots__ = ()
@@ -607,6 +857,13 @@ class A:
 [out]
 class A: ...
 
+[case testSkipPrivateProperty_inspect]
+class A:
+    @property
+    def _foo(self): ...
+[out]
+class A: ...
+
 [case testIncludePrivateProperty]
 # flags:  --include-private
 class A:
@@ -617,6 +874,16 @@ class A:
     @property
     def _foo(self) -> None: ...
 
+[case testIncludePrivateProperty_inspect]
+# flags:  --include-private
+class A:
+    @property
+    def _foo(self): ...
+[out]
+class A:
+    @property
+    def _foo(self): ...
+
 [case testSkipPrivateStaticAndClassMethod]
 class A:
     @staticmethod
@@ -626,6 +893,15 @@ class A:
 [out]
 class A: ...
 
+[case testSkipPrivateStaticAndClassMethod_inspect]
+class A:
+    @staticmethod
+    def _foo(): ...
+    @classmethod
+    def _bar(cls): ...
+[out]
+class A: ...
+
 [case testIncludePrivateStaticAndClassMethod]
 # flags:  --include-private
 class A:
@@ -640,6 +916,20 @@ class A:
     @classmethod
     def _bar(cls) -> None: ...
 
+[case testIncludePrivateStaticAndClassMethod_inspect]
+# flags:  --include-private
+class A:
+    @staticmethod
+    def _foo(): ...
+    @classmethod
+    def _bar(cls): ...
+[out]
+class A:
+    @staticmethod
+    def _foo(): ...
+    @classmethod
+    def _bar(cls): ...
+
 [case testNamedtuple]
 import collections, typing, x
 X = collections.namedtuple('X', ['a', 'b'])
@@ -656,6 +946,62 @@ class Y(NamedTuple):
     a: int
     b: str
 
+[case testNamedTupleClassSyntax_semanal]
+from typing import NamedTuple
+
+class A(NamedTuple):
+    x: int
+    y: str = 'a'
+
+class B(A):
+    z1: str
+    z2 = 1
+    z3: str = 'b'
+
+class RegularClass:
+    x: int
+    y: str = 'a'
+    class NestedNamedTuple(NamedTuple):
+        x: int
+        y: str = 'a'
+    z: str = 'b'
+[out]
+from typing import NamedTuple
+
+class A(NamedTuple):
+    x: int
+    y: str = ...
+
+class B(A):
+    z1: str
+    z2: int
+    z3: str
+
+class RegularClass:
+    x: int
+    y: str
+    class NestedNamedTuple(NamedTuple):
+        x: int
+        y: str = ...
+    z: str
+
+
+[case testNestedClassInNamedTuple_semanal-xfail]
+from typing import NamedTuple
+
+# TODO: make sure that nested classes in `NamedTuple` are supported:
+class NamedTupleWithNestedClass(NamedTuple):
+    class Nested:
+        x: int
+        y: str = 'a'
+[out]
+from typing import NamedTuple
+
+class NamedTupleWithNestedClass(NamedTuple):
+    class Nested:
+        x: int
+        y: str
+
 [case testEmptyNamedtuple]
 import collections, typing
 X = collections.namedtuple('X', [])
@@ -899,6 +1245,68 @@ T = TypeVar('T')
 
 class D(Generic[T]): ...
 
+[case testGenericClassTypeVarTuple]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+Ts = TypeVarTuple('Ts')
+class D(Generic[Unpack[Ts]]): ...
+def callback(func: Callable[[Unpack[Ts]], None], *args: Unpack[Ts]) -> None: ...
+[out]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple('Ts')
+
+class D(Generic[Unpack[Ts]]): ...
+
+def callback(func: Callable[[Unpack[Ts]], None], *args: Unpack[Ts]) -> None: ...
+
+[case testGenericClassTypeVarTuple_semanal]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+Ts = TypeVarTuple('Ts')
+class D(Generic[Unpack[Ts]]): ...
+def callback(func: Callable[[Unpack[Ts]], None], *args: Unpack[Ts]) -> None: ...
+[out]
+from typing import Generic
+from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple('Ts')
+
+class D(Generic[Unpack[Ts]]): ...
+
+def callback(func: Callable[[Unpack[Ts]], None], *args: Unpack[Ts]) -> None: ...
+
+[case testGenericClassTypeVarTuplePy311]
+# flags: --python-version=3.11
+from typing import Generic, TypeVarTuple
+Ts = TypeVarTuple('Ts')
+class D(Generic[*Ts]): ...
+def callback(func: Callable[[*Ts], None], *args: *Ts) -> None: ...
+[out]
+from typing import Generic, TypeVarTuple
+
+Ts = TypeVarTuple('Ts')
+
+class D(Generic[*Ts]): ...
+
+def callback(func: Callable[[*Ts], None], *args: *Ts) -> None: ...
+
+[case testGenericClassTypeVarTuplePy311_semanal]
+# flags: --python-version=3.11
+from typing import Generic, TypeVarTuple
+Ts = TypeVarTuple('Ts')
+class D(Generic[*Ts]): ...
+def callback(func: Callable[[*Ts], None], *args: *Ts) -> None: ...
+[out]
+from typing import Generic, TypeVarTuple
+
+Ts = TypeVarTuple('Ts')
+
+class D(Generic[*Ts]): ...
+
+def callback(func: Callable[[*Ts], None], *args: *Ts) -> None: ...
+
 [case testObjectBaseClass]
 class A(object): ...
 [out]
@@ -983,8 +1391,8 @@ from _typeshed import Incomplete
 
 class A:
     x: Incomplete
-    def __init__(self, a: Incomplete | None = ...) -> None: ...
-    def method(self, a: Incomplete | None = ...) -> None: ...
+    def __init__(self, a: Incomplete | None = None) -> None: ...
+    def method(self, a: Incomplete | None = None) -> None: ...
 
 [case testAnnotationImportsFrom]
 import foo
@@ -1014,9 +1422,8 @@ x: List[collections.defaultdict]
 
 [out]
 import collections
-from typing import List
 
-x: List[collections.defaultdict]
+x: list[collections.defaultdict]
 
 
 [case testAnnotationFwRefs]
@@ -1036,11 +1443,16 @@ y: C
 
 [case testTypeVarPreserved]
 tv = TypeVar('tv')
+ps = ParamSpec('ps')
+tvt = TypeVarTuple('tvt')
 
 [out]
 from typing import TypeVar
+from typing_extensions import ParamSpec, TypeVarTuple
 
 tv = TypeVar('tv')
+ps = ParamSpec('ps')
+tvt = TypeVarTuple('tvt')
 
 [case testTypeVarArgsPreserved]
 tv = TypeVar('tv', int, str)
@@ -1052,29 +1464,37 @@ tv = TypeVar('tv', int, str)
 
 [case testTypeVarNamedArgsPreserved]
 tv = TypeVar('tv', bound=bool, covariant=True)
+ps = ParamSpec('ps', bound=bool, covariant=True)
 
 [out]
 from typing import TypeVar
+from typing_extensions import ParamSpec
 
 tv = TypeVar('tv', bound=bool, covariant=True)
+ps = ParamSpec('ps', bound=bool, covariant=True)
 
 [case TypeVarImportAlias]
-from typing import TypeVar as t_TV
-from typing_extensions import TypeVar as te_TV
+from typing import TypeVar as t_TV, ParamSpec as t_PS
+from typing_extensions import TypeVar as te_TV, TypeVarTuple as te_TVT
 from x import TypeVar as x_TV
 
 T = t_TV('T')
 U = te_TV('U')
 V = x_TV('V')
 
+PS = t_PS('PS')
+TVT = te_TVT('TVT')
+
 [out]
 from _typeshed import Incomplete
-from typing import TypeVar as t_TV
-from typing_extensions import TypeVar as te_TV
+from typing import ParamSpec as t_PS, TypeVar as t_TV
+from typing_extensions import TypeVar as te_TV, TypeVarTuple as te_TVT
 
 T = t_TV('T')
 U = te_TV('U')
 V: Incomplete
+PS = t_PS('PS')
+TVT = te_TVT('TVT')
 
 [case testTypeVarFromImportAlias]
 import typing as t
@@ -1085,6 +1505,9 @@ T = t.TypeVar('T')
 U = te.TypeVar('U')
 V = x.TypeVar('V')
 
+PS = t.ParamSpec('PS')
+TVT = te.TypeVarTuple('TVT')
+
 [out]
 import typing as t
 import typing_extensions as te
@@ -1093,6 +1516,8 @@ from _typeshed import Incomplete
 T = t.TypeVar('T')
 U = te.TypeVar('U')
 V: Incomplete
+PS = t.ParamSpec('PS')
+TVT = te.TypeVarTuple('TVT')
 
 [case testTypeAliasPreserved]
 alias = str
@@ -1119,6 +1544,19 @@ from typing import TypeVar
 T = TypeVar('T')
 alias = Union[T, List[T]]
 
+[case testExplicitTypeAlias]
+from typing import TypeAlias
+
+explicit_alias: TypeAlias = tuple[int, str]
+implicit_alias = list[int]
+
+[out]
+from typing import TypeAlias
+
+explicit_alias: TypeAlias = tuple[int, str]
+implicit_alias = list[int]
+
+
 [case testEllipsisAliasPreserved]
 
 alias = Tuple[int, ...]
@@ -1252,11 +1690,11 @@ def all():
 from _typeshed import Incomplete
 from collections.abc import Generator
 
-def f() -> Generator[Incomplete, None, None]: ...
-def g() -> Generator[None, Incomplete, None]: ...
-def h1() -> Generator[None, None, None]: ...
+def f() -> Generator[Incomplete]: ...
+def g() -> Generator[None, Incomplete]: ...
+def h1() -> Generator[None]: ...
 def h2() -> Generator[None, None, Incomplete]: ...
-def h3() -> Generator[None, None, None]: ...
+def h3() -> Generator[None]: ...
 def all() -> Generator[Incomplete, Incomplete, Incomplete]: ...
 
 [case testFunctionYieldsNone]
@@ -1268,8 +1706,8 @@ def g():
 [out]
 from collections.abc import Generator
 
-def f() -> Generator[None, None, None]: ...
-def g() -> Generator[None, None, None]: ...
+def f() -> Generator[None]: ...
+def g() -> Generator[None]: ...
 
 [case testGeneratorAlreadyDefined]
 class Generator:
@@ -1283,7 +1721,7 @@ from collections.abc import Generator as _Generator
 
 class Generator: ...
 
-def f() -> _Generator[Incomplete, None, None]: ...
+def f() -> _Generator[Incomplete]: ...
 
 [case testGeneratorYieldFrom]
 def g1():
@@ -1304,10 +1742,10 @@ def g5():
 from _typeshed import Incomplete
 from collections.abc import Generator
 
-def g1() -> Generator[Incomplete, Incomplete, None]: ...
-def g2() -> Generator[Incomplete, Incomplete, None]: ...
-def g3() -> Generator[Incomplete, Incomplete, None]: ...
-def g4() -> Generator[Incomplete, Incomplete, None]: ...
+def g1() -> Generator[Incomplete, Incomplete]: ...
+def g2() -> Generator[Incomplete, Incomplete]: ...
+def g3() -> Generator[Incomplete, Incomplete]: ...
+def g4() -> Generator[Incomplete, Incomplete]: ...
 def g5() -> Generator[Incomplete, Incomplete, Incomplete]: ...
 
 [case testGeneratorYieldAndYieldFrom]
@@ -1340,13 +1778,13 @@ def g7():
 from _typeshed import Incomplete
 from collections.abc import Generator
 
-def g1() -> Generator[Incomplete, Incomplete, None]: ...
-def g2() -> Generator[Incomplete, Incomplete, None]: ...
-def g3() -> Generator[Incomplete, Incomplete, None]: ...
-def g4() -> Generator[Incomplete, Incomplete, None]: ...
-def g5() -> Generator[Incomplete, Incomplete, None]: ...
+def g1() -> Generator[Incomplete, Incomplete]: ...
+def g2() -> Generator[Incomplete, Incomplete]: ...
+def g3() -> Generator[Incomplete, Incomplete]: ...
+def g4() -> Generator[Incomplete, Incomplete]: ...
+def g5() -> Generator[Incomplete, Incomplete]: ...
 def g6() -> Generator[Incomplete, Incomplete, Incomplete]: ...
-def g7() -> Generator[Incomplete, Incomplete, None]: ...
+def g7() -> Generator[Incomplete, Incomplete]: ...
 
 [case testCallable]
 from typing import Callable
@@ -1685,9 +2123,22 @@ class Outer:
     class Inner: ...
 A = Outer.Inner
 
-[case testFunctionAlias_semanal]
-from asyncio import coroutine
-
+-- needs improvement
+[case testNestedClass_inspect]
+class Outer:
+    class Inner:
+        pass
+
+A = Outer.Inner
+[out]
+class Outer:
+    class Inner: ...
+
+class A: ...
+
+[case testFunctionAlias_semanal]
+from asyncio import coroutine
+
 @coroutine
 def start_server():
     ...
@@ -1823,9 +2274,9 @@ funcs: Dict[Any, Any]
 f = funcs[a.f]
 [out]
 from _typeshed import Incomplete
-from typing import Any, Dict
+from typing import Any
 
-funcs: Dict[Any, Any]
+funcs: dict[Any, Any]
 f: Incomplete
 
 [case testAbstractMethodNameExpr]
@@ -1918,6 +2369,25 @@ class A:
 def f(x) -> None: ...
 def g(x, y: str): ...
 
+class A:
+    def f(self, x) -> None: ...
+
+-- Same as above
+[case testFunctionPartiallyAnnotated_inspect]
+def f(x) -> None:
+    pass
+
+def g(x, y: str):
+    pass
+
+class A:
+    def f(self, x) -> None:
+        pass
+
+[out]
+def f(x) -> None: ...
+def g(x, y: str): ...
+
 class A:
     def f(self, x) -> None: ...
 
@@ -1938,6 +2408,24 @@ def f(x: Any): ...
 def g(x, y: Any) -> str: ...
 def h(x: Any) -> str: ...
 
+-- Same as above
+[case testExplicitAnyArg_inspect]
+from typing import Any
+
+def f(x: Any):
+    pass
+def g(x, y: Any) -> str:
+    pass
+def h(x: Any) -> str:
+    pass
+
+[out]
+from typing import Any
+
+def f(x: Any): ...
+def g(x, y: Any) -> str: ...
+def h(x: Any) -> str: ...
+
 [case testExplicitReturnedAny]
 from typing import Any
 
@@ -1966,10 +2454,12 @@ class B:
     @property
     def x(self):
         return 'x'
-
     @x.setter
     def x(self, value):
         self.y = 'y'
+    @x.deleter
+    def x(self):
+        del self.y
 
 [out]
 class A:
@@ -1983,6 +2473,8 @@ class B:
     y: str
     @x.setter
     def x(self, value) -> None: ...
+    @x.deleter
+    def x(self) -> None: ...
 
 [case testMisplacedTypeComment]
 def f():
@@ -2005,6 +2497,8 @@ else:
 [out]
 import cookielib as cookielib
 
+__all__ = ['cookielib']
+
 [case testCannotCalculateMRO_semanal]
 class X: pass
 
@@ -2142,7 +2636,7 @@ from _typeshed import Incomplete as _Incomplete
 
 Y: _Incomplete
 
-def g(x: _Incomplete | None = ...) -> None: ...
+def g(x: _Incomplete | None = None) -> None: ...
 
 x: _Incomplete
 
@@ -2269,6 +2763,28 @@ def g() -> None: ...
 <out/p/tests.pyi was not generated>
 <out/p/tests/test_foo.pyi was not generated>
 
+[case testTestFiles_inspect]
+# modules: p p.x p.tests p.tests.test_foo
+
+[file p/__init__.py]
+def f(): pass
+
+[file p/x.py]
+def g(): pass
+
+[file p/tests/__init__.py]
+
+[file p/tests/test_foo.py]
+def test_thing(): pass
+
+[out]
+# p/__init__.pyi
+def f(): ...
+# p/x.pyi
+def g(): ...
+<out/p/tests.pyi was not generated>
+<out/p/tests/test_foo.pyi was not generated>
+
 [case testVerboseFlag]
 # Just test that --verbose does not break anything in a basic test case.
 # flags: --verbose
@@ -2428,6 +2944,8 @@ class A: pass
 # p/__init__.pyi
 from p.a import A
 
+__all__ = ['a']
+
 a: A
 # p/a.pyi
 class A: ...
@@ -2570,6 +3088,8 @@ __uri__ = ''
 __version__ = ''
 
 [out]
+from m import __version__ as __version__
+
 class A: ...
 
 [case testHideDunderModuleAttributesWithAll_import]
@@ -2599,24 +3119,23 @@ __uri__ = ''
 __version__ = ''
 
 [out]
+from m import __about__ as __about__, __author__ as __author__, __version__ as __version__
+
+__all__ = ['__about__', '__author__', '__version__']
 
 [case testAttrsClass_semanal]
 import attrs
 
 @attrs.define
 class C:
-    x = attrs.field()
+    x: int = attrs.field()
 
 [out]
-from _typeshed import Incomplete
+import attrs
 
+@attrs.define
 class C:
-    x: Incomplete
-    def __init__(self, x) -> None: ...
-    def __lt__(self, other): ...
-    def __le__(self, other): ...
-    def __gt__(self, other): ...
-    def __ge__(self, other): ...
+    x: int = attrs.field()
 
 [case testNamedTupleInClass]
 from collections import namedtuple
@@ -2656,9 +3175,9 @@ y: b.Y
 z: p.a.X
 
 [out]
+import p.a
 import p.a as a
 import p.b as b
-import p.a
 
 x: a.X
 y: b.Y
@@ -2671,7 +3190,7 @@ from p import a
 x: a.X
 
 [out]
-from p import a as a
+from p import a
 
 x: a.X
 
@@ -2693,7 +3212,7 @@ from p import a
 x: a.X
 
 [out]
-from p import a as a
+from p import a
 
 x: a.X
 
@@ -2743,6 +3262,60 @@ import p.a
 x: a.X
 y: p.a.Y
 
+[case testNestedImports]
+import p
+import p.m1
+import p.m2
+
+x: p.X
+y: p.m1.Y
+z: p.m2.Z
+
+[out]
+import p
+import p.m1
+import p.m2
+
+x: p.X
+y: p.m1.Y
+z: p.m2.Z
+
+[case testNestedImportsAliased]
+import p as t
+import p.m1 as pm1
+import p.m2 as pm2
+
+x: t.X
+y: pm1.Y
+z: pm2.Z
+
+[out]
+import p as t
+import p.m1 as pm1
+import p.m2 as pm2
+
+x: t.X
+y: pm1.Y
+z: pm2.Z
+
+[case testNestedFromImports]
+from p import m1
+from p.m1 import sm1
+from p.m2 import sm2
+
+x: m1.X
+y: sm1.Y
+z: sm2.Z
+
+[out]
+from p import m1
+from p.m1 import sm1
+from p.m2 import sm2
+
+x: m1.X
+y: sm1.Y
+z: sm2.Z
+
 [case testOverload_fromTypingImport]
 from typing import Tuple, Union, overload
 
@@ -2771,19 +3344,18 @@ def f(*args: Union[int, Tuple[int, int]]) -> int:
 
 
 [out]
-from typing import Tuple, overload
+from typing import overload
 
 class A:
     @overload
     def f(self, x: int, y: int) -> int: ...
     @overload
-    def f(self, x: Tuple[int, int]) -> int: ...
-
+    def f(self, x: tuple[int, int]) -> int: ...
 
 @overload
 def f(x: int, y: int) -> int: ...
 @overload
-def f(x: Tuple[int, int]) -> int: ...
+def f(x: tuple[int, int]) -> int: ...
 
 [case testOverload_fromTypingExtensionsImport]
 from typing import Tuple, Union
@@ -2814,20 +3386,18 @@ def f(*args: Union[int, Tuple[int, int]]) -> int:
 
 
 [out]
-from typing import Tuple
 from typing_extensions import overload
 
 class A:
     @overload
     def f(self, x: int, y: int) -> int: ...
     @overload
-    def f(self, x: Tuple[int, int]) -> int: ...
-
+    def f(self, x: tuple[int, int]) -> int: ...
 
 @overload
 def f(x: int, y: int) -> int: ...
 @overload
-def f(x: Tuple[int, int]) -> int: ...
+def f(x: tuple[int, int]) -> int: ...
 
 [case testOverload_importTyping]
 import typing
@@ -2890,23 +3460,22 @@ class A:
     @typing.overload
     def f(self, x: int, y: int) -> int: ...
     @typing.overload
-    def f(self, x: typing.Tuple[int, int]) -> int: ...
+    def f(self, x: tuple[int, int]) -> int: ...
     @typing.overload
     @classmethod
     def g(cls, x: int, y: int) -> int: ...
     @typing.overload
     @classmethod
-    def g(cls, x: typing.Tuple[int, int]) -> int: ...
-
+    def g(cls, x: tuple[int, int]) -> int: ...
 
 @typing.overload
 def f(x: int, y: int) -> int: ...
 @typing.overload
-def f(x: typing.Tuple[int, int]) -> int: ...
+def f(x: tuple[int, int]) -> int: ...
 @typing_extensions.overload
 def g(x: int, y: int) -> int: ...
 @typing_extensions.overload
-def g(x: typing.Tuple[int, int]) -> int: ...
+def g(x: tuple[int, int]) -> int: ...
 
 [case testOverload_importTypingAs]
 import typing as t
@@ -2969,23 +3538,22 @@ class A:
     @t.overload
     def f(self, x: int, y: int) -> int: ...
     @t.overload
-    def f(self, x: t.Tuple[int, int]) -> int: ...
+    def f(self, x: tuple[int, int]) -> int: ...
     @t.overload
     @classmethod
     def g(cls, x: int, y: int) -> int: ...
     @t.overload
     @classmethod
-    def g(cls, x: t.Tuple[int, int]) -> int: ...
-
+    def g(cls, x: tuple[int, int]) -> int: ...
 
 @t.overload
 def f(x: int, y: int) -> int: ...
 @t.overload
-def f(x: t.Tuple[int, int]) -> int: ...
+def f(x: tuple[int, int]) -> int: ...
 @te.overload
 def g(x: int, y: int) -> int: ...
 @te.overload
-def g(x: t.Tuple[int, int]) -> int: ...
+def g(x: tuple[int, int]) -> int: ...
 
 [case testOverloadFromImportAlias]
 from typing import overload as t_overload
@@ -3052,7 +3620,7 @@ class P(Protocol):
 [case testNonDefaultKeywordOnlyArgAfterAsterisk]
 def func(*, non_default_kwarg: bool, default_kwarg: bool = True): ...
 [out]
-def func(*, non_default_kwarg: bool, default_kwarg: bool = ...): ...
+def func(*, non_default_kwarg: bool, default_kwarg: bool = True): ...
 
 [case testNestedGenerator]
 def f1():
@@ -3067,6 +3635,85 @@ def f2():
 def f1(): ...
 def f2(): ...
 
+[case testIncludeDocstrings]
+# flags:  --include-docstrings
+class A:
+    """class docstring
+
+    a multiline 😊 docstring"""
+    def func():
+        """func docstring
+        don't forget to indent"""
+        ...
+    def nodoc():
+        ...
+class B:
+    def quoteA():
+        '''func docstring with quotes"""\\n
+        and an end quote\''''
+        ...
+    def quoteB():
+        '''func docstring with quotes"""
+        \'\'\'
+        and an end quote\\"'''
+        ...
+    def quoteC():
+        """func docstring with end quote\\\""""
+        ...
+    def quoteD():
+        r'''raw with quotes\"'''
+        ...
+[out]
+class A:
+    """class docstring
+
+    a multiline 😊 docstring"""
+    def func() -> None:
+        """func docstring
+        don't forget to indent"""
+    def nodoc() -> None: ...
+
+class B:
+    def quoteA() -> None:
+        '''func docstring with quotes"""\\n
+        and an end quote\''''
+    def quoteB() -> None:
+        '''func docstring with quotes"""
+        \'\'\'
+        and an end quote\\"'''
+    def quoteC() -> None:
+        '''func docstring with end quote\\"'''
+    def quoteD() -> None:
+        '''raw with quotes\\"'''
+
+[case testIgnoreDocstrings]
+class A:
+    """class docstring
+
+    a multiline docstring"""
+    def func():
+        """func docstring
+
+        don't forget to indent"""
+    def nodoc():
+        ...
+
+class B:
+    def func():
+        """func docstring"""
+        ...
+    def nodoc():
+        ...
+
+[out]
+class A:
+    def func() -> None: ...
+    def nodoc() -> None: ...
+
+class B:
+    def func() -> None: ...
+    def nodoc() -> None: ...
+
 [case testKnownMagicMethodsReturnTypes]
 class Some:
     def __len__(self): ...
@@ -3096,6 +3743,67 @@ class Some:
     def __float__(self) -> float: ...
     def __index__(self) -> int: ...
 
+-- Same as above
+[case testKnownMagicMethodsReturnTypes_inspect]
+class Some:
+    def __len__(self): ...
+    def __length_hint__(self): ...
+    def __init__(self): ...
+    def __del__(self): ...
+    def __bool__(self): ...
+    def __bytes__(self): ...
+    def __format__(self, spec): ...
+    def __contains__(self, obj): ...
+    def __complex__(self): ...
+    def __int__(self): ...
+    def __float__(self): ...
+    def __index__(self): ...
+[out]
+class Some:
+    def __len__(self) -> int: ...
+    def __length_hint__(self) -> int: ...
+    def __init__(self) -> None: ...
+    def __del__(self) -> None: ...
+    def __bool__(self) -> bool: ...
+    def __bytes__(self) -> bytes: ...
+    def __format__(self, spec) -> str: ...
+    def __contains__(self, obj) -> bool: ...
+    def __complex__(self) -> complex: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __index__(self) -> int: ...
+
+
+[case testKnownMagicMethodsArgTypes]
+class MismatchNames:
+    def __exit__(self, tp, val, tb): ...
+
+class MatchNames:
+    def __exit__(self, type, value, traceback): ...
+
+[out]
+class MismatchNames:
+    def __exit__(self, tp: type[BaseException] | None, val: BaseException | None, tb: types.TracebackType | None) -> None: ...
+
+class MatchNames:
+    def __exit__(self, type: type[BaseException] | None, value: BaseException | None, traceback: types.TracebackType | None) -> None: ...
+
+-- Same as above (but can generate import statements)
+[case testKnownMagicMethodsArgTypes_inspect]
+class MismatchNames:
+    def __exit__(self, tp, val, tb): ...
+
+class MatchNames:
+    def __exit__(self, type, value, traceback): ...
+
+[out]
+import types
+
+class MismatchNames:
+    def __exit__(self, tp: type[BaseException] | None, val: BaseException | None, tb: types.TracebackType | None): ...
+
+class MatchNames:
+    def __exit__(self, type: type[BaseException] | None, value: BaseException | None, traceback: types.TracebackType | None): ...
 
 [case testTypeVarPEP604Bound]
 from typing import TypeVar
@@ -3148,7 +3856,7 @@ from typing import TypedDict
 X = TypedDict('X', a=int, b=str)
 Y = TypedDict('X', a=int, b=str, total=False)
 [out]
-from typing import TypedDict
+from typing_extensions import TypedDict
 
 class X(TypedDict):
     a: int
@@ -3317,3 +4025,696 @@ def gen2() -> _Generator[_Incomplete, _Incomplete, _Incomplete]: ...
 
 class X(_Incomplete): ...
 class Y(_Incomplete): ...
+
+[case testIgnoreLongDefaults]
+def f(x='abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz\
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz\
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz\
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz'): ...
+
+def g(x=b'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz\
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz\
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz\
+abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz'): ...
+
+def h(x=123456789012345678901234567890123456789012345678901234567890\
+123456789012345678901234567890123456789012345678901234567890\
+123456789012345678901234567890123456789012345678901234567890\
+123456789012345678901234567890123456789012345678901234567890): ...
+
+[out]
+def f(x: str = ...) -> None: ...
+def g(x: bytes = ...) -> None: ...
+def h(x: int = ...) -> None: ...
+
+[case testDefaultsOfBuiltinContainers]
+def f(x=(), y=(1,), z=(1, 2)): ...
+def g(x=[], y=[1, 2]): ...
+def h(x={}, y={1: 2, 3: 4}): ...
+def i(x={1, 2, 3}): ...
+def j(x=[(1,"a"), (2,"b")]): ...
+
+[out]
+def f(x=(), y=(1,), z=(1, 2)) -> None: ...
+def g(x=[], y=[1, 2]) -> None: ...
+def h(x={}, y={1: 2, 3: 4}) -> None: ...
+def i(x={1, 2, 3}) -> None: ...
+def j(x=[(1, 'a'), (2, 'b')]) -> None: ...
+
+[case testDefaultsOfBuiltinContainersWithNonTrivialContent]
+def f(x=(1, u.v), y=(k(),), z=(w,)): ...
+def g(x=[1, u.v], y=[k()], z=[w]): ...
+def h(x={1: u.v}, y={k(): 2}, z={m: m}, w={**n}): ...
+def i(x={u.v, 2}, y={3, k()}, z={w}): ...
+
+[out]
+def f(x=..., y=..., z=...) -> None: ...
+def g(x=..., y=..., z=...) -> None: ...
+def h(x=..., y=..., z=..., w=...) -> None: ...
+def i(x=..., y=..., z=...) -> None: ...
+
+[case testDataclass]
+import dataclasses
+import dataclasses as dcs
+from dataclasses import dataclass, field, Field, InitVar, KW_ONLY
+from dataclasses import dataclass as dc
+from datetime import datetime
+from typing import ClassVar
+
+@dataclasses.dataclass
+class X:
+    a: int
+    b: str = "hello"
+    c: ClassVar
+    d: ClassVar = 200
+    f: list[int] = field(init=False, default_factory=list)
+    g: int = field(default=2, kw_only=True)
+    _: KW_ONLY
+    h: int = 1
+    i: InitVar[str]
+    j: InitVar = 100
+    # Lambda not supported yet -> marked as Incomplete instead
+    k: str = Field(
+        default_factory=lambda: datetime.utcnow().isoformat(" ", timespec="seconds")
+    )
+    non_field = None
+
+@dcs.dataclass
+class Y: ...
+
+@dataclass
+class Z: ...
+
+@dc
+class W: ...
+
+@dataclass(init=False, repr=False)
+class V: ...
+
+[out]
+import dataclasses
+import dataclasses as dcs
+from _typeshed import Incomplete
+from dataclasses import Field, InitVar, KW_ONLY, dataclass, dataclass as dc, field
+from typing import ClassVar
+
+@dataclasses.dataclass
+class X:
+    a: int
+    b: str = ...
+    c: ClassVar
+    d: ClassVar = ...
+    f: list[int] = field(init=False, default_factory=list)
+    g: int = field(default=2, kw_only=True)
+    _: KW_ONLY
+    h: int = ...
+    i: InitVar[str]
+    j: InitVar = ...
+    k: str = Field(default_factory=Incomplete)
+    non_field = ...
+
+@dcs.dataclass
+class Y: ...
+@dataclass
+class Z: ...
+@dc
+class W: ...
+@dataclass(init=False, repr=False)
+class V: ...
+
+[case testDataclass_semanal]
+from dataclasses import Field, InitVar, dataclass, field
+from typing import ClassVar
+from datetime import datetime
+
+@dataclass
+class X:
+    a: int
+    b: InitVar[str]
+    c: str = "hello"
+    d: ClassVar
+    e: ClassVar = 200
+    f: list[int] = field(init=False, default_factory=list)
+    g: int = field(default=2, kw_only=True)
+    h: int = 1
+    i: InitVar = 100
+    j: list[int] = field(default_factory=list)
+    # Lambda not supported yet -> marked as Incomplete instead
+    k: str = Field(
+        default_factory=lambda: datetime.utcnow().isoformat(" ", timespec="seconds")
+    )
+    non_field = None
+
+@dataclass(init=False, repr=False, frozen=True)
+class Y: ...
+
+[out]
+from _typeshed import Incomplete
+from dataclasses import Field, InitVar, dataclass, field
+from typing import ClassVar
+
+@dataclass
+class X:
+    a: int
+    b: InitVar[str]
+    c: str = ...
+    d: ClassVar
+    e: ClassVar = ...
+    f: list[int] = field(init=False, default_factory=list)
+    g: int = field(default=2, kw_only=True)
+    h: int = ...
+    i: InitVar = ...
+    j: list[int] = field(default_factory=list)
+    k: str = Field(default_factory=Incomplete)
+    non_field = ...
+
+@dataclass(init=False, repr=False, frozen=True)
+class Y: ...
+
+[case testDataclassWithKwOnlyField_semanal]
+# flags: --python-version=3.10
+from dataclasses import dataclass, field, InitVar, KW_ONLY
+from typing import ClassVar
+
+@dataclass
+class X:
+    a: int
+    b: str = "hello"
+    c: ClassVar
+    d: ClassVar = 200
+    f: list[int] = field(init=False, default_factory=list)
+    g: int = field(default=2, kw_only=True)
+    _: KW_ONLY
+    h: int = 1
+    i: InitVar[str]
+    j: InitVar = 100
+    non_field = None
+
+@dataclass(init=False, repr=False, frozen=True)
+class Y: ...
+
+[out]
+from dataclasses import InitVar, KW_ONLY, dataclass, field
+from typing import ClassVar
+
+@dataclass
+class X:
+    a: int
+    b: str = ...
+    c: ClassVar
+    d: ClassVar = ...
+    f: list[int] = field(init=False, default_factory=list)
+    g: int = field(default=2, kw_only=True)
+    _: KW_ONLY
+    h: int = ...
+    i: InitVar[str]
+    j: InitVar = ...
+    non_field = ...
+
+@dataclass(init=False, repr=False, frozen=True)
+class Y: ...
+
+[case testDataclassWithExplicitGeneratedMethodsOverrides_semanal]
+from dataclasses import dataclass
+
+@dataclass
+class X:
+    a: int
+    def __init__(self, a: int, b: str = ...) -> None: ...
+    def __post_init__(self) -> None: ...
+
+[out]
+from dataclasses import dataclass
+
+@dataclass
+class X:
+    a: int
+    def __init__(self, a: int, b: str = ...) -> None: ...
+    def __post_init__(self) -> None: ...
+
+[case testDataclassInheritsFromAny_semanal]
+from dataclasses import dataclass
+import missing
+
+@dataclass
+class X(missing.Base):
+    a: int
+
+@dataclass
+class Y(missing.Base):
+    generated_args: str
+    generated_args_: str
+    generated_kwargs: float
+    generated_kwargs_: float
+
+[out]
+import missing
+from dataclasses import dataclass
+
+@dataclass
+class X(missing.Base):
+    a: int
+
+@dataclass
+class Y(missing.Base):
+    generated_args: str
+    generated_args_: str
+    generated_kwargs: float
+    generated_kwargs_: float
+
+[case testDataclassTransform]
+# dataclass_transform detection only works with semantic analysis.
+# Test stubgen doesn't break too badly without it.
+from typing_extensions import dataclass_transform
+
+@typing_extensions.dataclass_transform(kw_only_default=True)
+def create_model(cls):
+    return cls
+
+@create_model
+class X:
+    a: int
+    b: str = "hello"
+
+@typing_extensions.dataclass_transform(kw_only_default=True)
+class ModelBase: ...
+
+class Y(ModelBase):
+    a: int
+    b: str = "hello"
+
+@typing_extensions.dataclass_transform(kw_only_default=True)
+class DCMeta(type): ...
+
+class Z(metaclass=DCMeta):
+    a: int
+    b: str = "hello"
+
+[out]
+@typing_extensions.dataclass_transform(kw_only_default=True)
+def create_model(cls): ...
+
+class X:
+    a: int
+    b: str
+
+@typing_extensions.dataclass_transform(kw_only_default=True)
+class ModelBase: ...
+
+class Y(ModelBase):
+    a: int
+    b: str
+
+@typing_extensions.dataclass_transform(kw_only_default=True)
+class DCMeta(type): ...
+
+class Z(metaclass=DCMeta):
+    a: int
+    b: str
+
+[case testDataclassTransformDecorator_semanal]
+import typing_extensions
+from dataclasses import field
+
+@typing_extensions.dataclass_transform(kw_only_default=True)
+def create_model(cls):
+    return cls
+
+@create_model
+class X:
+    a: int
+    b: str = "hello"
+    c: bool = field(default=True)
+
+[out]
+import typing_extensions
+from dataclasses import field
+
+@typing_extensions.dataclass_transform(kw_only_default=True)
+def create_model(cls): ...
+
+@create_model
+class X:
+    a: int
+    b: str = ...
+    c: bool = field(default=True)
+
+[case testDataclassTransformClass_semanal]
+from dataclasses import field
+from typing_extensions import dataclass_transform
+
+@dataclass_transform(kw_only_default=True)
+class ModelBase: ...
+
+class X(ModelBase):
+    a: int
+    b: str = "hello"
+    c: bool = field(default=True)
+
+[out]
+from dataclasses import field
+from typing_extensions import dataclass_transform
+
+@dataclass_transform(kw_only_default=True)
+class ModelBase: ...
+
+class X(ModelBase):
+    a: int
+    b: str = ...
+    c: bool = field(default=True)
+
+[case testDataclassTransformMetaclass_semanal]
+from dataclasses import field
+from typing import Any
+from typing_extensions import dataclass_transform
+
+def custom_field(*, default: bool, kw_only: bool) -> Any: ...
+
+@dataclass_transform(kw_only_default=True, field_specifiers=(custom_field,))
+class DCMeta(type): ...
+
+class X(metaclass=DCMeta):
+    a: int
+    b: str = "hello"
+    c: bool = field(default=True)  # should be ignored, not field_specifier here
+
+class Y(X):
+    d: str = custom_field(default="Hello")
+
+[out]
+from typing import Any
+from typing_extensions import dataclass_transform
+
+def custom_field(*, default: bool, kw_only: bool) -> Any: ...
+
+@dataclass_transform(kw_only_default=True, field_specifiers=(custom_field,))
+class DCMeta(type): ...
+
+class X(metaclass=DCMeta):
+    a: int
+    b: str = ...
+    c: bool = ...
+
+class Y(X):
+    d: str = custom_field(default='Hello')
+
+[case testAlwaysUsePEP604Union]
+import typing
+import typing as t
+from typing import Optional, Union, Optional as O, Union as U
+import x
+
+union = Union[int, str]
+bad_union = Union[int]
+nested_union = Optional[Union[int, str]]
+not_union = x.Union[int, str]
+u = U[int, str]
+o = O[int]
+
+def f1(a: Union["int", Optional[tuple[int, t.Optional[int]]]]) -> int: ...
+def f2(a: typing.Union[int | x.Union[int, int], O[float]]) -> int: ...
+
+[out]
+import x
+from _typeshed import Incomplete
+
+union = int | str
+bad_union = int
+nested_union = int | str | None
+not_union: Incomplete
+u = int | str
+o = int | None
+
+def f1(a: int | tuple[int, int | None] | None) -> int: ...
+def f2(a: int | x.Union[int, int] | float | None) -> int: ...
+
+[case testTypingBuiltinReplacements]
+import typing
+import typing as t
+from typing import Tuple
+import typing_extensions
+import typing_extensions as te
+from typing_extensions import List, Type
+
+# builtins are not builtins
+tuple = int
+[list,] = float
+dict, set, frozenset = str, float, int
+
+x: Tuple[t.Text, t.FrozenSet[typing.Type[float]]]
+y: typing.List[int]
+z: t.Dict[str, float]
+v: typing.Set[int]
+w: List[typing_extensions.Dict[te.FrozenSet[Type[int]], te.Tuple[te.Set[te.Text], ...]]]
+
+x_alias = Tuple[str, ...]
+y_alias = typing.List[int]
+z_alias = t.Dict[str, float]
+v_alias = typing.Set[int]
+w_alias = List[typing_extensions.Dict[str, te.Tuple[int, ...]]]
+
+[out]
+from _typeshed import Incomplete
+from builtins import dict as _dict, frozenset as _frozenset, list as _list, set as _set, tuple as _tuple
+
+tuple = int
+list: Incomplete
+dict: Incomplete
+set: Incomplete
+frozenset: Incomplete
+x: _tuple[str, _frozenset[type[float]]]
+y: _list[int]
+z: _dict[str, float]
+v: _set[int]
+w: _list[_dict[_frozenset[type[int]], _tuple[_set[str], ...]]]
+x_alias = _tuple[str, ...]
+y_alias = _list[int]
+z_alias = _dict[str, float]
+v_alias = _set[int]
+w_alias = _list[_dict[str, _tuple[int, ...]]]
+
+[case testHandlingNameCollisions]
+# flags: --include-private
+from typing import Tuple
+tuple = int
+_tuple = range
+__tuple = map
+x: Tuple[int, str]
+[out]
+from builtins import tuple as ___tuple
+
+tuple = int
+_tuple = range
+__tuple = map
+x: ___tuple[int, str]
+
+[case testPEP570PosOnlyParams]
+def f(x=0, /): ...
+def f1(x: int, /): ...
+def f2(x: int, y: float = 1, /): ...
+def f3(x: int, /, y: float): ...
+def f4(x: int, /, y: float = 1): ...
+def f5(x: int, /, *, y: float): ...
+def f6(x: int = 0, /, *, y: float): ...
+def f7(x: int, /, *, y: float = 1): ...
+def f8(x: int = 0, /, *, y: float = 1): ...
+
+[out]
+def f(x: int = 0, /) -> None: ...
+def f1(x: int, /): ...
+def f2(x: int, y: float = 1, /): ...
+def f3(x: int, /, y: float): ...
+def f4(x: int, /, y: float = 1): ...
+def f5(x: int, /, *, y: float): ...
+def f6(x: int = 0, /, *, y: float): ...
+def f7(x: int, /, *, y: float = 1): ...
+def f8(x: int = 0, /, *, y: float = 1): ...
+
+[case testPreserveEmptyTuple]
+ann: tuple[()]
+alias = tuple[()]
+def f(x: tuple[()]): ...
+class C(tuple[()]): ...
+
+[out]
+ann: tuple[()]
+alias = tuple[()]
+
+def f(x: tuple[()]): ...
+
+class C(tuple[()]): ...
+
+[case testPreserveEnumValue_semanal]
+from enum import Enum
+
+class Foo(Enum):
+    A = 1
+    B = 2
+    C = 3
+
+class Bar(Enum):
+    A = object()
+    B = "a" + "b"
+
+[out]
+from enum import Enum
+
+class Foo(Enum):
+    A = 1
+    B = 2
+    C = 3
+
+class Bar(Enum):
+    A = ...
+    B = ...
+
+[case testGracefullyHandleInvalidOptionalUsage]
+from typing import Optional
+
+x: Optional  # invalid
+y: Optional[int]  # valid
+z: Optional[int, str]  # invalid
+w: Optional[int | str]  # valid
+r: Optional[type[int | str]]
+
+X = Optional
+Y = Optional[int]
+Z = Optional[int, str]
+W = Optional[int | str]
+R = Optional[type[int | str]]
+
+[out]
+from _typeshed import Incomplete
+from typing import Optional
+
+x: Incomplete
+y: int | None
+z: Incomplete
+w: int | str | None
+r: type[int | str] | None
+X = Optional
+Y = int | None
+Z = Incomplete
+W = int | str | None
+R = type[int | str] | None
+
+[case testClassInheritanceWithKeywordsConstants]
+class Test(Whatever, a=1, b='b', c=True, d=1.5, e=None, f=1j, g=b'123'): ...
+[out]
+class Test(Whatever, a=1, b='b', c=True, d=1.5, e=None, f=1j, g=b'123'): ...
+
+[case testClassInheritanceWithKeywordsDynamic]
+class Test(Whatever, keyword=SomeName * 2, attr=SomeName.attr): ...
+[out]
+class Test(Whatever, keyword=SomeName * 2, attr=SomeName.attr): ...
+
+[case testPEP695GenericClass]
+# flags: --python-version=3.12
+
+class C[T]: ...
+class C1[T1](int): ...
+class C2[T2: int]: ...
+class C3[T3: str | bytes]: ...
+class C4[T4: (str, bytes)]: ...
+
+class Outer:
+    class Inner[T]: ...
+
+[out]
+class C[T]: ...
+class C1[T1](int): ...
+class C2[T2: int]: ...
+class C3[T3: str | bytes]: ...
+class C4[T4: (str, bytes)]: ...
+
+class Outer:
+    class Inner[T]: ...
+
+[case testPEP695GenericFunction]
+# flags: --python-version=3.12
+
+def f1[T1](): ...
+def f2[T2: int](): ...
+def f3[T3: str | bytes](): ...
+def f4[T4: (str, bytes)](): ...
+
+class C:
+    def m[T](self, x: T) -> T: ...
+
+[out]
+def f1[T1]() -> None: ...
+def f2[T2: int]() -> None: ...
+def f3[T3: str | bytes]() -> None: ...
+def f4[T4: (str, bytes)]() -> None: ...
+
+class C:
+    def m[T](self, x: T) -> T: ...
+
+[case testPEP695TypeAlias]
+# flags: --python-version=3.12
+
+type Alias = int | str
+type Alias1[T1] = list[T1] | set[T1]
+type Alias2[T2: int] = list[T2] | set[T2]
+type Alias3[T3: str | bytes] = list[T3] | set[T3]
+type Alias4[T4: (str, bytes)] = list[T4] | set[T4]
+
+class C:
+    type IndentedAlias[T] = list[T]
+
+[out]
+type Alias = int | str
+type Alias1[T1] = list[T1] | set[T1]
+type Alias2[T2: int] = list[T2] | set[T2]
+type Alias3[T3: str | bytes] = list[T3] | set[T3]
+type Alias4[T4: (str, bytes)] = list[T4] | set[T4]
+class C:
+    type IndentedAlias[T] = list[T]
+
+[case testPEP695Syntax_semanal]
+# flags: --python-version=3.12
+
+class C[T]: ...
+def f[S](): ...
+type A[R] = list[R]
+
+[out]
+class C[T]: ...
+
+def f[S]() -> None: ...
+type A[R] = list[R]
+
+[case testPEP696Syntax]
+# flags: --python-version=3.13
+
+type Alias1[T1 = int] = list[T1] | set[T1]
+type Alias2[T2: int | float = int] = list[T2] | set[T2]
+class C3[T3 = int]: ...
+class C4[T4: int | float = int](list[T4]): ...
+def f5[T5 = int](): ...
+
+[out]
+type Alias1[T1 = int] = list[T1] | set[T1]
+type Alias2[T2: int | float = int] = list[T2] | set[T2]
+class C3[T3 = int]: ...
+class C4[T4: int | float = int](list[T4]): ...
+
+def f5[T5 = int]() -> None: ...
+
+[case testIgnoreMypyGeneratedMethods_semanal]
+# flags: --include-private --python-version=3.13
+from typing_extensions import dataclass_transform
+
+@dataclass_transform()
+class DCMeta(type): ...
+class DC(metaclass=DCMeta):
+    x: str
+
+[out]
+from typing_extensions import dataclass_transform
+
+@dataclass_transform()
+class DCMeta(type): ...
+
+class DC(metaclass=DCMeta):
+    x: str
diff --git a/test-data/unit/typexport-basic.test b/test-data/unit/typexport-basic.test
index 0dcd0098f177..512b572801d2 100644
--- a/test-data/unit/typexport-basic.test
+++ b/test-data/unit/typexport-basic.test
@@ -255,7 +255,7 @@ NameExpr(6) : A
 NameExpr(6) : A
 MemberExpr(7) : A
 MemberExpr(7) : A
-MemberExpr(7) : A
+MemberExpr(7) : Any
 NameExpr(7) : A
 NameExpr(7) : A
 
@@ -294,8 +294,8 @@ import typing
 x = ()
 [builtins fixtures/primitives.pyi]
 [out]
-NameExpr(2) : Tuple[]
-TupleExpr(2) : Tuple[]
+NameExpr(2) : Tuple[()]
+TupleExpr(2) : Tuple[()]
 
 [case testInferTwoTypes]
 ## NameExpr
@@ -313,8 +313,8 @@ def f() -> None:
     x = ()
 [builtins fixtures/primitives.pyi]
 [out]
-NameExpr(3) : Tuple[]
-TupleExpr(3) : Tuple[]
+NameExpr(3) : Tuple[()]
+TupleExpr(3) : Tuple[()]
 
 
 -- Basic generics
@@ -727,7 +727,7 @@ class A: pass
 class B:
   a = None # type: A
 [out]
-LambdaExpr(2) : def (B) -> A
+LambdaExpr(2) : def (x: B) -> A
 MemberExpr(2) : A
 NameExpr(2) : B
 
@@ -756,7 +756,7 @@ class B:
   a = None # type: A
 [builtins fixtures/list.pyi]
 [out]
-LambdaExpr(2) : def (B) -> builtins.list[A]
+LambdaExpr(2) : def (x: B) -> builtins.list[A]
 ListExpr(2) : builtins.list[A]
 
 [case testLambdaAndHigherOrderFunction]
@@ -775,7 +775,7 @@ map(
 CallExpr(9) : builtins.list[B]
 NameExpr(9) : def (f: def (A) -> B, a: builtins.list[A]) -> builtins.list[B]
 CallExpr(10) : B
-LambdaExpr(10) : def (A) -> B
+LambdaExpr(10) : def (x: A) -> B
 NameExpr(10) : def (a: A) -> B
 NameExpr(10) : builtins.list[A]
 NameExpr(10) : A
@@ -795,7 +795,7 @@ map(
 [builtins fixtures/list.pyi]
 [out]
 NameExpr(10) : def (f: def (A) -> builtins.list[B], a: builtins.list[A]) -> builtins.list[B]
-LambdaExpr(11) : def (A) -> builtins.list[B]
+LambdaExpr(11) : def (x: A) -> builtins.list[B]
 ListExpr(11) : builtins.list[B]
 NameExpr(11) : def (a: A) -> B
 NameExpr(11) : builtins.list[A]
@@ -817,7 +817,7 @@ map(
 --      context. Perhaps just fail instead?
 CallExpr(7) : builtins.list[Any]
 NameExpr(7) : def (f: builtins.list[def (A) -> Any], a: builtins.list[A]) -> builtins.list[Any]
-LambdaExpr(8) : def (A) -> A
+LambdaExpr(8) : def (x: A) -> A
 ListExpr(8) : builtins.list[def (A) -> Any]
 NameExpr(8) : A
 NameExpr(9) : builtins.list[A]
@@ -838,7 +838,7 @@ map(
 [out]
 CallExpr(9) : builtins.list[B]
 NameExpr(9) : def (f: def (A) -> B, a: builtins.list[A]) -> builtins.list[B]
-LambdaExpr(10) : def (A) -> B
+LambdaExpr(10) : def (x: A) -> B
 MemberExpr(10) : B
 NameExpr(10) : A
 NameExpr(11) : builtins.list[A]
@@ -860,7 +860,7 @@ map(
 CallExpr(9) : builtins.list[B]
 NameExpr(9) : def (f: def (A) -> B, a: builtins.list[A]) -> builtins.list[B]
 NameExpr(10) : builtins.list[A]
-LambdaExpr(11) : def (A) -> B
+LambdaExpr(11) : def (x: A) -> B
 MemberExpr(11) : B
 NameExpr(11) : A
 
@@ -1212,7 +1212,7 @@ f(
 [builtins fixtures/list.pyi]
 [out]
 NameExpr(8) : Overload(def (x: builtins.int, f: def (builtins.int) -> builtins.int), def (x: builtins.str, f: def (builtins.str) -> builtins.str))
-LambdaExpr(9) : def (builtins.int) -> builtins.int
+LambdaExpr(9) : def (x: builtins.int) -> builtins.int
 NameExpr(9) : builtins.int
 
 [case testExportOverloadArgTypeNested]
@@ -1231,10 +1231,31 @@ f(
     lambda x: x)
 [builtins fixtures/list.pyi]
 [out]
-LambdaExpr(9) : def (builtins.int) -> builtins.int
-LambdaExpr(10) : def (builtins.int) -> builtins.int
-LambdaExpr(12) : def (builtins.str) -> builtins.str
-LambdaExpr(13) : def (builtins.str) -> builtins.str
+LambdaExpr(9) : def (y: builtins.int) -> builtins.int
+LambdaExpr(10) : def (x: builtins.int) -> builtins.int
+LambdaExpr(12) : def (y: builtins.str) -> builtins.str
+LambdaExpr(13) : def (x: builtins.str) -> builtins.str
+
+[case testExportOverloadArgTypeDict]
+## DictExpr
+from typing import TypeVar, Generic, Any, overload, Dict
+T = TypeVar("T")
+class Key(Generic[T]): ...
+@overload
+def f(x: Key[T], y: T) -> T: ...
+@overload
+def f(x: int, y: Any) -> Any: ...
+def f(x, y): ...
+d: Dict = {}
+d.get(
+  "", {})
+f(
+  2, {})
+[builtins fixtures/dict.pyi]
+[out]
+DictExpr(10) : builtins.dict[Any, Any]
+DictExpr(12) : builtins.dict[Any, Any]
+DictExpr(14) : builtins.dict[Any, Any]
 
 -- TODO
 --
diff --git a/test-requirements.in b/test-requirements.in
new file mode 100644
index 000000000000..666dd9fc082c
--- /dev/null
+++ b/test-requirements.in
@@ -0,0 +1,15 @@
+# If you change this file (or mypy-requirements.txt or build-requirements.txt), please run:
+# pip-compile --output-file=test-requirements.txt --strip-extras --allow-unsafe test-requirements.in
+
+-r mypy-requirements.txt
+-r build-requirements.txt
+attrs>=18.0
+filelock>=3.3.0
+lxml>=5.3.0; python_version<'3.14'
+psutil>=4.0
+pytest>=8.1.0
+pytest-xdist>=1.34.0
+pytest-cov>=2.10.0
+setuptools>=75.1.0
+tomli>=1.1.0  # needed even on py311+ so the self check passes with --python-version 3.9
+pre_commit>=3.5.0
diff --git a/test-requirements.txt b/test-requirements.txt
index 42c8a08a2b5d..51281f0e4c11 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -1,22 +1,67 @@
--r mypy-requirements.txt
--r build-requirements.txt
-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
-pre-commit-hooks==4.4.0
-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
-setuptools>=65.5.1
-six
-tomli>=1.1.0
+#
+# This file is autogenerated by pip-compile with Python 3.12
+# by the following command:
+#
+#    pip-compile --allow-unsafe --output-file=test-requirements.txt --strip-extras test-requirements.in
+#
+attrs==25.1.0
+    # via -r test-requirements.in
+cfgv==3.4.0
+    # via pre-commit
+coverage==7.6.10
+    # via pytest-cov
+distlib==0.3.9
+    # via virtualenv
+execnet==2.1.1
+    # via pytest-xdist
+filelock==3.17.0
+    # via
+    #   -r test-requirements.in
+    #   virtualenv
+identify==2.6.6
+    # via pre-commit
+iniconfig==2.0.0
+    # via pytest
+lxml==5.3.0 ; python_version < "3.14"
+    # via -r test-requirements.in
+mypy-extensions==1.0.0
+    # via -r mypy-requirements.txt
+nodeenv==1.9.1
+    # via pre-commit
+packaging==24.2
+    # via pytest
+pathspec==0.12.1
+    # via -r mypy-requirements.txt
+platformdirs==4.3.6
+    # via virtualenv
+pluggy==1.5.0
+    # via pytest
+pre-commit==4.1.0
+    # via -r test-requirements.in
+psutil==6.1.1
+    # via -r test-requirements.in
+pytest==8.3.4
+    # via
+    #   -r test-requirements.in
+    #   pytest-cov
+    #   pytest-xdist
+pytest-cov==6.0.0
+    # via -r test-requirements.in
+pytest-xdist==3.6.1
+    # via -r test-requirements.in
+pyyaml==6.0.2
+    # via pre-commit
+tomli==2.2.1
+    # via -r test-requirements.in
+types-psutil==6.1.0.20241221
+    # via -r build-requirements.txt
+types-setuptools==75.8.0.20250110
+    # via -r build-requirements.txt
+typing-extensions==4.12.2
+    # via -r mypy-requirements.txt
+virtualenv==20.29.1
+    # via pre-commit
+
+# The following packages are considered to be unsafe in a requirements file:
+setuptools==75.8.0
+    # via -r test-requirements.in
diff --git a/tox.ini b/tox.ini
index 6d64cebaec6d..a505950521fa 100644
--- a/tox.ini
+++ b/tox.ini
@@ -2,10 +2,12 @@
 minversion = 4.4.4
 skip_missing_interpreters = {env:TOX_SKIP_MISSING_INTERPRETERS:True}
 envlist =
-    py37,
     py38,
     py39,
     py310,
+    py311,
+    py312,
+    py313,
     docs,
     lint,
     type,
@@ -18,29 +20,36 @@ passenv =
     PROGRAMDATA
     PROGRAMFILES(X86)
     PYTEST_ADDOPTS
-deps = -rtest-requirements.txt
+deps =
+    -r test-requirements.txt
+    # This is a bit of a hack, but ensures the faster-cache path is tested in CI
+    orjson;python_version=='3.12'
 commands = python -m pytest {posargs}
 
 [testenv:dev]
 description = generate a DEV environment, that has all project libraries
 usedevelop = True
 deps =
-    -rtest-requirements.txt
-    -rdocs/requirements-docs.txt
+    -r test-requirements.txt
+    -r docs/requirements-docs.txt
 commands =
     python -m pip list --format=columns
     python -c 'import sys; print(sys.executable)'
+    {posargs}
 
 [testenv:docs]
 description = invoke sphinx-build to build the HTML docs
-deps = -rdocs/requirements-docs.txt
+passenv =
+    VERIFY_MYPY_ERROR_CODES
+deps = -r docs/requirements-docs.txt
 commands =
-    sphinx-build -d "{toxworkdir}/docs_doctree" docs/source "{toxworkdir}/docs_out" --color -W -bhtml {posargs}
+    sphinx-build -n -d "{toxworkdir}/docs_doctree" docs/source "{toxworkdir}/docs_out" --color -W -bhtml {posargs}
     python -c 'import pathlib; print("documentation available under file://\{0\}".format(pathlib.Path(r"{toxworkdir}") / "docs_out" / "index.html"))'
 
 [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]
@@ -50,5 +59,6 @@ passenv =
     MYPY_FORCE_COLOR
     MYPY_FORCE_TERMINAL_WIDTH
 commands =
-    python -m mypy --config-file mypy_self_check.ini -p mypy -p mypyc
-    python -m mypy --config-file mypy_self_check.ini misc --exclude misc/fix_annotate.py --exclude misc/async_matrix.py --exclude misc/sync-typeshed.py
+    python runtests.py self
+    python -m mypy --config-file mypy_self_check.ini misc --exclude misc/sync-typeshed.py
+    python -m mypy --config-file mypy_self_check.ini test-data/unit/plugins